@idlizer/core 2.1.5 → 2.1.9-arktscgen-4

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;
@@ -263,7 +264,6 @@ export declare class CustomTypeConvertor extends BaseArgConvertor {
     isPointerType(): boolean;
 }
 export declare class OptionConvertor extends BaseArgConvertor {
-    private library;
     type: idl.IDLType;
     private readonly typeConvertor;
     constructor(library: LibraryInterface, param: string, type: idl.IDLType);
@@ -302,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;
@@ -325,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)
@@ -47,7 +51,6 @@ export function isDirectConvertedType(originalType, library) {
         convertor instanceof MapConvertor ||
         convertor instanceof TupleConvertor ||
         convertor instanceof AggregateConvertor ||
-        convertor instanceof UnionConvertor ||
         convertor instanceof OptionConvertor ||
         convertor instanceof ImportTypeConvertor) {
         // try { console.log(`convertor is ${convertor.constructor.name} for ${JSON.stringify(originalType)}`) } catch (e) {}
@@ -438,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);
         });
@@ -464,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));
         }
@@ -549,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;
@@ -717,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()
@@ -728,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;
@@ -809,12 +822,18 @@ export class OptionConvertor extends BaseArgConvertor {
     // TODO: be smarter here, and for smth like Length|undefined or number|undefined pass without serializer.
     constructor(library, param, type) {
         let conv = library.typeConvertor(param, type);
+        let currentConv = conv;
+        while (currentConv instanceof ProxyConvertor) {
+            currentConv = currentConv.convertor;
+        }
+        if (currentConv instanceof OptionConvertor) {
+            conv = currentConv.typeConvertor;
+        }
         let runtimeTypes = conv.runtimeTypes;
         if (!runtimeTypes.includes(RuntimeType.UNDEFINED)) {
             runtimeTypes.push(RuntimeType.UNDEFINED);
         }
         super(idl.createOptionalType(conv.idlType), runtimeTypes, conv.isScoped, true, param);
-        this.library = library;
         this.type = type;
         this.typeConvertor = conv;
     }
@@ -825,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('.', '_');
@@ -839,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
@@ -855,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
@@ -925,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) => {
@@ -940,7 +959,7 @@ export class UnionConvertor extends BaseArgConvertor {
             return { expr, stmt };
         });
         statements.push(writer.makeMultiBranchCondition(branches, writer.makeThrowError(`One of the branches for ${bufferName} has to be chosen through deserialisation.`)));
-        statements.push(assigneer(writer.makeCast(writer.makeString(bufferName), this.type)));
+        statements.push(assigneer(writer.makeCast(writer.makeString(bufferName), this.nativeType())));
         return new BlockStatement(statements, false);
     }
     nativeType() {
@@ -986,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) {
@@ -996,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() {
@@ -1058,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;
@@ -1099,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;
@@ -242,10 +263,10 @@ export declare abstract class LanguageWriter {
     }, op?: (writer: this) => void): void;
     abstract writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[], generics?: string[], isDeclared?: boolean): void;
     abstract writeFieldDeclaration(name: string, type: idl.IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
-    abstract writeFunctionDeclaration(name: string, signature: MethodSignature): void;
-    abstract writeFunctionImplementation(name: string, signature: MethodSignature, op: (writer: this) => void): void;
+    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;
@@ -377,11 +402,16 @@ export declare abstract class LanguageWriter {
      * Writes `namespace <namespace> {` and adds extra indent
      * @param namespace Namespace to begin
      */
-    pushNamespace(namespace: string, ident?: boolean): void;
+    pushNamespace(namespace: string, options: {
+        ident: boolean;
+        isDeclared?: boolean;
+    }): void;
     /**
      * Writes closing brace of namespace block and removes one level of indent
      */
-    popNamespace(ident?: boolean): void;
+    popNamespace(options: {
+        ident: boolean;
+    }): void;
     static _isReferenceRelativeToNamespaces: boolean;
     static get isReferenceRelativeToNamespaces(): boolean;
     static relativeReferences<T>(isRelative: boolean, op: () => T): T;