firefly-compiler 0.5.35 → 0.5.36

package/compiler/ModuleCache.ff

@@ -1,178 +1,178 @@
-import Syntax
-
-class ModuleCache(
-    version: Int
-    mutable parsedModules: Map[String, Pair[Module, Int]]
-    mutable resolvedModules: Map[String, Pair[Module, Int]]
-    mutable derivedModules: Map[String, Pair[Module, Int]]
-    mutable inferredModules: Map[String, Pair[Module, Int]]
-    mutable emittedModules: Map[String, Int]
-)
-
-new(version: Int): ModuleCache {
-    ModuleCache(
-        version = version
-        parsedModules = Map.new()
-        resolvedModules = Map.new()
-        derivedModules = Map.new()
-        inferredModules = Map.new()
-        emittedModules = Map.new()
-    )
-}
-
-extend self: ModuleCache {
-    
-    remove(keys: List[String]) {
-        if(!keys.isEmpty()):
-        self.parsedModules = self.parsedModules.removeList(keys)
-        self.resolvedModules = self.resolvedModules.removeList(keys)
-        self.derivedModules = self.derivedModules.removeList(keys)
-        self.inferredModules = self.inferredModules.removeList(keys)
-        self.emittedModules = self.emittedModules.removeList(keys)
-    }
-    
-    invalidate(key: String) {
-        //Log.trace("Invalidate: " + uri)
-        self.parsedModules.get(key).each: | Pair(module, _) =>
-        let moduleName = module.file.dropLast(3)
-        self.remove([key])
-        self.parsedModules.each {| k, Pair(m, _) =>
-            if(m.imports.any {i => i.package == module.packagePair && i.file == moduleName}) {
-                //Log.trace("Invalidating due to import of invalidated module: " + m.packagePair.groupName() + "/" + m.file)
-                self.remove([k])
-            }
-        }
-    }
-    
-    filesNotImporting(packagePair: PackagePair, moduleName: String): List[String] {
-        self.parsedModules.toList().collect {| Pair(k, Pair(m, _)) =>
-            if(!m.imports.any {i => i.package == packagePair && i.file == moduleName}): k
-        }
-    }
-    
-    without(newVersion: Int, path: Path): ModuleCache {
-        let key = path.absolute()
-        if(path.isFile()) {
-            self.ModuleCache(
-                version = newVersion
-                parsedModules = self.parsedModules.remove(key)
-                resolvedModules = self.resolvedModules.remove(key)
-                derivedModules = self.derivedModules.remove(key)
-                inferredModules = self.inferredModules.remove(key)
-                emittedModules = self.emittedModules.remove(key)
-            )
-        } else {
-            function invalidated(p: String): Bool {
-                p.startsWith(key) && !p.contains(".firefly/dependencies") && !p.contains(".firefly\\dependencies")
-            }
-            self.ModuleCache(
-                version = newVersion
-                parsedModules = self.parsedModules.toList().filter {| Pair(p, _) => !invalidated(p)}.toMap()
-                resolvedModules = self.resolvedModules.toList().filter {| Pair(p, _) => !invalidated(p)}.toMap()
-                derivedModules = self.derivedModules.toList().filter {| Pair(p, _) => !invalidated(p)}.toMap()
-                inferredModules = self.inferredModules.toList().filter {| Pair(p, _) => !invalidated(p)}.toMap()
-                emittedModules = self.emittedModules.toList().filter {| Pair(p, _) => !invalidated(p)}.toMap()
-            )
-        }
-    }
-    
-    mergeVersions(cache: ModuleCache): Unit {
-        self.parsedModules = mergeVersionedMap(self.parsedModules, cache.parsedModules) {_.second}
-        self.resolvedModules = mergeVersionedMap(self.resolvedModules, cache.resolvedModules) {_.second}
-        self.derivedModules = mergeVersionedMap(self.derivedModules, cache.derivedModules) {_.second}
-        self.inferredModules = mergeVersionedMap(self.inferredModules, cache.inferredModules) {_.second}
-        self.emittedModules = mergeVersionedMap(self.emittedModules, cache.emittedModules) {_}
-    }
-    
-    cacheParsedModule(
-        packagePaths: Map[PackagePair, Path]
-        packagePair: PackagePair
-        moduleName: String
-        body: Path => Module
-    ): Module {
-        let path = modulePath(packagePaths, packagePair, moduleName)
-        self.parsedModules.get(path.absolute()).map {_.first}.else:
-        let result = body(path)
-        self.parsedModules = self.parsedModules.add(path.absolute(), Pair(result, self.version))
-        result
-    }
-    
-    cacheResolvedModule(
-        packagePaths: Map[PackagePair, Path]
-        packagePair: PackagePair
-        moduleName: String
-        body: Path => Module
-    ): Module {
-        let path = modulePath(packagePaths, packagePair, moduleName)
-        self.resolvedModules.get(path.absolute()).map {_.first}.else:
-        let result = body(path)
-        self.resolvedModules = self.resolvedModules.add(path.absolute(), Pair(result, self.version))
-        result
-    }
-
-    cacheDerivedModule(
-        packagePaths: Map[PackagePair, Path]
-        packagePair: PackagePair
-        moduleName: String
-        body: Path => Module
-    ): Module {
-        let path = modulePath(packagePaths, packagePair, moduleName)
-        self.derivedModules.get(path.absolute()).map {_.first}.else:
-        let result = body(path)
-        self.derivedModules = self.derivedModules.add(path.absolute(), Pair(result, self.version))
-        result
-    }
-        
-    cacheInferredModule(
-        packagePaths: Map[PackagePair, Path]
-        packagePair: PackagePair
-        moduleName: String
-        body: Path => Module
-    ): Module {
-        let path = modulePath(packagePaths, packagePair, moduleName)
-        self.inferredModules.get(path.absolute()).map {_.first}.else:
-        let result = body(path)
-        self.inferredModules = self.inferredModules.add(path.absolute(), Pair(result, self.version))
-        result
-    }
- 
-    cacheEmittedModule(
-        packagePaths: Map[PackagePair, Path]
-        packagePair: PackagePair
-        moduleName: String
-        body: Path => Unit
-    ): Unit {
-        let path = modulePath(packagePaths, packagePair, moduleName)
-        if(!self.emittedModules.contains(path.absolute())):
-        self.emittedModules = self.emittedModules.add(path.absolute(), self.version)
-        try {
-            body(path)
-        } catchAny {error =>
-            self.emittedModules = self.emittedModules.remove(path.absolute())
-            error.rethrow()
-        }
-    }
-    
-}
-
-mergeVersionedMap[T](oldMap: Map[String, T], newMap: Map[String, T], getVersion: T => Int): Map[String, T] {
-    mutable result = newMap
-    oldMap.each {k, v =>
-        if(!newMap.get(k).any {getVersion(_) >= getVersion(v)}) {
-            result = result.add(k, v)
-        }
-    }
-    result
-}
-
-modulePath(
-    packagePaths: Map[PackagePair, Path]
-    packagePair: PackagePair
-    moduleName: String
-): Path {
-    let packagePath = packagePaths.get(packagePair).else {
-        panic("Internal error - package path missing: " + packagePair.groupName())
-    }
-    let file = moduleName + ".ff"
-    packagePath.slash(file)
-}
+import Syntax
+
+class ModuleCache(
+    version: Int
+    mutable parsedModules: Map[String, Pair[Module, Int]]
+    mutable resolvedModules: Map[String, Pair[Module, Int]]
+    mutable derivedModules: Map[String, Pair[Module, Int]]
+    mutable inferredModules: Map[String, Pair[Module, Int]]
+    mutable emittedModules: Map[String, Int]
+)
+
+new(version: Int): ModuleCache {
+    ModuleCache(
+        version = version
+        parsedModules = Map.new()
+        resolvedModules = Map.new()
+        derivedModules = Map.new()
+        inferredModules = Map.new()
+        emittedModules = Map.new()
+    )
+}
+
+extend self: ModuleCache {
+    
+    remove(keys: List[String]) {
+        if(!keys.isEmpty()):
+        self.parsedModules = self.parsedModules.removeList(keys)
+        self.resolvedModules = self.resolvedModules.removeList(keys)
+        self.derivedModules = self.derivedModules.removeList(keys)
+        self.inferredModules = self.inferredModules.removeList(keys)
+        self.emittedModules = self.emittedModules.removeList(keys)
+    }
+    
+    invalidate(key: String) {
+        //Log.trace("Invalidate: " + uri)
+        self.parsedModules.get(key).each: | Pair(module, _) =>
+        let moduleName = module.file.dropLast(3)
+        self.remove([key])
+        self.parsedModules.each {| k, Pair(m, _) =>
+            if(m.imports.any {i => i.package == module.packagePair && i.file == moduleName}) {
+                //Log.trace("Invalidating due to import of invalidated module: " + m.packagePair.groupName() + "/" + m.file)
+                self.remove([k])
+            }
+        }
+    }
+    
+    filesNotImporting(packagePair: PackagePair, moduleName: String): List[String] {
+        self.parsedModules.toList().collect {| Pair(k, Pair(m, _)) =>
+            if(!m.imports.any {i => i.package == packagePair && i.file == moduleName}): k
+        }
+    }
+    
+    without(newVersion: Int, path: Path): ModuleCache {
+        let key = path.absolute()
+        if(path.isFile()) {
+            self.ModuleCache(
+                version = newVersion
+                parsedModules = self.parsedModules.remove(key)
+                resolvedModules = self.resolvedModules.remove(key)
+                derivedModules = self.derivedModules.remove(key)
+                inferredModules = self.inferredModules.remove(key)
+                emittedModules = self.emittedModules.remove(key)
+            )
+        } else {
+            function invalidated(p: String): Bool {
+                p.startsWith(key) && !p.contains(".firefly/dependencies") && !p.contains(".firefly\\dependencies")
+            }
+            self.ModuleCache(
+                version = newVersion
+                parsedModules = self.parsedModules.toList().filter {| Pair(p, _) => !invalidated(p)}.toMap()
+                resolvedModules = self.resolvedModules.toList().filter {| Pair(p, _) => !invalidated(p)}.toMap()
+                derivedModules = self.derivedModules.toList().filter {| Pair(p, _) => !invalidated(p)}.toMap()
+                inferredModules = self.inferredModules.toList().filter {| Pair(p, _) => !invalidated(p)}.toMap()
+                emittedModules = self.emittedModules.toList().filter {| Pair(p, _) => !invalidated(p)}.toMap()
+            )
+        }
+    }
+    
+    mergeVersions(cache: ModuleCache): Unit {
+        self.parsedModules = mergeVersionedMap(self.parsedModules, cache.parsedModules) {_.second}
+        self.resolvedModules = mergeVersionedMap(self.resolvedModules, cache.resolvedModules) {_.second}
+        self.derivedModules = mergeVersionedMap(self.derivedModules, cache.derivedModules) {_.second}
+        self.inferredModules = mergeVersionedMap(self.inferredModules, cache.inferredModules) {_.second}
+        self.emittedModules = mergeVersionedMap(self.emittedModules, cache.emittedModules) {_}
+    }
+    
+    cacheParsedModule(
+        packagePaths: Map[PackagePair, Path]
+        packagePair: PackagePair
+        moduleName: String
+        body: Path => Module
+    ): Module {
+        let path = modulePath(packagePaths, packagePair, moduleName)
+        self.parsedModules.get(path.absolute()).map {_.first}.else:
+        let result = body(path)
+        self.parsedModules = self.parsedModules.add(path.absolute(), Pair(result, self.version))
+        result
+    }
+    
+    cacheResolvedModule(
+        packagePaths: Map[PackagePair, Path]
+        packagePair: PackagePair
+        moduleName: String
+        body: Path => Module
+    ): Module {
+        let path = modulePath(packagePaths, packagePair, moduleName)
+        self.resolvedModules.get(path.absolute()).map {_.first}.else:
+        let result = body(path)
+        self.resolvedModules = self.resolvedModules.add(path.absolute(), Pair(result, self.version))
+        result
+    }
+
+    cacheDerivedModule(
+        packagePaths: Map[PackagePair, Path]
+        packagePair: PackagePair
+        moduleName: String
+        body: Path => Module
+    ): Module {
+        let path = modulePath(packagePaths, packagePair, moduleName)
+        self.derivedModules.get(path.absolute()).map {_.first}.else:
+        let result = body(path)
+        self.derivedModules = self.derivedModules.add(path.absolute(), Pair(result, self.version))
+        result
+    }
+        
+    cacheInferredModule(
+        packagePaths: Map[PackagePair, Path]
+        packagePair: PackagePair
+        moduleName: String
+        body: Path => Module
+    ): Module {
+        let path = modulePath(packagePaths, packagePair, moduleName)
+        self.inferredModules.get(path.absolute()).map {_.first}.else:
+        let result = body(path)
+        self.inferredModules = self.inferredModules.add(path.absolute(), Pair(result, self.version))
+        result
+    }
+ 
+    cacheEmittedModule(
+        packagePaths: Map[PackagePair, Path]
+        packagePair: PackagePair
+        moduleName: String
+        body: Path => Unit
+    ): Unit {
+        let path = modulePath(packagePaths, packagePair, moduleName)
+        if(!self.emittedModules.contains(path.absolute())):
+        self.emittedModules = self.emittedModules.add(path.absolute(), self.version)
+        try {
+            body(path)
+        } catchAny {error =>
+            self.emittedModules = self.emittedModules.remove(path.absolute())
+            error.rethrow()
+        }
+    }
+    
+}
+
+mergeVersionedMap[T](oldMap: Map[String, T], newMap: Map[String, T], getVersion: T => Int): Map[String, T] {
+    mutable result = newMap
+    oldMap.each {k, v =>
+        if(!newMap.get(k).any {getVersion(_) >= getVersion(v)}) {
+            result = result.add(k, v)
+        }
+    }
+    result
+}
+
+modulePath(
+    packagePaths: Map[PackagePair, Path]
+    packagePair: PackagePair
+    moduleName: String
+): Path {
+    let packagePath = packagePaths.get(packagePair).else {
+        panic("Internal error - package path missing: " + packagePair.groupName())
+    }
+    let file = moduleName + ".ff"
+    packagePath.slash(file)
+}

package/compiler/Parser.ff

@@ -17,18 +17,6 @@ class Parser(
 
 data Poly(generics: List[String], constraints: List[Constraint])
 
-data ParsedTargets(
-    js: Option[Lambda]
-    jsSync: Option[String]
-    jsAsync: Option[String]
-    browser: Option[Lambda]
-    browserSync: Option[String]
-    browserAsync: Option[String]
-    node: Option[Lambda]
-    nodeSync: Option[String]
-    nodeAsync: Option[String]
-)
-
 new(
     packagePair: PackagePair 
     file: String
@@ -245,13 +233,11 @@ extend self: Parser {
     parseFunctionDefinition(member: Bool): DFunction {
         if(self.lspHook.trackSymbols) {self.lspHook.emit(ParseSymbolBegin)}
         let signature = self.parseSignature(member)
-        let body = if(self.current().rawIs("{")) {self.parseLambda(signature.parameters.size())}
-        let targets = self.parseTargets(signature.parameters.size())
-        let bestTarget = findBestTarget(self.targetIsNode, body, targets)
+        let body = self.parseLambda(signature.parameters.size())
         let result = DFunction(
             signature.at
             signature
-            bestTarget
+            body
         )
         if(self.lspHook.trackSymbols) {
             self.lspHook.emit(ParseSymbolEnd(
@@ -266,66 +252,6 @@ extend self: Parser {
         result
     }
 
-    parseTargets(parameterCount: Int): ParsedTargets {
-        function processCode(code: String): String {
-            let dropCount = if(code.startsWith("\"\"\"")) {3} else {1}
-            code.dropFirst(dropCount).dropLast(dropCount)
-                .replace("\\\"", "\"")
-                .replace("\\r", "\r")
-                .replace("\\n", "\n")
-                .replace("\\t", "\t")
-                .replace("\\\\", "\\")
-        }
-        mutable targets = ParsedTargets(None, None, None, None, None, None, None, None, None)
-        while {self.currentIsSeparator(LSemicolon) && self.ahead().is(LKeyword) && self.ahead().rawIs("target")} {
-            self.skip(LSeparator)
-            let at = self.skip(LKeyword).at()
-            let target = if(self.current().is(LLower)) {self.skip(LLower).raw()} else {self.skip(LKeyword).raw()}
-            if(self.current().rawIs("{")) {
-                let lambda = self.parseLambda(parameterCount)
-                target.{
-                    | "js" =>
-                        if(targets.jsSync != None) {throw(CompileError(at, "Duplicate target definition"))}
-                        targets = targets.ParsedTargets(js = Some(lambda))
-                    | "browser" =>
-                        if(targets.browserSync != None) {throw(CompileError(at, "Duplicate target definition"))}
-                        targets = targets.ParsedTargets(browser = Some(lambda))
-                    | "node" =>
-                        if(targets.nodeAsync != None) {throw(CompileError(at, "Duplicate target definition"))}
-                        targets = targets.ParsedTargets(node = Some(lambda))
-                    | _ =>
-                        throw(CompileError(at, "Unknown target"))
-                }
-            } else {
-                let mode = self.skip(LKeyword).raw()
-                let code = processCode(self.skip(LString).raw())
-                Pair(target, mode).{
-                    | Pair("js", "sync") =>
-                        if(targets.jsSync != None) {throw(CompileError(at, "Duplicate target definition"))}
-                        targets = targets.ParsedTargets(jsSync = Some(code))
-                    | Pair("js", "async") =>
-                        if(targets.jsAsync != None) {throw(CompileError(at, "Duplicate target definition"))}
-                        targets = targets.ParsedTargets(jsAsync = Some(code))
-                    | Pair("browser", "sync") =>
-                        if(targets.browserSync != None) {throw(CompileError(at, "Duplicate target definition"))}
-                        targets = targets.ParsedTargets(browserSync = Some(code))
-                    | Pair("browser", "async") =>
-                        if(targets.browserAsync != None) {throw(CompileError(at, "Duplicate target definition"))}
-                        targets = targets.ParsedTargets(browserAsync = Some(code))
-                    | Pair("node", "sync") =>
-                        if(targets.nodeSync != None) {throw(CompileError(at, "Duplicate target definition"))}
-                        targets = targets.ParsedTargets(nodeSync = Some(code))
-                    | Pair("node", "async") =>
-                        if(targets.nodeAsync != None) {throw(CompileError(at, "Duplicate target definition"))}
-                        targets = targets.ParsedTargets(nodeAsync = Some(code))
-                    | Pair(_, _) =>
-                        throw(CompileError(at, "Unknown target or mode"))
-                }
-            }
-        }
-        targets
-    }
-
     parseSignature(member: Bool): Signature {
         let nameToken = self.skip(LLower)
         let poly = if(self.current().rawIs("[")) {self.parseTypeParameters()} else {Poly([], [])}
@@ -1025,10 +951,14 @@ extend self: Parser {
         if(self.current().is(LKeyword) && (self.current().rawIs("let") || self.current().rawIs("mutable"))) {self.parseLet()} else:
         if(self.current().is(LKeyword) && self.current().rawIs("function")) {self.parseFunctions()} else:
         let term = self.parseTerm()
-        if(!self.current().is(LAssign) && !self.current().is2(LAssignPlus, LAssignMinus)) {term} else:
+        if(!self.current().is5(
+            LAssign, LAssignPlus, LAssignMinus, LAssignMultiplication, LAssignDivision
+        )) {term} else:
         let token = do {
             if(self.current().is(LAssignPlus)) {self.skip(LAssignPlus)} else:
             if(self.current().is(LAssignMinus)) {self.skip(LAssignMinus)} else:
+            if(self.current().is(LAssignMultiplication)) {self.skip(LAssignMultiplication)} else:
+            if(self.current().is(LAssignDivision)) {self.skip(LAssignDivision)} else:
             self.skip(LAssign)
         }
         let operator = token.raw().dropLast(1)
@@ -1088,7 +1018,7 @@ extend self: Parser {
             } else {
                 self.parseLambda(defaultParameterCount = signature.parameters.size())
             }
-            functions.push(DFunction(signature.at, signature, FireflyTarget(body)))
+            functions.push(DFunction(signature.at, signature, body))
             if(self.lspHook.trackSymbols) {
                 self.lspHook.emit(ParseSymbolEnd(
                     name = signature.name
@@ -1126,6 +1056,8 @@ extend self: Parser {
                     | "<=" => DynamicCall(EVariable(token.at(), "ff:core/Ordering.notAfter"), False)
                     | ">" => DynamicCall(EVariable(token.at(), "ff:core/Ordering.after"), False)
                     | ">=" => DynamicCall(EVariable(token.at(), "ff:core/Ordering.notBefore"), False)
+                    | "===" => DynamicCall(EVariable(token.at(), "ff:core/JsValue.JsValue_equals"), False)
+                    | "!==" => DynamicCall(EVariable(token.at(), "ff:core/JsValue.JsValue_notEquals"), False)
                     | o => DynamicCall(EVariable(token.at(), o), False)
                 }
                 result = ECall(token.at(), target, effect, [], arguments, [])
@@ -1166,10 +1098,10 @@ extend self: Parser {
                     result = EField(token.at(), False, result, token.raw())
                 }
             } elseIf {self.current().is(LArrowThin)} {
-                result = self.parseDynamicMember(result)
+                result = self.parseDynamicMember(result, False)
             } elseIf {self.current().is(LUnary)} {
                 let token = self.skip(LUnary)
-                let method = if(token.rawIs("!")) {"ff:core/UnsafeJs.value"} else {"ff:core/UnsafeJs.fromValue"}
+                let method = if(token.rawIs("!")) {"ff:core/Js.value"} else {"ff:core/Js.fromValue"}
                 let target = DynamicCall(EVariable(token.at(), method), False)
                 let effect = self.freshUnificationVariable(token.at())
                 result = ECall(token.at(), target, effect, [], [
@@ -1191,17 +1123,23 @@ extend self: Parser {
         result
     }
     
-    parseDynamicMember(record: Term): Term {
+    parseDynamicMember(record: Term, isModule: Bool): Term {
+        function recordField(at: Location, name: String): Term {
+            record.{
+                | EVariant e {isModule} => EVariable(at, e.name + "." + name)
+                | _ => EField(at, False, record, name)
+            }
+        }
         let token = self.skip(LArrowThin)
         if(self.current().rawIs("(")) {
             let arguments = self.parseFunctionArguments(token.at(), trailing = False)
             let effect = self.freshUnificationVariable(record.at)
             arguments.first.indexWhere {!_.name.isEmpty()}.{
                 | None =>
-                    let target = DynamicCall(EField(token.at(), False, record, "new" + arguments.first.size()), False)
+                    let target = DynamicCall(recordField(token.at(), "new" + arguments.first.size()), False)
                     ECall(record.at, target, effect, [], arguments.first, [])
                 | Some(0) => 
-                    let objectTarget = DynamicCall(EField(token.at(), False, record, "object"), False)
+                    let objectTarget = DynamicCall(recordField(token.at(), "object"), False)
                     mutable result = ECall(record.at, objectTarget, effect, [], [], [])
                     arguments.first.each {argument =>
                         if(argument.name.isEmpty()) {
@@ -1221,7 +1159,7 @@ extend self: Parser {
             let lambda = self.parseLambda()
             let effect = self.freshUnificationVariable(record.at)
             let arguments = lambda.cases.grabFirst().patterns.size()
-            let target = DynamicCall(EField(token.at(), False, record, "function" + arguments), False)
+            let target = DynamicCall(recordField(token.at(), "function" + arguments), False)
             ECall(record.at, target, effect, [], [
                 Argument(lambda.at, None, ELambda(lambda.at, lambda))
             ], [])
@@ -1240,12 +1178,12 @@ extend self: Parser {
                 throw(CompileError(argument.at, "Unexpected named argument"))
             }
             let effect = self.freshUnificationVariable(record.at)
-            let target = DynamicCall(EField(token.at(), False, record, "call" + arguments.first.size()), False)
+            let target = DynamicCall(recordField(token.at(), "call" + arguments.first.size()), False)
             ECall(record.at, target, effect, [], [
                 Argument(member.at, None, member)
                 ...arguments.first
             ], [])
-        } elseIf {self.current().is3(LAssign, LAssignPlus, LAssignMinus)} {
+        } elseIf {self.current().is5(LAssign, LAssignPlus, LAssignMinus, LAssignMultiplication, LAssignDivision)} {
             let method = 
                 if(self.current().is(LAssign)) {
                     self.skip(LAssign)
@@ -1253,20 +1191,26 @@ extend self: Parser {
                 } elseIf {self.current().is(LAssignPlus)} {
                     self.skip(LAssignPlus)
                     "increment"
-                } else {
+                } elseIf {self.current().is(LAssignMinus)} {
                     self.skip(LAssignMinus)
                     "decrement"
+                } elseIf {self.current().is(LAssignMultiplication)} {
+                    self.skip(LAssignMultiplication)
+                    "multiply"
+                } else {
+                    self.skip(LAssignDivision)
+                    "divide"
                 }
             let value = self.parseTerm()
             let effect = self.freshUnificationVariable(record.at)
-            let target = DynamicCall(EField(token.at(), False, record, "set"), False)
+            let target = DynamicCall(recordField(token.at(), method), False)
             ECall(record.at, target, effect, [], [
                 Argument(member.at, None, member)
                 Argument(value.at, None, value)
             ], [])
         } else {
             let effect = self.freshUnificationVariable(record.at)
-            let target = DynamicCall(EField(token.at(), False, record, "get"), False)
+            let target = DynamicCall(recordField(token.at(), "get"), False)
             ECall(record.at, target, effect, [], [
                 Argument(member.at, None, member)
             ], [])
@@ -1299,6 +1243,8 @@ extend self: Parser {
             } else {
                 self.parseVariant(prefix)
             }
+        } elseIf {self.current().is(LUpper) && self.ahead().is(LArrowThin)} {
+            self.parseDynamicMember(self.parseVariant(""), True)
         } elseIf {self.current().is(LUpper)} {
             self.parseVariant("")
         } elseIf {self.current().rawIs("{")} {
@@ -1445,28 +1391,9 @@ extend self: Parser {
 binaryOperators = [
     ["||"]
     ["&&"]
-    ["!=", "=="]
+    ["!=", "==", "!==", "==="]
     ["<=", ">=", "<", ">"]
     ["+", "-"]
     ["*", "/", "%"]
     ["^"]
 ]
-
-findBestTarget(targetIsNode: Bool, body: Option[Lambda], targets: ParsedTargets): Target {
-    let foreignTarget = if(targetIsNode) {
-        let sync = targets.nodeSync.orElse {targets.jsSync}
-        let async = targets.nodeAsync.orElse {targets.jsAsync}
-        ForeignTarget(sync, async)
-    } else {
-        let sync = targets.browserSync.orElse {targets.jsSync}
-        let async = targets.browserAsync.orElse {targets.jsAsync}
-        ForeignTarget(sync, async)
-    }
-    foreignTarget.{
-        | ForeignTarget(None, None) {targetIsNode} =>
-            targets.node.orElse {targets.js.orElse {body}}.map {FireflyTarget(_)}.else {foreignTarget}
-        | ForeignTarget(None, None) {!targetIsNode} =>
-            targets.browser.orElse {targets.js.orElse {body}}.map {FireflyTarget(_)}.else {foreignTarget}
-        | _ => foreignTarget
-    }
-}

package/compiler/Resolver.ff

@@ -212,12 +212,9 @@ extend self: Resolver {
             methods = definition.methods.map {self2.resolveSignature(_, True, False)}
             methodDefaults = definition.methodDefaults.map {| Pair(name, lambda) =>
                 let signature = definition.methods.find {_.name == name}.grab()
-                let function1 = DFunction(signature.at, signature, FireflyTarget(lambda))
+                let function1 = DFunction(signature.at, signature, lambda)
                 let function2 = self2.resolveFunctionDefinition(function1, True, False)
-                Pair(name, function2.body.{
-                    | FireflyTarget(lambda) => lambda
-                    | _ => throw(CompileError(signature.at, "Internal error: Expected method default to be a lambda"))
-                })
+                Pair(name, function2.body)
             }
         )
     }
@@ -490,10 +487,10 @@ extend self: Resolver {
     resolveFunctionDefinition(definition: DFunction, topLevel: Bool, isInstanceMethod: Bool): DFunction {
         let signature = self.resolveSignature(definition.signature, topLevel, isInstanceMethod)
         let self2 = self.withSignature(signature)
-        let body = definition.body.mapFirefly {lambda => lambda.Lambda(
+        let body = definition.body.Lambda(
             effect = signature.effect
-            cases = lambda.cases.map {self2.resolveCase(_, False)}
-        )}
+            cases = definition.body.cases.map {self2.resolveCase(_, False)}
+        )
         DFunction(definition.at, signature, body)
     }
 

package/compiler/Substitution.ff

@@ -39,7 +39,7 @@ extend self: Substitution {
     substituteFunctionDefinition(definition: DFunction): DFunction {
         definition.DFunction(
             signature = self.substituteSignature(definition.signature)
-            body = definition.body.mapFirefly {self.substituteLambda(_)}
+            body = self.substituteLambda(definition.body)
         )
     }