firefly-compiler 0.4.21 → 0.4.23

package/compiler/Dictionaries.ff

@@ -168,18 +168,18 @@ extend self: Dictionaries {
     ): Dictionary {
         let instantiationMap = typeParameters.zip(typeArguments).toMap()
         let unification = Unification.make([], False)
-        let newGenerics = constraint.generics.map { unification.instantiate(instantiationMap, _) }
-        let firstType = newGenerics.grabFirst().{
-            | TConstructor t => t
+        let newGenerics = constraint.generics.map {unification.instantiate(instantiationMap, _)}
+        newGenerics.grabFirst().{
+            | TConstructor firstType =>
+                let instance = self.instances.get(InstanceKey(constraint.name, firstType.name)).else {
+                    throw(CompileError(at, "Missing instance " + firstType.name + ": " + constraint.name))
+                }
+                let dictionaries = instance.constraints.map {c =>
+                    self.makeDictionary(at, instance.generics, firstType.generics, c)
+                }
+                Dictionary(instance.packagePair, instance.moduleName, constraint.name, firstType.name, dictionaries)
             | TVariable t => fail(t.at, " is still a unification variable")
         }
-        let instance = self.instances.get(InstanceKey(constraint.name, firstType.name)).else {
-            throw(CompileError(at, "Missing instance " + firstType.name + ": " + constraint.name))
-        }
-        let dictionaries = instance.constraints.map { c =>
-            self.makeDictionary(at, instance.generics, firstType.generics, c)
-        }
-        Dictionary(instance.packagePair, instance.moduleName, constraint.name, firstType.name, dictionaries)
     }
 
 }

package/compiler/Inference.ff

@@ -298,8 +298,11 @@ extend self: Inference {
                 }
                 self.unification.unify(at, expected, instantiated.scheme.signature.returnType)
                 let parameters = instantiated.scheme.signature.parameters.sortBy {_.name}
-                let recordType =
-                    TConstructor(at, "Record$" + parameters.map {_.name}.join("$"), parameters.map {_.valueType})
+                let paramtersWithFieldAt = parameters.map {p => p.valueType.{
+                    | TConstructor t => t.TConstructor(at = p.at)
+                    | TVariable t => t.TVariable(at = p.at)
+                }}
+                let recordType = TConstructor(at, "Record$" + parameters.map {_.name}.join("$"), paramtersWithFieldAt)
                 variableOption.toList().map {Pair(_, Pair(variableAt, recordType))}.toMap()
             | PVariant(at, "List$Empty", []) =>
                 let itemType = self.unification.freshUnificationVariable(at)
@@ -371,14 +374,18 @@ extend self: Inference {
                 let record = self.inferTerm(environment, recordType, e.record)
                 self.unification.substitute(recordType).{
                     | TConstructor(_, name, typeArguments)@t {name.startsWith("Record$")} =>
-                        if(self.lspHook.isAt(e.at)) {
-                            let symbolHook = SymbolHook(e.field, e.at, e.at)
-                            let noEffect = self.unification.freshUnificationVariable(e.at)
-                            self.lspHook.emit(
-                                InferRecordFieldHook(self.unification, environment, expected, t, e.field)
-                            )
-                        }
                         let fieldNames = name.split('$').dropFirst(1)
+                        if(self.lspHook.isEnabled()) {
+                            fieldNames.zip(typeArguments).each {| Pair(fieldName, fieldType) =>
+                                if(e.field == fieldName):
+                                let definedAt = self.unification.substitute(fieldType).at
+                                if(self.lspHook.isAt(e.at) || self.lspHook.isDefinedAt(definedAt)) {
+                                    self.lspHook.emit(
+                                        InferRecordFieldHook(e.at, self.unification, environment, expected, t, e.field)
+                                    )
+                                }
+                            }
+                        }
                         fieldNames.pairs().find {_.second == e.field}.map {_.first}.map {index =>
                             let t1 = typeArguments.grab(index)
                             self.unification.unify(e.at, expected, t1)
@@ -568,7 +575,7 @@ extend self: Inference {
             | ECall e =>
                 if((self.lspHook.isEnabled()) && e.target.{| StaticCall _ => True | _ => False}) {term} else:
                 let call = e.target.{
-                    | DynamicCall call => call
+                    | DynamicCall call => (function = call.function, tailCall = call.tailCall)
                     | StaticCall _ => fail(e.at, "Internal error: Static calls not expected in the Inference phase")
                 }
                 call.function.{
@@ -747,23 +754,26 @@ extend self: Inference {
         recordType: Type
         name: String
     ): Term {
-        let e = term.{| ECall e => e | _ => fail(term.at, "Call expected")}
-        let call = e.target.{
-            | DynamicCall call => call
-            | StaticCall _ => fail(e.at, "Internal error: Static calls not expected in inferMethodCall")
+        term.{
+            | ECall e =>
+                let tailCall = e.target.{
+                    | DynamicCall call => call.tailCall
+                    | StaticCall _ => fail(e.at, "Internal error: Static calls not expected in inferMethodCall")
+                }
+                let selfParameter = signature.parameters.grabFirst()
+                let selfArgument = Argument(record.at, Some(selfParameter.name), record) // Be careful not to infer again
+                self.unification.unify(term.at, expected, signature.returnType)
+                self.unification.unify(term.at, selfParameter.valueType, recordType)
+                let arguments = self.inferArguments(term.at, name, environment, signature.parameters.dropFirst(), e.arguments)
+                self.unification.affect(term.at, signature.effect, environment.effect)
+                e.ECall(
+                    target = StaticCall(name, instanceCall = False, tailCall = tailCall)
+                    typeArguments = instantiation.map {_.second}
+                    arguments = [selfArgument, ...arguments]
+                    effect = signature.effect
+                )
+            | _ => fail(term.at, "Call expected")
         }
-        let selfParameter = signature.parameters.grabFirst()
-        let selfArgument = Argument(record.at, Some(selfParameter.name), record) // Be careful not to infer again
-        self.unification.unify(term.at, expected, signature.returnType)
-        self.unification.unify(term.at, selfParameter.valueType, recordType)
-        let arguments = self.inferArguments(term.at, name, environment, signature.parameters.dropFirst(), e.arguments)
-        self.unification.affect(term.at, signature.effect, environment.effect)
-        e.ECall(
-            target = StaticCall(name, instanceCall = False, tailCall = call.tailCall)
-            typeArguments = instantiation.map {_.second}
-            arguments = [selfArgument, ...arguments]
-            effect = signature.effect
-        )
     }
 
     inferFunctionCall(
@@ -775,139 +785,148 @@ extend self: Inference {
         term: Term
         name: String
     ): Term {
-        let e = term.{| ECall e => e | _ => fail(term.at, "Call expected")}
-        let call = e.target.{
-            | DynamicCall call => call
-            | StaticCall _ => fail(e.at, "Internal error: Static calls not expected in inferFunctionCall")
+        term.{
+            | ECall e =>
+                let tailCall = e.target.{
+                    | DynamicCall call => call.tailCall
+                    | StaticCall _ => fail(e.at, "Internal error: Static calls not expected in inferFunctionCall")
+                }
+                self.unification.unify(e.at, expected, signature.returnType)
+                let arguments = self.inferArguments(e.at, name, environment, signature.parameters, e.arguments)
+                self.unification.affect(term.at, signature.effect, environment.effect)
+                e.ECall(
+                    target = StaticCall(name, instanceCall = instanceCall, tailCall = tailCall)
+                    typeArguments = instantiation.map {_.second}
+                    arguments = arguments
+                    effect = signature.effect
+                )
+            | _ => fail(term.at, "Call expected")
         }
-        self.unification.unify(e.at, expected, signature.returnType)
-        let arguments = self.inferArguments(e.at, name, environment, signature.parameters, e.arguments)
-        self.unification.affect(term.at, signature.effect, environment.effect)
-        e.ECall(
-            target = StaticCall(name, instanceCall = instanceCall, tailCall = call.tailCall)
-            typeArguments = instantiation.map {_.second}
-            arguments = arguments
-            effect = signature.effect
-        )
     }
 
     inferLambdaCall(environment: Environment, expected: Type, term: Term): Term {
-        let e = term.{| ECall e => e | _ => fail(term.at, "Call expected")}
-        let call = e.target.{
-            | DynamicCall call {!call.tailCall} => call
-            | DynamicCall _ => throw(CompileError(e.at, "Tailcalls not supported on lambda functions"))
-            | StaticCall _ => fail(e.at, "Internal error: Static calls not expected in inferLambdaCall")
-        }
-        let effect = self.unification.freshUnificationVariable(term.at)
-        let argumentTypes = e.arguments.map {self.unification.freshUnificationVariable(_.at)}
-        let functionType = TConstructor(e.at, "Function$" + e.arguments.size(), [
-            effect
-            ...argumentTypes
-            expected
-        ])
-        let function = self.inferTerm(environment, functionType, call.function)
-        let arguments = e.arguments.zip(argumentTypes).map {| Pair(argument, t) =>
-            argument.name.each {name =>
-                throw(CompileError(argument.at, "Named argument not allowed here: " + name))
-            }
-            argument.Argument(value = self.inferTerm(environment, t, argument.value))
-        }
-        e.typeArguments.first().each {typeArgument =>
-            throw(CompileError(typeArgument.at, "Type arguments not allowed here"))
+        term.{
+            | ECall e =>
+                let call = e.target.{
+                    | DynamicCall call {!call.tailCall} => (function = call.function, tailCall = call.tailCall)
+                    | DynamicCall _ => throw(CompileError(e.at, "Tailcalls not supported on lambda functions"))
+                    | StaticCall _ => fail(e.at, "Internal error: Static calls not expected in inferLambdaCall")
+                }
+                let effect = self.unification.freshUnificationVariable(term.at)
+                let argumentTypes = e.arguments.map {self.unification.freshUnificationVariable(_.at)}
+                let functionType = TConstructor(e.at, "Function$" + e.arguments.size(), [
+                    effect
+                    ...argumentTypes
+                    expected
+                ])
+                let function = self.inferTerm(environment, functionType, call.function)
+                let arguments = e.arguments.zip(argumentTypes).map {| Pair(argument, t) =>
+                    argument.name.each {name =>
+                        throw(CompileError(argument.at, "Named argument not allowed here: " + name))
+                    }
+                    argument.Argument(value = self.inferTerm(environment, t, argument.value))
+                }
+                e.typeArguments.first().each {typeArgument =>
+                    throw(CompileError(typeArgument.at, "Type arguments not allowed here"))
+                }
+                self.unification.affect(term.at, effect, environment.effect)
+                e.ECall(
+                    target = call.DynamicCall(function = function)
+                    typeArguments = []
+                    arguments = arguments
+                    effect = effect
+                )
+            | _ => fail(term.at, "Call expected")
         }
-        self.unification.affect(term.at, effect, environment.effect)
-        e.ECall(
-            target = call.DynamicCall(function = function)
-            typeArguments = []
-            arguments = arguments
-            effect = effect
-        )
     }
 
     inferOperator(environment: Environment, expected: Type, operator: String, term: Term): Term {
-        let e = term.{| ECall e => e | _ => fail(term.at, "Call expected") }
-        let target = StaticCall(operator, instanceCall = False, tailCall = False)
-        e.arguments.{
-            | [a1] {
-                operator == "!"
-            } =>
-                let t = TConstructor(e.at, core("Bool"), [])
-                let e1 = self.inferTerm(environment, t, a1.value)
-                self.unification.unify(e.at, expected, t)
-                e.ECall(target = target, arguments = [a1.Argument(value = e1)])
-            | [a1] {
-                operator == "-"
-            } =>
-                let t1 = self.unification.freshUnificationVariable(e.at)
-                let e1 = self.inferTerm(environment, t1, a1.value)
-                self.unification.substitute(t1).{
-                    | TConstructor(_, name, []) {name == core("Float")} =>
-                        self.unification.unify(e.at, expected, t1)
-                    | TConstructor(_, name, []) {name == core("Int")} =>
-                        self.unification.unify(e.at, expected, t1)
+        term.{
+            | ECall e =>
+                let target = StaticCall(operator, instanceCall = False, tailCall = False)
+                e.arguments.{
+                    | [a1] {
+                        operator == "!"
+                    } =>
+                        let t = TConstructor(e.at, core("Bool"), [])
+                        let e1 = self.inferTerm(environment, t, a1.value)
+                        self.unification.unify(e.at, expected, t)
+                        e.ECall(target = target, arguments = [a1.Argument(value = e1)])
+                    | [a1] {
+                        operator == "-"
+                    } =>
+                        let t1 = self.unification.freshUnificationVariable(e.at)
+                        let e1 = self.inferTerm(environment, t1, a1.value)
+                        self.unification.substitute(t1).{
+                            | TConstructor(_, name, []) {name == core("Float")} =>
+                                self.unification.unify(e.at, expected, t1)
+                            | TConstructor(_, name, []) {name == core("Int")} =>
+                                self.unification.unify(e.at, expected, t1)
+                            | _ {self.lspHook.isEnabled()} =>
+                            | _ =>
+                                throw(CompileError(e.at, "Operators on unknown types not currently supported"))
+                        }
+                        e.ECall(target = target, arguments = [a1.Argument(value = e1)])
+                    | [a1, a2] {
+                        operator == "||" || operator == "&&"
+                    } =>
+                        let t = TConstructor(e.at, core("Bool"), [])
+                        let e1 = self.inferTerm(environment, t, a1.value)
+                        let e2 = self.inferTerm(environment, t, a2.value)
+                        self.unification.unify(e.at, expected, t)
+                        e.ECall(target = target, arguments = [a1.Argument(value = e1), a2.Argument(value = e2)])
+                    | [a1, a2] {
+                        operator == "===" || operator == "!==" // For internal use
+                    } =>
+                        let t1 = self.unification.freshUnificationVariable(e.at)
+                        let e1 = self.inferTerm(environment, t1, a1.value)
+                        let e2 = self.inferTerm(environment, t1, a2.value)
+                        self.unification.unify(e.at, expected, TConstructor(e.at, core("Bool"), []))
+                        e.ECall(target = target, arguments = [a1.Argument(value = e1), a2.Argument(value = e2)])
+                    | [a1, a2] {
+                        operator == "+" || operator == "-" ||
+                        operator == "*" || operator == "/" || operator == "%" ||
+                        operator == "^"
+                    } =>
+                        let t1 = self.unification.freshUnificationVariable(e.at)
+                        let t2 = self.unification.freshUnificationVariable(e.at)
+                        let e1 = self.inferTerm(environment, t1, a1.value)
+                        let e2 = self.inferTerm(environment, t2, a2.value)
+                        let magic: Type => Option[String] = {t =>
+                            self.unification.substitute(t).{
+                                | TConstructor(_, name, []) {name == core("Float")} => Some("Float")
+                                | TConstructor(_, name, []) {name == core("Int")} => Some("Int")
+                                | TConstructor(_, name, []) {operator == "+" && name == core("String")} => Some("String")
+                                | _ => None
+                            }
+                        }
+                        let chooseType: (Option[String], Option[String]) => Unit = {
+                            | Some("String"), Some(_) => self.unification.unify(e.at, expected, t1)
+                            | Some(_), Some("String") => self.unification.unify(e.at, expected, t2)
+                            | Some("Float"), Some(_) => self.unification.unify(e.at, expected, t1)
+                            | Some(_), Some("Float") => self.unification.unify(e.at, expected, t2)
+                            | Some("Int"), Some(_) => self.unification.unify(e.at, expected, t1)
+                            | Some(_), Some("Int") => self.unification.unify(e.at, expected, t2)
+                            | Some(_), None =>
+                                self.unification.unify(e.at, t1, t2)
+                                self.unification.unify(e.at, expected, t1)
+                            | None, Some(_) =>
+                                self.unification.unify(e.at, t2, t1)
+                                self.unification.unify(e.at, expected, t2)
+                            | _, _ {self.lspHook.isEnabled()} =>
+                            | Some(_), Some(_) =>
+                                throw(CompileError(e.at, "Operators on these types not currently supported"))
+                            | None, None =>
+                                throw(CompileError(e.at, "Operators on unknown types not currently supported"))
+                        }
+                        chooseType(magic(t1), magic(t2))
+                        e.ECall(target = target, arguments = [a1.Argument(value = e1), a2.Argument(value = e2)])
                     | _ {self.lspHook.isEnabled()} =>
+                        term
                     | _ =>
-                        throw(CompileError(e.at, "Operators on unknown types not currently supported"))
-                }
-                e.ECall(target = target, arguments = [a1.Argument(value = e1)])
-            | [a1, a2] {
-                operator == "||" || operator == "&&"
-            } =>
-                let t = TConstructor(e.at, core("Bool"), [])
-                let e1 = self.inferTerm(environment, t, a1.value)
-                let e2 = self.inferTerm(environment, t, a2.value)
-                self.unification.unify(e.at, expected, t)
-                e.ECall(target = target, arguments = [a1.Argument(value = e1), a2.Argument(value = e2)])
-            | [a1, a2] {
-                operator == "===" || operator == "!==" // For internal use
-            } =>
-                let t1 = self.unification.freshUnificationVariable(e.at)
-                let e1 = self.inferTerm(environment, t1, a1.value)
-                let e2 = self.inferTerm(environment, t1, a2.value)
-                self.unification.unify(e.at, expected, TConstructor(e.at, core("Bool"), []))
-                e.ECall(target = target, arguments = [a1.Argument(value = e1), a2.Argument(value = e2)])
-            | [a1, a2] {
-                operator == "+" || operator == "-" ||
-                operator == "*" || operator == "/" || operator == "%" ||
-                operator == "^"
-            } =>
-                let t1 = self.unification.freshUnificationVariable(e.at)
-                let t2 = self.unification.freshUnificationVariable(e.at)
-                let e1 = self.inferTerm(environment, t1, a1.value)
-                let e2 = self.inferTerm(environment, t2, a2.value)
-                let magic: Type => Option[String] = {t =>
-                    self.unification.substitute(t).{
-                        | TConstructor(_, name, []) {name == core("Float")} => Some("Float")
-                        | TConstructor(_, name, []) {name == core("Int")} => Some("Int")
-                        | TConstructor(_, name, []) {operator == "+" && name == core("String")} => Some("String")
-                        | _ => None
-                    }
-                }
-                let chooseType: (Option[String], Option[String]) => Unit = {
-                    | Some("String"), Some(_) => self.unification.unify(e.at, expected, t1)
-                    | Some(_), Some("String") => self.unification.unify(e.at, expected, t2)
-                    | Some("Float"), Some(_) => self.unification.unify(e.at, expected, t1)
-                    | Some(_), Some("Float") => self.unification.unify(e.at, expected, t2)
-                    | Some("Int"), Some(_) => self.unification.unify(e.at, expected, t1)
-                    | Some(_), Some("Int") => self.unification.unify(e.at, expected, t2)
-                    | Some(_), None =>
-                        self.unification.unify(e.at, t1, t2)
-                        self.unification.unify(e.at, expected, t1)
-                    | None, Some(_) =>
-                        self.unification.unify(e.at, t2, t1)
-                        self.unification.unify(e.at, expected, t2)
-                    | _, _ {self.lspHook.isEnabled()} =>
-                    | Some(_), Some(_) =>
-                        throw(CompileError(e.at, "Operators on these types not currently supported"))
-                    | None, None =>
-                        throw(CompileError(e.at, "Operators on unknown types not currently supported"))
+                        fail(e.at, "Unknown operator: " + operator)
                 }
-                chooseType(magic(t1), magic(t2))
-                e.ECall(target = target, arguments = [a1.Argument(value = e1), a2.Argument(value = e2)])
-            | _ {self.lspHook.isEnabled()} =>
-                term
-            | _ =>
-                fail(e.at, "Unknown operator: " + operator)
+            | _ => fail(term.at, "Call expected")
         }
     }
 

package/compiler/JsEmitter.ff

@@ -899,9 +899,9 @@ extractTypeName(type: Type): String {
 
 firstTypeName(types: List[Type]): String {
     types.grabFirst().{
-        | TConstructor t => t
+        | TConstructor t => t.name
         | TVariable t => fail(t.at, " is still a unification variable")
-    }.name
+    }
 }
 
 makeDictionaryName(traitName: String, typeName: String): String {

package/compiler/LspHook.ff

@@ -173,6 +173,7 @@ class ResultHook {
         instantiated: Box[Option[Instantiated]]
     )
     InferRecordFieldHook(
+        usageAt: Location
         unification: Unification
         environment: Environment
         expected: Type
@@ -188,7 +189,7 @@ showHook(hook: ResultHook): String {
     | InferLookupHook(unification, environment, expected, selfVariable, symbol, instantiated) => "InferLookupHook(...)"
     | InferParameterHook(unification, environment, parameter, missing) => "InferParameterHook(...)"
     | InferPatternHook(unification, environment, expected, pattern) => "InferPatternHook(...)"
-    | InferRecordFieldHook(unification, environment, expected, recordType, fieldName) => "InferRecordFieldHook(...)"
+    | InferRecordFieldHook(usageAt, unification, environment, expected, recordType, fieldName) => "InferRecordFieldHook(...)"
     | InferSequentialStartHook(unification, term, missing) => "InferSequentialStartHook(...)"
     | InferTermHook(unification, environment, expected, term, recordType, missing) => "InferTermHook(...)"
     | ParseArgumentHook(callAt, argumentIndex, parameterName) => "ParseArgumentHook(...)"

package/compiler/Main.ff

@@ -63,7 +63,10 @@ main(system: NodeSystem): Unit {
             prepareFireflyDirectory(system.path("."))
             let localMainFile = system.path(mainFile).base()
             buildScript(localMainFile, resolvedDependencies.mainPackagePair, EmitNode, resolvedDependencies)
-            importAndRun(fireflyPath, "node", resolvedDependencies.mainPackagePair, localMainFile, arguments)
+            if(!importAndRun(fireflyPath, "node", resolvedDependencies.mainPackagePair, localMainFile, arguments)) {
+                let at = Location(system.path(mainFile + ".ff").absolute(), 1, 1)
+                throw(CompileError(at, "This module does not contain a 'nodeMain' function"))
+            }
 
         | BrowserCommand(mainFile) =>
             let resolvedDependencies = Dependencies.process(system.httpClient(), system.path(mainFile + ".ff"))
@@ -83,7 +86,7 @@ main(system: NodeSystem): Unit {
 
         | CheckCommand(filePath) => 
             let errors = Builder.check(system, fireflyPath, system.path(filePath), None, Map.empty(), LspHook.disabled(), True)
-            if(!errors.isEmpty()) {throw(CompileErrors(errors))}
+            if(!errors.isEmpty()) {throw(CompileErrors(errors.distinct()))}
 
         | BootstrapCommand =>
             let workingDirectory = system.path(".")
@@ -212,14 +215,19 @@ importAndRun(
     packagePair: PackagePair
     mainFile: String
     arguments: List[String]
-): Unit
+): Bool
     target node async """
         const process = await import('process');
         const cwd = process.cwd();
         const workingDirectory = cwd.indexOf(':') == 1 ? 'file:///' + cwd : cwd;
         const packagePath = packagePair_.group_ + "/" + packagePair_.name_
         const main = await import(workingDirectory + "/.firefly/output/" + target_ + "/" + packagePath + "/" + mainFile_ + ".mjs");
-        await main.$run$(fireflyPath_, arguments_)
+        if(typeof main.$run$ !== 'undefined') {
+            await main.$run$(fireflyPath_, arguments_);
+            return true;
+        } else {
+            return false;
+        }
     """
 
 prepareFireflyDirectory(path: Path) {

package/compiler/Patterns.ff

@@ -72,7 +72,7 @@ convert(modules: Map[String, Module], cases: List[MatchCase]): List[PatternCaseI
             None
         | PVariant p =>
             let fields = p.patterns.map(convertPattern).pairs().collect {
-                | Pair(i, Some(p)) => Some(Pair("" + i, p))
+                | Pair(i, Some(info)) => Some(Pair("" + i, info))
                 | _ => None
             }
             Some(PatternInfo(unqualifiedName(p.name), otherVariants(p.name), fields))