- Turned off parallel compilation, until a bug is fixed.

3 files changed, 68 insertions, 42 deletions

diff --git a/src/lux/analyser/lux.clj b/src/lux/analyser/lux.clj
index 9da884025..e907f8aa3 100644
--- a/src/lux/analyser/lux.clj
+++ b/src/lux/analyser/lux.clj
@@ -640,44 +640,65 @@
         _ (&&module/set-anns ==anns module-name)
         _imports (&&module/fetch-imports ==anns)
         current-module &/get-module-name
-        =asyncs (&/map% (fn [_import]
-                          (|let [[path alias] _import]
-                            (&/without-repl
-                             (&/save-module
-                              (|do [_ (if (= current-module path)
-                                        (&/fail-with-loc (str "[Analyser Error] Module can't import itself: " path))
-                                        (return nil))
-                                    already-compiled? (&&module/exists? path)
-                                    active? (&/active-module? path)
-                                    _ (&/assert! (not active?)
-                                                 (str "[Analyser Error] Can't import a module that is mid-compilation: " path " @ " current-module))
-                                    _ (&&module/add-import path)
-                                    ?async (if (not already-compiled?)
-                                             (compile-module path)
-                                             (|do [_compiler get-compiler]
-                                               (return (doto (promise)
-                                                         (deliver (&/$Right _compiler))))))
-                                    _ (if (= "" alias)
-                                        (return nil)
-                                        (&&module/alias current-module alias path))]
-                                (return ?async))))))
-                        _imports)
-        _compiler get-compiler
-        ;; Some type-vars in the typing environment stay in
-        ;; the environment forever, making type-checking slower.
-        ;; The merging process for compilers more-or-less "fixes" the
-        ;; problem by resetting the typing enviroment, but ideally
-        ;; those type-vars shouldn't survive in the first place.
-        ;; TODO: MUST FIX
-        _ (&/fold% (fn [compiler _async]
-                     (|case @_async
-                       (&/$Right _new-compiler)
-                       (set-compiler (merge-compilers current-module _new-compiler compiler))
-
-                       (&/$Left ?error)
-                       (fail ?error)))
-                   _compiler
-                   =asyncs)]
+        ;; =asyncs (&/map% (fn [_import]
+        ;;                   (|let [[path alias] _import]
+        ;;                     (&/without-repl
+        ;;                      (&/save-module
+        ;;                       (|do [_ (if (= current-module path)
+        ;;                                 (&/fail-with-loc (str "[Analyser Error] Module can't import itself: " path))
+        ;;                                 (return nil))
+        ;;                             already-compiled? (&&module/exists? path)
+        ;;                             active? (&/active-module? path)
+        ;;                             _ (&/assert! (not active?)
+        ;;                                          (str "[Analyser Error] Can't import a module that is mid-compilation: " path " @ " current-module))
+        ;;                             _ (&&module/add-import path)
+        ;;                             ?async (if (not already-compiled?)
+        ;;                                      (compile-module path)
+        ;;                                      (|do [_compiler get-compiler]
+        ;;                                        (return (doto (promise)
+        ;;                                                  (deliver (&/$Right _compiler))))))
+        ;;                             _ (if (= "" alias)
+        ;;                                 (return nil)
+        ;;                                 (&&module/alias current-module alias path))]
+        ;;                         (return ?async))))))
+        ;;                 _imports)
+        ;; _compiler get-compiler
+        ;; ;; Some type-vars in the typing environment stay in
+        ;; ;; the environment forever, making type-checking slower.
+        ;; ;; The merging process for compilers more-or-less "fixes" the
+        ;; ;; problem by resetting the typing enviroment, but ideally
+        ;; ;; those type-vars shouldn't survive in the first place.
+        ;; ;; TODO: MUST FIX
+        ;; _ (&/fold% (fn [compiler _async]
+        ;;              (|case @_async
+        ;;                (&/$Right _new-compiler)
+        ;;                (set-compiler (merge-compilers current-module _new-compiler compiler))
+
+        ;;                (&/$Left ?error)
+        ;;                (fail ?error)))
+        ;;            _compiler
+        ;;            =asyncs)
+        ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+        _ (&/map% (fn [_import]
+                    (|let [[path alias] _import]
+                      (&/without-repl
+                       (&/save-module
+                        (|do [_ (if (= current-module path)
+                                  (&/fail-with-loc (str "[Analyser Error] Module can't import itself: " path))
+                                  (return nil))
+                              already-compiled? (&&module/exists? path)
+                              active? (&/active-module? path)
+                              _ (&/assert! (not active?)
+                                           (str "[Analyser Error] Can't import a module that is mid-compilation: " path " @ " current-module))
+                              _ (&&module/add-import path)
+                              _ (if (not already-compiled?)
+                                  (compile-module path)
+                                  (return nil))
+                              _ (if (= "" alias)
+                                  (return nil)
+                                  (&&module/alias current-module alias path))]
+                          (return nil))))))
+                  _imports)]
     (return &/$Nil)))
 
 (defn ^:private coerce [new-type analysis]
diff --git a/src/lux/compiler.clj b/src/lux/compiler.clj
index 298445905..d8c5e4571 100644
--- a/src/lux/compiler.clj
+++ b/src/lux/compiler.clj
@@ -180,7 +180,8 @@
     (let [file-name (str name ".lux")]
       (|do [file-content (&&io/read-file source-dirs file-name)
             :let [file-hash (hash file-content)
-                  compile-module!! (&&parallel/parallel-compilation (partial compile-module source-dirs))]]
+                  ;; compile-module!! (&&parallel/parallel-compilation (partial compile-module source-dirs))
+                  compile-module!! (partial compile-module source-dirs)]]
         (if (&&cache/cached? name)
           (&&cache/load source-dirs name file-hash compile-module!!)
           (let [compiler-step (&analyser/analyse &optimizer/optimize eval! compile-module!! all-compilers)]
diff --git a/src/lux/compiler/cache.clj b/src/lux/compiler/cache.clj
index 788080b04..6c44e2a45 100644
--- a/src/lux/compiler/cache.clj
+++ b/src/lux/compiler/cache.clj
@@ -49,7 +49,9 @@
 
 (defn cached? [module]
   "(-> Text Bool)"
-  (.exists (new File (str @&&/!output-dir "/" (&host/->module-class module) "/" module-class))))
+  (.exists (new File (str @&&/!output-dir "/" (&host/->module-class module) "/" module-class)))
+  ;; false
+  )
 
 (defn delete [module]
   "(-> Text (Lux Null))"
@@ -107,8 +109,10 @@
     (if already-loaded?
       (return module-hash)
       (|let [redo-cache (|do [_ (delete module)
-                              async (compile-module module)]
-                          (assume-async-result @async))]
+                              ;; async (compile-module module)
+                              ]
+                          ;; (assume-async-result @async)
+                          (compile-module module))]
         (if (cached? module)
           (|do [loader &/loader
                 !classes &/classes