@idlizer/core 2.1.0 → 2.1.5

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

@@ -15,6 +15,7 @@ export interface ArgConvertor {
     convertorArg(param: string, writer: LanguageWriter): string;
     convertorSerialize(param: string, value: string, writer: LanguageWriter): void;
     convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    holdResource(resourceName: string, holder: string, writer: LanguageWriter): void;
     interopType(): idl.IDLType;
     nativeType(): idl.IDLType;
     targetType(writer: LanguageWriter): string;
@@ -23,6 +24,7 @@ export interface ArgConvertor {
     getMembers(): string[];
     getObjectAccessor(languge: Language, value: string, args?: Record<string, string>, writer?: LanguageWriter): string;
 }
+export declare function isDirectConvertedType(originalType: idl.IDLType | undefined, library: PeerLibrary): boolean;
 export declare function isVMContextMethod(method: Method): boolean;
 export declare function isDirectMethod(method: Method, library: PeerLibrary): boolean;
 export declare abstract class BaseArgConvertor implements ArgConvertor {
@@ -32,6 +34,7 @@ export declare abstract class BaseArgConvertor implements ArgConvertor {
     useArray: boolean;
     param: string;
     protected constructor(idlType: idl.IDLType, runtimeTypes: RuntimeType[], isScoped: boolean, useArray: boolean, param: string);
+    holdResource(_resourceName: string, _holder: string, _writer: LanguageWriter): void;
     nativeType(): idl.IDLType;
     isPointerType(): boolean;
     interopType(): idl.IDLType;
@@ -119,6 +122,16 @@ export declare class BigIntToU64Convertor extends BaseArgConvertor {
     interopType(): idl.IDLType;
     isPointerType(): boolean;
 }
+export declare class ObjectConvertor extends BaseArgConvertor {
+    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;
+    holdResource(name: string, holder: string, writer: LanguageWriter): void;
+    nativeType(): idl.IDLType;
+    interopType(): idl.IDLType;
+    isPointerType(): boolean;
+}
 export declare class PointerConvertor extends BaseArgConvertor {
     constructor(param: string);
     convertorArg(param: string, writer: LanguageWriter): string;
@@ -280,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;
@@ -321,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,37 +16,46 @@ 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";
 import { createEmptyReferenceResolver } from "../peer-generation/ReferenceResolver";
 import { PrimitiveTypesInstance } from "../peer-generation/PrimitiveType";
 import { qualifiedName } from "../peer-generation/idl/common";
-function isDirectConvertedType(originalType, library) {
+export function isDirectConvertedType(originalType, library) {
+    const debug = false;
     if (originalType == undefined)
         return true; // TODO: is it correct?
+    if (debug)
+        console.log(`IDL type ${idl.DebugUtils.debugPrintType(originalType)}`);
     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);
     // Resolve aliases.
     while (convertor instanceof TypeAliasConvertor) {
         convertor = convertor.convertor;
     }
-    // Temporary!
     if (convertor instanceof ArrayConvertor ||
-        convertor instanceof MapConvertor ||
         convertor instanceof CustomTypeConvertor ||
+        convertor instanceof UnionConvertor ||
         convertor instanceof CallbackConvertor ||
+        convertor instanceof MapConvertor ||
+        convertor instanceof TupleConvertor ||
         convertor instanceof AggregateConvertor ||
-        convertor instanceof UnionConvertor) {
+        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();
-    // TODO: make 'number' be direct!
+    if (debug)
+        console.log(`converted type ${idl.DebugUtils.debugPrintType(originalType)}`);
     let result = type == idl.IDLI8Type || type == idl.IDLU8Type
         || type == idl.IDLI16Type || type == idl.IDLU16Type
         || type == idl.IDLI32Type || type == idl.IDLU32Type
@@ -55,22 +64,27 @@ function isDirectConvertedType(originalType, library) {
         || type == idl.IDLPointerType
         || type == idl.IDLBooleanType
         || type == idl.IDLVoidType
-        || type == idl.IDLUndefinedType;
-    // try { if (!result) console.log(`type ${JSON.stringify(type)} is not direct`) } catch (e) {}
+        || type == idl.IDLUndefinedType
+        || type == idl.IDLSerializerBuffer
+        || type == idl.IDLNumberType;
+    if (!result && debug)
+        console.log(`type ${idl.DebugUtils.debugPrintType(type)} is not direct`);
     return result;
 }
 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))
+    if (isVMContextMethod(method)) {
         return false;
+    }
     let result = isDirectConvertedType(method.signature.returnType, library) &&
         method.signature.args.every((arg) => isDirectConvertedType(arg, library));
-    //if (!result) console.log(`method ${method.name} is not direct`)
+    // if (!result) console.log(`method ${method.name} is not direct`)
     return result;
 }
 export class BaseArgConvertor {
@@ -81,6 +95,7 @@ export class BaseArgConvertor {
         this.useArray = useArray;
         this.param = param;
     }
+    holdResource(_resourceName, _holder, _writer) { }
     nativeType() {
         throw new Error("Define");
     }
@@ -208,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;
@@ -296,21 +309,64 @@ 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, type) {
+        super(type, [
+            RuntimeType.BIGINT,
+            RuntimeType.BOOLEAN,
+            RuntimeType.FUNCTION,
+            RuntimeType.MATERIALIZED,
+            RuntimeType.NUMBER,
+            RuntimeType.OBJECT,
+            RuntimeType.STRING,
+            RuntimeType.SYMBOL,
+        ], false, true, param);
+    }
+    convertorArg(param, writer) {
+        return writer.escapeKeyword(param);
+    }
+    convertorSerialize(param, value, printer) {
+        if (printer.language === Language.CPP) {
+            printer.writeMethodCall(`${param}Serializer`, "writeObject", [value]);
+        }
+        else {
+            printer.writeMethodCall(`${param}Serializer`, "holdAndWriteObject", [value]);
+        }
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        return assigneer(writer.makeCast(writer.makeMethodCall(deserializerName, 'readObject', []), this.idlType, { optional: false }));
+    }
+    holdResource(name, holder, writer) {
+        writer.writeStatement(writer.makeAssign(name, idl.createReferenceType(`CallbackResource`), writer.makeString(`{${this.param}.resource.resourceId, holdManagedCallbackResource, releaseManagedCallbackResource}`), true));
+        writer.writeExpressionStatement(writer.makeMethodCall(holder, 'holdCallbackResource', [
+            writer.makeString('&' + name)
+        ]));
+    }
+    nativeType() {
+        return idl.IDLAnyType;
+    }
+    interopType() {
+        return idl.IDLAnyType;
+    }
+    isPointerType() {
+        return true;
+    }
+}
 export class PointerConvertor extends BaseArgConvertor {
     constructor(param) {
         // check numericPrimitiveTypes.include(type)
@@ -409,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));
@@ -504,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;
@@ -547,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(`}`);
     }
@@ -766,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) {
@@ -778,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) {
@@ -904,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})`;
@@ -917,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;
@@ -937,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})`;
@@ -946,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() {
@@ -1054,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;
@@ -236,7 +247,13 @@ export declare abstract class LanguageWriter {
     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 writeMethodImplementation(method: Method, op: (writer: this) => void): void;
-    abstract writeProperty(propName: string, propType: idl.IDLType, mutable?: boolean, getterLambda?: (writer: this) => void, setterLambda?: (writer: this) => void): void;
+    abstract writeProperty(propName: string, propType: idl.IDLType, modifiers: FieldModifier[], getter?: {
+        method: Method;
+        op?: () => void;
+    }, setter?: {
+        method: Method;
+        op: () => void;
+    }): void;
     abstract writeTypeDeclaration(decl: idl.IDLTypedef): void;
     abstract writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
     abstract makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression | undefined, isDeclared: boolean, isConst?: boolean, options?: MakeAssignOptions): LanguageStatement;
@@ -246,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;
@@ -263,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;
@@ -307,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;
@@ -339,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;
@@ -347,14 +365,13 @@ export declare abstract class LanguageWriter {
     discriminatorFromExpressions(value: string, runtimeType: RuntimeType, exprs: LanguageExpression[]): LanguageExpression;
     makeDiscriminatorConvertor(_convertor: ArgConvertor, _value: string, _index: number): LanguageExpression | undefined;
     makeNot(expr: LanguageExpression): LanguageExpression;
+    makeSerializedBufferGetter(serializer: string): LanguageExpression;
     makeEquals(args: LanguageExpression[]): LanguageExpression;
     castToInt(value: string, bitness: 8 | 32): string;
     castToBoolean(value: string): string;
     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
@@ -365,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;
@@ -663,6 +667,9 @@ export class LanguageWriter {
     makeNot(expr) {
         return this.makeString(`!(${expr.asString()})`);
     }
+    makeSerializedBufferGetter(serializer) {
+        return this.makeMethodCall(serializer, `asBuffer`, []);
+    }
     makeEquals(args) {
         return this.makeNaryOp("===", args);
     }
@@ -678,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 "";
@@ -740,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;