firefly-compiler 0.4.20 → 0.4.21

package/compiler/Builder.ff

@@ -88,15 +88,17 @@ check(
     system: NodeSystem
     fireflyPath: Path
     path: Path
+    mustContain: Option[String]
     virtualFiles: Map[String, String]
     lspHook: LspHook
     infer: Bool
-) {
+): List[CompileError] {
     let packages = path.isDirectory().{
-        | True => findPackageFiles(path)
+        | True => findPackageFiles(path, mustContain)
         | False {path.endsWith([".firefly", "package.ff"])} => [PackageFiles(path.parent().grab(), Some(path), [])]
         | False => [PackageFiles(path.parent().grab(), None, [path])]
     }
+    let errors = Array.make()
 
     packages.filter {!_.files.isEmpty()}.each {package => 
         let firstFile = package.files.grabFirst()
@@ -118,13 +120,19 @@ check(
         )
         package.files.each {file =>
             let localFile = file.base()
-            if(infer) {
-                compiler.infer(resolvedDependencies.mainPackagePair, localFile.dropLast(".ff".size()))
-            } else {
-                compiler.resolve(resolvedDependencies.mainPackagePair, localFile.dropLast(".ff".size()))
-            }
+            try {
+                if(infer) {
+                    compiler.infer(resolvedDependencies.mainPackagePair, localFile.dropLast(".ff".size()))
+                } else {
+                    compiler.resolve(resolvedDependencies.mainPackagePair, localFile.dropLast(".ff".size()))
+                }
+                Unit
+            } catch {| CompileError(_, _) @ c, error =>
+                errors.push(c)
+            } grab()
         }
     }
+    errors.drain()
 
 }
 
@@ -135,8 +143,8 @@ capability PackageFiles(
 )
 
 
-findPackageFiles(path: Path): List[PackageFiles] {
-    let files = findFireflyFiles(path)
+findPackageFiles(path: Path, mustContain: Option[String]): List[PackageFiles] {
+    let files = findFireflyFiles(path, mustContain)
     let split = files.partition {_.endsWith([".firefly", "package.ff"])}
     let packageFiles = split.first
     mutable singleFiles = split.second
@@ -153,15 +161,17 @@ findPackageFiles(path: Path): List[PackageFiles] {
     [...multiFileProjects, ...singleFileProjects]
 }
 
-findFireflyFiles(path: Path): List[Path] {
+findFireflyFiles(path: Path, mustContain: Option[String]): List[Path] {
     let split = path.entries().toList().partition {_.isDirectory()}
     let directories = split.first.map {_.path()}.filter {_.base().all {c => 
         c == '.' || c.isAsciiLower() || c.isAsciiDigit()
     }}
-    let fireflyFiles = split.second.map {_.path()}.filter {
-        _.extension() == ".ff"
+    let fireflyFiles = split.second.map {_.path()}.filter {file => 
+        file.extension() == ".ff" && mustContain.all {s => 
+            file.readText().contains(s)
+        }
     }
-    [...fireflyFiles, ...directories.flatMap {findFireflyFiles(_)}]
+    [...fireflyFiles, ...directories.flatMap {findFireflyFiles(_, mustContain)}]
 }
 
 internalCreateExecutable(

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)

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
@@ -193,8 +195,8 @@ showHook(hook: ResultHook): String {
     | 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

@@ -82,8 +82,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))}
+
         | BootstrapCommand =>
             let workingDirectory = system.path(".")
             Builder.build(
@@ -110,11 +111,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 +170,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", _] =>

package/compiler/Resolver.ff

@@ -49,16 +49,16 @@ extend self: Resolver {
 
     resolveModule(module: Module, otherModules: List[Module]): Module {
         let moduleNamespace =
-            module.file.replace("\\", "/").reverse().takeWhile { _ != '/' }.reverse().takeWhile { _ != '.' }
+            module.file.replace("\\", "/").reverse().takeWhile {_ != '/'}.reverse().takeWhile {_ != '.'}
         let self2 = self.processImports(module.imports, otherModules)
         let self3 = self2.processDefinitions(module, None)
         let module2 = module.Module(
-            types = module.types.map { self3.resolveTypeDefinition(_) }
-            traits = module.traits.map { self3.resolveTraitDefinition(_) }
-            instances = module.instances.map { self3.resolveInstanceDefinition(_) }
-            extends = module.extends.map { self3.resolveExtendDefinition(_) }
-            lets = module.lets.map { self3.resolveLetDefinition(_, True) }
-            functions = module.functions.map { self3.resolveFunctionDefinition(_, True, False) }
+            types = module.types.map {self3.resolveTypeDefinition(_)}
+            traits = module.traits.map {self3.resolveTraitDefinition(_)}
+            instances = module.instances.map {self3.resolveInstanceDefinition(_)}
+            extends = module.extends.map {self3.resolveExtendDefinition(_)}
+            lets = module.lets.map {self3.resolveLetDefinition(_, True)}
+            functions = module.functions.map {self3.resolveFunctionDefinition(_, True, False)}
         )
         module2.instances.each {_.typeArguments.each {self3.checkInstanceType(_)}}
         module2
@@ -135,7 +135,7 @@ extend self: Resolver {
     resolveTypeDefinition(definition: DType): DType {
         if(self.lspHook.isAt(definition.at)) {
             self.lspHook.emit(
-                ResolveSymbolHook(SymbolHook(definition.name, definition.at, definition.at), None)
+                ResolveSymbolHook(SymbolHook(definition.name, definition.at, definition.at), None, topLevel = True)
             )
         }
         let generics = definition.generics.map {g => Pair(g, g)}.toMap()
@@ -168,7 +168,7 @@ extend self: Resolver {
             variants = definition.variants.map {v =>
                 if(self.lspHook.isAt(v.at)) {
                     self.lspHook.emit(
-                        ResolveSymbolHook(SymbolHook(v.name, v.at, v.at), None)
+                        ResolveSymbolHook(SymbolHook(v.name, v.at, v.at), None, topLevel = True)
                     )
                 }
                 v.Variant(fields = v.fields.map {f =>
@@ -191,7 +191,7 @@ extend self: Resolver {
         if(self.lspHook.isAt(definition.at) || self.lspHook.isDefinedAt(definition.at)) {
             self.lspHook.emit(
                 ResolveSymbolHook(
-                    SymbolHook(definition.name, definition.at, definition.at), None
+                    SymbolHook(definition.name, definition.at, definition.at), None, topLevel = True
                 )
             )
         }        
@@ -221,7 +221,7 @@ extend self: Resolver {
         if(self.lspHook.isAt(definition.at) || self.lspHook.isDefinedAt(traitDefinedAt)) {
             self.lspHook.emit(
                 ResolveSymbolHook(
-                    SymbolHook(definition.traitName, definition.at, traitDefinedAt), None
+                    SymbolHook(definition.traitName, definition.at, traitDefinedAt), None, topLevel = True
                 )
             )
         }
@@ -266,7 +266,7 @@ extend self: Resolver {
         if(self.lspHook.isAt(definition.at) || self.lspHook.isDefinedAt(definition.at)) {
             self.lspHook.emit(
                 ResolveSymbolHook(
-                    SymbolHook(definition.name, definition.at, definition.at), None
+                    SymbolHook(definition.name, definition.at, definition.at), None, topLevel = topLevel
                 )
             )
         }
@@ -287,7 +287,7 @@ extend self: Resolver {
                 if(self.lspHook.isAt(e.at) || self.lspHook.isDefinedAt(at)) {
                     self.lspHook.emit(
                         ResolveSymbolHook(
-                            SymbolHook(e.name, e.at, at), None
+                            SymbolHook(e.name, e.at, at), None, topLevel = True
                         )
                     )
                 }
@@ -369,7 +369,7 @@ extend self: Resolver {
                 if(self.lspHook.isAt(e.at) || self.lspHook.isDefinedAt(e.at)) {
                     self.lspHook.emit(
                         ResolveSymbolHook(
-                            SymbolHook(e.name, e.at, e.at), None
+                            SymbolHook(e.name, e.at, e.at), None, topLevel = False
                         )
                     )
                 }
@@ -492,7 +492,7 @@ extend self: Resolver {
     resolveSignature(signature: Signature, topLevel: Bool, isInstanceMethod: Bool): Signature {
         if(self.lspHook.isAt(signature.at) || self.lspHook.isDefinedAt(signature.at)) {
             self.lspHook.emit(
-                ResolveSignatureHook(signature, isInstanceMethod)
+                ResolveSignatureHook(signature, isInstanceMethod, topLevel = topLevel)
             )
         }
         let newSignature = if(topLevel) {

package/compiler/Syntax.ff

@@ -9,6 +9,7 @@ extend self: Location {
 }
 
 data CompileError(at: Location, message: String)
+data CompileErrors(errors: List[CompileError])
 
 data ModuleWithPackageInfo(
     packageInfo: Option[PackageInfo]

package/core/Array.ff

@@ -35,10 +35,7 @@ extend self[T]: Array[T] {
 
     grab(index: Int): T
         target js sync """
-            if(index_ < 0 || index_ >= self_.array.length) {
-                ff_core_Try.internalThrowGrabException_()
-            }
-            return self_.array[index_]
+            return self_.array[index_] ?? internalGrab_(self_, index_);
         """
 
     grabFirst(): T {self.grab(0)}
@@ -261,3 +258,8 @@ sortRange[T](array: Array[T], compare: (T, T) => Ordering, start: Int, end: Int)
         }
     }
 }
+
+internalGrab[T](self: Array[T], index: Int): T
+    target js sync """
+        return index_ < 0 || index_ >= self_.array.length ? ff_core_Try.internalThrowGrabException_() : self_.array[index_];
+    """

package/core/Int.ff

@@ -27,23 +27,23 @@ extend self: Int {
         target js sync "return signed_ ? self_ >> bits_ : self_ >>> bits_;"
 
     to(inclusiveEnd: Int): List[Int] {
-        mutable result = []
-        mutable n = inclusiveEnd
-        while {self <= n} {
-            result = [n, ...result]
-            n -= 1
+        let result = Array.make()
+        mutable n = self
+        while {n <= inclusiveEnd} {
+            result.push(n)
+            n += 1
         }
-        result
+        result.drain()
     }
 
     until(exclusiveEnd: Int): List[Int] {
-        mutable result = []
-        mutable n = exclusiveEnd
-        while {self < n} {
-            result = [n - 1, ...result]
-            n -= 1
+        let result = Array.make()
+        mutable n = self
+        while {n < exclusiveEnd} {
+            result.push(n)
+            n += 1
         }
-        result
+        result.drain()
     }
 
     min(that: Int): Int {