firefly-compiler 0.4.17 → 0.4.19

package/compiler/Main.ff

@@ -108,7 +108,7 @@ main(system: NodeSystem): Unit {
     }
 
     try {
-        let command = parseCommandLine(system.arguments().toList())
+        let command = parseCommandLine(system.arguments())
         runCommand(command)
     } catch {| CommandLineError(message), error =>
         Log.debug(message)
@@ -144,7 +144,7 @@ parseCommandLine(arguments: List[String]): MainCommand {
         browserArguments.{
             | [mainFile] {mainFile.removeLast(".ff") | Some(mainName)} =>
                 BrowserCommand(mainName)
-            | [_, _, ..._] => throw(CommandLineError(
+            | [_, _, ...] => throw(CommandLineError(
                 "You must only specify a single argument to browser."  + usageString
             ))
             | _ => throw(CommandLineError(
@@ -155,7 +155,7 @@ parseCommandLine(arguments: List[String]): MainCommand {
         buildArguments.{
             | [mainFile] {mainFile.removeLast(".ff") | Some(mainName)} =>
                 BuildCommand(mainName)
-            | [_, _, ..._] => throw(CommandLineError(
+            | [_, _, ...] => throw(CommandLineError(
                 "You must only specify a single argument to build."  + usageString
             ))
             | _ => throw(CommandLineError(
@@ -166,7 +166,7 @@ parseCommandLine(arguments: List[String]): MainCommand {
         checkArguments.{
             | [fileName] {fileName.removeLast(".ff") | Some(_)} =>
                 CheckCommand(fileName)
-            | [_, _, ..._] => throw(CommandLineError(
+            | [_, _, ...] => throw(CommandLineError(
                 "You must only specify a single argument to check."  + usageString
             ))
             | _ => throw(CommandLineError(
@@ -177,7 +177,7 @@ parseCommandLine(arguments: List[String]): MainCommand {
         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))
+    | [s, ...] => throw(CommandLineError("Unknown command '" + s + "'" + usageString))
 }
 
 bundleForPkg(system: NodeSystem, packagePair: PackagePair, mainFile: String) {
@@ -213,7 +213,7 @@ importAndRun(
         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_))
+        await main.$run$(fireflyPath_, arguments_)
     """
 
 prepareFireflyDirectory(path: Path) {

package/compiler/Parser.ff

@@ -6,7 +6,7 @@ import LspHook
 class Parser(
     packagePair: PackagePair
     file: String
-    tokens: Array[Token]
+    tokens: List[Token]
     end: Token
     targetIsNode: Bool
     lspHook: LspHook
@@ -32,7 +32,7 @@ data ParsedTargets(
 make(
     packagePair: PackagePair 
     file: String
-    tokens: Array[Token]
+    tokens: List[Token]
     targetIsNode: Bool
     lspHook: LspHook
 ): Parser {
@@ -151,12 +151,12 @@ extend self: Parser {
         /* TODO: if(self.package != None && self.current().is(LKeyword) && self.current().rawIs("dependency")) {
             self.fail(self.current().at(), "Dependencies must be defined in the same file as the package declaration")
         }*/
-        let dependencies = Stack.make[DDependency]()
+        let dependencies = Array.make[DDependency]()
         while {self.current().is(LKeyword) && self.current().rawIs("dependency")} {
             dependencies.push(self.parseDependencyDefinition(package.targets))
             if(!self.current().is(LEnd)) {self.skipSeparator(LSemicolon)}
         }
-        let includes = Stack.make[DInclude]()
+        let includes = Array.make[DInclude]()
         while {self.current().is(LKeyword) && self.current().rawIs("include")} {
             includes.push(self.parseIncludeDefinition())
             if(!self.current().is(LEnd)) {self.skipSeparator(LSemicolon)}
@@ -166,13 +166,13 @@ extend self: Parser {
     }
 
     parseModule(): Module {
-        let imports = Stack.make[DImport]()
-        let types = Stack.make[DType]()
-        let traits = Stack.make[DTrait]()
-        let instances = Stack.make[DInstance]()
-        let extends = Stack.make[DExtend]()
-        let lets = Stack.make[DLet]()
-        let functions = Stack.make[DFunction]()
+        let imports = Array.make[DImport]()
+        let types = Array.make[DType]()
+        let traits = Array.make[DTrait]()
+        let instances = Array.make[DInstance]()
+        let extends = Array.make[DExtend]()
+        let lets = Array.make[DLet]()
+        let functions = Array.make[DFunction]()
         while {!self.current().is(LEnd)} {
             if(self.current().is(LLower) && (self.ahead().is(LAssign) || self.ahead().is(LColon))) {
                 lets.push(self.parseLetDefinition())
@@ -349,7 +349,7 @@ extend self: Parser {
         self.skip(LColon)
         let type = self.parseType()
         self.rawSkip(LBracketLeft, "{")
-        let methods = Stack.make[DFunction]()
+        let methods = Array.make[DFunction]()
         while {!self.current().is(LBracketRight)} {
             methods.push(self.parseFunctionDefinition(member = True))
             if(!self.current().is(LBracketRight)) {self.skipSeparator(LSemicolon)}
@@ -389,7 +389,7 @@ extend self: Parser {
         self.skip(LColon)
         let nameToken = self.skip(LUpper)
         let poly = if(!self.current().rawIs("[")) {Poly([], [])} else {self.parseTypeParameters()}
-        let constraints = Stack.make[Constraint]()
+        let constraints = Array.make[Constraint]()
         while {self.current().is(LColon)} {
             self.fail(self.current().at(), "Trait constraints is not yet implemented")
             self.skip(LColon)
@@ -399,10 +399,10 @@ extend self: Parser {
             ))
         }
         let generatorParameters = if(!self.current().rawIs("(")) {[]} else {self.parseFunctionParameters()}
-        let methodGenerators = Stack.make[Pair[String, Lambda]]()
-        let methodDefaults = Stack.make[Pair[String, Lambda]]()
+        let methodGenerators = Array.make[Pair[String, Lambda]]()
+        let methodDefaults = Array.make[Pair[String, Lambda]]()
         let methodSignatures = if(!self.current().rawIs("{")) {[]} else {
-            let signatures = Stack.make[Signature]()
+            let signatures = Array.make[Signature]()
             self.rawSkip(LBracketLeft, "{")
             while {!self.current().is(LBracketRight)} {
                 if(self.lspHook.trackSymbols) {self.lspHook.emit(ParseSymbolBegin)}
@@ -460,7 +460,7 @@ extend self: Parser {
         let instanceToken = self.rawSkip(LKeyword, "instance")
         let token = self.skip(LUpper)
         let poly = if(!self.current().rawIs("[")) {Poly([], [])} else {self.parseTypeParameters()}
-        let typeArguments = Stack.make[Type]()
+        let typeArguments = Array.make[Type]()
         typeArguments.push(TConstructor(token.at(), token.raw(), poly.generics.map {TConstructor(token.at(), _, [])}))
         self.skip(LColon)
         let nameToken = self.skip(LUpper)
@@ -474,7 +474,7 @@ extend self: Parser {
         }
         let generatorArguments = self.parseFunctionArguments(nameToken.at(), False).first
         let methods = if(!self.current().rawIs("{")) {[]} else {
-            let definitions = Stack.make[DFunction]()
+            let definitions = Array.make[DFunction]()
             self.rawSkip(LBracketLeft, "{")
             while {!self.current().is(LBracketRight)} {
                 definitions.push(self.parseFunctionDefinition(member = False))
@@ -528,7 +528,7 @@ extend self: Parser {
             [Variant(nameToken.at(), nameToken.raw(), [])]
         } else {
             self.rawSkip(LBracketLeft, "{")
-            let variantsBuilder = Stack.make[Variant]()
+            let variantsBuilder = Array.make[Variant]()
             while {!self.current().is(LBracketRight)} {
                 if(self.lspHook.trackSymbols) {self.lspHook.emit(ParseSymbolBegin)}
                 let variantNameToken = self.skip(LUpper)
@@ -583,7 +583,7 @@ extend self: Parser {
 
     parseImportDefinition(currentPackagePair: PackagePair): DImport {
         let importToken = self.rawSkip(LKeyword, "import")
-        let path = Stack.make[String]()
+        let path = Array.make[String]()
         while {self.current().is(LLower)} {
             path.push(self.parseDashedName())
             self.skip(LDot)
@@ -712,8 +712,8 @@ extend self: Parser {
 
     parseTypeParameters(): Poly {
         self.rawSkip(LBracketLeft, "[")
-        let parameters = Stack.make[String]()
-        let constraints = Stack.make[Constraint]()
+        let parameters = Array.make[String]()
+        let constraints = Array.make[Constraint]()
         while {!self.current().is(LBracketRight) && !self.current().is(LSemicolon)} {
             if(self.ahead().is(LBracketLeft)) {
                 constraints.push(self.parseConstraint())
@@ -736,7 +736,7 @@ extend self: Parser {
 
     parseTypeArguments(parenthesis: Bool = False): List[Type] {
         self.rawSkip(LBracketLeft, if(parenthesis) {"("} else {"["})
-        let types = Stack.make[Type]()
+        let types = Array.make[Type]()
         while {!self.current().is(LBracketRight)} {
             types.push(self.parseType())
             if(!self.current().is(LBracketRight)) {self.skip(LComma)}
@@ -746,7 +746,7 @@ extend self: Parser {
     }
 
     parseFunctionParameters(allowMutable: Bool = False): List[Parameter] {
-        let parameters = Stack.make[Parameter]()
+        let parameters = Array.make[Parameter]()
         self.rawSkip(LBracketLeft, "(")
         while {!self.current().is(LBracketRight)} {
             let lspTrackSymbols = self.lspHook.trackSymbols && allowMutable
@@ -784,7 +784,7 @@ extend self: Parser {
     }
 
     parseFunctionArguments(callAt: Location, trailing: Bool): Pair[List[Argument], Bool] {
-        let arguments = Stack.make[Argument]()
+        let arguments = Array.make[Argument]()
         if(self.current().rawIs("(")){
             self.rawSkip(LBracketLeft, "(")
             while {!self.current().is(LBracketRight)} {
@@ -854,13 +854,13 @@ extend self: Parser {
         let token = if(colon) {self.skip(LColon)} else {self.rawSkip(LBracketLeft, "{")}
         if(ignoreGenerateKeyword && self.current().is(LKeyword) && self.current().rawIs("generate")) {self.skip(LKeyword)}
         let result = if(self.current().is(LPipe)) {
-            let cases = Stack.make[MatchCase]()
+            let cases = Array.make[MatchCase]()
             while {self.current().is(LPipe)} {
                 cases.push(self.parseCase())
             }
             cases.toList()
         } elseIf {self.current().is2(LLower, LWildcard) && self.ahead().is2(LComma, LArrowThick)} {
-            let parameters = Stack.make[MatchPattern]()
+            let parameters = Array.make[MatchPattern]()
             while {!self.current().is(LArrowThick)} {
                 let isVariable = self.current().is(LLower)
                 let parameterToken = if(isVariable) {self.skip(LLower)} else {self.skip(LWildcard)}
@@ -888,14 +888,14 @@ extend self: Parser {
 
     parseCase(): MatchCase {
         let token = self.skip(LPipe)
-        let patterns = Stack.make[MatchPattern]()
+        let patterns = Array.make[MatchPattern]()
         while {!self.current().is3(LArrowThick, LPipe, LBracketRight) && !self.current().rawIs("{")} {
             patterns.push(self.parsePattern())
             if(!self.current().is3(LArrowThick, LPipe, LBracketRight) && !self.current().rawIs("{")) {
                 self.skip(LComma)
             }
         }
-        let guards = Stack.make[MatchGuard]()
+        let guards = Array.make[MatchGuard]()
         while {self.current().rawIs("{")} {
             guards.push(self.parseCaseGuard())
         }
@@ -944,7 +944,7 @@ extend self: Parser {
         } else {
             let token = self.skip(LUpper)
             if(self.current().rawIs("(")) {
-                let patterns = Stack.make[MatchPattern]()
+                let patterns = Array.make[MatchPattern]()
                 self.rawSkip(LBracketLeft, "(")
                 while {!self.current().is(LBracketRight)} {
                     let pattern = self.parsePattern()
@@ -1080,7 +1080,7 @@ extend self: Parser {
 
     parseFunctions(): Term {
         let at = self.current().at()
-        let functions = Stack.make[DFunction]()
+        let functions = Array.make[DFunction]()
         while {self.current().rawIs("function")} {
             if(self.lspHook.trackSymbols) {self.lspHook.emit(ParseSymbolBegin)}
             let functionAt = self.rawSkip(LKeyword, "function").at()
@@ -1256,7 +1256,7 @@ extend self: Parser {
     }
 
     parseRecord(copyAt: Option[Location]): List[Field] {
-        let fields = Stack.make[Field]()
+        let fields = Array.make[Field]()
         let startBracketAt = self.rawSkip(LBracketLeft, "(").at()
         let startAt = copyAt.else {startBracketAt}
         while {!self.current().is(LBracketRight)} {
@@ -1287,7 +1287,7 @@ extend self: Parser {
     }
 
     parseRecordType(): List[Pair[String, Type]] {
-        let fields = Stack.make[Pair[String, Type]]()
+        let fields = Array.make[Pair[String, Type]]()
         self.rawSkip(LBracketLeft, "(")
         while {!self.current().is(LBracketRight)} {
             let fieldToken = self.skip(LLower)
@@ -1300,7 +1300,7 @@ extend self: Parser {
     }
 
     parseRecordPattern(): List[Pair[String, MatchPattern]] {
-        let fields = Stack.make[Pair[String, MatchPattern]]()
+        let fields = Array.make[Pair[String, MatchPattern]]()
         self.rawSkip(LBracketLeft, "(")
         while {!self.current().is(LBracketRight)} {
             let fieldToken = self.skip(LLower)
@@ -1314,14 +1314,14 @@ extend self: Parser {
 
     parseListPattern(): MatchPattern {
         function convertListPattern(at: Location, items: List[Pair[MatchPattern, Bool]]): MatchPattern {
-            | _, [] => PVariant(at, "ff:core/List.Empty", [])
+            | _, [] => PVariant(at, "List$Empty", [])
             | _, [Pair(p, False), ...ps] =>
-                PVariant(at, "ff:core/List.Link", [p, convertListPattern(at, ps)])
+                PVariant(at, "List$Link", [p, convertListPattern(at, ps)])
             | _, [Pair(p, True)] => p
             | _, [Pair(p, True), ...] =>
                 throw(CompileError(p.at, "Invalid pattern: ... is only allowed for the last element in a list"))
         }
-        let items = Stack.make[Pair[MatchPattern, Bool]]()
+        let items = Array.make[Pair[MatchPattern, Bool]]()
         let at = self.rawSkip(LBracketLeft, "[").at()
         while {!self.current().rawIs("]")} {
             let spread = self.current().is(LDotDotDot)
@@ -1339,7 +1339,7 @@ extend self: Parser {
     }
 
     parseList(): Term {
-        let items = Stack.make[Pair[Term, Bool]]()
+        let items = Array.make[Pair[Term, Bool]]()
         let at = self.rawSkip(LBracketLeft, "[").at()
         while {!self.current().rawIs("]")} {
             let spread = self.current().is(LDotDotDot)
@@ -1361,7 +1361,7 @@ binaryOperators = [
     ["+", "-"]
     ["*", "/", "%"]
     ["^"]
-].toArray()
+]
 
 findBestTarget(targetIsNode: Bool, body: Option[Lambda], targets: ParsedTargets): Target {
     let foreignTarget = if(targetIsNode) {

package/compiler/Patterns.ff

@@ -50,6 +50,8 @@ convert(modules: Map[String, Module], cases: List[MatchCase]): List[PatternCaseI
         name.reverse().takeWhile {_ != '.'}.reverse()
     }
     function otherVariants(name: String): Set[String] {
+        if(name == "List$Empty") {["List$Link"].toSet()} else:
+        if(name == "List$Link") {["List$Empty"].toSet()} else:
         let variantName = unqualifiedName(name)
         let moduleName = name.dropLast(variantName.size() + 1)
         let variantModule = modules.grab(moduleName)

package/compiler/Syntax.ff

@@ -264,7 +264,7 @@ extend self: Type {
                 | TConstructor(at, name, [_, ...generics]) {name.startsWith("Function$")} =>
                     "(" + generics.dropLast().map {go(_)}.join(", ") + ") => " + go(generics.grabLast())
                 | TConstructor(at, name, generics) {name.startsWith("Record$")} =>
-                    let as = name.split('$').toList().dropFirst().zip(generics)
+                    let as = name.split('$').dropFirst().zip(generics)
                     "(" + as.map {| Pair(label, t) => label + ": " + go(t)}.join(", ") + ")"
                 | TConstructor(at, name, generics) =>
                     let shortenedName = shortenType(name)

package/compiler/Tokenizer.ff

@@ -2,12 +2,12 @@ import Token
 import Syntax
 import LspHook
 
-tokenize(file: String, code: String, completionAt: Option[Location], attemptFixes: Bool): Array[Token] {
+tokenize(file: String, code: String, completionAt: Option[Location], attemptFixes: Bool): List[Token] {
 
     let completionLine = completionAt.filter {_.file == file}.map {_.line}.else {-1}
     let completionColumn = completionAt.filter {_.file == file}.map {_.column}.else {-1}
 
-    let tokens = Stack.make[Token]()
+    let tokens = Array.make[Token]()
     mutable line = 1
     mutable lineOffset = 0
 

package/compiler/Workspace.ff

@@ -29,9 +29,9 @@ loadWorkspace(path: Path): Workspace {
 parseWorkspaceFile(path: Path, packageDirectory: Path): Workspace {
     let text = path.readText()
     mutable defaultLocation = None
-    let lines = text.split('\n').toList().map {_.replace("\r", "").takeWhile {_ != '#'}}.filter {_.size() != 0}
+    let lines = text.split('\n').map {_.replace("\r", "").takeWhile {_ != '#'}}.filter {_.size() != 0}
     let rules = lines.collect {line =>
-        let columns = line.replace("\t", " ").split(' ').toList().filter {_.size() != 0}
+        let columns = line.replace("\t", " ").split(' ').filter {_.size() != 0}
         defaultLocation.each {_ =>
             panic("Unexpected rule after the * rule: " + line)
         }