aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorEduardo Julian2016-11-27 12:18:10 -0400
committerEduardo Julian2016-11-27 12:18:10 -0400
commit75235b66b2567d343ee7a677cc0d5ba5893ffc8d (patch)
tree11f5f3b81ebdfc21f40c857e39faa377b80db447
parenta6afe8aaa95fb8685a402709c1ddcd5bee7219d6 (diff)
- Turned off parallel compilation, until a bug is fixed.
Diffstat (limited to '')
-rw-r--r--src/lux/analyser/lux.clj97
-rw-r--r--src/lux/compiler.clj3
-rw-r--r--src/lux/compiler/cache.clj10
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