firefly-compiler 0.5.35 → 0.5.36

package/compiler/Dependencies.ff

@@ -1,187 +1,186 @@
-import Parser
-import Syntax
-import Tokenizer
-import Workspace
-import LspHook
-import DependencyLock
-
-capability Dependencies(
-    workspace: Workspace
-    mutable packages: Map[PackagePair, PackageInfo]
-    mutable packagePaths: Map[PackagePair, Path]
-    mutable singleFilePackages: Set[PackagePair]
-)
-
-capability ResolvedDependencies(
-    mainPackagePair: PackagePair
-    packages: Map[PackagePair, PackageInfo]
-    packagePaths: Map[PackagePair, Path]
-    singleFilePackages: Set[PackagePair]
-)
-
-extend self: Dependencies {
-
-    loadPackageInfo(
-        packagePair: PackagePair
-        path: Path
-    ): PackageInfo {
-        let packageDirectory = if(path.extension() == ".ff") {path.parent().grab()} else {path}
-        let sharedPackageFile = packageDirectory.slash(".firefly").slash("package.ff")
-        let packageFile = if(sharedPackageFile.exists()) {
-            sharedPackageFile
-        } else {
-            self.singleFilePackages = self.singleFilePackages.add(packagePair)
-            path
-        }
-        let code = packageFile.readText()
-        self.parsePackageFile(packagePair, packageFile.relativeTo(path), code)
-    }
-    
-    parsePackageFile(
-        packagePair: PackagePair
-        fileName: String
-        code: String
-    ): PackageInfo {
-        let tokens = Tokenizer.tokenize(fileName, code, None, True)
-        let parser = Parser.new(packagePair, fileName, tokens, False, LspHook.disabled())
-        let info = parser.parsePackageInfo()
-        self.addCoreDependencyIfMissing(info)
-    }
-
-    addCoreDependencyIfMissing(info: PackageInfo): PackageInfo {
-        if(info.dependencies.any {d =>
-            d.packagePair.group == "ff" && d.packagePair.name == "core"
-        }) {
-            info
-        } else {
-            let coreDependency = DDependency(
-                at = info.package.at
-                packagePair = PackagePair("ff", "core")
-                version = Version(info.package.at, 0, 0, 0)
-                safety = Trusted
-                targets = info.package.targets
-            )
-            info.PackageInfo(dependencies = [coreDependency, ...info.dependencies])
-        }
-    }
-
-    processPackageInfo(
-        packageInfo: PackageInfo
-    ): List[DDependency] {
-        self.packages = self.packages.add(packageInfo.package.packagePair, packageInfo)
-        packageInfo.dependencies.filter {!self.packages.contains(_.packagePair)}
-    }
-
-    fetchDependency(
-        path: Path
-        httpClient: HttpClient
-        dependencyLock: DependencyLock
-        dependency: DDependency
-    ): Path {
-        let location = self.workspace.findPackageLocation(dependency.packagePair, dependency.version)
-        if(location.contains(":") && !location.dropFirst(1).startsWith(":")) {
-            if(location.startsWith("http://") || location.startsWith("https://")) {
-                let packagePair = dependency.packagePair
-                let directory = if(path.isDirectory()) {path} else {path.parent().grab()}
-                let dependenciesPath = directory.slash(".firefly").slash("dependencies")
-                let dependencyPath = dependenciesPath.slash(packagePair.group).slash(packagePair.name)
-                let tarGzPath = dependenciesPath.slash(Workspace.tarGzName(packagePair, dependency.version))
-                let donePath = dependenciesPath.slash(Workspace.tarGzName(packagePair, dependency.version) + ".done")
-                if(!donePath.exists()) {
-                    dependencyLock.do(donePath.absolute()) {
-                        if(!donePath.exists()) {
-                            Log.trace("Fetching " + location)
-                            let buffer = httpClient.get(location, []) {response =>
-                                if(!response.ok()) {
-                                    panic("Could not download dependency: " + location)
-                                }
-                                response.readBuffer()
-                            }
-                            if(dependencyPath.exists()) {
-                                dependencyPath.delete()
-                            }
-                            dependencyPath.createDirectory(createParentDirectories = True)
-                            tarGzPath.writeStream([buffer].toStream())
-                            internalExtractTarGz(tarGzPath, dependencyPath)
-                            tarGzPath.renameTo(donePath)
-                        }
-                    }
-                }
-                dependencyPath
-            } else {
-                panic("Loading packages by this protocol is not supported: " + location)
-            }
-        } else {
-            path.path(location)
-        }
-    }
-
-    processDependencies(
-        path: Path
-        httpClient: HttpClient
-        dependencyLock: DependencyLock
-        dependencies: List[DDependency]
-    ): Unit {
-        // Remember to check for cycles
-        let packageInfos = dependencies.map {dependency =>
-            let dependencyPath = self.fetchDependency(path, httpClient, dependencyLock, dependency)
-            self.packagePaths = self.packagePaths.add(dependency.packagePair, dependencyPath)
-            let packageInfo = self.loadPackageInfo(dependency.packagePair, dependencyPath)
-            checkPackagePairs(dependency.packagePair, packageInfo.package.packagePair)
-            packageInfo
-        }
-        let newDependencies = packageInfos.flatMap {self.processPackageInfo(_)}
-        if(newDependencies != []) {
-            self.processDependencies(path, httpClient, dependencyLock, newDependencies)
-        }
-    }
-
-}
-
-process(fetch: HttpClient, dependencyLock: DependencyLock, path: Path): ResolvedDependencies {
-    let workspace = Workspace.loadWorkspace(path)
-    let self = Dependencies(workspace, [].toMap(), [].toMap(), [].toSet())
-    let packageInfo = self.loadPackageInfo(PackagePair("script", "script"), path)
-    let newDependencies = self.processPackageInfo(packageInfo)
-    self.processDependencies(path, fetch, dependencyLock, newDependencies)
-    let packagePaths = self.packagePaths.add(packageInfo.package.packagePair, findScriptPackageLocation(path))
-    ResolvedDependencies(
-        mainPackagePair = packageInfo.package.packagePair
-        packages = self.packages
-        packagePaths = packagePaths
-        singleFilePackages = self.singleFilePackages
-    )
-}
-
-findScriptPackageLocation(path: Path): Path {
-    let packageDirectory = if(path.extension() == ".ff") {path.parent().grab()} else {path}
-    function go(directory: Path): Path {
-        let packageFile = directory.slash(".firefly").slash("package.ff")
-        if(packageFile.exists()) {
-            directory
-        } elseIf {!directory.parent().isEmpty()} {
-            go(directory.parent().grab())
-        } else {
-            packageDirectory
-        }
-    }
-    go(packageDirectory)
-}
-
-checkPackagePairs(dependencyPair: PackagePair, packagePair: PackagePair): Unit {
-    if(
-        packagePair.group != dependencyPair.group ||
-        packagePair.name != dependencyPair.name
-    ) {
-        panic(
-            "Dependency declaration and package declaration disagree on package name: " +
-            dependencyPair.groupName() + " vs. " + packagePair.groupName()
-        )
-    }
-}
-
-internalExtractTarGz(tarGzPath: Path, path: Path): Unit
-    target node async """
-        import * as tar from 'tar'
-        await tar.extract({file: tarGzPath_, cwd: path_, strict: true})
-    """
+import Parser
+import Syntax
+import Tokenizer
+import Workspace
+import LspHook
+import DependencyLock
+
+capability Dependencies(
+    workspace: Workspace
+    mutable packages: Map[PackagePair, PackageInfo]
+    mutable packagePaths: Map[PackagePair, Path]
+    mutable singleFilePackages: Set[PackagePair]
+)
+
+capability ResolvedDependencies(
+    mainPackagePair: PackagePair
+    packages: Map[PackagePair, PackageInfo]
+    packagePaths: Map[PackagePair, Path]
+    singleFilePackages: Set[PackagePair]
+)
+
+extend self: Dependencies {
+
+    loadPackageInfo(
+        packagePair: PackagePair
+        path: Path
+    ): PackageInfo {
+        let packageDirectory = if(path.extension() == ".ff") {path.parent().grab()} else {path}
+        let sharedPackageFile = packageDirectory.slash(".firefly").slash("package.ff")
+        let packageFile = if(sharedPackageFile.exists()) {
+            sharedPackageFile
+        } else {
+            self.singleFilePackages = self.singleFilePackages.add(packagePair)
+            path
+        }
+        let code = packageFile.readText()
+        self.parsePackageFile(packagePair, packageFile.relativeTo(path), code)
+    }
+    
+    parsePackageFile(
+        packagePair: PackagePair
+        fileName: String
+        code: String
+    ): PackageInfo {
+        let tokens = Tokenizer.tokenize(fileName, code, None, True)
+        let parser = Parser.new(packagePair, fileName, tokens, False, LspHook.disabled())
+        let info = parser.parsePackageInfo()
+        self.addCoreDependencyIfMissing(info)
+    }
+
+    addCoreDependencyIfMissing(info: PackageInfo): PackageInfo {
+        if(info.dependencies.any {d =>
+            d.packagePair.group == "ff" && d.packagePair.name == "core"
+        }) {
+            info
+        } else {
+            let coreDependency = DDependency(
+                at = info.package.at
+                packagePair = PackagePair("ff", "core")
+                version = Version(info.package.at, 0, 0, 0)
+                safety = Trusted
+                targets = info.package.targets
+            )
+            info.PackageInfo(dependencies = [coreDependency, ...info.dependencies])
+        }
+    }
+
+    processPackageInfo(
+        packageInfo: PackageInfo
+    ): List[DDependency] {
+        self.packages = self.packages.add(packageInfo.package.packagePair, packageInfo)
+        packageInfo.dependencies.filter {!self.packages.contains(_.packagePair)}
+    }
+
+    fetchDependency(
+        path: Path
+        httpClient: HttpClient
+        dependencyLock: DependencyLock
+        dependency: DDependency
+    ): Path {
+        let location = self.workspace.findPackageLocation(dependency.packagePair, dependency.version)
+        if(location.contains(":") && !location.dropFirst(1).startsWith(":")) {
+            if(location.startsWith("http://") || location.startsWith("https://")) {
+                let packagePair = dependency.packagePair
+                let directory = if(path.isDirectory()) {path} else {path.parent().grab()}
+                let dependenciesPath = directory.slash(".firefly").slash("dependencies")
+                let dependencyPath = dependenciesPath.slash(packagePair.group).slash(packagePair.name)
+                let tarGzPath = dependenciesPath.slash(Workspace.tarGzName(packagePair, dependency.version))
+                let donePath = dependenciesPath.slash(Workspace.tarGzName(packagePair, dependency.version) + ".done")
+                if(!donePath.exists()) {
+                    dependencyLock.do(donePath.absolute()) {
+                        if(!donePath.exists()) {
+                            Log.trace("Fetching " + location)
+                            let buffer = httpClient.get(location, []) {response =>
+                                if(!response.ok()) {
+                                    panic("Could not download dependency: " + location)
+                                }
+                                response.readBuffer()
+                            }
+                            if(dependencyPath.exists()) {
+                                dependencyPath.delete()
+                            }
+                            dependencyPath.createDirectory(createParentDirectories = True)
+                            tarGzPath.writeStream([buffer].toStream())
+                            internalExtractTarGz(tarGzPath, dependencyPath)
+                            tarGzPath.renameTo(donePath)
+                        }
+                    }
+                }
+                dependencyPath
+            } else {
+                panic("Loading packages by this protocol is not supported: " + location)
+            }
+        } else {
+            path.path(location)
+        }
+    }
+
+    processDependencies(
+        path: Path
+        httpClient: HttpClient
+        dependencyLock: DependencyLock
+        dependencies: List[DDependency]
+    ): Unit {
+        // Remember to check for cycles
+        let packageInfos = dependencies.map {dependency =>
+            let dependencyPath = self.fetchDependency(path, httpClient, dependencyLock, dependency)
+            self.packagePaths = self.packagePaths.add(dependency.packagePair, dependencyPath)
+            let packageInfo = self.loadPackageInfo(dependency.packagePair, dependencyPath)
+            checkPackagePairs(dependency.packagePair, packageInfo.package.packagePair)
+            packageInfo
+        }
+        let newDependencies = packageInfos.flatMap {self.processPackageInfo(_)}
+        if(newDependencies != []) {
+            self.processDependencies(path, httpClient, dependencyLock, newDependencies)
+        }
+    }
+
+}
+
+process(fetch: HttpClient, dependencyLock: DependencyLock, path: Path): ResolvedDependencies {
+    let workspace = Workspace.loadWorkspace(path)
+    let self = Dependencies(workspace, [].toMap(), [].toMap(), [].toSet())
+    let packageInfo = self.loadPackageInfo(PackagePair("script", "script"), path)
+    let newDependencies = self.processPackageInfo(packageInfo)
+    self.processDependencies(path, fetch, dependencyLock, newDependencies)
+    let packagePaths = self.packagePaths.add(packageInfo.package.packagePair, findScriptPackageLocation(path))
+    ResolvedDependencies(
+        mainPackagePair = packageInfo.package.packagePair
+        packages = self.packages
+        packagePaths = packagePaths
+        singleFilePackages = self.singleFilePackages
+    )
+}
+
+findScriptPackageLocation(path: Path): Path {
+    let packageDirectory = if(path.extension() == ".ff") {path.parent().grab()} else {path}
+    function go(directory: Path): Path {
+        let packageFile = directory.slash(".firefly").slash("package.ff")
+        if(packageFile.exists()) {
+            directory
+        } elseIf {!directory.parent().isEmpty()} {
+            go(directory.parent().grab())
+        } else {
+            packageDirectory
+        }
+    }
+    go(packageDirectory)
+}
+
+checkPackagePairs(dependencyPair: PackagePair, packagePair: PackagePair): Unit {
+    if(
+        packagePair.group != dependencyPair.group ||
+        packagePair.name != dependencyPair.name
+    ) {
+        panic(
+            "Dependency declaration and package declaration disagree on package name: " +
+            dependencyPair.groupName() + " vs. " + packagePair.groupName()
+        )
+    }
+}
+
+internalExtractTarGz(tarGzPath: Path, path: Path): Unit {
+    let tar = Js.import("tar")
+    Js.await(tar->extract(Js->(file = tarGzPath.absolutePath, cwd = path.absolutePath, strict = True)))
+}

package/compiler/DependencyLock.ff

@@ -1,17 +1,17 @@
-capability DependencyLock(
-    doneLocks: StringMap[Lock]
-    task: Task
-)
-
-new(task: Task): DependencyLock {
-    DependencyLock(StringMap.new(), task)
-}
-
-extend self: DependencyLock {
-    do[T](doneFile: String, body: () => T): T {
-        let lock = self.doneLocks.getOrSet(doneFile) {self.task.lock()}
-        lock.do(reentrant = False) {
-            body()
-        }
-    }
-}
+capability DependencyLock(
+    doneLocks: StringMap[Lock]
+    task: Task
+)
+
+new(task: Task): DependencyLock {
+    DependencyLock(StringMap.new(), task)
+}
+
+extend self: DependencyLock {
+    do[T](doneFile: String, body: () => T): T {
+        let lock = self.doneLocks.getOrSet(doneFile) {self.task.lock()}
+        lock.do {
+            body()
+        }
+    }
+}

package/compiler/Deriver.ff

@@ -75,18 +75,16 @@ extend self: Deriver {
         }
         let strings =
             [EString(at, "\"[\""), ...typeArgumentStrings.separate([EString(at, "\",\"")]), EString(at, "\"]\"")]
-        let body = FireflyTarget(
-            Lambda(at, noEffect, [MatchCase(
-                at = at
-                patterns = []
-                guards = []
-                body = self.makeSimpleCall(at, "ff:core/Any.internalAnyTag", [
-                    strings.foldLeft(EString(at, "\"" + selfTypeName + "\"")) {a, b =>
-                        self.makeSimpleCall(at, "+", [a, b])
-                    }
-                ])
-            )])
-        )
+        let body = Lambda(at, noEffect, [MatchCase(
+            at = at
+            patterns = []
+            guards = []
+            body = self.makeSimpleCall(at, "ff:core/Any.internalAnyTag", [
+                strings.foldLeft(EString(at, "\"" + selfTypeName + "\"")) {a, b =>
+                    self.makeSimpleCall(at, "+", [a, b])
+                }
+            ])
+        )])
         let method = DFunction(at, signature, body)
         DInstance(
             at = at
@@ -130,9 +128,8 @@ extend self: Deriver {
             returnType = TConstructor(at, "ff:core/String.String", [])
             effect = noEffect
         )
-        let body = FireflyTarget(
+        let body = 
             Lambda(at, noEffect, self.makeShowCases(modulePrefix, declaration, selfType))
-        )
         let showMethod = DFunction(at, signature, body)
         DInstance(
             at = at
@@ -209,9 +206,8 @@ extend self: Deriver {
             returnType = TConstructor(at, "ff:core/Ordering.Ordering", [])
             effect = noEffect
         )
-        let body = FireflyTarget(
+        let body =
             Lambda(at, noEffect, self.makeOrderingCases(modulePrefix, declaration, selfType))
-        )
         let compareMethod = DFunction(at, signature, body)
         DInstance(
             at = at
@@ -275,12 +271,12 @@ extend self: Deriver {
                     )
                 }
                 let differentVariant = MatchCase(
-                    at = at,
+                    at = at
                     patterns = [wildcardPattern, wildcardPattern]
                     guards = []
                     body =
-                        EFunctions(at,
-                            [DFunction(at, numberSignature, FireflyTarget(Lambda(at, noEffect, numberCases)))],
+                        EFunctions(at
+                            [DFunction(at, numberSignature, Lambda(at, noEffect, numberCases))]
                             self.makeSimpleCall(at, "ff:core/Ordering.compare", [
                                 self.makeSimpleCall(at, "number", [EVariable(at, "x")])
                                 self.makeSimpleCall(at, "number", [EVariable(at, "y")])
@@ -350,9 +346,8 @@ extend self: Deriver {
             returnType = TConstructor(at, "ff:core/Bool.Bool", [])
             effect = noEffect
         )
-        let body = FireflyTarget(
+        let body =
             Lambda(at, noEffect, self.makeEqualsCases(modulePrefix, declaration, selfType))
-        )
         let equalsMethod = DFunction(at, signature, body)
         DInstance(
             at = at
@@ -484,17 +479,14 @@ extend self: Deriver {
             effect = noEffect
         )
         let wildcardPattern = PVariable(at, None)
-        let serializeBody = FireflyTarget(
+        let serializeBody = 
             Lambda(at, noEffect, self.makeSerializeBody(modulePrefix, declaration, selfType))
-        )
-        let deserializeBody = FireflyTarget(
-            Lambda(at, noEffect, [MatchCase(
-                at = at
-                patterns = [wildcardPattern]
-                guards = []
-                body = self.makeDeserializeBody(modulePrefix, declaration, selfType)
-            )])
-        )
+        let deserializeBody = Lambda(at, noEffect, [MatchCase(
+            at = at
+            patterns = [wildcardPattern]
+            guards = []
+            body = self.makeDeserializeBody(modulePrefix, declaration, selfType)
+        )])
         DInstance(
             at = at
             generics = declaration.generics

package/compiler/Dictionaries.ff

@@ -53,7 +53,7 @@ extend self: Dictionaries {
         let instances = constraintsToInstances(definition.signature.constraints)
         let self2 = self.Dictionaries(instances = self.instances.addAll(instances))
         definition.DFunction(
-            body = definition.body.mapFirefly {self2.processLambda(functions, _)}
+            body = self2.processLambda(functions, definition.body)
         )
     }
 

package/compiler/Inference.ff

@@ -149,15 +149,13 @@ extend self: Inference {
                 constraints = [...definition.constraints, ...method.signature.constraints]
                 parameters = [selfParameter, ...method.signature.parameters]
             )
-            let body = method.body.mapFirefly {lambda =>
-                lambda.Lambda(
-                    cases = lambda.cases.map {case =>
-                        case.MatchCase(
-                            patterns = [PVariable(method.at, None), ...case.patterns]
-                        )
-                    }
-                )
-            }
+            let body = method.body.Lambda(
+                cases = method.body.cases.map {case =>
+                    case.MatchCase(
+                        patterns = [PVariable(method.at, None), ...case.patterns]
+                    )
+                }
+            )
             let function = method.DFunction(
                 signature = signature
                 body = body
@@ -198,7 +196,7 @@ extend self: Inference {
         let instances = constraintsToInstances(definition.signature.constraints)
         self.unification.withLocalInstances(instances) {
             definition.DFunction(
-                body = definition.body.mapFirefly {self.inferLambda(environment2, functionType, _)}
+                body = self.inferLambda(environment2, functionType, definition.body)
             )
         }
     }
@@ -765,12 +763,19 @@ extend self: Inference {
         signature: Signature
     ): Term {
         let t = signature.returnType
-        if(operator == "+" || operator == "-") {
-            self.unification.unify(at, t, TConstructor(at, core("Int"), []))
+        let newValue = self.inferTerm(environment, t, value)
+        if(operator == "+" || operator == "-" || operator == "*" || operator == "/") {
+            self.unification.substitute(t).{
+                | TConstructor(_, name, _) {
+                    name == core("Int") || name == core("Float") || name == core("JsValue") ||
+                    (name == core("String") && operator == "+")
+                } => 
+                | _ => 
+                    self.unification.unify(at, t, TConstructor(at, core("Int"), []))
+            }
         } elseIf {operator != ""} {
-            throw(CompileError(at, "Only +=, -= and = assignments are supported. Got: " + operator + "="))
+            throw(CompileError(at, "Only +=, -=, *=, /= and = assignments are supported. Got: " + operator + "="))
         }
-        let newValue = self.inferTerm(environment, t, value)
         self.unification.unify(at, expected, TConstructor(at, core("Unit"), []))
         newValue
     }
@@ -818,18 +823,29 @@ extend self: Inference {
     ): Term {
         term.{
             | ECall e =>
+                mutable isUnsafeJsAwaitCall = False
                 let tailCall = e.target.{
-                    | DynamicCall call => call.tailCall
-                    | StaticCall _ => fail(e.at, "Internal error: Static calls not expected in inferFunctionCall")
+                    | DynamicCall call => 
+                        call.function.{
+                            | EVariable(_, "ff:core/Js.await") => 
+                                isUnsafeJsAwaitCall = True
+                            | EVariable(_, "ff:core/Js.awaitCancellablePromise") => 
+                                isUnsafeJsAwaitCall = True
+                            | _ => 
+                        }
+                        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)
+                let effect = if(isUnsafeJsAwaitCall) {TConstructor(term.at, "Q$", [])} else {signature.effect}
+                self.unification.affect(term.at, effect, environment.effect)
                 e.ECall(
                     target = StaticCall(name, instanceCall = instanceCall, tailCall = tailCall)
                     typeArguments = instantiation.map {_.second}
                     arguments = arguments
-                    effect = signature.effect
+                    effect = effect
                 )
             | _ => fail(term.at, "Call expected")
         }
@@ -941,6 +957,7 @@ extend self: Inference {
                         let e2 = self.inferTerm(environment, t2, a2.value)
                         let magic: Type => Option[String] = {t =>
                             self.unification.substitute(t).{
+                                | TConstructor(_, name, []) {name == core("JsValue")} => Some("JsValue")
                                 | TConstructor(_, name, []) {name == core("Float")} => Some("Float")
                                 | TConstructor(_, name, []) {name == core("Int")} => Some("Int")
                                 | TConstructor(_, name, []) {operator == "+" && name == core("String")} => Some("String")
@@ -948,6 +965,12 @@ extend self: Inference {
                             }
                         }
                         let chooseType: (Option[String], Option[String]) => Unit = {
+                            | Some("JsValue"), _ =>
+                                self.unification.unify(e2.at, t1, t2)
+                                self.unification.unify(e.at, expected, t1)
+                            | _, Some("JsValue") =>
+                                self.unification.unify(e1.at, t2, t1)
+                                self.unification.unify(e.at, expected, t2)
                             | 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)
@@ -955,10 +978,10 @@ extend self: Inference {
                             | 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(e2.at, t1, t2)
                                 self.unification.unify(e.at, expected, t1)
                             | None, Some(_) =>
-                                self.unification.unify(e.at, t2, t1)
+                                self.unification.unify(e1.at, t2, t1)
                                 self.unification.unify(e.at, expected, t2)
                             | _, _ {self.lspHook.isEnabled()} =>
                             | Some(_), Some(_) =>