firefly-compiler 0.4.4

package/compiler/JsImporter.ff

@@ -0,0 +1,56 @@
+import Syntax
+
+class JsImporter(
+    mutable imports: Map[String, String]
+)
+
+make(): JsImporter {
+    JsImporter(Map.empty())
+}
+
+fail[T](at: Location, message: String): T {
+    panic(message + " " + at.show())
+}
+
+extend self: JsImporter {
+
+    add(url: String): String {
+        let importName = self.imports.get(url).{
+            | None =>
+                let n = "import$" + self.imports.size()
+                self.imports = self.imports.add(url, n)
+                n
+            | Some(n) => n
+        }
+        importName
+    }
+
+    process(at: Location, code: String): String {
+        let space = code.takeWhile {c => c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == ';'}
+        let rest = code.dropFirst(space.size())
+        if(!rest.startsWith("import * as ")) {code} else:
+        let rest2 = rest.dropFirst("import * as ".size())
+        let name = rest2.takeWhile {_.isAsciiLetterOrDigit()}
+        if(name.size() == 0) {throw(CompileError(at, "Expected alias after \"import * as \""))}
+        let rest3 = rest2.dropFirst(name.size())
+        if(!rest3.startsWith(" from '")) {throw(CompileError(at, "Expected \" from '\" after \"import * as ...\""))}
+        let rest4 = rest3.dropFirst(" from '".size())
+        let url = rest4.takeWhile {_ != '\''}
+        if(url.size() == 0) {throw(CompileError(at, "Expected module name after \" from '\""))}
+        if(url.any{_ == '\n'}) {throw(CompileError(at, "Unclosed module name string"))}
+        let rest5 = rest4.dropFirst(url.size() + 1)
+        let importName = self.add(url)
+        space + "const " + name + " = " + importName + self.process(at, rest5)
+    }
+
+    generateImports(ignoreModules: Set[String]): List[String] {
+        self.imports.pairs().map {| Pair(moduleName, mangledName) =>
+            if(ignoreModules.contains(moduleName)) {
+                "const " + mangledName + " = void 0; // Ignored import"
+            } else {
+                "import * as " + mangledName + " from '" + moduleName + "';"
+            }
+        }
+    }
+
+}

package/compiler/LspHook.ff

@@ -0,0 +1,188 @@
+import Syntax
+import Unification
+import Environment
+
+class LspHook(
+    at: Location
+    definedAt: Location
+    insertIdentifier: Bool
+    trackSymbols: Bool
+    stackOfResults: Stack[ResultHook]
+)
+
+disabled(): LspHook {
+    make(None, None, False, False)
+}
+
+make(at: Option[Location], definedAt: Option[Location], insertIdentifier: Bool, trackSymbols: Bool): LspHook {
+    LspHook( // Default dummy values instead of Option[Location] to speed up location hit check
+        at = at.else {Location("^lsp", -7, -7)}
+        definedAt = definedAt.else {Location("^lsp", -7, -7)}
+        insertIdentifier = insertIdentifier
+        trackSymbols = trackSymbols
+        stackOfResults = [].toStack()
+    )
+}
+
+extend self: LspHook {
+    isEnabled(): Bool {
+        self.at.line != -7 || 
+        self.definedAt.line != -7 ||
+        self.trackSymbols
+    }
+    isAt(at: Location): Bool {
+        self.at.line == at.line &&
+        self.at.column == at.column &&
+        self.at.file == at.file
+    }
+    isDefinedAt(at: Location): Bool {
+        self.definedAt.line == at.line &&
+        self.definedAt.column == at.column &&
+        self.definedAt.file == at.file
+    }
+    emit(result: ResultHook) {
+        self.stackOfResults.push(result)
+    }
+    results(): List[ResultHook] {
+        self.stackOfResults.toList()
+    }
+}
+
+strictlyBetween(afterAt: Location, beforeAt: Location, at: Location, extraColumns: Int): Bool {
+    at.file == afterAt.file && (
+        (at.line == afterAt.line && at.column > afterAt.column) ||
+        at.line > afterAt.line
+    ) && (
+        (at.line == beforeAt.line && at.column < beforeAt.column + extraColumns) ||
+        at.line < beforeAt.line
+    )
+}
+
+data SymbolHook(
+    qualifiedName: String
+    usageAt: Location
+    definedAt: Location
+)
+
+class Box[T](mutable value: T)
+
+class ResultHook {
+    ParseSymbolBegin
+    ParseSymbolEnd(
+        name: String
+        kind: Int
+        selectionStart: Location
+        selectionEnd: Location
+        start: Location
+        end: Location
+    )
+    ParseArgumentHook(
+        callAt: Location
+        argumentIndex: Int
+        parameterName: Option[String]
+    )
+    ResolveSymbolHook(
+        symbol: SymbolHook
+        annotation: Option[Type]
+    )
+    ResolveTypeHook(
+        types: Map[String, String]
+        typeGenerics: Map[String, List[String]]
+        symbol: SymbolHook
+        explicitType: Type
+    )
+    ResolveConstraintHook(
+        symbol: SymbolHook
+        constrant: Constraint
+    )
+    ResolveSignatureHook(
+        signature: Signature
+        isInstanceMethod: Bool
+    )
+    ResolveVariantFieldHook(
+        symbol: SymbolHook
+        type: Type
+        commonField: Bool
+    )
+    InferTermHook(
+        unification: Unification
+        environment: Environment
+        expected: Type
+        term: Term
+        recordType: Box[Option[Type]]
+        missing: StringMap[Pair[Instantiated, Option[List[Argument]]]]
+    )
+    InferLambdaStartHook(
+        unification: Unification
+        environment: Environment
+        lambdaType: Type
+    )
+    InferSequentialStartHook(
+        unification: Unification
+        term: Term
+        missing: StringMap[Pair[Instantiated, Option[List[Argument]]]]
+    )
+    InferFunctionDefinitionHook(
+        unification: Unification
+        environment: Environment
+        definition: DFunction
+        missing: StringMap[Pair[Instantiated, Option[List[Argument]]]]
+    )
+    InferPatternHook(
+        unification: Unification
+        environment: Environment
+        expected: Type
+        pattern: MatchPattern
+    )
+    InferParameterHook(
+        unification: Unification
+        environment: Environment
+        parameter: Parameter
+        missing: StringMap[Pair[Instantiated, Option[List[Argument]]]]
+    )
+    InferArgumentHook(
+        unification: Unification
+        environment: Environment
+        isCopy: Bool
+        callAt: Location
+        callName: String
+        parameters: List[Parameter]
+        arguments: List[Argument]
+        argumentIndex: Int
+    )
+    InferLookupHook(
+        unification: Unification
+        environment: Environment
+        expected: Type
+        selfVariable: Option[String]
+        symbol: Box[SymbolHook]
+        instantiated: Box[Option[Instantiated]]
+    )
+    InferRecordFieldHook(
+        unification: Unification
+        environment: Environment
+        expected: Type
+        recordType: Type
+        fieldName: String
+    )
+}
+
+showHook(hook: ResultHook): String {
+    | InferArgumentHook(unification, environment, isCopy, callAt, callName, parameters, arguments, argumentIndex) => "InferArgumentHook(...)"
+    | InferFunctionDefinitionHook(unification, environment, definition, missing) => "InferFunctionDefinitionHook(...)"
+    | InferLambdaStartHook(unification, environment, lambdaType) => "InferLambdaStartHook(...)"
+    | InferLookupHook(unification, environment, expected, selfVariable, symbol, instantiated) => "InferLookupHook(...)"
+    | InferParameterHook(unification, environment, parameter, missing) => "InferParameterHook(...)"
+    | InferPatternHook(unification, environment, expected, pattern) => "InferPatternHook(...)"
+    | InferRecordFieldHook(unification, environment, expected, recordType, fieldName) => "InferRecordFieldHook(...)"
+    | InferSequentialStartHook(unification, term, missing) => "InferSequentialStartHook(...)"
+    | InferTermHook(unification, environment, expected, term, recordType, missing) => "InferTermHook(...)"
+    | ParseArgumentHook(callAt, argumentIndex, parameterName) => "ParseArgumentHook(...)"
+    | ParseSymbolBegin => "ParseSymbolBegin(...)"
+    | ParseSymbolEnd(name, kind, selectionStart, selectionEnd, start, end) => "ParseSymbolEnd(...)"
+    | ResolveConstraintHook(symbol, constrant) => "ResolveConstraintHook(...)"
+    | ResolveSignatureHook(signature, _) => "ResolveSignatureHook(...)"
+    | ResolveSymbolHook(symbol, annotation) => "ResolveSymbolHook(...)"
+    | ResolveTypeHook(types, typeGenerics, symbol, explicitType) => "ResolveTypeHook(...)"
+    | ResolveVariantFieldHook(symbol, type, commonField) => "ResolveVariantFieldHook(...)"
+}

package/compiler/Main.ff

@@ -0,0 +1,237 @@
+import Tokenizer
+import Parser
+import Syntax
+import Resolver
+import Compiler
+import Unification
+import Builder
+import Dependencies
+import JsEmitter
+import Inference
+import LspHook
+
+data MainCommand {
+    BootstrapCommand
+    RunCommand(mainPath: String, argument: List[String])
+    BrowserCommand(mainPath: String)
+    BuildCommand(mainPath: String)
+    CheckCommand(filePath: String)
+}
+
+data CommandLineError(problem: String)
+
+main(system: NodeSystem): Unit {
+
+    let fireflyPath = detectFireflyPath(system)
+
+    function buildScript(
+        mainFile: String
+        mainPackagePair: PackagePair
+        emitTarget: EmitTarget
+        resolvedDependencies: ResolvedDependencies
+    ) {
+        let fixedPackagePaths = if(resolvedDependencies.packagePaths.contains(PackagePair("ff", "core"))) {
+            resolvedDependencies.packagePaths
+        } else {
+            resolvedDependencies.packagePaths.add(PackagePair("ff", "core"), fireflyPath.slash("core"))
+        }
+        let compilerModulePath = if(emitTarget != EmitBrowser && emitTarget != EmitExecutable) {
+            fireflyPath.slash("output").slash("js").slash("ff").slash("compiler/Builder.mjs")
+        }
+        let targetName = emitTarget.{
+            | EmitBuild => "build"
+            | EmitNode => "node"
+            | EmitBrowser => "browser"
+            | EmitExecutable => "executable"
+        }
+        Builder.build(
+            system = system
+            emitTarget = emitTarget
+            mainPackage = mainPackagePair
+            mainModule = mainFile
+            resolvedDependencies = resolvedDependencies.ResolvedDependencies(packagePaths = fixedPackagePaths)
+            compilerModulePath = compilerModulePath
+            tempPath = system.path(".firefly").slash("temporary")
+            jsOutputPath = system.path(".firefly").path("output").path(targetName)
+            printMeasurements = False
+        )
+    }
+
+    function runCommand(command: MainCommand) {
+        | RunCommand(mainFile, arguments) =>
+            let resolvedDependencies = Dependencies.process(system.httpClient(), system.path(mainFile + ".ff"))
+            prepareFireflyDirectory(system.path("."))
+            let localMainFile = system.path(mainFile).base()
+            buildScript(localMainFile, resolvedDependencies.mainPackagePair, EmitNode, resolvedDependencies)
+            importAndRun(fireflyPath, "node", resolvedDependencies.mainPackagePair, localMainFile, arguments)
+
+        | BrowserCommand(mainFile) =>
+            let resolvedDependencies = Dependencies.process(system.httpClient(), system.path(mainFile + ".ff"))
+            prepareFireflyDirectory(system.path("."))
+            let localMainFile = system.path(mainFile).base()
+            buildScript(mainFile, resolvedDependencies.mainPackagePair, EmitBrowser, resolvedDependencies)
+            bundleForBrowser(system, resolvedDependencies.mainPackagePair, localMainFile)
+
+        | BuildCommand(mainFile) =>
+            let resolvedDependencies = Dependencies.process(system.httpClient(), system.path(mainFile + ".ff"))
+            prepareFireflyDirectory(system.path("."))
+            let localMainFile = system.path(mainFile).base()
+            buildScript(localMainFile, resolvedDependencies.mainPackagePair, EmitBuild, resolvedDependencies)
+            buildScript(localMainFile, resolvedDependencies.mainPackagePair, EmitExecutable, resolvedDependencies)
+            bundleForPkg(system, resolvedDependencies.mainPackagePair, localMainFile)
+            importAndRun(fireflyPath, "build", resolvedDependencies.mainPackagePair, localMainFile, [])
+
+        | CheckCommand(filePath) => 
+            Builder.check(system, fireflyPath, system.path(filePath), Map.empty(), LspHook.disabled(), True)
+        
+        | BootstrapCommand =>
+            let workingDirectory = system.path(".")
+            Builder.build(
+                system = system
+                emitTarget = EmitNode
+                mainPackage = PackagePair("ff", "compiler")
+                mainModule = "Main"
+                resolvedDependencies = ResolvedDependencies(
+                    mainPackagePair = PackagePair("ff", "compiler")
+                    packages = [].toMap() // Only used for includes currently
+                    packagePaths = [
+                        Pair(PackagePair("ff", "compiler"), workingDirectory.slash("compiler"))
+                        Pair(PackagePair("ff", "core"), workingDirectory.slash("core"))
+                    ].toMap()
+                    singleFilePackages = [].toSet()
+                )
+                compilerModulePath = None
+                tempPath = workingDirectory.slash("output").slash("temporary")
+                jsOutputPath = workingDirectory.slash("output").slash("js")
+                printMeasurements = True
+            )
+    }
+
+    try {
+        let command = parseCommandLine(system.arguments().toList())
+        runCommand(command)
+    } catch {| CommandLineError(message), error =>
+        Log.debug(message)
+    } catch {| CompileError(at, message), error =>
+        Log.debug(message)
+        Log.debug(" at " + at.file.replace("./", "") + ":" + at.line + ":" + at.column)
+    } grab()
+}
+
+usageString = """
+usage: firefly <main-file> [<main-arguments>] | <command> [<command-arguments>]
+
+These are the commands:
+   run <main-file> [<main-arguments>]    Run the main file with the provided arguments
+   browser <main-file>                   Compile the main file for the browser
+   build <main-file>                     Build the main file
+   check <firefly-file>                  Check the firefly source file for errors
+   bootstrap                             Bootstrap the compiler
+"""
+
+parseCommandLine(arguments: List[String]): MainCommand {
+    | [mainFile, ...mainArguments] {mainFile.removeLast(".ff") | Some(mainName)} =>
+        RunCommand(mainName, mainArguments)
+    | ["run", ...runArguments] =>
+        runArguments.{
+            | [mainFile, ...mainArguments] {mainFile.removeLast(".ff") | Some(mainName)} =>
+                RunCommand(mainName, mainArguments)
+            | _ => throw(CommandLineError(
+                "You must specify a Firefly file (.ff) as first argument to run."  + usageString
+            ))
+        }
+    | ["browser", ...browserArguments] =>
+        browserArguments.{
+            | [mainFile] {mainFile.removeLast(".ff") | Some(mainName)} =>
+                BrowserCommand(mainName)
+            | [_, _, ..._] => throw(CommandLineError(
+                "You must only specify a single argument to browser."  + usageString
+            ))
+            | _ => throw(CommandLineError(
+                "You must specify a Firefly file (.ff) as the argument to browser."  + usageString
+            ))
+        }
+    | ["build", ...buildArguments] =>
+        buildArguments.{
+            | [mainFile] {mainFile.removeLast(".ff") | Some(mainName)} =>
+                BuildCommand(mainName)
+            | [_, _, ..._] => throw(CommandLineError(
+                "You must only specify a single argument to build."  + usageString
+            ))
+            | _ => throw(CommandLineError(
+                "You must specify a Firefly file (.ff) as the argument to build."  + usageString
+            ))
+        }
+    | ["check", ...checkArguments] =>
+        checkArguments.{
+            | [fileName] {fileName.removeLast(".ff") | Some(_)} =>
+                CheckCommand(fileName)
+            | [_, _, ..._] => throw(CommandLineError(
+                "You must only specify a single argument to check."  + usageString
+            ))
+            | _ => throw(CommandLineError(
+                "You must specify a Firefly file (.ff) as the argument to build."  + usageString
+            ))
+        }
+    | ["bootstrap", _] =>
+        throw(CommandLineError("bootstrap takes no arguments" + usageString))
+    | ["bootstrap"] => BootstrapCommand
+    | [] => throw(CommandLineError("You must specify a command or a main file to run." + usageString))
+    | [s, ..._] => throw(CommandLineError("Unknown command '" + s + "'" + usageString))
+}
+
+bundleForPkg(system: NodeSystem, packagePair: PackagePair, mainFile: String) {
+    let prefix = ".firefly/output/executable/"
+    let mainJsFile = prefix + packagePair.groupName("/") + "/" + mainFile + ".mjs"
+    let file = prefix + "Main.bundle.js"
+    BuildSystem.internalNodeCallEsBuild(system, mainJsFile, outputPath = file, minify = False)
+}
+
+bundleForBrowser(system: NodeSystem, packagePair: PackagePair, mainFile: String) {
+    let prefix = ".firefly/output/browser/"
+    let mainJsFile = prefix + packagePair.groupName("/") + "/" + mainFile + ".mjs"
+    let file = prefix + "Main.bundle.js"
+    let browserCode = BrowserCode(
+        packageGroup = packagePair.group
+        packageName = packagePair.name
+        mainFile = system.path(mainFile)
+        assetSystem = AssetSystem([Pair("/", {system.path(".").readStream()})].toMap())
+    ) // TODO
+    BuildSystem.internalCallEsBuild(browserCode, mainJsFile, outputPath = file, minify = True, sourceMap = True)
+}
+
+importAndRun(
+    fireflyPath: Path
+    target: String
+    packagePair: PackagePair
+    mainFile: String
+    arguments: List[String]
+): Unit
+    target node async """
+        const process = await import('process');
+        const cwd = process.cwd();
+        const workingDirectory = cwd.indexOf(':') == 1 ? 'file:///' + cwd : cwd;
+        const packagePath = packagePair_.group_ + "/" + packagePair_.name_
+        const main = await import(workingDirectory + "/.firefly/output/" + target_ + "/" + packagePath + "/" + mainFile_ + ".mjs");
+        await main.$run$(fireflyPath_, ff_core_List.List_toArray(arguments_))
+    """
+
+prepareFireflyDirectory(path: Path) {
+    if(!path.slash(".firefly").slash("output").exists()) {
+        if(!path.slash(".firefly").exists()) {
+            path.slash(".firefly").createDirectory()
+        }
+        path.slash(".firefly").slash("output").createDirectory()
+    }
+}
+
+detectFireflyPath(system: NodeSystem): Path
+    target node async """
+        import * as url from 'url'
+        const suffix = '/output/js/ff/compiler/Main.mjs'
+        const moduleUrl = import.meta.url
+        if(!import.meta.url.endsWith(suffix)) {
+            throw 'Expected module path to end with: ' + suffix + ", but got: " + moduleUrl;
+        }
+        return url.fileURLToPath(new URL(moduleUrl.slice(0, -suffix.length)))
+    """