firefly-compiler 0.4.20 → 0.4.22

package/compiler/Builder.ff

@@ -88,15 +88,17 @@ check(
     system: NodeSystem
     fireflyPath: Path
     path: Path
+    mustContain: Option[String]
     virtualFiles: Map[String, String]
     lspHook: LspHook
     infer: Bool
-) {
+): List[CompileError] {
     let packages = path.isDirectory().{
-        | True => findPackageFiles(path)
+        | True => findPackageFiles(path, mustContain)
         | False {path.endsWith([".firefly", "package.ff"])} => [PackageFiles(path.parent().grab(), Some(path), [])]
         | False => [PackageFiles(path.parent().grab(), None, [path])]
     }
+    let errors = Array.make()
 
     packages.filter {!_.files.isEmpty()}.each {package => 
         let firstFile = package.files.grabFirst()
@@ -118,13 +120,19 @@ check(
         )
         package.files.each {file =>
             let localFile = file.base()
-            if(infer) {
-                compiler.infer(resolvedDependencies.mainPackagePair, localFile.dropLast(".ff".size()))
-            } else {
-                compiler.resolve(resolvedDependencies.mainPackagePair, localFile.dropLast(".ff".size()))
-            }
+            try {
+                if(infer) {
+                    compiler.infer(resolvedDependencies.mainPackagePair, localFile.dropLast(".ff".size()))
+                } else {
+                    compiler.resolve(resolvedDependencies.mainPackagePair, localFile.dropLast(".ff".size()))
+                }
+                Unit
+            } catch {| CompileError(_, _) @ c, error =>
+                errors.push(c)
+            } grab()
         }
     }
+    errors.drain()
 
 }
 
@@ -135,8 +143,8 @@ capability PackageFiles(
 )
 
 
-findPackageFiles(path: Path): List[PackageFiles] {
-    let files = findFireflyFiles(path)
+findPackageFiles(path: Path, mustContain: Option[String]): List[PackageFiles] {
+    let files = findFireflyFiles(path, mustContain)
     let split = files.partition {_.endsWith([".firefly", "package.ff"])}
     let packageFiles = split.first
     mutable singleFiles = split.second
@@ -153,15 +161,17 @@ findPackageFiles(path: Path): List[PackageFiles] {
     [...multiFileProjects, ...singleFileProjects]
 }
 
-findFireflyFiles(path: Path): List[Path] {
+findFireflyFiles(path: Path, mustContain: Option[String]): List[Path] {
     let split = path.entries().toList().partition {_.isDirectory()}
     let directories = split.first.map {_.path()}.filter {_.base().all {c => 
         c == '.' || c.isAsciiLower() || c.isAsciiDigit()
     }}
-    let fireflyFiles = split.second.map {_.path()}.filter {
-        _.extension() == ".ff"
+    let fireflyFiles = split.second.map {_.path()}.filter {file => 
+        file.extension() == ".ff" && mustContain.all {s => 
+            file.readText().contains(s)
+        }
     }
-    [...fireflyFiles, ...directories.flatMap {findFireflyFiles(_)}]
+    [...fireflyFiles, ...directories.flatMap {findFireflyFiles(_, mustContain)}]
 }
 
 internalCreateExecutable(

package/compiler/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")
         }
     }