firefly-compiler 0.4.4

package/compiler/Substitution.ff

@@ -0,0 +1,178 @@
+import Syntax
+
+class Substitution(mutable substitution: Map[Int, Type])
+
+core(name: String): String {
+    "ff:core/" + name + "." + name
+}
+
+extend self: Substitution {
+
+    substituteModule(module: Module): Module {
+        let lets = module.lets.map { self.substituteLetDefinition(_) }
+        let functions = module.functions.map { self.substituteFunctionDefinition(_) }
+        let extends = module.extends.map { self.substituteExtendDefinition(_) }
+        //let traits = module.traits.map { self.substituteTraitDefinition(_) }
+        let instances = module.instances.map { self.substituteInstanceDefinition(_) }
+        module.Module(
+            //traits = traits,
+            instances = instances
+            extends = extends
+            lets = lets
+            functions = functions
+        )
+    }
+
+    substituteLetDefinition(definition: DLet): DLet {
+        definition.DLet(
+            variableType = self.substituteType(definition.variableType)
+            value = self.substituteTerm(definition.value)
+        )
+    }
+
+    substituteExtendDefinition(definition: DExtend): DExtend {
+        definition.DExtend(
+            methods = definition.methods.map { self.substituteFunctionDefinition(_) }
+        )
+    }
+
+    substituteFunctionDefinition(definition: DFunction): DFunction {
+        definition.DFunction(
+            signature = self.substituteSignature(definition.signature)
+            body = definition.body.mapFirefly {self.substituteLambda(_)}
+        )
+    }
+
+    substituteSignature(signature: Signature): Signature {
+        signature.Signature(
+            constraints = signature.constraints.map {self.substituteConstraint(_)}
+            parameters = signature.parameters.map {self.substituteParameter(_)}
+            returnType = self.substituteType(signature.returnType)
+            effect = self.substituteType(signature.effect)
+        )
+    }
+
+    substituteConstraint(constraint: Constraint): Constraint {
+        constraint.Constraint(
+            generics = constraint.generics.map {self.substituteType(_)}
+        )
+    }
+
+    substituteParameter(parameter: Parameter): Parameter {
+        parameter.Parameter(
+            valueType = self.substituteType(parameter.valueType)
+            default = parameter.default.map {self.substituteTerm(_)}
+        )
+    }
+
+    substituteInstanceDefinition(definition: DInstance): DInstance {
+        definition.DInstance(
+            methods = definition.methods.map { self.substituteFunctionDefinition(_) }
+        )
+    }
+
+    substituteLambda(definition: Lambda): Lambda {
+        definition.Lambda(
+            effect = self.substituteType(definition.effect)
+            cases = definition.cases.map { case =>
+                case.MatchCase(
+                    guards = case.guards.map { g => g.MatchGuard(term = self.substituteTerm(g.term)) }
+                    body = self.substituteTerm(case.body)
+                )
+            }
+        )
+    }
+
+    substituteTerm(term: Term): Term {
+        term.{
+            | EString _ => term
+            | EChar _ => term
+            | EInt _ => term
+            | EFloat _ => term
+            | EVariable _ => term
+            | EField e => e.EField(record = self.substituteTerm(e.record))
+            | EWildcard e => term
+            | EList e => e.EList(
+                elementType = self.substituteType(e.elementType)
+                items = e.items.map {| Pair(item, b) => Pair(self.substituteTerm(item), b) }
+            )
+            | ESequential e => e.ESequential(
+                before = self.substituteTerm(e.before)
+                after = self.substituteTerm(e.after)
+            )
+            | ELet e => e.ELet(
+                valueType = self.substituteType(e.valueType)
+                value = self.substituteTerm(e.value)
+                body = self.substituteTerm(e.body)
+            )
+            | ELambda e => e.ELambda(lambda = self.substituteLambda(e.lambda))
+            | EVariant e => e.EVariant(
+                typeArguments = e.typeArguments.map {self.substituteType(_)}
+                arguments = e.arguments.map { _.map {self.substituteArgument(_)} }
+            )
+            | EVariantIs e => e.EVariantIs(
+                typeArguments = e.typeArguments.map {self.substituteType(_)}
+            )
+            | ECopy e => e.ECopy(
+                record = self.substituteTerm(e.record)
+                arguments = e.arguments.map {self.substituteField(_)}
+            )
+            | EPipe e => e.EPipe(
+                value = self.substituteTerm(e.value)
+                effect = self.substituteType(e.effect)
+                function = self.substituteTerm(e.function)
+            )
+            | ECall e => e.ECall(
+                target = e.target.{
+                    | DynamicCall call => call.DynamicCall(function = self.substituteTerm(call.function))
+                    | StaticCall _ => e.target
+                }
+                effect = self.substituteType(e.effect)
+                typeArguments = e.typeArguments.map {self.substituteType(_)}
+                arguments = e.arguments.map {self.substituteArgument(_)}
+            )
+            | ERecord e => e.ERecord(fields = e.fields.map {self.substituteField(_)})
+            | EFunctions e => e.EFunctions(
+                functions = e.functions.map {self.substituteFunctionDefinition(_)}
+                body = self.substituteTerm(e.body)
+            )
+            | EAssign e => e.EAssign(value = self.substituteTerm(e.value))
+            | EAssignField e => e.EAssignField(
+                record = self.substituteTerm(e.record)
+                value = self.substituteTerm(e.value)
+            )
+        }
+    }
+
+    substituteArgument(argument: Argument): Argument {
+        argument.Argument(value = self.substituteTerm(argument.value))
+    }
+
+    substituteField(field: Field): Field {
+        field.Field(value = self.substituteTerm(field.value))
+    }
+
+    substituteType(type: Type): Type {
+        | TVariable(at, i) =>
+            if(self.has(i)) { self.substituteType(self.get(i)) } else { TConstructor(at, core("Nothing"), []) }
+        | TConstructor t =>
+            t.TConstructor(generics = t.generics.map { t => self.substituteType(t) })
+    }
+
+    get(index: Int): Type {
+        self.substitution.grab(index).{
+            | TVariable(_, i) { self.has(i) } =>
+                let t = self.get(i)
+                self.substitution = self.substitution.add(index, t)
+                t
+            | TVariable(at, _) =>
+                TConstructor(at, core("Nothing"), [])
+            | t => t
+        }
+    }
+
+    has(index: Int): Bool {
+        self.substitution.contains(index)
+    }
+
+}

package/compiler/Syntax.ff

@@ -0,0 +1,299 @@
+data Location(file: String, line: Int, column: Int)
+
+extend self: Location {
+    show(): String {
+        "in " + self.file + " " +
+        "at line " + self.line +
+        ", column " + self.column
+    }
+}
+
+data CompileError(at: Location, message: String)
+
+data ModuleWithPackageInfo(
+    packageInfo: Option[PackageInfo]
+    module: Module
+)
+
+data PackageInfo(
+    package: DPackage
+    dependencies: List[DDependency]
+    includes: List[DInclude]
+)
+
+data Module(
+    file: String
+    packagePair: PackagePair
+    imports: List[DImport]
+    types: List[DType]
+    traits: List[DTrait]
+    instances: List[DInstance]
+    extends: List[DExtend]
+    lets: List[DLet]
+    functions: List[DFunction]
+)
+
+data PackagePair(
+    group: String
+    name: String
+)
+
+extend self: PackagePair {
+    groupName(delimiter: String = ":"): String {
+        self.group + delimiter + self.name
+    }
+}
+
+data DPackage(
+    at: Location
+    packagePair: PackagePair
+    version: Version
+    targets: TargetNames
+)
+data DDependency(
+    at: Location
+    packagePair: PackagePair
+    version: Version
+    safety: Safety
+    targets: TargetNames
+)
+data DInclude(
+    at: Location
+    path: String
+)
+data TargetNames(
+    node: Bool
+    browser: Bool
+)
+data DImport(
+    at: Location
+    alias: String
+    package: PackagePair
+    directory: List[String]
+    file: String
+)
+data DFunction(
+    at: Location
+    signature: Signature
+    body: Target
+)
+data DLet(
+    at: Location
+    name: String
+    variableType: Type
+    value: Term
+)
+data DExtend(
+    at: Location
+    name: String
+    generics: List[String]
+    constraints: List[Constraint]
+    type: Type
+    methods: List[DFunction]
+)
+data DType(
+    at: Location
+    newtype: Bool
+    data: Bool
+    name: String
+    generics: List[String]
+    constraints: List[Constraint]
+    commonFields: List[Parameter]
+    variants: List[Variant]
+)
+data DTrait(
+    at: Location
+    name: String
+    generics: List[String]
+    constraints: List[Constraint]
+    generatorParameters: List[Parameter]
+    methods: List[Signature]
+    methodDefaults: List[Pair[String, Lambda]]
+    methodGenerators: List[Pair[String, Lambda]]
+)
+data DInstance(
+    at: Location
+    generics: List[String]
+    constraints: List[Constraint]
+    traitName: String
+    typeArguments: List[Type]
+    generatorArguments: List[Argument]
+    methods: List[DFunction]
+    derived: Bool
+)
+
+data Term(at: Location) {
+    EString(value: String)
+    EChar(value: String)
+    EInt(value: String)
+    EFloat(value: String)
+    EVariable(name: String)
+    ELambda(lambda: Lambda)
+    EFunctions(functions: List[DFunction], body: Term)
+    ELet(mutable: Bool, name: String, valueType: Type, value: Term, body: Term)
+    ESequential(before: Term, after: Term)
+    EAssign(operator: String, variable: String, value: Term)
+    EAssignField(operator: String, record: Term, field: String, value: Term)
+    EPipe(value: Term, effect: Type, function: Term)
+    ECall(
+        target: CallTarget
+        effect: Type
+        typeArguments: List[Type]
+        arguments: List[Argument]
+        dictionaries: List[Dictionary]
+    )
+    EList(elementType: Type, items: List[Pair[Term, Bool]])
+    ECopy(name: String, record: Term, arguments: List[Field])
+    EVariant(name: String, typeArguments: List[Type], arguments: Option[List[Argument]])
+    EVariantIs(name: String, typeArguments: List[Type])
+    ERecord(fields: List[Field])
+    EField(newtype: Bool, record: Term, field: String)
+    EWildcard(index: Int)
+}
+
+data CallTarget {
+    DynamicCall(function: Term, tailCall: Bool)
+    StaticCall(name: String, tailCall: Bool, instanceCall: Bool)
+}
+
+data MatchCase(
+    at: Location
+    patterns: List[MatchPattern]
+    guards: List[MatchGuard]
+    body: Term
+)
+
+data MatchPattern(at: Location) {
+    PString(value: String)
+    PInt(value: String)
+    PChar(value: String)
+    PVariable(name: Option[String])
+    PVariant(name: String, patterns: List[MatchPattern])
+    PVariantAs(name: String, variableAt: Location, variable: Option[String])
+    PAlias(pattern: MatchPattern, variable: String)
+}
+
+data MatchGuard(
+    at: Location
+    term: Term
+    pattern: MatchPattern
+)
+
+data Dictionary(
+    packagePair: PackagePair
+    moduleName: String
+    traitName: String
+    typeName: String
+    dictionaries: List[Dictionary]
+)
+
+data Signature(
+    at: Location
+    name: String
+    member: Bool
+    generics: List[String]
+    constraints: List[Constraint]
+    parameters: List[Parameter]
+    returnType: Type
+    effect: Type
+)
+
+data Lambda(at: Location, effect: Type, cases: List[MatchCase])
+
+data Variant(at: Location, name: String, fields: List[Parameter])
+
+data Parameter(at: Location, mutable: Bool, name: String, valueType: Type, default: Option[Term])
+
+data Argument(at: Location, name: Option[String], value: Term)
+
+data Field(at: Location, name: String, value: Term)
+
+data Constraint(at: Location, name: String, generics: List[Type])
+
+data Target {
+    FireflyTarget(lambda: Lambda)
+    ForeignTarget(syncCode: Option[String], asyncCode: Option[String])
+}
+
+data Type(at: Location) {
+    TConstructor(name: String, generics: List[Type])
+    TVariable(index: Int)
+}
+
+data Safety {
+    Safe
+    Unsafe
+    Trusted
+}
+
+data Version(at: Location, major: Int, minor: Int, patch: Int)
+
+extend self: Type {
+    show(shownTypes: List[Type]): String {
+        mutable seenTypes = Map.empty()
+        let typeNames = 'a'.codeUnit.to('z'.codeUnit).map {Char(_).toString()}.toStream()
+        function shortenType(qualified: String): String {
+            qualified.reverse().takeWhile {_ != '.'}.reverse()
+        }
+        function shortenTypes(types: List[Type]) {
+            types.each {
+                | TConstructor(_, name, typeArguments) =>
+                    let shortenedName = shortenType(name)
+                    seenTypes.get(shortenedName).{
+                        | None => 
+                            seenTypes = seenTypes.add(shortenedName, name)
+                        | Some(qualified) => 
+                            if(name != qualified) {
+                                seenTypes = seenTypes.add(shortenedName, "")
+                            }
+                    }
+                    shortenTypes(typeArguments)
+                | TVariable(_, index) =>
+                    if(!seenTypes.contains("$" + index)) {
+                        seenTypes = seenTypes.add("$" + index, typeNames.next().else {"$" + index})
+                    }
+            }
+        }
+        shortenTypes([...shownTypes, self])
+        function go(type: Type): String {
+            type.{
+                | TConstructor(at, name, [_, r]) {name.startsWith("Function$")} =>
+                    "() => " + go(r)
+                | TConstructor(at, name, [_, a, r]) {name.startsWith("Function$")} =>
+                    go(a) + " => " + go(r)
+                | 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)
+                    "(" + as.map {| Pair(label, t) => label + ": " + go(t)}.join(", ") + ")"
+                | TConstructor(at, name, generics) =>
+                    let shortenedName = shortenType(name)
+                    let chosenName = seenTypes.grab(shortenedName).{
+                        | "" => name
+                        | _ => shortenedName
+                    }
+                    let filteredGenerics = generics.filter {
+                        // Hack to hide the effect, only works when the effect is Q$
+                        | TConstructor(_, "Q$", _) => False
+                        | _ => True
+                    }
+                    if(filteredGenerics.isEmpty()) {chosenName} else {
+                        chosenName + "[" + filteredGenerics.map {go(_)}.join(", ") + "]"
+                    }
+                | TVariable(at, index) =>
+                    seenTypes.grab("$" + index)
+            }
+        }
+        go(self)
+    }
+}
+
+extend self: Target {
+    mapFirefly(body: Lambda => Lambda): Target {
+        self.{
+             | FireflyTarget(lambda) => FireflyTarget(body(lambda))
+             | ForeignTarget(_, _) => self
+        }
+    }
+}
+

package/compiler/Token.ff

@@ -0,0 +1,180 @@
+import Syntax
+
+data Token(
+    file: String
+    code: String
+    kind: TokenKind
+    startLine: Int
+    startLineOffset: Int
+    startOffset: Int
+    stopLine: Int
+    stopLineOffset: Int
+    stopOffset: Int
+)
+
+extend token: Token {
+
+    at(): Location {
+        Location(token.file, token.startLine, (token.startOffset - token.startLineOffset) + 1)
+    }
+
+    end(): Location {
+        Location(token.file, token.startLine, (token.stopOffset - token.startLineOffset) + 1)
+    }
+
+    raw(): String {
+        token.code.slice(token.startOffset, token.stopOffset)
+    }
+
+    is(kind1: TokenKind): Bool {
+        token.kind == kind1
+    }
+
+    is2(kind1: TokenKind, kind2: TokenKind): Bool {
+        token.kind == kind1 || token.kind == kind2
+    }
+
+    is3(kind1: TokenKind, kind2: TokenKind, kind3: TokenKind): Bool {
+        token.kind == kind1 || token.kind == kind2 || token.kind == kind3
+    }
+
+    rawIs(value: String): Bool {
+        token.stopOffset - token.startOffset == value.size() &&
+        token.code.startsWith(value, token.startOffset)
+    }
+
+    rawIs2(value1: String, value2: String): Bool {
+        token.rawIs(value1) || token.rawIs(value2)
+    }
+
+    rawIs3(value1: String, value2: String, value3: String): Bool {
+        token.rawIs(value1) || token.rawIs(value2) || token.rawIs(value3)
+    }
+
+    rawIs4(value1: String, value2: String, value3: String, value4: String): Bool {
+        token.rawIs(value1) || token.rawIs(value2) || token.rawIs(value3) || token.rawIs(value4)
+    }
+
+}
+
+data TokenKind {
+    LEnd
+    LString
+    LChar
+    LInt
+    LFloat
+    LKeyword
+    LNamespace
+    LLower
+    LUpper
+    LWildcard
+    LBracketLeft
+    LBracketRight
+    LOperator
+    LComma
+    LSeparator
+    LDot
+    LSemicolon
+    LPipe
+    LColon
+    LDotDotDot
+    LArrowThick
+    LAssign
+    LAssignPlus
+    LAssignMinus
+    LAssignLink
+}
+
+extend self: TokenKind {
+
+    beforeSeparator(): Bool {
+        self.{
+            | LEnd => False
+            | LString => True
+            | LChar => True
+            | LInt => True
+            | LFloat => True
+            | LKeyword => True
+            | LNamespace => False
+            | LLower => True
+            | LUpper => True
+            | LWildcard => True
+            | LBracketLeft => False
+            | LBracketRight => True
+            | LOperator => False
+            | LComma => False
+            | LSeparator => False
+            | LDot => False
+            | LSemicolon => False
+            | LPipe => False
+            | LColon => False
+            | LDotDotDot => False
+            | LArrowThick => False
+            | LAssign => False
+            | LAssignPlus => False
+            | LAssignMinus => False
+            | LAssignLink => False
+        }
+    }
+
+    afterSeparator(): Bool {
+        self.{
+            | LEnd => False
+            | LString => True
+            | LChar => True
+            | LInt => True
+            | LFloat => True
+            | LKeyword => True
+            | LNamespace => True
+            | LLower => True
+            | LUpper => True
+            | LWildcard => True
+            | LBracketLeft => True
+            | LBracketRight => False
+            | LOperator => False
+            | LComma => False
+            | LSeparator => False
+            | LDot => False
+            | LSemicolon => False
+            | LPipe => False
+            | LColon => False
+            | LDotDotDot => True
+            | LArrowThick => False
+            | LAssign => False
+            | LAssignPlus => False
+            | LAssignMinus => False
+            | LAssignLink => False
+        }
+    }
+
+    afterKeyword(): Bool {
+        self.{
+            | LEnd => False
+            | LString => True
+            | LChar => True
+            | LInt => True
+            | LFloat => True
+            | LKeyword => True
+            | LNamespace => True
+            | LLower => True
+            | LUpper => True
+            | LWildcard => True
+            | LBracketLeft => False
+            | LBracketRight => False
+            | LOperator => False
+            | LComma => False
+            | LSeparator => False
+            | LDot => False
+            | LSemicolon => False
+            | LPipe => False
+            | LColon => False
+            | LDotDotDot => False
+            | LArrowThick => False
+            | LAssign => False
+            | LAssignPlus => False
+            | LAssignMinus => False
+            | LAssignLink => False
+        }
+    }
+
+}