firefly-compiler 0.4.4

package/compiler/Deriver.ff

@@ -0,0 +1,647 @@
+import Syntax
+
+data Deriver()
+
+make(): Deriver {
+    Deriver()
+}
+
+fail[T](at: Location, message: String): T {
+    panic(message + " " + at.show())
+}
+
+extend self: Deriver {
+
+    deriveModule(module: Module): Module {
+
+        let modulePrefix = module.packagePair.groupName() + "/" + module.file.dropLast(3)
+
+        module.Module(
+            instances = [
+                ...module.instances
+                ...self.makeHasAnyTagInstances(modulePrefix, module)
+                ...self.makeShowInstances(modulePrefix, module)
+                ...self.makeEqualInstances(modulePrefix, module)
+                ...self.makeOrderingInstances(modulePrefix, module)
+                ...self.makeSerializableInstances(modulePrefix, module)
+            ]
+        )
+    }
+
+    // HasAnyTag
+    makeHasAnyTagInstances(modulePrefix: String, module: Module): List[DInstance] {
+        let coreWhitelist = [
+            "ff:core/Serializable.DeserializationChecksumException"
+            "ff:core/Core.GrabException"
+        ].toSet() // Maybe whitelist all?
+        let missingInstance =
+            self.findTypesThatNeedInstances("ff:core/Any.HasAnyTag", modulePrefix, coreWhitelist, True, module)
+        missingInstance.map {self.makeHasAnyTagInstance(modulePrefix, _)}
+    }
+
+    makeHasAnyTagInstance(modulePrefix: String, declaration: DType): DInstance {
+        let at = declaration.at.Location(file = declaration.at.file + "/<derived>")
+        let constraints = declaration.generics.map {t =>
+            Constraint(at, "ff:core/Any.HasAnyTag", [TConstructor(at, t, [])])
+        }
+        let typeArguments = declaration.generics.map {t =>
+            TConstructor(at, t, [])
+        }
+        let selfTypeName = modulePrefix + "." + declaration.name
+        let selfType = TConstructor(at, selfTypeName, typeArguments)
+        let noEffect = TConstructor(at, "ff:core/Nothing.Nothing", [])
+        let signature = Signature(
+            at = at
+            name = "anyTag"
+            member = False
+            generics = []
+            constraints = []
+            parameters = []
+            returnType = TConstructor(at, "ff:core/Any.AnyTag", [selfType])
+            effect = noEffect
+        )
+        let typeArgumentStrings = typeArguments.map {
+            self.makeMethodCall(at, self.makeSimpleCall(at, "ff:core/Any.anyTag", [], [_]), "show", [])
+        }
+        let strings =
+            [EString(at, "\"[\""), ...typeArgumentStrings.insertBetween([EString(at, "\",\"")]), EString(at, "\"]\"")]
+        let body = FireflyTarget(
+            Lambda(at, noEffect, [MatchCase(
+                at = at,
+                patterns = []
+                guards = []
+                body = self.makeSimpleCall(at, "ff:core/Any.internalAnyTag", [
+                    strings.foldLeft(EString(at, "\"" + selfTypeName + "\"")) {a, b =>
+                        self.makeSimpleCall(at, "+", [a, b])
+                    }
+                ])
+            )])
+        )
+        let method = DFunction(at, signature, body)
+        DInstance(
+            at = at
+            generics = declaration.generics
+            constraints = constraints
+            traitName = "ff:core/Any.HasAnyTag"
+            typeArguments = [selfType]
+            generatorArguments = []
+            methods = [method]
+            derived = True
+        )
+    }
+
+    // Show
+    makeShowInstances(modulePrefix: String, module: Module): List[DInstance] {
+        let coreWhitelist = [
+            "ff:core/Option.Option"
+        ].toSet()
+        let missingInstance =
+            self.findTypesThatNeedInstances("ff:core/Show.Show", modulePrefix, coreWhitelist, True, module)
+        missingInstance.map {self.makeShowInstance(modulePrefix, _)}
+    }
+
+    makeShowInstance(modulePrefix: String, declaration: DType): DInstance {
+        let at = declaration.at.Location(file = declaration.at.file + "/<derived>")
+        let constraints = declaration.generics.map {t =>
+            Constraint(at, "ff:core/Show.Show", [TConstructor(at, t, [])])
+        }
+        let typeArguments = declaration.generics.map {t =>
+            TConstructor(at, t, [])
+        }
+        let selfType = TConstructor(at, modulePrefix + "." + declaration.name, typeArguments)
+        let noEffect = TConstructor(at, "ff:core/Nothing.Nothing", [])
+        let signature = Signature(
+            at = at
+            name = "show"
+            member = False
+            generics = []
+            constraints = []
+            parameters = [Parameter(at, False, "value", selfType, None)]
+            returnType = TConstructor(at, "ff:core/String.String", [])
+            effect = noEffect
+        )
+        let body = FireflyTarget(
+            Lambda(at, noEffect, self.makeShowCases(modulePrefix, declaration, selfType))
+        )
+        let showMethod = DFunction(at, signature, body)
+        DInstance(
+            at = at
+            generics = declaration.generics
+            constraints = constraints
+            traitName = "ff:core/Show.Show"
+            typeArguments = [selfType]
+            generatorArguments = []
+            methods = [showMethod]
+            derived = True
+        )
+    }
+
+    makeShowCases(modulePrefix: String, declaration: DType, selfType: Type): List[MatchCase] {
+        let at = declaration.at.Location(file = declaration.at.file + "/<derived>")
+        let noEffect = TConstructor(at, "ff:core/Nothing.Nothing", [])
+        let wildcardPattern = PVariable(at, None)
+        declaration.variants.{
+            | variants =>
+                variants.map {variant =>
+                    let variantName = modulePrefix + "." + variant.name
+                    let fields = [...declaration.commonFields, ...variant.fields]
+                    let strings = if(fields.size() == 0) {[]} else {[
+                        EString(at, "\"(\"")
+                        ...fields.map {field =>
+                            self.makeSimpleCall(at, "ff:core/Show.show", [
+                                EField(at, False, EVariable(at, "z"), field.name)
+                            ])
+                        }.insertBetween([EString(at, "\", \"")])
+                        EString(at, "\")\"")
+                    ]}
+                    MatchCase(
+                        at = at
+                        patterns = [PVariantAs(at, variantName, at, Some("z"))]
+                        guards = []
+                        body = strings.foldLeft(EString(at, "\"" + variant.name + "\"")) {a, b =>
+                            self.makeSimpleCall(at, "+", [a, b])
+                        }
+                    )
+                }
+        }
+    }
+
+    // Ordering
+    makeOrderingInstances(modulePrefix: String, module: Module): List[DInstance] {
+        let coreWhitelist = [
+            "ff:core/Option.Option"
+        ].toSet()
+        let missingInstance =
+            self.findTypesThatNeedInstances("ff:core/Ordering.Order", modulePrefix, coreWhitelist, True, module)
+        missingInstance.map {self.makeOrderingInstance(modulePrefix, _)}
+    }
+
+    makeOrderingInstance(modulePrefix: String, declaration: DType): DInstance {
+        let at = declaration.at.Location(file = declaration.at.file + "/<derived>")
+        let constraints = declaration.generics.map {t =>
+            Constraint(at, "ff:core/Ordering.Order", [TConstructor(at, t, [])])
+        }
+        let typeArguments = declaration.generics.map {t =>
+            TConstructor(at, t, [])
+        }
+        let selfType = TConstructor(at, modulePrefix + "." + declaration.name, typeArguments)
+        let noEffect = TConstructor(at, "ff:core/Nothing.Nothing", [])
+        let signature = Signature(
+            at = at
+            name = "compare"
+            member = False
+            generics = []
+            constraints = []
+            parameters = [
+                Parameter(at, False, "x", selfType, None)
+                Parameter(at, False, "y", selfType, None)
+            ]
+            returnType = TConstructor(at, "ff:core/Ordering.Ordering", [])
+            effect = noEffect
+        )
+        let body = FireflyTarget(
+            Lambda(at, noEffect, self.makeOrderingCases(modulePrefix, declaration, selfType))
+        )
+        let compareMethod = DFunction(at, signature, body)
+        DInstance(
+            at = at
+            generics = declaration.generics
+            constraints = constraints
+            traitName = "ff:core/Ordering.Order"
+            typeArguments = [selfType]
+            generatorArguments = []
+            methods = [compareMethod]
+            derived = True
+        )
+    }
+
+    makeOrderingCases(modulePrefix: String, declaration: DType, selfType: Type): List[MatchCase] {
+        let at = declaration.at.Location(file = declaration.at.file + "/<derived>")
+        let noEffect = TConstructor(at, "ff:core/Nothing.Nothing", [])
+        let wildcardPattern = PVariable(at, None)
+        let sameCase = MatchCase(
+            at = at,
+            patterns = [wildcardPattern, wildcardPattern]
+            guards = [MatchGuard(
+                at,
+                self.makeSimpleCall(at, "===", [EVariable(at, "x"), EVariable(at, "y")]),
+                PVariant(at, "ff:core/Bool.True", [])
+            )]
+            body = EVariant(at, "ff:core/Ordering.OrderingSame", [], None)
+        )
+        declaration.variants.{
+            | [variant] =>
+                let fields = [...declaration.commonFields, ...variant.fields]
+                [sameCase, MatchCase(
+                    at = at
+                    patterns = [wildcardPattern, wildcardPattern]
+                    guards = []
+                    body = self.makeOrderingFields(modulePrefix, declaration, fields)
+                )]
+            | variants =>
+                let variantsWithFields = variants.filter {variant =>
+                    !declaration.commonFields.isEmpty() || !variant.fields.isEmpty()
+                } // We can skip no-arg constructors assuming there are never more than one instance of them
+                let sameVariantCases = variantsWithFields.map { variant =>
+                    let variantName = modulePrefix + "." + variant.name
+                    let fields = [...declaration.commonFields, ...variant.fields]
+                    MatchCase(
+                        at = at,
+                        patterns = [PVariantAs(at, variantName, at, Some("x")), PVariantAs(at, variantName, at, Some("y"))]
+                        guards = []
+                        body = self.makeOrderingFields(modulePrefix, declaration, fields)
+                    )
+                }
+                let intType = TConstructor(at, "ff:core/Int.Int", [])
+                let numberSignature =
+                    Signature(at, "number", False, [], [], [Parameter(at, False, "z", selfType, None)], intType, noEffect)
+                let numberCases = declaration.variants.pairs().map {| Pair(index, variant) =>
+                    let variantName = modulePrefix + "." + variant.name
+                    MatchCase(
+                        at = at
+                        patterns = [PVariantAs(at, variantName, at, None)]
+                        guards = []
+                        body = EInt(at, "" + index)
+                    )
+                }
+                let differentVariant = MatchCase(
+                    at = at,
+                    patterns = [wildcardPattern, wildcardPattern]
+                    guards = []
+                    body =
+                        EFunctions(at,
+                            [DFunction(at, numberSignature, FireflyTarget(Lambda(at, noEffect, numberCases)))],
+                            self.makeSimpleCall(at, "ff:core/Ordering.compare", [
+                                self.makeSimpleCall(at, "number", [EVariable(at, "x")])
+                                self.makeSimpleCall(at, "number", [EVariable(at, "y")])
+                            ])
+                        )
+                )
+                [sameCase, ...sameVariantCases, differentVariant]
+        }
+    }
+
+    makeOrderingFields(modulePrefix: String, declaration: DType, fields: List[Parameter]): Term {
+        let at = declaration.at.Location(file = declaration.at.file + "/<derived>")
+        let orderingType = TConstructor(at, "ff:core/Ordering.Ordering", [])
+        let orderingSame = EVariant(at, "ff:core/Ordering.OrderingSame", [], None)
+        function go(fields: List[Parameter]): Term {
+            | [] =>
+                orderingSame
+            | [head, ...tail] =>
+                let variableName = head.name + "Ordering"
+                let compareTerm = self.makeSimpleCall(at, "ff:core/Ordering.compare", [
+                    EField(at, False, EVariable(at, "x"), head.name)
+                    EField(at, False, EVariable(at, "y"), head.name)
+                ])
+                let notEqualTerm = self.makeSimpleCall(at, "!==", [
+                    EVariable(at, variableName)
+                    orderingSame
+                ])
+                let ifTerm = self.makeIf(at, notEqualTerm, EVariable(at, variableName), go(tail))
+                ELet(at, False, variableName, orderingType, compareTerm, ifTerm)
+        }
+        go(fields)
+    }
+
+    // Equal
+    makeEqualInstances(modulePrefix: String, module: Module): List[DInstance] {
+        let coreWhitelist = [
+            "ff:core/Option.Option"
+            "ff:core/List.List"
+            "ff:core/Pair.Pair"
+        ].toSet()
+        let missingInstance =
+            self.findTypesThatNeedInstances("ff:core/Equal.Equal", modulePrefix, coreWhitelist, True, module)
+        missingInstance.map {self.makeEqualInstance(modulePrefix, _)}
+    }
+
+    makeEqualInstance(modulePrefix: String, declaration: DType): DInstance {
+        let at = declaration.at.Location(file = declaration.at.file + "/<derived>")
+        let constraints = declaration.generics.map {t =>
+            Constraint(at, "ff:core/Equal.Equal", [TConstructor(at, t, [])])
+        }
+        let typeArguments = declaration.generics.map {t =>
+            TConstructor(at, t, [])
+        }
+        let selfType = TConstructor(at, modulePrefix + "." + declaration.name, typeArguments)
+        let noEffect = TConstructor(at, "ff:core/Nothing.Nothing", [])
+        let signature = Signature(
+            at = at
+            name = "equals"
+            member = False
+            generics = []
+            constraints = []
+            parameters = [
+                Parameter(at, False, "x", selfType, None)
+                Parameter(at, False, "y", selfType, None)
+            ]
+            returnType = TConstructor(at, "ff:core/Bool.Bool", [])
+            effect = noEffect
+        )
+        let body = FireflyTarget(
+            Lambda(at, noEffect, self.makeEqualsCases(modulePrefix, declaration, selfType))
+        )
+        let equalsMethod = DFunction(at, signature, body)
+        DInstance(
+            at = at
+            generics = declaration.generics
+            constraints = constraints
+            traitName = "ff:core/Equal.Equal"
+            typeArguments = [selfType]
+            generatorArguments = []
+            methods = [equalsMethod]
+            derived = True
+        )
+    }
+
+    makeEqualsCases(modulePrefix: String, declaration: DType, selfType: Type): List[MatchCase] {
+        let at = declaration.at.Location(file = declaration.at.file + "/<derived>")
+        let noEffect = TConstructor(at, "ff:core/Nothing.Nothing", [])
+        let wildcardPattern = PVariable(at, None)
+        let sameCase = MatchCase(
+            at = at
+            patterns = [wildcardPattern, wildcardPattern]
+            guards = [MatchGuard(
+                at
+                self.makeSimpleCall(at, "===", [EVariable(at, "x"), EVariable(at, "y")])
+                PVariant(at, "ff:core/Bool.True", [])
+            )]
+            body = EVariant(at, "ff:core/Bool.True", [], None)
+        )
+        declaration.variants.{
+            | [variant] =>
+                let fields = [...declaration.commonFields, ...variant.fields]
+                [sameCase, MatchCase(
+                    at = at
+                    patterns = [wildcardPattern, wildcardPattern]
+                    guards = []
+                    body = self.makeEqualFields(modulePrefix, declaration, fields)
+                )]
+            | variants =>
+                let variantsWithFields = variants.filter {variant =>
+                    !declaration.commonFields.isEmpty() || !variant.fields.isEmpty()
+                } // We can skip no-arg constructors assuming there are never more than one instance of them
+                let sameVariantCases = variantsWithFields.map { variant =>
+                    let variantName = modulePrefix + "." + variant.name
+                    let fields = [...declaration.commonFields, ...variant.fields]
+                    MatchCase(
+                        at = at
+                        patterns = [PVariantAs(at, variantName, at, Some("x")), PVariantAs(at, variantName, at, Some("y"))]
+                        guards = []
+                        body = self.makeEqualFields(modulePrefix, declaration, fields)
+                    )
+                }
+                let differentVariant = MatchCase(
+                    at = at
+                    patterns = [wildcardPattern, wildcardPattern]
+                    guards = []
+                    body = EVariant(at, "ff:core/Bool.False", [], None)
+                )
+                [sameCase, ...sameVariantCases, differentVariant]
+        }
+    }
+
+    makeEqualFields(modulePrefix: String, declaration: DType, fields: List[Parameter]): Term {
+        let at = declaration.at.Location(file = declaration.at.file + "/<derived>")
+        function go(fields: List[Parameter]): Term {
+            | [] =>
+                EVariant(at, "ff:core/Bool.True", [], None)
+            | [head] =>
+                self.makeSimpleCall(at, "ff:core/Equal.equals", [
+                    EField(at, False, EVariable(at, "x"), head.name)
+                    EField(at, False, EVariable(at, "y"), head.name)
+                ])
+            | [head, ...tail] =>
+                let equalsTerm = self.makeSimpleCall(at, "ff:core/Equal.equals", [
+                    EField(at, False, EVariable(at, "x"), head.name)
+                    EField(at, False, EVariable(at, "y"), head.name)
+                ])
+                self.makeSimpleCall(at, "&&", [
+                    equalsTerm
+                    go(tail)
+                ])
+        }
+        go(fields)
+    }
+
+    // Serializable
+    makeSerializableInstances(modulePrefix: String, module: Module): List[DInstance] {
+        let coreWhitelist = [
+            "ff:core/Option.Option"
+            "ff:core/Pair.Pair"
+        ].toSet()
+        let missingInstance =
+            self.findTypesThatNeedInstances("ff:core/Serializable.Serializable", modulePrefix, coreWhitelist, True, module)
+        missingInstance.map {self.makeSerializableInstance(modulePrefix, _)}
+    }
+
+    makeSerializableInstance(modulePrefix: String, declaration: DType): DInstance {
+        let at = declaration.at.Location(file = declaration.at.file + "/<derived>")
+        let constraints = declaration.generics.map { t =>
+            Constraint(at, "ff:core/Serializable.Serializable", [TConstructor(at, t, [])])
+        }
+        let typeArguments = declaration.generics.map { t =>
+            TConstructor(at, t, [])
+        }
+        let selfType = TConstructor(at, modulePrefix + "." + declaration.name, typeArguments)
+        let noEffect = TConstructor(at, "ff:core/Nothing.Nothing", [])
+        let serializationType = TConstructor(at, "ff:core/Serializable.Serialization", [])
+        let serializeSignature = Signature(
+            at = at
+            name = "serializeUsing"
+            member = False
+            generics = []
+            constraints = []
+            parameters = [
+                Parameter(at, False, "serialization", serializationType, None)
+                Parameter(at, False, "value", selfType, None)
+            ]
+            returnType = TConstructor(at, "ff:core/Unit.Unit", [])
+            effect = noEffect
+        )
+        let deserializeSignature = Signature(
+            at = at
+            name = "deserializeUsing"
+            member = False
+            generics = []
+            constraints = []
+            parameters = [
+                Parameter(at, False, "serialization", serializationType, None)
+            ]
+            returnType = selfType
+            effect = noEffect
+        )
+        let wildcardPattern = PVariable(at, None)
+        let serializeBody = FireflyTarget(
+            Lambda(at, noEffect, self.makeSerializeBody(modulePrefix, declaration, selfType))
+        )
+        let deserializeBody = FireflyTarget(
+            Lambda(at, noEffect, [MatchCase(
+                at = at
+                patterns = [wildcardPattern]
+                guards = []
+                body = self.makeDeserializeBody(modulePrefix, declaration, selfType)
+            )])
+        )
+        DInstance(
+            at = at
+            generics = declaration.generics
+            constraints = constraints
+            traitName = "ff:core/Serializable.Serializable"
+            typeArguments = [selfType]
+            generatorArguments = []
+            methods = [
+                DFunction(at, serializeSignature, serializeBody)
+                DFunction(at, deserializeSignature, deserializeBody)
+            ]
+            derived = True
+        )
+    }
+
+    makeSerializeBody(modulePrefix: String, declaration: DType, selfType: Type): List[MatchCase] {
+        let at = declaration.at.Location(file = declaration.at.file + "/<derived>")
+        let wildcardPattern = PVariable(at, None)
+        declaration.variants.pairs().map {| Pair(index, variant) =>
+            let variantName = modulePrefix + "." + variant.name
+            let fields = [...declaration.commonFields, ...variant.fields]
+            let updateChecksum = self.makeUpdateChecksum(at, variantName, declaration, variant)
+            let setVariantIndex = self.makeMethodCall(
+                at = at
+                target = EField(at, False, EVariable(at, "serialization"), "buffer")
+                methodName = "setUint8"
+                arguments = [EField(at, False, EVariable(at, "serialization"), "offset"), EInt(at, "" + index)]
+            )
+            let fieldSerializations = fields.map {field =>
+                self.makeSimpleCall(at, "ff:core/Serializable.serializeUsing", [
+                    EVariable(at, "serialization")
+                    EField(at, False, EVariable(at, "v"), field.name)
+                ])
+            }
+            MatchCase(
+                at = at,
+                patterns = [wildcardPattern, PVariantAs(at, variantName, at, Some("v"))]
+                guards = []
+                body = [
+                    setVariantIndex
+                    EAssignField(at, "+", EVariable(at, "serialization"), "offset", EInt(at, "1"))
+                    ...fieldSerializations
+                ].foldLeft(updateChecksum) {ESequential(at, _, _)}
+            )
+        }
+    }
+
+    makeDeserializeBody(modulePrefix: String, declaration: DType, selfType: Type): Term {
+        let at = declaration.at.Location(file = declaration.at.file + "/<derived>")
+        let noEffect = TConstructor(at, "ff:core/Nothing.Nothing", [])
+        let wildcardPattern = PVariable(at, None)
+        let grabVariantIndex = self.makeMethodCall(
+            at = at
+            target = EField(at, False, EVariable(at, "serialization"), "buffer")
+            methodName = "grabUint8"
+            arguments = [EField(at, False, EVariable(at, "serialization"), "offset")]
+        )
+        let intType = TConstructor(at, "ff:core/Int.Int", [])
+        let incrementOffset = EAssignField(at, "+", EVariable(at, "serialization"), "offset", EInt(at, "1"))
+        let cases = declaration.variants.pairs().map {| Pair(index, variant) =>
+            let variantName = modulePrefix + "." + variant.name
+            let fields = [...declaration.commonFields, ...variant.fields]
+            let fieldValues = fields.map {field =>
+                Argument(
+                    at
+                    None
+                    self.makeSimpleCall(at, "ff:core/Serializable.deserializeUsing", [EVariable(at, "serialization")])
+                )
+            }
+            let updateChecksum = self.makeUpdateChecksum(at, variantName, declaration, variant)
+            let makeVariant = EVariant(at, variantName, [], Some(fieldValues))
+            MatchCase(
+                at = at,
+                patterns = [PInt(at, "" + index)]
+                guards = []
+                body = ESequential(at, updateChecksum, makeVariant)
+            )
+        }
+        let otherwiseCase = MatchCase(
+            at = at,
+            patterns = [wildcardPattern]
+            guards = []
+            body = self.makeSimpleCall(at, "ff:core/Core.throw", [
+                EVariant(at, "ff:core/Serializable.DeserializationChecksumException", [], None)
+            ])
+        )
+        let matchLambda = ELambda(at, Lambda(at, noEffect, [...cases, otherwiseCase]))
+        let match = EPipe(at, EVariable(at, "variantIndex"), noEffect, matchLambda)
+        ELet(at, False, "variantIndex", intType, grabVariantIndex, ESequential(at, incrementOffset, match))
+    }
+
+    makeUpdateChecksum(at: Location, variantName: String, declaration: DType, variant: Variant): Term {
+        let fields = [...declaration.commonFields, ...variant.fields]
+        let variantChecksum = variantName.size() // TODO: Hash variantName + fields with type terms + type parameters (+ type arguments?)
+        EAssignField(at, "", EVariable(at, "serialization"), "checksum"
+            self.makeMethodCall(
+                at = at
+                target = self.makeSimpleCall(at, "+", [
+                    self.makeSimpleCall(at, "*", [
+                        EInt(at, "31")
+                        EField(at, False, EVariable(at, "serialization"), "checksum")
+                    ])
+                    EInt(at, "" + variantChecksum)
+                ])
+                methodName = "bitOr"
+                arguments = [EInt(at, "0")]
+            )
+        )
+    }
+
+    // Common
+
+    findTypesThatNeedInstances(
+        traitName: String
+        modulePrefix: String
+        coreWhitelist: Set[String]
+        allowGenerics: Bool
+        module: Module
+    ): List[DType] {
+        let typesWithInstance = module.instances.collect {
+            | instance {instance.typeArguments.first() | Some(TConstructor(_, name, _))} =>
+                if(instance.traitName == traitName) {name}
+            | _ => None
+        }.toSet()
+
+        module.types.filter {t =>
+            (module.packagePair.groupName() != "ff:core" || coreWhitelist.contains(modulePrefix + "." + t.name)) &&
+            !t.generics.first().any {_ == "Q$"} &&
+            (allowGenerics || t.generics.isEmpty()) &&
+            t.data && !t.newtype &&
+            !typesWithInstance.contains(modulePrefix + "." + t.name)
+        }
+    }
+
+    makeSimpleCall(at: Location, name: String, arguments: List[Term], typeArguments: List[Type] = []): Term {
+        let noEffect = TConstructor(at, "ff:core/Nothing.Nothing", [])
+        let callTarget = DynamicCall(EVariable(at, name), tailCall = False)
+        ECall(at, callTarget, noEffect, typeArguments, arguments.map { e =>
+            Argument(at, None, e)
+        }, [])
+    }
+
+    makeMethodCall(at: Location, target: Term, methodName: String, arguments: List[Term]): Term {
+        let noEffect = TConstructor(at, "ff:core/Nothing.Nothing", [])
+        let method = EField(at, False, target, methodName)
+        ECall(at, DynamicCall(method, False), noEffect, [], arguments.map {Argument(at, None, _)}, [])
+    }
+
+    makeIf(at: Location, condition: Term, then: Term, else: Term): Term {
+        let noEffect = TConstructor(at, "ff:core/Nothing.Nothing", [])
+        let target = DynamicCall(EVariable(at, "ff:core/Core.if"), tailCall = False)
+        let option = ECall(at, target, noEffect, [], [
+            Argument(at, None, condition)
+            Argument(at, None, ELambda(at, Lambda(at, noEffect, [MatchCase(at, [], [], then)])))
+        ], [])
+        ECall(at, DynamicCall(EField(at, False, option, "else"), tailCall = False), noEffect, [], [
+            Argument(at, None, ELambda(at, Lambda(at, noEffect, [MatchCase(at, [], [], else)])))
+        ], [])
+    }
+
+}