@tutao/licc 3.98.2

package/lib/KotlinGenerator.ts

@@ -0,0 +1,241 @@
+import {FacadeDefinition, getArgs, LangGenerator, MethodDefinition, minusculize, RenderedType, StructDefinition, TypeRefDefinition} from "./common.js"
+import {Accumulator} from "./Accumulator.js"
+import {ParsedType, parseType} from "./Parser.js"
+
+export class KotlinGenerator implements LangGenerator {
+
+	generateGlobalDispatcher(name: string, facadeNames: string[]): string {
+		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: StructDefinition): string {
+		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()
+	}
+
+	private static generateImports(acc: Accumulator) {
+		acc.line("package de.tutao.tutanota.ipc")
+		acc.line()
+		acc.line("import kotlinx.serialization.*")
+		acc.line("import kotlinx.serialization.json.*")
+		acc.line()
+	}
+
+	private generateDocComment(acc: Accumulator, comment: string | null | undefined) {
+		if (!comment) return
+		acc.line("/**")
+		acc.line(` * ${comment}`)
+		acc.line(" */")
+	}
+
+	generateFacade(definition: FacadeDefinition): string {
+		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: FacadeDefinition): string {
+		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] as const)
+			}
+			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()
+	}
+
+	private static generateNativeInterface(): string {
+		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()
+	}
+
+	private static generateMethodSignature(methodGenerator: Accumulator, name: string, methodDefinition: MethodDefinition, prefix: string = "") {
+		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: FacadeDefinition): string {
+		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(): Record<string, string> {
+		return {
+			"NativeInterface": KotlinGenerator.generateNativeInterface()
+		}
+	}
+
+	generateTypeRef(outDir: string, definitionPath: string, definition: TypeRefDefinition): string | null {
+		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: string): RenderedType {
+	const parsed = parseType(name)
+	return renderKotlinType(parsed)
+}
+
+function renderKotlinType(parsed: ParsedType): RenderedType {
+	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: string, nullable: boolean) {
+	return nullable ? `${name}?` : name
+}

package/lib/Parser.ts

@@ -0,0 +1,68 @@
+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: string): ParsedType {
+	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
+
+
+// {basename: List, generics: [{basename: string, generics: []}]>
+export interface ParsedType {
+	// this needs an import
+	external: boolean
+	// this argument or return can be null
+	nullable: boolean
+	// name as given in the json file, without generics
+	baseName: string
+	// contained generic types, if any
+	generics: ParsedType[]
+}

package/lib/SwiftGenerator.ts

@@ -0,0 +1,248 @@
+import {FacadeDefinition, getArgs, LangGenerator, MethodDefinition, minusculize, RenderedType, StructDefinition, TypeRefDefinition} from "./common.js"
+import {Accumulator} from "./Accumulator.js"
+import {ParsedType, parseType} from "./Parser.js"
+
+export class SwiftGenerator implements LangGenerator {
+
+	handleStructDefinition(definition: StructDefinition): string {
+		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()
+	}
+
+	private generateDocComment(acc: Accumulator, comment: string | null | undefined) {
+		if (!comment) return
+		acc.line("/**")
+		acc.line(` * ${comment}`)
+		acc.line(" */")
+	}
+
+	generateFacade(definition: FacadeDefinition): string {
+		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()
+	}
+
+	private static generateMethodSignature(methodGenerator: Accumulator, name: string, methodDefinition: 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: FacadeDefinition): string {
+		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] as const)
+			}
+			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: string, facadeNames: Array<string>): string {
+		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: FacadeDefinition): string {
+		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(): Record<string, string> {
+		return {
+			"NativeInterface": SwiftGenerator.generateNativeInterface()
+		}
+	}
+
+	private static generateNativeInterface(): string {
+		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: string, definitionPath: string, definition: TypeRefDefinition): string | null {
+		return null
+	}
+}
+
+function typeNameSwift(name: string): RenderedType {
+	const parsed = parseType(name)
+	return renderSwiftType(parsed)
+}
+
+function renderSwiftType(parsed: ParsedType): RenderedType {
+	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: string, nullable: boolean) {
+	return nullable ? `${name}?` : name
+}