@idlizer/core 2.0.15

package/build/lib/src/LanguageWriters/LanguageWriter.js

@@ -0,0 +1,746 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import * as idl from "../idl";
+import * as fs from "fs";
+import { RuntimeType } from "./common";
+export class TernaryExpression {
+    constructor(condition, trueExpression, falseExpression) {
+        this.condition = condition;
+        this.trueExpression = trueExpression;
+        this.falseExpression = falseExpression;
+    }
+    asString() {
+        return `(${this.condition.asString()}) ? (${this.trueExpression.asString()}) : (${this.falseExpression.asString()})`;
+    }
+}
+export class NaryOpExpression {
+    constructor(op, args) {
+        this.op = op;
+        this.args = args;
+    }
+    asString() {
+        return `${this.args.map(arg => `(${arg.asString()})`).join(` ${this.op} `)}`;
+    }
+}
+export class StringExpression {
+    constructor(value) {
+        this.value = value;
+    }
+    asString() {
+        return this.value;
+    }
+}
+export class NewObjectExpression {
+    constructor(objectName, params) {
+        this.objectName = objectName;
+        this.params = params;
+    }
+    asString() {
+        return `new ${this.objectName}(${this.params.map(it => it.asString()).join(", ")})`;
+    }
+}
+export class FunctionCallExpression {
+    constructor(name, params) {
+        this.name = name;
+        this.params = params;
+    }
+    asString() {
+        return `${this.name}(${this.params.map(it => it.asString()).join(", ")})`;
+    }
+}
+export class MethodCallExpression extends FunctionCallExpression {
+    constructor(receiver, method, params, nullable = false) {
+        super(method, params);
+        this.receiver = receiver;
+        this.nullable = nullable;
+    }
+    asString() {
+        return `${this.receiver}${this.nullable ? "?" : ""}.${super.asString()}`;
+    }
+}
+export class FieldAccessExpression {
+    constructor(receiver, field, nullable = false) {
+        this.receiver = receiver;
+        this.field = field;
+        this.nullable = nullable;
+    }
+    asString() {
+        return `${this.receiver}${this.nullable ? "?" : ""}.${this.field}`;
+    }
+}
+export class CheckDefinedExpression {
+    constructor(value) {
+        this.value = value;
+    }
+    asString() {
+        return `${this.value} != undefined`;
+    }
+}
+export class ProxyStatement {
+    constructor(cb) {
+        this.cb = cb;
+    }
+    write(writer) {
+        this.cb(writer);
+    }
+}
+export class AssignStatement {
+    constructor(variableName, type, expression, isDeclared = true, isConst = true, options) {
+        this.variableName = variableName;
+        this.type = type;
+        this.expression = expression;
+        this.isDeclared = isDeclared;
+        this.isConst = isConst;
+        this.options = options;
+    }
+    write(writer) {
+        var _a, _b;
+        if (this.isDeclared) {
+            const typeSpec = ((_a = this.options) === null || _a === void 0 ? void 0 : _a.overrideTypeName)
+                ? `: ${this.options.overrideTypeName}`
+                : this.type
+                    ? `: ${writer.getNodeName(this.type)}${ /*SHOULD BE REMOVED*/idl.isOptionalType(this.type) ? "|undefined" : ""}`
+                    : "";
+            const initValue = this.expression ? `= ${this.expression.asString()}` : "";
+            const constSpec = this.isConst ? "const" : "let";
+            writer.print(`${constSpec} ${this.variableName}${typeSpec} ${initValue}`);
+        }
+        else {
+            writer.print(`${this.variableName} = ${(_b = this.expression) === null || _b === void 0 ? void 0 : _b.asString()}`);
+        }
+    }
+}
+export class ExpressionStatement {
+    constructor(expression) {
+        this.expression = expression;
+    }
+    write(writer) {
+        const text = this.expression.asString();
+        if (text.length > 0) {
+            writer.print(`${this.expression.asString()}${writer.maybeSemicolon()}`);
+        }
+    }
+}
+export class BlockStatement {
+    constructor(statements, inScope = true) {
+        this.statements = statements;
+        this.inScope = inScope;
+    }
+    write(writer) {
+        if (this.inScope) {
+            writer.print("{");
+            writer.pushIndent();
+        }
+        this.statements.forEach(s => s.write(writer));
+        if (this.inScope) {
+            writer.popIndent();
+            writer.print("}");
+        }
+    }
+}
+export class IfStatement {
+    constructor(condition, thenStatement, elseStatement, insideIfOp, insideElseOp) {
+        this.condition = condition;
+        this.thenStatement = thenStatement;
+        this.elseStatement = elseStatement;
+        this.insideIfOp = insideIfOp;
+        this.insideElseOp = insideElseOp;
+    }
+    write(writer) {
+        writer.print(`if (${this.condition.asString()})`);
+        this.writeBody(writer, this.thenStatement, () => {
+            if (this.insideIfOp) {
+                this.insideIfOp();
+            }
+        });
+        if (this.elseStatement !== undefined) {
+            writer.print("else");
+            this.writeBody(writer, this.elseStatement, () => {
+                if (this.insideElseOp) {
+                    this.insideElseOp();
+                }
+            });
+        }
+    }
+    writeBody(writer, body, op) {
+        if (!(body instanceof BlockStatement)) {
+            writer.pushIndent();
+        }
+        body.write(writer);
+        op();
+        if (!(body instanceof BlockStatement)) {
+            writer.popIndent();
+        }
+    }
+}
+export class MultiBranchIfStatement {
+    constructor(statements, elseStatement) {
+        this.statements = statements;
+        this.elseStatement = elseStatement;
+    }
+    write(writer) {
+        this.statements.forEach((value, index) => {
+            const { expr, stmt } = value;
+            if (index == 0) {
+                writer.print(`if (${expr.asString()}) {`);
+            }
+            else {
+                writer.print(`else if (${expr.asString()}) {`);
+            }
+            writer.pushIndent();
+            stmt.write(writer);
+            writer.popIndent();
+            writer.print("}");
+        });
+        if (this.statements.length > 0 && this.elseStatement !== undefined) {
+            writer.print("else {");
+            writer.pushIndent();
+            this.elseStatement.write(writer);
+            writer.popIndent();
+            writer.print("}");
+        }
+    }
+}
+export class CheckOptionalStatement {
+    constructor(undefinedValue, optionalExpression, doStatement) {
+        this.undefinedValue = undefinedValue;
+        this.optionalExpression = optionalExpression;
+        this.doStatement = doStatement;
+    }
+    write(writer) {
+        writer.print(`if (${this.optionalExpression.asString()} != ${this.undefinedValue})`);
+        writer.pushIndent();
+        this.doStatement.write(writer);
+        writer.popIndent();
+    }
+}
+// maybe rename or move of fix
+export class TsEnumEntityStatement {
+    constructor(enumEntity, isExport) {
+        this.enumEntity = enumEntity;
+        this.isExport = isExport;
+    }
+    write(writer) {
+        // writer.print(this.enumEntity.comment)
+        idl.getNamespacesPathFor(this.enumEntity).forEach(it => writer.pushNamespace(it.name));
+        writer.print(`${this.isExport ? "export " : ""}enum ${this.enumEntity.name} {`);
+        writer.pushIndent();
+        this.enumEntity.elements.forEach((member, index) => {
+            // writer.print(member.comment)
+            const initValue = member.initializer
+                ? ` = ${this.maybeQuoted(member.initializer)}` : ``;
+            writer.print(`${member.name}${initValue},`);
+            let originalName = idl.getExtAttribute(member, idl.IDLExtendedAttributes.OriginalEnumMemberName);
+            if (originalName) {
+                const initValue = ` = ${member.name}`;
+                writer.print(`${originalName}${initValue},`);
+            }
+        });
+        writer.popIndent();
+        writer.print(`}`);
+        idl.getNamespacesPathFor(this.enumEntity).forEach(it => writer.popNamespace());
+    }
+    maybeQuoted(value) {
+        if (typeof value == "string")
+            return `"${value}"`;
+        else
+            return `${value}`;
+    }
+}
+export class ReturnStatement {
+    constructor(expression) {
+        this.expression = expression;
+    }
+    write(writer) {
+        writer.print(this.expression ? `return ${this.expression.asString()}` : "return");
+    }
+}
+export class LambdaExpression {
+    constructor(originalWriter, signature, resolver, body) {
+        this.originalWriter = originalWriter;
+        this.signature = signature;
+        this.resolver = resolver;
+        this.body = body;
+    }
+    bodyAsString() {
+        const writer = this.originalWriter.fork();
+        if (this.body) {
+            for (const stmt of this.body) {
+                stmt.write(writer);
+            }
+        }
+        return writer.printer.getOutput()
+            .map(line => line.trim())
+            .filter(line => line !== "")
+            .map(line => line === "{" || line === "}" || this.statementHasSemicolon ? line : `${line};`)
+            .join(" ");
+    }
+}
+////////////////////////////////////////////////////////////////
+//                         SIGNATURES                         //
+////////////////////////////////////////////////////////////////
+export var FieldModifier;
+(function (FieldModifier) {
+    FieldModifier[FieldModifier["READONLY"] = 0] = "READONLY";
+    FieldModifier[FieldModifier["PRIVATE"] = 1] = "PRIVATE";
+    FieldModifier[FieldModifier["PUBLIC"] = 2] = "PUBLIC";
+    FieldModifier[FieldModifier["STATIC"] = 3] = "STATIC";
+    FieldModifier[FieldModifier["PROTECTED"] = 4] = "PROTECTED";
+    FieldModifier[FieldModifier["FINAL"] = 5] = "FINAL";
+    FieldModifier[FieldModifier["VOLATILE"] = 6] = "VOLATILE";
+    FieldModifier[FieldModifier["INTERNAL"] = 7] = "INTERNAL";
+})(FieldModifier || (FieldModifier = {}));
+export var MethodModifier;
+(function (MethodModifier) {
+    MethodModifier[MethodModifier["PUBLIC"] = 0] = "PUBLIC";
+    MethodModifier[MethodModifier["PRIVATE"] = 1] = "PRIVATE";
+    MethodModifier[MethodModifier["STATIC"] = 2] = "STATIC";
+    MethodModifier[MethodModifier["NATIVE"] = 3] = "NATIVE";
+    MethodModifier[MethodModifier["INLINE"] = 4] = "INLINE";
+    MethodModifier[MethodModifier["GETTER"] = 5] = "GETTER";
+    MethodModifier[MethodModifier["SETTER"] = 6] = "SETTER";
+    MethodModifier[MethodModifier["PROTECTED"] = 7] = "PROTECTED";
+    MethodModifier[MethodModifier["FREE"] = 8] = "FREE";
+})(MethodModifier || (MethodModifier = {}));
+export var ClassModifier;
+(function (ClassModifier) {
+    ClassModifier[ClassModifier["PUBLIC"] = 0] = "PUBLIC";
+    ClassModifier[ClassModifier["PRIVATE"] = 1] = "PRIVATE";
+    ClassModifier[ClassModifier["PROTECTED"] = 2] = "PROTECTED";
+})(ClassModifier || (ClassModifier = {}));
+export class Field {
+    constructor(name, type, modifiers = []) {
+        this.name = name;
+        this.type = type;
+        this.modifiers = modifiers;
+    }
+}
+export class Method {
+    constructor(name, signature, modifiers = undefined, generics) {
+        this.name = name;
+        this.signature = signature;
+        this.modifiers = modifiers;
+        this.generics = generics;
+    }
+}
+export class PrintHint {
+    constructor(hint) {
+        this.hint = hint;
+    }
+}
+PrintHint.AsPointer = new PrintHint('AsPointer');
+PrintHint.AsConstPointer = new PrintHint('AsConstPointer');
+PrintHint.AsValue = new PrintHint('AsValue');
+PrintHint.AsConstReference = new PrintHint('AsConstReference');
+export class MethodSignature {
+    constructor(returnType, args, defaults = undefined, printHints, argNames) {
+        this.returnType = returnType;
+        this.args = args;
+        this.defaults = defaults;
+        this.printHints = printHints;
+        this.argNames = argNames;
+    }
+    argName(index) {
+        var _a, _b;
+        return (_b = (_a = this === null || this === void 0 ? void 0 : this.argNames) === null || _a === void 0 ? void 0 : _a.at(index)) !== null && _b !== void 0 ? _b : `arg${index}`;
+    }
+    argDefault(index) {
+        var _a;
+        return (_a = this.defaults) === null || _a === void 0 ? void 0 : _a[index];
+    }
+    retHint() {
+        var _a;
+        return (_a = this.printHints) === null || _a === void 0 ? void 0 : _a[0];
+    }
+    argHint(index) {
+        var _a;
+        return (_a = this.printHints) === null || _a === void 0 ? void 0 : _a[index + 1];
+    }
+    toString() {
+        return `${this.args.map(it => idl.forceAsNamedNode(it).name)} => ${this.returnType}`;
+    }
+}
+export class NamedMethodSignature extends MethodSignature {
+    constructor(returnType, args = [], argsNames = [], defaults = undefined, printHints) {
+        super(returnType, args, defaults, printHints);
+        this.argsNames = argsNames;
+    }
+    static make(returnType, args) {
+        return new NamedMethodSignature(returnType, args.map(it => it.type), args.map(it => it.name));
+    }
+    argName(index) {
+        return this.argsNames[index];
+    }
+}
+////////////////////////////////////////////////////////////////
+//                    LANGUAGE WRITER                         //
+////////////////////////////////////////////////////////////////
+export class LanguageWriter {
+    constructor(printer, resolver, language) {
+        this.printer = printer;
+        this.resolver = resolver;
+        this.language = language;
+    }
+    indentDepth() {
+        return this.printer.indentDepth();
+    }
+    maybeSemicolon() { return ";"; }
+    // version of makeCast which uses TypeCheck.typeCast<T>(value) call for ETS language writer
+    // Use it only if TypeChecker class is added as import to the generated file
+    makeTypeCast(value, type, options) {
+        return this.makeCast(value, type, options);
+    }
+    makeUnwrapOptional(expression) {
+        return expression;
+    }
+    concat(other) {
+        other.getOutput().forEach(it => this.print(it));
+        return this;
+    }
+    printTo(file) {
+        fs.writeFileSync(file, this.getOutput().join("\n"));
+    }
+    writeLines(lines) {
+        lines.split("\n").forEach(it => this.print(it));
+    }
+    writeGetterImplementation(method, op) {
+        var _a;
+        this.writeMethodImplementation(new Method(method.name, method.signature, [MethodModifier.GETTER].concat((_a = method.modifiers) !== null && _a !== void 0 ? _a : [])), op);
+    }
+    writeSetterImplementation(method, op) {
+        var _a;
+        this.writeMethodImplementation(new Method(method.name, method.signature, [MethodModifier.SETTER].concat((_a = method.modifiers) !== null && _a !== void 0 ? _a : [])), op);
+    }
+    writeSuperCall(params) {
+        this.printer.print(`super(${params.join(", ")})${this.maybeSemicolon()}`);
+    }
+    writeMethodCall(receiver, method, params, nullable = false) {
+        this.printer.print(`${receiver}${nullable ? "?" : ""}.${method}(${params.join(", ")})`);
+    }
+    writeStatement(stmt) {
+        stmt.write(this);
+    }
+    writeStatements(...statements) {
+        statements.forEach(it => this.writeStatement(it));
+    }
+    writeExpressionStatement(smth) {
+        this.writeStatement(new ExpressionStatement(smth));
+    }
+    makeRef(type, _options) {
+        return type;
+    }
+    makeThis() {
+        return new StringExpression("this");
+    }
+    makeNull(value) {
+        return new StringExpression("null");
+    }
+    makeVoid() {
+        return this.makeUndefined();
+    }
+    makeRuntimeTypeCondition(typeVarName, equals, type, varName) {
+        const op = equals ? "==" : "!=";
+        return this.makeNaryOp(op, [this.makeRuntimeType(type), this.makeString(typeVarName)]);
+    }
+    makeValueFromOption(value, destinationConvertor) {
+        return this.makeString(`${value}!`);
+    }
+    makeNewObject(objectName, params = []) {
+        return new NewObjectExpression(objectName, params);
+    }
+    makeFunctionCall(name, params) {
+        if (typeof name === "string") {
+            return new FunctionCallExpression(name, params);
+        }
+        return new FunctionCallExpression(name.asString(), params);
+    }
+    makeMethodCall(receiver, method, params, nullable) {
+        return new MethodCallExpression(receiver, method, params, nullable);
+    }
+    makeFieldAccess(receiver, method, nullable) {
+        return new FieldAccessExpression(receiver, method, nullable);
+    }
+    makeNativeCall(nativeModule, method, params, nullable) {
+        return new MethodCallExpression(this.nativeReceiver(nativeModule), method, params, nullable);
+    }
+    makeBlock(statements, inScope = true) {
+        return new BlockStatement(statements, inScope);
+    }
+    nativeReceiver(nativeModule) {
+        return nativeModule.name;
+    }
+    makeDefinedCheck(value) {
+        return new CheckDefinedExpression(value);
+    }
+    makeRuntimeTypeDefinedCheck(runtimeType) {
+        return this.makeRuntimeTypeCondition(runtimeType, false, RuntimeType.UNDEFINED);
+    }
+    makeCondition(condition, thenStatement, elseStatement, insideIfOp, insideElseOp) {
+        return new IfStatement(condition, thenStatement, elseStatement, insideIfOp, insideElseOp);
+    }
+    makeMultiBranchCondition(conditions, elseStatement) {
+        return new MultiBranchIfStatement(conditions, elseStatement);
+    }
+    makeTernary(condition, trueExpression, falseExpression) {
+        return new TernaryExpression(condition, trueExpression, falseExpression);
+    }
+    makeArrayLength(array, length) {
+        return this.makeString(`${array}.length`);
+    }
+    makeArrayAccess(value, indexVar) {
+        return this.makeString(`${value}[${indexVar}]`);
+    }
+    makeTupleAccess(value, index) {
+        return this.makeString(`${value}[${index}]`);
+    }
+    makeUnionSelector(value, valueType) {
+        return this.makeAssign(valueType, undefined, this.makeString(`runtimeType(${value})`), false);
+    }
+    makeUnionVariantCondition(_convertor, _valueName, valueType, type, _convertorIndex, _runtimeTypeIndex) {
+        return this.makeString(`RuntimeType.${type.toUpperCase()} == ${valueType}`);
+    }
+    makeUnionVariantCast(value, type, convertor, index) {
+        return this.makeString(`unsafeCast<${type}>(${value})`);
+    }
+    makeUnionTypeDefaultInitializer() {
+        return this.makeRuntimeType(RuntimeType.UNDEFINED);
+    }
+    makeRuntimeTypeGetterCall(value) {
+        return this.makeFunctionCall("runtimeType", [this.makeString(value)]);
+    }
+    makeArrayResize(array, arrayType, length, deserializer) {
+        return new ExpressionStatement(new StringExpression(""));
+    }
+    makeMapResize(mapTypeName, keyType, valueType, map, size, deserializer) {
+        return new ExpressionStatement(new StringExpression("// TODO: TS map resize"));
+    }
+    makeMapSize(map) {
+        return this.makeString(`${map}.size`);
+    }
+    makeTupleAlloc(option) {
+        return new ExpressionStatement(new StringExpression(""));
+    }
+    makeSetUnionSelector(value, index) {
+        // empty expression
+        return new ExpressionStatement(new StringExpression(""));
+    }
+    makeSetOptionTag(value, tag) {
+        // empty expression
+        return new ExpressionStatement(new StringExpression(""));
+    }
+    makeString(value) {
+        return new StringExpression(value);
+    }
+    makeNaryOp(op, args) {
+        return new NaryOpExpression(op, args);
+    }
+    makeStatement(expr) {
+        return new ExpressionStatement(expr);
+    }
+    writeNativeMethodDeclaration(name, signature, isNative) {
+        this.writeMethodDeclaration(name, signature);
+    }
+    writeUnsafeNativeMethodDeclaration(name, signature) {
+        return;
+    }
+    pushIndent() {
+        this.printer.pushIndent();
+    }
+    popIndent() {
+        this.printer.popIndent();
+    }
+    print(string) {
+        this.printer.print(string);
+    }
+    getOutput() {
+        return this.printer.getOutput();
+    }
+    makeSignature(returnType, parameters) {
+        return new MethodSignature(returnType, parameters.map(it => it.type));
+    }
+    makeNamedSignature(returnType, parameters) {
+        return NamedMethodSignature.make(returnType, parameters.map(it => ({
+            name: it.name,
+            type: it.isOptional ? idl.createOptionalType(it.type) : it.type
+        })));
+    }
+    makeNativeMethodNamedSignature(returnType, parameters) {
+        return this.makeNamedSignature(returnType, parameters);
+    }
+    makeSerializerConstructorSignature() {
+        return undefined;
+    }
+    mapFieldModifier(modifier) {
+        return `${FieldModifier[modifier].toLowerCase()}`;
+    }
+    mapMethodModifier(modifier) {
+        return `${MethodModifier[modifier].toLowerCase()}`;
+    }
+    /**
+     * TODO: replace me with {@link makeUnsafeCast_}
+     */
+    makeUnsafeCast(convertor, param) {
+        return `unsafeCast<int32>(${param})`;
+    }
+    makeUnsafeCast_(value, type, typeOptions) {
+        return `(${value.asString()} as ${this.getNodeName(type)})`;
+    }
+    runtimeType(param, valueType, value) {
+        this.writeStatement(this.makeAssign(valueType, idl.IDLI32Type, this.makeFunctionCall("runtimeType", [this.makeString(value)]), false));
+    }
+    makeDiscriminatorFromFields(convertor, value, accessors, duplicates) {
+        return this.makeString(`(${this.makeNaryOp("||", accessors.map(it => this.makeString(`${value}!.hasOwnProperty("${it}")`))).asString()})`);
+    }
+    makeCallIsResource(value) {
+        return this.makeString(`isResource(${value})`);
+    }
+    makeEnumEntity(enumEntity, isExport) {
+        return new TsEnumEntityStatement(enumEntity, isExport);
+    }
+    makeFieldModifiersList(modifiers, customFieldFilter) {
+        let allowedModifiers = this.supportedFieldModifiers;
+        let modifierFilter = customFieldFilter ? customFieldFilter : function (field) {
+            return allowedModifiers.includes(field);
+        };
+        let prefix = modifiers === null || modifiers === void 0 ? void 0 : modifiers.filter(modifierFilter).map(it => this.mapFieldModifier(it)).join(" ");
+        return prefix ? prefix : "";
+    }
+    escapeKeyword(keyword) {
+        return keyword;
+    }
+    makeCastCustomObject(customName, _isGenericType) {
+        return this.makeString(customName);
+    }
+    makeHasOwnProperty(value, _valueTypeName, property, propertyTypeName) {
+        const expressions = [this.makeString(`${value}.hasOwnProperty("${property}")`)];
+        if (propertyTypeName) {
+            expressions.push(this.makeString(`isInstanceOf("${propertyTypeName}", ${value}.${property})`));
+        }
+        return this.makeNaryOp("&&", expressions);
+    }
+    discriminatorFromExpressions(value, runtimeType, exprs) {
+        return this.makeNaryOp("&&", [
+            this.makeNaryOp("==", [this.makeRuntimeType(runtimeType), this.makeString(`${value}_type`)]),
+            ...exprs
+        ]);
+    }
+    makeDiscriminatorConvertor(_convertor, _value, _index) {
+        return undefined;
+    }
+    makeNot(expr) {
+        return this.makeString(`!(${expr.asString()})`);
+    }
+    makeEquals(args) {
+        return this.makeNaryOp("===", args);
+    }
+    castToInt(value, bitness) { return value; }
+    castToBoolean(value) { return value; }
+    makeCallIsObject(value) {
+        return this.makeString(`typeof ${value} === "object"`);
+    }
+    makeCallIsArrayBuffer(value) {
+        return this.makeString(`${value} instanceof ArrayBuffer`);
+    }
+    instanceOf(convertor, value, _duplicateMembers) {
+        return this.makeString(`${value} instanceof ${this.getNodeName(convertor.idlType)}`);
+    }
+    // The version of instanceOf() which does not use ArgConvertors
+    typeInstanceOf(type, value, members) {
+        return this.makeString(`${value} instanceof ${this.getNodeName(type)}`);
+    }
+    makeLengthSerializer(serializer, value) {
+        const valueType = "valueType";
+        return this.makeBlock([
+            this.makeAssign(valueType, undefined, this.makeFunctionCall("runtimeType", [this.makeString(value)]), true),
+            this.makeStatement(this.makeMethodCall(serializer, "writeInt8", [this.makeString(valueType)])),
+            this.makeMultiBranchCondition([
+                {
+                    expr: this.makeRuntimeTypeCondition(valueType, true, RuntimeType.NUMBER),
+                    stmt: this.makeStatement(this.makeMethodCall(serializer, "writeFloat32", [this.makeString(`${value} as float32`)]))
+                },
+                {
+                    expr: this.makeRuntimeTypeCondition(valueType, true, RuntimeType.STRING),
+                    stmt: this.makeStatement(this.makeMethodCall(serializer, "writeString", [this.makeString(`${value} as string`)]))
+                },
+                {
+                    expr: this.makeRuntimeTypeCondition(valueType, true, RuntimeType.OBJECT),
+                    stmt: this.makeStatement(this.makeMethodCall(serializer, "writeInt32", [this.makeString(`(${value} as Resource).id as int32`)]))
+                },
+            ]),
+        ], false);
+    }
+    makeLengthDeserializer(deserializer) {
+        const valueType = "valueType";
+        return this.makeBlock([
+            this.makeAssign(valueType, undefined, this.makeMethodCall(deserializer, "readInt8", []), true),
+            this.makeMultiBranchCondition([{
+                    expr: this.makeRuntimeTypeCondition(valueType, true, RuntimeType.NUMBER),
+                    stmt: this.makeReturn(this.makeString(`${deserializer}.readFloat32() as number`))
+                },
+                {
+                    expr: this.makeRuntimeTypeCondition(valueType, true, RuntimeType.STRING),
+                    stmt: this.makeReturn(this.makeMethodCall(deserializer, "readString", []))
+                },
+                {
+                    expr: this.makeRuntimeTypeCondition(valueType, true, RuntimeType.OBJECT),
+                    stmt: this.makeReturn(this.makeString(`({id: ${deserializer}.readInt32(), bundleName: "", moduleName: ""}) as Resource`))
+                }], this.makeReturn(this.makeUndefined())),
+        ], false);
+    }
+    stringifyTypeOrEmpty(type) {
+        if (type === undefined)
+            return "";
+        return this.getNodeName(type);
+    }
+    /**
+     * Writes `namespace <namespace> {` and adds extra indent
+     * @param namespace Namespace to begin
+     */
+    pushNamespace(namespace, ident = true) {
+        this.print(`namespace ${namespace} {`);
+        if (ident)
+            this.pushIndent();
+    }
+    /**
+     * Writes closing brace of namespace block and removes one level of indent
+     */
+    popNamespace(ident = true) {
+        if (ident)
+            this.popIndent();
+        this.print(`}`);
+    }
+}
+export function mangleMethodName(method, id) {
+    return `${method.name}${id !== null && id !== void 0 ? id : ""}`;
+}
+export function printMethodDeclaration(printer, retType, methodName, apiParameters, postfix = "") {
+    if (apiParameters.length > 1) {
+        const methodTypeName = `${retType} ${methodName}`;
+        const indent = ` `.repeat(methodTypeName.length + 1);
+        printer.print(`${methodTypeName}(${apiParameters[0]},`);
+        for (let i = 1; i < apiParameters.length; i++) {
+            printer.print(indent + apiParameters[i] + ((i === apiParameters.length - 1) ? `)${postfix}` : ","));
+        }
+    }
+    else {
+        const signature = `${retType} ${methodName}(${apiParameters.join(", ")})${postfix}`;
+        printer.print(signature);
+    }
+}
+export function copyMethod(method, overrides) {
+    var _a, _b, _c, _d;
+    return new Method((_a = overrides.name) !== null && _a !== void 0 ? _a : method.name, (_b = overrides.signature) !== null && _b !== void 0 ? _b : method.signature, (_c = overrides.modifiers) !== null && _c !== void 0 ? _c : method.modifiers, (_d = overrides.generics) !== null && _d !== void 0 ? _d : method.generics);
+}
+//# sourceMappingURL=LanguageWriter.js.map