firefly-compiler 0.4.21 → 0.4.23

package/compiler/Resolver.ff

@@ -20,6 +20,12 @@ class ResolverState(
     mutable nextUnificationVariableIndex: Int
 )
 
+data CaseVariable(
+    at: Location
+    name: String
+    asBound: Option[String]
+)
+
 make(packagePair: PackagePair, moduleName: String, lspHook: LspHook): Resolver {
     Resolver(
         variables = [].toMap()
@@ -77,8 +83,8 @@ extend self: Resolver {
 
     processImports(imports: List[DImport], modules: List[Module]): Resolver {
         mutable resolver = self
-        imports.each { import =>
-            modules.find { _.file.dropLast(3) == import.file }.{
+        imports.each {import =>
+            modules.find {_.file.dropLast(3) == import.file}.{
                 | Some(module) =>
                     resolver = resolver.processDefinitions(module, Some(import.alias))
                 | None =>
@@ -95,7 +101,7 @@ extend self: Resolver {
                 module.file.dropLast(3) + "." + name
             importAlias.{
                 | None => [Pair(name, full), Pair(full, full)]
-                | Some(alias) { unqualified } => [Pair(alias + "." + name, full), Pair(name, full), Pair(full, full)]
+                | Some(alias) {unqualified} => [Pair(alias + "." + name, full), Pair(name, full), Pair(full, full)]
                 | Some(alias) => [Pair(alias + "." + name, full), Pair(full, full)]
             }
         }
@@ -103,20 +109,20 @@ extend self: Resolver {
             module.packagePair.group == "ff" &&
             module.packagePair.name == "core" &&
             module.file == "Core.ff"
-        let lets = module.lets.flatMap { entry(_.name, isCore) }.toMap()
-        let letLocations = module.lets.flatMap {d => entry(d.name, True).map {_.mapSecond {_ => d.at}} }.toMap()
-        let functions = module.functions.flatMap { entry(_.signature.name, isCore) }.toMap()
+        let lets = module.lets.flatMap {entry(_.name, isCore)}.toMap()
+        let letLocations = module.lets.flatMap {d => entry(d.name, True).map {_.mapSecond {_ => d.at}}}.toMap()
+        let functions = module.functions.flatMap {entry(_.signature.name, isCore)}.toMap()
         let functionLocations = module.functions.flatMap {d => entry(d.signature.name, True).map {_.mapSecond {_ => d.at}} }.toMap()
-        let traitMethods = module.traits.flatMap { _.methods }.flatMap { entry(_.name, False) }.toMap()
-        let traitMethodLocations = module.traits.flatMap {_.methods}.flatMap {d => entry(d.name, True).map {_.mapSecond {_ => d.at}} }.toMap()
-        let traits = module.traits.flatMap { entry(_.name, True) }.toMap()
-        let traitLocations = module.traits.flatMap {d => entry(d.name, True).map {_.mapSecond {_ => d.at}} }.toMap()
-        let types = module.types.flatMap { entry(_.name, True) }.toMap()
+        let traitMethods = module.traits.flatMap {_.methods }.flatMap {entry(_.name, False)}.toMap()
+        let traitMethodLocations = module.traits.flatMap {_.methods}.flatMap {d => entry(d.name, True).map {_.mapSecond {_ => d.at}}}.toMap()
+        let traits = module.traits.flatMap {entry(_.name, True) }.toMap()
+        let traitLocations = module.traits.flatMap {d => entry(d.name, True).map {_.mapSecond {_ => d.at}}}.toMap()
+        let types = module.types.flatMap {entry(_.name, True) }.toMap()
         let typeGenerics = module.types.flatMap {d => entry(d.name, True).map {p => Pair(p.first, d.generics)}}.toMap()
-        let typeLocations = module.types.flatMap {d => entry(d.name, True).map {_.mapSecond {_ => d.at}} }.toMap()
-        let asyncTypes = module.types.filter { _.generics.first().any {_ == "Q$"} }
-            .flatMap { entry(_.name, True).map {_.first} }.toSet()
-        let variants = module.types.flatMap { _.variants }.flatMap { entry(_.name, True) }.toMap()
+        let typeLocations = module.types.flatMap {d => entry(d.name, True).map {_.mapSecond {_ => d.at}}}.toMap()
+        let asyncTypes = module.types.filter {_.generics.first().any {_ == "Q$"}}
+            .flatMap {entry(_.name, True).map {_.first}}.toSet()
+        let variants = module.types.flatMap {_.variants }.flatMap {entry(_.name, True)}.toMap()
         self.Resolver(
             variables = self.variables.addAll(lets).addAll(functions).addAll(traitMethods)
             variableLocations = self.variableLocations.addAll(letLocations).addAll(functionLocations).addAll(traitMethodLocations)
@@ -276,132 +282,134 @@ extend self: Resolver {
         )
     }
 
-    resolveTerm(term: Term, topLevel: Bool): Term {
-        | EString _, _ => term
-        | EChar _, _ => term
-        | EInt _, _ => term
-        | EFloat _, _ => term
-        | EVariable e, _ =>
-            if(self.lspHook.isEnabled()) {
-                let at = self.variableLocations.get(e.name).else {e.at}
-                if(self.lspHook.isAt(e.at) || self.lspHook.isDefinedAt(at)) {
-                    self.lspHook.emit(
-                        ResolveSymbolHook(
-                            SymbolHook(e.name, e.at, at), None, topLevel = True
+    resolveTerm(term: Term, topLevel: Bool, inField: Bool = False): Term {
+        term.{
+            | EString _ => term
+            | EChar _ => term
+            | EInt _ => term
+            | EFloat _ => term
+            | EVariable e =>
+                if(self.lspHook.isEnabled()) {
+                    let at = self.variableLocations.get(e.name).else {e.at}
+                    if(self.lspHook.isAt(e.at) || self.lspHook.isDefinedAt(at)) {
+                        self.lspHook.emit(
+                            ResolveSymbolHook(
+                                SymbolHook(e.name, e.at, at), None, topLevel = True
+                            )
                         )
-                    )
+                    }
                 }
-            }
-            self.variables.get(e.name).map {e.EVariable(name = _)}.else {term}
-        | EList(at, t, items), _ =>
-            EList(at, self.resolveType(t, topLevel), items.map {| Pair(item, spread) =>
-                Pair(self.resolveTerm(item, topLevel), spread)
-            })
-        | EVariant(at, name, typeArguments, arguments), _ =>
-            EVariant(
-                at = at
-                name = self.variants.get(name).else {name}
-                typeArguments = typeArguments.map {self.resolveType(_, topLevel)}
-                arguments = arguments.map {_.map {a => a.Argument(value = self.resolveTerm(a.value, topLevel))}}
-            )
-        | EVariantIs(at, name, typeArguments), _ =>
-            EVariantIs(
-                at = at
-                name = self.variants.get(name).else { throw(CompileError(at, "No such variant: " + name)) }
-                typeArguments = typeArguments.map { self.resolveType(_, topLevel) }
-            )
-        | ECopy(at, name, record, arguments), _ =>
-            ECopy(
-                at = at
-                name = self.variants.get(name).else {name}
-                record = self.resolveTerm(record, topLevel)
-                arguments = arguments.map {f => f.Field(value = self.resolveTerm(f.value, topLevel))}
-            )
-        | EField e, _ =>
-            e.EField(record = self.resolveTerm(e.record, topLevel))
-        | ELambda(at, Lambda(lambdaAt, _, cases)), _ =>
-            let effect = self.makeEffectArgument(lambdaAt, topLevel)
-            ELambda(at, Lambda(lambdaAt, effect, cases.map {self.resolveCase(_, topLevel)}))
-        | EPipe(at, value, effect, function), _ =>
-            EPipe(
-                at = at
-                value = self.resolveTerm(value, topLevel)
-                effect = self.resolveType(effect, topLevel)
-                function = self.resolveTerm(function, topLevel)
-            )
-        | ECall(at, DynamicCall target, effect, typeArguments, arguments, dictionaries), _ =>
-            ECall(
-                at = at
-                target = target.DynamicCall(function = self.resolveTerm(target.function, topLevel))
-                effect = self.resolveType(effect, topLevel)
-                typeArguments = typeArguments.map {self.resolveType(_, topLevel)}
-                arguments = arguments.map {a => a.Argument(value = self.resolveTerm(a.value, topLevel))}
-                dictionaries = dictionaries
-            )
-        | ECall(at, StaticCall _, _, _, _, _), _ =>
-            throw(CompileError(at, "Internal error: Static calls not expected in the Resolver phase"))
-        | ERecord(at, fields), _ =>
-            ERecord(
-                at = at
-                fields = fields.map {f => f.Field(value = self.resolveTerm(f.value, topLevel))}
-            )
-        | EWildcard e, _ =>
-            if(e.index == 0) {throw(CompileError(e.at, "Unbound wildcard"))}
-            e.EWildcard()
-        | EFunctions(at, functions, body), _ =>
-            let functionMap = functions.map {_.signature.name}.map {name => Pair(name, name)}.toMap()
-            let locationMap = functions.map {_.signature}.map {s => Pair(s.name, s.at)}.toMap()
-            let self2 = self.Resolver(
-                variables = self.variables.addAll(functionMap)
-                variableLocations = self.variableLocations.addAll(locationMap)
-            )
-            EFunctions(
-                at = at
-                functions = functions.map {self2.resolveFunctionDefinition(_, topLevel, False)}
-                body = self2.resolveTerm(body, topLevel)
-            )
-        | ELet e, _ =>
-            let self2 = self.Resolver(
-                variables = self.variables.add(e.name, e.name)
-                variableLocations = self.variableLocations.add(e.name, e.at)
-            )
-            if(self.lspHook.isEnabled()) {
-                if(self.lspHook.isAt(e.at) || self.lspHook.isDefinedAt(e.at)) {
-                    self.lspHook.emit(
-                        ResolveSymbolHook(
-                            SymbolHook(e.name, e.at, e.at), None, topLevel = False
+                self.variables.get(e.name).map {e.EVariable(name = _)}.else {term}
+            | EList(at, t, items) =>
+                EList(at, self.resolveType(t, topLevel), items.map {| Pair(item, spread) =>
+                    Pair(self.resolveTerm(item, topLevel), spread)
+                })
+            | EVariant(at, name, typeArguments, arguments) =>
+                EVariant(
+                    at = at
+                    name = self.variants.get(name).else {name}
+                    typeArguments = typeArguments.map {self.resolveType(_, topLevel)}
+                    arguments = arguments.map {_.map {a => a.Argument(value = self.resolveTerm(a.value, topLevel))}}
+                )
+            | EVariantIs(at, name, typeArguments) =>
+                EVariantIs(
+                    at = at
+                    name = self.variants.get(name).else {throw(CompileError(at, "No such variant: " + name))}
+                    typeArguments = typeArguments.map {self.resolveType(_, topLevel)}
+                )
+            | ECopy(at, name, record, arguments) =>
+                ECopy(
+                    at = at
+                    name = self.variants.get(name).else {name}
+                    record = self.resolveTerm(record, topLevel, inField = True)
+                    arguments = arguments.map {f => f.Field(value = self.resolveTerm(f.value, topLevel))}
+                )
+            | EField e =>
+                e.EField(record = self.resolveTerm(e.record, topLevel, inField = True))
+            | ELambda(at, Lambda(lambdaAt, _, cases)) =>
+                let effect = self.makeEffectArgument(lambdaAt, topLevel)
+                ELambda(at, Lambda(lambdaAt, effect, cases.map {self.resolveCase(_, topLevel)}))
+            | EPipe(at, value, effect, function) =>
+                EPipe(
+                    at = at
+                    value = self.resolveTerm(value, topLevel)
+                    effect = self.resolveType(effect, topLevel)
+                    function = self.resolveTerm(function, topLevel)
+                )
+            | ECall(at, DynamicCall target, effect, typeArguments, arguments, dictionaries) =>
+                ECall(
+                    at = at
+                    target = target.DynamicCall(function = self.resolveTerm(target.function, topLevel))
+                    effect = self.resolveType(effect, topLevel)
+                    typeArguments = typeArguments.map {self.resolveType(_, topLevel)}
+                    arguments = arguments.map {a => a.Argument(value = self.resolveTerm(a.value, topLevel))}
+                    dictionaries = dictionaries
+                )
+            | ECall(at, StaticCall _, _, _, _, _) =>
+                throw(CompileError(at, "Internal error: Static calls not expected in the Resolver phase"))
+            | ERecord(at, fields) =>
+                ERecord(
+                    at = at
+                    fields = fields.map {f => f.Field(value = self.resolveTerm(f.value, topLevel))}
+                )
+            | EWildcard e =>
+                if(e.index == 0) {throw(CompileError(e.at, "Unbound wildcard"))}
+                e.EWildcard()
+            | EFunctions(at, functions, body) =>
+                let functionMap = functions.map {_.signature.name}.map {name => Pair(name, name)}.toMap()
+                let locationMap = functions.map {_.signature}.map {s => Pair(s.name, s.at)}.toMap()
+                let self2 = self.Resolver(
+                    variables = self.variables.addAll(functionMap)
+                    variableLocations = self.variableLocations.addAll(locationMap)
+                )
+                EFunctions(
+                    at = at
+                    functions = functions.map {self2.resolveFunctionDefinition(_, topLevel, False)}
+                    body = self2.resolveTerm(body, topLevel)
+                )
+            | ELet e =>
+                let self2 = self.Resolver(
+                    variables = self.variables.add(e.name, e.name)
+                    variableLocations = self.variableLocations.add(e.name, e.at)
+                )
+                if(self.lspHook.isEnabled()) {
+                    if(self.lspHook.isAt(e.at) || self.lspHook.isDefinedAt(e.at)) {
+                        self.lspHook.emit(
+                            ResolveSymbolHook(
+                                SymbolHook(e.name, e.at, e.at), None, topLevel = False
+                            )
                         )
-                    )
-                }
-            }
-            e.ELet(
-                valueType = self.resolveType(e.valueType, topLevel)
-                value = self.resolveTerm(e.value, topLevel)
-                body = self2.resolveTerm(e.body, topLevel)
-            )
-        | ESequential(at, before, after), _ =>
-            ESequential(
-                at = at
-                before = self.resolveTerm(before, topLevel)
-                after = self.resolveTerm(after, topLevel)
-            )
-        | EAssign(at, operator, variable, value), _ =>
-            EAssign(
-                at = at
-                operator = operator
-                variable = self.variables.get(variable).else {
-                    throw(CompileError(at, "No such variable: " + variable))
+                    }
                 }
-                value = self.resolveTerm(value, topLevel)
-            )
-        | EAssignField(at, operator, record, field, value), _ =>
-            EAssignField(
-                at = at
-                operator = operator
-                record = self.resolveTerm(record, topLevel)
-                field = field
-                value = self.resolveTerm(value, topLevel)
-            )
+                e.ELet(
+                    valueType = self.resolveType(e.valueType, topLevel)
+                    value = self.resolveTerm(e.value, topLevel)
+                    body = self2.resolveTerm(e.body, topLevel)
+                )
+            | ESequential(at, before, after) =>
+                ESequential(
+                    at = at
+                    before = self.resolveTerm(before, topLevel)
+                    after = self.resolveTerm(after, topLevel)
+                )
+            | EAssign(at, operator, variable, value) =>
+                EAssign(
+                    at = at
+                    operator = operator
+                    variable = self.variables.get(variable).else {
+                        throw(CompileError(at, "No such variable: " + variable))
+                    }
+                    value = self.resolveTerm(value, topLevel)
+                )
+            | EAssignField(at, operator, record, field, value) =>
+                EAssignField(
+                    at = at
+                    operator = operator
+                    record = self.resolveTerm(record, topLevel)
+                    field = field
+                    value = self.resolveTerm(value, topLevel)
+                )
+        }
     }
 
     resolveType(type: Type, topLevel: Bool): Type {
@@ -535,7 +543,7 @@ extend self: Resolver {
     }
 
     resolveCase(case: MatchCase, topLevel: Bool): MatchCase {
-        function findVariables(pattern: MatchPattern): Map[String, Pair[Location, String]] {
+        function findVariables(pattern: MatchPattern): Map[String, CaseVariable] {
             | PString _ =>
                 Map.empty()
             | PInt _ =>
@@ -543,22 +551,22 @@ extend self: Resolver {
             | PChar _ =>
                 Map.empty()
             | PVariable(at, Some(name)) =>
-                [Pair(name, Pair(at, name))].toMap()
+                [Pair(name, CaseVariable(at, name, None))].toMap()
             | PVariable(_, None) =>
                 Map.empty()
             | PVariant(_, _, patterns) =>
                 patterns.map(findVariables).foldLeft(Map.empty()) {_.addAll(_)}
-            | PVariantAs(at, _, variableAt, variable) =>
-                variable.toList().map {x => Pair(x, Pair(variableAt, x))}.toMap()
+            | PVariantAs(at, variant, variableAt, variable) =>
+                variable.toList().map {x => Pair(x, CaseVariable(variableAt, x, Some(variant)))}.toMap()
             | PAlias(at, pattern, variable) =>
-                [Pair(variable, Pair(at, variable))].toMap().addAll(findVariables(pattern))
+                [Pair(variable, CaseVariable(at, variable, None))].toMap().addAll(findVariables(pattern))
         }
         let variableMap = case.patterns.map(findVariables).foldLeft(Map.empty()) {_.addAll(_)}
         mutable guards = []
         let variableMap2 = case.guards.foldLeft(variableMap) {variableMap1, g =>
             let self2 = self.Resolver(
-                variables = self.variables.addAll(variableMap1.mapValues {_, p => p.second})
-                variableLocations = self.variableLocations.addAll(variableMap1.mapValues {_, p => p.first})
+                variables = self.variables.addAll(variableMap1.mapValues {_, p => p.name})
+                variableLocations = self.variableLocations.addAll(variableMap1.mapValues {_, p => p.at})
             )
             let guard = g.MatchGuard(
                 term = self2.resolveTerm(g.term, topLevel)
@@ -568,8 +576,8 @@ extend self: Resolver {
             variableMap1.addAll(findVariables(guard.pattern))
         }
         let self3 = self.Resolver(
-            variables = self.variables.addAll(variableMap2.mapValues {_, p => p.second})
-            variableLocations = self.variableLocations.addAll(variableMap2.mapValues {_, p => p.first})
+            variables = self.variables.addAll(variableMap2.mapValues {_, p => p.name})
+            variableLocations = self.variableLocations.addAll(variableMap2.mapValues {_, p => p.at})
         )
         MatchCase(
             at = case.at

package/compiler/Substitution.ff

@@ -154,9 +154,9 @@ extend self: Substitution {
 
     substituteType(type: Type): Type {
         | TVariable(at, i) =>
-            if(self.has(i)) { self.substituteType(self.get(i)) } else { TConstructor(at, core("Nothing"), []) }
+            if(self.has(i)) {self.substituteType(self.get(i))} else {TConstructor(at, core("Nothing"), [])}
         | TConstructor t =>
-            t.TConstructor(generics = t.generics.map { t => self.substituteType(t) })
+            t.TConstructor(generics = t.generics.map {g => self.substituteType(g)})
     }
 
     get(index: Int): Type {

package/compiler/Unification.ff

@@ -152,7 +152,7 @@ extend self: Unification {
     substitute(type: Type): Type {
         | TVariable(_, i) {self.get(i) | Some(t)} => self.substitute(t)
         | TVariable(_, _) => type
-        | TConstructor t => t.TConstructor(generics = t.generics.map {t => self.substitute(t)})
+        | TConstructor t => t.TConstructor(generics = t.generics.map {g => self.substitute(g)})
     }
 
     unify(at: Location, t1: Type, t2: Type): Unit {

package/core/Map.ff

@@ -18,6 +18,14 @@ extend self[K: Order, V]: Map[K, V] {
         Map(result)
     }
 
+    addList(that: List[Pair[K, V]]): Map[K, V] {
+        mutable result = self.redBlack
+        that.each {| Pair(k, v) =>
+            result = RbMap.insert(k, v, result)
+        }
+        Map(result)
+    }
+
     get(key: K): Option[V] {
         self.redBlack.get(key)
     }

package/core/Set.ff

@@ -7,6 +7,13 @@ empty[T](): Set[T] {
 extend self[T: Order]: Set[T] {
     add(value: T): Set[T] {Set(self.map.add(value, Unit))}
     addAll(that: Set[T]): Set[T] {Set(self.map.addAll(that.map))}
+    addList(that: List[T]): Set[T] {
+        mutable result = self.map
+        that.each {k =>
+            result = result.add(k, Unit)
+        }
+        Set(result)        
+    }
     remove(value: T): Set[T] {Set(self.map.remove(value))}
     removeAll(that: Set[T]): Set[T] {Set(self.map.removeAll(that.map))}
     contains(value: T): Bool {self.map.contains(value)}

package/lsp/Handler.ff

@@ -436,7 +436,13 @@ extend self: Handler {
             | InferPatternHook h {h.pattern | PVariantAs p} => Some(Definition(p.variableAt, p.name, False))
             | InferPatternHook h {h.pattern | PVariable p} => p.name.map {Definition(p.at, _, False)}
             | InferPatternHook h {h.pattern | PAlias p} => Some(Definition(p.at, p.variable, False))
-            | _ => None
+            | InferRecordFieldHook h {h.unification.substitute(h.recordType) | TConstructor(_, n, ts)} =>
+                let fieldNames = n.split('$').dropFirst(1)
+                let fieldDefinedAt = fieldNames.zip(ts).collectFirst {| Pair(name, t) =>
+                    if(name == h.fieldName) {t.at}
+                }
+                fieldDefinedAt.map {Definition(_, h.fieldName, False)}
+            | h => None
         }.filter {pair => !pair.at.file.endsWith(">")}
             
         function unqualify(qualifiedName: String): String {
@@ -445,7 +451,6 @@ extend self: Handler {
 
         definedAtList.first().{
             | Some(definition) =>
-                //Log.trace("handleReferences definedAt: " + Show.show(definedAt))
                 let lspHook = LspHook.make(at = None, definedAt = Some(definition.at), insertIdentifier = False, trackSymbols = False)
                 let localCheck = local || definition.local
                 let path = if(localCheck) {system.path(targetAt.file)} else {self.rootPath.grab()}
@@ -456,7 +461,7 @@ extend self: Handler {
                 let errors = Builder.check(system, self.fireflyPath, path, mustContain, self.virtualFiles, lspHook, True)
                 errors.each {| CompileError(at, message) => 
                     Log.trace("findReferences second check error: " + message + " in " + at.file + ":" + at.line + ":" + at.column)
-                }  
+                }
 
                 let referencesResult = lspHook.results().collect {
                     | ResolveSymbolHook h => Some(h.symbol.usageAt)
@@ -468,11 +473,14 @@ extend self: Handler {
                     | InferArgumentHook h {h.arguments.dropFirst(h.argumentIndex).first() | Some(a)} {a.name | Some(n)} => 
                         h.parameters.find {_.name == n}.map {_ => a.at}
                     | InferLookupHook h => Some(h.symbol.value.usageAt)
+                    | InferRecordFieldHook h => Some(h.usageAt)
                     | _ => None
                 }.filter {at => 
                     !at.file.endsWith(">") &&
                     (includeDeclaration || at != definition.at)
                 }
+                
+                //referencesResult.each {Log.trace(Show.show(_))}
 
                 let clientLocations = referencesResult.addAll(
                     if(includeDeclaration) {[definition.at]} else {[]}

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

@@ -535,16 +535,10 @@ const unification_ = ff_compiler_Unification.make_([], false);
 const newGenerics_ = ff_core_List.List_map(constraint_.generics_, ((_w1) => {
 return ff_compiler_Unification.Unification_instantiate(unification_, instantiationMap_, _w1)
 }));
-const firstType_ = (((_1) => {
+{
+const _1 = ff_core_List.List_grabFirst(newGenerics_);
 if(_1.TConstructor) {
-const t_ = _1;
-return t_
-}
-if(_1.TVariable) {
-const t_ = _1;
-return ff_compiler_Dictionaries.fail_(t_.at_, " is still a unification variable")
-}
-}))(ff_core_List.List_grabFirst(newGenerics_));
+const firstType_ = _1;
 const instance_ = ff_core_Option.Option_else(ff_core_Map.Map_get(self_.instances_, ff_compiler_Unification.InstanceKey(constraint_.name_, firstType_.name_), ff_compiler_Unification.ff_core_Ordering_Order$ff_compiler_Unification_InstanceKey), (() => {
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(at_, ((("Missing instance " + firstType_.name_) + ": ") + constraint_.name_)), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 }));
@@ -553,6 +547,12 @@ return ff_compiler_Dictionaries.Dictionaries_makeDictionary(self_, at_, instance
 }));
 return ff_compiler_Syntax.Dictionary(instance_.packagePair_, instance_.moduleName_, constraint_.name_, firstType_.name_, dictionaries_)
 }
+if(_1.TVariable) {
+const t_ = _1;
+return ff_compiler_Dictionaries.fail_(t_.at_, " is still a unification variable")
+}
+}
+}
 
 export async function Dictionaries_processModule$(self_, module_, otherModules_, $task) {
 const environment_ = ff_compiler_Environment.make_(module_, otherModules_, true);
@@ -936,16 +936,10 @@ const unification_ = ff_compiler_Unification.make_([], false);
 const newGenerics_ = ff_core_List.List_map(constraint_.generics_, ((_w1) => {
 return ff_compiler_Unification.Unification_instantiate(unification_, instantiationMap_, _w1)
 }));
-const firstType_ = (((_1) => {
+{
+const _1 = ff_core_List.List_grabFirst(newGenerics_);
 if(_1.TConstructor) {
-const t_ = _1;
-return t_
-}
-if(_1.TVariable) {
-const t_ = _1;
-return ff_compiler_Dictionaries.fail_(t_.at_, " is still a unification variable")
-}
-}))(ff_core_List.List_grabFirst(newGenerics_));
+const firstType_ = _1;
 const instance_ = ff_core_Option.Option_else(ff_core_Map.Map_get(self_.instances_, ff_compiler_Unification.InstanceKey(constraint_.name_, firstType_.name_), ff_compiler_Unification.ff_core_Ordering_Order$ff_compiler_Unification_InstanceKey), (() => {
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(at_, ((("Missing instance " + firstType_.name_) + ": ") + constraint_.name_)), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 }));
@@ -954,6 +948,12 @@ return ff_compiler_Dictionaries.Dictionaries_makeDictionary(self_, at_, instance
 }));
 return ff_compiler_Syntax.Dictionary(instance_.packagePair_, instance_.moduleName_, constraint_.name_, firstType_.name_, dictionaries_)
 }
+if(_1.TVariable) {
+const t_ = _1;
+return ff_compiler_Dictionaries.fail_(t_.at_, " is still a unification variable")
+}
+}
+}
 
 export const ff_core_Any_HasAnyTag$ff_compiler_Dictionaries_Dictionaries = {
 anyTag_() {