@idlizer/core 2.0.41 → 2.1.0

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

@@ -1,9 +1,10 @@
 import * as idl from "../idl";
 import { Language } from "../Language";
-import { LanguageExpression, LanguageStatement, LanguageWriter, ExpressionAssigner } from "./LanguageWriter";
+import { ExpressionAssigner, LanguageExpression, LanguageStatement, LanguageWriter, Method } from "./LanguageWriter";
 import { RuntimeType } from "./common";
 import { LibraryInterface } from "../LibraryInterface";
 import { ReferenceResolver } from "../peer-generation/ReferenceResolver";
+import { PeerLibrary } from "../peer-generation/PeerLibrary";
 export interface ArgConvertor {
     param: string;
     idlType: idl.IDLType;
@@ -22,6 +23,8 @@ export interface ArgConvertor {
     getMembers(): string[];
     getObjectAccessor(languge: Language, value: string, args?: Record<string, string>, writer?: LanguageWriter): string;
 }
+export declare function isVMContextMethod(method: Method): boolean;
+export declare function isDirectMethod(method: Method, library: PeerLibrary): boolean;
 export declare abstract class BaseArgConvertor implements ArgConvertor {
     idlType: idl.IDLType;
     runtimeTypes: RuntimeType[];

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

@@ -14,15 +14,65 @@
  */
 import * as idl from "../idl";
 import { Language } from "../Language";
-import { PrintHint, BlockStatement, StringExpression } from "./LanguageWriter";
+import { BlockStatement, PrintHint, StringExpression, MethodModifier } from "./LanguageWriter";
 import { RuntimeType } from "./common";
 import { generatorTypePrefix } from "../config";
 import { hashCodeFromString, warn } from "../util";
 import { UnionRuntimeTypeChecker } from "../peer-generation/unions";
-import { CppNameConvertor } from "./convertors/CppConvertors";
+import { CppConvertor, CppNameConvertor } from "./convertors/CppConvertors";
 import { createEmptyReferenceResolver } from "../peer-generation/ReferenceResolver";
-import { CppConvertor } from "./convertors/CppConvertors";
 import { PrimitiveTypesInstance } from "../peer-generation/PrimitiveType";
+import { qualifiedName } from "../peer-generation/idl/common";
+function isDirectConvertedType(originalType, library) {
+    if (originalType == undefined)
+        return true; // TODO: is it correct?
+    if (originalType == idl.IDLInteropReturnBufferType)
+        return false;
+    if (originalType == idl.IDLThisType)
+        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 CallbackConvertor ||
+        convertor instanceof AggregateConvertor ||
+        convertor instanceof UnionConvertor) {
+        // 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!
+    let result = type == idl.IDLI8Type || type == idl.IDLU8Type
+        || type == idl.IDLI16Type || type == idl.IDLU16Type
+        || type == idl.IDLI32Type || type == idl.IDLU32Type
+        || type == idl.IDLF32Type
+        || type == idl.IDLI64Type || type == idl.IDLU64Type
+        || 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) {}
+    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));
+}
+export function isDirectMethod(method, library) {
+    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`)
+    return result;
+}
 export class BaseArgConvertor {
     constructor(idlType, runtimeTypes, isScoped, useArray, param) {
         this.idlType = idlType;
@@ -158,14 +208,10 @@ export class EnumConvertor extends BaseArgConvertor {
         this.enumEntry = enumEntry;
     }
     convertorArg(param, writer) {
-        return writer.makeEnumCast(writer.escapeKeyword(param), false, this);
+        return writer.makeEnumCast(this.enumEntry, writer.escapeKeyword(param));
     }
     convertorSerialize(param, value, writer) {
-        value =
-            idl.isStringEnum(this.enumEntry)
-                ? writer.ordinalFromEnum(writer.makeString(value), idl.createReferenceType(this.enumEntry)).asString()
-                : writer.makeEnumCast(value, false, this);
-        writer.writeMethodCall(`${param}Serializer`, "writeInt32", [value]);
+        writer.writeMethodCall(`${param}Serializer`, "writeInt32", [writer.makeEnumCast(this.enumEntry, value)]);
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
         const readExpr = writer.makeMethodCall(`${deserializerName}`, "readInt32", []);
@@ -456,7 +502,9 @@ export class InterfaceConvertor extends BaseArgConvertor {
         return this.idlType;
     }
     interopType() {
-        throw new Error("Must never be used");
+        // Actually shouldn't be used!
+        // throw new Error("Must never be used")
+        return idl.IDLObjectType;
     }
     isPointerType() {
         return true;
@@ -889,7 +937,7 @@ export class MaterializedClassConvertor extends BaseArgConvertor {
     convertorArg(param, writer) {
         switch (writer.language) {
             case Language.CPP:
-                return `static_cast<${generatorTypePrefix()}${this.declaration.name}>(${param})`;
+                return `static_cast<${generatorTypePrefix()}${qualifiedName(this.declaration, "_")}>(${param})`;
             case Language.JAVA:
             case Language.CJ:
                 return `MaterializedBase.toPeerPtr(${param})`;
@@ -898,12 +946,12 @@ export class MaterializedClassConvertor extends BaseArgConvertor {
         }
     }
     convertorSerialize(param, value, printer) {
-        printer.writeStatement(printer.makeStatement(printer.makeMethodCall(`${param}Serializer`, `write${this.declaration.name}`, [
+        printer.writeStatement(printer.makeStatement(printer.makeMethodCall(`${param}Serializer`, `write${qualifiedName(this.declaration, "_")}`, [
             printer.makeString(value)
         ])));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
-        const readStatement = writer.makeCast(writer.makeMethodCall(`${deserializerName}`, `read${this.declaration.name}`, []), idl.createReferenceType(this.declaration));
+        const readStatement = writer.makeCast(writer.makeMethodCall(`${deserializerName}`, `read${qualifiedName(this.declaration, "_")}`, []), idl.createReferenceType(this.declaration));
         return assigneer(readStatement);
     }
     nativeType() {

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

@@ -154,7 +154,8 @@ export declare enum MethodModifier {
     GETTER = 6,
     SETTER = 7,
     THROWS = 8,
-    FREE = 9
+    FREE = 9,
+    FORCE_CONTEXT = 10
 }
 export declare enum ClassModifier {
     PUBLIC = 0,
@@ -172,6 +173,7 @@ export declare class Method {
     signature: MethodSignature;
     modifiers: MethodModifier[] | undefined;
     generics?: string[] | undefined;
+    private static knownReferenceTypes;
     constructor(name: string, signature: MethodSignature, modifiers?: MethodModifier[] | undefined, generics?: string[] | undefined);
 }
 export declare class PrintHint {
@@ -227,7 +229,7 @@ export declare abstract class LanguageWriter {
         stringId: string | undefined;
         numberId: number;
     }[], op?: (writer: this) => void): void;
-    abstract writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[], isDeclared?: boolean): 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;
@@ -263,7 +265,7 @@ export declare abstract class LanguageWriter {
     abstract get supportedFieldModifiers(): FieldModifier[];
     abstract enumFromOrdinal(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
     abstract ordinalFromEnum(value: LanguageExpression, enumReference: idl.IDLType): LanguageExpression;
-    abstract makeEnumCast(enumName: string, unsafe: boolean, convertor: ArgConvertor | undefined): string;
+    abstract makeEnumCast(enumEntry: idl.IDLEnum, enumName: string): string;
     abstract getNodeName(type: idl.IDLNode): string;
     abstract fork(options?: {
         resolver?: ReferenceResolver;
@@ -315,7 +317,7 @@ export declare abstract class LanguageWriter {
     makeString(value: string): LanguageExpression;
     makeNaryOp(op: string, args: LanguageExpression[]): LanguageExpression;
     makeStatement(expr: LanguageExpression): LanguageStatement;
-    writeNativeMethodDeclaration(name: string, signature: MethodSignature, isNative?: boolean): void;
+    writeNativeMethodDeclaration(method: Method): void;
     writeUnsafeNativeMethodDeclaration(name: string, signature: MethodSignature): void;
     pushIndent(): void;
     popIndent(): void;
@@ -330,7 +332,7 @@ export declare abstract class LanguageWriter {
     /**
      * TODO: replace me with {@link makeUnsafeCast_}
      */
-    makeUnsafeCast(convertor: ArgConvertor, param: string): string;
+    makeUnsafeCast(param: string): string;
     makeUnsafeCast_(value: LanguageExpression, type: idl.IDLType, typeOptions?: PrintHint): string;
     runtimeType(param: ArgConvertor, valueType: string, value: string): void;
     makeDiscriminatorFromFields(convertor: {

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

@@ -317,6 +317,7 @@ export var MethodModifier;
     MethodModifier[MethodModifier["SETTER"] = 7] = "SETTER";
     MethodModifier[MethodModifier["THROWS"] = 8] = "THROWS";
     MethodModifier[MethodModifier["FREE"] = 9] = "FREE";
+    MethodModifier[MethodModifier["FORCE_CONTEXT"] = 10] = "FORCE_CONTEXT";
 })(MethodModifier || (MethodModifier = {}));
 export var ClassModifier;
 (function (ClassModifier) {
@@ -339,6 +340,10 @@ export class Method {
         this.generics = generics;
     }
 }
+// Mostly for synthetic methods.
+Method.knownReferenceTypes = [
+    'KInt', 'KPointer', 'undefined' /* This one looks like a bug */
+];
 export class PrintHint {
     constructor(hint) {
         this.hint = hint;
@@ -565,8 +570,8 @@ export class LanguageWriter {
     makeStatement(expr) {
         return new ExpressionStatement(expr);
     }
-    writeNativeMethodDeclaration(name, signature, isNative) {
-        this.writeMethodDeclaration(name, signature);
+    writeNativeMethodDeclaration(method) {
+        this.writeMethodDeclaration(method.name, method.signature);
     }
     writeUnsafeNativeMethodDeclaration(name, signature) {
         return;
@@ -607,7 +612,7 @@ export class LanguageWriter {
     /**
      * TODO: replace me with {@link makeUnsafeCast_}
      */
-    makeUnsafeCast(convertor, param) {
+    makeUnsafeCast(param) {
         return `unsafeCast<int32>(${param})`;
     }
     makeUnsafeCast_(value, type, typeOptions) {

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

@@ -25,11 +25,12 @@ export declare class GenericCppConvertor implements NodeConvertor<ConvertResult>
     convertTypeReference(type: idl.IDLReferenceType): ConvertResult;
     convertTypeParameter(type: idl.IDLTypeParameterType): ConvertResult;
     convertPrimitiveType(type: idl.IDLPrimitiveType): ConvertResult;
-    private enumName;
+    private qualifiedName;
     private computeTargetTypeLiteralName;
 }
 export declare class CppConvertor extends GenericCppConvertor implements IdlNameConvertor {
     private unwrap;
+    private isPrimitiveOrPrimitiveAlias;
     convert(node: idl.IDLNode): string;
 }
 export declare class CppNameConvertor implements IdlNameConvertor {

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

@@ -21,6 +21,7 @@ import { maybeTransformManagedCallback } from '../ArgConvertors';
 import { qualifiedName } from '../../peer-generation/idl/common';
 import { capitalize } from '../../util';
 import { isMaterialized } from '../../peer-generation/isMaterialized';
+import { isInIdlizeInternal } from '../../idlize';
 export class GenericCppConvertor {
     constructor(resolver) {
         this.resolver = resolver;
@@ -38,34 +39,34 @@ export class GenericCppConvertor {
         switch (node.subkind) {
             case idl.IDLInterfaceSubkind.AnonymousInterface:
                 return node.name
-                    ? this.make(node.name)
+                    ? this.make(this.qualifiedName(node))
                     : this.make(this.computeTargetTypeLiteralName(node), true);
             case idl.IDLInterfaceSubkind.Interface:
             case idl.IDLInterfaceSubkind.Class:
-                if (idl.hasExtAttribute(node, idl.IDLExtendedAttributes.Predefined)) {
-                    return this.make(node.name, true);
+                if (isInIdlizeInternal(node)) {
+                    return this.make(this.qualifiedName(node), true);
                 }
-                return this.make(node.name);
+                return this.make(this.qualifiedName(node));
             case idl.IDLInterfaceSubkind.Tuple:
                 return node.name
-                    ? this.make(node.name)
+                    ? this.make(this.qualifiedName(node))
                     : this.make(`Tuple_${node.properties.map(it => this.convertNode(idl.maybeOptional(it.type, it.isOptional)).text).join("_")}`, true);
         }
     }
     convertEnum(node) {
-        return this.make(this.enumName(node));
+        return this.make(this.qualifiedName(node));
     }
     convertTypedef(node) {
-        return this.make(node.name);
+        return this.make(this.qualifiedName(node));
     }
     convertCallback(node) {
-        return this.make(generatorConfiguration().LibraryPrefix + node.name, true);
+        return this.make(generatorConfiguration().LibraryPrefix + this.qualifiedName(node), true);
     }
     convertMethod(node) {
         return this.make(node.name);
     }
     convertConstant(node) {
-        return this.make(node.name);
+        return this.make(this.qualifiedName(node));
     }
     /////////////////////////////////////////////////////////////////////////////////////////
     convertOptional(type) {
@@ -151,7 +152,7 @@ export class GenericCppConvertor {
         }
         throw new Error(`Unmapped primitive type ${idl.DebugUtils.debugPrintType(type)}`);
     }
-    enumName(target) {
+    qualifiedName(target) {
         return qualifiedName(target, "_");
     }
     computeTargetTypeLiteralName(decl) {
@@ -178,9 +179,23 @@ export class CppConvertor extends GenericCppConvertor {
         const typePrefix = conf.TypePrefix;
         // TODO remove this ugly hack for CustomObject's
         const convertedToCustomObject = result.text === idl.IDLCustomObjectType.name;
-        const libPrefix = idl.isPrimitiveType(type) || convertedToCustomObject ? "" : conf.LibraryPrefix;
+        const libPrefix = this.isPrimitiveOrPrimitiveAlias(type) || convertedToCustomObject ? "" : conf.LibraryPrefix;
         return `${typePrefix}${libPrefix}${result.text}`;
     }
+    isPrimitiveOrPrimitiveAlias(type) {
+        if (!idl.isType(type))
+            return false;
+        const { resolver } = this;
+        while (type && idl.isReferenceType(type)) {
+            const resolved = resolver.resolveTypeReference(type);
+            if (!resolved)
+                return false;
+            if (!idl.isTypedef(resolved))
+                break;
+            type = resolved.type;
+        }
+        return idl.isPrimitiveType(type);
+    }
     convert(node) {
         return this.unwrap(node, this.convertNode(node));
     }
@@ -247,7 +262,7 @@ export class CppReturnTypeConvertor {
     convertTypeReference(type) {
         const decl = this.resolver.resolveTypeReference(type);
         if (decl && idl.isInterface(decl) && isMaterialized(decl, this.resolver)) {
-            return generatorTypePrefix() + decl.name;
+            return generatorTypePrefix() + qualifiedName(decl, "_");
         }
         return this.convertor.convert(type);
     }

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

@@ -1,5 +1,5 @@
 import * as idl from "../../idl";
-import { TSTypeNameConvertor } from "./TSConvertors";
+import { TSInteropArgConvertor, TSTypeNameConvertor } from "./TSConvertors";
 export declare class ETSTypeNameConvertor extends TSTypeNameConvertor {
     convertTypeReference(type: idl.IDLReferenceType): string;
     convertContainer(type: idl.IDLContainerType): string;
@@ -9,4 +9,6 @@ export declare class ETSTypeNameConvertor extends TSTypeNameConvertor {
     protected mapCallback(decl: idl.IDLCallback): string;
     protected mapFunctionType(typeArgs: string[]): string;
 }
+export declare class ETSInteropArgConvertor extends TSInteropArgConvertor {
+}
 //# sourceMappingURL=ETSConvertors.d.ts.map

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

@@ -16,7 +16,7 @@ import * as idl from "../../idl";
 import { Language } from "../../Language";
 import { createDeclarationNameConvertor } from "../../peer-generation/idl/IdlNameConvertor";
 import { convertDeclaration } from "../nameConvertor";
-import { TSTypeNameConvertor } from "./TSConvertors";
+import { TSInteropArgConvertor, TSTypeNameConvertor } from "./TSConvertors";
 export class ETSTypeNameConvertor extends TSTypeNameConvertor {
     convertTypeReference(type) {
         // Only to deal with namespaces. TODO: remove later
@@ -109,4 +109,6 @@ export class ETSTypeNameConvertor extends TSTypeNameConvertor {
         return `Function${typeArgs.length - 1}<${typeArgs.join(",")}>`;
     }
 }
+export class ETSInteropArgConvertor extends TSInteropArgConvertor {
+}
 //# sourceMappingURL=ETSConvertors.js.map

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

@@ -114,16 +114,16 @@ export class InteropArgConvertor {
             case idl.IDLU64Type: return "KLong";
             case idl.IDLI32Type: return "KInt";
             case idl.IDLF32Type: return "KFloat";
-            case idl.IDLNumberType: return 'number'; // should be removed! It is KInteropNumber or smth
-            case idl.IDLBigintType: return 'bigint'; // should be removed! It is KLong or smth
+            case idl.IDLNumberType: return 'KInteropNumber';
+            case idl.IDLBigintType: return 'KLong';
             case idl.IDLBooleanType:
             case idl.IDLFunctionType: return 'KInt';
             case idl.IDLStringType: return 'KStringPtr';
-            case idl.IDLBufferType: return `ArrayBuffer`;
+            case idl.IDLBufferType: return `KInteropBuffer`;
             case idl.IDLLengthType: return 'Length';
             case idl.IDLDate: return 'KLong';
             case idl.IDLUndefinedType:
-            case idl.IDLVoidType: return PrimitiveTypesInstance.NativePointer.getText();
+            case idl.IDLVoidType:
             case idl.IDLPointerType: return 'KPointer'; // return PrimitiveTypesInstance.NativePointer.getText()
         }
         throw new Error(`Cannot pass primitive type ${type.name} through interop`);

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

@@ -1,6 +1,6 @@
 import * as idl from '../../idl';
 import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
-import { IdlNameConvertor, NodeConvertor } from '../nameConvertor';
+import { IdlNameConvertor, NodeConvertor, TypeConvertor } from '../nameConvertor';
 export declare class TSTypeNameConvertor implements NodeConvertor<string>, IdlNameConvertor {
     protected resolver: ReferenceResolver;
     constructor(resolver: ReferenceResolver);
@@ -24,4 +24,14 @@ export declare class TSTypeNameConvertor implements NodeConvertor<string>, IdlNa
     protected productType(decl: idl.IDLInterface, isTuple: boolean, includeFieldNames: boolean): string;
     protected mapFunctionType(typeArgs: string[]): string;
 }
+export declare class TSInteropArgConvertor implements TypeConvertor<string> {
+    convert(type: idl.IDLType): string;
+    convertContainer(type: idl.IDLContainerType): string;
+    convertImport(type: idl.IDLReferenceType, importClause: string): string;
+    convertOptional(type: idl.IDLOptionalType): string;
+    convertPrimitiveType(type: idl.IDLPrimitiveType): string;
+    convertTypeParameter(type: idl.IDLTypeParameterType): string;
+    convertTypeReference(type: idl.IDLReferenceType): string;
+    convertUnion(type: idl.IDLUnionType): string;
+}
 //# sourceMappingURL=TSConvertors.d.ts.map

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

@@ -13,7 +13,7 @@
  * limitations under the License.
  */
 import * as idl from '../../idl';
-import { convertNode } from '../nameConvertor';
+import { convertNode, convertType } from '../nameConvertor';
 export class TSTypeNameConvertor {
     constructor(resolver) {
         this.resolver = resolver;
@@ -173,4 +173,47 @@ export class TSTypeNameConvertor {
         return `Function${typeArgs.length ? `<${typeArgs.join(",")}>` : ''}`;
     }
 }
+export class TSInteropArgConvertor {
+    convert(type) {
+        return convertType(this, type);
+    }
+    convertContainer(type) {
+        throw new Error(`Cannot pass container types through interop`);
+    }
+    convertImport(type, importClause) {
+        throw new Error(`Cannot pass import types through interop`);
+    }
+    convertOptional(type) {
+        return "KNativePointer";
+    }
+    convertPrimitiveType(type) {
+        switch (type) {
+            case idl.IDLI64Type: return "KLong";
+            case idl.IDLU64Type: return "KLong";
+            case idl.IDLI32Type: return "KInt";
+            case idl.IDLF32Type: return "KFloat";
+            case idl.IDLNumberType: return 'number';
+            case idl.IDLBigintType: return 'bigint';
+            case idl.IDLBooleanType:
+            case idl.IDLFunctionType: return 'KInt';
+            case idl.IDLStringType: return 'KStringPtr';
+            case idl.IDLBufferType: return `ArrayBuffer`;
+            case idl.IDLLengthType: return 'Length';
+            case idl.IDLDate: return 'number';
+            case idl.IDLUndefinedType:
+            case idl.IDLVoidType:
+            case idl.IDLPointerType: return 'KPointer';
+        }
+        throw new Error(`Cannot pass primitive type ${type.name} through interop`);
+    }
+    convertTypeParameter(type) {
+        throw new Error("Cannot pass type parameters through interop");
+    }
+    convertTypeReference(type) {
+        throw new Error(`Cannot pass type references through interop`);
+    }
+    convertUnion(type) {
+        throw new Error("Cannot pass union types through interop");
+    }
+}
 //# sourceMappingURL=TSConvertors.js.map

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

@@ -1,8 +1,8 @@
 import { Language } from "../Language";
 import { ReferenceResolver } from "../peer-generation/ReferenceResolver";
-import { InteropArgConvertor } from "./convertors/InteropConvertors";
 import { LanguageWriter } from "./LanguageWriter";
+import { TypeConvertor } from "./nameConvertor";
 export * from "./nameConvertor";
 export declare function createLanguageWriter(language: Language, resolver?: ReferenceResolver): LanguageWriter;
-export declare function createInteropArgConvertor(language: Language): InteropArgConvertor;
+export declare function createInteropArgConvertor(language: Language): TypeConvertor<string>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -4,10 +4,9 @@ import { PrimitiveTypesInstance } from "../peer-generation/PrimitiveType";
 import { createEmptyReferenceResolver } from "../peer-generation/ReferenceResolver";
 import { CJIDLTypeToForeignStringConvertor, CJInteropArgConvertor, CJTypeNameConvertor } from "./convertors/CJConvertors";
 import { CppInteropArgConvertor, CppConvertor } from "./convertors/CppConvertors";
-import { ETSTypeNameConvertor } from "./convertors/ETSConvertors";
-import { InteropArgConvertor } from "./convertors/InteropConvertors";
+import { ETSInteropArgConvertor, ETSTypeNameConvertor } from "./convertors/ETSConvertors";
 import { JavaInteropArgConvertor, JavaTypeNameConvertor } from "./convertors/JavaConvertors";
-import { TSTypeNameConvertor } from "./convertors/TSConvertors";
+import { TSInteropArgConvertor, TSTypeNameConvertor } from "./convertors/TSConvertors";
 import { CJLanguageWriter } from "./writers/CJLanguageWriter";
 import { CppLanguageWriter } from "./writers/CppLanguageWriter";
 import { ETSLanguageWriter } from "./writers/ETSLanguageWriter";
@@ -28,8 +27,8 @@ export function createLanguageWriter(language, resolver) {
 }
 export function createInteropArgConvertor(language) {
     switch (language) {
-        case Language.TS:
-        case Language.ARKTS: return new InteropArgConvertor();
+        case Language.TS: return new TSInteropArgConvertor();
+        case Language.ARKTS: return new ETSInteropArgConvertor();
         case Language.CPP: return CppInteropArgConvertor.INSTANCE;
         case Language.JAVA: return new JavaInteropArgConvertor();
         case Language.CJ: return new CJInteropArgConvertor();

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

@@ -2,7 +2,7 @@ import * as idl from "../../idl";
 import { IndentedPrinter } from "../../IndentedPrinter";
 import { ArgConvertor, BaseArgConvertor } from "../ArgConvertors";
 import { RuntimeType } from "../common";
-import { AssignStatement, FieldModifier, LambdaExpression, LanguageExpression, LanguageStatement, LanguageWriter, MakeCastOptions, Method, MethodModifier, MethodSignature, NamedMethodSignature, ObjectArgs } from "../LanguageWriter";
+import { AssignStatement, FieldModifier, LambdaExpression, LanguageExpression, LanguageStatement, LanguageWriter, MakeCastOptions, Method, MethodModifier, MethodSignature, ObjectArgs } from "../LanguageWriter";
 import { IdlNameConvertor } from "../nameConvertor";
 import { Language } from "../../Language";
 import { ReferenceResolver } from "../../peer-generation/ReferenceResolver";
@@ -81,7 +81,7 @@ export declare class CJLanguageWriter extends LanguageWriter {
         stringId: string | undefined;
         numberId: number;
     }[], op: (writer: LanguageWriter) => void): void;
-    writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[]): void;
+    writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[], generics?: string[]): void;
     writeFunctionDeclaration(name: string, signature: MethodSignature): void;
     writeFunctionImplementation(name: string, signature: MethodSignature, op: (writer: this) => void): void;
     private generateFunctionDeclaration;
@@ -96,8 +96,8 @@ export declare class CJLanguageWriter extends LanguageWriter {
     writeCJForeign(op: (writer: CJLanguageWriter) => void): void;
     private writeDeclaration;
     writeNativeFunctionCall(printer: LanguageWriter, name: string, signature: MethodSignature): void;
-    writeNativeMethodDeclaration(name: string, signature: NamedMethodSignature): void;
-    makeEnumCast(enumName: string, _unsafe: boolean, _convertor: ArgConvertor | undefined): string;
+    writeNativeMethodDeclaration(method: Method): void;
+    makeEnumCast(_enumEntry: idl.IDLEnum, enumName: string): string;
     makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression, isDeclared?: boolean, isConst?: boolean): LanguageStatement;
     makeClassInit(type: idl.IDLType, parameters: LanguageExpression[]): LanguageExpression;
     makeArrayInit(type: idl.IDLContainerType, size?: number): LanguageExpression;

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

@@ -293,7 +293,7 @@ export class CJLanguageWriter extends LanguageWriter {
         this.popIndent();
         this.printer.print(`}`);
     }
-    writeInterface(name, op, superInterfaces) {
+    writeInterface(name, op, superInterfaces, generics) {
         let extendsClause = superInterfaces ? ` <: ${superInterfaces.join(" & ")}` : '';
         this.printer.print(`public interface ${name}${extendsClause} {`);
         this.pushIndent();
@@ -404,12 +404,13 @@ export class CJLanguageWriter extends LanguageWriter {
     writeNativeFunctionCall(printer, name, signature) {
         printer.print(`return unsafe { ${name}(${signature.args.map((it, index) => `${signature.argName(index)}`).join(", ")}) }`);
     }
-    writeNativeMethodDeclaration(name, signature) {
-        let signture = `${signature.args.map((it, index) => `${this.escapeKeyword(signature.argName(index))}: ${this.typeForeignConvertor.convert(it)}`).join(", ")}`;
+    writeNativeMethodDeclaration(method) {
+        let name = method.name;
+        let signture = `${method.signature.args.map((it, index) => `${this.escapeKeyword(method.signature.argName(index))}: ${this.typeForeignConvertor.convert(it)}`).join(", ")}`;
         name = name.startsWith('_') ? name.slice(1) : name;
-        this.print(`func ${name}(${signture}): ${this.typeForeignConvertor.convert(signature.returnType)}`);
+        this.print(`func ${name}(${signture}): ${this.typeForeignConvertor.convert(method.signature.returnType)}`);
     }
-    makeEnumCast(enumName, _unsafe, _convertor) {
+    makeEnumCast(_enumEntry, enumName) {
         return `${enumName}.value`;
     }
     makeAssign(variableName, type, expr, isDeclared = true, isConst = true) {

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

@@ -7,6 +7,7 @@ import { IdlNameConvertor } from "../nameConvertor";
 import { RuntimeType } from "../common";
 import { IndentedPrinter } from "../../IndentedPrinter";
 import { ReferenceResolver } from "../../peer-generation/ReferenceResolver";
+import * as idl from "../../idl";
 export declare class CppCastExpression implements LanguageExpression {
     convertor: IdlNameConvertor;
     value: LanguageExpression;
@@ -41,7 +42,7 @@ export declare class CppLanguageWriter extends CLikeLanguageWriter {
         resolver?: ReferenceResolver;
     }): LanguageWriter;
     writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[]): void;
-    writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[]): void;
+    writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[], generics?: string[]): void;
     writeMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;
     writeFieldDeclaration(name: string, type: IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
     writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
@@ -102,9 +103,9 @@ export declare class CppLanguageWriter extends CLikeLanguageWriter {
     get supportedFieldModifiers(): FieldModifier[];
     enumFromOrdinal(value: LanguageExpression, type: IDLType): LanguageExpression;
     ordinalFromEnum(value: LanguageExpression, _: IDLType): LanguageExpression;
-    makeUnsafeCast(convertor: ArgConvertor, param: string): string;
+    makeUnsafeCast(param: string): string;
     makeUnsafeCast_(value: LanguageExpression, type: IDLType, typeOptions?: PrintHint): string;
-    makeEnumCast(value: string, _unsafe: boolean, convertor: ArgConvertor | undefined): string;
+    makeEnumCast(enumEntry: idl.IDLEnum, value: string): string;
     escapeKeyword(name: string): string;
     makeEnumEntity(enumEntity: IDLEnum, isExport: boolean): LanguageStatement;
     private decayTypeName;

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

@@ -19,8 +19,8 @@ import { AssignStatement, BlockStatement, FieldModifier, PrintHint, MethodModifi
 import { CDefinedExpression, CLikeExpressionStatement, CLikeLanguageWriter, CLikeLoopStatement, CLikeReturnStatement } from "./CLikeLanguageWriter";
 import { RuntimeType } from "../common";
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { throwException } from "../../util";
 import { cppKeywords } from "../../languageSpecificKeywords";
+import * as idl from "../../idl";
 ////////////////////////////////////////////////////////////////
 //                        EXPRESSIONS                         //
 ////////////////////////////////////////////////////////////////
@@ -180,7 +180,7 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
         this.popIndent();
         this.printer.print(`};`);
     }
-    writeInterface(name, op, superInterfaces) {
+    writeInterface(name, op, superInterfaces, generics) {
         throw new Error("Method not implemented.");
     }
     writeMethodCall(receiver, method, params, nullable = false) {
@@ -376,7 +376,7 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
     ordinalFromEnum(value, _) {
         return value;
     }
-    makeUnsafeCast(convertor, param) {
+    makeUnsafeCast(param) {
         return param;
     }
     makeUnsafeCast_(value, type, typeOptions) {
@@ -396,11 +396,8 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
         }
         return `(${typeName}) (${value.asString()})`;
     }
-    makeEnumCast(value, _unsafe, convertor) {
-        if (convertor !== undefined) {
-            return `static_cast<${this.typeConvertor.convert(convertor.nativeType())}>(${value})`;
-        }
-        throwException("Need pass EnumConvertor");
+    makeEnumCast(enumEntry, value) {
+        return `static_cast<${this.typeConvertor.convert(idl.createReferenceType(enumEntry))}>(${value})`;
     }
     escapeKeyword(name) {
         return cppKeywords.has(name) ? name + "_" : name;