firefly-compiler 0.4.19 → 0.4.21

package/compiler/Resolver.ff

@@ -49,16 +49,16 @@ extend self: Resolver {
 
     resolveModule(module: Module, otherModules: List[Module]): Module {
         let moduleNamespace =
-            module.file.replace("\\", "/").reverse().takeWhile { _ != '/' }.reverse().takeWhile { _ != '.' }
+            module.file.replace("\\", "/").reverse().takeWhile {_ != '/'}.reverse().takeWhile {_ != '.'}
         let self2 = self.processImports(module.imports, otherModules)
         let self3 = self2.processDefinitions(module, None)
         let module2 = module.Module(
-            types = module.types.map { self3.resolveTypeDefinition(_) }
-            traits = module.traits.map { self3.resolveTraitDefinition(_) }
-            instances = module.instances.map { self3.resolveInstanceDefinition(_) }
-            extends = module.extends.map { self3.resolveExtendDefinition(_) }
-            lets = module.lets.map { self3.resolveLetDefinition(_, True) }
-            functions = module.functions.map { self3.resolveFunctionDefinition(_, True, False) }
+            types = module.types.map {self3.resolveTypeDefinition(_)}
+            traits = module.traits.map {self3.resolveTraitDefinition(_)}
+            instances = module.instances.map {self3.resolveInstanceDefinition(_)}
+            extends = module.extends.map {self3.resolveExtendDefinition(_)}
+            lets = module.lets.map {self3.resolveLetDefinition(_, True)}
+            functions = module.functions.map {self3.resolveFunctionDefinition(_, True, False)}
         )
         module2.instances.each {_.typeArguments.each {self3.checkInstanceType(_)}}
         module2
@@ -135,7 +135,7 @@ extend self: Resolver {
     resolveTypeDefinition(definition: DType): DType {
         if(self.lspHook.isAt(definition.at)) {
             self.lspHook.emit(
-                ResolveSymbolHook(SymbolHook(definition.name, definition.at, definition.at), None)
+                ResolveSymbolHook(SymbolHook(definition.name, definition.at, definition.at), None, topLevel = True)
             )
         }
         let generics = definition.generics.map {g => Pair(g, g)}.toMap()
@@ -168,7 +168,7 @@ extend self: Resolver {
             variants = definition.variants.map {v =>
                 if(self.lspHook.isAt(v.at)) {
                     self.lspHook.emit(
-                        ResolveSymbolHook(SymbolHook(v.name, v.at, v.at), None)
+                        ResolveSymbolHook(SymbolHook(v.name, v.at, v.at), None, topLevel = True)
                     )
                 }
                 v.Variant(fields = v.fields.map {f =>
@@ -191,7 +191,7 @@ extend self: Resolver {
         if(self.lspHook.isAt(definition.at) || self.lspHook.isDefinedAt(definition.at)) {
             self.lspHook.emit(
                 ResolveSymbolHook(
-                    SymbolHook(definition.name, definition.at, definition.at), None
+                    SymbolHook(definition.name, definition.at, definition.at), None, topLevel = True
                 )
             )
         }        
@@ -221,7 +221,7 @@ extend self: Resolver {
         if(self.lspHook.isAt(definition.at) || self.lspHook.isDefinedAt(traitDefinedAt)) {
             self.lspHook.emit(
                 ResolveSymbolHook(
-                    SymbolHook(definition.traitName, definition.at, traitDefinedAt), None
+                    SymbolHook(definition.traitName, definition.at, traitDefinedAt), None, topLevel = True
                 )
             )
         }
@@ -266,7 +266,7 @@ extend self: Resolver {
         if(self.lspHook.isAt(definition.at) || self.lspHook.isDefinedAt(definition.at)) {
             self.lspHook.emit(
                 ResolveSymbolHook(
-                    SymbolHook(definition.name, definition.at, definition.at), None
+                    SymbolHook(definition.name, definition.at, definition.at), None, topLevel = topLevel
                 )
             )
         }
@@ -287,7 +287,7 @@ extend self: Resolver {
                 if(self.lspHook.isAt(e.at) || self.lspHook.isDefinedAt(at)) {
                     self.lspHook.emit(
                         ResolveSymbolHook(
-                            SymbolHook(e.name, e.at, at), None
+                            SymbolHook(e.name, e.at, at), None, topLevel = True
                         )
                     )
                 }
@@ -369,7 +369,7 @@ extend self: Resolver {
                 if(self.lspHook.isAt(e.at) || self.lspHook.isDefinedAt(e.at)) {
                     self.lspHook.emit(
                         ResolveSymbolHook(
-                            SymbolHook(e.name, e.at, e.at), None
+                            SymbolHook(e.name, e.at, e.at), None, topLevel = False
                         )
                     )
                 }
@@ -492,7 +492,7 @@ extend self: Resolver {
     resolveSignature(signature: Signature, topLevel: Bool, isInstanceMethod: Bool): Signature {
         if(self.lspHook.isAt(signature.at) || self.lspHook.isDefinedAt(signature.at)) {
             self.lspHook.emit(
-                ResolveSignatureHook(signature, isInstanceMethod)
+                ResolveSignatureHook(signature, isInstanceMethod, topLevel = topLevel)
             )
         }
         let newSignature = if(topLevel) {

package/compiler/Syntax.ff

@@ -9,6 +9,7 @@ extend self: Location {
 }
 
 data CompileError(at: Location, message: String)
+data CompileErrors(errors: List[CompileError])
 
 data ModuleWithPackageInfo(
     packageInfo: Option[PackageInfo]

package/core/Array.ff

@@ -35,10 +35,7 @@ extend self[T]: Array[T] {
 
     grab(index: Int): T
         target js sync """
-            if(index_ < 0 || index_ >= self_.array.length) {
-                ff_core_Try.internalThrowGrabException_()
-            }
-            return self_.array[index_]
+            return self_.array[index_] ?? internalGrab_(self_, index_);
         """
 
     grabFirst(): T {self.grab(0)}
@@ -261,3 +258,8 @@ sortRange[T](array: Array[T], compare: (T, T) => Ordering, start: Int, end: Int)
         }
     }
 }
+
+internalGrab[T](self: Array[T], index: Int): T
+    target js sync """
+        return index_ < 0 || index_ >= self_.array.length ? ff_core_Try.internalThrowGrabException_() : self_.array[index_];
+    """

package/core/Int.ff

@@ -27,23 +27,23 @@ extend self: Int {
         target js sync "return signed_ ? self_ >> bits_ : self_ >>> bits_;"
 
     to(inclusiveEnd: Int): List[Int] {
-        mutable result = []
-        mutable n = inclusiveEnd
-        while {self <= n} {
-            result = [n, ...result]
-            n -= 1
+        let result = Array.make()
+        mutable n = self
+        while {n <= inclusiveEnd} {
+            result.push(n)
+            n += 1
         }
-        result
+        result.drain()
     }
 
     until(exclusiveEnd: Int): List[Int] {
-        mutable result = []
-        mutable n = exclusiveEnd
-        while {self < n} {
-            result = [n - 1, ...result]
-            n -= 1
+        let result = Array.make()
+        mutable n = self
+        while {n < exclusiveEnd} {
+            result.push(n)
+            n += 1
         }
-        result
+        result.drain()
     }
 
     min(that: Int): Int {

package/core/Json.ff

@@ -405,8 +405,8 @@ internalCompare(a: Json, b: Json): Int
         } else if (typeof a_ === 'number' || typeof b_ === 'number') {
             if(typeof b_ !== 'number') return -1;
             if(typeof a_ !== 'number') return 1;
-            if(isNaB(a_)) return isNaB(b_) ? 0 : -1;
-            if(isNaB(b_)) return 1;
+            if(isNaN(a_)) return isNaN(b_) ? 0 : -1;
+            if(isNaN(b_)) return 1;
             return a_ < b_ ? -1 : 1;
         } else if (typeof a_ === 'string' || typeof b_ === 'string') {
             if(typeof b_ !== 'string') return -1;

package/core/List.ff

@@ -47,10 +47,7 @@ extend self[T]: List[T] {
 
     grab(index: Int): T
         target js sync """
-            if(index_ < 0 || index_ >= self_.length) {
-                ff_core_Try.internalThrowGrabException_()
-            }
-            return self_[index_]
+            return self_[index_] ?? internalGrab_(self_, index_);
         """
 
     first(): Option[T] {self.get(0)}
@@ -411,3 +408,8 @@ instance List[T: Order]: Order {
 
 internalSame[T](left: List[T], right: List[T]): Bool
     target js sync "return left_ === right_"
+
+internalGrab[T](self: List[T], index: Int): T
+    target js sync """
+        return index_ < 0 || index_ >= self_.length ? ff_core_Try.internalThrowGrabException_() : self_[index_];
+    """

package/experimental/benchmarks/ListGrab.ff

@@ -0,0 +1,23 @@
+nodeMain(system: NodeSystem) {
+    let list = 1.to(10000)
+    benchmark(list, 100000)
+    let time = system.mainTask().time {
+        benchmark(list, 100000)
+    }
+    Log.trace(time.second.show())
+}
+
+benchmark(list: List[Int], iterations: Int): Int {
+    mutable sum = 0
+    mutable i = 0
+    while {i < iterations} {
+        mutable j = 0
+        sum = 0
+        while {j < 10000} {
+            sum += list.grab(j)
+            j += 1
+        }
+        i += 1
+    }
+    sum
+}

package/experimental/benchmarks/ListGrab.java

@@ -0,0 +1,55 @@
+/*
+
+nodeMain(system: NodeSystem) {
+    let list = 1.to(10000)
+    benchmark(list, 10000)
+    let time = system.mainTask().time {
+        benchmark(list, 10000)
+    }
+    Log.trace(time.second.show())
+}
+
+benchmark(list: List[Int], iterations: Int): Int {
+    mutable sum = 0
+    mutable i = 0
+    while {i < iterations} {
+        mutable j = 0
+        while {j < 10000} {
+            sum += list.grab(j)
+            j += 1
+        }
+        i += 1
+    }
+    sum
+}
+
+ */
+
+ // Rewrite the above to Java
+
+import java.util.ArrayList;
+
+public class ListGrab {
+    public static void main(String[] args) {
+        ArrayList<Integer> list = new ArrayList<>();
+        for (int i = 1; i <= 10000; i++) {
+            list.add(i);
+        }
+        benchmark(list, 100000);
+        long time = System.currentTimeMillis();
+        benchmark(list, 100000);
+        time = System.currentTimeMillis() - time;
+        System.out.println(time / 1000.0);
+    }
+
+    public static long benchmark(ArrayList<Integer> list, int iterations) {
+        long sum = 0;
+        for (int i = 0; i < iterations; i++) {
+            sum = 0;
+            for (int j = 0; j < 10000; j++) {
+                sum += list.get(j);
+            }
+        }
+        return sum;
+    }
+}

package/experimental/benchmarks/Pyrotek45.ff

@@ -0,0 +1,30 @@
+nodeMain(system: NodeSystem) {
+    benchmark()
+    let time = system.mainTask().time {
+        benchmark()
+    }
+    Log.trace(time.second.show())
+}
+
+benchmark() {
+    mutable num = 20000
+    let v = num
+    mutable i = 1
+    mutable j = 1
+    mutable sum = 0
+    while {i < v} {
+        j = 1
+        while {j < num - 1} {
+            if(num % j == 0) {
+                sum += j
+            }
+            j += 1
+        }
+        if(num == sum) {
+            Log.show(sum)
+        }
+        sum = 0
+        num -= 1
+        i += 1
+    }    
+}

package/experimental/benchmarks/Pyrotek45.java

@@ -0,0 +1,64 @@
+/*
+nodeMain(system: NodeSystem) {
+    benchmark()
+    let time = system.mainTask().time {
+        benchmark()
+    }
+    Log.trace(time.second.show())
+}
+
+benchmark() {
+    mutable num = 20000
+    let v = num
+    mutable i = 1
+    mutable j = 1
+    mutable sum = 0
+    while {i < v} {
+        j = 1
+        while {j < num - 1} {
+            if(num % j == 0) {
+                sum += j
+            }
+            j += 1
+        }
+        if(num == sum) {
+            Log.show(sum)
+        }
+        sum = 0
+        num -= 1
+        i += 1
+    }    
+}
+*/
+
+// Rewrite this in Java
+
+public class Pyrotek45 {
+    public static void main(String[] args) {
+        benchmark();
+        long time = System.currentTimeMillis();
+        benchmark();
+        time = System.currentTimeMillis() - time;
+        System.out.println(time / 1000.0);
+    }
+
+    public static void benchmark() {
+        int num = 20000;
+        int v = num;
+        int i = 1;
+        int j = 1;
+        int sum = 0;
+        for (i = 1; i < v; i++) {
+            for (j = 1; j < num - 1; j++) {
+                if (num % j == 0) {
+                    sum += j;
+                }
+            }
+            if (num == sum) {
+                System.out.println(sum);
+            }
+            sum = 0;
+            num -= 1;
+        }
+    }
+}

package/experimental/tests/TestJson.ff

@@ -0,0 +1,26 @@
+nodeMain(system: NodeSystem) {
+    let jsons = [
+        Json.object()
+        Json.object().with("x", 1) 
+        Json.object().with("y", 1)
+        Json.object().with("x", 1).with("y", 1)
+        Json.object().with("y", 2).with("x", 1)
+        Json.object().with("x", 1).with("y", 2)
+        Json.array([Json.int(3)])
+        Json.int(3)
+        Json.null()
+        Json.float(3.5)
+        Json.bool(True)
+        Json.bool(False)
+    ]
+    system.writeLine(Show.show(Json.array(jsons.sort())))
+    jsons.each {json =>
+        let equal = jsons.filter {_ == json}
+        if(equal.size() != 1) {
+            system.writeLine(
+                "None-singleton equals: " + 
+                equal.map {j => Show.show(json) + " == " + Show.show(j)}.join(" && ")
+            )
+        }
+    }
+}

package/lsp/CompletionHandler.ff

@@ -748,8 +748,8 @@ toplevelCompletion(lspHook: LspHook): List[CompletionInfo] {
             label = "webapp", 
             extra = " with frontend and backend", 
             snippet = [
-                "dependency ff:httpserver:0.0.0"
-                "import HttpServer from ff:httpserver"
+                "dependency ff:webserver:0.0.0"
+                "import WebServer from ff:webserver"
                 ""
                 "browserMain(system: BrowserSystem): Unit {"
                 "    let response = system.httpClient().fetch(\"http://localhost:8080/hello\")"
@@ -758,19 +758,19 @@ toplevelCompletion(lspHook: LspHook): List[CompletionInfo] {
                 "}"
                 ""
                 "nodeMain(system: NodeSystem): Unit {"
-                "    HttpServer.listen(system, \"localhost\", 8080) {request, response =>"
-                "        if(request.path() == \"/\") {"
-                "            response.setHeader(\"Content-Type\", [\"text/html; charset=UTF-8\"])"
-                "            response.writeText(\"<!doctype html>\")"
-                "            response.writeText(\"<script type='module' src='/js/script/script/WebApp.mjs'></script>\")"
-                "        } elseIf {request.path() == \"/hello\"} {"
-                "            response.setHeader(\"Content-Type\", [\"text/plain; charset=UTF-8\"])"
-                "            response.writeText(\"Hello from server!\")"
-                "        } elseIf {request.path().startsWith(\"/js/\") && !request.path().contains(\"..\")} {"
-                "            response.setHeader(\"Content-Type\", [\"text/javascript; charset=UTF-8\"])"
-                "            response.writeText(system.assets().readText(request.path()))"
+                "    WebServer.make(system, \"localhost\", 8080).listen {request =>"
+                "        if(request.readPath() == \"/\") {"
+                "            request.writeHeader(\"Content-Type\", \"text/html; charset=UTF-8\")"
+                "            request.writeText(\"<!doctype html>\")"
+                "            request.writeText(\"<script type='module' src='/js/script/script/WebApp.mjs'></script>\")"
+                "        } elseIf {request.readPath() == \"/hello\"} {"
+                "            request.writeHeader(\"Content-Type\", \"text/plain; charset=UTF-8\")"
+                "            request.writeText(\"Hello from server!\")"
+                "        } elseIf {request.readPath().startsWith(\"/js/\") && !request.readPath().contains(\"..\")} {"
+                "            request.writeHeader(\"Content-Type\", \"text/javascript; charset=UTF-8\")"
+                "            request.writeText(system.assets().readText(request.readPath()))"
                 "        } else {"
-                "            response.writeStatus(404, Some(\"Not found\"))"
+                "            request.writeStatus(\"404 Not found\")"
                 "        }"
                 "    }"
                 "}"

package/lsp/Handler.ff

@@ -49,6 +49,8 @@ data TokenLocation(
     followedByLeftBracket: Bool
 )
 
+data Definition(at: Location, name: String, local: Bool)
+
 
 extend self: Handler {
 
@@ -194,18 +196,14 @@ extend self: Handler {
         let uri = parameters.grab("textDocument").field("uri").grabString()
         let path = system.pathFromUrl(uri)
         let fireflyPath = system.path(".")
-        let diagnostics = try {
-            Builder.check(system, fireflyPath, path, self.virtualFiles, LspHook.disabled(), True)
-            []
-        } catch {| CompileError(at, message), error =>
+        let errors = Builder.check(system, fireflyPath, path, None, self.virtualFiles, LspHook.disabled(), True)
+        let diagnostics = errors.map {| CompileError(at, message) => 
             let tokenLocation = self.findToken(system, at)
-            let diagnostic = Json.object()
+            Json.object()
                 .with("range", self.tokenLocationToLspRange(tokenLocation))
                 .with("severity", 1)
                 .with("message", message)
-            [diagnostic]
-        } grab()
-
+        }
         let o = Json.object()
             .with("kind", "full")
             .with("items", diagnostics)
@@ -217,18 +215,14 @@ extend self: Handler {
         let uri = parameters.grab("textDocument").field("uri").grabString()
         let path = system.pathFromUrl(uri)
         let fireflyPath = system.path(".")
-        let diagnostics = try {
-            Builder.check(system, fireflyPath, path, self.virtualFiles, LspHook.disabled(), True)
-            []
-        } catch {| CompileError(at, message), error =>
+        let errors = Builder.check(system, fireflyPath, path, None, self.virtualFiles, LspHook.disabled(), True)
+        let diagnostics = errors.map {| CompileError(at, message) => 
             let tokenLocation = self.findToken(system, at)
-            let diagnostic = Json.object()
+            Json.object()
                 .with("range", self.tokenLocationToLspRange(tokenLocation))
                 .with("severity", 1)
                 .with("message", message)
-            [diagnostic].filter {_ => path.absolute() == system.path(at.file).absolute()}
-        } grab()
-
+        }
         Json.object()
             .with("uri", uri)
             .with("version", parameters.grab("textDocument").field("version"))
@@ -275,12 +269,12 @@ extend self: Handler {
 
     handleWorkspaceSymbol(system: NodeSystem, parameters: Map[String, Json]): ResultOrError {
         let query = parameters.grab("query").grabString()
-        let files = self.printTime(system.mainTask(), "findFireflyFiles") {Builder.findFireflyFiles(self.rootPath.grab())}
+        let files = self.printTime(system.mainTask(), "findFireflyFiles") {Builder.findFireflyFiles(self.rootPath.grab(), None)}
         let symbols = files.flatMap {file => 
             let documentSymbols = self.getDocumentSymbolsWithCache(system, file)
             let workspaceSymbols = documentSymbols.flatMap {SymbolHandler.documentToWorkspaceSymbols(_, None)}
             if(query == "") {
-                workspaceSymbols.filter {_.kind == 5} // Class
+                workspaceSymbols.filter {_.kind == SType}
             } else {
                 workspaceSymbols.filter {SymbolHandler.symbolFilter(_, query)}
             }
@@ -311,11 +305,10 @@ extend self: Handler {
 
     handleHover(system: NodeSystem, targetAt: Location, goToDefinition: Bool): ResultOrError {
         let lspHook = LspHook.make(at = Some(targetAt), definedAt = None, insertIdentifier = False, trackSymbols = False)
-        try {
-            Builder.check(system, self.fireflyPath, system.path(targetAt.file), self.virtualFiles, lspHook, True)
-        } catch {| CompileError(at, message), error =>
+        let errors = Builder.check(system, self.fireflyPath, system.path(targetAt.file), None, self.virtualFiles, lspHook, True)
+        errors.each {| CompileError(at, message) => 
             Log.trace("handleHover check error: " + message)
-        } grab()
+        }
         let o = if(goToDefinition) {
             HoverHandler.handleGoToDefinition(system, self, lspHook)
         } else {
@@ -332,13 +325,11 @@ extend self: Handler {
             line = token.startLine
             column = token.startColumn
         )
-        //Log.show(token.followedByLeftBracket)
         let lspHook = LspHook.make(at = Some(completionAt), definedAt = None, insertIdentifier = True, trackSymbols = False)
-        try {
-            Builder.check(system, self.fireflyPath, system.path(completionAt.file), self.virtualFiles, lspHook, True)
-        } catch {| CompileError(at, message), error =>
+        let errors = Builder.check(system, self.fireflyPath, system.path(completionAt.file), None, self.virtualFiles, lspHook, True)
+        errors.each {| CompileError(at, message) => 
             Log.trace("handleCompletion check error: " + message)
-        } grab()
+        }        
         let o = CompletionHandler.handleCompletion(lspHook, completionAt.column == 1, token.followedByLeftBracket)
         Result(o.write())
     }
@@ -368,11 +359,10 @@ extend self: Handler {
                 Some(SignatureHelpHandler.pickActiveParameter(help, h.argumentIndex, h.parameterName))
             | ParseArgumentHook h => 
                 let callLspHook = LspHook.make(at = Some(h.callAt), definedAt = None, insertIdentifier = False, trackSymbols = False)
-                try {
-                    Builder.check(system, self.fireflyPath, system.path(cursorAt.file), self.virtualFiles, callLspHook, True)
-                } catch {| CompileError(at, message), error =>
+                let errors = Builder.check(system, self.fireflyPath, system.path(cursorAt.file), None, self.virtualFiles, callLspHook, True)
+                errors.each {| CompileError(at, message) => 
                     Log.trace("handleSignatureHelp check 2 error: " + message)
-                } grab()
+                }        
                 let help = SignatureHelpHandler.handleSignatureHelp(system, callLspHook)
                 if(!help.isNull()) {
                     SignatureHelpHandler.pickActiveParameter(help, h.argumentIndex, h.parameterName)
@@ -427,40 +417,46 @@ extend self: Handler {
 
     findReferences(system: NodeSystem, targetAt: Location, local: Bool, includeDeclaration: Bool): Option[List[TokenLocation]] {
         let temporaryLspHook = LspHook.make(at = Some(targetAt), definedAt = None, insertIdentifier = False, trackSymbols = False)
-        try {
-            Builder.check(system, self.fireflyPath, system.path(targetAt.file), self.virtualFiles, temporaryLspHook, True)
-        } catch {| CompileError(at, message), error =>
-            Log.trace("findReferences first check error: " + message)
-        } grab()
-
+        let errors = Builder.check(system, self.fireflyPath, system.path(targetAt.file), None, self.virtualFiles, temporaryLspHook, True)
+        errors.each {| CompileError(at, message) => 
+            Log.trace("findReferences first check error: " + message + " in " + at.file + ":" + at.line + ":" + at.column)
+        }  
+                
         //Log.trace("defined at hooks: " + Show.show(temporaryLspHook.results().map(LspHook.showHook)))
         let definedAtList = temporaryLspHook.results().collect {
-            | ResolveSymbolHook h => Some(h.symbol.definedAt)
-            | ResolveVariantFieldHook h => Some(h.symbol.definedAt)
-            | ResolveTypeHook h => Some(h.symbol.definedAt)
-            | ResolveConstraintHook h => Some(h.symbol.definedAt)
-            | ResolveSignatureHook h {!h.isInstanceMethod} => Some(h.signature.at)
-            | InferParameterHook h => Some(h.parameter.at)
+            | ResolveSymbolHook h => Some(Definition(h.symbol.definedAt, h.symbol.qualifiedName, local = !h.topLevel))
+            | ResolveVariantFieldHook h => Some(Definition(h.symbol.definedAt, h.symbol.qualifiedName, False))
+            | ResolveTypeHook h => Some(Definition(h.symbol.definedAt, h.symbol.qualifiedName, False))
+            | ResolveConstraintHook h => Some(Definition(h.symbol.definedAt, h.symbol.qualifiedName, False))
+            | ResolveSignatureHook h {!h.isInstanceMethod} => Some(Definition(h.signature.at, h.signature.name, local = !h.topLevel))
+            | InferParameterHook h => Some(Definition(h.parameter.at, h.parameter.name, False))
             | InferArgumentHook h {h.arguments.dropFirst(h.argumentIndex).first() | Some(a)} {a.name | Some(n)} => 
-                h.parameters.find {_.name == n}.map {_.at}
-            | InferLookupHook h => Some(h.symbol.value.definedAt)
-            | InferPatternHook h {h.pattern | PVariantAs p} => Some(p.variableAt)
-            | InferPatternHook h {h.pattern | PVariable p} => Some(p.at)
-            | InferPatternHook h {h.pattern | PAlias p} => Some(p.at)
+                h.parameters.find {_.name == n}.map {Definition(_.at, n, False)}
+            | InferLookupHook h => Some(Definition(h.symbol.value.definedAt, h.symbol.value.qualifiedName, False))
+            | InferPatternHook h {h.pattern | PVariantAs p} => Some(Definition(p.variableAt, p.name, False))
+            | InferPatternHook h {h.pattern | PVariable p} => p.name.map {Definition(p.at, _, False)}
+            | InferPatternHook h {h.pattern | PAlias p} => Some(Definition(p.at, p.variable, False))
             | _ => None
-        }.filter {at => !at.file.endsWith(">")}
+        }.filter {pair => !pair.at.file.endsWith(">")}
             
+        function unqualify(qualifiedName: String): String {
+            qualifiedName.split('.').grabLast()
+        }
+
         definedAtList.first().{
-            | Some(definedAt) =>
+            | Some(definition) =>
                 //Log.trace("handleReferences definedAt: " + Show.show(definedAt))
-                let lspHook = LspHook.make(at = None, definedAt = Some(definedAt), insertIdentifier = False, trackSymbols = False)
-                try {
-                    let path = if(local) {system.path(targetAt.file)} else {self.rootPath.grab()}
-                    Builder.check(system, self.fireflyPath, path, self.virtualFiles, lspHook, True)
-                } catch {| CompileError(at, message), error =>
-                    // TODO: This skips checking all the other files
-                    Log.trace("findReferences second check error: " + message)
-                } grab()
+                let lspHook = LspHook.make(at = None, definedAt = Some(definition.at), insertIdentifier = False, trackSymbols = False)
+                let localCheck = local || definition.local
+                let path = if(localCheck) {system.path(targetAt.file)} else {self.rootPath.grab()}
+                let mustContain = Some(definition.name).filter {_ => !localCheck}.map(unqualify)
+                Log.trace("findReferences definition: " + Show.show(definition))
+                mustContain.each {Log.trace("mustContain: " + _)}
+                
+                let errors = Builder.check(system, self.fireflyPath, path, mustContain, self.virtualFiles, lspHook, True)
+                errors.each {| CompileError(at, message) => 
+                    Log.trace("findReferences second check error: " + message + " in " + at.file + ":" + at.line + ":" + at.column)
+                }  
 
                 let referencesResult = lspHook.results().collect {
                     | ResolveSymbolHook h => Some(h.symbol.usageAt)
@@ -475,11 +471,11 @@ extend self: Handler {
                     | _ => None
                 }.filter {at => 
                     !at.file.endsWith(">") &&
-                    (includeDeclaration || at != definedAt)
+                    (includeDeclaration || at != definition.at)
                 }
 
                 let clientLocations = referencesResult.addAll(
-                    if(includeDeclaration) {[definedAt]} else {[]}
+                    if(includeDeclaration) {[definition.at]} else {[]}
                 ).distinct().filter {
                     !local || _.file == targetAt.file
                 }.map {at =>