firefly-compiler 0.5.65 → 0.5.67

package/compiler/Parser.ff

@@ -172,7 +172,12 @@ extend self: Parser {
             } elseIf {self.current().is(LKeyword) && self.current().rawIs4("data", "class", "capability", "newtype")} {
                 types.push(self.parseTypeDefinition())
             } elseIf {self.current().is(LKeyword) && self.current().rawIs("import")} {
-                imports.push(self.parseImportDefinition(self.moduleKey.packagePair))
+                if(self.lspHook.isEnabled() && self.ahead().is(LLower) && !self.aheadAhead().is(LDot)) {
+                    self.skip(LKeyword)
+                    self.skip(LLower)
+                } else {
+                    imports.push(self.parseImportDefinition(self.moduleKey.packagePair))
+                }
             } elseIf {self.current().is(LKeyword) && self.current().rawIs("include")} {
                 throw(CompileError(self.current().at()
                     "Includes must be at the top of the file or below 'package'"

package/lsp/CompletionHandler.ff

@@ -14,9 +14,28 @@ data CompletionInfo(
     documentation: String
     expectedType: Option[Type]
     secondarySort: Int = 5
+    insertion: Option[Pair[Int, String]] = None
 )
 
-handleCompletion(lspHook: LspHook, toplevel: Bool, followedByOpenBracket: Bool): Json {
+data ImportSymbolsInfo(
+    import: Bool
+    importSymbols: List[ImportSymbolInfo]
+    importLine: Int
+)
+
+data ImportSymbolInfo(
+    moduleKey: ModuleKey
+    typeNames: List[String]
+    variantNames: List[String]
+    traitNames: List[String]
+)
+
+handleCompletion(
+    lspHook: LspHook
+    toplevel: Bool
+    followedByOpenBracket: Bool
+    importSymbols: ImportSymbolsInfo
+): Json {
     let topLevelCompletions = if(!toplevel) {[]} else {toplevelCompletion(lspHook)}
     let patternCompletions = lspHook.results().collectFirst {
         | InferPatternHook h =>
@@ -30,7 +49,7 @@ handleCompletion(lspHook: LspHook, toplevel: Bool, followedByOpenBracket: Bool):
     mutable typeCompletions = []
     let completions = patternCompletions.else {lspHook.results().flatMap {
         | ResolveTypeHook h =>
-            typeCompletions = [...typeCompletions, ...typeCompletion(h.types, h.typeGenerics)]
+            typeCompletions = [...typeCompletions, ...typeCompletion(h.types, h.typeGenerics, importSymbols)]
             []
         | ResolveVariantFieldHook _ =>
             sawParameterOrVariantFieldHook = True
@@ -59,10 +78,11 @@ handleCompletion(lspHook: LspHook, toplevel: Bool, followedByOpenBracket: Bool):
                 } {
                     scheme.signature.returnType | TConstructor(_, selfTypeName, _)
                 } => 
-                    let otherCompletions = completion(h.unification, h.environment, "", None, expected)
+                    let otherCompletions = 
+                        completion(h.unification, h.environment, "", None, expected, importSymbols)
                     let selfCompletions = h.environment.symbols.get(selfName).toList().flatMap {scheme =>
                         let prefix = selfTypeName + "_"
-                        completion(h.unification, h.environment, prefix, None, expected).filter {
+                        completion(h.unification, h.environment, prefix, None, expected, importSymbols).filter {
                             _.label.first().any {_.isAsciiLower()}
                         }.map {c =>
                             c.CompletionInfo(label = selfName + "." + c.label, snippet = selfName + "." + c.snippet)
@@ -70,7 +90,7 @@ handleCompletion(lspHook: LspHook, toplevel: Bool, followedByOpenBracket: Bool):
                     }
                     [...otherCompletions, ...selfCompletions]
                 | _ => 
-                    completion(h.unification, h.environment, typePrefix, qualifiedByAlias, expected)
+                    completion(h.unification, h.environment, typePrefix, qualifiedByAlias, expected, importSymbols)
             }
         | InferRecordFieldHook h {h.unification.substitute(h.recordType) | TConstructor(_, n, ts)} =>
             let fieldNames = n.split('$').dropFirst(1)
@@ -78,7 +98,7 @@ handleCompletion(lspHook: LspHook, toplevel: Bool, followedByOpenBracket: Bool):
                 let t2 = h.unification.substitute(t)
                 CompletionInfo(name, "", "", name, True, t2, "(...)." + name + ": " + t2.show([]), Some(h.expected))
             }
-            [...fieldCompletions, ...completion(h.unification, h.environment, n, None, h.expected)]
+            [...fieldCompletions, ...completion(h.unification, h.environment, n, None, h.expected, importSymbols)]
         | InferArgumentHook h {
             ![ // Avoids named argument suggestions for operators that become trait method calls, such as ==
                 "ff:core/Equal.equals", "ff:core/Equal.notEquals"
@@ -157,7 +177,9 @@ handleCompletion(lspHook: LspHook, toplevel: Bool, followedByOpenBracket: Bool):
             } else {c}
         }
     }
-    completionsToJson([...fixedCompletions, ...fixedTypeCompletions, ...topLevelCompletions])
+    let importCompletions = 
+        importCompletion(importSymbols.importSymbols.filter {_ => importSymbols.import}.map {_.moduleKey})
+    completionsToJson([...fixedCompletions, ...fixedTypeCompletions, ...topLevelCompletions, ...importCompletions])
 }
 
 completionsToJson(completions: List[CompletionInfo]): Json {
@@ -172,7 +194,8 @@ completionsToJson(completions: List[CompletionInfo]): Json {
             let isVariable = isLower && !i.extra.contains("(") && !i.extra.contains("{")
             let isDefinition = ["let ", "mutable ", "function "].any {i.snippet.startsWith(_)}
             let isParameter = i.snippet.endsWith(" = ")
-            let sortText = if(isParameter || isDefinition) {0} else {9 - (
+            let isImport = i.documentation == "// Imports this module"
+            let sortText = if(isParameter || isDefinition || isImport) {0} else {9 - (
                 isVariable.toInt() + isUnqualified.toInt() +
                 isAlpha.toInt() + isLower.toInt() + isMember.toInt()
             )} + if(isMember) {"1"} else {"0"} + i.secondarySort + i.label.lower()
@@ -183,6 +206,7 @@ completionsToJson(completions: List[CompletionInfo]): Json {
             Json.object()
                 // Namespace or Property or Constructor or EnumMember or Constructor or Method/Function or Field/Variable
                 .with("kind"
+                    if(isImport) {2} else:
                     if(shownType == "") {3} else:
                     if(isParameter) {10} else:
                     if(i.type.{| TConstructor(_, "type", _) => True | _ => False}) {9} else:
@@ -203,10 +227,43 @@ completionsToJson(completions: List[CompletionInfo]): Json {
                     .with("kind", "markdown")
                     .with("value", "```\n" + i.documentation + "\n```")
                 )
+                .with("additionalTextEdits", i.insertion.toList().map {| Pair(line, text) => Json.object()
+                    .with("range", Json->(
+                        start = Json->(line = line - 1, character = 0)
+                        end = Json->(line = line - 1, character = 0)
+                    ))
+                    .with("newText", text)
+                })
         })
 }
 
-typeCompletion(types: Map[String, String], typeGenerics: Map[String, List[String]]): List[CompletionInfo] {
+importCompletion(moduleKeys: List[ModuleKey]): List[CompletionInfo] {
+    moduleKeys.map {moduleKey =>
+        let label = moduleKey.folders.map {_ + "."}.join() + moduleKey.name
+        let extra = if(moduleKey.packagePair.name == "script" && moduleKey.packagePair.group == "script") {
+            ""
+        } else {
+            " from " + moduleKey.packagePair.groupName(":")
+        }
+        CompletionInfo(
+            label = label
+            extra = extra
+            more = ""
+            snippet = label + extra
+            member = False
+            type = TConstructor(Location("", 0, 0), "", [])
+            documentation = "// Imports this module", 
+            expectedType = None
+            secondarySort = if(extra == "") {1} else {2}
+        )
+    }
+}
+
+typeCompletion(
+    types: Map[String, String]
+    typeGenerics: Map[String, List[String]]
+    importSymbols: ImportSymbolsInfo
+): List[CompletionInfo] {
     let completions = types.toList().filter {| Pair(n, full) =>
         n.all {_.isAsciiLetterOrDigit()}
     }.map {| Pair(typeName, full) =>
@@ -217,7 +274,11 @@ typeCompletion(types: Map[String, String], typeGenerics: Map[String, List[String
         let snippet = typeName + if(realGenerics.isEmpty()) {""} else {"[$0]"}
         CompletionInfo(label, extra, "", snippet, False, TConstructor(Location("", 0, 0), "type", []), full, None)
     }
-    completions
+    let importCompletions = importSymbols.importSymbols.flatMap {| info =>
+        info.typeNames.map: name =>
+        makeAutoimportCompletion(info, importSymbols.importLine, name, True)
+    }
+    [...completions, ...importCompletions]
 }
 
 completion(
@@ -226,6 +287,7 @@ completion(
     prefix: String
     qualifiedByAlias: Option[String]
     expected: Type
+    importSymbols: ImportSymbolsInfo
 ): List[CompletionInfo] {
 
     let member = prefix.contains("_")
@@ -299,9 +361,41 @@ completion(
             members.push(makeCompletion(unification, expected, prefix, memberName, memberScheme, False, member))
         }
     }
+    
+    if(prefix == "") {
+        importSymbols.importSymbols.each {| info =>
+            [info.moduleKey.name, ...info.variantNames].distinct().each: name =>
+            members.push(makeAutoimportCompletion(info, importSymbols.importLine, name, False))
+        }
+    }
+    
     members.toList()
 }
 
+makeAutoimportCompletion(info: ImportSymbolInfo, importLine: Int, name: String, isType: Bool): CompletionInfo {
+    let moduleName = info.moduleKey.folders.map {_ + "."}.join() + info.moduleKey.name
+    let fromName = if(
+        info.moduleKey.packagePair.name == "script" && info.moduleKey.packagePair.group == "script"
+    ) {
+        ""
+    } else {
+        info.moduleKey.packagePair.groupName(":")
+    }
+    let importName = if(fromName == "") {moduleName} else {moduleName + " from " + fromName}
+    CompletionInfo(
+        label = name
+        extra = ""
+        more = if(fromName == "") {moduleName} else {fromName + "/" + moduleName}
+        snippet = name
+        member = False
+        type = TConstructor(Location("", 0, 0), if(isType) {"type"} else {""}, [])
+        documentation = "// Will import the following module:\nimport " + importName
+        expectedType = None
+        secondarySort = 9
+        insertion = Some(Pair(importLine, "import " + importName + "\n"))
+    )
+}
+
 makeCompletion(
     unification: Unification
     expected: Type

package/lsp/Handler.ff

@@ -1,5 +1,6 @@
 import JsEmitter from ff:compiler
 import Builder from ff:compiler
+import Dependencies from ff:compiler
 import Syntax from ff:compiler
 import Tokenizer from ff:compiler
 import Parser from ff:compiler
@@ -21,6 +22,7 @@ capability Handler(
     mutable cancelledRequests: Set[MessageId]
     mutable responseCache: Map[TokenRequestCacheKey, ResultOrError]
     mutable fileSymbolsCache: Map[String, List[DocumentSymbol]]
+    mutable importSymbolsCache: Pair[String, List[ImportSymbolInfo]]
     moduleCache: ModuleCache
     dependencyLock: DependencyLock
 )
@@ -93,11 +95,15 @@ extend self: Handler {
 
     handleRequest(system: NodeSystem, method: String, parameters: Map[String, Json], version: Int): ResultOrError {
         method.{
-            | "initialize" => self.handleInitialize(system, parameters)
+            | "initialize" => 
+                self.handleInitialize(system, parameters)
             //| "textDocument/diagnostic" => self.handleDiagnostic(system, parameters)
-            | "textDocument/documentSymbol" => self.handleDocumentSymbol(system, parameters)
-            | "textDocument/completion" => self.handleCompletion(system, parameters, version)
-            | "textDocument/signatureHelp" => self.handleSignatureHelp(system, parameters, version)
+            | "textDocument/documentSymbol" => 
+                self.handleDocumentSymbol(system, parameters)
+            | "textDocument/completion" => 
+                self.handleCompletion(system, parameters, version)
+            | "textDocument/signatureHelp" => 
+                self.handleSignatureHelp(system, parameters, version)
             | "textDocument/hover" => 
                 self.handleTokenRequestWithCache(system, method, parameters) {key => 
                     self.handleHover(system, key.targetAt, goToDefinition = False, version)
@@ -110,7 +116,8 @@ extend self: Handler {
                 self.handleTokenRequestWithCache(system, method, parameters) {key => 
                     self.handleReferences(system, key.targetAt, key.includeDeclaration, local = False, version)
                 }
-            | "textDocument/rename" => self.handleRename(system, parameters, version)
+            | "textDocument/rename" => 
+                self.handleRename(system, parameters, version)
             | "textDocument/documentHighlight" => 
                 self.handleTokenRequestWithCache(system, method, parameters) {key => 
                     self.handleReferences(system, key.targetAt, includeDeclaration = True, local = True, version)
@@ -119,8 +126,10 @@ extend self: Handler {
                 self.printTime(system.mainTask(), "handleWorkspaceSymbol") {
                     self.handleWorkspaceSymbol(system, parameters)
                 }
-            | "shutdown" => Result(Json.null().write())
-            | _ => self.handleUnsupported()
+            | "shutdown" => 
+                Result(Json.null().write())
+            | _ => 
+                self.handleUnsupported()
         }
     }
 
@@ -231,6 +240,7 @@ extend self: Handler {
     }*/
 
     handleFocusDiagnostic(system: NodeSystem, parameters: Map[String, Json], version: Int): Json {
+        self.importSymbolsCache = Pair("", [])
         let js = system.js()
         let uri = parameters.grab("textDocument").field("uri").grabString()
         let path = system.pathFromUrl(uri)
@@ -384,6 +394,7 @@ extend self: Handler {
     handleCompletion(system: NodeSystem, parameters: Map[String, Json], version: Int): ResultOrError {
         let location = self.findLocationFromParameters(system, parameters)
         let token = self.findToken(system, location, insertToken = True)
+        let toplevelToken = self.findToken(system, location.Location(column = 1), insertToken = False)
         let completionAt = Location(
             file = location.file
             line = token.startLine
@@ -395,7 +406,19 @@ extend self: Handler {
         errors.each {| CompileError(at, message) => 
             Log.trace("handleCompletion check error: " + message)
         }        
-        let o = CompletionHandler.handleCompletion(lspHook, completionAt.column == 1, token.followedByLeftBracket)
+        let importSymbols = self.printTime(system.mainTask(), "findModulesToImport") {
+            self.findModulesToImport(system, path, lspHook)
+        }
+        let o = CompletionHandler.handleCompletion(
+            lspHook = lspHook
+            toplevel = completionAt.column == 1
+            followedByOpenBracket = token.followedByLeftBracket
+            importSymbols = ImportSymbolsInfo(
+                import = toplevelToken.raw == "import" && location.column >= 8
+                importSymbols = importSymbols.first
+                importLine = importSymbols.second
+            )
+        )
         Result(o.write())
     }
 
@@ -592,7 +615,55 @@ extend self: Handler {
                 None
         }
     }
-
+    
+    findModulesToImport(system: NodeSystem, modulePath: Path, lspHook: LspHook): Pair[List[ImportSymbolInfo], Int] {
+        let importSymbols = if(self.importSymbolsCache.first == modulePath.absolute()) {
+            self.importSymbolsCache.second
+        } else {
+            let dependencies = 
+                Dependencies.process(system.httpClient(), DependencyLock.new(system.mainTask()), modulePath)
+            let nonCore = dependencies.packagePaths.toList().filter {!_.first.isCore()}
+            function parseModule(packagePair: PackagePair, path: Path): Option[Module] {
+                dependencies.packagePaths.get(packagePair).flatMap: packagePath =>
+                packagePair.moduleKey(packagePath, path).flatMap: moduleKey =>
+                self.moduleCache.parsedModules.get(path.absolute()).map {_.first}.orElse:
+                try {
+                    let code = self.virtualFiles.get(path.absolute()).else {path.readText()}
+                    let tokens = Tokenizer.tokenize(path.absolute(), code, None, True)
+                    let parser = Parser.new(moduleKey, tokens, True, LspHook.disabled())
+                    parser.parseModuleWithPackageInfo().module
+                }.toOption()
+            }
+            let symbols = nonCore.flatMap {| Pair(packagePair, packagePath) =>
+                let packageFiles = Builder.findPackageFilesForDirectory(packagePath, None, Set.new())
+                packageFiles.flatMap {_.files.collect {file => 
+                    parseModule(packagePair, file).map: module =>
+                    let typeNames = module.types.map {_.name}
+                    let variantNames = module.types.flatMap {_.variants.map {_.name}}
+                    let traitNames = module.traits.map {_.name}
+                    ImportSymbolInfo(module.moduleKey, typeNames, variantNames, traitNames)
+                }}
+            }
+            self.importSymbolsCache = Pair(modulePath.absolute(), symbols)
+            symbols
+        }
+        mutable importLine = 1
+        let imports = try {
+            let code = self.virtualFiles.get(modulePath.absolute()).else {modulePath.readText()}
+            let tokens = Tokenizer.tokenize(modulePath.absolute(), code, Some(lspHook.at), True)
+            let parser = Parser.new(ModuleKey(PackagePair("", ""), [], ""), tokens, True, lspHook)
+            tokens.each {token => 
+                if(token.is(LKeyword) && token.rawIs4("import", "include", "package", "dependency")) {
+                    importLine = token.startLine + 1
+                }
+            }
+            parser.parseModuleWithPackageInfo().module
+        }.toOption().toList().flatMap {
+            _.imports.map {_.moduleKey}
+        }.toSet()
+        Pair(importSymbols.filter {!imports.contains(_.moduleKey)}, importLine)
+    }
+    
     makeNotificationMessage(method: String, params: Json): Json {
         Json.object()
             .with("jsonrpc", "2.0")

package/lsp/LanguageServer.ff

@@ -38,6 +38,7 @@ main(system: NodeSystem) {
         cancelledRequests = [].toSet()
         responseCache = Map.new()
         fileSymbolsCache = Map.new()
+        importSymbolsCache = Pair("", [])
         moduleCache = cache
         dependencyLock = DependencyLock.new(system.mainTask())
     )

package/lsp/TestReferences.ff

@@ -8,7 +8,7 @@ nodeMain(system: NodeSystem) {
     let fireflyPath = system.path(".")
     Log.debug(fireflyPath.absolute())
     let cache = ModuleCache.new(0)
-    let handler = Handler(fireflyPath, None, Map.new(), [].toSet(), Map.new(), Map.new(), cache, DependencyLock.new(system.mainTask()))
+    let handler = Handler(fireflyPath, None, Map.new(), [].toSet(), Map.new(), Map.new(), Pair("", []), cache, DependencyLock.new(system.mainTask()))
     let targetAt = Location("/home/werk/projects/firefly-boot/lsp/TestReferencesCase.ff", 7, 5)
     let references = handler.findReferences(system, targetAt, local = False, includeDeclaration = True, version = 0)
     Log.show(references)

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

@@ -288,7 +288,12 @@ instances_.array.push(ff_compiler_Parser.Parser_parseInstanceDefinition(self_))
 } else if((ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LKeyword()) && ff_compiler_Token.Token_rawIs4(ff_compiler_Parser.Parser_current(self_), "data", "class", "capability", "newtype"))) {
 types_.array.push(ff_compiler_Parser.Parser_parseTypeDefinition(self_))
 } else if((ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LKeyword()) && ff_compiler_Token.Token_rawIs(ff_compiler_Parser.Parser_current(self_), "import"))) {
+if(((ff_compiler_LspHook.LspHook_isEnabled(self_.lspHook_) && ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_ahead(self_), ff_compiler_Token.LLower())) && (!ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_aheadAhead(self_), ff_compiler_Token.LDot())))) {
+ff_compiler_Parser.Parser_skip(self_, ff_compiler_Token.LKeyword());
+ff_compiler_Parser.Parser_skip(self_, ff_compiler_Token.LLower())
+} else {
 imports_.array.push(ff_compiler_Parser.Parser_parseImportDefinition(self_, self_.moduleKey_.packagePair_))
+}
 } else if((ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LKeyword()) && ff_compiler_Token.Token_rawIs(ff_compiler_Parser.Parser_current(self_), "include"))) {
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(ff_compiler_Token.Token_at(ff_compiler_Parser.Parser_current(self_)), "Includes must be at the top of the file or below 'package'"), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 } else if((ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LKeyword()) && ff_compiler_Token.Token_rawIs(ff_compiler_Parser.Parser_current(self_), "dependency"))) {
@@ -1792,7 +1797,12 @@ instances_.array.push(ff_compiler_Parser.Parser_parseInstanceDefinition(self_))
 } else if((ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LKeyword()) && ff_compiler_Token.Token_rawIs4(ff_compiler_Parser.Parser_current(self_), "data", "class", "capability", "newtype"))) {
 types_.array.push(ff_compiler_Parser.Parser_parseTypeDefinition(self_))
 } else if((ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LKeyword()) && ff_compiler_Token.Token_rawIs(ff_compiler_Parser.Parser_current(self_), "import"))) {
+if(((ff_compiler_LspHook.LspHook_isEnabled(self_.lspHook_) && ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_ahead(self_), ff_compiler_Token.LLower())) && (!ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_aheadAhead(self_), ff_compiler_Token.LDot())))) {
+ff_compiler_Parser.Parser_skip(self_, ff_compiler_Token.LKeyword());
+ff_compiler_Parser.Parser_skip(self_, ff_compiler_Token.LLower())
+} else {
 imports_.array.push(ff_compiler_Parser.Parser_parseImportDefinition(self_, self_.moduleKey_.packagePair_))
+}
 } else if((ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LKeyword()) && ff_compiler_Token.Token_rawIs(ff_compiler_Parser.Parser_current(self_), "include"))) {
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(ff_compiler_Token.Token_at(ff_compiler_Parser.Parser_current(self_)), "Includes must be at the top of the file or below 'package'"), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 } else if((ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LKeyword()) && ff_compiler_Token.Token_rawIs(ff_compiler_Parser.Parser_current(self_), "dependency"))) {

package/package.json

@@ -4,7 +4,7 @@
     "description": "Firefly compiler",
     "author": "Firefly team",
     "license": "MIT",
-    "version": "0.5.65",
+    "version": "0.5.67",
     "repository": {
         "type": "git",
         "url": "https://github.com/Ahnfelt/firefly-boot"

package/vscode/package.json

@@ -4,7 +4,7 @@
     "description": "Firefly language support",
     "author": "Firefly team",
     "license": "MIT",
-    "version": "0.5.65",
+    "version": "0.5.67",
     "repository": {
         "type": "git",
         "url": "https://github.com/Ahnfelt/firefly-boot"

package/core/Box.ff

@@ -1,7 +0,0 @@
-class Box[T](mutable value: T)
-
-extend self[T]: Box[T] {
-    modify(body: T => T): Unit {
-        self.value = body(self.value)
-    }
-}