@idlizer/core 2.1.5 → 2.1.9-arktscgen-4

package/build/lib/src/LanguageWriters/writers/KotlinLanguageWriter.js

@@ -0,0 +1,495 @@
+/*
+ * 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 { Language } from '../../Language';
+import { IndentedPrinter } from "../../IndentedPrinter";
+import { AssignStatement, DelegationType, ExpressionStatement, FieldModifier, LambdaExpression, LanguageWriter, Method, MethodModifier, MethodSignature } from "../LanguageWriter";
+import { RuntimeType } from "../common";
+import { isDefined } from "../../util";
+import { TSReturnStatement } from './TsLanguageWriter';
+import { removePoints } from '../convertors/CJConvertors';
+export class KotlinEnumEntityStatement {
+    constructor(enumEntity, options) {
+        this.enumEntity = enumEntity;
+        this.options = options;
+    }
+    write(writer) {
+        let mangledName = removePoints(idl.getQualifiedName(this.enumEntity, 'namespace.name'));
+        writer.print(`${this.options.isExport ? "public " : ""}enum class ${mangledName}(val value: Int) {`);
+        writer.pushIndent();
+        this.enumEntity.elements.forEach((member, index) => {
+            const initValue = member.initializer != undefined
+                ? `(${this.maybeQuoted(member.initializer)})` : ``;
+            writer.print(`${member.name}${initValue},`);
+            let originalName = idl.getExtAttribute(member, idl.IDLExtendedAttributes.OriginalEnumMemberName);
+            if (originalName) {
+                const initValue = `(${member.name}.value)`;
+                writer.print(`${originalName}${initValue},`);
+            }
+        });
+        writer.popIndent();
+        writer.print(`}`);
+    }
+    maybeQuoted(value) {
+        if (typeof value == "string")
+            return `"${value}"`;
+        else
+            return `${value}`;
+    }
+}
+export class KotlinEnumWithGetter {
+    constructor(enumEntity, isExport) {
+        this.enumEntity = enumEntity;
+        this.isExport = isExport;
+    }
+    write(writer) {
+        const initializers = this.enumEntity.elements.map(it => {
+            return { name: it.name, id: it.initializer };
+        });
+        const isStringEnum = initializers.every(it => typeof it.id == 'string');
+        let memberValue = 0;
+        const members = [];
+        for (const initializer of initializers) {
+            if (typeof initializer.id == 'string') {
+                members.push({ name: initializer.name, stringId: initializer.id, numberId: memberValue });
+            }
+            else if (typeof initializer.id == 'number') {
+                memberValue = initializer.id;
+                members.push({ name: initializer.name, stringId: undefined, numberId: memberValue });
+            }
+            else {
+                members.push({ name: initializer.name, stringId: undefined, numberId: memberValue });
+            }
+            memberValue += 1;
+        }
+        let mangledName = removePoints(idl.getQualifiedName(this.enumEntity, 'namespace.name'));
+        writer.writeClass(mangledName, () => {
+            const enumType = idl.createReferenceType(this.enumEntity);
+            writer.makeStaticBlock(() => {
+                members.forEach(it => {
+                    writer.writeFieldDeclaration(it.name, idl.IDLAnyType, [FieldModifier.PUBLIC, FieldModifier.STATIC, FieldModifier.FINAL], false, writer.makeString(`${mangledName}(${it.stringId ? `\"${it.stringId}\"` : it.numberId})`));
+                });
+            });
+            const value = 'value';
+            writer.writeFieldDeclaration(value, idl.IDLI32Type, [FieldModifier.PUBLIC], true, writer.makeNull());
+            const signature = new MethodSignature(idl.IDLVoidType, [idl.IDLI32Type]);
+            writer.writeConstructorImplementation('constructor', signature, () => {
+                writer.writeStatement(writer.makeAssign(`this.${value}`, undefined, writer.makeString(signature.argName(0)), false));
+            });
+            if (isStringEnum) {
+                const stringValue = 'stringValue';
+                writer.writeFieldDeclaration(stringValue, idl.IDLStringType, [FieldModifier.PUBLIC], true, writer.makeNull());
+                const signature = new MethodSignature(idl.IDLVoidType, [idl.IDLStringType]);
+                writer.writeConstructorImplementation('constructor', signature, () => {
+                    writer.writeStatement(writer.makeAssign(`this.${stringValue}`, undefined, writer.makeString(signature.argName(0)), false));
+                });
+            }
+        });
+    }
+}
+class KotlinMapForEachStatement {
+    constructor(map, key, value, op) {
+        this.map = map;
+        this.key = key;
+        this.value = value;
+        this.op = op;
+    }
+    write(writer) {
+        writer.print(`for ((${this.key}, ${this.value}) in ${this.map}) {`);
+        writer.pushIndent();
+        this.op();
+        writer.popIndent();
+        writer.print(`}`);
+    }
+}
+export class KotlinThrowErrorStatement {
+    constructor(message) {
+        this.message = message;
+    }
+    write(writer) {
+        writer.print(`throw Error("${this.message}")`);
+    }
+}
+export class KotlinLoopStatement {
+    constructor(counter, limit, statement) {
+        this.counter = counter;
+        this.limit = limit;
+        this.statement = statement;
+    }
+    write(writer) {
+        writer.print(`for (${this.counter} in 0..${this.limit}) {`);
+        if (this.statement) {
+            writer.pushIndent();
+            this.statement.write(writer);
+            writer.popIndent();
+            writer.print("}");
+        }
+    }
+}
+export class KotlinAssignStatement extends AssignStatement {
+    constructor(variableName, type, expression, isDeclared = true, isConst = true) {
+        super(variableName, type, expression, isDeclared, isConst);
+        this.variableName = variableName;
+        this.type = type;
+        this.expression = expression;
+        this.isDeclared = isDeclared;
+        this.isConst = isConst;
+    }
+    write(writer) {
+        var _a;
+        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)}` : "";
+            const constSpec = this.isConst ? "val" : "var";
+            const initValue = this.expression ? `= ${this.expression.asString()}` : "";
+            writer.print(`${constSpec} ${this.variableName}${typeSpec} ${initValue}`);
+        }
+        else {
+            writer.print(`${this.variableName} = ${this.expression.asString()}`);
+        }
+    }
+}
+export class KotlinNewObjectExpression {
+    constructor(objectName, params) {
+        this.objectName = objectName;
+        this.params = params;
+    }
+    asString() {
+        return `${this.objectName}(${this.params.map(it => it.asString()).join(", ")})`;
+    }
+}
+export class KotlinCheckDefinedExpression {
+    constructor(value) {
+        this.value = value;
+    }
+    asString() {
+        return `${this.value} != null`;
+    }
+}
+class KotlinUnwrapOptionalExpression {
+    constructor(value) {
+        this.value = value;
+    }
+    asString() {
+        return `requireNotNull(${this.value.asString()})`;
+    }
+}
+class KotlinLambdaExpression extends LambdaExpression {
+    constructor(writer, signature, resolver, body) {
+        super(writer, signature, resolver, body);
+        this.writer = writer;
+    }
+    get statementHasSemicolon() {
+        return false;
+    }
+    asString() {
+        const params = this.signature.args.map((it, i) => `${this.writer.escapeKeyword(this.signature.argName(i))}: ${this.writer.getNodeName(it)}`);
+        return `{${params.join(", ")} -> ${this.bodyAsString()} }`;
+    }
+}
+export class KotlinLanguageWriter extends LanguageWriter {
+    constructor(printer, resolver, typeConvertor, language = Language.KOTLIN) {
+        super(printer, resolver, language);
+        this.typeConvertor = typeConvertor;
+    }
+    fork(options) {
+        var _a;
+        return new KotlinLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.language);
+    }
+    getNodeName(type) {
+        return this.typeConvertor.convert(type);
+    }
+    writeClass(name, op, superClass, interfaces, generics, isDeclared, isAbstract) {
+        let extendsClause = superClass ? `${superClass}` : undefined;
+        let implementsClause = interfaces ? `${interfaces.join(' , ')}` : undefined;
+        let inheritancePart = [extendsClause, implementsClause]
+            .filter(isDefined)
+            .join(' , ');
+        inheritancePart = inheritancePart.length != 0 ? ' : '.concat(inheritancePart) : '';
+        this.printer.print(`public open class ${name}${inheritancePart} {`);
+        this.pushIndent();
+        op(this);
+        this.popIndent();
+        this.printer.print(`}`);
+    }
+    writeInterface(name, op, superInterfaces, generics, isDeclared) {
+        this.printer.print(`public interface ${name} {`);
+        this.pushIndent();
+        op(this);
+        this.popIndent();
+        this.printer.print(`}`);
+    }
+    writeFunctionDeclaration(name, signature, generics) {
+        this.printer.print(this.generateFunctionDeclaration(name, signature));
+    }
+    writeFunctionImplementation(name, signature, op, generics) {
+        this.printer.print(`${this.generateFunctionDeclaration(name, signature)} {`);
+        this.printer.pushIndent();
+        op(this);
+        this.printer.popIndent();
+        this.printer.print('}');
+    }
+    generateFunctionDeclaration(name, signature) {
+        const args = signature.args.map((it, index) => `${signature.argName(index)}: ${this.getNodeName(it)}`);
+        return `public fun ${name}(${args.join(", ")}): ${this.getNodeName(signature.returnType)}`;
+    }
+    writeEnum(name, members, options) {
+        throw new Error("Try to avoid writeEnum");
+    }
+    writeDeclaration(name, signature, needReturn, needBracket, modifiers, generics) {
+        let prefix = !modifiers ? undefined : this.supportedModifiers
+            .filter(it => modifiers.includes(it))
+            .map(it => this.mapMethodModifier(it)).join(" ");
+        if (modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.GETTER)) {
+            prefix = `${prefix} get`;
+        }
+        else if (modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.SETTER)) {
+            prefix = `${prefix} set`;
+            needReturn = false;
+        }
+        prefix = prefix ? prefix.trim() + " " : "";
+        const typeParams = (generics === null || generics === void 0 ? void 0 : generics.length) ? `<${generics.join(", ")}>` : "";
+        const normalizedArgs = signature.args.map((it, i) => idl.isOptionalType(it) && signature.isArgOptional(i) ? idl.maybeUnwrapOptionalType(it) : it);
+        this.printer.print(`${prefix}fun ${name}${typeParams}(${normalizedArgs.map((it, index) => `${signature.argName(index)}: ${this.getNodeName(it)}${signature.isArgOptional(index) ? "?" : ``}${signature.argDefault(index) ? ' = ' + signature.argDefault(index) : ""}`).join(", ")})${needReturn ? ": " + this.getNodeName(signature.returnType) : ""}${needBracket ? " {" : ""}`);
+    }
+    writeFieldDeclaration(name, type, modifiers, optional, initExpr) {
+        const init = initExpr != undefined ? ` = ${initExpr.asString()}` : ``;
+        let prefix = this.makeFieldModifiersList(modifiers === null || modifiers === void 0 ? void 0 : modifiers.filter(m => m != FieldModifier.READONLY && m != FieldModifier.STATIC));
+        this.printer.print(`${prefix ? prefix.concat(" ") : ""}${(modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(FieldModifier.READONLY)) ? 'val' : 'var'} ${name}: ${this.getNodeName(idl.maybeOptional(type, optional))}${init}`);
+    }
+    writeNativeMethodDeclaration(method) {
+        let name = method.name;
+        let signature = method.signature;
+        this.writeMethodImplementation(new Method(name, signature, [MethodModifier.STATIC]), writer => { });
+    }
+    writeMethodDeclaration(name, signature, modifiers) {
+        this.writeDeclaration(name, signature, true, false, modifiers);
+    }
+    writeConstructorImplementation(className, signature, op, delegationCall, modifiers) {
+        const delegationType = ((delegationCall === null || delegationCall === void 0 ? void 0 : delegationCall.delegationType) == DelegationType.THIS) ? "this" : "super";
+        const superInvocation = delegationCall
+            ? ` : ${delegationType}(${delegationCall.delegationArgs.map(it => it.asString()).join(", ")})`
+            : "";
+        const argList = signature.args.map((it, index) => {
+            var _a;
+            const maybeDefault = ((_a = signature.defaults) === null || _a === void 0 ? void 0 : _a[index]) ? ` = ${signature.defaults[index]}` : "";
+            return `${signature.argName(index)}: ${this.getNodeName(it)}${maybeDefault}`;
+        }).join(", ");
+        this.print(`constructor(${argList})${superInvocation} {`);
+        this.pushIndent();
+        op(this);
+        this.popIndent();
+        this.printer.print(`}`);
+    }
+    writeMethodImplementation(method, op) {
+        this.writeDeclaration(method.name, method.signature, true, true, method.modifiers, method.generics);
+        this.pushIndent();
+        op(this);
+        this.popIndent();
+        this.printer.print(`}`);
+    }
+    writeProperty(propName, propType, modifiers, getter, setter) {
+        let containerName = propName.concat("_container");
+        let truePropName = this.escapeKeyword(propName);
+        if (getter) {
+            if (!getter.op) {
+                this.print(`private var ${containerName}: ${this.getNodeName(propType)}`);
+            }
+        }
+        let isStatic = modifiers.includes(FieldModifier.STATIC);
+        let isMutable = !modifiers.includes(FieldModifier.READONLY);
+        this.print(`public ${isMutable ? "var " : "val "}${truePropName}: ${this.getNodeName(propType)}`);
+        if (getter) {
+            this.pushIndent();
+            this.writeGetterImplementation(getter.method, getter.op);
+            if (isMutable) {
+                if (setter) {
+                    this.writeSetterImplementation(setter.method, setter ? setter.op : (writer) => { this.print(`${containerName} = ${truePropName}`); });
+                }
+                else {
+                    this.print(`set(${truePropName}) {`);
+                    this.pushIndent();
+                    this.print(`${containerName} = ${truePropName}`);
+                    this.popIndent();
+                    this.print(`}`);
+                }
+            }
+            this.popIndent();
+        }
+    }
+    writeGetterImplementation(method, op) {
+        this.print(`get() {`);
+        this.pushIndent();
+        op ? op(this) : this.print(`return ${method.signature.argsNames.map(arg => `${arg}_container`).join(', ')}`);
+        this.popIndent();
+        this.print('}');
+    }
+    writeSetterImplementation(method, op) {
+        this.print(`set(${method.signature.argsNames.map(arg => this.escapeKeyword(arg)).join(', ')}) {`);
+        this.pushIndent();
+        op(this);
+        this.popIndent();
+        this.print('}');
+    }
+    writeTypeDeclaration(decl) {
+        throw new Error("Not implemented");
+    }
+    writeConstant(constName, constType, constVal) {
+        throw new Error("Not implemented");
+    }
+    makeNull() {
+        return this.makeString('null');
+    }
+    makeAssign(variableName, type, expr, isDeclared = true, isConst = true, options) {
+        return new KotlinAssignStatement(variableName, type, expr, isDeclared, isConst);
+    }
+    makeLambda(signature, body) {
+        return new KotlinLambdaExpression(this, signature, this.resolver, body);
+    }
+    makeThrowError(message) {
+        return new KotlinThrowErrorStatement(message);
+    }
+    makeReturn(expr) {
+        return new TSReturnStatement(expr);
+    }
+    makeCheckOptional(optional, doStatement) {
+        throw new Error("Not implemented");
+    }
+    makeStatement(expr) {
+        return new ExpressionStatement(expr);
+    }
+    makeLoop(counter, limit, statement) {
+        return new KotlinLoopStatement(counter, limit, statement);
+    }
+    makeMapForEach(map, key, value, op) {
+        return new KotlinMapForEachStatement(map, key, value, op);
+    }
+    writePrintLog(message) {
+        throw new Error("Not implemented");
+    }
+    makeCast(value, node, options) {
+        return this.makeString(`${value.asString()} as ${this.getNodeName(node)}`);
+    }
+    typeInstanceOf(type, value, members) {
+        throw new Error("Not implemented");
+    }
+    getObjectAccessor(convertor, value, args) {
+        throw new Error("Not implemented");
+    }
+    makeUndefined() {
+        return this.makeNull();
+    }
+    makeRuntimeType(rt) {
+        return this.makeString(`RuntimeType.${RuntimeType[rt]}.value`);
+    }
+    makeTupleAlloc(option) {
+        throw new Error("Not implemented");
+    }
+    makeArrayInit(type, size) {
+        return this.makeString(`Array<${this.getNodeName(type.elementType[0])}>(${size !== null && size !== void 0 ? size : ''})`);
+    }
+    makeArrayLength(array, length) {
+        return this.makeString(`${array}.size`);
+    }
+    makeClassInit(type, paramenters) {
+        throw new Error("Not implemented");
+    }
+    makeMapInit(type) {
+        return this.makeString(`${this.getNodeName(type)}()`);
+    }
+    makeMapInsert(keyAccessor, key, valueAccessor, value) {
+        return this.makeStatement(this.makeMethodCall(keyAccessor, "set", [this.makeString(key), this.makeString(value)]));
+    }
+    makeUnwrapOptional(expression) {
+        return new KotlinUnwrapOptionalExpression(expression);
+    }
+    makeDefinedCheck(value) {
+        return new KotlinCheckDefinedExpression(value);
+    }
+    makeUnionSelector(value, valueType) {
+        return this.makeAssign(valueType, undefined, this.makeMethodCall(value, "getSelector", []), false);
+    }
+    makeUnionVariantCast(value, type, convertor, index) {
+        return this.makeMethodCall(value, `getValue${index}`, []);
+    }
+    makeValueFromOption(value, destinationConvertor) {
+        return this.makeString(`${value}!!`);
+    }
+    makeUnionVariantCondition(_convertor, _valueName, valueType, type, _convertorIndex, _runtimeTypeIndex) {
+        return this.makeString(`RuntimeType.${type.toUpperCase()}.value == ${valueType}`);
+    }
+    makeRuntimeTypeCondition(typeVarName, equals, type, varName) {
+        if (varName) {
+            return this.makeDefinedCheck(varName);
+        }
+        else {
+            const op = equals ? "==" : "!=";
+            return this.makeNaryOp(op, [this.makeRuntimeType(type), this.makeString(`${typeVarName}.toInt()`)]);
+        }
+    }
+    getTagType() {
+        return idl.createReferenceType("Tag");
+    }
+    getRuntimeType() {
+        return idl.IDLNumberType;
+    }
+    makeTupleAssign(receiver, fields) {
+        throw new Error("Not implemented");
+    }
+    get supportedModifiers() {
+        return [MethodModifier.PUBLIC, MethodModifier.PRIVATE, MethodModifier.OVERRIDE];
+    }
+    get supportedFieldModifiers() {
+        return [FieldModifier.PUBLIC, FieldModifier.PRIVATE, FieldModifier.PROTECTED, FieldModifier.READONLY];
+    }
+    enumFromI32(value, enumEntry) {
+        return this.makeString(`${this.getNodeName(enumEntry)}(${value.asString()})`);
+    }
+    i32FromEnum(value, enumEntry) {
+        return this.makeString(`${value.asString()}.value`);
+    }
+    makeEnumEntity(enumEntity, options) {
+        return new KotlinEnumWithGetter(enumEntity, options.isExport);
+    }
+    castToBoolean(value) {
+        return `if (${value}) { 1 } else { 0 }`;
+    }
+    castToInt(value, bitness) {
+        return `${this.escapeKeyword(value)}.${bitness == 8 ? 'toByte()' : 'toInt()'}`;
+    }
+    makeCallIsObject(value) {
+        throw new Error("Not implemented");
+    }
+    makeNewObject(objectName, params = []) {
+        return new KotlinNewObjectExpression(objectName, params);
+    }
+    escapeKeyword(keyword) {
+        return keyword;
+    }
+    makeDiscriminatorConvertor(convertor, value, index) {
+        throw new Error("Not implemented");
+    }
+    makeStaticBlock(op) {
+        this.printer.print('companion object {');
+        this.printer.pushIndent();
+        op(this);
+        this.popIndent();
+        this.printer.print('}');
+    }
+    pushNamespace(namespace, options) { }
+    popNamespace(options) { }
+}
+//# sourceMappingURL=KotlinLanguageWriter.js.map

package/build/lib/src/LanguageWriters/writers/TsLanguageWriter.d.ts

@@ -1,7 +1,7 @@
 import * as idl from '../../idl';
 import { Language } from '../../Language';
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { FieldModifier, LambdaExpression, LanguageExpression, LanguageStatement, LanguageWriter, MakeAssignOptions, MakeCastOptions, Method, MethodModifier, MethodSignature, NamedMethodSignature, ObjectArgs, ReturnStatement } from "../LanguageWriter";
+import { DelegationCall, FieldModifier, LambdaExpression, LanguageExpression, LanguageStatement, LanguageWriter, MakeAssignOptions, MakeCastOptions, Method, MethodModifier, MethodSignature, NamedMethodSignature, ObjectArgs, ReturnStatement } from "../LanguageWriter";
 import { ArgConvertor } from "../ArgConvertors";
 import { IdlNameConvertor } from "../nameConvertor";
 import { RuntimeType } from "../common";
@@ -32,15 +32,18 @@ export declare class TSLanguageWriter extends LanguageWriter {
     protected typeConvertor: IdlNameConvertor;
     constructor(printer: IndentedPrinter, resolver: ReferenceResolver, typeConvertor: IdlNameConvertor, language?: Language);
     maybeSemicolon(): string;
-    pushNamespace(namespace: string, ident?: boolean): void;
+    pushNamespace(namespace: string, options: {
+        ident: boolean;
+        isDeclared?: boolean;
+    }): void;
     fork(options?: {
         resolver?: ReferenceResolver;
     }): LanguageWriter;
     getNodeName(type: idl.IDLNode): string;
     writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[], generics?: string[], isDeclared?: boolean, isAbstract?: boolean): void;
     writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[], generics?: string[], isDeclared?: boolean): void;
-    writeFunctionDeclaration(name: string, signature: MethodSignature): void;
-    writeFunctionImplementation(name: string, signature: MethodSignature, op: (writer: this) => void): void;
+    writeFunctionDeclaration(name: string, signature: MethodSignature, generics?: string[]): void;
+    writeFunctionImplementation(name: string, signature: MethodSignature, op: (writer: this) => void, generics?: string[]): void;
     private generateFunctionDeclaration;
     writeEnum(name: string, members: {
         name: string;
@@ -54,7 +57,7 @@ export declare class TSLanguageWriter extends LanguageWriter {
     writeFieldDeclaration(name: string, type: idl.IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
     writeNativeMethodDeclaration(method: Method): void;
     writeMethodDeclaration(name: string, signature: MethodSignature, modifiers?: MethodModifier[]): void;
-    writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
+    writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, delegationCall?: DelegationCall, modifiers?: MethodModifier[]): void;
     writeMethodImplementation(method: Method, op: (writer: this) => void): void;
     writeProperty(propName: string, propType: idl.IDLType, modifiers: FieldModifier[], getter?: {
         method: Method;

package/build/lib/src/LanguageWriters/writers/TsLanguageWriter.js

@@ -16,7 +16,7 @@ import * as idl from '../../idl';
 import { isOptionalType } from '../../idl';
 import { Language } from '../../Language';
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { AssignStatement, BlockStatement, CheckOptionalStatement, ExpressionStatement, FieldModifier, IfStatement, LambdaExpression, LanguageWriter, Method, MethodModifier, MethodSignature, NamedMethodSignature, NaryOpExpression, ReturnStatement, StringExpression } from "../LanguageWriter";
+import { AssignStatement, BlockStatement, CheckOptionalStatement, DelegationType, ExpressionStatement, FieldModifier, IfStatement, LambdaExpression, LanguageWriter, Method, MethodModifier, MethodSignature, NamedMethodSignature, NaryOpExpression, ReturnStatement, StringExpression } from "../LanguageWriter";
 import { RuntimeType } from "../common";
 import { rightmostIndexOf, throwException } from "../../util";
 import { TSKeywords } from '../../languageSpecificKeywords';
@@ -124,10 +124,11 @@ export class TSLanguageWriter extends LanguageWriter {
         this.typeConvertor = typeConvertor;
     }
     maybeSemicolon() { return ""; }
-    pushNamespace(namespace, ident = true) {
+    pushNamespace(namespace, options) {
         this.namespaceStack.push(namespace);
-        this.print(`export namespace ${namespace} {`);
-        if (ident)
+        const declaredPrefix = options.isDeclared ? "declare " : "";
+        this.print(`export ${declaredPrefix}namespace ${namespace} {`);
+        if (options.ident)
             this.pushIndent();
     }
     fork(options) {
@@ -165,24 +166,25 @@ export class TSLanguageWriter extends LanguageWriter {
         this.popIndent();
         this.printer.print(`}`);
     }
-    writeFunctionDeclaration(name, signature) {
-        this.printer.print(this.generateFunctionDeclaration(name, signature));
+    writeFunctionDeclaration(name, signature, generics) {
+        this.printer.print(this.generateFunctionDeclaration(name, signature, generics));
     }
-    writeFunctionImplementation(name, signature, op) {
-        this.printer.print(`${this.generateFunctionDeclaration(name, signature)} {`);
+    writeFunctionImplementation(name, signature, op, generics) {
+        this.printer.print(`${this.generateFunctionDeclaration(name, signature, generics)} {`);
         this.printer.pushIndent();
         op(this);
         this.printer.popIndent();
         this.printer.print('}');
     }
-    generateFunctionDeclaration(name, signature) {
+    generateFunctionDeclaration(name, signature, generics) {
         const rightmostRegularParameterIndex = rightmostIndexOf(signature.args, it => !isOptionalType(it));
         const args = signature.args.map((it, index) => {
             const optionalToken = idl.isOptionalType(it) && index > rightmostRegularParameterIndex ? '?' : '';
             return `${signature.argName(index)}${optionalToken}: ${this.getNodeName(it)}`;
         });
         const returnType = this.getNodeName(signature.returnType);
-        return `export function ${name}(${args.join(", ")}): ${returnType}`;
+        const typeParams = generics && generics.length ? '<' + (generics === null || generics === void 0 ? void 0 : generics.join(', ')) + '>' : '';
+        return `export function ${name}${typeParams}(${args.join(", ")}): ${returnType}`;
     }
     writeEnum(name, members, options) {
         this.printer.print(`${options.isExport ? "export " : ""}${options.isDeclare ? "declare " : ""}enum ${name} {`);
@@ -222,11 +224,13 @@ export class TSLanguageWriter extends LanguageWriter {
     writeMethodDeclaration(name, signature, modifiers) {
         this.writeDeclaration(name, signature, true, false, modifiers);
     }
-    writeConstructorImplementation(className, signature, op, superCall, modifiers) {
+    writeConstructorImplementation(className, signature, op, delegationCall, modifiers) {
+        var _a;
         this.writeDeclaration(`${modifiers ? modifiers.map((it) => MethodModifier[it].toLowerCase()).join(' ') + ' ' : ''}constructor`, signature, false, true);
         this.pushIndent();
-        if (superCall) {
-            this.print(`super(${superCall.signature.args.map((_, i) => superCall === null || superCall === void 0 ? void 0 : superCall.signature.argName(i)).join(", ")})`);
+        if (delegationCall) {
+            const delegationType = ((delegationCall === null || delegationCall === void 0 ? void 0 : delegationCall.delegationType) == DelegationType.THIS) ? "this" : "super";
+            this.print(`${delegationType}(${(_a = delegationCall.delegationArgs) === null || _a === void 0 ? void 0 : _a.map(it => it.asString()).join(", ")})`);
         }
         op(this);
         this.popIndent();

package/build/lib/src/LibraryInterface.d.ts

@@ -2,6 +2,7 @@ import * as idl from "./idl";
 import { Language } from "./Language";
 import { IdlNameConvertor } from "./LanguageWriters";
 import { ArgConvertor } from "./LanguageWriters/ArgConvertors";
+import { LayoutManager } from "./peer-generation/LayoutManager";
 import { ReferenceResolver } from "./peer-generation/ReferenceResolver";
 export interface LibraryInterface extends ReferenceResolver {
     language: Language;
@@ -12,6 +13,7 @@ export interface LibraryInterface extends ReferenceResolver {
     createTypeNameConvertor(language: Language): IdlNameConvertor;
     createContinuationCallbackReference(continuationType: idl.IDLType): idl.IDLReferenceType;
     getCurrentContext(): string | undefined;
+    layout: LayoutManager;
     /**
      * todo: is it really needed?
      */