firefly-compiler 0.4.20 → 0.4.22

package/compiler/JsEmitter.ff

@@ -223,9 +223,9 @@ extend self: JsEmitter {
                     }.join("\n")
                     let body = self.emitTailCall {
                         let casesString = cases.map {
-                            "{\n" + self.emitCase(escapedArguments, _, True, True, async) + "\n}"
+                            self.emitCase(escapedArguments, _, [], [], True, True, async)
                         }.join("\n")
-                        "{\n" + shadowingWorkaround + "\n" + casesString + "\n}"
+                        shadowingWorkaround + "\n" + casesString
                     }
                     signature + " {\n" + body + "\n}"
             }
@@ -343,7 +343,7 @@ extend self: JsEmitter {
             Patterns.convertAndCheck(self.otherModules, cases)
             let arguments = cases.grab(0).patterns.pairs().map {"_" + (_.first + 1)}
             let escapedArguments = arguments.map(escapeKeyword) // emitCase arguments must be preescaped
-            let caseStrings = cases.map {"{\n" + self.emitCase(escapedArguments, _, True, True, newAsync) + "\n}"}
+            let caseStrings = cases.map {self.emitCase(escapedArguments, _, [], [], True, True, newAsync)}
             let prefix = if(newAsync) {"async "} else {""}
             "(" + prefix + "(" + [...escapedArguments, ...controller].join(", ") + ") => " +
             "{\n" + caseStrings.join("\n") + "\n})"
@@ -356,6 +356,12 @@ extend self: JsEmitter {
             "(" + operator + self.emitArgument(at, value, async) + ")"
         | ECall(at, StaticCall(operator, _, _), _, [], [left, right], _) {!operator.grabFirst().isAsciiLetter()} =>
             "(" + self.emitArgument(at, left, async) + " " + operator + " " + self.emitArgument(at, right, async) + ")"
+        | ECall(at, StaticCall("ff:core/List.List_grab", _, _), _, _, [Argument(_, _, EVariable(_, x1)), Argument(_, _, EVariable(_, x2))], _) =>
+            "(" + escapeResolved(x1) + "[" + escapeResolved(x2) + "] ?? " + 
+            "ff_core_List.internalGrab_(" + escapeResolved(x1) + ", " + escapeResolved(x2) + "))"
+        | ECall(at, StaticCall("ff:core/Array.Array_grab", _, _), _, _, [Argument(_, _, EVariable(_, x1)), Argument(_, _, EVariable(_, x2))], _) =>
+            "(" + escapeResolved(x1) + ".array[" + escapeResolved(x2) + "] ?? " + 
+            "ff_core_Array.internalGrab_(" + escapeResolved(x1) + ", " + escapeResolved(x2) + "))"
         | ECall(at, StaticCall("ff:unsafejs/UnsafeJs.import", _, _), _, _, [Argument(_, _, EString(_, url))], _) =>
             self.jsImporter.add(url.replace("\"", ""))
         | ECall(at, StaticCall("ff:unsafejs/UnsafeJs.await", _, _), _, _, [Argument(_, _, body)], _) =>
@@ -490,9 +496,9 @@ extend self: JsEmitter {
                 self.emitStatements(body, last, async)
             | EVariant(at, "ff:core/Unit.Unit", _, _) =>
                 ""
-            | ESequential(at, EVariant(at, "ff:core/Unit.Unit", _, _), after) =>
+            | ESequential(_, EVariant(_, "ff:core/Unit.Unit", _, _), after) =>
                 self.emitStatements(after, last, async)
-            | ESequential(at, before, EVariant(at, "ff:core/Unit.Unit", _, _)) =>
+            | ESequential(_, before, EVariant(_, "ff:core/Unit.Unit", _, _)) =>
                 self.emitStatements(before, False, async)
             | ESequential(at, before, after) =>
                 self.emitStatements(before, False, async) + ";\n" + self.emitStatements(after, last, async)
@@ -561,7 +567,7 @@ extend self: JsEmitter {
                 Patterns.convertAndCheck(self.otherModules, cases)
                 if(!last) {"do "}.else {""} +
                 "{\nconst _1 = " + self.emitTerm(value, async) + ";\n" +
-                cases.map {"{\n" + self.emitCase(["_1"], _, True, last, async) + "\n}"}.join("\n") +
+                cases.map {self.emitCase(["_1"], _, [], [], True, last, async)}.join("\n") +
                 "\n}" + if(!last) {" while(false)"}.else {""}
             | _ =>
                 detectIfElse(term).{
@@ -594,16 +600,16 @@ extend self: JsEmitter {
             let arguments = ["_exception.value_", "_error"]
             cases.{
                 | [case] =>
-                    self.emitCase(arguments, case, False, last, catchAsync)
+                    self.emitCase(arguments, case, [], [], False, last, catchAsync)
                 | cs =>
                     let caseStrings =
-                        cases.map {"{\n" + self.emitCase(arguments, _, True, last, catchAsync) + "\n}"}
+                        cases.map {self.emitCase(arguments, _, [], [], True, last, catchAsync)}
                     if(last) {caseStrings.join("\n")} else {"do {\n" + caseStrings.join("\n") + "\n} while(false)"}
             }
         }
         term.{
-            | ECall(at, StaticCall("ff:core/Try.Try_finally", _, _), _, _, [
-                Argument(_, _, ECall(at, StaticCall("ff:core/Core.try", _, _), _, _, [
+            | ECall(_, StaticCall("ff:core/Try.Try_finally", _, _), _, _, [
+                Argument(_, _, ECall(_, StaticCall("ff:core/Core.try", _, _), _, _, [
                     Argument(_, _, ELambda(_, Lambda(_, tryEffect, [MatchCase(_, [], [], tryBody)])))
                 ], _))
                 Argument(_, _, ELambda(_, Lambda(_, finallyEffect, [MatchCase(_, [], [], finallyBody)])))
@@ -614,8 +620,8 @@ extend self: JsEmitter {
                     "try {\n" + self.emitStatements(tryBody, last, tryAsync) +
                     "\n} finally {\n" + self.emitStatements(finallyBody, last, finallyAsync) + "\n}"
                 )
-            | ECall(at, StaticCall("ff:core/Try.Try_catch", _, _), _, _, [
-                Argument(_, _, ECall(at, StaticCall("ff:core/Core.try", _, _), _, _, [
+            | ECall(_, StaticCall("ff:core/Try.Try_catch", _, _), _, _, [
+                Argument(_, _, ECall(_, StaticCall("ff:core/Core.try", _, _), _, _, [
                     Argument(_, _, ELambda(_, Lambda(_, tryEffect, [MatchCase(_, [], [], tryBody)])))
                 ], _))
                 Argument(_, _, ELambda(_, Lambda(_, catchEffect, cases)))
@@ -631,9 +637,9 @@ extend self: JsEmitter {
                         emitCatch(catchEffect, cases) +
                     "\n}"
                 )
-            | ECall(at, StaticCall("ff:core/Try.Try_finally", _, _), _, _, [
-                Argument(_, _, ECall(at, StaticCall("ff:core/Try.Try_catch", _, _), _, _, [
-                    Argument(_, _, ECall(at, StaticCall("ff:core/Core.try", _, _), _, _, [
+            | ECall(_, StaticCall("ff:core/Try.Try_finally", _, _), _, _, [
+                Argument(_, _, ECall(_, StaticCall("ff:core/Try.Try_catch", _, _), _, _, [
+                    Argument(_, _, ECall(_, StaticCall("ff:core/Core.try", _, _), _, _, [
                         Argument(_, _, ELambda(_, Lambda(_, tryEffect, [MatchCase(_, [], [], tryBody)])))
                     ], _))
                     Argument(_, _, ELambda(_, Lambda(_, catchEffect, cases)))
@@ -657,7 +663,23 @@ extend self: JsEmitter {
         }
     }
 
-    emitCase(arguments: List[String], matchCase: MatchCase, jump: Bool, last: Bool, async: Bool): String {
+    emitCase(
+        arguments: List[String]
+        matchCase: MatchCase
+        conditions: List[String]
+        variables: List[String]
+        jump: Bool
+        last: Bool
+        async: Bool
+    ): String {
+        function emitWrapper(code: String): String {
+            if(conditions.isEmpty()) {"{\n"} else {
+                "if(" + conditions.join(" && ") + ") {\n"
+            } +
+            variables.join() +
+            code +
+            "\n}"
+        }
         Pair(matchCase.patterns, matchCase.guards).{
             | Pair([p, ...ps], _) =>
                 self.emitPattern(
@@ -665,18 +687,45 @@ extend self: JsEmitter {
                     p
                     arguments.dropFirst()
                     matchCase.MatchCase(patterns = ps)
+                    conditions
+                    variables
                     jump
                     last
                     async
                 )
+            | Pair([], [MatchGuard(_, e, PVariant(_, "ff:core/Bool.True", _))]) {variables.isEmpty()} =>
+                let newCase = matchCase.MatchCase(patterns = [], guards = [])
+                self.emitCase([], newCase, [...conditions, self.emitTerm(e, async)], [], jump, last, async)
+            | Pair([], [MatchGuard(_, e, PVariant(_, "ff:core/Bool.True", _))]) =>
+                let newCase = matchCase.MatchCase(patterns = [], guards = [])
+                let code = self.emitCase([], newCase, [self.emitTerm(e, async)], [], jump, last, async)
+                emitWrapper(code)
             | Pair([], [guard, ...guards]) =>
                 let guardName = "_guard" + (guards.size() + 1)
                 let newCase = matchCase.MatchCase(patterns = [guard.pattern], guards = guards)
-                "const " + guardName + " = " + self.emitTerm(guard.term, async) + ";\n" +
-                self.emitCase([guardName], newCase, jump, last, async)
+                let code = 
+                    "const " + guardName + " = " + self.emitTerm(guard.term, async) + ";\n" +
+                    self.emitCase([guardName], newCase, [], [], jump, last, async)
+                emitWrapper(code)
             | Pair([], []) =>
-                self.emitStatements(matchCase.body, last, async) +
-                if(jump && last) {"\nreturn"} elseIf {jump} {"\nbreak"} else {""}
+                let statementsCode = self.emitStatements(matchCase.body, last, async)
+                let lastLine = statementsCode.reverse().takeWhile {_ != '\n'}.reverse()
+                let returns = 
+                    lastLine.startsWith("return ") || 
+                    lastLine.startsWith("break ") ||
+                    lastLine.startsWith("continue ") ||
+                    lastLine.startsWith("return;") || 
+                    lastLine.startsWith("break;") ||
+                    lastLine.startsWith("continue;") ||
+                    lastLine.startsWith("throw ")
+                let code = statementsCode + if(jump && last && !returns) {
+                    "\nreturn"
+                } elseIf {jump && !returns} {
+                    "\nbreak"
+                } else {
+                    ""
+                }
+                emitWrapper(code)
         }
     }
 
@@ -685,81 +734,78 @@ extend self: JsEmitter {
         pattern: MatchPattern
         arguments: List[String]
         matchCase: MatchCase
+        conditions: List[String]
+        variables: List[String]
         jump: Bool
         last: Bool
         async: Bool
     ): String {
         pattern.{
             | PString(_, value) =>
-                "if(" + argument + " === " + value + ") {\n" +
-                self.emitCase(arguments, matchCase, jump, last, async) +
-                "\n}"
+                let newConditions = [...conditions, argument + " === " + value]
+                self.emitCase(arguments, matchCase, newConditions, variables, jump, last, async)
             | PInt(_, value) =>
-                "if(" + argument + " === " + value + ") {\n" +
-                self.emitCase(arguments, matchCase, jump, last, async) +
-                "\n}"
+                let newConditions = [...conditions, argument + " === " + value]
+                self.emitCase(arguments, matchCase, newConditions, variables, jump, last, async)
             | PChar(_, value) =>
-                "if(" + argument + " === " + charLiteralToNumber(value) + ") {\n" +
-                self.emitCase(arguments, matchCase, jump, last, async) +
-                "\n}"
+                let newConditions = [...conditions, argument + " === " + charLiteralToNumber(value)]
+                self.emitCase(arguments, matchCase, newConditions, variables, jump, last, async)
             | PVariable(_, None) =>
-                self.emitCase(arguments, matchCase, jump, last, async)
+                self.emitCase(arguments, matchCase, conditions, variables, jump, last, async)
             | PVariable(_, Some(name)) =>
                 let escaped = escapeKeyword(name)
-                if(escaped != argument) {"const " + escaped + " = " + argument + ";\n"} else {""} +
-                self.emitCase(arguments, matchCase, jump, last, async)
+                let newVariables = if(escaped != argument) {
+                    [...variables, "const " + escaped + " = " + argument + ";\n"]
+                } else {variables}
+                self.emitCase(arguments, matchCase, conditions, newVariables, jump, last, async)
             | PVariant(_, "ff:core/Bool.False", []) =>
-                "if(!" + argument + ") {\n" +
-                self.emitCase(arguments, matchCase, jump, last, async) +
-                "\n}"
+                self.emitCase(arguments, matchCase, [...conditions, "!" + argument], variables, jump, last, async)
             | PVariant(_, "ff:core/Bool.True", []) =>
-                "if(" + argument + ") {\n" +
-                self.emitCase(arguments, matchCase, jump, last, async) +
-                "\n}"
-            | PVariant(_, "List$Empty", []) =>
-                mutable shortArgument = argument
-                mutable shortCount = 0
-                while {shortArgument.endsWith(".slice(1)")} {
-                    shortArgument = shortArgument.dropLast(".slice(1)".size())
-                    shortCount += 1
-                }
-                "if(" + shortArgument + ".length === " + shortCount + ") {\n" +
-                self.emitCase(arguments, matchCase, jump, last, async) +
-                "\n}"
-            | PVariant(_, "List$Link", [head, tail]) =>
-                mutable shortArgument = argument
-                mutable shortCount = 0
-                while {shortArgument.endsWith(".slice(1)")} {
-                    shortArgument = shortArgument.dropLast(".slice(1)".size())
-                    shortCount += 1
+                self.emitCase(arguments, matchCase, [...conditions, argument], variables, jump, last, async)
+            | PVariant(_, emptyOrLink, _) {emptyOrLink == "List$Empty" || emptyOrLink == "List$Link"} =>
+                mutable restPattern = None
+                function listPatterns(matchPattern: MatchPattern): List[MatchPattern] {
+                    | PVariant(_, "List$Empty", []) => 
+                        []
+                    | PVariant(_, "List$Link", [head, tail]) =>
+                        [head, ...listPatterns(tail)]
+                    | p =>
+                        restPattern = Some(p)
+                        []
                 }
-                let newArguments = [shortArgument + "[" + shortCount + "]", argument + ".slice(1)", ...arguments]
-                let newMatchCase = matchCase.MatchCase(patterns = [head, tail, ...matchCase.patterns])
-                "if(" + shortArgument + ".length > " + shortCount + ") {\n" +
-                self.emitCase(newArguments, newMatchCase, jump, last, async) +
-                "\n}"
+                let patterns = listPatterns(pattern)
+                let itemArguments = patterns.pairs().map {| Pair(i, _) => argument + "[" + i + "]"}
+                let restArgument = restPattern.map {_ => argument + ".slice(" + patterns.size() + ")"}
+                let newArguments = [...itemArguments, ...restArgument.toList(), ...arguments]
+                let newMatchCase = matchCase.MatchCase(
+                    patterns = [...patterns, ...restPattern.toList(), ...matchCase.patterns]
+                )
+                let operator = restPattern.map {_ => ">="}.else {"==="}
+                let newConditions = [...conditions, argument + ".length " + operator + " " + patterns.size()]
+                self.emitCase(newArguments, newMatchCase, newConditions, variables, jump, last, async)
             | PVariant(_, name, patterns) =>
                 let processed = self.processVariantCase(name, argument)
                 let newMatchCase = matchCase.MatchCase(patterns = [...patterns, ...matchCase.patterns])
-                if(processed.loneVariant) {""} else {
-                    "if(" + argument + "." + processed.variantName + ") {\n"
-                } +
-                self.emitCase([...processed.arguments, ...arguments], newMatchCase, jump, last, async) +
-                if(processed.loneVariant) {""} else {"\n}"}
+                let newConditions = if(processed.loneVariant) {conditions} else {
+                    [...conditions, argument + "." + processed.variantName]
+                }
+                let newArguments = [...processed.arguments, ...arguments]
+                self.emitCase(newArguments, newMatchCase, newConditions, variables, jump, last, async)
             | PVariantAs(at, name, variableAt, variable) =>
                 let processed = self.processVariantCase(name, argument)
-                if(processed.loneVariant) {""} else {
-                    "if(" + argument + "." + processed.variantName + ") {\n"
-                } +
-                variable.map(escapeKeyword).filter {_ != argument}.map {
-                    "const " + _ + " = " + argument + ";\n"
-                }.else {""} +
-                self.emitCase(arguments, matchCase, jump, last, async) +
-                if(processed.loneVariant) {""} else {"\n}"}
+                let newConditions = if(processed.loneVariant) {conditions} else {
+                    [...conditions, argument + "." + processed.variantName]
+                }
+                let newVariables = variable.map(escapeKeyword).filter {_ != argument}.map {
+                    [...variables, "const " + _ + " = " + argument + ";\n"]
+                }.else {[]}
+                self.emitCase(arguments, matchCase, newConditions, newVariables, jump, last, async)
             | PAlias(_, pattern, variable) =>
                 let escaped = escapeKeyword(variable)
-                if(escaped != argument) {"const " + escaped + " = " + argument + ";\n"} else {""} +
-                self.emitPattern(argument, pattern, arguments, matchCase, jump, last, async)
+                let newVariables = if(escaped != argument) {
+                    [...variables, "const " + escaped + " = " + argument + ";\n"]
+                } else {variables}
+                self.emitPattern(argument, pattern, arguments, matchCase, conditions, newVariables, jump, last, async)
         }
     }
 
@@ -771,8 +817,6 @@ extend self: JsEmitter {
     }
 
     processVariantCase(name: String, argument: String): ProcessedVariantCase {
-        if(name == "List$Empty") {ProcessedVariantCase(name, False, False, [])} else:
-        if(name == "List$Link") {ProcessedVariantCase(name, False, False, [argument + "[0]", argument + ".slice(1)"])} else:
         let variantNameUnqualified = name.reverse().takeWhile {_ != '.'}.reverse()
         let variantName = escapeKeyword(variantNameUnqualified)
         let moduleName = name.dropLast(variantNameUnqualified.size() + 1)
@@ -855,9 +899,9 @@ extractTypeName(type: Type): String {
 
 firstTypeName(types: List[Type]): String {
     types.grabFirst().{
-        | TConstructor t => t
+        | TConstructor t => t.name
         | TVariable t => fail(t.at, " is still a unification variable")
-    }.name
+    }
 }
 
 makeDictionaryName(traitName: String, typeName: String): String {

package/compiler/LspHook.ff

@@ -96,6 +96,7 @@ class ResultHook {
     ResolveSymbolHook(
         symbol: SymbolHook
         annotation: Option[Type]
+        topLevel: Bool
     )
     ResolveTypeHook(
         types: Map[String, String]
@@ -110,6 +111,7 @@ class ResultHook {
     ResolveSignatureHook(
         signature: Signature
         isInstanceMethod: Bool
+        topLevel: Bool
     )
     ResolveVariantFieldHook(
         symbol: SymbolHook
@@ -171,6 +173,7 @@ class ResultHook {
         instantiated: Box[Option[Instantiated]]
     )
     InferRecordFieldHook(
+        usageAt: Location
         unification: Unification
         environment: Environment
         expected: Type
@@ -186,15 +189,15 @@ showHook(hook: ResultHook): String {
     | InferLookupHook(unification, environment, expected, selfVariable, symbol, instantiated) => "InferLookupHook(...)"
     | InferParameterHook(unification, environment, parameter, missing) => "InferParameterHook(...)"
     | InferPatternHook(unification, environment, expected, pattern) => "InferPatternHook(...)"
-    | InferRecordFieldHook(unification, environment, expected, recordType, fieldName) => "InferRecordFieldHook(...)"
+    | InferRecordFieldHook(usageAt, unification, environment, expected, recordType, fieldName) => "InferRecordFieldHook(...)"
     | InferSequentialStartHook(unification, term, missing) => "InferSequentialStartHook(...)"
     | InferTermHook(unification, environment, expected, term, recordType, missing) => "InferTermHook(...)"
     | ParseArgumentHook(callAt, argumentIndex, parameterName) => "ParseArgumentHook(...)"
     | ParseSymbolBegin => "ParseSymbolBegin(...)"
     | ParseSymbolEnd(name, kind, selectionStart, selectionEnd, start, end) => "ParseSymbolEnd(...)"
     | ResolveConstraintHook(symbol, constrant) => "ResolveConstraintHook(...)"
-    | ResolveSignatureHook(signature, _) => "ResolveSignatureHook(...)"
-    | ResolveSymbolHook(symbol, annotation) => "ResolveSymbolHook(...)"
+    | ResolveSignatureHook(signature, _, _) => "ResolveSignatureHook(...)"
+    | ResolveSymbolHook(symbol, annotation, _) => "ResolveSymbolHook(...)"
     | ResolveTypeHook(types, typeGenerics, symbol, explicitType) => "ResolveTypeHook(...)"
     | ResolveVariantFieldHook(symbol, type, commonField) => "ResolveVariantFieldHook(...)"
 }

package/compiler/Main.ff

@@ -63,7 +63,10 @@ main(system: NodeSystem): Unit {
             prepareFireflyDirectory(system.path("."))
             let localMainFile = system.path(mainFile).base()
             buildScript(localMainFile, resolvedDependencies.mainPackagePair, EmitNode, resolvedDependencies)
-            importAndRun(fireflyPath, "node", resolvedDependencies.mainPackagePair, localMainFile, arguments)
+            if(!importAndRun(fireflyPath, "node", resolvedDependencies.mainPackagePair, localMainFile, arguments)) {
+                let at = Location(system.path(mainFile + ".ff").absolute(), 1, 1)
+                throw(CompileError(at, "This module does not contain a 'nodeMain' function"))
+            }
 
         | BrowserCommand(mainFile) =>
             let resolvedDependencies = Dependencies.process(system.httpClient(), system.path(mainFile + ".ff"))
@@ -82,8 +85,9 @@ main(system: NodeSystem): Unit {
             importAndRun(fireflyPath, "build", resolvedDependencies.mainPackagePair, localMainFile, [])
 
         | CheckCommand(filePath) => 
-            Builder.check(system, fireflyPath, system.path(filePath), Map.empty(), LspHook.disabled(), True)
-        
+            let errors = Builder.check(system, fireflyPath, system.path(filePath), None, Map.empty(), LspHook.disabled(), True)
+            if(!errors.isEmpty()) {throw(CompileErrors(errors.distinct()))}
+
         | BootstrapCommand =>
             let workingDirectory = system.path(".")
             Builder.build(
@@ -110,11 +114,16 @@ main(system: NodeSystem): Unit {
     try {
         let command = parseCommandLine(system.arguments())
         runCommand(command)
-    } catch {| CommandLineError(message), error =>
+    } catch {| CommandLineError(message), _ =>
         Log.debug(message)
-    } catch {| CompileError(at, message), error =>
+    } catch {| CompileError(at, message), _ =>
         Log.debug(message)
         Log.debug(" at " + at.file.replace("./", "") + ":" + at.line + ":" + at.column)
+    } catch {| CompileErrors(errors), _ =>
+        errors.map {| CompileError(at, message) => 
+            Log.debug(message)
+            Log.debug(" at " + at.file.replace("./", "") + ":" + at.line + ":" + at.column)
+        }
     } grab()
 }
 
@@ -164,13 +173,13 @@ parseCommandLine(arguments: List[String]): MainCommand {
         }
     | ["check", ...checkArguments] =>
         checkArguments.{
-            | [fileName] {fileName.removeLast(".ff") | Some(_)} =>
+            | [fileName] =>
                 CheckCommand(fileName)
             | [_, _, ...] => throw(CommandLineError(
                 "You must only specify a single argument to check."  + usageString
             ))
-            | _ => throw(CommandLineError(
-                "You must specify a Firefly file (.ff) as the argument to build."  + usageString
+            | [] => throw(CommandLineError(
+                "You must specify a Firefly file (.ff) or directory as the argument to check."  + usageString
             ))
         }
     | ["bootstrap", _] =>
@@ -206,14 +215,19 @@ importAndRun(
     packagePair: PackagePair
     mainFile: String
     arguments: List[String]
-): Unit
+): Bool
     target node async """
         const process = await import('process');
         const cwd = process.cwd();
         const workingDirectory = cwd.indexOf(':') == 1 ? 'file:///' + cwd : cwd;
         const packagePath = packagePair_.group_ + "/" + packagePair_.name_
         const main = await import(workingDirectory + "/.firefly/output/" + target_ + "/" + packagePath + "/" + mainFile_ + ".mjs");
-        await main.$run$(fireflyPath_, arguments_)
+        if(typeof main.$run$ !== 'undefined') {
+            await main.$run$(fireflyPath_, arguments_);
+            return true;
+        } else {
+            return false;
+        }
     """
 
 prepareFireflyDirectory(path: Path) {

package/compiler/Patterns.ff

@@ -72,7 +72,7 @@ convert(modules: Map[String, Module], cases: List[MatchCase]): List[PatternCaseI
             None
         | PVariant p =>
             let fields = p.patterns.map(convertPattern).pairs().collect {
-                | Pair(i, Some(p)) => Some(Pair("" + i, p))
+                | Pair(i, Some(info)) => Some(Pair("" + i, info))
                 | _ => None
             }
             Some(PatternInfo(unqualifiedName(p.name), otherVariants(p.name), fields))