firefly-compiler 0.4.30 → 0.4.31

package/compiler/Builder.ff

@@ -139,7 +139,6 @@ check(
                 } else {
                     compiler.resolve(resolvedDependencies.mainPackagePair, localFile.dropLast(".ff".size()))
                 }
-                Unit
             } catch {| CompileError(_, _) @ c, error =>
                 errors.push(c)
             } grab()

package/compiler/Inference.ff

@@ -462,9 +462,39 @@ extend self: Inference {
                                 )
                         }
                     | _ =>
+                        let unitName = core("Unit")
+                        function semicolonUnit(body: Term): Term {
+                            | ECall e {e.target | DynamicCall c} {c.function | EVariable x} {
+                                x.name == "ff:core/Core.if" || x.name == "ff:core/Core.try"
+                            } =>
+                                e.ECall(arguments = e.arguments.map {
+                                    | Argument a {a.value | ELambda l} =>
+                                        a.Argument(value = l.ELambda(lambda = 
+                                            l.lambda.Lambda(cases = l.lambda.cases.map {c =>
+                                                c.MatchCase(body = 
+                                                    ESequential(c.at, c.body, EVariant(c.at, unitName, [], None))
+                                                )
+                                            })
+                                        ))
+                                    | a => a
+                                })
+                            | ECall e {e.target | DynamicCall c} {c.function | EField f} {
+                                f.field == "else" || f.field == "elseIf" || f.field == "grab" ||
+                                f.field == "catch" || f.field == "catchAny" || f.field == "finally"
+                            } =>
+                                e.ECall(target = c.DynamicCall(function = f.EField(record = semicolonUnit(f.record))))
+                            | ESequential e =>
+                                e.ESequential(after = semicolonUnit(e.after))
+                            | ELet e =>
+                                e.ELet(body = semicolonUnit(e.body))
+                            | EFunctions e =>
+                                e.EFunctions(body = semicolonUnit(e.body))
+                            | _ => 
+                                body
+                        }
                         ESequential(
                             at = at
-                            before = self.inferTerm(environment, newExpected, before)
+                            before = self.inferTerm(environment, newExpected, semicolonUnit(before))
                             after = self.inferTerm(environment, expected, after)
                         )
                 }

package/compiler/Tokenizer.ff

@@ -83,7 +83,6 @@ tokenize(file: String, code: String, completionAt: Option[Location], attemptFixe
                         if(i + 1 < code.size() && code.grab(i) == '_') {i += 1}
                     }
                 }
-                Unit // Think about how to avoid requiring this
             } else {
                 while {i < code.size() && (code.grab(i) == ' ' || code.grab(i) == '\t' || code.grab(i) == '\r')} {i += 1}
             }

package/compiler/Unification.ff

@@ -173,7 +173,6 @@ extend self: Unification {
                     generics1.dropLast().zip(generics2.dropLast()).each {| Pair(t3, t4) => self.unify(at, t3, t4)}
                     generics1.takeLast().zip(generics2.takeLast()).each {| Pair(t3, t4) => self.unify(at, t3, t4)}
                 }
-                Unit // TODO: Think about how to avoid writing this
             } else {
                 generics1.zip(generics2).each {| Pair(t1, t2) => self.unify(at, t1, t2) }
             }

package/experimental/random/Units.ff

@@ -0,0 +1,36 @@
+
+nodeMain(system: NodeSystem) {
+    if(True) {
+        1 + 1
+    } else {
+        "foo"
+    }
+    if(True) {
+        1
+    } elseIf {False} {
+        'x'
+    } else {
+        "foo"
+    }
+    if(True) {
+        if(True) {
+            1
+        } else {
+            "foo"
+        }
+    } else {
+        "foo"
+    }
+    try {
+        1
+    } catchAny {_ =>
+        "foo"
+    } grab()
+    [1, 2, 3].each {_ =>
+        try {
+            if(False) {1} else {2}
+        } catchAny {_ =>
+            "foo"
+        } grab()
+    }
+}

package/lsp/Handler.ff

@@ -382,7 +382,6 @@ extend self: Handler {
             let tokens = Tokenizer.tokenize(cursorAt.file, code, None, True)
             let parser = Parser.make(PackagePair("script", "script"), cursorAt.file, tokens, False, lspHook)
             parser.parseModuleWithPackageInfo()
-            Unit // Think of a way to avoid writing this
         } catch {| CompileError(at, message), error =>
             Log.trace("handleSignatureHelp check error: " + message)
         } grab()

package/lsp/TestReferences.ff

@@ -9,7 +9,7 @@ nodeMain(system: NodeSystem) {
     let cache = ModuleCache.empty(0)
     let handler = Handler(fireflyPath, None, Map.empty(), [].toSet(), Map.empty(), Map.empty(), cache)
     let targetAt = Location("/home/werk/projects/firefly-boot/lsp/TestReferencesCase.ff", 7, 5)
-    let references = handler.findReferences(system, targetAt, local = False, includeDeclaration = True)
+    let references = handler.findReferences(system, targetAt, local = False, includeDeclaration = True, version = 0)
     Log.show(references)
     references.each {_.each {r => 
         Log.show(r)

package/lux/Lux.ff

@@ -306,7 +306,6 @@ extend self: Lux {
                     lux.element.removeAt(lux.element.child)
                     lux.element.insertBefore(fragment, lux.jsSystem.null())
                 }
-                Unit
             } catchAny {error =>
                 if(error.name() != "AbortError") {
                     error.rethrow()

package/output/js/ff/compiler/Inference.mjs

@@ -831,7 +831,128 @@ return ff_compiler_Syntax.ESequential(at_, ff_compiler_Inference.Inference_infer
 return
 }
 {
-return ff_compiler_Syntax.ESequential(at_, ff_compiler_Inference.Inference_inferTerm(self_, environment_, newExpected_, before_), ff_compiler_Inference.Inference_inferTerm(self_, environment_, expected_, after_))
+const unitName_ = ff_compiler_Inference.core_("Unit");
+function semicolonUnit_(body_) {
+const body_a = body_;
+if(body_a.ECall) {
+const e_ = body_a;
+const _guard3 = e_.target_;
+if(_guard3.DynamicCall) {
+const c_ = _guard3;
+const _guard2 = c_.function_;
+if(_guard2.EVariable) {
+const x_ = _guard2;
+if(((x_.name_ === "ff:core/Core.if") || (x_.name_ === "ff:core/Core.try"))) {
+{
+const _1 = e_;
+{
+const _c = _1;
+return ff_compiler_Syntax.ECall(_c.at_, _c.target_, _c.effect_, _c.typeArguments_, ff_core_List.List_map(e_.arguments_, ((_1) => {
+{
+const a_ = _1;
+const _guard1 = a_.value_;
+if(_guard1.ELambda) {
+const l_ = _guard1;
+{
+const _1 = a_;
+{
+const _c = _1;
+return ff_compiler_Syntax.Argument(_c.at_, _c.name_, (((_c) => {
+return ff_compiler_Syntax.ELambda(_c.at_, (((_c) => {
+return ff_compiler_Syntax.Lambda(_c.at_, _c.effect_, ff_core_List.List_map(l_.lambda_.cases_, ((c_) => {
+{
+const _1 = c_;
+{
+const _c = _1;
+return ff_compiler_Syntax.MatchCase(_c.at_, _c.patterns_, _c.guards_, ff_compiler_Syntax.ESequential(c_.at_, c_.body_, ff_compiler_Syntax.EVariant(c_.at_, unitName_, [], ff_core_Option.None())))
+}
+}
+})))
+}))(l_.lambda_))
+}))(l_))
+return
+}
+}
+return
+}
+}
+{
+const a_ = _1;
+return a_
+}
+})), _c.dictionaries_)
+return
+}
+}
+return
+}
+}
+}
+}
+if(body_a.ECall) {
+const e_ = body_a;
+const _guard3 = e_.target_;
+if(_guard3.DynamicCall) {
+const c_ = _guard3;
+const _guard2 = c_.function_;
+if(_guard2.EField) {
+const f_ = _guard2;
+if(((((((f_.field_ === "else") || (f_.field_ === "elseIf")) || (f_.field_ === "grab")) || (f_.field_ === "catch")) || (f_.field_ === "catchAny")) || (f_.field_ === "finally"))) {
+{
+const _1 = e_;
+{
+const _c = _1;
+return ff_compiler_Syntax.ECall(_c.at_, (((_c) => {
+return ff_compiler_Syntax.DynamicCall((((_c) => {
+return ff_compiler_Syntax.EField(_c.at_, _c.newtype_, semicolonUnit_(f_.record_), _c.field_)
+}))(f_), _c.tailCall_)
+}))(c_), _c.effect_, _c.typeArguments_, _c.arguments_, _c.dictionaries_)
+return
+}
+}
+return
+}
+}
+}
+}
+if(body_a.ESequential) {
+const e_ = body_a;
+{
+const _1 = e_;
+{
+const _c = _1;
+return ff_compiler_Syntax.ESequential(_c.at_, _c.before_, semicolonUnit_(e_.after_))
+}
+}
+return
+}
+if(body_a.ELet) {
+const e_ = body_a;
+{
+const _1 = e_;
+{
+const _c = _1;
+return ff_compiler_Syntax.ELet(_c.at_, _c.mutable_, _c.name_, _c.valueType_, _c.value_, semicolonUnit_(e_.body_))
+}
+}
+return
+}
+if(body_a.EFunctions) {
+const e_ = body_a;
+{
+const _1 = e_;
+{
+const _c = _1;
+return ff_compiler_Syntax.EFunctions(_c.at_, _c.functions_, semicolonUnit_(e_.body_))
+}
+}
+return
+}
+{
+return body_
+}
+}
+return ff_compiler_Syntax.ESequential(at_, ff_compiler_Inference.Inference_inferTerm(self_, environment_, newExpected_, semicolonUnit_(before_)), ff_compiler_Inference.Inference_inferTerm(self_, environment_, expected_, after_))
 }
 }
 return
@@ -2508,7 +2629,128 @@ return ff_compiler_Syntax.ESequential(at_, ff_compiler_Inference.Inference_infer
 return
 }
 {
-return ff_compiler_Syntax.ESequential(at_, ff_compiler_Inference.Inference_inferTerm(self_, environment_, newExpected_, before_), ff_compiler_Inference.Inference_inferTerm(self_, environment_, expected_, after_))
+const unitName_ = ff_compiler_Inference.core_("Unit");
+function semicolonUnit_(body_) {
+const body_a = body_;
+if(body_a.ECall) {
+const e_ = body_a;
+const _guard3 = e_.target_;
+if(_guard3.DynamicCall) {
+const c_ = _guard3;
+const _guard2 = c_.function_;
+if(_guard2.EVariable) {
+const x_ = _guard2;
+if(((x_.name_ === "ff:core/Core.if") || (x_.name_ === "ff:core/Core.try"))) {
+{
+const _1 = e_;
+{
+const _c = _1;
+return ff_compiler_Syntax.ECall(_c.at_, _c.target_, _c.effect_, _c.typeArguments_, ff_core_List.List_map(e_.arguments_, ((_1) => {
+{
+const a_ = _1;
+const _guard1 = a_.value_;
+if(_guard1.ELambda) {
+const l_ = _guard1;
+{
+const _1 = a_;
+{
+const _c = _1;
+return ff_compiler_Syntax.Argument(_c.at_, _c.name_, (((_c) => {
+return ff_compiler_Syntax.ELambda(_c.at_, (((_c) => {
+return ff_compiler_Syntax.Lambda(_c.at_, _c.effect_, ff_core_List.List_map(l_.lambda_.cases_, ((c_) => {
+{
+const _1 = c_;
+{
+const _c = _1;
+return ff_compiler_Syntax.MatchCase(_c.at_, _c.patterns_, _c.guards_, ff_compiler_Syntax.ESequential(c_.at_, c_.body_, ff_compiler_Syntax.EVariant(c_.at_, unitName_, [], ff_core_Option.None())))
+}
+}
+})))
+}))(l_.lambda_))
+}))(l_))
+return
+}
+}
+return
+}
+}
+{
+const a_ = _1;
+return a_
+}
+})), _c.dictionaries_)
+return
+}
+}
+return
+}
+}
+}
+}
+if(body_a.ECall) {
+const e_ = body_a;
+const _guard3 = e_.target_;
+if(_guard3.DynamicCall) {
+const c_ = _guard3;
+const _guard2 = c_.function_;
+if(_guard2.EField) {
+const f_ = _guard2;
+if(((((((f_.field_ === "else") || (f_.field_ === "elseIf")) || (f_.field_ === "grab")) || (f_.field_ === "catch")) || (f_.field_ === "catchAny")) || (f_.field_ === "finally"))) {
+{
+const _1 = e_;
+{
+const _c = _1;
+return ff_compiler_Syntax.ECall(_c.at_, (((_c) => {
+return ff_compiler_Syntax.DynamicCall((((_c) => {
+return ff_compiler_Syntax.EField(_c.at_, _c.newtype_, semicolonUnit_(f_.record_), _c.field_)
+}))(f_), _c.tailCall_)
+}))(c_), _c.effect_, _c.typeArguments_, _c.arguments_, _c.dictionaries_)
+return
+}
+}
+return
+}
+}
+}
+}
+if(body_a.ESequential) {
+const e_ = body_a;
+{
+const _1 = e_;
+{
+const _c = _1;
+return ff_compiler_Syntax.ESequential(_c.at_, _c.before_, semicolonUnit_(e_.after_))
+}
+}
+return
+}
+if(body_a.ELet) {
+const e_ = body_a;
+{
+const _1 = e_;
+{
+const _c = _1;
+return ff_compiler_Syntax.ELet(_c.at_, _c.mutable_, _c.name_, _c.valueType_, _c.value_, semicolonUnit_(e_.body_))
+}
+}
+return
+}
+if(body_a.EFunctions) {
+const e_ = body_a;
+{
+const _1 = e_;
+{
+const _c = _1;
+return ff_compiler_Syntax.EFunctions(_c.at_, _c.functions_, semicolonUnit_(e_.body_))
+}
+}
+return
+}
+{
+return body_
+}
+}
+return ff_compiler_Syntax.ESequential(at_, ff_compiler_Inference.Inference_inferTerm(self_, environment_, newExpected_, semicolonUnit_(before_)), ff_compiler_Inference.Inference_inferTerm(self_, environment_, expected_, after_))
 }
 }
 return

package/output/js/ff/compiler/Main.mjs

@@ -227,7 +227,7 @@ return
 }
 ff_core_Try.Try_grab(ff_core_Try.Try_catch(ff_core_Try.Try_catch(ff_core_Try.Try_catch(ff_core_Core.try_((() => {
 const command_ = ff_compiler_Main.parseCommandLine_(ff_core_NodeSystem.NodeSystem_arguments(system_));
-return runCommand_(command_)
+runCommand_(command_)
 })), ((_1, _2) => {
 {
 const message_ = _1.problem_;
@@ -475,7 +475,7 @@ return
 }
 ff_core_Try.Try_grab(ff_core_Try.Try_catch(ff_core_Try.Try_catch(ff_core_Try.Try_catch((await ff_core_Core.try_$((async ($task) => {
 const command_ = ff_compiler_Main.parseCommandLine_((await ff_core_NodeSystem.NodeSystem_arguments$(system_, $task)));
-return (await runCommand_$(command_, $task))
+(await runCommand_$(command_, $task))
 }), $task)), ((_1, _2) => {
 {
 const message_ = _1.problem_;

package/output/js/ff/compiler/ModuleCache.mjs

@@ -312,7 +312,7 @@ const path_ = ff_compiler_ModuleCache.modulePath_(packagePaths_, packagePair_, m
 if((!ff_core_Map.Map_contains(self_.emittedModules_, ff_core_Path.Path_absolute(path_), ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String))) {
 self_.emittedModules_ = ff_core_Map.Map_add(self_.emittedModules_, ff_core_Path.Path_absolute(path_), self_.version_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String);
 ff_core_Try.Try_grab(ff_core_Try.Try_catchAny(ff_core_Core.try_((() => {
-return body_(path_)
+body_(path_)
 })), ((error_) => {
 self_.emittedModules_ = ff_core_Map.Map_remove(self_.emittedModules_, ff_core_Path.Path_absolute(path_), ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String);
 ff_core_Error.Error_rethrow(error_)
@@ -485,7 +485,7 @@ const path_ = (await ff_compiler_ModuleCache.modulePath_$(packagePaths_, package
 if((!ff_core_Map.Map_contains(self_.emittedModules_, (await ff_core_Path.Path_absolute$(path_, $task)), ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String))) {
 self_.emittedModules_ = ff_core_Map.Map_add(self_.emittedModules_, (await ff_core_Path.Path_absolute$(path_, $task)), self_.version_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String);
 ff_core_Try.Try_grab((await ff_core_Try.Try_catchAny$((await ff_core_Core.try_$((async ($task) => {
-return (await body_(path_, $task))
+(await body_(path_, $task))
 }), $task)), (async (error_, $task) => {
 self_.emittedModules_ = ff_core_Map.Map_remove(self_.emittedModules_, (await ff_core_Path.Path_absolute$(path_, $task)), ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String);
 ff_core_Error.Error_rethrow(error_)

package/output/js/ff/compiler/Patterns.mjs

@@ -264,7 +264,7 @@ return ff_compiler_Patterns.PatternCaseInfo(fields_, (!exhaustiveGuards_))
 export function convertAndCheck_(modules_, cases_) {
 const converted_ = ff_compiler_Patterns.convert_(modules_, cases_);
 ff_core_Try.Try_else(ff_core_Core.try_((() => {
-return ff_compiler_Patterns.check_(ff_core_List.List_toMap([], ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), [], converted_, false, false)
+ff_compiler_Patterns.check_(ff_core_List.List_toMap([], ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), [], converted_, false, false)
 })), (() => {
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(ff_core_List.List_grab(cases_, 0).at_, "Unexhaustive match"), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 }))
@@ -434,7 +434,7 @@ return ff_compiler_Patterns.PatternCaseInfo(fields_, (!exhaustiveGuards_))
 export async function convertAndCheck_$(modules_, cases_, $task) {
 const converted_ = ff_compiler_Patterns.convert_(modules_, cases_);
 ff_core_Try.Try_else(ff_core_Core.try_((() => {
-return ff_compiler_Patterns.check_(ff_core_List.List_toMap([], ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), [], converted_, false, false)
+ff_compiler_Patterns.check_(ff_core_List.List_toMap([], ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), [], converted_, false, false)
 })), (() => {
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(ff_core_List.List_grab(cases_, 0).at_, "Unexhaustive match"), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 }))

package/output/js/ff/core/Task.mjs

@@ -231,7 +231,7 @@ return _w1.first_
 }), ff_core_Ordering.ff_core_Ordering_Order$ff_core_Int_Int), ((_w1) => {
 return _w1.second_
 }));
-return ff_core_Channel.Channel_write(successChannel_, result_)
+ff_core_Channel.Channel_write(successChannel_, result_)
 })), ((error_) => {
 ff_core_Channel.Channel_write(failureChannel_, error_);
 ff_core_Task.Task_abort(t_)
@@ -251,7 +251,7 @@ let live_ = ff_core_List.List_size(tasks_);
 const started_ = ff_core_List.List_map(tasks_, ((task_) => {
 return ff_core_Task.Task_spawn(self_, ((_) => {
 ff_core_Try.Try_grab(ff_core_Try.Try_catchAny(ff_core_Core.try_((() => {
-return ff_core_Channel.Channel_write(successChannel_, task_())
+ff_core_Channel.Channel_write(successChannel_, task_())
 })), ((e_) => {
 live_ -= 1;
 if((live_ === 0)) {
@@ -304,7 +304,7 @@ return _w1.first_
 }), ff_core_Ordering.ff_core_Ordering_Order$ff_core_Int_Int), ((_w1) => {
 return _w1.second_
 }));
-return (await ff_core_Channel.Channel_write$(successChannel_, result_, $task))
+(await ff_core_Channel.Channel_write$(successChannel_, result_, $task))
 }), $task)), (async (error_, $task) => {
 (await ff_core_Channel.Channel_write$(failureChannel_, error_, $task));
 (await ff_core_Task.Task_abort$(t_, $task))
@@ -324,7 +324,7 @@ let live_ = ff_core_List.List_size(tasks_);
 const started_ = (await ff_core_List.List_map$(tasks_, (async (task_, $task) => {
 return (await ff_core_Task.Task_spawn$(self_, (async (_, $task) => {
 ff_core_Try.Try_grab((await ff_core_Try.Try_catchAny$((await ff_core_Core.try_$((async ($task) => {
-return (await ff_core_Channel.Channel_write$(successChannel_, (await task_($task)), $task))
+(await ff_core_Channel.Channel_write$(successChannel_, (await task_($task)), $task))
 }), $task)), (async (e_, $task) => {
 live_ -= 1;
 if((live_ === 0)) {

package/package.json

@@ -4,7 +4,7 @@
   "description": "Firefly compiler",
   "author": "Firefly team",
   "license": "MIT",
-  "version": "0.4.30",
+  "version": "0.4.31",
   "repository": {
     "type": "git",
     "url": "https://github.com/Ahnfelt/firefly-boot"

package/vscode/package.json

@@ -4,7 +4,7 @@
     "description": "Firefly language support",
     "author": "Firefly team",
     "license": "MIT",
-    "version": "0.4.30",
+    "version": "0.4.31",
     "repository": {
         "type": "git",
         "url": "https://github.com/Ahnfelt/firefly-boot"