firefly-compiler 0.5.43 → 0.5.45

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/Compiler.ff

@@ -167,9 +167,12 @@ extend self: Compiler {
             }
             try {
                 self.parse(newPackagePair, newModuleName, Some(import.at))
-            } catch {| CompileError(_, _) @ e, error =>
+            } tryCatch {| CompileError(_, _) @ e, error =>
                 let newError = CompileError(import.at, "Parse error in imported module: " + import.package.groupName() + "/" + newModuleName)
                 throw(CompileErrors([e, newError]))
+            } catch {| CompileErrors(compileErrors), error =>
+                let newError = CompileError(import.at, "Parse errors in imported module: " + import.package.groupName() + "/" + newModuleName)
+                throw(CompileErrors([...compileErrors, newError]))
             }
         }
     }

package/compiler/Inference.ff

@@ -27,15 +27,32 @@ core(name: String): String {
 }
 
 extend self: Inference {
-
+    
     inferModule(module: Module, otherModules: List[Module]): Module {
         let environment = Environment.new(module, otherModules, alreadyFlat = False)
 
-        let traits = module.traits.map {self.inferTraitDefinition(environment, _)}
-        let instances = module.instances.map {self.inferInstanceDefinition(environment, _)}
-        let lets = module.lets.map {self.inferLetDefinition(environment, _)}
-        let functions = module.functions.map {self.inferFunctionDefinition(environment, _)}
-        let extends = module.extends.map {self.inferExtendDefinition(environment, _)}
+        let errors = Array.new()
+        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()
+            | allErrors => throw(CompileErrors(allErrors.map {_.first}))
+        }        
+        
         let result = module.Module(
             traits = traits
             instances = instances
@@ -89,7 +106,7 @@ extend self: Inference {
             }
             
             definition.DInstance(
-                methods = definition.methods.map {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 {
@@ -143,7 +160,7 @@ extend self: Inference {
             valueType = definition.type
             default = None
         )
-        let functions = definition.methods.map {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]

package/compiler/Parser.ff

@@ -824,7 +824,7 @@ extend self: Parser {
         while {self.current().rawIs("{")} {
             guards.push(self.parseCaseGuard())
         }
-        if(!self.lspHook.isEnabled() || !self.current().is2(LPipe, LBracketRight)) {
+        if(!self.lspHook.isEnabled() || self.current().is(LArrowThick)) {
             self.skip(LArrowThick)
         }
         let body = self.parseStatements()
@@ -1040,7 +1040,13 @@ extend self: Parser {
     }
 
     parseBinary(level: Int): Term {
-        if(level >= binaryOperators.size()) {self.parseUnary()} else:
+        if(level >= binaryOperators.size()) {
+            if(self.lspHook.isEnabled() && self.current().is(LBracketRight)) {
+                EVariable(self.current().at(), "")
+            } else {
+                self.parseUnary()
+            }
+        } else:
         let operators = binaryOperators.grab(level)
         mutable result = self.parseBinary(level + 1)
         if(self.current().is(LOperator)) {

package/compiler/Resolver.ff

@@ -58,18 +58,37 @@ 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 = 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 = 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()
+        groupedExtendMethods.values().map {_.flatten()}.map {methods =>
+            checkDuplicates(methods) {_.signature.name} {_.at}
+        }
         module2.instances.each {_.typeArguments.each {self3.checkInstanceType(_)}}
         module2
     }
-
+    
     checkInstanceType(type: Type) {
         type.{
             | TConstructor(_, name, typeArguments) =>
@@ -159,7 +178,7 @@ extend self: Resolver {
         }
         definition.DType(
             constraints = definition.constraints.map {self2.resolveConstraint(_, True)}
-            commonFields = definition.commonFields.map {f =>
+            commonFields = checkDuplicates(definition.commonFields.map {f =>
                 let valueType = self2.resolveType(f.valueType, True)
                 if(self.lspHook.isAt(f.at) || self.lspHook.isDefinedAt(f.at)) {
                     self.lspHook.emit(
@@ -170,13 +189,14 @@ extend self: Resolver {
                     valueType = valueType
                     default = f.default.map {self2.resolveTerm(_, True)}
                 )
-            }
-            variants = definition.variants.map {v =>
+            }) {_.name} {_.at}
+            variants = checkDuplicates(definition.variants.map {v =>
                 if(self.lspHook.isAt(v.at)) {
                     self.lspHook.emit(
                         ResolveSymbolHook(SymbolHook(v.name, v.at, v.at), None, topLevel = True)
                     )
                 }
+                checkDuplicates([...definition.commonFields, ...v.fields]) {_.name} {_.at}
                 v.Variant(fields = v.fields.map {f =>
                     let valueType = self2.resolveType(f.valueType, True)
                     if(self.lspHook.isAt(f.at) || self.lspHook.isDefinedAt(f.at)) {
@@ -189,7 +209,7 @@ extend self: Resolver {
                         default = f.default.map {self2.resolveTerm(_, True) }
                     )
                 })
-            }
+            }) {_.name} {_.at}
         )
     }
 
@@ -209,7 +229,9 @@ extend self: Resolver {
         )
         definition.DTrait(
             constraints = definition.constraints.map {self2.resolveConstraint(_, True)}
-            methods = definition.methods.map {self2.resolveSignature(_, True, False)}
+            methods = checkDuplicates(
+                definition.methods.map {self2.resolveSignature(_, True, False)}
+            ) {_.name} {_.at}
             methodDefaults = definition.methodDefaults.map {| Pair(name, lambda) =>
                 let signature = definition.methods.find {_.name == name}.grab()
                 let function1 = DFunction(signature.at, signature, lambda)
@@ -623,3 +645,15 @@ extend self: Resolver {
     }
 
 }
+
+checkDuplicates[T](items: List[T], name: T => String, at: T => Location): List[T] {
+    mutable seen = Map.new()
+    items.map {item =>
+        let n = name(item)
+        if(seen.contains(n)) {
+            throw(CompileError(at(item), "Duplicate definition: " + n))
+        }
+        seen = seen.add(n, item)
+    }
+    items
+}

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/lsp/Handler.ff

@@ -279,6 +279,9 @@ extend self: Handler {
         } tryCatch {| CompileError(at, message), error =>
             Log.trace("handleDocumentSymbol parse error: " + message)
             []
+        } tryCatch {| CompileErrors(_), error =>
+            Log.trace("handleDocumentSymbol parse errors: ")
+            []
         } catch {| ReadSymbolsError e, _ => 
             Log.trace("handleDocumentSymbol ReadSymbolsError")
             []
@@ -402,8 +405,10 @@ extend self: Handler {
             let tokens = Tokenizer.tokenize(cursorAt.file, code, None, True)
             let parser = Parser.new(PackagePair("script", "script"), cursorAt.file, tokens, False, lspHook)
             parser.parseModuleWithPackageInfo()
-        } catch {| CompileError(at, message), error =>
+        } tryCatch {| CompileError(at, message), error =>
             Log.trace("handleSignatureHelp check error: " + message)
+        } catch {| CompileErrors(_), error =>
+            Log.trace("handleSignatureHelp check errors")
         }
         let o = lspHook.results().collectFirst {
             | ParseArgumentHook h {parameters.get("context") | Some(context)} {

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

@@ -209,19 +209,23 @@ return (_w1 + "/")
 if((!ff_core_Map.Map_contains(self_.packagePaths_, newPackagePair_, ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair))) {
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(import_.at_, ("Missing dependency declaration for: " + ff_compiler_Syntax.PackagePair_groupName(newPackagePair_, ":"))), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 };
-try {
+return ff_core_Try.Try_catch(ff_core_Try.Try_tryCatch(ff_core_Core.try_((() => {
 return ff_compiler_Compiler.Compiler_parse(self_, newPackagePair_, newModuleName_, ff_core_Option.Some(import_.at_))
-} catch(_error) {
-if(!_error.ffException) throw _error
-const _exception = ff_core_Any.fromAny_(_error.ffException, ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)
-if(!_exception.Some) throw _error
+})), ((_1, _2) => {
 {
-const e_ = _exception.value_;
-const error_ = _error;
+const e_ = _1;
+const error_ = _2;
 const newError_ = ff_compiler_Syntax.CompileError(import_.at_, ((("Parse error in imported module: " + ff_compiler_Syntax.PackagePair_groupName(import_.package_, ":")) + "/") + newModuleName_));
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileErrors([e_, newError_]), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors)})
 }
+}), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError), ((_1, _2) => {
+{
+const compileErrors_ = _1.errors_;
+const error_ = _2;
+const newError_ = ff_compiler_Syntax.CompileError(import_.at_, ((("Parse errors in imported module: " + ff_compiler_Syntax.PackagePair_groupName(import_.package_, ":")) + "/") + newModuleName_));
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileErrors([...compileErrors_, newError_]), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors)})
 }
+}), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors)
 }))
 }
 
@@ -346,19 +350,23 @@ return (_w1 + "/")
 if((!ff_core_Map.Map_contains(self_.packagePaths_, newPackagePair_, ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair))) {
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(import_.at_, ("Missing dependency declaration for: " + ff_compiler_Syntax.PackagePair_groupName(newPackagePair_, ":"))), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 };
-try {
+return ff_core_Try.Try_catch(ff_core_Try.Try_tryCatch((await ff_core_Core.try_$((async ($task) => {
 return (await ff_compiler_Compiler.Compiler_parse$(self_, newPackagePair_, newModuleName_, ff_core_Option.Some(import_.at_), $task))
-} catch(_error) {
-if(!_error.ffException) throw _error
-const _exception = ff_core_Any.fromAny_(_error.ffException, ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)
-if(!_exception.Some) throw _error
+}), $task)), ((_1, _2) => {
 {
-const e_ = _exception.value_;
-const error_ = _error;
+const e_ = _1;
+const error_ = _2;
 const newError_ = ff_compiler_Syntax.CompileError(import_.at_, ((("Parse error in imported module: " + ff_compiler_Syntax.PackagePair_groupName(import_.package_, ":")) + "/") + newModuleName_));
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileErrors([e_, newError_]), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors)})
 }
+}), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError), ((_1, _2) => {
+{
+const compileErrors_ = _1.errors_;
+const error_ = _2;
+const newError_ = ff_compiler_Syntax.CompileError(import_.at_, ((("Parse errors in imported module: " + ff_compiler_Syntax.PackagePair_groupName(import_.package_, ":")) + "/") + newModuleName_));
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileErrors([...compileErrors_, newError_]), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors)})
 }
+}), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors)
 }), $task))
 }
 

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

@@ -173,21 +173,40 @@ return ff_core_Pair.Pair(ff_compiler_Unification.InstanceKey(c_.name_, typeName_
 
 export function Inference_inferModule(self_, module_, otherModules_) {
 const environment_ = ff_compiler_Environment.new_(module_, otherModules_, false);
-const traits_ = ff_core_List.List_map(module_.traits_, ((_w1) => {
+const errors_ = ff_core_Array.new_();
+const traits_ = ff_compiler_Syntax.catchManyInto_(errors_, module_.traits_, ((_w1) => {
 return ff_compiler_Inference.Inference_inferTraitDefinition(self_, environment_, _w1)
 }));
-const instances_ = ff_core_List.List_map(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_core_List.List_map(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_core_List.List_map(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_core_List.List_map(module_.extends_, ((_w1) => {
+const extends_ = ff_compiler_Syntax.catchManyInto_(errors_, module_.extends_, ((_w1) => {
 return ff_compiler_Inference.Inference_inferExtendDefinition(self_, environment_, _w1)
 }));
+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);
 const result_ = (((_c) => {
 return ff_compiler_Syntax.Module(_c.file_, _c.packagePair_, _c.imports_, _c.types_, traits_, instances_, extends_, lets_, functions_)
 }))(module_);
@@ -236,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_core_List.List_map(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)
@@ -295,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_core_List.List_map(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_);
@@ -2071,21 +2090,40 @@ return instantiated_
 
 export async function Inference_inferModule$(self_, module_, otherModules_, $task) {
 const environment_ = ff_compiler_Environment.new_(module_, otherModules_, false);
-const traits_ = ff_core_List.List_map(module_.traits_, ((_w1) => {
+const errors_ = ff_core_Array.new_();
+const traits_ = ff_compiler_Syntax.catchManyInto_(errors_, module_.traits_, ((_w1) => {
 return ff_compiler_Inference.Inference_inferTraitDefinition(self_, environment_, _w1)
 }));
-const instances_ = ff_core_List.List_map(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_core_List.List_map(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_core_List.List_map(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_core_List.List_map(module_.extends_, ((_w1) => {
+const extends_ = ff_compiler_Syntax.catchManyInto_(errors_, module_.extends_, ((_w1) => {
 return ff_compiler_Inference.Inference_inferExtendDefinition(self_, environment_, _w1)
 }));
+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);
 const result_ = (((_c) => {
 return ff_compiler_Syntax.Module(_c.file_, _c.packagePair_, _c.imports_, _c.types_, traits_, instances_, extends_, lets_, functions_)
 }))(module_);
@@ -2134,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_core_List.List_map(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)
@@ -2193,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_core_List.List_map(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/Parser.mjs

@@ -933,7 +933,7 @@ const guards_ = ff_core_Array.new_();
 while(ff_compiler_Token.Token_rawIs(ff_compiler_Parser.Parser_current(self_), "{")) {
 guards_.array.push(ff_compiler_Parser.Parser_parseCaseGuard(self_))
 };
-if(((!ff_compiler_LspHook.LspHook_isEnabled(self_.lspHook_)) || (!ff_compiler_Token.Token_is2(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LPipe(), ff_compiler_Token.LBracketRight())))) {
+if(((!ff_compiler_LspHook.LspHook_isEnabled(self_.lspHook_)) || ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LArrowThick()))) {
 ff_compiler_Parser.Parser_skip(self_, ff_compiler_Token.LArrowThick())
 };
 const body_ = ff_compiler_Parser.Parser_parseStatements(self_);
@@ -1201,7 +1201,11 @@ return ff_compiler_Parser.Parser_parseBinary(self_, 0)
 
 export function Parser_parseBinary(self_, level_) {
 if((level_ >= ff_compiler_Parser.binaryOperators_.length)) {
+if((ff_compiler_LspHook.LspHook_isEnabled(self_.lspHook_) && ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LBracketRight()))) {
+return ff_compiler_Syntax.EVariable(ff_compiler_Token.Token_at(ff_compiler_Parser.Parser_current(self_)), "")
+} else {
 return ff_compiler_Parser.Parser_parseUnary(self_)
+}
 } else {
 const operators_ = (ff_compiler_Parser.binaryOperators_[level_] ?? ff_core_List.List_grab(ff_compiler_Parser.binaryOperators_, level_));
 let result_ = ff_compiler_Parser.Parser_parseBinary(self_, (level_ + 1));
@@ -2433,7 +2437,7 @@ const guards_ = ff_core_Array.new_();
 while(ff_compiler_Token.Token_rawIs(ff_compiler_Parser.Parser_current(self_), "{")) {
 guards_.array.push(ff_compiler_Parser.Parser_parseCaseGuard(self_))
 };
-if(((!ff_compiler_LspHook.LspHook_isEnabled(self_.lspHook_)) || (!ff_compiler_Token.Token_is2(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LPipe(), ff_compiler_Token.LBracketRight())))) {
+if(((!ff_compiler_LspHook.LspHook_isEnabled(self_.lspHook_)) || ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LArrowThick()))) {
 ff_compiler_Parser.Parser_skip(self_, ff_compiler_Token.LArrowThick())
 };
 const body_ = ff_compiler_Parser.Parser_parseStatements(self_);
@@ -2701,7 +2705,11 @@ return ff_compiler_Parser.Parser_parseBinary(self_, 0)
 
 export async function Parser_parseBinary$(self_, level_, $task) {
 if((level_ >= ff_compiler_Parser.binaryOperators_.length)) {
+if((ff_compiler_LspHook.LspHook_isEnabled(self_.lspHook_) && ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LBracketRight()))) {
+return ff_compiler_Syntax.EVariable(ff_compiler_Token.Token_at(ff_compiler_Parser.Parser_current(self_)), "")
+} else {
 return ff_compiler_Parser.Parser_parseUnary(self_)
+}
 } else {
 const operators_ = (ff_compiler_Parser.binaryOperators_[level_] ?? ff_core_List.List_grab(ff_compiler_Parser.binaryOperators_, level_));
 let result_ = ff_compiler_Parser.Parser_parseBinary(self_, (level_ + 1));

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

@@ -121,10 +121,34 @@ export function new_(packagePair_, moduleName_, lspHook_) {
 return ff_compiler_Resolver.Resolver(ff_core_List.List_toMap([], ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), ff_core_List.List_toMap([], ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), ff_core_List.List_toMap([], ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), ff_core_List.List_toMap([], ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), ff_core_List.List_toMap([], ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), ff_core_List.List_toMap([], ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), ff_core_List.List_toSet([], ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), ff_core_List.List_toSet([], ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), ff_core_List.List_toMap([], ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), ff_core_List.List_toMap([], ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), ff_compiler_Resolver.ResolverState(2), lspHook_)
 }
 
+export function checkDuplicates_(items_, name_, at_) {
+let seen_ = ff_core_Map.new_();
+ff_core_List.List_map(items_, ((item_) => {
+const n_ = name_(item_);
+if(ff_core_Map.Map_contains(seen_, n_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String)) {
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(at_(item_), ("Duplicate definition: " + n_)), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
+};
+seen_ = ff_core_Map.Map_add(seen_, n_, item_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String)
+}));
+return items_
+}
+
 export async function new_$(packagePair_, moduleName_, lspHook_, $task) {
 return ff_compiler_Resolver.Resolver(ff_core_List.List_toMap([], ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), ff_core_List.List_toMap([], ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), ff_core_List.List_toMap([], ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), ff_core_List.List_toMap([], ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), ff_core_List.List_toMap([], ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), ff_core_List.List_toMap([], ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), ff_core_List.List_toSet([], ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), ff_core_List.List_toSet([], ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), ff_core_List.List_toMap([], ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), ff_core_List.List_toMap([], ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), ff_compiler_Resolver.ResolverState(2), lspHook_)
 }
 
+export async function checkDuplicates_$(items_, name_, at_, $task) {
+let seen_ = ff_core_Map.new_();
+(await ff_core_List.List_map$(items_, (async (item_, $task) => {
+const n_ = (await name_(item_, $task));
+if(ff_core_Map.Map_contains(seen_, n_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String)) {
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError((await at_(item_, $task)), ("Duplicate definition: " + n_)), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
+};
+seen_ = ff_core_Map.Map_add(seen_, n_, item_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String)
+}), $task));
+return items_
+}
+
 export function Resolver_freshUnificationVariable(self_, at_) {
 const result_ = ff_compiler_Syntax.TVariable(at_, self_.state_.nextUnificationVariableIndex_);
 self_.state_.nextUnificationVariableIndex_ += 3;
@@ -139,21 +163,74 @@ 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_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)
-})), ff_core_List.List_map(module_.traits_, ((_w1) => {
+})), ff_compiler_Syntax.catchManyInto_(errors_, module_.traits_, ((_w1) => {
 return ff_compiler_Resolver.Resolver_resolveTraitDefinition(self3_, _w1)
-})), ff_core_List.List_map(module_.instances_, ((_w1) => {
+})), ff_compiler_Syntax.catchManyInto_(errors_, module_.instances_, ((_w1) => {
 return ff_compiler_Resolver.Resolver_resolveInstanceDefinition(self3_, _w1)
-})), ff_core_List.List_map(module_.extends_, ((_w1) => {
+})), ff_compiler_Syntax.catchManyInto_(errors_, module_.extends_, ((_w1) => {
 return ff_compiler_Resolver.Resolver_resolveExtendDefinition(self3_, _w1)
-})), ff_core_List.List_map(module_.lets_, ((_w1) => {
+})), ff_compiler_Syntax.catchManyInto_(errors_, module_.lets_, ((_w1) => {
 return ff_compiler_Resolver.Resolver_resolveLetDefinition(self3_, _w1, true)
-})), ff_core_List.List_map(module_.functions_, ((_w1) => {
+})), 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_(module2_.traits_, ((_w1) => {
+return _w1.name_
+}), ((_w1) => {
+return _w1.at_
+}));
+ff_compiler_Resolver.checkDuplicates_(module2_.lets_, ((_w1) => {
+return _w1.name_
+}), ((_w1) => {
+return _w1.at_
+}));
+ff_compiler_Resolver.checkDuplicates_(module2_.functions_, ((_w1) => {
+return _w1.signature_.name_
+}), ((_w1) => {
+return _w1.at_
+}));
+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)
+})), x_.methods_)
+})), ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String);
+ff_core_List.List_map(ff_core_List.List_map(ff_core_Map.Map_values(groupedExtendMethods_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), ((_w1) => {
+return ff_core_List.List_flatten(_w1)
+})), ((methods_) => {
+return ff_compiler_Resolver.checkDuplicates_(methods_, ((_w1) => {
+return _w1.signature_.name_
+}), ((_w1) => {
+return _w1.at_
+}))
+}));
 for(let for_a = module2_.instances_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const _w1 = for_a[for_i];
 for(let for_a = _w1.typeArguments_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
@@ -338,7 +415,7 @@ const _1 = definition_;
 const _c = _1;
 return ff_compiler_Syntax.DType(_c.at_, _c.newtype_, _c.data_, _c.name_, _c.generics_, ff_core_List.List_map(definition_.constraints_, ((_w1) => {
 return ff_compiler_Resolver.Resolver_resolveConstraint(self2_, _w1, true)
-})), ff_core_List.List_map(definition_.commonFields_, ((f_) => {
+})), ff_compiler_Resolver.checkDuplicates_(ff_core_List.List_map(definition_.commonFields_, ((f_) => {
 const valueType_ = ff_compiler_Resolver.Resolver_resolveType(self2_, f_.valueType_, true);
 if((ff_compiler_LspHook.LspHook_isAt(self_.lspHook_, f_.at_) || ff_compiler_LspHook.LspHook_isDefinedAt(self_.lspHook_, f_.at_))) {
 ff_compiler_LspHook.LspHook_emit(self_.lspHook_, ff_compiler_LspHook.ResolveVariantFieldHook(ff_compiler_LspHook.SymbolHook(f_.name_, f_.at_, f_.at_), valueType_, true))
@@ -353,10 +430,19 @@ return ff_compiler_Resolver.Resolver_resolveTerm(self2_, _w1, true, false)
 return
 }
 }
-})), ff_core_List.List_map(definition_.variants_, ((v_) => {
+})), ((_w1) => {
+return _w1.name_
+}), ((_w1) => {
+return _w1.at_
+})), ff_compiler_Resolver.checkDuplicates_(ff_core_List.List_map(definition_.variants_, ((v_) => {
 if(ff_compiler_LspHook.LspHook_isAt(self_.lspHook_, v_.at_)) {
 ff_compiler_LspHook.LspHook_emit(self_.lspHook_, ff_compiler_LspHook.ResolveSymbolHook(ff_compiler_LspHook.SymbolHook(v_.name_, v_.at_, v_.at_), ff_core_Option.None(), true))
 };
+ff_compiler_Resolver.checkDuplicates_([...definition_.commonFields_, ...v_.fields_], ((_w1) => {
+return _w1.name_
+}), ((_w1) => {
+return _w1.at_
+}));
 {
 const _1 = v_;
 {
@@ -380,6 +466,10 @@ return
 return
 }
 }
+})), ((_w1) => {
+return _w1.name_
+}), ((_w1) => {
+return _w1.at_
 })))
 return
 }
@@ -402,8 +492,12 @@ const _1 = definition_;
 const _c = _1;
 return ff_compiler_Syntax.DTrait(_c.at_, _c.name_, _c.generics_, ff_core_List.List_map(definition_.constraints_, ((_w1) => {
 return ff_compiler_Resolver.Resolver_resolveConstraint(self2_, _w1, true)
-})), _c.generatorParameters_, ff_core_List.List_map(definition_.methods_, ((_w1) => {
+})), _c.generatorParameters_, ff_compiler_Resolver.checkDuplicates_(ff_core_List.List_map(definition_.methods_, ((_w1) => {
 return ff_compiler_Resolver.Resolver_resolveSignature(self2_, _w1, true, false)
+})), ((_w1) => {
+return _w1.name_
+}), ((_w1) => {
+return _w1.at_
 })), ff_core_List.List_map(definition_.methodDefaults_, ((_1) => {
 {
 const name_ = _1.first_;
@@ -1070,21 +1164,74 @@ 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_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)
-})), ff_core_List.List_map(module_.traits_, ((_w1) => {
+})), ff_compiler_Syntax.catchManyInto_(errors_, module_.traits_, ((_w1) => {
 return ff_compiler_Resolver.Resolver_resolveTraitDefinition(self3_, _w1)
-})), ff_core_List.List_map(module_.instances_, ((_w1) => {
+})), ff_compiler_Syntax.catchManyInto_(errors_, module_.instances_, ((_w1) => {
 return ff_compiler_Resolver.Resolver_resolveInstanceDefinition(self3_, _w1)
-})), ff_core_List.List_map(module_.extends_, ((_w1) => {
+})), ff_compiler_Syntax.catchManyInto_(errors_, module_.extends_, ((_w1) => {
 return ff_compiler_Resolver.Resolver_resolveExtendDefinition(self3_, _w1)
-})), ff_core_List.List_map(module_.lets_, ((_w1) => {
+})), ff_compiler_Syntax.catchManyInto_(errors_, module_.lets_, ((_w1) => {
 return ff_compiler_Resolver.Resolver_resolveLetDefinition(self3_, _w1, true)
-})), ff_core_List.List_map(module_.functions_, ((_w1) => {
+})), 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_(module2_.traits_, ((_w1) => {
+return _w1.name_
+}), ((_w1) => {
+return _w1.at_
+}));
+ff_compiler_Resolver.checkDuplicates_(module2_.lets_, ((_w1) => {
+return _w1.name_
+}), ((_w1) => {
+return _w1.at_
+}));
+ff_compiler_Resolver.checkDuplicates_(module2_.functions_, ((_w1) => {
+return _w1.signature_.name_
+}), ((_w1) => {
+return _w1.at_
+}));
+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)
+})), x_.methods_)
+})), ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String);
+ff_core_List.List_map(ff_core_List.List_map(ff_core_Map.Map_values(groupedExtendMethods_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), ((_w1) => {
+return ff_core_List.List_flatten(_w1)
+})), ((methods_) => {
+return ff_compiler_Resolver.checkDuplicates_(methods_, ((_w1) => {
+return _w1.signature_.name_
+}), ((_w1) => {
+return _w1.at_
+}))
+}));
 for(let for_a = module2_.instances_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const _w1 = for_a[for_i];
 for(let for_a = _w1.typeArguments_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
@@ -1269,7 +1416,7 @@ const _1 = definition_;
 const _c = _1;
 return ff_compiler_Syntax.DType(_c.at_, _c.newtype_, _c.data_, _c.name_, _c.generics_, ff_core_List.List_map(definition_.constraints_, ((_w1) => {
 return ff_compiler_Resolver.Resolver_resolveConstraint(self2_, _w1, true)
-})), ff_core_List.List_map(definition_.commonFields_, ((f_) => {
+})), ff_compiler_Resolver.checkDuplicates_(ff_core_List.List_map(definition_.commonFields_, ((f_) => {
 const valueType_ = ff_compiler_Resolver.Resolver_resolveType(self2_, f_.valueType_, true);
 if((ff_compiler_LspHook.LspHook_isAt(self_.lspHook_, f_.at_) || ff_compiler_LspHook.LspHook_isDefinedAt(self_.lspHook_, f_.at_))) {
 ff_compiler_LspHook.LspHook_emit(self_.lspHook_, ff_compiler_LspHook.ResolveVariantFieldHook(ff_compiler_LspHook.SymbolHook(f_.name_, f_.at_, f_.at_), valueType_, true))
@@ -1284,10 +1431,19 @@ return ff_compiler_Resolver.Resolver_resolveTerm(self2_, _w1, true, false)
 return
 }
 }
-})), ff_core_List.List_map(definition_.variants_, ((v_) => {
+})), ((_w1) => {
+return _w1.name_
+}), ((_w1) => {
+return _w1.at_
+})), ff_compiler_Resolver.checkDuplicates_(ff_core_List.List_map(definition_.variants_, ((v_) => {
 if(ff_compiler_LspHook.LspHook_isAt(self_.lspHook_, v_.at_)) {
 ff_compiler_LspHook.LspHook_emit(self_.lspHook_, ff_compiler_LspHook.ResolveSymbolHook(ff_compiler_LspHook.SymbolHook(v_.name_, v_.at_, v_.at_), ff_core_Option.None(), true))
 };
+ff_compiler_Resolver.checkDuplicates_([...definition_.commonFields_, ...v_.fields_], ((_w1) => {
+return _w1.name_
+}), ((_w1) => {
+return _w1.at_
+}));
 {
 const _1 = v_;
 {
@@ -1311,6 +1467,10 @@ return
 return
 }
 }
+})), ((_w1) => {
+return _w1.name_
+}), ((_w1) => {
+return _w1.at_
 })))
 return
 }
@@ -1333,8 +1493,12 @@ const _1 = definition_;
 const _c = _1;
 return ff_compiler_Syntax.DTrait(_c.at_, _c.name_, _c.generics_, ff_core_List.List_map(definition_.constraints_, ((_w1) => {
 return ff_compiler_Resolver.Resolver_resolveConstraint(self2_, _w1, true)
-})), _c.generatorParameters_, ff_core_List.List_map(definition_.methods_, ((_w1) => {
+})), _c.generatorParameters_, ff_compiler_Resolver.checkDuplicates_(ff_core_List.List_map(definition_.methods_, ((_w1) => {
 return ff_compiler_Resolver.Resolver_resolveSignature(self2_, _w1, true, false)
+})), ((_w1) => {
+return _w1.name_
+}), ((_w1) => {
+return _w1.at_
 })), ff_core_List.List_map(definition_.methodDefaults_, ((_1) => {
 {
 const name_ = _1.first_;

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.43",
+    "version": "0.5.45",
     "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.43",
+    "version": "0.5.45",
     "repository": {
         "type": "git",
         "url": "https://github.com/Ahnfelt/firefly-boot"