@idlizer/core 2.1.2 → 2.1.5

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

@@ -123,7 +123,7 @@ export declare class BigIntToU64Convertor extends BaseArgConvertor {
     isPointerType(): boolean;
 }
 export declare class ObjectConvertor extends BaseArgConvertor {
-    constructor(param: string);
+    constructor(param: string, type: idl.IDLType);
     convertorArg(param: string, writer: LanguageWriter): string;
     convertorSerialize(param: string, value: string, printer: LanguageWriter): void;
     convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
@@ -293,8 +293,7 @@ export declare class UnionConvertor extends BaseArgConvertor {
 }
 export declare class FunctionConvertor extends BaseArgConvertor {
     private library;
-    protected type: idl.IDLReferenceType;
-    constructor(library: LibraryInterface, param: string, type: idl.IDLReferenceType);
+    constructor(library: LibraryInterface, param: string);
     convertorArg(param: string, writer: LanguageWriter): string;
     convertorSerialize(param: string, value: string, writer: LanguageWriter): void;
     convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
@@ -334,6 +333,7 @@ export declare class CallbackConvertor extends BaseArgConvertor {
     convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter, useSyncVersion?: boolean): LanguageStatement;
     nativeType(): idl.IDLType;
     isPointerType(): boolean;
+    unionDiscriminator(value: string, index: number, writer: LanguageWriter, duplicates: Set<string>): LanguageExpression | undefined;
 }
 export declare const CallbackKind = "CallbackKind";
 export declare function generateCallbackKindName(callback: idl.IDLCallback): string;

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

@@ -16,7 +16,7 @@ import * as idl from "../idl";
 import { Language } from "../Language";
 import { BlockStatement, PrintHint, StringExpression, MethodModifier } from "./LanguageWriter";
 import { RuntimeType } from "./common";
-import { generatorTypePrefix } from "../config";
+import { generatorConfiguration, generatorTypePrefix } from "../config";
 import { hashCodeFromString, warn } from "../util";
 import { UnionRuntimeTypeChecker } from "../peer-generation/unions";
 import { CppConvertor, CppNameConvertor } from "./convertors/CppConvertors";
@@ -29,9 +29,10 @@ export function isDirectConvertedType(originalType, library) {
         return true; // TODO: is it correct?
     if (debug)
         console.log(`IDL type ${idl.DebugUtils.debugPrintType(originalType)}`);
-    if (originalType == idl.IDLInteropReturnBufferType) {
+    if (originalType == idl.IDLInteropReturnBufferType)
         return false;
-    }
+    if (originalType == idl.IDLThisType)
+        return true; /* Because this type for native is pointer, right? */
     if (originalType == idl.IDLSerializerBuffer)
         return true;
     let convertor = library.typeConvertor("x", originalType, false);
@@ -46,7 +47,10 @@ export function isDirectConvertedType(originalType, library) {
         convertor instanceof MapConvertor ||
         convertor instanceof TupleConvertor ||
         convertor instanceof AggregateConvertor ||
-        convertor instanceof OptionConvertor) {
+        convertor instanceof UnionConvertor ||
+        convertor instanceof OptionConvertor ||
+        convertor instanceof ImportTypeConvertor) {
+        // try { console.log(`convertor is ${convertor.constructor.name} for ${JSON.stringify(originalType)}`) } catch (e) {}
         return false;
     }
     let type = convertor.interopType();
@@ -71,7 +75,8 @@ export function isVMContextMethod(method) {
     var _a, _b;
     return !!idl.asPromise(method.signature.returnType) ||
         !!((_a = method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(MethodModifier.THROWS)) ||
-        !!((_b = method.modifiers) === null || _b === void 0 ? void 0 : _b.includes(MethodModifier.FORCE_CONTEXT));
+        !!((_b = method.modifiers) === null || _b === void 0 ? void 0 : _b.includes(MethodModifier.FORCE_CONTEXT)) ||
+        generatorConfiguration().forceContext.includes(method.name);
 }
 export function isDirectMethod(method, library) {
     if (isVMContextMethod(method)) {
@@ -218,20 +223,18 @@ export class EnumConvertor extends BaseArgConvertor {
         this.enumEntry = enumEntry;
     }
     convertorArg(param, writer) {
-        return writer.makeEnumCast(this.enumEntry, writer.escapeKeyword(param));
+        return writer.i32FromEnum(writer.makeString(writer.escapeKeyword(param)), this.enumEntry).asString();
     }
     convertorSerialize(param, value, writer) {
-        writer.writeMethodCall(`${param}Serializer`, "writeInt32", [writer.makeEnumCast(this.enumEntry, value)]);
+        writer.writeMethodCall(`${param}Serializer`, "writeInt32", [writer.i32FromEnum(writer.makeString(value), this.enumEntry).asString()]);
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
         const readExpr = writer.makeMethodCall(`${deserializerName}`, "readInt32", []);
-        const enumExpr = idl.isStringEnum(this.enumEntry)
-            ? writer.enumFromOrdinal(readExpr, idl.createReferenceType(this.enumEntry))
-            : writer.makeCast(readExpr, idl.createReferenceType(this.enumEntry));
+        const enumExpr = writer.enumFromI32(readExpr, this.enumEntry);
         return assigneer(enumExpr);
     }
     nativeType() {
-        return idl.createReferenceType(this.enumEntry);
+        return this.idlType;
     }
     interopType() {
         return idl.IDLI32Type;
@@ -306,24 +309,24 @@ export class BigIntToU64Convertor extends BaseArgConvertor {
         return writer.escapeKeyword(param);
     }
     convertorSerialize(param, value, printer) {
-        printer.writeMethodCall(`${param}Serializer`, "writeUInt64", [value]);
+        printer.writeMethodCall(`${param}Serializer`, "writeInt64", [value]);
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
-        return assigneer(writer.makeCast(writer.makeString(`${deserializerName}.readUInt64()`), this.idlType, { optional: false }));
+        return assigneer(writer.makeCast(writer.makeString(`${deserializerName}.readInt64()`), this.idlType, { optional: false }));
     }
     nativeType() {
-        return idl.IDLU64Type;
+        return idl.IDLI64Type;
     }
     interopType() {
-        return idl.IDLU64Type;
+        return idl.IDLI64Type;
     }
     isPointerType() {
         return false;
     }
 }
 export class ObjectConvertor extends BaseArgConvertor {
-    constructor(param) {
-        super(idl.IDLAnyType, [
+    constructor(param, type) {
+        super(type, [
             RuntimeType.BIGINT,
             RuntimeType.BOOLEAN,
             RuntimeType.FUNCTION,
@@ -332,7 +335,6 @@ export class ObjectConvertor extends BaseArgConvertor {
             RuntimeType.OBJECT,
             RuntimeType.STRING,
             RuntimeType.SYMBOL,
-            RuntimeType.UNDEFINED
         ], false, true, param);
     }
     convertorArg(param, writer) {
@@ -463,7 +465,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], "$NOT TO BE PRINTED%")
+                    ? idl.createUnionType([idl.IDLUndefinedType, prop.type])
                     : prop.type;
                 return writer.makeAssign(`${bufferName}_${prop.name}`, memberType, expr, true, true);
             }, writer));
@@ -558,7 +560,7 @@ export class InterfaceConvertor extends BaseArgConvertor {
     interopType() {
         // Actually shouldn't be used!
         // throw new Error("Must never be used")
-        return idl.IDLObjectType;
+        return idl.IDLSerializerBuffer;
     }
     isPointerType() {
         return true;
@@ -601,7 +603,7 @@ export class ArrayConvertor extends BaseArgConvertor {
         printer.writeStatement(printer.makeLoop(loopCounter, valueLength));
         printer.pushIndent();
         printer.writeStatement(printer.makeAssign(`${value}_element`, this.elementType, printer.makeArrayAccess(value, loopCounter), true));
-        this.elementConvertor.convertorSerialize(param, this.elementConvertor.getObjectAccessor(printer.language, `${value}_element`), printer);
+        this.elementConvertor.convertorSerialize(param, `${value}_element`, printer);
         printer.popIndent();
         printer.print(`}`);
     }
@@ -820,7 +822,7 @@ export class OptionConvertor extends BaseArgConvertor {
         throw new Error("Must never be used");
     }
     convertorSerialize(param, value, printer) {
-        const valueType = `${value}_type`;
+        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) {
@@ -832,8 +834,9 @@ export class OptionConvertor extends BaseArgConvertor {
         if (printer.language == Language.CJ) {
             printer.writeMethodCall(`${param}Serializer`, "writeInt8", ["RuntimeType.OBJECT.ordinal"]); // everything is object, except None<T>
         }
-        printer.writeStatement(printer.makeAssign(`${value}_value`, undefined, printer.makeValueFromOption(value, this.typeConvertor), true));
-        this.typeConvertor.convertorSerialize(param, this.typeConvertor.getObjectAccessor(printer.language, `${value}_value`), printer);
+        const valueValue = `${value}_value`.replaceAll('.', '_');
+        printer.writeStatement(printer.makeAssign(valueValue, undefined, printer.makeValueFromOption(value, this.typeConvertor), true));
+        this.typeConvertor.convertorSerialize(param, this.typeConvertor.getObjectAccessor(printer.language, valueValue), printer);
         printer.popIndent();
         printer.print(`}`);
         if (printer.language == Language.CJ) {
@@ -958,11 +961,10 @@ export class UnionConvertor extends BaseArgConvertor {
     }
 }
 export class FunctionConvertor extends BaseArgConvertor {
-    constructor(library, param, type) {
+    constructor(library, param) {
         // TODO: pass functions as integers to native side.
         super(idl.IDLFunctionType, [RuntimeType.FUNCTION], false, false, param);
         this.library = library;
-        this.type = type;
     }
     convertorArg(param, writer) {
         return writer.language == Language.CPP ? `makeArkFunctionFromId(${param})` : `registerCallback(${param})`;
@@ -971,7 +973,7 @@ export class FunctionConvertor extends BaseArgConvertor {
         writer.writeMethodCall(`${param}Serializer`, "writeFunction", [value]);
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
-        return assigneer(writer.makeCast(writer.makeString(`${deserializerName}.readFunction()`), this.type, { optional: true }));
+        return assigneer(writer.makeCast(writer.makeString(`${deserializerName}.readFunction()`), idl.IDLFunctionType, { optional: true }));
     }
     nativeType() {
         return idl.IDLFunctionType;
@@ -991,7 +993,7 @@ export class MaterializedClassConvertor extends BaseArgConvertor {
     convertorArg(param, writer) {
         switch (writer.language) {
             case Language.CPP:
-                return `static_cast<${generatorTypePrefix()}${qualifiedName(this.declaration, "_")}>(${param})`;
+                return `static_cast<${generatorTypePrefix()}${qualifiedName(this.declaration, "_", "namespace.name")}>(${param})`;
             case Language.JAVA:
             case Language.CJ:
                 return `MaterializedBase.toPeerPtr(${param})`;
@@ -1000,12 +1002,12 @@ export class MaterializedClassConvertor extends BaseArgConvertor {
         }
     }
     convertorSerialize(param, value, printer) {
-        printer.writeStatement(printer.makeStatement(printer.makeMethodCall(`${param}Serializer`, `write${qualifiedName(this.declaration, "_")}`, [
+        printer.writeStatement(printer.makeStatement(printer.makeMethodCall(`${param}Serializer`, `write${qualifiedName(this.declaration, "_", "namespace.name")}`, [
             printer.makeString(value)
         ])));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
-        const readStatement = writer.makeCast(writer.makeMethodCall(`${deserializerName}`, `read${qualifiedName(this.declaration, "_")}`, []), idl.createReferenceType(this.declaration));
+        const readStatement = writer.makeCast(writer.makeMethodCall(`${deserializerName}`, `read${qualifiedName(this.declaration, "_", "namespace.name")}`, []), this.declaration);
         return assigneer(readStatement);
     }
     nativeType() {
@@ -1108,6 +1110,10 @@ export class CallbackConvertor extends BaseArgConvertor {
     isPointerType() {
         return true;
     }
+    unionDiscriminator(value, index, writer, duplicates) {
+        // We serialize callbacks as table offsets, so don't need to discriminate them. Runtime type check is enough
+        return writer.makeUnionVariantCondition(this, value, `${value}_type`, RuntimeType[RuntimeType.FUNCTION]);
+    }
 }
 ////////////////////////////////////////////////////////////////////////////////
 // UTILS

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

@@ -114,8 +114,11 @@ export declare class CheckOptionalStatement implements LanguageStatement {
 }
 export declare class TsEnumEntityStatement implements LanguageStatement {
     private readonly enumEntity;
-    private readonly isExport;
-    constructor(enumEntity: idl.IDLEnum, isExport: boolean);
+    private readonly options;
+    constructor(enumEntity: idl.IDLEnum, options: {
+        isExport: boolean;
+        isDeclare: boolean;
+    });
     write(writer: LanguageWriter): void;
     private maybeQuoted;
 }
@@ -134,6 +137,9 @@ export declare abstract class LambdaExpression implements LanguageExpression {
     abstract asString(): string;
     bodyAsString(): string;
 }
+export declare enum ArgumentModifier {
+    OPTIONAL = 0
+}
 export declare enum FieldModifier {
     READONLY = 0,
     PRIVATE = 1,
@@ -191,16 +197,18 @@ export declare class MethodSignature {
     defaults: stringOrNone[] | undefined;
     printHints?: MethodArgPrintHintOrNone[] | undefined;
     argNames?: string[] | undefined;
-    constructor(returnType: idl.IDLType, args: idl.IDLType[], defaults?: stringOrNone[] | undefined, printHints?: MethodArgPrintHintOrNone[] | undefined, argNames?: string[] | undefined);
+    argsModifiers: ArgumentModifier[][] | undefined;
+    constructor(returnType: idl.IDLType, args: idl.IDLType[], defaults?: stringOrNone[] | undefined, argsModifiers?: (ArgumentModifier[] | ArgumentModifier | undefined)[] | undefined, printHints?: MethodArgPrintHintOrNone[] | undefined, argNames?: string[] | undefined);
     argName(index: number): string;
     argDefault(index: number): string | undefined;
+    isArgOptional(index: number): boolean;
     retHint(): PrintHint | undefined;
     argHint(index: number): PrintHint | undefined;
     toString(): string;
 }
 export declare class NamedMethodSignature extends MethodSignature {
     argsNames: string[];
-    constructor(returnType: idl.IDLType, args?: idl.IDLType[], argsNames?: string[], defaults?: stringOrNone[] | undefined, printHints?: MethodArgPrintHintOrNone[]);
+    constructor(returnType: idl.IDLType, args?: idl.IDLType[], argsNames?: string[], defaults?: stringOrNone[] | undefined, argsModifiers?: (ArgumentModifier[] | ArgumentModifier | undefined)[] | undefined, printHints?: MethodArgPrintHintOrNone[]);
     static make(returnType: idl.IDLType, args: {
         name: string;
         type: idl.IDLType;
@@ -228,7 +236,10 @@ export declare abstract class LanguageWriter {
         alias?: string;
         stringId: string | undefined;
         numberId: number;
-    }[], op?: (writer: this) => void): void;
+    }[], options: {
+        isExport: boolean;
+        isDeclare?: boolean;
+    }, 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;
@@ -252,7 +263,7 @@ export declare abstract class LanguageWriter {
     abstract makeCheckOptional(optional: LanguageExpression, doStatement: LanguageStatement): LanguageStatement;
     abstract makeRuntimeType(rt: RuntimeType): LanguageExpression;
     abstract getObjectAccessor(convertor: ArgConvertor, value: string, args?: ObjectArgs): string;
-    abstract makeCast(value: LanguageExpression, type: idl.IDLType, options?: MakeCastOptions): LanguageExpression;
+    abstract makeCast(value: LanguageExpression, node: idl.IDLNode, options?: MakeCastOptions): LanguageExpression;
     makeTypeCast(value: LanguageExpression, type: idl.IDLType, options?: MakeCastOptions): LanguageExpression;
     abstract writePrintLog(message: string): void;
     abstract makeUndefined(): LanguageExpression;
@@ -269,9 +280,8 @@ export declare abstract class LanguageWriter {
     abstract makeTupleAssign(receiver: string, tupleFields: string[]): LanguageStatement;
     abstract get supportedModifiers(): MethodModifier[];
     abstract get supportedFieldModifiers(): FieldModifier[];
-    abstract enumFromOrdinal(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
-    abstract ordinalFromEnum(value: LanguageExpression, enumReference: idl.IDLType): LanguageExpression;
-    abstract makeEnumCast(enumEntry: idl.IDLEnum, enumName: string): string;
+    abstract enumFromI32(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
+    abstract i32FromEnum(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
     abstract getNodeName(type: idl.IDLNode): string;
     abstract fork(options?: {
         resolver?: ReferenceResolver;
@@ -313,7 +323,6 @@ export declare abstract class LanguageWriter {
     makeUnionVariantCondition(_convertor: ArgConvertor, _valueName: string, valueType: string, type: string, _convertorIndex?: number, _runtimeTypeIndex?: number): LanguageExpression;
     makeUnionVariantCast(value: string, type: string, convertor: ArgConvertor, index?: number): LanguageExpression;
     makeUnionTypeDefaultInitializer(): LanguageExpression;
-    makeRuntimeTypeGetterCall(value: string): LanguageExpression;
     makeArrayResize(array: string, arrayType: string, length: string, deserializer: string): LanguageStatement;
     makeMapResize(mapTypeName: string, keyType: idl.IDLType, valueType: idl.IDLType, map: string, size: string, deserializer: string): LanguageStatement;
     makeMapSize(map: string): LanguageExpression;
@@ -345,7 +354,10 @@ export declare abstract class LanguageWriter {
         targetType: (writer: LanguageWriter) => string;
     }, value: string, accessors: string[], duplicates: Set<string>): LanguageExpression;
     makeIsTypeCall(value: string, decl: idl.IDLInterface): LanguageExpression;
-    makeEnumEntity(enumEntity: idl.IDLEnum, isExport: boolean): LanguageStatement;
+    makeEnumEntity(enumEntity: idl.IDLEnum, options: {
+        isExport: boolean;
+        isDeclare?: boolean;
+    }): LanguageStatement;
     makeFieldModifiersList(modifiers: FieldModifier[] | undefined, customFieldFilter?: (field: FieldModifier) => boolean): string;
     escapeKeyword(keyword: string): string;
     makeCastCustomObject(customName: string, _isGenericType: boolean): LanguageExpression;
@@ -360,8 +372,6 @@ export declare abstract class LanguageWriter {
     makeCallIsObject(value: string): LanguageExpression;
     instanceOf(convertor: ArgConvertor, value: string, _duplicateMembers?: Set<string>): LanguageExpression;
     typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;
-    makeLengthSerializer(serializer: string, value: string): LanguageStatement | undefined;
-    makeLengthDeserializer(deserializer: string): LanguageStatement | undefined;
     stringifyTypeOrEmpty(type: idl.IDLType | undefined): string;
     /**
      * Writes `namespace <namespace> {` and adds extra indent
@@ -372,6 +382,9 @@ export declare abstract class LanguageWriter {
      * Writes closing brace of namespace block and removes one level of indent
      */
     popNamespace(ident?: boolean): void;
+    static _isReferenceRelativeToNamespaces: boolean;
+    static get isReferenceRelativeToNamespaces(): boolean;
+    static relativeReferences<T>(isRelative: boolean, op: () => T): T;
 }
 export declare function mangleMethodName(method: Method, id?: number): string;
 export declare function printMethodDeclaration(printer: IndentedPrinter, retType: string, methodName: string, apiParameters: string[], postfix?: string): void;

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

@@ -231,14 +231,13 @@ export class CheckOptionalStatement {
 }
 // maybe rename or move of fix
 export class TsEnumEntityStatement {
-    constructor(enumEntity, isExport) {
+    constructor(enumEntity, options) {
         this.enumEntity = enumEntity;
-        this.isExport = isExport;
+        this.options = options;
     }
     write(writer) {
         // writer.print(this.enumEntity.comment)
-        idl.getNamespacesPathFor(this.enumEntity).forEach(it => writer.pushNamespace(it.name));
-        writer.print(`${this.isExport ? "export " : ""}enum ${this.enumEntity.name} {`);
+        writer.print(`${this.options.isExport ? "export " : ""}${this.options.isDeclare ? "declare " : ""}enum ${this.enumEntity.name} {`);
         writer.pushIndent();
         this.enumEntity.elements.forEach((member, index) => {
             // writer.print(member.comment)
@@ -253,7 +252,6 @@ export class TsEnumEntityStatement {
         });
         writer.popIndent();
         writer.print(`}`);
-        idl.getNamespacesPathFor(this.enumEntity).forEach(it => writer.popNamespace());
     }
     maybeQuoted(value) {
         if (typeof value == "string")
@@ -294,6 +292,10 @@ export class LambdaExpression {
 ////////////////////////////////////////////////////////////////
 //                         SIGNATURES                         //
 ////////////////////////////////////////////////////////////////
+export var ArgumentModifier;
+(function (ArgumentModifier) {
+    ArgumentModifier[ArgumentModifier["OPTIONAL"] = 0] = "OPTIONAL";
+})(ArgumentModifier || (ArgumentModifier = {}));
 export var FieldModifier;
 (function (FieldModifier) {
     FieldModifier[FieldModifier["READONLY"] = 0] = "READONLY";
@@ -354,12 +356,13 @@ PrintHint.AsConstPointer = new PrintHint('AsConstPointer');
 PrintHint.AsValue = new PrintHint('AsValue');
 PrintHint.AsConstReference = new PrintHint('AsConstReference');
 export class MethodSignature {
-    constructor(returnType, args, defaults = undefined, printHints, argNames) {
+    constructor(returnType, args, defaults = undefined, argsModifiers = undefined, printHints, argNames) {
         this.returnType = returnType;
         this.args = args;
         this.defaults = defaults;
         this.printHints = printHints;
         this.argNames = argNames;
+        this.argsModifiers = argsModifiers === null || argsModifiers === void 0 ? void 0 : argsModifiers.map(it => it === undefined ? [] : Array.isArray(it) ? it : [it]);
     }
     argName(index) {
         var _a, _b;
@@ -369,6 +372,10 @@ export class MethodSignature {
         var _a;
         return (_a = this.defaults) === null || _a === void 0 ? void 0 : _a[index];
     }
+    isArgOptional(index) {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.argsModifiers) === null || _a === void 0 ? void 0 : _a[index]) === null || _b === void 0 ? void 0 : _b.includes(ArgumentModifier.OPTIONAL)) !== null && _c !== void 0 ? _c : false;
+    }
     retHint() {
         var _a;
         return (_a = this.printHints) === null || _a === void 0 ? void 0 : _a[0];
@@ -382,8 +389,8 @@ export class MethodSignature {
     }
 }
 export class NamedMethodSignature extends MethodSignature {
-    constructor(returnType, args = [], argsNames = [], defaults = undefined, printHints) {
-        super(returnType, args, defaults, printHints);
+    constructor(returnType, args = [], argsNames = [], defaults = undefined, argsModifiers = undefined, printHints) {
+        super(returnType, args, defaults, argsModifiers, printHints);
         this.argsNames = argsNames;
     }
     static make(returnType, args) {
@@ -538,9 +545,6 @@ export class LanguageWriter {
     makeUnionTypeDefaultInitializer() {
         return this.makeRuntimeType(RuntimeType.UNDEFINED);
     }
-    makeRuntimeTypeGetterCall(value) {
-        return this.makeFunctionCall("runtimeType", [this.makeString(value)]);
-    }
     makeArrayResize(array, arrayType, length, deserializer) {
         return new ExpressionStatement(new StringExpression(""));
     }
@@ -627,8 +631,8 @@ export class LanguageWriter {
     makeIsTypeCall(value, decl) {
         return this.makeString(`is${decl.name}(${value})`);
     }
-    makeEnumEntity(enumEntity, isExport) {
-        return new TsEnumEntityStatement(enumEntity, isExport);
+    makeEnumEntity(enumEntity, options) {
+        return new TsEnumEntityStatement(enumEntity, { isExport: options.isExport, isDeclare: !!options.isDeclare });
     }
     makeFieldModifiersList(modifiers, customFieldFilter) {
         let allowedModifiers = this.supportedFieldModifiers;
@@ -681,45 +685,6 @@ export class LanguageWriter {
     typeInstanceOf(type, value, members) {
         return this.makeString(`${value} instanceof ${this.getNodeName(type)}`);
     }
-    makeLengthSerializer(serializer, value) {
-        const valueType = "valueType";
-        return this.makeBlock([
-            this.makeAssign(valueType, undefined, this.makeFunctionCall("runtimeType", [this.makeString(value)]), true),
-            this.makeStatement(this.makeMethodCall(serializer, "writeInt8", [this.makeString(valueType)])),
-            this.makeMultiBranchCondition([
-                {
-                    expr: this.makeRuntimeTypeCondition(valueType, true, RuntimeType.NUMBER),
-                    stmt: this.makeStatement(this.makeMethodCall(serializer, "writeFloat32", [this.makeString(`${value} as float32`)]))
-                },
-                {
-                    expr: this.makeRuntimeTypeCondition(valueType, true, RuntimeType.STRING),
-                    stmt: this.makeStatement(this.makeMethodCall(serializer, "writeString", [this.makeString(`${value} as string`)]))
-                },
-                {
-                    expr: this.makeRuntimeTypeCondition(valueType, true, RuntimeType.OBJECT),
-                    stmt: this.makeStatement(this.makeMethodCall(serializer, "writeInt32", [this.makeString(`(${value} as Resource).id as int32`)]))
-                },
-            ]),
-        ], false);
-    }
-    makeLengthDeserializer(deserializer) {
-        const valueType = "valueType";
-        return this.makeBlock([
-            this.makeAssign(valueType, undefined, this.makeMethodCall(deserializer, "readInt8", []), true),
-            this.makeMultiBranchCondition([{
-                    expr: this.makeRuntimeTypeCondition(valueType, true, RuntimeType.NUMBER),
-                    stmt: this.makeReturn(this.makeString(`${deserializer}.readFloat32() as number`))
-                },
-                {
-                    expr: this.makeRuntimeTypeCondition(valueType, true, RuntimeType.STRING),
-                    stmt: this.makeReturn(this.makeMethodCall(deserializer, "readString", []))
-                },
-                {
-                    expr: this.makeRuntimeTypeCondition(valueType, true, RuntimeType.OBJECT),
-                    stmt: this.makeReturn(this.makeString(`({id: ${deserializer}.readInt32(), bundleName: "", moduleName: ""}) as Resource`))
-                }], this.makeReturn(this.makeUndefined())),
-        ], false);
-    }
     stringifyTypeOrEmpty(type) {
         if (type === undefined)
             return "";
@@ -743,7 +708,16 @@ export class LanguageWriter {
             this.popIndent();
         this.print(`}`);
     }
+    static get isReferenceRelativeToNamespaces() { return this._isReferenceRelativeToNamespaces; }
+    static relativeReferences(isRelative, op) {
+        const prevIsRelative = this.isReferenceRelativeToNamespaces;
+        this._isReferenceRelativeToNamespaces = isRelative;
+        const result = op();
+        this._isReferenceRelativeToNamespaces = prevIsRelative;
+        return result;
+    }
 }
+LanguageWriter._isReferenceRelativeToNamespaces = false;
 export function mangleMethodName(method, id) {
     return `${method.name}${id !== null && id !== void 0 ? id : ""}`;
 }

package/build/lib/src/LanguageWriters/convertors/CJConvertors.d.ts

@@ -17,7 +17,8 @@ export declare class CJTypeNameConvertor implements NodeConvertor<string>, IdlNa
     convertCallback(type: idl.IDLCallback): string;
     convertMethod(node: idl.IDLMethod): string;
     convertConstant(node: idl.IDLConstant): string;
-    convertImport(type: idl.IDLReferenceType, importClause: string): string;
+    convertImport(type: idl.IDLImport): string;
+    convertTypeReferenceAsImport(type: idl.IDLReferenceType, importClause: string): string;
     convertTypeReference(type: idl.IDLReferenceType): string;
     convertTypeParameter(type: idl.IDLTypeParameterType): string;
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;

package/build/lib/src/LanguageWriters/convertors/CJConvertors.js

@@ -20,6 +20,11 @@ export class CJTypeNameConvertor {
         this.resolver = resolver;
     }
     convert(node) {
+        if (idl.isType(node) && idl.isReferenceType(node)) {
+            if (node.name.startsWith('%TEXT%:')) {
+                return node.name.substring(7);
+            }
+        }
         return convertNode(this, node);
     }
     /***** TypeConvertor<string> **********************************/
@@ -35,7 +40,7 @@ export class CJTypeNameConvertor {
         }
         if (idl.IDLContainerUtils.isRecord(type)) {
             const stringes = type.elementType.slice(0, 2).map(it => convertType(this, it));
-            return `Map<${stringes[0]}, ${stringes[1]}>`;
+            return `HashMap<${stringes[0]}, ${stringes[1]}>`;
         }
         if (idl.IDLContainerUtils.isPromise(type)) {
             return `Any`;
@@ -56,7 +61,7 @@ export class CJTypeNameConvertor {
     }
     convertCallback(type) {
         const params = type.parameters.map(it => `${it.name}: ${it.isOptional ? "?" : ""}${this.convert(it.type)}`);
-        return `\{(${params.join(", ")}) => ${this.convert(type.returnType)}\}`;
+        return `(${params.join(", ")}) -> ${this.convert(type.returnType)}`;
     }
     convertMethod(node) {
         throw new Error('Method not implemented.');
@@ -64,7 +69,11 @@ export class CJTypeNameConvertor {
     convertConstant(node) {
         throw new Error('Method not implemented.');
     }
-    convertImport(type, importClause) {
+    convertImport(type) {
+        console.warn("Imports are not implemented yet");
+        return type.name;
+    }
+    convertTypeReferenceAsImport(type, importClause) {
         return type.name;
     }
     convertTypeReference(type) {
@@ -72,7 +81,7 @@ export class CJTypeNameConvertor {
             return "KPointer";
         const importAttr = idl.getExtAttribute(type, idl.IDLExtendedAttributes.Import);
         if (importAttr) {
-            return this.convertImport(type, importAttr);
+            return this.convertTypeReferenceAsImport(type, importAttr);
         }
         // resolve synthetic types
         const decl = this.resolver.resolveTypeReference(type);
@@ -112,6 +121,8 @@ export class CJTypeNameConvertor {
             case idl.IDLBufferType: return 'Array<UInt8>';
             case idl.IDLInteropReturnBufferType: return 'Array<UInt8>';
             case idl.IDLBigintType: return 'Int64';
+            case idl.IDLSerializerBuffer: return 'KSerializerBuffer';
+            case idl.IDLAnyType: return 'Any';
         }
         throw new Error(`Unsupported IDL primitive ${idl.DebugUtils.debugPrintType(type)}`);
     }
@@ -131,6 +142,7 @@ export class CJIDLTypeToForeignStringConvertor extends CJTypeNameConvertor {
             switch (type) {
                 case idl.IDLStringType: return 'CString';
                 case idl.IDLInteropReturnBufferType: return 'KInteropReturnBuffer';
+                case idl.IDLSerializerBuffer: return 'KSerializerBuffer';
             }
         }
         if (idl.isContainerType(type)) {
@@ -162,7 +174,6 @@ export class CJInteropArgConvertor extends InteropArgConvertor {
     convertPrimitiveType(type) {
         switch (type) {
             case idl.IDLNumberType: return "Float64";
-            case idl.IDLLengthType: return "Ark_Length";
         }
         return super.convertPrimitiveType(type);
     }

package/build/lib/src/LanguageWriters/convertors/CppConvertors.d.ts

@@ -21,7 +21,8 @@ export declare class GenericCppConvertor implements NodeConvertor<ConvertResult>
     convertOptional(type: idl.IDLOptionalType): ConvertResult;
     convertUnion(type: idl.IDLUnionType): ConvertResult;
     convertContainer(type: idl.IDLContainerType): ConvertResult;
-    convertImport(type: idl.IDLReferenceType, _: string): ConvertResult;
+    convertImport(type: idl.IDLImport): ConvertResult;
+    convertTypeReferenceAsImport(type: idl.IDLReferenceType, _: string): ConvertResult;
     convertTypeReference(type: idl.IDLReferenceType): ConvertResult;
     convertTypeParameter(type: idl.IDLTypeParameterType): ConvertResult;
     convertPrimitiveType(type: idl.IDLPrimitiveType): ConvertResult;
@@ -51,7 +52,8 @@ export declare class CppReturnTypeConvertor implements TypeConvertor<string> {
     isVoid(returnType: idl.IDLType): boolean;
     convert(type: idl.IDLType): string;
     convertContainer(type: idl.IDLContainerType): string;
-    convertImport(type: idl.IDLReferenceType, importClause: string): string;
+    convertImport(type: idl.IDLImport): string;
+    convertTypeReferenceAsImport(type: idl.IDLReferenceType, importClause: string): string;
     convertOptional(type: idl.IDLOptionalType): string;
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
     convertTypeParameter(type: idl.IDLTypeParameterType): string;