@tutao/licc 3.98.2

package/README.md

@@ -0,0 +1,137 @@
+# licc - the little interprocess communications compiler
+
+usage info: type `licc --help`
+
+## output
+
+there are three kinds of json files `licc` understands. they are distinguished by their top-level `type` property.
+
+### structs
+
+`"type": "struct"` definitions are simply generated into the output directory as a single source file of the
+platform-appropriate language.
+
+### facades
+
+`"type": "facade"` definitions can lead to several output files, depending on the definitions `senders` and `receivers`
+fields:
+
+* **senders and receivers**: the interface containing all methods
+* **senders**: one implementation of the interface in form of the `SendDispatcher`.
+  It takes a transport instance that does the actual sending of the message and must be implemented manually.
+* **receivers**: one `ReceiveDispatcher`. It takes the actual, working implementation of the interface during
+  construction
+  and dispatches to it.
+* **additionally**, every platform that is on the receiving side of any facades gets one `GlobalDispatcher`
+  implementation
+  that dispatches to all receive dispatchers.
+
+this leads to the following flow, with manually implemented components marked with `*`:
+
+```
+SENDING SIDE: *caller* => SendDispatcher => *outgoing transport*
+RECEIVING SIDE: *incoming transport* => GlobalDispatcher => ReceiveDispatcher => *facade implementation*
+```
+
+Dispatch is achieved via string identifiers; the incoming transport will
+call `GlobalDispatcher.dispatch("FacadeName", "methodName", arrayOfArgs)` which calls the ReceiveDispatcher
+for `FacadeName` with `ReceiveDispatcher.dispatch("methodName", arrayOfArgs)`.
+This call will be dispatched to the appropriate method as `facadeName.methodName(arrayOfArgs[0], ..., arrayOfArgs[-1])`.
+
+### typerefs
+
+`"type": "typeref"` definitions are used to refer to types that are not defined in a definition file and are not
+primitives (that
+the generator therefore has no knowledge of). They have to contain a language-specific path to a definition of the
+type that the generator will generate a reexport for, which can then be referred to by the facades (which don't actually
+know the difference between a generated struct and such a reexport).
+
+## definition syntax
+
+the schema format is described in `lib/common.ts`.
+each schema is a JSON file with a single data type or facade definition.
+as discussed above, the type (`struct`, `facade` or `typeref`) is given by the `type` property of the contained json
+object.
+facades must have a `senders` and a `receivers` property listing the appropriate platforms.
+
+**Note:** there is minimal validation. we don't detect duplicate method or argument definitions and do not do a very
+good job to validate type syntax.
+
+### structs
+
+struct fields are given as an object with `"fieldName": "fieldType"` properties.
+
+```json
+{
+	"name": "Foo",
+	"type": "struct",
+	"doc": "optional doc comment that explains the type's purpose",
+	"fields": {
+		"fieldName": "fieldType",
+		...
+	}
+}
+```
+
+### facades
+
+```json
+{
+	"name": "BarFacade",
+	"type": "facade",
+	"senders": ["web"],
+	"receivers": ["desktop", "ios"],
+	"doc": "optional doc comment explaining the scope of the facade",
+	"methods": {
+		"methodName": {
+			"doc": "optional comment explaining the contract and purpose of the method",
+			"arg": [
+				{"argName1": "argType1"},
+				{"argName2": "argType2"},
+				...
+			],
+			"ret": "returnType"
+		},
+		...
+	}
+}
+```
+
+Note: method arg must be given as a list of single-property objects as above to preserve argument order.
+
+### typerefs
+
+```json
+{
+	"name": "BazType",
+	"type": "typeref",
+	"location": {
+		"typescript": "../../src/somedir/BazType.js",
+		"kotlin": "de.tutao.tutanota.BazType"
+	}
+}
+```
+
+Note the `.js` extension on the typescript reference. Reference paths are resolved relative to the `json` file
+containing the typeref.
+
+### supported types:
+
+* nullable types, denoted with a `?` suffix: `string?`
+* `List<elementType>`
+* `Map<keyType, valueType>`
+* the primitives listed in `dist/parser.ts`
+* "external" types (the ones that don't fit any of the above but are otherwise valid identifiers)
+* any combination of these
+
+all type names must be valid identifiers in all supported output languages.
+
+## Known issues
+
+* the `bytes` primitive types is generating `DataWrapper` types for mobile, because we can't directly send byte arrays
+  over the bridge and need some kind of marker that distinguishes plain strings from encoded byte arrays. Currently,
+  this requirement to wrap byte arrays leaks out to consumers of the generated classes.
+* struct definitions are generated for every language regardless if they're mentioned in that languages' generated
+  files.
+* it's theoretically possible two separate compilations of the same source files to yield different output because field
+  order in json objects is not defined. this was not observed yet and is unlikely to become a problem.

package/dist/Accumulator.js

@@ -0,0 +1,23 @@
+const HEADER = "/* generated file, don't edit. */\n";
+export class Accumulator {
+    appender;
+    code = "";
+    imports = new Set();
+    constructor(appender = (code) => this.code += code) {
+        this.appender = appender;
+    }
+    line(code = "") {
+        this.appender(code + "\n");
+    }
+    indent(indent = "\t") {
+        return new Accumulator((code) => {
+            this.appender(indent + code);
+        });
+    }
+    addImport(imp) {
+        this.imports.add(imp);
+    }
+    finish() {
+        return HEADER + "\n" + Array.from(this.imports).join("\n") + "\n" + this.code;
+    }
+}

package/dist/KotlinGenerator.js

@@ -0,0 +1,224 @@
+import { getArgs, minusculize } from "./common.js";
+import { Accumulator } from "./Accumulator.js";
+import { parseType } from "./Parser.js";
+export class KotlinGenerator {
+    generateGlobalDispatcher(name, facadeNames) {
+        const acc = new Accumulator();
+        KotlinGenerator.generateImports(acc);
+        acc.line(`import de.tutao.tutanota.ipc.*`);
+        acc.line();
+        acc.line(`class ${name} (`);
+        const methodAcc = acc.indent();
+        methodAcc.line(`json: Json,`);
+        for (let facadeName of facadeNames) {
+            methodAcc.line(`${minusculize(facadeName)} : ${facadeName},`);
+        }
+        acc.line(") {");
+        for (let facadeName of facadeNames) {
+            methodAcc.line(`private val ${minusculize(facadeName)}: ${facadeName}ReceiveDispatcher = ${facadeName}ReceiveDispatcher(json, ${minusculize(facadeName)})`);
+        }
+        methodAcc.line();
+        methodAcc.line(`suspend fun dispatch(facadeName: String, methodName: String, args: List<String>): String {`);
+        const whenAcc = methodAcc.indent();
+        whenAcc.line(`return when (facadeName) {`);
+        const caseAcc = whenAcc.indent();
+        for (let facadeName of facadeNames) {
+            caseAcc.line(`"${facadeName}" -> this.${minusculize(facadeName)}.dispatch(methodName, args)`);
+        }
+        caseAcc.line(`else -> throw Error("unknown facade: $facadeName")`);
+        whenAcc.line(`}`);
+        methodAcc.line(`}`);
+        acc.line(`}`);
+        return acc.finish();
+    }
+    handleStructDefinition(definition) {
+        const acc = new Accumulator();
+        KotlinGenerator.generateImports(acc);
+        acc.line();
+        if (definition.doc) {
+            this.generateDocComment(acc, definition.doc);
+        }
+        acc.line("@Serializable");
+        acc.line(`data class ${definition.name}(`);
+        const fieldGenerator = acc.indent();
+        for (const [name, fieldDefinition] of Object.entries(definition.fields)) {
+            const renderedType = typeNameKotlin(fieldDefinition);
+            fieldGenerator.line(`val ${name}: ${renderedType.name},`);
+        }
+        acc.line(")");
+        return acc.finish();
+    }
+    static generateImports(acc) {
+        acc.line("package de.tutao.tutanota.ipc");
+        acc.line();
+        acc.line("import kotlinx.serialization.*");
+        acc.line("import kotlinx.serialization.json.*");
+        acc.line();
+    }
+    generateDocComment(acc, comment) {
+        if (!comment)
+            return;
+        acc.line("/**");
+        acc.line(` * ${comment}`);
+        acc.line(" */");
+    }
+    generateFacade(definition) {
+        const acc = new Accumulator();
+        KotlinGenerator.generateImports(acc);
+        this.generateDocComment(acc, definition.doc);
+        acc.line(`interface ${definition.name} {`);
+        const methodAcc = acc.indent();
+        for (const [name, methodDefinition] of Object.entries(definition.methods)) {
+            this.generateDocComment(methodAcc, methodDefinition.doc);
+            KotlinGenerator.generateMethodSignature(methodAcc, name, methodDefinition);
+        }
+        acc.line("}");
+        return acc.finish();
+    }
+    generateReceiveDispatcher(definition) {
+        const acc = new Accumulator();
+        // Some names might clash, we don't read this file, we don't care
+        acc.line(`@file:Suppress("NAME_SHADOWING")`);
+        KotlinGenerator.generateImports(acc);
+        acc.line(`class ${definition.name}ReceiveDispatcher(`);
+        acc.indent().line(`private val json: Json,`);
+        acc.indent().line(`private val facade: ${definition.name},`);
+        acc.line(`) {`);
+        const methAcc = acc.indent();
+        methAcc.line();
+        methAcc.line(`suspend fun dispatch(method: String, arg: List<String>): String {`);
+        const whenAcc = methAcc.indent();
+        whenAcc.line(`when (method) {`);
+        const caseAcc = whenAcc.indent();
+        for (const [methodName, methodDef] of Object.entries(definition.methods)) {
+            caseAcc.line(`"${methodName}" -> {`);
+            const arg = getArgs(methodName, methodDef);
+            const decodedArgs = [];
+            for (let i = 0; i < arg.length; i++) {
+                const { name: argName, type } = arg[i];
+                const renderedArgType = typeNameKotlin(type);
+                decodedArgs.push([argName, renderedArgType]);
+            }
+            const varAcc = caseAcc.indent();
+            for (let i = 0; i < arg.length; i++) {
+                const [argName, renderedType] = decodedArgs[i];
+                varAcc.line(`val ${argName}: ${renderedType.name} = json.decodeFromString(arg[${i}])`);
+            }
+            varAcc.line(`val result: ${typeNameKotlin(methodDef.ret).name} = this.facade.${methodName}(`);
+            for (let i = 0; i < arg.length; i++) {
+                const [argName] = decodedArgs[i];
+                varAcc.indent().line(`${argName},`);
+            }
+            varAcc.line(`)`);
+            varAcc.line(`return json.encodeToString(result)`);
+            caseAcc.line(`}`);
+        }
+        caseAcc.line(`else -> throw Error("unknown method for ${definition.name}: $method")`);
+        whenAcc.line(`}`);
+        methAcc.line(`}`);
+        acc.line(`}`);
+        return acc.finish();
+    }
+    static generateNativeInterface() {
+        const acc = new Accumulator();
+        KotlinGenerator.generateImports(acc);
+        acc.line(`interface NativeInterface {`);
+        acc.indent().line(`suspend fun sendRequest(requestType: String, args: List<String>): String`);
+        acc.line(`}`);
+        return acc.finish();
+    }
+    static generateMethodSignature(methodGenerator, name, methodDefinition, prefix = "") {
+        methodGenerator.line(`${prefix} suspend fun ${name}(`);
+        const argGenerator = methodGenerator.indent();
+        for (const argument of getArgs(name, methodDefinition)) {
+            const renderedArgument = typeNameKotlin(argument.type);
+            argGenerator.line(`${argument.name}: ${renderedArgument.name},`);
+        }
+        const renderedReturn = typeNameKotlin(methodDefinition.ret);
+        methodGenerator.line(`): ${renderedReturn.name}`);
+    }
+    generateSendDispatcher(definition) {
+        const acc = new Accumulator();
+        KotlinGenerator.generateImports(acc);
+        const classBodyAcc = acc.indent();
+        acc.line(`class ${definition.name}SendDispatcher (`);
+        classBodyAcc.line(`private val json: Json,`);
+        classBodyAcc.line(`private val transport : NativeInterface,`);
+        acc.line(`) : ${definition.name} {`);
+        classBodyAcc.line(`private val encodedFacade = json.encodeToString("${definition.name}")`);
+        for (const [methodName, methodDefinition] of Object.entries(definition.methods)) {
+            KotlinGenerator.generateMethodSignature(classBodyAcc, methodName, methodDefinition, "override");
+            classBodyAcc.line("{");
+            const methodBodyAcc = classBodyAcc.indent();
+            methodBodyAcc.line(`val encodedMethod = json.encodeToString("${methodName}")`);
+            methodBodyAcc.line("val args : MutableList<String> = mutableListOf()");
+            for (let arg of getArgs(methodName, methodDefinition)) {
+                methodBodyAcc.line(`args.add(json.encodeToString(${arg.name}))`);
+            }
+            if (methodDefinition.ret !== "void") {
+                methodBodyAcc.line(`val result = this.transport.sendRequest("ipc", listOf(encodedFacade, encodedMethod) + args)`);
+                methodBodyAcc.line(`return json.decodeFromString(result)`);
+            }
+            else {
+                methodBodyAcc.line(`this.transport.sendRequest("ipc", listOf(encodedFacade, encodedMethod) + args)`);
+            }
+            classBodyAcc.line(`}`);
+            classBodyAcc.line();
+        }
+        acc.line(`}`);
+        return acc.finish();
+    }
+    generateExtraFiles() {
+        return {
+            "NativeInterface": KotlinGenerator.generateNativeInterface()
+        };
+    }
+    generateTypeRef(outDir, definitionPath, definition) {
+        if (definition.location.kotlin) {
+            const acc = new Accumulator();
+            acc.line(`package de.tutao.tutanota.ipc`);
+            acc.line(`typealias ${definition.name} = ${definition.location.kotlin}`);
+            return acc.finish();
+        }
+        else {
+            return null;
+        }
+    }
+}
+function typeNameKotlin(name) {
+    const parsed = parseType(name);
+    return renderKotlinType(parsed);
+}
+function renderKotlinType(parsed) {
+    const { baseName, nullable, external } = parsed;
+    switch (baseName) {
+        case "List":
+            const renderedListInner = renderKotlinType(parsed.generics[0]);
+            return {
+                externals: renderedListInner.externals,
+                name: maybeNullable(`List<${renderedListInner.name}>`, nullable)
+            };
+        case "Map":
+            const renderedKey = renderKotlinType(parsed.generics[0]);
+            const renderedValue = renderKotlinType(parsed.generics[1]);
+            return {
+                externals: [...renderedKey.externals, ...renderedValue.externals],
+                name: maybeNullable(`Map<${renderedKey.name}, ${renderedValue.name}>`, nullable)
+            };
+        case "string":
+            return { externals: [], name: maybeNullable("String", nullable) };
+        case "boolean":
+            return { externals: [], name: maybeNullable("Boolean", nullable) };
+        case "number":
+            return { externals: [], name: maybeNullable("Int", nullable) };
+        case "bytes":
+            return { externals: [], name: maybeNullable("DataWrapper", nullable) };
+        case "void":
+            return { externals: [], name: maybeNullable("Unit", nullable) };
+        default:
+            return { externals: [baseName], name: maybeNullable(baseName, nullable) };
+    }
+}
+function maybeNullable(name, nullable) {
+    return nullable ? `${name}?` : name;
+}

package/dist/Parser.js

@@ -0,0 +1,49 @@
+export const PRIMITIVES = ["string", "boolean", "number", "bytes", "void"];
+const KOTLIN_KEYWORDS = [
+    "as", "break", "class", "continue", "do", "else", "false", "for", "fun", "if", "in", "interface", "is", "null", "object", "package", "return", "super",
+    "this", "throw", "true", "try", "typealias", "typeof", "val", "var", "when", "while"
+];
+const TYPESCRIPT_KEYWORDS = [
+    "var", "const", "let", "break", "return", "case", "catch", "class", "continue", "debugger", "default", "delete", "do", "else", "enum", "export", "extends",
+    "false", "finally", "for", "function", "if", "import", "in", "instanceOf", "new", "null", "return", "super", "switch", "this", "throw", "true", "try",
+    "typeOf", "void", "while", "with"
+];
+const SWIFT_KEYWORDS = [
+    "Class", "deinit", "Enum", "extension", "Func", "import", "Init", "internal", "Let", "operator", "private", "protocol", "public", "static", "struct", "subscript",
+    "typealias", "var", "break", "case", "continue", "default", "do", "else", "fallthrough", "for", "if", "in", "return", "switch", "where", "while",
+    "as", "dynamicType", "false", "is", "nil", "self", "Self", "super", "true", "_COLUMN_", "_FILE_", "_FUNCTION_", "_LINE_",
+    "associativity", "convenience", "dynamic", "didSet", "final", "get", "infix", "inout", "lazy", "left", "mutating", "none", "nonmutating",
+    "optional", "override", "postfix", "precedence", "prefix", "Protocol", "required", "right", "set", "Type", "unowned", "weak", "willSet"
+];
+const FORBIDDEN_IDENTIFIERS = new Set([...KOTLIN_KEYWORDS, ...TYPESCRIPT_KEYWORDS, ...SWIFT_KEYWORDS]);
+/**
+ * parse a type definition string from the json into a structure that contains all information needed to render
+ * language-specific type defs
+ */
+export function parseType(typeString) {
+    let nullable = false;
+    typeString = typeString.trim();
+    if (typeString.endsWith("?")) {
+        nullable = true;
+        typeString = typeString.slice(0, -1);
+    }
+    const listMatch = typeString.match(/^\s*List<\s*(.*)\s*>\s*$/);
+    if (listMatch) {
+        const nested = parseType(listMatch[1]);
+        return { baseName: "List", generics: [nested], nullable, external: false };
+    }
+    const mapMatch = typeString.match(/^\s*Map<\s*(.*?),\s*(.*?)\s*>\s*$/);
+    if (mapMatch) {
+        const nestedKey = parseType(mapMatch[1]);
+        const nestedValue = parseType(mapMatch[2]);
+        return { baseName: "Map", generics: [nestedKey, nestedValue], nullable, external: false };
+    }
+    // this is a basic type without generic params
+    const external = !PRIMITIVES.includes(typeString);
+    const willBreakAtLeastOneLang = FORBIDDEN_IDENTIFIERS.has(typeString) && external;
+    const startsWithLetterOrUnderscore = typeString.match(/^[_a-zA-Z]/);
+    if (willBreakAtLeastOneLang || !startsWithLetterOrUnderscore) {
+        throw new Error(`illegal identifier: "${typeString}"`);
+    }
+    return { baseName: typeString, generics: [], external, nullable };
+} // frontend type

package/dist/SwiftGenerator.js

@@ -0,0 +1,232 @@
+import { getArgs, minusculize } from "./common.js";
+import { Accumulator } from "./Accumulator.js";
+import { parseType } from "./Parser.js";
+export class SwiftGenerator {
+    handleStructDefinition(definition) {
+        const acc = new Accumulator();
+        this.generateDocComment(acc, definition.doc);
+        acc.line(`public struct ${definition.name} : Codable {`);
+        const fieldGenerator = acc.indent();
+        for (const [name, fieldDefinition] of Object.entries(definition.fields)) {
+            const renderedType = typeNameSwift(fieldDefinition);
+            fieldGenerator.line(`let ${name}: ${renderedType.name}`);
+        }
+        acc.line("}");
+        return acc.finish();
+    }
+    generateDocComment(acc, comment) {
+        if (!comment)
+            return;
+        acc.line("/**");
+        acc.line(` * ${comment}`);
+        acc.line(" */");
+    }
+    generateFacade(definition) {
+        const acc = new Accumulator();
+        acc.line("import Foundation");
+        acc.line();
+        this.generateDocComment(acc, definition.doc);
+        acc.line(`public protocol ${definition.name} {`);
+        const methodAcc = acc.indent();
+        for (const [name, methodDefinition] of Object.entries(definition.methods)) {
+            this.generateDocComment(methodAcc, methodDefinition.doc);
+            SwiftGenerator.generateMethodSignature(methodAcc, name, methodDefinition);
+        }
+        acc.line("}");
+        return acc.finish();
+    }
+    static generateMethodSignature(methodGenerator, name, methodDefinition) {
+        methodGenerator.line(`func ${name}(`);
+        const argGenerator = methodGenerator.indent();
+        const args = getArgs(name, methodDefinition);
+        const lastArg = args[args.length - 1];
+        for (const argument of args) {
+            const renderedArgument = typeNameSwift(argument.type);
+            const argLine = `_ ${argument.name}: ${renderedArgument.name}` +
+                ((argument === lastArg) ? "" : ",");
+            argGenerator.line(argLine);
+        }
+        const renderedReturn = typeNameSwift(methodDefinition.ret);
+        methodGenerator.line(`) async throws -> ${renderedReturn.name}`);
+    }
+    generateReceiveDispatcher(definition) {
+        const acc = new Accumulator();
+        acc.line("import Foundation");
+        acc.line();
+        acc.line(`public class ${definition.name}ReceiveDispatcher {`);
+        const methodAcc = acc.indent();
+        methodAcc.line(`let facade: ${definition.name}`);
+        methodAcc.line(`init(facade: ${definition.name}) {`);
+        methodAcc.indent().line(`self.facade = facade`);
+        methodAcc.line(`}`);
+        methodAcc.line(`func dispatch(method: String, arg: [String]) async throws -> String {`);
+        const switchAcc = methodAcc.indent();
+        switchAcc.line(`switch method {`);
+        const caseAcc = switchAcc.indent();
+        for (const [methodName, method] of Object.entries(definition.methods)) {
+            const arg = getArgs(methodName, method);
+            const decodedArgs = [];
+            for (let i = 0; i < arg.length; i++) {
+                const { name: argName, type } = arg[i];
+                const renderedArgType = typeNameSwift(type);
+                decodedArgs.push([argName, renderedArgType]);
+            }
+            switchAcc.line(`case "${methodName}":`);
+            for (let i = 0; i < arg.length; i++) {
+                const [argName, argType] = decodedArgs[i];
+                caseAcc.line(`let ${argName} = try! JSONDecoder().decode(${argType.name}.self, from: arg[${i}].data(using: .utf8)!)`);
+            }
+            if (method.ret === "void") {
+                caseAcc.line(`try await self.facade.${methodName}(`);
+            }
+            else {
+                caseAcc.line(`let result = try await self.facade.${methodName}(`);
+            }
+            for (let i = 0; i < arg.length; i++) {
+                const comma = i === arg.length - 1 ? "" : ",";
+                caseAcc.indent().line(arg[i].name + comma);
+            }
+            caseAcc.line(")");
+            if (method.ret === "void") {
+                caseAcc.line(`return "null"`);
+            }
+            else {
+                caseAcc.line(`return toJson(result)`);
+            }
+        }
+        switchAcc.line(`default:`);
+        caseAcc.line(`fatalError("licc messed up! \\(method)")`);
+        switchAcc.line(`}`);
+        methodAcc.line(`}`);
+        acc.line(`}`);
+        return acc.finish();
+    }
+    generateGlobalDispatcher(name, facadeNames) {
+        const acc = new Accumulator();
+        acc.line(`public class ${name} {`);
+        const methodAcc = acc.indent();
+        for (let facadeName of facadeNames) {
+            methodAcc.line(`private let ${minusculize(facadeName)}: ${facadeName}ReceiveDispatcher`);
+        }
+        methodAcc.line();
+        methodAcc.line(`init(`);
+        const lastFacadeName = facadeNames[facadeNames.length - 1];
+        for (let facadeName of facadeNames) {
+            const comma = facadeName === lastFacadeName ? "" : ",";
+            methodAcc.indent().line(`${minusculize(facadeName)} : ${facadeName}${comma}`);
+        }
+        methodAcc.line(`) {`);
+        for (let facadeName of facadeNames) {
+            methodAcc.indent().line(`self.${minusculize(facadeName)} = ${facadeName}ReceiveDispatcher(facade: ${minusculize(facadeName)})`);
+        }
+        methodAcc.line(`}`);
+        methodAcc.line();
+        methodAcc.line(`func dispatch(facadeName: String, methodName: String, args: Array<String>) async throws -> String {`);
+        const switchAcc = methodAcc.indent();
+        switchAcc.line(`switch facadeName {`);
+        const caseAcc = switchAcc.indent();
+        for (let facadeName of facadeNames) {
+            caseAcc.line(`case "${facadeName}":`);
+            caseAcc.indent().line(`return try await self.${minusculize(facadeName)}.dispatch(method: methodName, arg: args)`);
+        }
+        caseAcc.line(`default:`);
+        caseAcc.indent().line(`fatalError("licc messed up! " + facadeName)`);
+        switchAcc.line(`}`);
+        methodAcc.line(`}`);
+        acc.line(`}`);
+        return acc.finish();
+    }
+    generateSendDispatcher(definition) {
+        const acc = new Accumulator();
+        acc.line("import Foundation");
+        acc.line();
+        acc.line(`class ${definition.name}SendDispatcher : ${definition.name} {`);
+        const classBodyAcc = acc.indent();
+        classBodyAcc.line(`private let transport: NativeInterface`);
+        classBodyAcc.line(`init(transport: NativeInterface) { self.transport = transport }`);
+        classBodyAcc.line();
+        for (const [methodName, methodDefinition] of Object.entries(definition.methods)) {
+            SwiftGenerator.generateMethodSignature(classBodyAcc, methodName, methodDefinition);
+            const methodBodyAcc = classBodyAcc.indent();
+            methodBodyAcc.line("{");
+            const args = getArgs(methodName, methodDefinition);
+            if (args.length > 0) {
+                methodBodyAcc.line("var args = [String]()");
+            }
+            else {
+                // let instead of var so that it shuts up about mutability unused
+                methodBodyAcc.line("let args = [String]()");
+            }
+            for (let arg of args) {
+                methodBodyAcc.line(`args.append(toJson(${arg.name}))`);
+            }
+            methodBodyAcc.line(`let encodedFacadeName = toJson("${definition.name}")`);
+            methodBodyAcc.line(`let encodedMethodName = toJson("${methodName}")`);
+            if (methodDefinition.ret !== "void") {
+                methodBodyAcc.line(`let returnValue = try await self.transport.sendRequest(requestType: "ipc",  args: [encodedFacadeName, encodedMethodName] + args)`);
+                methodBodyAcc.line(`return try! JSONDecoder().decode(${typeNameSwift(methodDefinition.ret).name}.self, from: returnValue.data(using: .utf8)!)`);
+            }
+            else {
+                methodBodyAcc.line(`let _ = try await self.transport.sendRequest(requestType: "ipc",  args: [encodedFacadeName, encodedMethodName] + args)`);
+            }
+            methodBodyAcc.line(`}`);
+            classBodyAcc.line();
+        }
+        acc.line(`}`);
+        return acc.finish();
+    }
+    generateExtraFiles() {
+        return {
+            "NativeInterface": SwiftGenerator.generateNativeInterface()
+        };
+    }
+    static generateNativeInterface() {
+        const acc = new Accumulator();
+        acc.line(`protocol NativeInterface {`);
+        acc.indent().line(`func sendRequest(requestType: String, args: [String]) async throws -> String`);
+        acc.line(`}`);
+        acc.line();
+        acc.line("func toJson<T>(_ thing: T) -> String where T : Encodable {");
+        acc.indent().line("return String(data: try! JSONEncoder().encode(thing), encoding: .utf8)!");
+        acc.line("}");
+        acc.line();
+        return acc.finish();
+    }
+    generateTypeRef(outDir, definitionPath, definition) {
+        return null;
+    }
+}
+function typeNameSwift(name) {
+    const parsed = parseType(name);
+    return renderSwiftType(parsed);
+}
+function renderSwiftType(parsed) {
+    const { baseName, nullable } = parsed;
+    switch (baseName) {
+        case "List":
+            const renderedListInner = renderSwiftType(parsed.generics[0]);
+            return { externals: renderedListInner.externals, name: maybeNullable(`[${renderedListInner.name}]`, nullable) };
+        case "Map":
+            const renderedKey = renderSwiftType(parsed.generics[0]);
+            const renderedValue = renderSwiftType(parsed.generics[1]);
+            return {
+                externals: [...renderedKey.externals, ...renderedValue.externals],
+                name: maybeNullable(`[${renderedKey.name} : ${renderedValue.name}]`, nullable)
+            };
+        case "string":
+            return { externals: [], name: maybeNullable("String", nullable) };
+        case "boolean":
+            return { externals: [], name: maybeNullable("Bool", nullable) };
+        case "number":
+            return { externals: [], name: maybeNullable("Int", nullable) };
+        case "bytes":
+            return { externals: [], name: maybeNullable("DataWrapper", nullable) };
+        case "void":
+            return { externals: [], name: maybeNullable("Void", nullable) };
+        default:
+            return { externals: [baseName], name: maybeNullable(baseName, nullable) };
+    }
+}
+function maybeNullable(name, nullable) {
+    return nullable ? `${name}?` : name;
+}