firefly-compiler 0.5.44 → 0.5.46

package/bin/firefly.mjs

@@ -1,2 +1,2 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 import * as firefly from '../output/js/ff/compiler/Main.mjs';

package/compiler/Inference.ff

@@ -32,11 +32,21 @@ extend self: Inference {
         let environment = Environment.new(module, otherModules, alreadyFlat = False)
 
         let errors = Array.new()
-        let traits = catchManyInto(errors, module.traits) {self.inferTraitDefinition(environment, _)}
-        let instances = catchManyInto(errors, module.instances) {self.inferInstanceDefinition(environment, _)}
-        let lets = catchManyInto(errors, module.lets) {self.inferLetDefinition(environment, _)}
-        let functions = catchManyInto(errors, module.functions) {self.inferFunctionDefinition(environment, _)}
-        let extends = catchManyInto(errors, module.extends) {self.inferExtendDefinition(environment, _)}
+        let traits = Syntax.catchManyInto(errors, module.traits) {
+            self.inferTraitDefinition(environment, _)
+        }
+        let instances = Syntax.catchManyInto(errors, module.instances) {
+            self.inferInstanceDefinition(environment, _)
+        }
+        let lets = Syntax.catchManyInto(errors, module.lets) {
+            self.inferLetDefinition(environment, _)
+        }
+        let functions = Syntax.catchManyInto(errors, module.functions) {
+            self.inferFunctionDefinition(environment, _)
+        }
+        let extends = Syntax.catchManyInto(errors, module.extends) {
+            self.inferExtendDefinition(environment, _)
+        }
         errors.drain().{
             | [] =>
             | [Pair(_, error)] => error.rethrow()
@@ -96,7 +106,7 @@ extend self: Inference {
             }
             
             definition.DInstance(
-                methods = catchMany(definition.methods) {instanceFunction =>
+                methods = Syntax.catchMany(definition.methods) {instanceFunction =>
                     let methodName = instanceFunction.signature.name
                     let traitMethodName = traitName.reverse().dropWhile {_ != '.'}.reverse() + methodName
                     let traitMethodScheme = environment.symbols.get(traitMethodName).else {
@@ -150,7 +160,7 @@ extend self: Inference {
             valueType = definition.type
             default = None
         )
-        let functions = catchMany(definition.methods) {method =>
+        let functions = Syntax.catchMany(definition.methods) {method =>
             let signature = method.signature.Signature(
                 generics = [...definition.generics, ...method.signature.generics]
                 constraints = [...definition.constraints, ...method.signature.constraints]
@@ -1223,30 +1233,3 @@ constraintsToInstances(constraints: List[Constraint]): Map[InstanceKey, Instance
         )
     }.toMap()
 }
-
-catchMany[T](list: List[T], body: T => T): List[T] {
-    let errors = Array.new()
-    let result = catchManyInto(errors, list, body)
-    errors.drain().{
-        | [] => result
-        | [Pair(_, error)] => error.rethrow()
-        | allErrors => throw(CompileErrors(allErrors.map {_.first}))
-    }
-}
-
-catchManyInto[T](errors: Array[Pair[CompileError, Error]], list: List[T], body: T => T): List[T] {
-    let result = list.map {x =>
-        try {
-            body(x)
-        } tryCatch {| CompileError(at, message), error =>
-            errors.push(Pair(CompileError(at, message), error))
-            x
-        } catch {| CompileErrors(compileErrors), error =>
-            compileErrors.each {compileError => 
-                errors.push(Pair(compileError, error))
-            }
-            x
-        }
-    }
-    if(errors.isEmpty()) {result} else {[]}
-}

package/compiler/Main.ff

@@ -18,6 +18,7 @@ data MainCommand {
     BrowserCommand(mainPath: String)
     BuildCommand(mainPath: String)
     CheckCommand(filePath: String)
+    SymbolsCommand(outPath: String, filePaths: List[String])
 }
 
 data CommandLineError(problem: String)
@@ -143,6 +144,21 @@ main(system: NodeSystem): Unit {
                 printMeasurements = True
                 moduleCache = ModuleCache.new(0)
             )
+            
+        | SymbolsCommand(outPath, filePaths) =>
+            let columns = filePaths.flatMap {filePath =>
+                let path = system.path(filePath)
+                let code = path.readText()
+                let packagePair = PackagePair("script", "script")
+                let tokens = Tokenizer.tokenize(path.absolute(), code, None, False)
+                let parser = Parser.new(packagePair, path.base(), tokens, True, LspHook.disabled())
+                let module = parser.parseModuleWithPackageInfo().module
+                makeSymbolColumns(module)
+            }
+            let rowCount = columns.sortBy {_.size()}.last().map {_.size()}.else {0}
+            let tsv = 0.until(rowCount).map {i => columns.map {_.get(i).else {""}}}
+            system.path(outPath).writeText(tsv.map {_.join("\t")}.join("\n") + "\n")
+            
     }
 
     try {
@@ -169,6 +185,7 @@ These are the commands:
    browser <main-file>                   Compile the main file for the browser
    build <main-file>                     Build the main file
    check <firefly-file>                  Check the firefly source file for errors
+   symbols <firefly-file>                Print a .tsv with the symbols of a firefly source file
    bootstrap                             Bootstrap the compiler
 """
 
@@ -180,7 +197,7 @@ parseCommandLine(arguments: List[String]): MainCommand {
             | [mainFile, ...mainArguments] {mainFile.removeLast(".ff") | Some(mainName)} =>
                 RunCommand(mainName, mainArguments)
             | _ => throw(CommandLineError(
-                "You must specify a Firefly file (.ff) as first argument to run."  + usageString
+                "You must specify a Firefly file (.ff) as first argument to run." + usageString
             ))
         }
     | ["browser", ...browserArguments] =>
@@ -188,10 +205,10 @@ parseCommandLine(arguments: List[String]): MainCommand {
             | [mainFile] {mainFile.removeLast(".ff") | Some(mainName)} =>
                 BrowserCommand(mainName)
             | [_, _, ...] => throw(CommandLineError(
-                "You must only specify a single argument to browser."  + usageString
+                "You must only specify a single argument to browser." + usageString
             ))
             | _ => throw(CommandLineError(
-                "You must specify a Firefly file (.ff) as the argument to browser."  + usageString
+                "You must specify a Firefly file (.ff) as the argument to browser." + usageString
             ))
         }
     | ["build", ...buildArguments] =>
@@ -199,10 +216,10 @@ parseCommandLine(arguments: List[String]): MainCommand {
             | [mainFile] {mainFile.removeLast(".ff") | Some(mainName)} =>
                 BuildCommand(mainName)
             | [_, _, ...] => throw(CommandLineError(
-                "You must only specify a single argument to build."  + usageString
+                "You must only specify a single argument to build." + usageString
             ))
             | _ => throw(CommandLineError(
-                "You must specify a Firefly file (.ff) as the argument to build."  + usageString
+                "You must specify a Firefly file (.ff) as the argument to build." + usageString
             ))
         }
     | ["check", ...checkArguments] =>
@@ -210,10 +227,18 @@ parseCommandLine(arguments: List[String]): MainCommand {
             | [fileName] =>
                 CheckCommand(fileName)
             | [_, _, ...] => throw(CommandLineError(
-                "You must only specify a single argument to check."  + usageString
+                "You must only specify a single argument to check." + usageString
             ))
             | [] => throw(CommandLineError(
-                "You must specify a Firefly file (.ff) or directory as the argument to check."  + usageString
+                "You must specify a Firefly file (.ff) or directory as the argument to check." + usageString
+            ))
+        }
+    | ["symbols", ...checkArguments] =>
+        checkArguments.{
+            | [outName, fileName, ...fileNames] {outName.endsWith(".tsv")} =>
+                SymbolsCommand(outName, [fileName, ...fileNames])
+            | _ => throw(CommandLineError(
+                "You must specify a output file (.tsv) and 1+ Firefly files (.ff) to symbols." + usageString
             ))
         }
     | ["bootstrap", _] =>
@@ -284,3 +309,39 @@ detectFireflyPath(system: NodeSystem): Path {
         Path(url->fileURLToPath(Js->URL->(moduleUrl->slice(0, -suffix.size())))?)
     }
 }
+
+makeSymbolColumns(module: Module): List[List[String]] {
+    function processSignature(signature: Signature): String {
+        let generics = if(signature.generics.isEmpty()) {""} else {"[" + signature.generics.join(", ") + "]"}
+        let parameters = "(" + signature.parameters.map {_.name}.join(", ") + ")"
+        signature.name + generics + parameters
+    }
+    let traits = module.traits.map {x =>
+        let generics = x.generics.dropFirst()
+        let g = x.generics.first().map {_ + ": "}.else {""}
+        (name = g + x.name, generics = generics, symbols = x.methods.map {processSignature(_)})
+    }
+    let types = module.types.map {x =>
+        let variants = x.variants.map {variant =>
+            let parameters = if(variant.fields.isEmpty() && x.commonFields.isEmpty()) {""} else {
+                "(" + [...x.commonFields, ...variant.fields].map {_.name}.join(", ") + ")"
+            }
+            variant.name + parameters
+        }
+        let methods = module.extends.filter {_.type.{
+            | TConstructor(_, name, _) => name == x.name
+            | _ => False
+        }}.flatMap {_.methods}.map {_.signature}.map {processSignature(_)}
+        (name = x.name, generics = x.generics, symbols = [...variants, ...methods])
+    }
+    let toplevel = if(module.functions.isEmpty()) {[]} else {
+        let functions = module.functions.map {processSignature(_.signature)}
+        [(name = "", generics = [], symbols = [...module.lets.map {_.name}, ...functions])]
+    }
+    let all = [...toplevel, ...types, ...traits]
+    all.map {r => 
+        let generics = if(r.generics.isEmpty()) {""} else {"[" + r.generics.join(", ") + "]"}
+        let header = (module.file + " " + r.name + generics).trim()
+        [header, ...r.symbols.sort()]
+    }
+}

package/compiler/Resolver.ff

@@ -58,16 +58,27 @@ extend self: Resolver {
             module.file.replace("\\", "/").reverse().takeWhile {_ != '/'}.reverse().takeWhile {_ != '.'}
         let self2 = self.processImports(module.imports, otherModules)
         let self3 = self2.processDefinitions(module, None)
+        
+        let errors = Array.new()
         let module2 = module.Module(
-            types = checkDuplicates(module.types.map {self3.resolveTypeDefinition(_)}) {_.name} {_.at}
-            traits = checkDuplicates(module.traits.map {self3.resolveTraitDefinition(_)}) {_.name} {_.at}
-            instances = module.instances.map {self3.resolveInstanceDefinition(_)}
-            extends = module.extends.map {self3.resolveExtendDefinition(_)}
-            lets = checkDuplicates(module.lets.map {self3.resolveLetDefinition(_, True)}) {_.name} {_.at}
-            functions = checkDuplicates(
-                module.functions.map {self3.resolveFunctionDefinition(_, True, False)}
-            ) {_.signature.name} {_.at}
+            types = Syntax.catchManyInto(errors, module.types) {self3.resolveTypeDefinition(_)}
+            traits = Syntax.catchManyInto(errors, module.traits) {self3.resolveTraitDefinition(_)}
+            instances = Syntax.catchManyInto(errors, module.instances) {self3.resolveInstanceDefinition(_)}
+            extends = Syntax.catchManyInto(errors, module.extends) {self3.resolveExtendDefinition(_)}
+            lets = Syntax.catchManyInto(errors, module.lets) {self3.resolveLetDefinition(_, True)}
+            functions = Syntax.catchManyInto(errors, module.functions) {
+                self3.resolveFunctionDefinition(_, True, False)
+            }
         )
+        errors.drain().{
+            | [] =>
+            | [Pair(_, error)] => error.rethrow()
+            | allErrors => throw(CompileErrors(allErrors.map {_.first}))
+        }   
+        checkDuplicates(module2.types) {_.name} {_.at}
+        checkDuplicates(module2.traits) {_.name} {_.at}
+        checkDuplicates(module2.lets) {_.name} {_.at}
+        checkDuplicates(module2.functions) {_.signature.name} {_.at}
         let groupedExtendMethods = module2.extends.map {x => 
             Pair(x.type.show([]).takeWhile {_.isAsciiLetterOrDigit()}, x.methods)
         }.group()

package/compiler/Syntax.ff

@@ -283,3 +283,30 @@ extend self: Type {
         go(self)
     }
 }
+
+catchMany[T](list: List[T], body: T => T): List[T] {
+    let errors = Array.new()
+    let result = catchManyInto(errors, list, body)
+    errors.drain().{
+        | [] => result
+        | [Pair(_, error)] => error.rethrow()
+        | allErrors => throw(CompileErrors(allErrors.map {_.first}))
+    }
+}
+
+catchManyInto[T](errors: Array[Pair[CompileError, Error]], list: List[T], body: T => T): List[T] {
+    let result = list.map {x =>
+        try {
+            body(x)
+        } tryCatch {| CompileError(at, message), error =>
+            errors.push(Pair(CompileError(at, message), error))
+            x
+        } catch {| CompileErrors(compileErrors), error =>
+            compileErrors.each {compileError => 
+                errors.push(Pair(compileError, error))
+            }
+            x
+        }
+    }
+    if(errors.isEmpty()) {result} else {[]}
+}

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

@@ -142,59 +142,6 @@ return ff_core_Pair.Pair(ff_compiler_Unification.InstanceKey(c_.name_, typeName_
 })), ff_compiler_Unification.ff_core_Ordering_Order$ff_compiler_Unification_InstanceKey)
 }
 
-export function catchMany_(list_, body_) {
-const errors_ = ff_core_Array.new_();
-const result_ = ff_compiler_Inference.catchManyInto_(errors_, list_, body_);
-{
-const _1 = ff_core_Array.Array_drain(errors_);
-if(_1.length === 0) {
-return result_
-}
-if(_1.length === 1) {
-const error_ = _1[0].second_;
-return ff_core_Error.Error_rethrow(error_)
-}
-{
-const allErrors_ = _1;
-throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileErrors(ff_core_List.List_map(allErrors_, ((_w1) => {
-return _w1.first_
-}))), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors)})
-return
-}
-}
-}
-
-export function catchManyInto_(errors_, list_, body_) {
-const result_ = ff_core_List.List_map(list_, ((x_) => {
-return ff_core_Try.Try_catch(ff_core_Try.Try_tryCatch(ff_core_Core.try_((() => {
-return body_(x_)
-})), ((_1, _2) => {
-{
-const at_ = _1.at_;
-const message_ = _1.message_;
-const error_ = _2;
-errors_.array.push(ff_core_Pair.Pair(ff_compiler_Syntax.CompileError(at_, message_), error_));
-return x_
-}
-}), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError), ((_1, _2) => {
-{
-const compileErrors_ = _1.errors_;
-const error_ = _2;
-for(let for_a = compileErrors_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
-const compileError_ = for_a[for_i];
-errors_.array.push(ff_core_Pair.Pair(compileError_, error_))
-};
-return x_
-}
-}), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors)
-}));
-if(ff_core_Array.Array_isEmpty(errors_)) {
-return result_
-} else {
-return []
-}
-}
-
 export async function new_$(modules_, lspHook_, $task) {
 return ff_compiler_Inference.Inference(ff_compiler_Unification.new_(modules_, ff_compiler_LspHook.LspHook_isEnabled(lspHook_)), ff_core_StringMap.new_(), lspHook_)
 }
@@ -224,75 +171,22 @@ return ff_core_Pair.Pair(ff_compiler_Unification.InstanceKey(c_.name_, typeName_
 })), ff_compiler_Unification.ff_core_Ordering_Order$ff_compiler_Unification_InstanceKey)
 }
 
-export async function catchMany_$(list_, body_, $task) {
-const errors_ = ff_core_Array.new_();
-const result_ = (await ff_compiler_Inference.catchManyInto_$(errors_, list_, body_, $task));
-{
-const _1 = ff_core_Array.Array_drain(errors_);
-if(_1.length === 0) {
-return result_
-}
-if(_1.length === 1) {
-const error_ = _1[0].second_;
-return ff_core_Error.Error_rethrow(error_)
-}
-{
-const allErrors_ = _1;
-throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileErrors(ff_core_List.List_map(allErrors_, ((_w1) => {
-return _w1.first_
-}))), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors)})
-return
-}
-}
-}
-
-export async function catchManyInto_$(errors_, list_, body_, $task) {
-const result_ = (await ff_core_List.List_map$(list_, (async (x_, $task) => {
-return ff_core_Try.Try_catch(ff_core_Try.Try_tryCatch((await ff_core_Core.try_$((async ($task) => {
-return (await body_(x_, $task))
-}), $task)), ((_1, _2) => {
-{
-const at_ = _1.at_;
-const message_ = _1.message_;
-const error_ = _2;
-errors_.array.push(ff_core_Pair.Pair(ff_compiler_Syntax.CompileError(at_, message_), error_));
-return x_
-}
-}), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError), ((_1, _2) => {
-{
-const compileErrors_ = _1.errors_;
-const error_ = _2;
-for(let for_a = compileErrors_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
-const compileError_ = for_a[for_i];
-errors_.array.push(ff_core_Pair.Pair(compileError_, error_))
-};
-return x_
-}
-}), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors)
-}), $task));
-if(ff_core_Array.Array_isEmpty(errors_)) {
-return result_
-} else {
-return []
-}
-}
-
 export function Inference_inferModule(self_, module_, otherModules_) {
 const environment_ = ff_compiler_Environment.new_(module_, otherModules_, false);
 const errors_ = ff_core_Array.new_();
-const traits_ = ff_compiler_Inference.catchManyInto_(errors_, module_.traits_, ((_w1) => {
+const traits_ = ff_compiler_Syntax.catchManyInto_(errors_, module_.traits_, ((_w1) => {
 return ff_compiler_Inference.Inference_inferTraitDefinition(self_, environment_, _w1)
 }));
-const instances_ = ff_compiler_Inference.catchManyInto_(errors_, module_.instances_, ((_w1) => {
+const instances_ = ff_compiler_Syntax.catchManyInto_(errors_, module_.instances_, ((_w1) => {
 return ff_compiler_Inference.Inference_inferInstanceDefinition(self_, environment_, _w1)
 }));
-const lets_ = ff_compiler_Inference.catchManyInto_(errors_, module_.lets_, ((_w1) => {
+const lets_ = ff_compiler_Syntax.catchManyInto_(errors_, module_.lets_, ((_w1) => {
 return ff_compiler_Inference.Inference_inferLetDefinition(self_, environment_, _w1)
 }));
-const functions_ = ff_compiler_Inference.catchManyInto_(errors_, module_.functions_, ((_w1) => {
+const functions_ = ff_compiler_Syntax.catchManyInto_(errors_, module_.functions_, ((_w1) => {
 return ff_compiler_Inference.Inference_inferFunctionDefinition(self_, environment_, _w1)
 }));
-const extends_ = ff_compiler_Inference.catchManyInto_(errors_, module_.extends_, ((_w1) => {
+const extends_ = ff_compiler_Syntax.catchManyInto_(errors_, module_.extends_, ((_w1) => {
 return ff_compiler_Inference.Inference_inferExtendDefinition(self_, environment_, _w1)
 }));
 do {
@@ -361,7 +255,7 @@ throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Sy
 const _1 = definition_;
 {
 const _c = _1;
-return ff_compiler_Syntax.DInstance(_c.at_, _c.generics_, _c.constraints_, _c.traitName_, _c.typeArguments_, _c.generatorArguments_, ff_compiler_Inference.catchMany_(definition_.methods_, ((instanceFunction_) => {
+return ff_compiler_Syntax.DInstance(_c.at_, _c.generics_, _c.constraints_, _c.traitName_, _c.typeArguments_, _c.generatorArguments_, ff_compiler_Syntax.catchMany_(definition_.methods_, ((instanceFunction_) => {
 const methodName_ = instanceFunction_.signature_.name_;
 const traitMethodName_ = (ff_core_String.String_reverse(ff_core_String.String_dropWhile(ff_core_String.String_reverse(traitName_), ((_w1) => {
 return (_w1 !== 46)
@@ -420,7 +314,7 @@ return ff_compiler_Syntax.DLet(_c.at_, _c.name_, _c.variableType_, value_)
 
 export function Inference_inferExtendDefinition(self_, environment_, definition_) {
 const selfParameter_ = ff_compiler_Syntax.Parameter(definition_.at_, false, definition_.name_, definition_.type_, ff_core_Option.None());
-const functions_ = ff_compiler_Inference.catchMany_(definition_.methods_, ((method_) => {
+const functions_ = ff_compiler_Syntax.catchMany_(definition_.methods_, ((method_) => {
 const signature_ = (((_c) => {
 return ff_compiler_Syntax.Signature(_c.at_, _c.name_, _c.member_, [...definition_.generics_, ...method_.signature_.generics_], [...definition_.constraints_, ...method_.signature_.constraints_], [selfParameter_, ...method_.signature_.parameters_], _c.returnType_, _c.effect_)
 }))(method_.signature_);
@@ -2197,19 +2091,19 @@ return instantiated_
 export async function Inference_inferModule$(self_, module_, otherModules_, $task) {
 const environment_ = ff_compiler_Environment.new_(module_, otherModules_, false);
 const errors_ = ff_core_Array.new_();
-const traits_ = ff_compiler_Inference.catchManyInto_(errors_, module_.traits_, ((_w1) => {
+const traits_ = ff_compiler_Syntax.catchManyInto_(errors_, module_.traits_, ((_w1) => {
 return ff_compiler_Inference.Inference_inferTraitDefinition(self_, environment_, _w1)
 }));
-const instances_ = ff_compiler_Inference.catchManyInto_(errors_, module_.instances_, ((_w1) => {
+const instances_ = ff_compiler_Syntax.catchManyInto_(errors_, module_.instances_, ((_w1) => {
 return ff_compiler_Inference.Inference_inferInstanceDefinition(self_, environment_, _w1)
 }));
-const lets_ = ff_compiler_Inference.catchManyInto_(errors_, module_.lets_, ((_w1) => {
+const lets_ = ff_compiler_Syntax.catchManyInto_(errors_, module_.lets_, ((_w1) => {
 return ff_compiler_Inference.Inference_inferLetDefinition(self_, environment_, _w1)
 }));
-const functions_ = ff_compiler_Inference.catchManyInto_(errors_, module_.functions_, ((_w1) => {
+const functions_ = ff_compiler_Syntax.catchManyInto_(errors_, module_.functions_, ((_w1) => {
 return ff_compiler_Inference.Inference_inferFunctionDefinition(self_, environment_, _w1)
 }));
-const extends_ = ff_compiler_Inference.catchManyInto_(errors_, module_.extends_, ((_w1) => {
+const extends_ = ff_compiler_Syntax.catchManyInto_(errors_, module_.extends_, ((_w1) => {
 return ff_compiler_Inference.Inference_inferExtendDefinition(self_, environment_, _w1)
 }));
 do {
@@ -2278,7 +2172,7 @@ throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Sy
 const _1 = definition_;
 {
 const _c = _1;
-return ff_compiler_Syntax.DInstance(_c.at_, _c.generics_, _c.constraints_, _c.traitName_, _c.typeArguments_, _c.generatorArguments_, ff_compiler_Inference.catchMany_(definition_.methods_, ((instanceFunction_) => {
+return ff_compiler_Syntax.DInstance(_c.at_, _c.generics_, _c.constraints_, _c.traitName_, _c.typeArguments_, _c.generatorArguments_, ff_compiler_Syntax.catchMany_(definition_.methods_, ((instanceFunction_) => {
 const methodName_ = instanceFunction_.signature_.name_;
 const traitMethodName_ = (ff_core_String.String_reverse(ff_core_String.String_dropWhile(ff_core_String.String_reverse(traitName_), ((_w1) => {
 return (_w1 !== 46)
@@ -2337,7 +2231,7 @@ return ff_compiler_Syntax.DLet(_c.at_, _c.name_, _c.variableType_, value_)
 
 export async function Inference_inferExtendDefinition$(self_, environment_, definition_, $task) {
 const selfParameter_ = ff_compiler_Syntax.Parameter(definition_.at_, false, definition_.name_, definition_.type_, ff_core_Option.None());
-const functions_ = ff_compiler_Inference.catchMany_(definition_.methods_, ((method_) => {
+const functions_ = ff_compiler_Syntax.catchMany_(definition_.methods_, ((method_) => {
 const signature_ = (((_c) => {
 return ff_compiler_Syntax.Signature(_c.at_, _c.name_, _c.member_, [...definition_.generics_, ...method_.signature_.generics_], [...definition_.constraints_, ...method_.signature_.constraints_], [selfParameter_, ...method_.signature_.parameters_], _c.returnType_, _c.effect_)
 }))(method_.signature_);

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

@@ -139,6 +139,9 @@ return {BuildCommand: true, mainPath_};
 export function CheckCommand(filePath_) {
 return {CheckCommand: true, filePath_};
 }
+export function SymbolsCommand(outPath_, filePaths_) {
+return {SymbolsCommand: true, outPath_, filePaths_};
+}
 
 // type CommandLineError
 export function CommandLineError(problem_) {
@@ -153,6 +156,7 @@ These are the commands:
    browser <main-file>                   Compile the main file for the browser
    build <main-file>                     Build the main file
    check <firefly-file>                  Check the firefly source file for errors
+   symbols <firefly-file>                Print a .tsv with the symbols of a firefly source file
    bootstrap                             Bootstrap the compiler
 `;
 
@@ -226,12 +230,43 @@ throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Sy
 }
 return
 }
-{
+if(command_a.BootstrapCommand) {
 const workingDirectory_ = ff_core_NodeSystem.NodeSystem_path(system_, ".");
 const fakeLocation_ = ff_compiler_Syntax.Location("<core>", 0, 0);
 ff_compiler_Builder.build_(system_, ff_compiler_JsEmitter.EmitNode(), ff_compiler_Syntax.PackagePair("ff", "compiler"), "Main", ff_compiler_Dependencies.ResolvedDependencies(ff_compiler_Syntax.PackagePair("ff", "compiler"), ff_core_List.List_toMap([ff_core_Pair.Pair(ff_compiler_Syntax.PackagePair("ff", "core"), ff_compiler_Syntax.PackageInfo(ff_compiler_Syntax.DPackage(fakeLocation_, ff_compiler_Syntax.PackagePair("ff", "core"), ff_compiler_Syntax.Version(fakeLocation_, 0, 0, 0), ff_compiler_Syntax.TargetNames(true, false)), [], [ff_compiler_Syntax.DInclude(fakeLocation_, "node_modules")]))], ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair), ff_core_List.List_toMap([ff_core_Pair.Pair(ff_compiler_Syntax.PackagePair("ff", "compiler"), ff_core_Path.Path_slash(workingDirectory_, "compiler")), ff_core_Pair.Pair(ff_compiler_Syntax.PackagePair("ff", "core"), ff_core_Path.Path_slash(workingDirectory_, "core"))], ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair), ff_core_List.List_toSet([], ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair)), ff_core_Option.None(), ff_core_Path.Path_slash(ff_core_Path.Path_slash(workingDirectory_, "output"), "temporary"), ff_core_Path.Path_slash(ff_core_Path.Path_slash(workingDirectory_, "output"), "js"), true, ff_compiler_ModuleCache.new_(0))
 return
 }
+{
+const outPath_ = command_a.outPath_;
+const filePaths_ = command_a.filePaths_;
+const columns_ = ff_core_List.List_flatMap(filePaths_, ((filePath_) => {
+const path_ = ff_core_NodeSystem.NodeSystem_path(system_, filePath_);
+const code_ = ff_core_Path.Path_readText(path_);
+const packagePair_ = ff_compiler_Syntax.PackagePair("script", "script");
+const tokens_ = ff_compiler_Tokenizer.tokenize_(ff_core_Path.Path_absolute(path_), code_, ff_core_Option.None(), false);
+const parser_ = ff_compiler_Parser.new_(packagePair_, ff_core_Path.Path_base(path_), tokens_, true, ff_compiler_LspHook.disabled_());
+const module_ = ff_compiler_Parser.Parser_parseModuleWithPackageInfo(parser_).module_;
+return ff_compiler_Main.makeSymbolColumns_(module_)
+}));
+const rowCount_ = ff_core_Option.Option_else(ff_core_Option.Option_map(ff_core_List.List_last(ff_core_List.List_sortBy(columns_, ((_w1) => {
+return _w1.length
+}), ff_core_Ordering.ff_core_Ordering_Order$ff_core_Int_Int)), ((_w1) => {
+return _w1.length
+})), (() => {
+return 0
+}));
+const tsv_ = ff_core_List.List_map(ff_core_Int.Int_until(0, rowCount_), ((i_) => {
+return ff_core_List.List_map(columns_, ((_w1) => {
+return ff_core_Option.Option_else(ff_core_List.List_get(_w1, i_), (() => {
+return ""
+}))
+}))
+}));
+ff_core_Path.Path_writeText(ff_core_NodeSystem.NodeSystem_path(system_, outPath_), (ff_core_List.List_join(ff_core_List.List_map(tsv_, ((_w1) => {
+return ff_core_List.List_join(_w1, "\t")
+})), "\n") + "\n"))
+return
+}
 }
 ff_core_Try.Try_catch(ff_core_Try.Try_tryCatch(ff_core_Try.Try_tryCatch(ff_core_Core.try_((() => {
 const command_ = ff_compiler_Main.parseCommandLine_(ff_core_NodeSystem.NodeSystem_arguments(system_));
@@ -355,6 +390,24 @@ throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Ma
 }
 return
 }
+if(arguments_a.length >= 1 && arguments_a[0] === "symbols") {
+const checkArguments_ = arguments_a.slice(1);
+{
+const _1 = checkArguments_;
+if(_1.length >= 2) {
+const outName_ = _1[0];
+const fileName_ = _1[1];
+const fileNames_ = _1.slice(2);
+if(ff_core_String.String_endsWith(outName_, ".tsv")) {
+return ff_compiler_Main.SymbolsCommand(outName_, [fileName_, ...fileNames_])
+}
+}
+{
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Main.CommandLineError(("You must specify a output file (.tsv) and 1+ Firefly files (.ff) to symbols." + ff_compiler_Main.usageString_)), ff_compiler_Main.ff_core_Any_HasAnyTag$ff_compiler_Main_CommandLineError)})
+}
+}
+return
+}
 if(arguments_a.length === 2 && arguments_a[0] === "bootstrap") {
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Main.CommandLineError(("bootstrap takes no arguments" + ff_compiler_Main.usageString_)), ff_compiler_Main.ff_core_Any_HasAnyTag$ff_compiler_Main_CommandLineError)})
 }
@@ -423,6 +476,88 @@ return ff_core_Path.Path(url_.fileURLToPath((new URL(moduleUrl_.slice(0, (-suffi
 }
 }
 
+export function makeSymbolColumns_(module_) {
+function processSignature_(signature_) {
+const generics_ = (ff_core_List.List_isEmpty(signature_.generics_)
+? ""
+: (("[" + ff_core_List.List_join(signature_.generics_, ", ")) + "]"));
+const parameters_ = (("(" + ff_core_List.List_join(ff_core_List.List_map(signature_.parameters_, ((_w1) => {
+return _w1.name_
+})), ", ")) + ")");
+return ((signature_.name_ + generics_) + parameters_)
+}
+const traits_ = ff_core_List.List_map(module_.traits_, ((x_) => {
+const generics_ = ff_core_List.List_dropFirst(x_.generics_, 1);
+const g_ = ff_core_Option.Option_else(ff_core_Option.Option_map(ff_core_List.List_first(x_.generics_), ((_w1) => {
+return (_w1 + ": ")
+})), (() => {
+return ""
+}));
+return {
+generics_: generics_,
+name_: (g_ + x_.name_),
+symbols_: ff_core_List.List_map(x_.methods_, ((_w1) => {
+return processSignature_(_w1)
+}))
+}
+}));
+const types_ = ff_core_List.List_map(module_.types_, ((x_) => {
+const variants_ = ff_core_List.List_map(x_.variants_, ((variant_) => {
+const parameters_ = ((ff_core_List.List_isEmpty(variant_.fields_) && ff_core_List.List_isEmpty(x_.commonFields_))
+? ""
+: (("(" + ff_core_List.List_join(ff_core_List.List_map([...x_.commonFields_, ...variant_.fields_], ((_w1) => {
+return _w1.name_
+})), ", ")) + ")"));
+return (variant_.name_ + parameters_)
+}));
+const methods_ = ff_core_List.List_map(ff_core_List.List_map(ff_core_List.List_flatMap(ff_core_List.List_filter(module_.extends_, ((_w1) => {
+{
+const _1 = _w1.type_;
+if(_1.TConstructor) {
+const name_ = _1.name_;
+return (name_ === x_.name_)
+}
+{
+return false
+}
+}
+})), ((_w1) => {
+return _w1.methods_
+})), ((_w1) => {
+return _w1.signature_
+})), ((_w1) => {
+return processSignature_(_w1)
+}));
+return {
+generics_: x_.generics_,
+name_: x_.name_,
+symbols_: [...variants_, ...methods_]
+}
+}));
+const toplevel_ = (ff_core_List.List_isEmpty(module_.functions_)
+? []
+: (function() {
+const functions_ = ff_core_List.List_map(module_.functions_, ((_w1) => {
+return processSignature_(_w1.signature_)
+}));
+return [{
+generics_: [],
+name_: "",
+symbols_: [...ff_core_List.List_map(module_.lets_, ((_w1) => {
+return _w1.name_
+})), ...functions_]
+}]
+})());
+const all_ = [...toplevel_, ...types_, ...traits_];
+return ff_core_List.List_map(all_, ((r_) => {
+const generics_ = (ff_core_List.List_isEmpty(r_.generics_)
+? ""
+: (("[" + ff_core_List.List_join(r_.generics_, ", ")) + "]"));
+const header_ = ff_core_String.String_trim((((module_.file_ + " ") + r_.name_) + generics_));
+return [header_, ...ff_core_List.List_sort(r_.symbols_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String)]
+}))
+}
+
 export async function main_$(system_, $task) {
 const fireflyPath_ = (await ff_compiler_Main.detectFireflyPath_$(system_, $task));
 async function buildScript_$(mainFile_, mainPackagePair_, emitTarget_, resolvedDependencies_, $task) {
@@ -493,12 +628,43 @@ throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Sy
 }
 return
 }
-{
+if(command_a.BootstrapCommand) {
 const workingDirectory_ = (await ff_core_NodeSystem.NodeSystem_path$(system_, ".", $task));
 const fakeLocation_ = ff_compiler_Syntax.Location("<core>", 0, 0);
 (await ff_compiler_Builder.build_$(system_, ff_compiler_JsEmitter.EmitNode(), ff_compiler_Syntax.PackagePair("ff", "compiler"), "Main", ff_compiler_Dependencies.ResolvedDependencies(ff_compiler_Syntax.PackagePair("ff", "compiler"), ff_core_List.List_toMap([ff_core_Pair.Pair(ff_compiler_Syntax.PackagePair("ff", "core"), ff_compiler_Syntax.PackageInfo(ff_compiler_Syntax.DPackage(fakeLocation_, ff_compiler_Syntax.PackagePair("ff", "core"), ff_compiler_Syntax.Version(fakeLocation_, 0, 0, 0), ff_compiler_Syntax.TargetNames(true, false)), [], [ff_compiler_Syntax.DInclude(fakeLocation_, "node_modules")]))], ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair), ff_core_List.List_toMap([ff_core_Pair.Pair(ff_compiler_Syntax.PackagePair("ff", "compiler"), (await ff_core_Path.Path_slash$(workingDirectory_, "compiler", $task))), ff_core_Pair.Pair(ff_compiler_Syntax.PackagePair("ff", "core"), (await ff_core_Path.Path_slash$(workingDirectory_, "core", $task)))], ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair), ff_core_List.List_toSet([], ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair)), ff_core_Option.None(), (await ff_core_Path.Path_slash$((await ff_core_Path.Path_slash$(workingDirectory_, "output", $task)), "temporary", $task)), (await ff_core_Path.Path_slash$((await ff_core_Path.Path_slash$(workingDirectory_, "output", $task)), "js", $task)), true, ff_compiler_ModuleCache.new_(0), $task))
 return
 }
+{
+const outPath_ = command_a.outPath_;
+const filePaths_ = command_a.filePaths_;
+const columns_ = (await ff_core_List.List_flatMap$(filePaths_, (async (filePath_, $task) => {
+const path_ = (await ff_core_NodeSystem.NodeSystem_path$(system_, filePath_, $task));
+const code_ = (await ff_core_Path.Path_readText$(path_, $task));
+const packagePair_ = ff_compiler_Syntax.PackagePair("script", "script");
+const tokens_ = ff_compiler_Tokenizer.tokenize_((await ff_core_Path.Path_absolute$(path_, $task)), code_, ff_core_Option.None(), false);
+const parser_ = ff_compiler_Parser.new_(packagePair_, (await ff_core_Path.Path_base$(path_, $task)), tokens_, true, ff_compiler_LspHook.disabled_());
+const module_ = ff_compiler_Parser.Parser_parseModuleWithPackageInfo(parser_).module_;
+return ff_compiler_Main.makeSymbolColumns_(module_)
+}), $task));
+const rowCount_ = ff_core_Option.Option_else(ff_core_Option.Option_map(ff_core_List.List_last(ff_core_List.List_sortBy(columns_, ((_w1) => {
+return _w1.length
+}), ff_core_Ordering.ff_core_Ordering_Order$ff_core_Int_Int)), ((_w1) => {
+return _w1.length
+})), (() => {
+return 0
+}));
+const tsv_ = ff_core_List.List_map(ff_core_Int.Int_until(0, rowCount_), ((i_) => {
+return ff_core_List.List_map(columns_, ((_w1) => {
+return ff_core_Option.Option_else(ff_core_List.List_get(_w1, i_), (() => {
+return ""
+}))
+}))
+}));
+(await ff_core_Path.Path_writeText$((await ff_core_NodeSystem.NodeSystem_path$(system_, outPath_, $task)), (ff_core_List.List_join(ff_core_List.List_map(tsv_, ((_w1) => {
+return ff_core_List.List_join(_w1, "\t")
+})), "\n") + "\n"), $task))
+return
+}
 }
 ff_core_Try.Try_catch(ff_core_Try.Try_tryCatch(ff_core_Try.Try_tryCatch((await ff_core_Core.try_$((async ($task) => {
 const command_ = ff_compiler_Main.parseCommandLine_((await ff_core_NodeSystem.NodeSystem_arguments$(system_, $task)));
@@ -622,6 +788,24 @@ throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Ma
 }
 return
 }
+if(arguments_a.length >= 1 && arguments_a[0] === "symbols") {
+const checkArguments_ = arguments_a.slice(1);
+{
+const _1 = checkArguments_;
+if(_1.length >= 2) {
+const outName_ = _1[0];
+const fileName_ = _1[1];
+const fileNames_ = _1.slice(2);
+if(ff_core_String.String_endsWith(outName_, ".tsv")) {
+return ff_compiler_Main.SymbolsCommand(outName_, [fileName_, ...fileNames_])
+}
+}
+{
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Main.CommandLineError(("You must specify a output file (.tsv) and 1+ Firefly files (.ff) to symbols." + ff_compiler_Main.usageString_)), ff_compiler_Main.ff_core_Any_HasAnyTag$ff_compiler_Main_CommandLineError)})
+}
+}
+return
+}
 if(arguments_a.length === 2 && arguments_a[0] === "bootstrap") {
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Main.CommandLineError(("bootstrap takes no arguments" + ff_compiler_Main.usageString_)), ff_compiler_Main.ff_core_Any_HasAnyTag$ff_compiler_Main_CommandLineError)})
 }
@@ -690,6 +874,88 @@ return ff_core_Path.Path(url_.fileURLToPath((new URL(moduleUrl_.slice(0, (-suffi
 }
 }
 
+export async function makeSymbolColumns_$(module_, $task) {
+function processSignature_(signature_) {
+const generics_ = (ff_core_List.List_isEmpty(signature_.generics_)
+? ""
+: (("[" + ff_core_List.List_join(signature_.generics_, ", ")) + "]"));
+const parameters_ = (("(" + ff_core_List.List_join(ff_core_List.List_map(signature_.parameters_, ((_w1) => {
+return _w1.name_
+})), ", ")) + ")");
+return ((signature_.name_ + generics_) + parameters_)
+}
+const traits_ = ff_core_List.List_map(module_.traits_, ((x_) => {
+const generics_ = ff_core_List.List_dropFirst(x_.generics_, 1);
+const g_ = ff_core_Option.Option_else(ff_core_Option.Option_map(ff_core_List.List_first(x_.generics_), ((_w1) => {
+return (_w1 + ": ")
+})), (() => {
+return ""
+}));
+return {
+generics_: generics_,
+name_: (g_ + x_.name_),
+symbols_: ff_core_List.List_map(x_.methods_, ((_w1) => {
+return processSignature_(_w1)
+}))
+}
+}));
+const types_ = ff_core_List.List_map(module_.types_, ((x_) => {
+const variants_ = ff_core_List.List_map(x_.variants_, ((variant_) => {
+const parameters_ = ((ff_core_List.List_isEmpty(variant_.fields_) && ff_core_List.List_isEmpty(x_.commonFields_))
+? ""
+: (("(" + ff_core_List.List_join(ff_core_List.List_map([...x_.commonFields_, ...variant_.fields_], ((_w1) => {
+return _w1.name_
+})), ", ")) + ")"));
+return (variant_.name_ + parameters_)
+}));
+const methods_ = ff_core_List.List_map(ff_core_List.List_map(ff_core_List.List_flatMap(ff_core_List.List_filter(module_.extends_, ((_w1) => {
+{
+const _1 = _w1.type_;
+if(_1.TConstructor) {
+const name_ = _1.name_;
+return (name_ === x_.name_)
+}
+{
+return false
+}
+}
+})), ((_w1) => {
+return _w1.methods_
+})), ((_w1) => {
+return _w1.signature_
+})), ((_w1) => {
+return processSignature_(_w1)
+}));
+return {
+generics_: x_.generics_,
+name_: x_.name_,
+symbols_: [...variants_, ...methods_]
+}
+}));
+const toplevel_ = (ff_core_List.List_isEmpty(module_.functions_)
+? []
+: (await (async function() {
+const functions_ = ff_core_List.List_map(module_.functions_, ((_w1) => {
+return processSignature_(_w1.signature_)
+}));
+return [{
+generics_: [],
+name_: "",
+symbols_: [...ff_core_List.List_map(module_.lets_, ((_w1) => {
+return _w1.name_
+})), ...functions_]
+}]
+})()));
+const all_ = [...toplevel_, ...types_, ...traits_];
+return ff_core_List.List_map(all_, ((r_) => {
+const generics_ = (ff_core_List.List_isEmpty(r_.generics_)
+? ""
+: (("[" + ff_core_List.List_join(r_.generics_, ", ")) + "]"));
+const header_ = ff_core_String.String_trim((((module_.file_ + " ") + r_.name_) + generics_));
+return [header_, ...ff_core_List.List_sort(r_.symbols_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String)]
+}))
+}
+
 
 
 export const ff_core_Any_HasAnyTag$ff_compiler_Main_MainCommand = {
@@ -729,10 +995,14 @@ if(value_a.BuildCommand) {
 const z_ = value_a;
 return ((("BuildCommand" + "(") + ff_core_Show.ff_core_Show_Show$ff_core_String_String.show_(z_.mainPath_)) + ")")
 }
-{
+if(value_a.CheckCommand) {
 const z_ = value_a;
 return ((("CheckCommand" + "(") + ff_core_Show.ff_core_Show_Show$ff_core_String_String.show_(z_.filePath_)) + ")")
 }
+{
+const z_ = value_a;
+return ((((("SymbolsCommand" + "(") + ff_core_Show.ff_core_Show_Show$ff_core_String_String.show_(z_.outPath_)) + ", ") + ff_core_Show.ff_core_Show_Show$ff_core_List_List(ff_core_Show.ff_core_Show_Show$ff_core_String_String).show_(z_.filePaths_)) + ")")
+}
 },
 async show_$(value_, $task) {
 const value_a = value_;
@@ -752,10 +1022,14 @@ if(value_a.BuildCommand) {
 const z_ = value_a;
 return ((("BuildCommand" + "(") + ff_core_Show.ff_core_Show_Show$ff_core_String_String.show_(z_.mainPath_)) + ")")
 }
-{
+if(value_a.CheckCommand) {
 const z_ = value_a;
 return ((("CheckCommand" + "(") + ff_core_Show.ff_core_Show_Show$ff_core_String_String.show_(z_.filePath_)) + ")")
 }
+{
+const z_ = value_a;
+return ((((("SymbolsCommand" + "(") + ff_core_Show.ff_core_Show_Show$ff_core_String_String.show_(z_.outPath_)) + ", ") + ff_core_Show.ff_core_Show_Show$ff_core_List_List(ff_core_Show.ff_core_Show_Show$ff_core_String_String).show_(z_.filePaths_)) + ")")
+}
 }
 };
 
@@ -803,6 +1077,11 @@ const x_ = x_a;
 const y_ = y_a;
 return (x_.filePath_ === y_.filePath_)
 }
+if(x_a.SymbolsCommand && y_a.SymbolsCommand) {
+const x_ = x_a;
+const y_ = y_a;
+return ((x_.outPath_ === y_.outPath_) && ff_core_List.ff_core_Equal_Equal$ff_core_List_List(ff_core_Equal.ff_core_Equal_Equal$ff_core_String_String).equals_(x_.filePaths_, y_.filePaths_))
+}
 {
 return false
 }
@@ -833,6 +1112,11 @@ const x_ = x_a;
 const y_ = y_a;
 return (x_.filePath_ === y_.filePath_)
 }
+if(x_a.SymbolsCommand && y_a.SymbolsCommand) {
+const x_ = x_a;
+const y_ = y_a;
+return ((x_.outPath_ === y_.outPath_) && ff_core_List.ff_core_Equal_Equal$ff_core_List_List(ff_core_Equal.ff_core_Equal_Equal$ff_core_String_String).equals_(x_.filePaths_, y_.filePaths_))
+}
 {
 return false
 }
@@ -918,6 +1202,22 @@ return ff_core_Ordering.OrderingSame()
 }
 return
 }
+if(x_a.SymbolsCommand && y_a.SymbolsCommand) {
+const x_ = x_a;
+const y_ = y_a;
+const outPathOrdering_ = ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String.compare_(x_.outPath_, y_.outPath_);
+if((outPathOrdering_ !== ff_core_Ordering.OrderingSame())) {
+return outPathOrdering_
+} else {
+const filePathsOrdering_ = ff_core_Ordering.ff_core_Ordering_Order$ff_core_List_List(ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String).compare_(x_.filePaths_, y_.filePaths_);
+if((filePathsOrdering_ !== ff_core_Ordering.OrderingSame())) {
+return filePathsOrdering_
+} else {
+return ff_core_Ordering.OrderingSame()
+}
+}
+return
+}
 {
 function number_(z_) {
 const z_a = z_;
@@ -933,9 +1233,12 @@ return 2
 if(z_a.BuildCommand) {
 return 3
 }
-{
+if(z_a.CheckCommand) {
 return 4
 }
+{
+return 5
+}
 }
 return ff_core_Ordering.ff_core_Ordering_Order$ff_core_Int_Int.compare_(number_(x_), number_(y_))
 }
@@ -995,6 +1298,22 @@ return ff_core_Ordering.OrderingSame()
 }
 return
 }
+if(x_a.SymbolsCommand && y_a.SymbolsCommand) {
+const x_ = x_a;
+const y_ = y_a;
+const outPathOrdering_ = ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String.compare_(x_.outPath_, y_.outPath_);
+if((outPathOrdering_ !== ff_core_Ordering.OrderingSame())) {
+return outPathOrdering_
+} else {
+const filePathsOrdering_ = ff_core_Ordering.ff_core_Ordering_Order$ff_core_List_List(ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String).compare_(x_.filePaths_, y_.filePaths_);
+if((filePathsOrdering_ !== ff_core_Ordering.OrderingSame())) {
+return filePathsOrdering_
+} else {
+return ff_core_Ordering.OrderingSame()
+}
+}
+return
+}
 {
 function number_(z_) {
 const z_a = z_;
@@ -1010,9 +1329,12 @@ return 2
 if(z_a.BuildCommand) {
 return 3
 }
-{
+if(z_a.CheckCommand) {
 return 4
 }
+{
+return 5
+}
 }
 return ff_core_Ordering.ff_core_Ordering_Order$ff_core_Int_Int.compare_(number_(x_), number_(y_))
 }
@@ -1094,7 +1416,7 @@ serialization_.offset_ += 1;
 ff_core_Serializable.ff_core_Serializable_Serializable$ff_core_String_String.serializeUsing_(serialization_, v_.mainPath_)
 return
 }
-{
+if(value_a.CheckCommand) {
 const v_ = value_a;
 serialization_.checksum_ = ff_core_Int.Int_bitOr(((31 * serialization_.checksum_) + 29), 0);
 ff_core_Serializable.Serialization_autoResize(serialization_, 1);
@@ -1103,6 +1425,16 @@ serialization_.offset_ += 1;
 ff_core_Serializable.ff_core_Serializable_Serializable$ff_core_String_String.serializeUsing_(serialization_, v_.filePath_)
 return
 }
+{
+const v_ = value_a;
+serialization_.checksum_ = ff_core_Int.Int_bitOr(((31 * serialization_.checksum_) + 31), 0);
+ff_core_Serializable.Serialization_autoResize(serialization_, 1);
+ff_core_Buffer.Buffer_setUint8(serialization_.buffer_, serialization_.offset_, 5);
+serialization_.offset_ += 1;
+ff_core_Serializable.ff_core_Serializable_Serializable$ff_core_String_String.serializeUsing_(serialization_, v_.outPath_);
+ff_core_Serializable.ff_core_Serializable_Serializable$ff_core_List_List(ff_core_Serializable.ff_core_Serializable_Serializable$ff_core_String_String).serializeUsing_(serialization_, v_.filePaths_)
+return
+}
 },
 deserializeUsing_(serialization_) {
 const variantIndex_ = ff_core_Buffer.Buffer_grabUint8(serialization_.buffer_, serialization_.offset_);
@@ -1129,6 +1461,10 @@ if(_1 === 4) {
 serialization_.checksum_ = ff_core_Int.Int_bitOr(((31 * serialization_.checksum_) + 29), 0);
 return ff_compiler_Main.CheckCommand(ff_core_Serializable.ff_core_Serializable_Serializable$ff_core_String_String.deserializeUsing_(serialization_))
 }
+if(_1 === 5) {
+serialization_.checksum_ = ff_core_Int.Int_bitOr(((31 * serialization_.checksum_) + 31), 0);
+return ff_compiler_Main.SymbolsCommand(ff_core_Serializable.ff_core_Serializable_Serializable$ff_core_String_String.deserializeUsing_(serialization_), ff_core_Serializable.ff_core_Serializable_Serializable$ff_core_List_List(ff_core_Serializable.ff_core_Serializable_Serializable$ff_core_String_String).deserializeUsing_(serialization_))
+}
 {
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_core_Serializable.DeserializationChecksumException(), ff_core_Serializable.ff_core_Any_HasAnyTag$ff_core_Serializable_DeserializationChecksumException)})
 }
@@ -1173,7 +1509,7 @@ serialization_.offset_ += 1;
 ff_core_Serializable.ff_core_Serializable_Serializable$ff_core_String_String.serializeUsing_(serialization_, v_.mainPath_)
 return
 }
-{
+if(value_a.CheckCommand) {
 const v_ = value_a;
 serialization_.checksum_ = ff_core_Int.Int_bitOr(((31 * serialization_.checksum_) + 29), 0);
 ff_core_Serializable.Serialization_autoResize(serialization_, 1);
@@ -1182,6 +1518,16 @@ serialization_.offset_ += 1;
 ff_core_Serializable.ff_core_Serializable_Serializable$ff_core_String_String.serializeUsing_(serialization_, v_.filePath_)
 return
 }
+{
+const v_ = value_a;
+serialization_.checksum_ = ff_core_Int.Int_bitOr(((31 * serialization_.checksum_) + 31), 0);
+ff_core_Serializable.Serialization_autoResize(serialization_, 1);
+ff_core_Buffer.Buffer_setUint8(serialization_.buffer_, serialization_.offset_, 5);
+serialization_.offset_ += 1;
+ff_core_Serializable.ff_core_Serializable_Serializable$ff_core_String_String.serializeUsing_(serialization_, v_.outPath_);
+ff_core_Serializable.ff_core_Serializable_Serializable$ff_core_List_List(ff_core_Serializable.ff_core_Serializable_Serializable$ff_core_String_String).serializeUsing_(serialization_, v_.filePaths_)
+return
+}
 },
 async deserializeUsing_$(serialization_, $task) {
 const variantIndex_ = ff_core_Buffer.Buffer_grabUint8(serialization_.buffer_, serialization_.offset_);
@@ -1208,6 +1554,10 @@ if(_1 === 4) {
 serialization_.checksum_ = ff_core_Int.Int_bitOr(((31 * serialization_.checksum_) + 29), 0);
 return ff_compiler_Main.CheckCommand(ff_core_Serializable.ff_core_Serializable_Serializable$ff_core_String_String.deserializeUsing_(serialization_))
 }
+if(_1 === 5) {
+serialization_.checksum_ = ff_core_Int.Int_bitOr(((31 * serialization_.checksum_) + 31), 0);
+return ff_compiler_Main.SymbolsCommand(ff_core_Serializable.ff_core_Serializable_Serializable$ff_core_String_String.deserializeUsing_(serialization_), ff_core_Serializable.ff_core_Serializable_Serializable$ff_core_List_List(ff_core_Serializable.ff_core_Serializable_Serializable$ff_core_String_String).deserializeUsing_(serialization_))
+}
 {
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_core_Serializable.DeserializationChecksumException(), ff_core_Serializable.ff_core_Any_HasAnyTag$ff_core_Serializable_DeserializationChecksumException)})
 }

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

@@ -163,37 +163,60 @@ return (_w1 !== 46)
 }));
 const self2_ = ff_compiler_Resolver.Resolver_processImports(self_, module_.imports_, otherModules_);
 const self3_ = ff_compiler_Resolver.Resolver_processDefinitions(self2_, module_, ff_core_Option.None());
+const errors_ = ff_core_Array.new_();
 const module2_ = (((_c) => {
-return ff_compiler_Syntax.Module(_c.file_, _c.packagePair_, _c.imports_, ff_compiler_Resolver.checkDuplicates_(ff_core_List.List_map(module_.types_, ((_w1) => {
+return ff_compiler_Syntax.Module(_c.file_, _c.packagePair_, _c.imports_, ff_compiler_Syntax.catchManyInto_(errors_, module_.types_, ((_w1) => {
 return ff_compiler_Resolver.Resolver_resolveTypeDefinition(self3_, _w1)
-})), ((_w1) => {
+})), ff_compiler_Syntax.catchManyInto_(errors_, module_.traits_, ((_w1) => {
+return ff_compiler_Resolver.Resolver_resolveTraitDefinition(self3_, _w1)
+})), ff_compiler_Syntax.catchManyInto_(errors_, module_.instances_, ((_w1) => {
+return ff_compiler_Resolver.Resolver_resolveInstanceDefinition(self3_, _w1)
+})), ff_compiler_Syntax.catchManyInto_(errors_, module_.extends_, ((_w1) => {
+return ff_compiler_Resolver.Resolver_resolveExtendDefinition(self3_, _w1)
+})), ff_compiler_Syntax.catchManyInto_(errors_, module_.lets_, ((_w1) => {
+return ff_compiler_Resolver.Resolver_resolveLetDefinition(self3_, _w1, true)
+})), ff_compiler_Syntax.catchManyInto_(errors_, module_.functions_, ((_w1) => {
+return ff_compiler_Resolver.Resolver_resolveFunctionDefinition(self3_, _w1, true, false)
+})))
+}))(module_);
+do {
+const _1 = ff_core_Array.Array_drain(errors_);
+if(_1.length === 0) {
+
+break
+}
+if(_1.length === 1) {
+const error_ = _1[0].second_;
+ff_core_Error.Error_rethrow(error_)
+break
+}
+{
+const allErrors_ = _1;
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileErrors(ff_core_List.List_map(allErrors_, ((_w1) => {
+return _w1.first_
+}))), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors)})
+}
+} while(false);
+ff_compiler_Resolver.checkDuplicates_(module2_.types_, ((_w1) => {
 return _w1.name_
 }), ((_w1) => {
 return _w1.at_
-})), ff_compiler_Resolver.checkDuplicates_(ff_core_List.List_map(module_.traits_, ((_w1) => {
-return ff_compiler_Resolver.Resolver_resolveTraitDefinition(self3_, _w1)
-})), ((_w1) => {
+}));
+ff_compiler_Resolver.checkDuplicates_(module2_.traits_, ((_w1) => {
 return _w1.name_
 }), ((_w1) => {
 return _w1.at_
-})), ff_core_List.List_map(module_.instances_, ((_w1) => {
-return ff_compiler_Resolver.Resolver_resolveInstanceDefinition(self3_, _w1)
-})), ff_core_List.List_map(module_.extends_, ((_w1) => {
-return ff_compiler_Resolver.Resolver_resolveExtendDefinition(self3_, _w1)
-})), ff_compiler_Resolver.checkDuplicates_(ff_core_List.List_map(module_.lets_, ((_w1) => {
-return ff_compiler_Resolver.Resolver_resolveLetDefinition(self3_, _w1, true)
-})), ((_w1) => {
+}));
+ff_compiler_Resolver.checkDuplicates_(module2_.lets_, ((_w1) => {
 return _w1.name_
 }), ((_w1) => {
 return _w1.at_
-})), ff_compiler_Resolver.checkDuplicates_(ff_core_List.List_map(module_.functions_, ((_w1) => {
-return ff_compiler_Resolver.Resolver_resolveFunctionDefinition(self3_, _w1, true, false)
-})), ((_w1) => {
+}));
+ff_compiler_Resolver.checkDuplicates_(module2_.functions_, ((_w1) => {
 return _w1.signature_.name_
 }), ((_w1) => {
 return _w1.at_
-})))
-}))(module_);
+}));
 const groupedExtendMethods_ = ff_core_List.List_group(ff_core_List.List_map(module2_.extends_, ((x_) => {
 return ff_core_Pair.Pair(ff_core_String.String_takeWhile(ff_compiler_Syntax.Type_show(x_.type_, []), ((_w1) => {
 return ff_core_Char.Char_isAsciiLetterOrDigit(_w1)
@@ -1141,37 +1164,60 @@ return (_w1 !== 46)
 }));
 const self2_ = ff_compiler_Resolver.Resolver_processImports(self_, module_.imports_, otherModules_);
 const self3_ = ff_compiler_Resolver.Resolver_processDefinitions(self2_, module_, ff_core_Option.None());
+const errors_ = ff_core_Array.new_();
 const module2_ = (((_c) => {
-return ff_compiler_Syntax.Module(_c.file_, _c.packagePair_, _c.imports_, ff_compiler_Resolver.checkDuplicates_(ff_core_List.List_map(module_.types_, ((_w1) => {
+return ff_compiler_Syntax.Module(_c.file_, _c.packagePair_, _c.imports_, ff_compiler_Syntax.catchManyInto_(errors_, module_.types_, ((_w1) => {
 return ff_compiler_Resolver.Resolver_resolveTypeDefinition(self3_, _w1)
-})), ((_w1) => {
+})), ff_compiler_Syntax.catchManyInto_(errors_, module_.traits_, ((_w1) => {
+return ff_compiler_Resolver.Resolver_resolveTraitDefinition(self3_, _w1)
+})), ff_compiler_Syntax.catchManyInto_(errors_, module_.instances_, ((_w1) => {
+return ff_compiler_Resolver.Resolver_resolveInstanceDefinition(self3_, _w1)
+})), ff_compiler_Syntax.catchManyInto_(errors_, module_.extends_, ((_w1) => {
+return ff_compiler_Resolver.Resolver_resolveExtendDefinition(self3_, _w1)
+})), ff_compiler_Syntax.catchManyInto_(errors_, module_.lets_, ((_w1) => {
+return ff_compiler_Resolver.Resolver_resolveLetDefinition(self3_, _w1, true)
+})), ff_compiler_Syntax.catchManyInto_(errors_, module_.functions_, ((_w1) => {
+return ff_compiler_Resolver.Resolver_resolveFunctionDefinition(self3_, _w1, true, false)
+})))
+}))(module_);
+do {
+const _1 = ff_core_Array.Array_drain(errors_);
+if(_1.length === 0) {
+
+break
+}
+if(_1.length === 1) {
+const error_ = _1[0].second_;
+ff_core_Error.Error_rethrow(error_)
+break
+}
+{
+const allErrors_ = _1;
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileErrors(ff_core_List.List_map(allErrors_, ((_w1) => {
+return _w1.first_
+}))), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors)})
+}
+} while(false);
+ff_compiler_Resolver.checkDuplicates_(module2_.types_, ((_w1) => {
 return _w1.name_
 }), ((_w1) => {
 return _w1.at_
-})), ff_compiler_Resolver.checkDuplicates_(ff_core_List.List_map(module_.traits_, ((_w1) => {
-return ff_compiler_Resolver.Resolver_resolveTraitDefinition(self3_, _w1)
-})), ((_w1) => {
+}));
+ff_compiler_Resolver.checkDuplicates_(module2_.traits_, ((_w1) => {
 return _w1.name_
 }), ((_w1) => {
 return _w1.at_
-})), ff_core_List.List_map(module_.instances_, ((_w1) => {
-return ff_compiler_Resolver.Resolver_resolveInstanceDefinition(self3_, _w1)
-})), ff_core_List.List_map(module_.extends_, ((_w1) => {
-return ff_compiler_Resolver.Resolver_resolveExtendDefinition(self3_, _w1)
-})), ff_compiler_Resolver.checkDuplicates_(ff_core_List.List_map(module_.lets_, ((_w1) => {
-return ff_compiler_Resolver.Resolver_resolveLetDefinition(self3_, _w1, true)
-})), ((_w1) => {
+}));
+ff_compiler_Resolver.checkDuplicates_(module2_.lets_, ((_w1) => {
 return _w1.name_
 }), ((_w1) => {
 return _w1.at_
-})), ff_compiler_Resolver.checkDuplicates_(ff_core_List.List_map(module_.functions_, ((_w1) => {
-return ff_compiler_Resolver.Resolver_resolveFunctionDefinition(self3_, _w1, true, false)
-})), ((_w1) => {
+}));
+ff_compiler_Resolver.checkDuplicates_(module2_.functions_, ((_w1) => {
 return _w1.signature_.name_
 }), ((_w1) => {
 return _w1.at_
-})))
-}))(module_);
+}));
 const groupedExtendMethods_ = ff_core_List.List_group(ff_core_List.List_map(module2_.extends_, ((x_) => {
 return ff_core_Pair.Pair(ff_core_String.String_takeWhile(ff_compiler_Syntax.Type_show(x_.type_, []), ((_w1) => {
 return ff_core_Char.Char_isAsciiLetterOrDigit(_w1)

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

@@ -358,9 +358,111 @@ return {at_, major_, minor_, patch_};
 
 
 
+export function catchMany_(list_, body_) {
+const errors_ = ff_core_Array.new_();
+const result_ = ff_compiler_Syntax.catchManyInto_(errors_, list_, body_);
+{
+const _1 = ff_core_Array.Array_drain(errors_);
+if(_1.length === 0) {
+return result_
+}
+if(_1.length === 1) {
+const error_ = _1[0].second_;
+return ff_core_Error.Error_rethrow(error_)
+}
+{
+const allErrors_ = _1;
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileErrors(ff_core_List.List_map(allErrors_, ((_w1) => {
+return _w1.first_
+}))), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors)})
+return
+}
+}
+}
 
+export function catchManyInto_(errors_, list_, body_) {
+const result_ = ff_core_List.List_map(list_, ((x_) => {
+return ff_core_Try.Try_catch(ff_core_Try.Try_tryCatch(ff_core_Core.try_((() => {
+return body_(x_)
+})), ((_1, _2) => {
+{
+const at_ = _1.at_;
+const message_ = _1.message_;
+const error_ = _2;
+errors_.array.push(ff_core_Pair.Pair(ff_compiler_Syntax.CompileError(at_, message_), error_));
+return x_
+}
+}), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError), ((_1, _2) => {
+{
+const compileErrors_ = _1.errors_;
+const error_ = _2;
+for(let for_a = compileErrors_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
+const compileError_ = for_a[for_i];
+errors_.array.push(ff_core_Pair.Pair(compileError_, error_))
+};
+return x_
+}
+}), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors)
+}));
+if(ff_core_Array.Array_isEmpty(errors_)) {
+return result_
+} else {
+return []
+}
+}
 
+export async function catchMany_$(list_, body_, $task) {
+const errors_ = ff_core_Array.new_();
+const result_ = (await ff_compiler_Syntax.catchManyInto_$(errors_, list_, body_, $task));
+{
+const _1 = ff_core_Array.Array_drain(errors_);
+if(_1.length === 0) {
+return result_
+}
+if(_1.length === 1) {
+const error_ = _1[0].second_;
+return ff_core_Error.Error_rethrow(error_)
+}
+{
+const allErrors_ = _1;
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileErrors(ff_core_List.List_map(allErrors_, ((_w1) => {
+return _w1.first_
+}))), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors)})
+return
+}
+}
+}
 
+export async function catchManyInto_$(errors_, list_, body_, $task) {
+const result_ = (await ff_core_List.List_map$(list_, (async (x_, $task) => {
+return ff_core_Try.Try_catch(ff_core_Try.Try_tryCatch((await ff_core_Core.try_$((async ($task) => {
+return (await body_(x_, $task))
+}), $task)), ((_1, _2) => {
+{
+const at_ = _1.at_;
+const message_ = _1.message_;
+const error_ = _2;
+errors_.array.push(ff_core_Pair.Pair(ff_compiler_Syntax.CompileError(at_, message_), error_));
+return x_
+}
+}), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError), ((_1, _2) => {
+{
+const compileErrors_ = _1.errors_;
+const error_ = _2;
+for(let for_a = compileErrors_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
+const compileError_ = for_a[for_i];
+errors_.array.push(ff_core_Pair.Pair(compileError_, error_))
+};
+return x_
+}
+}), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors)
+}), $task));
+if(ff_core_Array.Array_isEmpty(errors_)) {
+return result_
+} else {
+return []
+}
+}
 
 export function Location_show(self_) {
 return (((((("in " + self_.file_) + " ") + "at line ") + self_.line_) + ", column ") + self_.column_)

package/package.json

@@ -4,7 +4,7 @@
     "description": "Firefly compiler",
     "author": "Firefly team",
     "license": "MIT",
-    "version": "0.5.44",
+    "version": "0.5.46",
     "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.5.44",
+    "version": "0.5.46",
     "repository": {
         "type": "git",
         "url": "https://github.com/Ahnfelt/firefly-boot"