firefly-compiler 0.4.19 → 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

@@ -66,11 +66,23 @@ data SymbolHook(
 
 class Box[T](mutable value: T)
 
+data DocumentSymbolKind {
+    SLet(mutable: Bool)
+    SFunction(member: Bool)
+    SExtend
+    STraitFunction
+    STrait
+    SInstance
+    SVariant
+    SType
+    SParameter
+}
+
 class ResultHook {
     ParseSymbolBegin
     ParseSymbolEnd(
         name: String
-        kind: Int
+        kind: DocumentSymbolKind
         selectionStart: Location
         selectionEnd: Location
         start: Location
@@ -84,6 +96,7 @@ class ResultHook {
     ResolveSymbolHook(
         symbol: SymbolHook
         annotation: Option[Type]
+        topLevel: Bool
     )
     ResolveTypeHook(
         types: Map[String, String]
@@ -98,6 +111,7 @@ class ResultHook {
     ResolveSignatureHook(
         signature: Signature
         isInstanceMethod: Bool
+        topLevel: Bool
     )
     ResolveVariantFieldHook(
         symbol: SymbolHook
@@ -181,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/Parser.ff

@@ -232,7 +232,7 @@ extend self: Parser {
         if(self.lspHook.trackSymbols) {
             self.lspHook.emit(ParseSymbolEnd(
                 name = nameToken.raw()
-                kind = 14
+                kind = SLet(mutable = False)
                 selectionStart = nameToken.at()
                 selectionEnd = nameToken.end()
                 start = nameToken.at()
@@ -254,10 +254,9 @@ extend self: Parser {
             bestTarget
         )
         if(self.lspHook.trackSymbols) {
-            let kind = if(member) {6} else {12}
             self.lspHook.emit(ParseSymbolEnd(
                 name = signature.name
-                kind = kind
+                kind = SFunction(member)
                 selectionStart = signature.at
                 selectionEnd = signature.at.Location(column = signature.at.column + signature.name.size())
                 start = signature.at
@@ -365,7 +364,7 @@ extend self: Parser {
             }
             self.lspHook.emit(ParseSymbolEnd(
                 name = name
-                kind = 3 // Namespace
+                kind = SExtend
                 selectionStart = nameToken.at()
                 selectionEnd = nameToken.end()
                 start = extendToken.at()
@@ -411,7 +410,7 @@ extend self: Parser {
                 if(self.lspHook.trackSymbols) {
                     self.lspHook.emit(ParseSymbolEnd(
                         name = signatureNameToken.raw() 
-                        kind = 12  // Function   
+                        kind = STraitFunction
                         selectionStart = signatureNameToken.at()
                         selectionEnd = signatureNameToken.end()
                         start = signatureNameToken.at()
@@ -436,7 +435,7 @@ extend self: Parser {
         if(self.lspHook.trackSymbols) {
             self.lspHook.emit(ParseSymbolEnd(
                 name = nameToken.raw() 
-                kind = 11 // Interface 
+                kind = STrait 
                 selectionStart = nameToken.at()
                 selectionEnd = nameToken.end()
                 start = traitToken.at()
@@ -487,7 +486,7 @@ extend self: Parser {
             let name = token.raw() + ": " + nameToken.raw()
             self.lspHook.emit(ParseSymbolEnd(
                 name = name
-                kind = 19 // Object  
+                kind = SInstance  
                 selectionStart = nameToken.at()
                 selectionEnd = nameToken.end()
                 start = instanceToken.at()
@@ -545,7 +544,7 @@ extend self: Parser {
                 if(self.lspHook.trackSymbols) {
                     self.lspHook.emit(ParseSymbolEnd(
                         name = variantNameToken.raw()
-                        kind = 10 // Enum
+                        kind = SVariant
                         selectionStart = variantNameToken.at()
                         selectionEnd = variantNameToken.end()
                         start = variantNameToken.at()
@@ -571,7 +570,7 @@ extend self: Parser {
         if(self.lspHook.trackSymbols) {
             self.lspHook.emit(ParseSymbolEnd(
                 name = nameToken.raw()
-                kind = 5
+                kind = SType
                 selectionStart = nameToken.at()
                 selectionEnd = nameToken.end()
                 start = kindToken.at()
@@ -770,7 +769,7 @@ extend self: Parser {
             if(lspTrackSymbols) {
                 self.lspHook.emit(ParseSymbolEnd(
                     name = parameterNameToken.raw()
-                    kind = 7 // Property
+                    kind = SParameter
                     selectionStart = parameterNameToken.at()
                     selectionEnd = parameterNameToken.end()
                     start = lspFirst.at()
@@ -1059,10 +1058,9 @@ extend self: Parser {
         self.skip(LAssign)
         let value = self.parseTerm()
         if(self.lspHook.trackSymbols) {
-            let kind = if(mutable) {13} else {14}
             self.lspHook.emit(ParseSymbolEnd(
                 name = nameToken.raw()
-                kind = kind
+                kind = SLet(mutable)
                 selectionStart = nameToken.at()
                 selectionEnd = nameToken.end()
                 start = mutableToken.at()
@@ -1095,7 +1093,7 @@ extend self: Parser {
             if(self.lspHook.trackSymbols) {
                 self.lspHook.emit(ParseSymbolEnd(
                     name = signature.name
-                    kind = 12
+                    kind = SFunction(member = False)
                     selectionStart = signature.at
                     selectionEnd = signature.at.Location(column = signature.at.column + signature.name.size())
                     start = functionAt