firefly-compiler 0.4.20 → 0.4.21

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/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,7 +269,7 @@ 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)}
@@ -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 =>

package/lsp/SignatureHelpHandler.ff

@@ -44,10 +44,11 @@ handleSignatureHelp(system: NodeSystem, lspHook: LspHook): Json {
 
 pickActiveParameter(help: Json, argumentIndex: Int, parameterName: Option[String]): Json {
     parameterName.flatMap {name =>
-        let parameters = help.field("signatures").index(0).field("parameters").grabArray()
-        parameters.pairs().collectFirst {| Pair(i, p) => 
-            if(name == p.field("label").grabString().takeWhile {_.isAsciiLetterOrDigit()}) {
-                help.with("activeParameter", i)
+        help.field("signatures").index(0).field("parameters").getArray().flatMap {parameters =>
+            parameters.pairs().collectFirst {| Pair(i, p) => 
+                if(name == p.field("label").grabString().takeWhile {_.isAsciiLetterOrDigit()}) {
+                    help.with("activeParameter", i)
+                }
             }
         }
     }.else {help.with("activeParameter", argumentIndex)}

package/lsp/TestReferences.ff

@@ -0,0 +1,15 @@
+import Handler
+import Syntax from ff:compiler
+
+nodeMain(system: NodeSystem) {
+    Log.debug("Hello")
+    let fireflyPath = system.path(".")
+    Log.debug(fireflyPath.absolute())
+    let handler = Handler(fireflyPath, None, Map.empty(), [].toSet(), Map.empty(), Map.empty())
+    let targetAt = Location("/home/werk/projects/firefly-boot/lsp/TestReferencesCase.ff", 7, 5)
+    let references = handler.findReferences(system, targetAt, local = False, includeDeclaration = True)
+    Log.show(references)
+    references.each {_.each {r => 
+        Log.show(r)
+    }}
+}

package/lsp/TestReferencesCase.ff

@@ -0,0 +1,8 @@
+foo(a: Int): Int {
+    a + a
+}
+
+nodeMain(system: NodeSystem) {
+    foo(13)
+    foo(37)
+}

package/output/js/ff/compiler/Builder.mjs

@@ -166,30 +166,19 @@ return ff_compiler_Dependencies.ResolvedDependencies(_c.mainPackagePair_, _c.pac
 }))(resolvedDependencies_), ff_core_Option.None(), ff_core_NodeSystem.NodeSystem_path(system_, ".firefly/temporary"), ff_core_Path.Path_slash(ff_core_NodeSystem.NodeSystem_path(system_, ".firefly/output"), target_), false)
 }
 
-export function check_(system_, fireflyPath_, path_, virtualFiles_, lspHook_, infer_) {
+export function check_(system_, fireflyPath_, path_, mustContain_, virtualFiles_, lspHook_, infer_) {
 const packages_ = (((_1) => {
-{
 if(_1) {
-return ff_compiler_Builder.findPackageFiles_(path_)
-return
-}
+return ff_compiler_Builder.findPackageFiles_(path_, mustContain_)
 }
-{
-if(!_1) {
-const _guard1 = ff_core_Path.Path_endsWith(path_, [".firefly", "package.ff"]);
-if(_guard1) {
+if(!_1 && ff_core_Path.Path_endsWith(path_, [".firefly", "package.ff"])) {
 return [ff_compiler_Builder.PackageFiles(ff_core_Option.Option_grab(ff_core_Path.Path_parent(path_)), ff_core_Option.Some(path_), [])]
-return
-}
 }
-}
-{
 if(!_1) {
 return [ff_compiler_Builder.PackageFiles(ff_core_Option.Option_grab(ff_core_Path.Path_parent(path_)), ff_core_Option.None(), [path_])]
-return
-}
 }
 }))(ff_core_Path.Path_isDirectory(path_));
+const errors_ = ff_core_Array.make_();
 ff_core_List.List_each(ff_core_List.List_filter(packages_, ((_w1) => {
 return (!ff_core_List.List_isEmpty(_w1.files_))
 })), ((package_) => {
@@ -204,17 +193,29 @@ return ff_compiler_Dependencies.ResolvedDependencies(_c.mainPackagePair_, _c.pac
 const compiler_ = ff_compiler_Compiler.make_(ff_compiler_JsEmitter.EmitBuild(), ff_core_NodeSystem.NodeSystem_mainTask(system_), ff_core_Option.None(), ff_core_Path.Path_slash(ff_core_Path.Path_slash(package_.root_, ".firefly"), "temporary"), fixedResolvedDependencies_, virtualFiles_, lspHook_);
 ff_core_List.List_each(package_.files_, ((file_) => {
 const localFile_ = ff_core_Path.Path_base(file_);
+try {
 if(infer_) {
 ff_compiler_Compiler.Compiler_infer(compiler_, resolvedDependencies_.mainPackagePair_, ff_core_String.String_dropLast(localFile_, ff_core_String.String_size(".ff")))
 } else {
 ff_compiler_Compiler.Compiler_resolve(compiler_, resolvedDependencies_.mainPackagePair_, ff_core_String.String_dropLast(localFile_, ff_core_String.String_size(".ff")))
 }
+} catch(_error) {
+if(!_error.ffException) throw _error
+const _exception = ff_core_Any.fromAny_(_error.ffException, ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)
+if(!_exception.Some) throw _error
+{
+const c_ = _exception.value_;
+const error_ = _error;
+ff_core_Array.Array_push(errors_, c_)
+}
+}
 }))
-}))
+}));
+return ff_core_Array.Array_drain(errors_)
 }
 
-export function findPackageFiles_(path_) {
-const files_ = ff_compiler_Builder.findFireflyFiles_(path_);
+export function findPackageFiles_(path_, mustContain_) {
+const files_ = ff_compiler_Builder.findFireflyFiles_(path_, mustContain_);
 const split_ = ff_core_List.List_partition(files_, ((_w1) => {
 return ff_core_Path.Path_endsWith(_w1, [".firefly", "package.ff"])
 }));
@@ -235,7 +236,7 @@ return ff_compiler_Builder.PackageFiles(projectRoot_, ff_core_Option.None(), [fi
 return [...multiFileProjects_, ...singleFileProjects_]
 }
 
-export function findFireflyFiles_(path_) {
+export function findFireflyFiles_(path_, mustContain_) {
 const split_ = ff_core_List.List_partition(ff_core_Stream.Stream_toList(ff_core_Path.Path_entries(path_)), ((_w1) => {
 return ff_core_Path.PathEntry_isDirectory(_w1)
 }));
@@ -248,11 +249,13 @@ return (((c_ === 46) || ff_core_Char.Char_isAsciiLower(c_)) || ff_core_Char.Char
 }));
 const fireflyFiles_ = ff_core_List.List_filter(ff_core_List.List_map(split_.second_, ((_w1) => {
 return ff_core_Path.PathEntry_path(_w1)
-})), ((_w1) => {
-return (ff_core_Path.Path_extension(_w1) === ".ff")
+})), ((file_) => {
+return ((ff_core_Path.Path_extension(file_) === ".ff") && ff_core_Option.Option_all(mustContain_, ((s_) => {
+return ff_core_String.String_contains(ff_core_Path.Path_readText(file_), s_)
+})))
 }));
 return [...fireflyFiles_, ...ff_core_List.List_flatMap(directories_, ((_w1) => {
-return ff_compiler_Builder.findFireflyFiles_(_w1)
+return ff_compiler_Builder.findFireflyFiles_(_w1, mustContain_)
 }))]
 }
 
@@ -345,30 +348,19 @@ return ff_compiler_Dependencies.ResolvedDependencies(_c.mainPackagePair_, _c.pac
 }))(resolvedDependencies_), ff_core_Option.None(), (await ff_core_NodeSystem.NodeSystem_path$(system_, ".firefly/temporary", $task)), (await ff_core_Path.Path_slash$((await ff_core_NodeSystem.NodeSystem_path$(system_, ".firefly/output", $task)), target_, $task)), false, $task))
 }
 
-export async function check_$(system_, fireflyPath_, path_, virtualFiles_, lspHook_, infer_, $task) {
+export async function check_$(system_, fireflyPath_, path_, mustContain_, virtualFiles_, lspHook_, infer_, $task) {
 const packages_ = (await ((async (_1, $task) => {
-{
 if(_1) {
-return (await ff_compiler_Builder.findPackageFiles_$(path_, $task))
-return
-}
+return (await ff_compiler_Builder.findPackageFiles_$(path_, mustContain_, $task))
 }
-{
-if(!_1) {
-const _guard1 = (await ff_core_Path.Path_endsWith$(path_, [".firefly", "package.ff"], $task));
-if(_guard1) {
+if(!_1 && (await ff_core_Path.Path_endsWith$(path_, [".firefly", "package.ff"], $task))) {
 return [ff_compiler_Builder.PackageFiles(ff_core_Option.Option_grab((await ff_core_Path.Path_parent$(path_, $task))), ff_core_Option.Some(path_), [])]
-return
-}
 }
-}
-{
 if(!_1) {
 return [ff_compiler_Builder.PackageFiles(ff_core_Option.Option_grab((await ff_core_Path.Path_parent$(path_, $task))), ff_core_Option.None(), [path_])]
-return
-}
 }
 }))((await ff_core_Path.Path_isDirectory$(path_, $task)), $task));
+const errors_ = ff_core_Array.make_();
 (await ff_core_List.List_each$(ff_core_List.List_filter(packages_, ((_w1) => {
 return (!ff_core_List.List_isEmpty(_w1.files_))
 })), (async (package_, $task) => {
@@ -383,17 +375,29 @@ return ff_compiler_Dependencies.ResolvedDependencies(_c.mainPackagePair_, _c.pac
 const compiler_ = (await ff_compiler_Compiler.make_$(ff_compiler_JsEmitter.EmitBuild(), (await ff_core_NodeSystem.NodeSystem_mainTask$(system_, $task)), ff_core_Option.None(), (await ff_core_Path.Path_slash$((await ff_core_Path.Path_slash$(package_.root_, ".firefly", $task)), "temporary", $task)), fixedResolvedDependencies_, virtualFiles_, lspHook_, $task));
 (await ff_core_List.List_each$(package_.files_, (async (file_, $task) => {
 const localFile_ = (await ff_core_Path.Path_base$(file_, $task));
+try {
 if(infer_) {
 (await ff_compiler_Compiler.Compiler_infer$(compiler_, resolvedDependencies_.mainPackagePair_, ff_core_String.String_dropLast(localFile_, ff_core_String.String_size(".ff")), $task))
 } else {
 (await ff_compiler_Compiler.Compiler_resolve$(compiler_, resolvedDependencies_.mainPackagePair_, ff_core_String.String_dropLast(localFile_, ff_core_String.String_size(".ff")), $task))
 }
+} catch(_error) {
+if(!_error.ffException) throw _error
+const _exception = ff_core_Any.fromAny_(_error.ffException, ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)
+if(!_exception.Some) throw _error
+{
+const c_ = _exception.value_;
+const error_ = _error;
+ff_core_Array.Array_push(errors_, c_)
+}
+}
 }), $task))
-}), $task))
+}), $task));
+return ff_core_Array.Array_drain(errors_)
 }
 
-export async function findPackageFiles_$(path_, $task) {
-const files_ = (await ff_compiler_Builder.findFireflyFiles_$(path_, $task));
+export async function findPackageFiles_$(path_, mustContain_, $task) {
+const files_ = (await ff_compiler_Builder.findFireflyFiles_$(path_, mustContain_, $task));
 const split_ = (await ff_core_List.List_partition$(files_, (async (_w1, $task) => {
 return (await ff_core_Path.Path_endsWith$(_w1, [".firefly", "package.ff"], $task))
 }), $task));
@@ -414,7 +418,7 @@ return ff_compiler_Builder.PackageFiles(projectRoot_, ff_core_Option.None(), [fi
 return [...multiFileProjects_, ...singleFileProjects_]
 }
 
-export async function findFireflyFiles_$(path_, $task) {
+export async function findFireflyFiles_$(path_, mustContain_, $task) {
 const split_ = (await ff_core_List.List_partition$((await ff_core_Stream.Stream_toList$((await ff_core_Path.Path_entries$(path_, $task)), $task)), (async (_w1, $task) => {
 return (await ff_core_Path.PathEntry_isDirectory$(_w1, $task))
 }), $task));
@@ -427,11 +431,13 @@ return (((c_ === 46) || ff_core_Char.Char_isAsciiLower(c_)) || ff_core_Char.Char
 }), $task));
 const fireflyFiles_ = (await ff_core_List.List_filter$((await ff_core_List.List_map$(split_.second_, (async (_w1, $task) => {
 return (await ff_core_Path.PathEntry_path$(_w1, $task))
-}), $task)), (async (_w1, $task) => {
-return ((await ff_core_Path.Path_extension$(_w1, $task)) === ".ff")
+}), $task)), (async (file_, $task) => {
+return (((await ff_core_Path.Path_extension$(file_, $task)) === ".ff") && (await ff_core_Option.Option_all$(mustContain_, (async (s_, $task) => {
+return ff_core_String.String_contains((await ff_core_Path.Path_readText$(file_, $task)), s_)
+}), $task)))
 }), $task));
 return [...fireflyFiles_, ...(await ff_core_List.List_flatMap$(directories_, (async (_w1, $task) => {
-return (await ff_compiler_Builder.findFireflyFiles_$(_w1, $task))
+return (await ff_compiler_Builder.findFireflyFiles_$(_w1, mustContain_, $task))
 }), $task))]
 }