@idlizer/core 2.1.7 → 2.1.9-arktscgen-5

package/build/lib/src/IndentedPrinter.js

@@ -14,6 +14,7 @@
 */
 import * as fs from "fs";
 import { indentedBy } from "./util";
+import path from "path";
 export class IndentedPrinter {
     constructor(output = []) {
         this.output = output;
@@ -42,6 +43,7 @@ export class IndentedPrinter {
         return this.output;
     }
     printTo(file) {
+        fs.mkdirSync(path.dirname(file), { recursive: true });
         fs.writeFileSync(file, this.getOutput().join("\n"));
     }
     withIndent(prints) {

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

@@ -7,6 +7,7 @@ export declare class Language {
     static JAVA: Language;
     static CPP: Language;
     static CJ: Language;
+    static KOTLIN: Language;
     private constructor();
     toString(): string;
     get directory(): string;

package/build/lib/src/Language.js

@@ -30,6 +30,8 @@ export class Language {
             case "java": return Language.JAVA;
             case "ts": return Language.TS;
             case "cangjie": return Language.CJ;
+            case "cpp": return Language.CPP;
+            case "kotlin": return Language.KOTLIN;
             default: throw new Error(`Unsupported language ${name}`);
         }
     }
@@ -39,4 +41,5 @@ Language.ARKTS = new Language("ArkTS", ".ts", true); // using .ts for ArkTS unti
 Language.JAVA = new Language("Java", ".java", false);
 Language.CPP = new Language("C++", ".cc", false);
 Language.CJ = new Language("CangJie", ".cj", false);
+Language.KOTLIN = new Language("Kotlin", ".kt", false);
 //# sourceMappingURL=Language.js.map

package/build/lib/src/LanguageWriters/ArgConvertors.d.ts

@@ -1,10 +1,11 @@
 import * as idl from "../idl";
 import { Language } from "../Language";
 import { ExpressionAssigner, LanguageExpression, LanguageStatement, LanguageWriter, Method } from "./LanguageWriter";
-import { RuntimeType } from "./common";
+import { NativeModuleType, RuntimeType } from "./common";
 import { LibraryInterface } from "../LibraryInterface";
 import { ReferenceResolver } from "../peer-generation/ReferenceResolver";
 import { PeerLibrary } from "../peer-generation/PeerLibrary";
+export declare function getSerializerName(declaration: idl.IDLEntry): string;
 export interface ArgConvertor {
     param: string;
     idlType: idl.IDLType;
@@ -301,8 +302,21 @@ export declare class FunctionConvertor extends BaseArgConvertor {
     isPointerType(): boolean;
 }
 export declare class MaterializedClassConvertor extends BaseArgConvertor {
+    private library;
+    declaration: idl.IDLInterface;
+    constructor(library: LibraryInterface, param: string, declaration: idl.IDLInterface);
+    convertorArg(param: string, writer: LanguageWriter): string;
+    convertorSerialize(param: string, value: string, printer: LanguageWriter): void;
+    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    nativeType(): idl.IDLType;
+    interopType(): idl.IDLType;
+    isPointerType(): boolean;
+    unionDiscriminator(value: string, index: number, writer: LanguageWriter, duplicates: Set<string>): LanguageExpression | undefined;
+}
+export declare class ExternalTypeConvertor extends BaseArgConvertor {
+    private library;
     declaration: idl.IDLInterface;
-    constructor(param: string, declaration: idl.IDLInterface);
+    constructor(library: PeerLibrary, param: string, declaration: idl.IDLInterface);
     convertorArg(param: string, writer: LanguageWriter): string;
     convertorSerialize(param: string, value: string, printer: LanguageWriter): void;
     convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
@@ -324,7 +338,8 @@ export declare class ImportTypeConvertor extends BaseArgConvertor {
 export declare class CallbackConvertor extends BaseArgConvertor {
     private readonly library;
     private readonly decl;
-    constructor(library: LibraryInterface, param: string, decl: idl.IDLCallback);
+    private readonly interopModuleName;
+    constructor(library: LibraryInterface, param: string, decl: idl.IDLCallback, interopModuleName: NativeModuleType);
     private get isTransformed();
     private get transformedDecl();
     convertorArg(param: string, writer: LanguageWriter): string;

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

@@ -14,15 +14,19 @@
  */
 import * as idl from "../idl";
 import { Language } from "../Language";
-import { BlockStatement, PrintHint, StringExpression, MethodModifier } from "./LanguageWriter";
+import { BlockStatement, PrintHint, StringExpression, MethodModifier, NamedMethodSignature, ProxyStatement, ExpressionStatement } from "./LanguageWriter";
 import { RuntimeType } from "./common";
 import { generatorConfiguration, generatorTypePrefix } from "../config";
-import { hashCodeFromString, warn } from "../util";
+import { getExtractorName, hashCodeFromString, warn } from "../util";
 import { UnionRuntimeTypeChecker } from "../peer-generation/unions";
 import { CppConvertor, CppNameConvertor } from "./convertors/CppConvertors";
 import { createEmptyReferenceResolver } from "../peer-generation/ReferenceResolver";
 import { PrimitiveTypesInstance } from "../peer-generation/PrimitiveType";
 import { qualifiedName } from "../peer-generation/idl/common";
+import { LayoutNodeRole } from "../peer-generation/LayoutManager";
+export function getSerializerName(declaration) {
+    return `${idl.getQualifiedName(declaration, "namespace.name").split('.').join('_')}_serializer`;
+}
 export function isDirectConvertedType(originalType, library) {
     const debug = false;
     if (originalType == undefined)
@@ -437,7 +441,7 @@ export class AggregateConvertor extends BaseArgConvertor {
     convertorSerialize(param, value, printer) {
         this.memberConvertors.forEach((it, index) => {
             let memberName = this.members[index][0];
-            let memberAccess = `${value}.${memberName}`;
+            let memberAccess = `${value}.${printer.escapeKeyword(memberName)}`;
             printer.writeStatement(printer.makeAssign(`${value}_${memberName}`, undefined, printer.makeString(memberAccess), true));
             it.convertorSerialize(param, `${value}_${memberName}`, printer);
         });
@@ -463,9 +467,7 @@ export class AggregateConvertor extends BaseArgConvertor {
                 /**
                  * todo: check UnionType name creation for union of unnamed nodes (isNamedNode() == false)
                  */
-                const memberType = prop.isOptional
-                    ? idl.createUnionType([idl.IDLUndefinedType, prop.type])
-                    : prop.type;
+                const memberType = idl.maybeOptional(prop.type, prop.isOptional);
                 return writer.makeAssign(`${bufferName}_${prop.name}`, memberType, expr, true, true);
             }, writer));
         }
@@ -548,10 +550,14 @@ export class InterfaceConvertor extends BaseArgConvertor {
         throw new Error("Must never be used");
     }
     convertorSerialize(param, value, printer) {
-        printer.writeMethodCall(`${param}Serializer`, `write${this.library.getInteropName(this.idlType)}`, [value]);
+        const accessor = getSerializerName(this.declaration);
+        printer.addFeature(accessor, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
+        printer.writeStaticMethodCall(accessor, 'write', [`${param}Serializer`, value]);
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
-        return assigneer(writer.makeMethodCall(`${deserializerName}`, `read${this.library.getInteropName(this.idlType)}`, []));
+        const accessor = getSerializerName(this.declaration);
+        writer.addFeature(accessor, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
+        return assigneer(writer.makeStaticMethodCall(accessor, 'read', [writer.makeString(deserializerName)]));
     }
     nativeType() {
         return this.idlType;
@@ -716,6 +722,11 @@ export class DateConvertor extends BaseArgConvertor {
         if (writer.language === Language.CPP) {
             writer.writeMethodCall(`${param}Serializer`, "writeInt64", [value]);
         }
+        else if (writer.language === Language.CJ) {
+            writer.writeMethodCall(`${param}Serializer`, "writeInt64", [
+                writer.makeCast(writer.makeString(`${value}`), idl.IDLI64Type).asString()
+            ]);
+        }
         else {
             writer.writeMethodCall(`${param}Serializer`, "writeInt64", [
                 writer.makeCast(writer.makeString(`${value}.getTime()`), idl.IDLI64Type).asString()
@@ -727,10 +738,13 @@ export class DateConvertor extends BaseArgConvertor {
         if (writer.language === Language.CPP) {
             return assigneer(deserializeTime);
         }
+        if (writer.language === Language.CJ) {
+            return assigneer(writer.makeString(`DateTime.now()`));
+        }
         return assigneer(writer.makeString(`new Date(${deserializeTime.asString()})`));
     }
     nativeType() {
-        return idl.createReferenceType('Date');
+        return idl.IDLDate;
     }
     interopType() {
         return idl.IDLDate;
@@ -830,13 +844,13 @@ export class OptionConvertor extends BaseArgConvertor {
         const valueType = `${value}_type`.replaceAll('.', '_');
         const serializedType = (printer.language == Language.JAVA ? undefined : idl.IDLI32Type);
         printer.writeStatement(printer.makeAssign(valueType, serializedType, printer.makeRuntimeType(RuntimeType.UNDEFINED), true, false));
-        if (printer.language != Language.CJ) {
+        if (printer.language != Language.CJ && printer.language != Language.KOTLIN) {
             printer.runtimeType(this, valueType, value);
             printer.writeMethodCall(`${param}Serializer`, "writeInt8", [printer.castToInt(valueType, 8)]);
         }
         printer.print(`if (${printer.makeRuntimeTypeCondition(valueType, false, RuntimeType.UNDEFINED, value).asString()}) {`);
         printer.pushIndent();
-        if (printer.language == Language.CJ) {
+        if (printer.language == Language.CJ || printer.language == Language.KOTLIN) {
             printer.writeMethodCall(`${param}Serializer`, "writeInt8", ["RuntimeType.OBJECT.ordinal"]); // everything is object, except None<T>
         }
         const valueValue = `${value}_value`.replaceAll('.', '_');
@@ -844,7 +858,7 @@ export class OptionConvertor extends BaseArgConvertor {
         this.typeConvertor.convertorSerialize(param, this.typeConvertor.getObjectAccessor(printer.language, valueValue), printer);
         printer.popIndent();
         printer.print(`}`);
-        if (printer.language == Language.CJ) {
+        if (printer.language == Language.CJ || printer.language == Language.KOTLIN) {
             printer.print('else {');
             printer.pushIndent();
             printer.writeMethodCall(`${param}Serializer`, "writeInt8", ["RuntimeType.UNDEFINED.ordinal"]); // undefined
@@ -860,7 +874,7 @@ export class OptionConvertor extends BaseArgConvertor {
         const statements = [];
         statements.push(writer.makeAssign(runtimeBufferName, undefined, writer.makeCast(writer.makeString(`${deserializerName}.readInt8()`), writer.getRuntimeType()), true));
         const bufferType = this.nativeType();
-        statements.push(writer.makeAssign(bufferName, bufferType, writer.language == Language.CJ ? writer.makeNull() : undefined, true, false));
+        statements.push(writer.makeAssign(bufferName, bufferType, (writer.language == Language.CJ || writer.language == Language.KOTLIN) ? writer.makeNull() : undefined, true, false));
         const thenStatement = new BlockStatement([
             this.typeConvertor.convertorDeserialize(`${bufferName}_`, deserializerName, (expr) => {
                 const receiver = writer.language === Language.CPP
@@ -930,7 +944,7 @@ export class UnionConvertor extends BaseArgConvertor {
             statements.push(writer.makeAssign(`${bufferName}.selector`, undefined, writer.makeString(selectorBuffer), false));
         const branches = this.memberConvertors.map((it, index) => {
             const receiver = this.getObjectAccessor(writer.language, bufferName, { index: `${index}` });
-            const expr = writer.makeString(`${selectorBuffer} == ${index}`);
+            const expr = writer.makeString(`${selectorBuffer} == ${writer.castToInt(index.toString(), 8)}`);
             const stmt = new BlockStatement([
                 writer.makeSetUnionSelector(bufferName, `${index}`),
                 it.convertorDeserialize(`${bufferName}_u`, deserializerName, (expr) => {
@@ -991,8 +1005,9 @@ export class FunctionConvertor extends BaseArgConvertor {
     }
 }
 export class MaterializedClassConvertor extends BaseArgConvertor {
-    constructor(param, declaration) {
+    constructor(library, param, declaration) {
         super(idl.createReferenceType(declaration), [RuntimeType.OBJECT], false, false, param);
+        this.library = library;
         this.declaration = declaration;
     }
     convertorArg(param, writer) {
@@ -1001,18 +1016,71 @@ export class MaterializedClassConvertor extends BaseArgConvertor {
                 return `static_cast<${generatorTypePrefix()}${qualifiedName(this.declaration, "_", "namespace.name")}>(${param})`;
             case Language.JAVA:
             case Language.CJ:
-                return `MaterializedBase.toPeerPtr(${param})`;
+                return `MaterializedBase.toPeerPtr(${writer.escapeKeyword(param)})`;
             default:
                 return `toPeerPtr(${param})`;
         }
     }
     convertorSerialize(param, value, printer) {
-        printer.writeStatement(printer.makeStatement(printer.makeMethodCall(`${param}Serializer`, `write${qualifiedName(this.declaration, "_", "namespace.name")}`, [
+        const accessorRoot = getSerializerName(this.declaration);
+        printer.addFeature(accessorRoot, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
+        printer.writeStaticMethodCall(accessorRoot, 'write', [`${param}Serializer`, value]);
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        const accessorRoot = getSerializerName(this.declaration);
+        writer.addFeature(accessorRoot, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
+        const readStatement = writer.makeCast(writer.makeStaticMethodCall(accessorRoot, "read", [writer.makeString(deserializerName)]), this.declaration);
+        return assigneer(readStatement);
+    }
+    nativeType() {
+        return idl.createReferenceType(this.declaration);
+    }
+    interopType() {
+        return idl.IDLPointerType;
+    }
+    isPointerType() {
+        return false;
+    }
+    unionDiscriminator(value, index, writer, duplicates) {
+        if (idl.isInterface(this.declaration)) {
+            if (this.declaration.subkind === idl.IDLInterfaceSubkind.Class) {
+                return writer.discriminatorFromExpressions(value, RuntimeType.OBJECT, [writer.instanceOf(this, value, duplicates)]);
+            }
+            if (this.declaration.subkind === idl.IDLInterfaceSubkind.Interface) {
+                const uniqueFields = this.declaration.properties.filter(it => !duplicates.has(it.name));
+                return this.discriminatorFromFields(value, writer, uniqueFields, it => it.name, it => it.isOptional, duplicates);
+            }
+        }
+    }
+}
+export class ExternalTypeConvertor extends BaseArgConvertor {
+    constructor(library, param, declaration) {
+        super(idl.createReferenceType(declaration), [RuntimeType.OBJECT], false, false, param);
+        this.library = library;
+        this.declaration = declaration;
+        console.log(`ExternalType convertor for type: ${declaration.name}`);
+    }
+    convertorArg(param, writer) {
+        const lang = writer.language;
+        switch (lang) {
+            case Language.CPP:
+                return `static_cast<${generatorTypePrefix()}${qualifiedName(this.declaration, "_", "namespace.name")}>(${param})`;
+            default:
+                return `extractors.${getExtractorName(this.declaration, lang, true)}(${param})`;
+        }
+    }
+    convertorSerialize(param, value, printer) {
+        const accessor = getSerializerName(this.declaration);
+        printer.addFeature(accessor, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
+        printer.writeStatement(printer.makeStatement(printer.makeStaticMethodCall(accessor, 'write', [
+            printer.makeString(`${param}Serializer`),
             printer.makeString(value)
         ])));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
-        const readStatement = writer.makeCast(writer.makeMethodCall(`${deserializerName}`, `read${qualifiedName(this.declaration, "_", "namespace.name")}`, []), this.declaration);
+        const accessor = getSerializerName(this.declaration);
+        writer.addFeature(accessor, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
+        const readStatement = writer.makeCast(writer.makeStaticMethodCall(accessor, 'read', [writer.makeString(deserializerName)]), this.declaration);
         return assigneer(readStatement);
     }
     nativeType() {
@@ -1063,10 +1131,11 @@ export class ImportTypeConvertor extends BaseArgConvertor {
     }
 }
 export class CallbackConvertor extends BaseArgConvertor {
-    constructor(library, param, decl) {
+    constructor(library, param, decl, interopModuleName) {
         super(idl.createReferenceType(decl), [RuntimeType.FUNCTION], false, true, param);
         this.library = library;
         this.decl = decl;
+        this.interopModuleName = interopModuleName;
     }
     get isTransformed() {
         return this.decl !== this.transformedDecl;
@@ -1104,10 +1173,72 @@ export class CallbackConvertor extends BaseArgConvertor {
             });
             return assigneer(writer.makeString(`{${resourceReadExpr.asString()}, ${callReadExpr.asString()}, ${callSyncReadExpr.asString()}}`));
         }
-        let result = writer.makeString(`${deserializerName}.read${this.library.getInteropName(this.transformedDecl)}(${useSyncVersion ? 'true' : ''})`);
-        if (this.isTransformed)
-            result = writer.makeMethodCall(`CallbackTransformer`, `transformTo${this.library.getInteropName(this.decl)}`, [result]);
-        return assigneer(result);
+        const resourceName = bufferName + "_resource";
+        const callName = bufferName + "_call";
+        const callSyncName = bufferName + '_callSync';
+        const argsSerializer = bufferName + "_args";
+        const continuationValueName = bufferName + "_continuationValue";
+        const continuationCallbackName = bufferName + "_continuationCallback";
+        const statements = [];
+        statements.push(writer.makeAssign(resourceName, idl.createReferenceType("CallbackResource"), writer.makeMethodCall(deserializerName, 'readCallbackResource', []), true));
+        statements.push(writer.makeAssign(callName, idl.IDLPointerType, writer.makeMethodCall(deserializerName, `readPointer`, []), true));
+        statements.push(writer.makeAssign(callSyncName, idl.IDLPointerType, writer.makeMethodCall(deserializerName, 'readPointer', []), true));
+        const callbackSignature = new NamedMethodSignature(this.decl.returnType, this.decl.parameters.map(it => idl.maybeOptional(it.type, it.isOptional)), this.decl.parameters.map(it => it.name));
+        const hasContinuation = !idl.isVoidType(this.decl.returnType);
+        let continuation = [];
+        if (hasContinuation) {
+            const continuationReference = this.library.createContinuationCallbackReference(this.decl.returnType);
+            const continuationConvertor = this.library.typeConvertor(continuationCallbackName, continuationReference);
+            const returnType = this.decl.returnType;
+            const optionalReturnType = idl.createOptionalType(this.decl.returnType);
+            continuation = [
+                writer.language == Language.CJ ?
+                    writer.makeAssign(continuationValueName, undefined, writer.makeString(`${writer.getNodeName(this.decl.returnType).replace(/[\<\>]/g, '')}Holder(None<${writer.getNodeName(this.decl.returnType)}>)`), true, true) :
+                    writer.makeAssign(continuationValueName, optionalReturnType, undefined, true, false),
+                writer.makeAssign(continuationCallbackName, continuationReference, writer.makeLambda(new NamedMethodSignature(idl.IDLVoidType, [returnType], [`value`]), [
+                    writer.language == Language.CJ ?
+                        writer.makeAssign(`${continuationValueName}.value`, undefined, writer.makeString(`value`), false) :
+                        writer.makeAssign(continuationValueName, undefined, writer.makeString(`value`), false)
+                ]), true),
+                new ProxyStatement(writer => {
+                    continuationConvertor.convertorSerialize(argsSerializer, continuationCallbackName, writer);
+                }),
+            ];
+        }
+        const result = writer.makeLambda(callbackSignature, [
+            writer.makeAssign(`${argsSerializer}Serializer`, idl.createReferenceType('SerializerBase'), writer.makeMethodCall('SerializerBase', 'hold', []), true),
+            new ExpressionStatement(writer.makeMethodCall(`${argsSerializer}Serializer`, `writeInt32`, [writer.makeString(`${resourceName}.resourceId`)])),
+            new ExpressionStatement(writer.makeMethodCall(`${argsSerializer}Serializer`, `writePointer`, [writer.makeString(callName)])),
+            new ExpressionStatement(writer.makeMethodCall(`${argsSerializer}Serializer`, `writePointer`, [writer.makeString(callSyncName)])),
+            ...this.decl.parameters.map(it => {
+                const convertor = this.library.typeConvertor(it.name, it.type, it.isOptional);
+                return new ProxyStatement((writer) => {
+                    convertor.convertorSerialize(argsSerializer, writer.escapeKeyword(it.name), writer);
+                });
+            }),
+            ...continuation,
+            new ExpressionStatement(useSyncVersion
+                ? writer.makeNativeCall(this.interopModuleName, `_CallCallbackSync`, [
+                    writer.makeString(generateCallbackKindValue(this.decl).toString()),
+                    writer.makeSerializedBufferGetter(`${argsSerializer}Serializer`),
+                    writer.makeString(`${argsSerializer}Serializer.length()`),
+                ])
+                : writer.makeNativeCall(this.interopModuleName, `_CallCallback`, [
+                    writer.makeString(generateCallbackKindValue(this.decl).toString()),
+                    writer.makeSerializedBufferGetter(`${argsSerializer}Serializer`),
+                    writer.makeString(`${argsSerializer}Serializer.length()`),
+                ])),
+            new ExpressionStatement(writer.makeMethodCall(`${argsSerializer}Serializer`, `release`, [])),
+            writer.makeReturn(hasContinuation
+                ? writer.makeCast(writer.language == Language.CJ ?
+                    writer.makeString(`${continuationValueName}.value`) :
+                    writer.makeString(continuationValueName), this.decl.returnType)
+                : undefined),
+        ]);
+        return writer.makeBlock([
+            ...statements,
+            assigneer(result)
+        ], false);
     }
     nativeType() {
         return idl.createReferenceType(this.decl);

package/build/lib/src/LanguageWriters/LanguageWriter.d.ts

@@ -33,8 +33,8 @@ export declare class NewObjectExpression implements LanguageExpression {
     asString(): string;
 }
 export declare class FunctionCallExpression implements LanguageExpression {
-    private name;
-    private params;
+    protected name: string;
+    protected params: LanguageExpression[];
     constructor(name: string, params: LanguageExpression[]);
     asString(): string;
 }
@@ -44,6 +44,14 @@ export declare class MethodCallExpression extends FunctionCallExpression {
     constructor(receiver: string, method: string, params: LanguageExpression[], nullable?: boolean);
     asString(): string;
 }
+export declare class MethodStaticCallExpression extends MethodCallExpression {
+    receiver: string;
+    nullable: boolean;
+    constructor(receiver: string, method: string, params: LanguageExpression[], nullable?: boolean);
+}
+export declare class ThisCallExpression extends FunctionCallExpression {
+    constructor(params: LanguageExpression[]);
+}
 export declare class FieldAccessExpression {
     receiver: string;
     field: string;
@@ -161,13 +169,23 @@ export declare enum MethodModifier {
     SETTER = 7,
     THROWS = 8,
     FREE = 9,
-    FORCE_CONTEXT = 10
+    FORCE_CONTEXT = 10,
+    OVERRIDE = 11
 }
 export declare enum ClassModifier {
     PUBLIC = 0,
     PRIVATE = 1,
     PROTECTED = 2
 }
+export declare enum DelegationType {
+    THIS = 0,
+    SUPER = 1
+}
+export interface DelegationCall {
+    delegationType?: DelegationType;
+    delegationName?: string;
+    delegationArgs: LanguageExpression[];
+}
 export declare class Field {
     name: string;
     type: idl.IDLType;
@@ -189,6 +207,7 @@ export declare class PrintHint {
     static AsConstPointer: PrintHint;
     static AsValue: PrintHint;
     static AsConstReference: PrintHint;
+    static AsReference: PrintHint;
 }
 type MethodArgPrintHintOrNone = PrintHint | undefined;
 export declare class MethodSignature {
@@ -230,6 +249,8 @@ export declare abstract class LanguageWriter {
     language: Language);
     indentDepth(): number;
     maybeSemicolon(): string;
+    features: [string, string][];
+    addFeature(feature: string, module: string): void;
     abstract writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[], generics?: string[], isDeclared?: boolean, isExport?: boolean): void;
     abstract writeEnum(name: string, members: {
         name: string;
@@ -245,7 +266,7 @@ export declare abstract class LanguageWriter {
     abstract writeFunctionDeclaration(name: string, signature: MethodSignature, generics?: string[]): void;
     abstract writeFunctionImplementation(name: string, signature: MethodSignature, op: (writer: this) => void, generics?: string[]): void;
     abstract writeMethodDeclaration(name: string, signature: MethodSignature, modifiers?: MethodModifier[]): void;
-    abstract writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
+    abstract writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, delegationCall?: DelegationCall, modifiers?: MethodModifier[]): void;
     abstract writeMethodImplementation(method: Method, op: (writer: this) => void): void;
     abstract writeProperty(propName: string, propType: idl.IDLType, modifiers: FieldModifier[], getter?: {
         method: Method;
@@ -293,6 +314,7 @@ export declare abstract class LanguageWriter {
     writeSetterImplementation(method: Method, op: (writer: this) => void): void;
     writeSuperCall(params: string[]): void;
     writeMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;
+    writeStaticMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;
     writeStatement(stmt: LanguageStatement): void;
     writeStatements(...statements: LanguageStatement[]): void;
     writeExpressionStatement(smth: LanguageExpression): void;
@@ -307,6 +329,8 @@ export declare abstract class LanguageWriter {
     makeNewObject(objectName: string, params?: LanguageExpression[]): LanguageExpression;
     makeFunctionCall(name: string | LanguageExpression, params: LanguageExpression[]): LanguageExpression;
     makeMethodCall(receiver: string, method: string, params: LanguageExpression[], nullable?: boolean): LanguageExpression;
+    makeThisCall(params: LanguageExpression[]): LanguageExpression;
+    makeStaticMethodCall(receiver: string, method: string, params: LanguageExpression[], nullable?: boolean): LanguageExpression;
     makeFieldAccess(receiver: string, method: string, nullable?: boolean): LanguageExpression;
     makeNativeCall(nativeModule: NativeModuleType, method: string, params: LanguageExpression[], nullable?: boolean): LanguageExpression;
     makeBlock(statements: LanguageStatement[], inScope?: boolean): BlockStatement;
@@ -370,6 +394,7 @@ export declare abstract class LanguageWriter {
     castToInt(value: string, bitness: 8 | 32): string;
     castToBoolean(value: string): string;
     makeCallIsObject(value: string): LanguageExpression;
+    makeStaticBlock(op: (writer: LanguageWriter) => void): void;
     instanceOf(convertor: ArgConvertor, value: string, _duplicateMembers?: Set<string>): LanguageExpression;
     typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;
     stringifyTypeOrEmpty(type: idl.IDLType | undefined): string;

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

@@ -73,6 +73,18 @@ export class MethodCallExpression extends FunctionCallExpression {
         return `${this.receiver}${this.nullable ? "?" : ""}.${super.asString()}`;
     }
 }
+export class MethodStaticCallExpression extends MethodCallExpression {
+    constructor(receiver, method, params, nullable = false) {
+        super(receiver, method, params, nullable);
+        this.receiver = receiver;
+        this.nullable = nullable;
+    }
+}
+export class ThisCallExpression extends FunctionCallExpression {
+    constructor(params) {
+        super("this", params);
+    }
+}
 export class FieldAccessExpression {
     constructor(receiver, field, nullable = false) {
         this.receiver = receiver;
@@ -283,6 +295,9 @@ export class LambdaExpression {
                 stmt.write(writer);
             }
         }
+        writer.features.forEach(([feature, module]) => {
+            this.originalWriter.addFeature(feature, module);
+        });
         return (this.body ? ((_a = this.body) === null || _a === void 0 ? void 0 : _a.length) > 1 ? '\n' : '' : '').concat(writer.getOutput()
             .filter(line => line !== "")
             .map(line => indentedBy(line.endsWith('{') || line.endsWith('}') || line.endsWith(';') ? line : `${line};`, 1))
@@ -320,6 +335,7 @@ export var MethodModifier;
     MethodModifier[MethodModifier["THROWS"] = 8] = "THROWS";
     MethodModifier[MethodModifier["FREE"] = 9] = "FREE";
     MethodModifier[MethodModifier["FORCE_CONTEXT"] = 10] = "FORCE_CONTEXT";
+    MethodModifier[MethodModifier["OVERRIDE"] = 11] = "OVERRIDE";
 })(MethodModifier || (MethodModifier = {}));
 export var ClassModifier;
 (function (ClassModifier) {
@@ -327,6 +343,11 @@ export var ClassModifier;
     ClassModifier[ClassModifier["PRIVATE"] = 1] = "PRIVATE";
     ClassModifier[ClassModifier["PROTECTED"] = 2] = "PROTECTED";
 })(ClassModifier || (ClassModifier = {}));
+export var DelegationType;
+(function (DelegationType) {
+    DelegationType[DelegationType["THIS"] = 0] = "THIS";
+    DelegationType[DelegationType["SUPER"] = 1] = "SUPER";
+})(DelegationType || (DelegationType = {}));
 export class Field {
     constructor(name, type, modifiers = []) {
         this.name = name;
@@ -355,6 +376,7 @@ PrintHint.AsPointer = new PrintHint('AsPointer');
 PrintHint.AsConstPointer = new PrintHint('AsConstPointer');
 PrintHint.AsValue = new PrintHint('AsValue');
 PrintHint.AsConstReference = new PrintHint('AsConstReference');
+PrintHint.AsReference = new PrintHint('AsReference');
 export class MethodSignature {
     constructor(returnType, args, defaults = undefined, argsModifiers = undefined, printHints, argNames) {
         this.returnType = returnType;
@@ -410,11 +432,15 @@ export class LanguageWriter {
         this.resolver = resolver;
         this.language = language;
         this.namespaceStack = [];
+        this.features = [];
     }
     indentDepth() {
         return this.printer.indentDepth();
     }
     maybeSemicolon() { return ";"; }
+    addFeature(feature, module) {
+        this.features.push([feature, module]);
+    }
     // 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) {
@@ -441,12 +467,17 @@ export class LanguageWriter {
         var _a;
         this.writeMethodImplementation(new Method(method.name, method.signature, [MethodModifier.SETTER].concat((_a = method.modifiers) !== null && _a !== void 0 ? _a : [])), op);
     }
+    // Deprecated
+    // Use instead declarationCall parameter in writeConstructorImplementation(...)
     writeSuperCall(params) {
         this.printer.print(`super(${params.join(", ")})${this.maybeSemicolon()}`);
     }
     writeMethodCall(receiver, method, params, nullable = false) {
         this.printer.print(`${receiver}${nullable ? "?" : ""}.${method}(${params.join(", ")})`);
     }
+    writeStaticMethodCall(receiver, method, params, nullable = false) {
+        this.writeMethodCall(receiver, method, params, nullable);
+    }
     writeStatement(stmt) {
         stmt.write(this);
     }
@@ -497,6 +528,14 @@ export class LanguageWriter {
     makeMethodCall(receiver, method, params, nullable) {
         return new MethodCallExpression(receiver, method, params, nullable);
     }
+    // Deprecated
+    // Use instead declarationCall parameter in writeConstructorImplementation(...) with DelegationType.THIS
+    makeThisCall(params) {
+        return new ThisCallExpression(params);
+    }
+    makeStaticMethodCall(receiver, method, params, nullable) {
+        return new MethodStaticCallExpression(receiver, method, params, nullable);
+    }
     makeFieldAccess(receiver, method, nullable) {
         return new FieldAccessExpression(receiver, method, nullable);
     }
@@ -678,6 +717,9 @@ export class LanguageWriter {
     makeCallIsObject(value) {
         return this.makeString(`typeof ${value} === "object"`);
     }
+    makeStaticBlock(op) {
+        op(this);
+    }
     instanceOf(convertor, value, _duplicateMembers) {
         return this.makeString(`${value} instanceof ${this.getNodeName(convertor.idlType)}`);
     }