npm - @idlizer/core - Versions diffs - 2.0.43 → 2.1.0 - Mend

@idlizer/core 2.0.43 → 2.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (22) hide show

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

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 {
@@ -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,6 @@ export declare abstract class LanguageWriter {
     makeString(value: string): LanguageExpression;
     makeNaryOp(op: string, args: LanguageExpression[]): LanguageExpression;
     makeStatement(expr: LanguageExpression): LanguageStatement;
-    tryWriteQuick(method: Method): void;
     writeNativeMethodDeclaration(method: Method): void;
     writeUnsafeNativeMethodDeclaration(name: string, signature: MethodSignature): void;
     pushIndent(): void;
@@ -331,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 CHANGED Viewed

@@ -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,9 +570,7 @@ export class LanguageWriter {
     makeStatement(expr) {
         return new ExpressionStatement(expr);
     }
-    tryWriteQuick(method) { }
     writeNativeMethodDeclaration(method) {
-        this.tryWriteQuick(method);
         this.writeMethodDeclaration(method.name, method.signature);
     }
     writeUnsafeNativeMethodDeclaration(name, signature) {
@@ -609,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 CHANGED Viewed

@@ -25,7 +25,7 @@ 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 {

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

@@ -39,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 (isInIdlizeInternal(node)) {
-                    return this.make(node.name, true);
+                    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) {
@@ -152,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) {
@@ -262,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/writers/CJLanguageWriter.d.ts CHANGED Viewed

@@ -97,7 +97,7 @@ export declare class CJLanguageWriter extends LanguageWriter {
     private writeDeclaration;
     writeNativeFunctionCall(printer: LanguageWriter, name: string, signature: MethodSignature): void;
     writeNativeMethodDeclaration(method: Method): void;
-    makeEnumCast(enumName: string, _unsafe: boolean, _convertor: ArgConvertor | undefined): string;
+    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 CHANGED Viewed

@@ -410,7 +410,7 @@ export class CJLanguageWriter extends LanguageWriter {
         name = name.startsWith('_') ? name.slice(1) : name;
         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 CHANGED Viewed

@@ -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;
@@ -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 CHANGED Viewed

@@ -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                         //
 ////////////////////////////////////////////////////////////////
@@ -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;

package/build/lib/src/LanguageWriters/writers/ETSLanguageWriter.d.ts CHANGED Viewed

@@ -42,7 +42,6 @@ export declare class ETSLanguageWriter extends TSLanguageWriter {
     makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;
     makeMapSize(map: string): LanguageExpression;
     get supportedModifiers(): MethodModifier[];
-    makeUnsafeCast(convertor: ArgConvertor, param: string): string;
     runtimeType(param: ArgConvertor, valueType: string, value: string): void;
     makeUnionVariantCast(value: string, type: string, convertor: ArgConvertor, index?: number): LanguageExpression;
     enumFromOrdinal(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
@@ -55,12 +54,9 @@ export declare class ETSLanguageWriter extends TSLanguageWriter {
     makeEnumEntity(enumEntity: IDLEnum, isExport: boolean): LanguageStatement;
     getObjectAccessor(convertor: ArgConvertor, value: string, args?: ObjectArgs): string;
     writeMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;
-    isDirectType(type: IDLType): boolean;
     isQuickType(type: IDLType): boolean;
-    tryWriteQuick(method: Method): void;
     writeNativeMethodDeclaration(method: Method): void;
     writeProperty(propName: string, propType: IDLType): void;
-    makeEnumCast(value: string, _unsafe: boolean, convertor: ArgConvertor | undefined): string;
     makeUnionVariantCondition(convertor: ArgConvertor, valueName: string, valueType: string, type: string, convertorIndex: number, runtimeTypeIndex: number): LanguageExpression;
     makeCastCustomObject(customName: string, isGenericType: boolean): LanguageExpression;
     makeHasOwnProperty(value: string, valueTypeName: string, property: string, propertyTypeName: string): LanguageExpression;

package/build/lib/src/LanguageWriters/writers/ETSLanguageWriter.js CHANGED Viewed

@@ -15,14 +15,13 @@
 import { IndentedPrinter } from "../../IndentedPrinter";
 import { LambdaExpression, MethodModifier } from "../LanguageWriter";
 import { TSCastExpression, TSLanguageWriter } from "./TsLanguageWriter";
-import { getExtAttribute, IDLI32Type, IDLThisType } from '../../idl';
+import { getExtAttribute, IDLThisType } from '../../idl';
 import { AggregateConvertor, ArrayConvertor, CustomTypeConvertor, InterfaceConvertor, MaterializedClassConvertor, OptionConvertor, UnionConvertor, BufferConvertor } from "../ArgConvertors";
 import * as idl from '../../idl';
 import { convertDeclaration } from "../nameConvertor";
 import { createDeclarationNameConvertor } from "../../peer-generation/idl/IdlNameConvertor";
 import { Language } from "../../Language";
 import { RuntimeType } from "../common";
-import { throwException } from "../../util";
 ////////////////////////////////////////////////////////////////
 //                         STATEMENTS                         //
 ////////////////////////////////////////////////////////////////
@@ -177,13 +176,6 @@ export class ETSLanguageWriter extends TSLanguageWriter {
     get supportedModifiers() {
         return [MethodModifier.PUBLIC, MethodModifier.PRIVATE, MethodModifier.NATIVE, MethodModifier.STATIC];
     }
-    makeUnsafeCast(convertor, param) {
-        if (idl.isEnum(convertor.idlType) && !param.endsWith(".value")) {
-            const isStringEnum = idl.isStringEnum(convertor.idlType);
-            return `(${param} as ${this.typeConvertor.convert(convertor.idlType)}).${isStringEnum ? 'ordinal' : 'value'}`;
-        }
-        return super.makeUnsafeCast(convertor, param);
-    }
     runtimeType(param, valueType, value) {
         super.runtimeType(param, valueType, value);
     }
@@ -226,48 +218,18 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         // ArkTS does not support - 'this.?'
         super.writeMethodCall(receiver, method, params, nullable && receiver !== "this");
     }
-    isDirectType(type) {
-        let converted = this.getNodeName(type);
-        return type == idl.IDLI32Type || type == idl.IDLPointerType || type == idl.IDLBooleanType
-            || type == idl.IDLVoidType || converted == "KPointer" || converted == "KInt";
-    }
     isQuickType(type) {
         return idl.asPromise(type) == undefined;
     }
-    tryWriteQuick(method) {
-        var _a;
-        if ((_a = method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(MethodModifier.THROWS))
-            return;
-        if (false && this.isDirectType(method.signature.returnType) && method.signature.args.every((type) => this.isDirectType(type))) {
-            this.print('@ani.unsafe.Direct');
-            return;
-        }
-        if (this.isQuickType(method.signature.returnType)) {
-            this.print('@ani.unsafe.Quick');
-            return;
-        }
-    }
     writeNativeMethodDeclaration(method) {
         if (method.signature.returnType === IDLThisType) {
             throw new Error('static method can not return this!');
         }
-        this.tryWriteQuick(method);
         this.writeMethodDeclaration(method.name, method.signature, [MethodModifier.STATIC, MethodModifier.NATIVE]);
     }
     writeProperty(propName, propType) {
         throw new Error("writeProperty for ArkTS is not implemented yet.");
     }
-    makeEnumCast(value, _unsafe, convertor) {
-        if (convertor === undefined) {
-            throwException(`The makeEnumCast function required EnumConvertor`);
-        }
-        const decl = this.resolver.toDeclaration(convertor.nativeType());
-        if (!idl.isEnum(decl)) {
-            throwException(`Declaration type must be Enum`);
-        }
-        // ((value as Axis) as int) - in case when Axis was casted to Object in Map<Axis, Smth>
-        return this.makeCast(this.makeCast(this.makeString(value), convertor.idlType), IDLI32Type).asString();
-    }
     makeUnionVariantCondition(convertor, valueName, valueType, type, convertorIndex, runtimeTypeIndex) {
         if (idl.isEnum(this.resolver.toDeclaration(convertor.nativeType()))) {
             return this.instanceOf(convertor, valueName);

package/build/lib/src/LanguageWriters/writers/JavaLanguageWriter.d.ts CHANGED Viewed

@@ -78,7 +78,7 @@ export declare class JavaLanguageWriter extends CLikeLanguageWriter {
     ordinalFromEnum(value: LanguageExpression, _: idl.IDLType): LanguageExpression;
     makeValueFromOption(value: string): LanguageExpression;
     runtimeType(param: ArgConvertor, valueType: string, value: string): void;
-    makeEnumCast(enumName: string, _unsafe: boolean, _convertor: ArgConvertor | undefined): string;
+    makeEnumCast(_enumEntry: idl.IDLEnum, enumName: string): string;
     castToBoolean(value: string): string;
     makeLengthSerializer(serializer: string, value: string): LanguageStatement | undefined;
 }

package/build/lib/src/LanguageWriters/writers/JavaLanguageWriter.js CHANGED Viewed

@@ -267,7 +267,7 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
     runtimeType(param, valueType, value) {
         this.writeStatement(this.makeAssign(valueType, undefined, this.makeRuntimeTypeGetterCall(value), false));
     }
-    makeEnumCast(enumName, _unsafe, _convertor) {
+    makeEnumCast(_enumEntry, enumName) {
         return `${enumName}.value`;
     }
     castToBoolean(value) { return value; }

package/build/lib/src/LanguageWriters/writers/TsLanguageWriter.d.ts CHANGED Viewed

@@ -85,7 +85,7 @@ export declare class TSLanguageWriter extends LanguageWriter {
     get supportedFieldModifiers(): FieldModifier[];
     enumFromOrdinal(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
     ordinalFromEnum(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
-    makeEnumCast(enumName: string, unsafe: boolean, convertor: ArgConvertor): string;
+    makeEnumCast(enumEntry: idl.IDLEnum, param: string): string;
     castToBoolean(value: string): string;
     makeCallIsObject(value: string): LanguageExpression;
     escapeKeyword(keyword: string): string;

package/build/lib/src/LanguageWriters/writers/TsLanguageWriter.js CHANGED Viewed

@@ -13,13 +13,13 @@
  * limitations under the License.
  */
 import * as idl from '../../idl';
+import { isOptionalType } from '../../idl';
 import { Language } from '../../Language';
 import { IndentedPrinter } from "../../IndentedPrinter";
 import { AssignStatement, BlockStatement, CheckOptionalStatement, ExpressionStatement, FieldModifier, IfStatement, LambdaExpression, LanguageWriter, Method, MethodModifier, NamedMethodSignature, NaryOpExpression, ReturnStatement, StringExpression } from "../LanguageWriter";
 import { RuntimeType } from "../common";
 import { rightmostIndexOf, throwException } from "../../util";
 import { TSKeywords } from '../../languageSpecificKeywords';
-import { isOptionalType } from "../../idl";
 ////////////////////////////////////////////////////////////////
 //                        EXPRESSIONS                         //
 ////////////////////////////////////////////////////////////////
@@ -388,11 +388,12 @@ export class TSLanguageWriter extends LanguageWriter {
         }
         return value;
     }
-    makeEnumCast(enumName, unsafe, convertor) {
-        if (unsafe) {
-            return this.makeUnsafeCast(convertor, enumName);
-        }
-        return enumName;
+    makeEnumCast(enumEntry, param) {
+        // Take the ordinal value if Enum is a string, and valueOf when it is an integer
+        // Enum.valueOf() - compatible with ArkTS/TS
+        return idl.isStringEnum(enumEntry)
+            ? this.ordinalFromEnum(this.makeString(param), idl.createReferenceType(enumEntry)).asString()
+            : `${param}.valueOf()`;
     }
     castToBoolean(value) { return `+${value}`; }
     makeCallIsObject(value) {

package/build/lib/src/config.d.ts CHANGED Viewed

@@ -13,6 +13,7 @@ export declare const CoreConfigurationSchema: {
                 readonly builderClasses: string[];
                 readonly forceMaterialized: string[];
                 readonly forceCallback: string[];
+                readonly forceContext: string[];
             }>;
             success(): boolean;
             unwrap(): {
@@ -26,6 +27,7 @@ export declare const CoreConfigurationSchema: {
                 readonly builderClasses: string[];
                 readonly forceMaterialized: string[];
                 readonly forceCallback: string[];
+                readonly forceContext: string[];
             };
             error(): string;
             get(): import("./configDescriber").ValidationResult<{
@@ -39,6 +41,7 @@ export declare const CoreConfigurationSchema: {
                 readonly builderClasses: string[];
                 readonly forceMaterialized: string[];
                 readonly forceCallback: string[];
+                readonly forceContext: string[];
             }>;
             or<U>(x: U): {
                 box: import("./configDescriber").ValidationResult<{
@@ -52,6 +55,7 @@ export declare const CoreConfigurationSchema: {
                     readonly builderClasses: string[];
                     readonly forceMaterialized: string[];
                     readonly forceCallback: string[];
+                    readonly forceContext: string[];
                 } | U>;
                 success(): boolean;
                 unwrap(): {
@@ -65,6 +69,7 @@ export declare const CoreConfigurationSchema: {
                     readonly builderClasses: string[];
                     readonly forceMaterialized: string[];
                     readonly forceCallback: string[];
+                    readonly forceContext: string[];
                 } | U;
                 error(): string;
                 get(): import("./configDescriber").ValidationResult<{
@@ -78,6 +83,7 @@ export declare const CoreConfigurationSchema: {
                     readonly builderClasses: string[];
                     readonly forceMaterialized: string[];
                     readonly forceCallback: string[];
+                    readonly forceContext: string[];
                 } | U>;
                 or<U_1>(x: U_1): {
                     box: import("./configDescriber").ValidationResult<{
@@ -91,6 +97,7 @@ export declare const CoreConfigurationSchema: {
                         readonly builderClasses: string[];
                         readonly forceMaterialized: string[];
                         readonly forceCallback: string[];
+                        readonly forceContext: string[];
                     } | U | U_1>;
                     success(): boolean;
                     unwrap(): {
@@ -104,6 +111,7 @@ export declare const CoreConfigurationSchema: {
                         readonly builderClasses: string[];
                         readonly forceMaterialized: string[];
                         readonly forceCallback: string[];
+                        readonly forceContext: string[];
                     } | U | U_1;
                     error(): string;
                     get(): import("./configDescriber").ValidationResult<{
@@ -117,6 +125,7 @@ export declare const CoreConfigurationSchema: {
                         readonly builderClasses: string[];
                         readonly forceMaterialized: string[];
                         readonly forceCallback: string[];
+                        readonly forceContext: string[];
                     } | U | U_1>;
                     or<U_2>(x: U_2): {
                         box: import("./configDescriber").ValidationResult<{
@@ -130,6 +139,7 @@ export declare const CoreConfigurationSchema: {
                             readonly builderClasses: string[];
                             readonly forceMaterialized: string[];
                             readonly forceCallback: string[];
+                            readonly forceContext: string[];
                         } | U | U_1 | U_2>;
                         success(): boolean;
                         unwrap(): {
@@ -143,6 +153,7 @@ export declare const CoreConfigurationSchema: {
                             readonly builderClasses: string[];
                             readonly forceMaterialized: string[];
                             readonly forceCallback: string[];
+                            readonly forceContext: string[];
                         } | U | U_1 | U_2;
                         error(): string;
                         get(): import("./configDescriber").ValidationResult<{
@@ -156,6 +167,7 @@ export declare const CoreConfigurationSchema: {
                             readonly builderClasses: string[];
                             readonly forceMaterialized: string[];
                             readonly forceCallback: string[];
+                            readonly forceContext: string[];
                         } | U | U_1 | U_2>;
                         or<U_3>(x: U_3): {
                             box: import("./configDescriber").ValidationResult<{
@@ -169,6 +181,7 @@ export declare const CoreConfigurationSchema: {
                                 readonly builderClasses: string[];
                                 readonly forceMaterialized: string[];
                                 readonly forceCallback: string[];
+                                readonly forceContext: string[];
                             } | U | U_1 | U_2 | U_3>;
                             success(): boolean;
                             unwrap(): {
@@ -182,6 +195,7 @@ export declare const CoreConfigurationSchema: {
                                 readonly builderClasses: string[];
                                 readonly forceMaterialized: string[];
                                 readonly forceCallback: string[];
+                                readonly forceContext: string[];
                             } | U | U_1 | U_2 | U_3;
                             error(): string;
                             get(): import("./configDescriber").ValidationResult<{
@@ -195,6 +209,7 @@ export declare const CoreConfigurationSchema: {
                                 readonly builderClasses: string[];
                                 readonly forceMaterialized: string[];
                                 readonly forceCallback: string[];
+                                readonly forceContext: string[];
                             } | U | U_1 | U_2 | U_3>;
                             or<U_4>(x: U_4): {
                                 box: import("./configDescriber").ValidationResult<{
@@ -208,6 +223,7 @@ export declare const CoreConfigurationSchema: {
                                     readonly builderClasses: string[];
                                     readonly forceMaterialized: string[];
                                     readonly forceCallback: string[];
+                                    readonly forceContext: string[];
                                 } | U | U_1 | U_2 | U_3 | U_4>;
                                 success(): boolean;
                                 unwrap(): {
@@ -221,6 +237,7 @@ export declare const CoreConfigurationSchema: {
                                     readonly builderClasses: string[];
                                     readonly forceMaterialized: string[];
                                     readonly forceCallback: string[];
+                                    readonly forceContext: string[];
                                 } | U | U_1 | U_2 | U_3 | U_4;
                                 error(): string;
                                 get(): import("./configDescriber").ValidationResult<{
@@ -234,6 +251,7 @@ export declare const CoreConfigurationSchema: {
                                     readonly builderClasses: string[];
                                     readonly forceMaterialized: string[];
                                     readonly forceCallback: string[];
+                                    readonly forceContext: string[];
                                 } | U | U_1 | U_2 | U_3 | U_4>;
                                 or<U_5>(x: U_5): {
                                     box: import("./configDescriber").ValidationResult<{
@@ -247,6 +265,7 @@ export declare const CoreConfigurationSchema: {
                                         readonly builderClasses: string[];
                                         readonly forceMaterialized: string[];
                                         readonly forceCallback: string[];
+                                        readonly forceContext: string[];
                                     } | U | U_1 | U_2 | U_3 | U_4 | U_5>;
                                     success(): boolean;
                                     unwrap(): {
@@ -260,6 +279,7 @@ export declare const CoreConfigurationSchema: {
                                         readonly builderClasses: string[];
                                         readonly forceMaterialized: string[];
                                         readonly forceCallback: string[];
+                                        readonly forceContext: string[];
                                     } | U | U_1 | U_2 | U_3 | U_4 | U_5;
                                     error(): string;
                                     get(): import("./configDescriber").ValidationResult<{
@@ -273,6 +293,7 @@ export declare const CoreConfigurationSchema: {
                                         readonly builderClasses: string[];
                                         readonly forceMaterialized: string[];
                                         readonly forceCallback: string[];
+                                        readonly forceContext: string[];
                                     } | U | U_1 | U_2 | U_3 | U_4 | U_5>;
                                     or<U_6>(x: U_6): {
                                         box: import("./configDescriber").ValidationResult<{
@@ -286,6 +307,7 @@ export declare const CoreConfigurationSchema: {
                                             readonly builderClasses: string[];
                                             readonly forceMaterialized: string[];
                                             readonly forceCallback: string[];
+                                            readonly forceContext: string[];
                                         } | U | U_1 | U_2 | U_3 | U_4 | U_5 | U_6>;
                                         success(): boolean;
                                         unwrap(): {
@@ -299,6 +321,7 @@ export declare const CoreConfigurationSchema: {
                                             readonly builderClasses: string[];
                                             readonly forceMaterialized: string[];
                                             readonly forceCallback: string[];
+                                            readonly forceContext: string[];
                                         } | U | U_1 | U_2 | U_3 | U_4 | U_5 | U_6;
                                         error(): string;
                                         get(): import("./configDescriber").ValidationResult<{
@@ -312,6 +335,7 @@ export declare const CoreConfigurationSchema: {
                                             readonly builderClasses: string[];
                                             readonly forceMaterialized: string[];
                                             readonly forceCallback: string[];
+                                            readonly forceContext: string[];
                                         } | U | U_1 | U_2 | U_3 | U_4 | U_5 | U_6>;
                                         or<U_7>(x: U_7): {
                                             box: import("./configDescriber").ValidationResult<{
@@ -325,6 +349,7 @@ export declare const CoreConfigurationSchema: {
                                                 readonly builderClasses: string[];
                                                 readonly forceMaterialized: string[];
                                                 readonly forceCallback: string[];
+                                                readonly forceContext: string[];
                                             } | U | U_1 | U_2 | U_3 | U_4 | U_5 | U_6 | U_7>;
                                             success(): boolean;
                                             unwrap(): {
@@ -338,6 +363,7 @@ export declare const CoreConfigurationSchema: {
                                                 readonly builderClasses: string[];
                                                 readonly forceMaterialized: string[];
                                                 readonly forceCallback: string[];
+                                                readonly forceContext: string[];
                                             } | U | U_1 | U_2 | U_3 | U_4 | U_5 | U_6 | U_7;
                                             error(): string;
                                             get(): import("./configDescriber").ValidationResult<{
@@ -351,6 +377,7 @@ export declare const CoreConfigurationSchema: {
                                                 readonly builderClasses: string[];
                                                 readonly forceMaterialized: string[];
                                                 readonly forceCallback: string[];
+                                                readonly forceContext: string[];
                                             } | U | U_1 | U_2 | U_3 | U_4 | U_5 | U_6 | U_7>;
                                             or<U_8>(x: U_8): {
                                                 box: import("./configDescriber").ValidationResult<{
@@ -364,6 +391,7 @@ export declare const CoreConfigurationSchema: {
                                                     readonly builderClasses: string[];
                                                     readonly forceMaterialized: string[];
                                                     readonly forceCallback: string[];
+                                                    readonly forceContext: string[];
                                                 } | U | U_1 | U_2 | U_3 | U_4 | U_5 | U_6 | U_7 | U_8>;
                                                 success(): boolean;
                                                 unwrap(): {
@@ -377,6 +405,7 @@ export declare const CoreConfigurationSchema: {
                                                     readonly builderClasses: string[];
                                                     readonly forceMaterialized: string[];
                                                     readonly forceCallback: string[];
+                                                    readonly forceContext: string[];
                                                 } | U | U_1 | U_2 | U_3 | U_4 | U_5 | U_6 | U_7 | U_8;
                                                 error(): string;
                                                 get(): import("./configDescriber").ValidationResult<{
@@ -390,6 +419,7 @@ export declare const CoreConfigurationSchema: {
                                                     readonly builderClasses: string[];
                                                     readonly forceMaterialized: string[];
                                                     readonly forceCallback: string[];
+                                                    readonly forceContext: string[];
                                                 } | U | U_1 | U_2 | U_3 | U_4 | U_5 | U_6 | U_7 | U_8>;
                                                 or<U_9>(x: U_9): {
                                                     box: import("./configDescriber").ValidationResult<{
@@ -403,6 +433,7 @@ export declare const CoreConfigurationSchema: {
                                                         readonly builderClasses: string[];
                                                         readonly forceMaterialized: string[];
                                                         readonly forceCallback: string[];
+                                                        readonly forceContext: string[];
                                                     } | U | U_1 | U_2 | U_3 | U_4 | U_5 | U_6 | U_7 | U_8 | U_9>;
                                                     success(): boolean;
                                                     unwrap(): {
@@ -416,6 +447,7 @@ export declare const CoreConfigurationSchema: {
                                                         readonly builderClasses: string[];
                                                         readonly forceMaterialized: string[];
                                                         readonly forceCallback: string[];
+                                                        readonly forceContext: string[];
                                                     } | U | U_1 | U_2 | U_3 | U_4 | U_5 | U_6 | U_7 | U_8 | U_9;
                                                     error(): string;
                                                     get(): import("./configDescriber").ValidationResult<{
@@ -429,6 +461,7 @@ export declare const CoreConfigurationSchema: {
                                                         readonly builderClasses: string[];
                                                         readonly forceMaterialized: string[];
                                                         readonly forceCallback: string[];
+                                                        readonly forceContext: string[];
                                                     } | U | U_1 | U_2 | U_3 | U_4 | U_5 | U_6 | U_7 | U_8 | U_9>;
                                                     or<U_10>(x: U_10): any;
                                                 };
@@ -456,6 +489,7 @@ export declare const CoreConfigurationSchema: {
             readonly builderClasses: string[];
             readonly forceMaterialized: string[];
             readonly forceCallback: string[];
+            readonly forceContext: string[];
         }>;
         success(): boolean;
         unwrap(): {
@@ -469,6 +503,7 @@ export declare const CoreConfigurationSchema: {
             readonly builderClasses: string[];
             readonly forceMaterialized: string[];
             readonly forceCallback: string[];
+            readonly forceContext: string[];
         };
         error(): string;
         get(): import("./configDescriber").ValidationResult<{
@@ -482,6 +517,7 @@ export declare const CoreConfigurationSchema: {
             readonly builderClasses: string[];
             readonly forceMaterialized: string[];
             readonly forceCallback: string[];
+            readonly forceContext: string[];
         }>;
         or<U>(x: U): {
             box: import("./configDescriber").ValidationResult<{
@@ -495,6 +531,7 @@ export declare const CoreConfigurationSchema: {
                 readonly builderClasses: string[];
                 readonly forceMaterialized: string[];
                 readonly forceCallback: string[];
+                readonly forceContext: string[];
             } | U>;
             success(): boolean;
             unwrap(): {
@@ -508,6 +545,7 @@ export declare const CoreConfigurationSchema: {
                 readonly builderClasses: string[];
                 readonly forceMaterialized: string[];
                 readonly forceCallback: string[];
+                readonly forceContext: string[];
             } | U;
             error(): string;
             get(): import("./configDescriber").ValidationResult<{
@@ -521,6 +559,7 @@ export declare const CoreConfigurationSchema: {
                 readonly builderClasses: string[];
                 readonly forceMaterialized: string[];
                 readonly forceCallback: string[];
+                readonly forceContext: string[];
             } | U>;
             or<U_1>(x: U_1): {
                 box: import("./configDescriber").ValidationResult<{
@@ -534,6 +573,7 @@ export declare const CoreConfigurationSchema: {
                     readonly builderClasses: string[];
                     readonly forceMaterialized: string[];
                     readonly forceCallback: string[];
+                    readonly forceContext: string[];
                 } | U | U_1>;
                 success(): boolean;
                 unwrap(): {
@@ -547,6 +587,7 @@ export declare const CoreConfigurationSchema: {
                     readonly builderClasses: string[];
                     readonly forceMaterialized: string[];
                     readonly forceCallback: string[];
+                    readonly forceContext: string[];
                 } | U | U_1;
                 error(): string;
                 get(): import("./configDescriber").ValidationResult<{
@@ -560,6 +601,7 @@ export declare const CoreConfigurationSchema: {
                     readonly builderClasses: string[];
                     readonly forceMaterialized: string[];
                     readonly forceCallback: string[];
+                    readonly forceContext: string[];
                 } | U | U_1>;
                 or<U_2>(x: U_2): {
                     box: import("./configDescriber").ValidationResult<{
@@ -573,6 +615,7 @@ export declare const CoreConfigurationSchema: {
                         readonly builderClasses: string[];
                         readonly forceMaterialized: string[];
                         readonly forceCallback: string[];
+                        readonly forceContext: string[];
                     } | U | U_1 | U_2>;
                     success(): boolean;
                     unwrap(): {
@@ -586,6 +629,7 @@ export declare const CoreConfigurationSchema: {
                         readonly builderClasses: string[];
                         readonly forceMaterialized: string[];
                         readonly forceCallback: string[];
+                        readonly forceContext: string[];
                     } | U | U_1 | U_2;
                     error(): string;
                     get(): import("./configDescriber").ValidationResult<{
@@ -599,6 +643,7 @@ export declare const CoreConfigurationSchema: {
                         readonly builderClasses: string[];
                         readonly forceMaterialized: string[];
                         readonly forceCallback: string[];
+                        readonly forceContext: string[];
                     } | U | U_1 | U_2>;
                     or<U_3>(x: U_3): {
                         box: import("./configDescriber").ValidationResult<{
@@ -612,6 +657,7 @@ export declare const CoreConfigurationSchema: {
                             readonly builderClasses: string[];
                             readonly forceMaterialized: string[];
                             readonly forceCallback: string[];
+                            readonly forceContext: string[];
                         } | U | U_1 | U_2 | U_3>;
                         success(): boolean;
                         unwrap(): {
@@ -625,6 +671,7 @@ export declare const CoreConfigurationSchema: {
                             readonly builderClasses: string[];
                             readonly forceMaterialized: string[];
                             readonly forceCallback: string[];
+                            readonly forceContext: string[];
                         } | U | U_1 | U_2 | U_3;
                         error(): string;
                         get(): import("./configDescriber").ValidationResult<{
@@ -638,6 +685,7 @@ export declare const CoreConfigurationSchema: {
                             readonly builderClasses: string[];
                             readonly forceMaterialized: string[];
                             readonly forceCallback: string[];
+                            readonly forceContext: string[];
                         } | U | U_1 | U_2 | U_3>;
                         or<U_4>(x: U_4): {
                             box: import("./configDescriber").ValidationResult<{
@@ -651,6 +699,7 @@ export declare const CoreConfigurationSchema: {
                                 readonly builderClasses: string[];
                                 readonly forceMaterialized: string[];
                                 readonly forceCallback: string[];
+                                readonly forceContext: string[];
                             } | U | U_1 | U_2 | U_3 | U_4>;
                             success(): boolean;
                             unwrap(): {
@@ -664,6 +713,7 @@ export declare const CoreConfigurationSchema: {
                                 readonly builderClasses: string[];
                                 readonly forceMaterialized: string[];
                                 readonly forceCallback: string[];
+                                readonly forceContext: string[];
                             } | U | U_1 | U_2 | U_3 | U_4;
                             error(): string;
                             get(): import("./configDescriber").ValidationResult<{
@@ -677,6 +727,7 @@ export declare const CoreConfigurationSchema: {
                                 readonly builderClasses: string[];
                                 readonly forceMaterialized: string[];
                                 readonly forceCallback: string[];
+                                readonly forceContext: string[];
                             } | U | U_1 | U_2 | U_3 | U_4>;
                             or<U_5>(x: U_5): {
                                 box: import("./configDescriber").ValidationResult<{
@@ -690,6 +741,7 @@ export declare const CoreConfigurationSchema: {
                                     readonly builderClasses: string[];
                                     readonly forceMaterialized: string[];
                                     readonly forceCallback: string[];
+                                    readonly forceContext: string[];
                                 } | U | U_1 | U_2 | U_3 | U_4 | U_5>;
                                 success(): boolean;
                                 unwrap(): {
@@ -703,6 +755,7 @@ export declare const CoreConfigurationSchema: {
                                     readonly builderClasses: string[];
                                     readonly forceMaterialized: string[];
                                     readonly forceCallback: string[];
+                                    readonly forceContext: string[];
                                 } | U | U_1 | U_2 | U_3 | U_4 | U_5;
                                 error(): string;
                                 get(): import("./configDescriber").ValidationResult<{
@@ -716,6 +769,7 @@ export declare const CoreConfigurationSchema: {
                                     readonly builderClasses: string[];
                                     readonly forceMaterialized: string[];
                                     readonly forceCallback: string[];
+                                    readonly forceContext: string[];
                                 } | U | U_1 | U_2 | U_3 | U_4 | U_5>;
                                 or<U_6>(x: U_6): {
                                     box: import("./configDescriber").ValidationResult<{
@@ -729,6 +783,7 @@ export declare const CoreConfigurationSchema: {
                                         readonly builderClasses: string[];
                                         readonly forceMaterialized: string[];
                                         readonly forceCallback: string[];
+                                        readonly forceContext: string[];
                                     } | U | U_1 | U_2 | U_3 | U_4 | U_5 | U_6>;
                                     success(): boolean;
                                     unwrap(): {
@@ -742,6 +797,7 @@ export declare const CoreConfigurationSchema: {
                                         readonly builderClasses: string[];
                                         readonly forceMaterialized: string[];
                                         readonly forceCallback: string[];
+                                        readonly forceContext: string[];
                                     } | U | U_1 | U_2 | U_3 | U_4 | U_5 | U_6;
                                     error(): string;
                                     get(): import("./configDescriber").ValidationResult<{
@@ -755,6 +811,7 @@ export declare const CoreConfigurationSchema: {
                                         readonly builderClasses: string[];
                                         readonly forceMaterialized: string[];
                                         readonly forceCallback: string[];
+                                        readonly forceContext: string[];
                                     } | U | U_1 | U_2 | U_3 | U_4 | U_5 | U_6>;
                                     or<U_7>(x: U_7): {
                                         box: import("./configDescriber").ValidationResult<{
@@ -768,6 +825,7 @@ export declare const CoreConfigurationSchema: {
                                             readonly builderClasses: string[];
                                             readonly forceMaterialized: string[];
                                             readonly forceCallback: string[];
+                                            readonly forceContext: string[];
                                         } | U | U_1 | U_2 | U_3 | U_4 | U_5 | U_6 | U_7>;
                                         success(): boolean;
                                         unwrap(): {
@@ -781,6 +839,7 @@ export declare const CoreConfigurationSchema: {
                                             readonly builderClasses: string[];
                                             readonly forceMaterialized: string[];
                                             readonly forceCallback: string[];
+                                            readonly forceContext: string[];
                                         } | U | U_1 | U_2 | U_3 | U_4 | U_5 | U_6 | U_7;
                                         error(): string;
                                         get(): import("./configDescriber").ValidationResult<{
@@ -794,6 +853,7 @@ export declare const CoreConfigurationSchema: {
                                             readonly builderClasses: string[];
                                             readonly forceMaterialized: string[];
                                             readonly forceCallback: string[];
+                                            readonly forceContext: string[];
                                         } | U | U_1 | U_2 | U_3 | U_4 | U_5 | U_6 | U_7>;
                                         or<U_8>(x: U_8): {
                                             box: import("./configDescriber").ValidationResult<{
@@ -807,6 +867,7 @@ export declare const CoreConfigurationSchema: {
                                                 readonly builderClasses: string[];
                                                 readonly forceMaterialized: string[];
                                                 readonly forceCallback: string[];
+                                                readonly forceContext: string[];
                                             } | U | U_1 | U_2 | U_3 | U_4 | U_5 | U_6 | U_7 | U_8>;
                                             success(): boolean;
                                             unwrap(): {
@@ -820,6 +881,7 @@ export declare const CoreConfigurationSchema: {
                                                 readonly builderClasses: string[];
                                                 readonly forceMaterialized: string[];
                                                 readonly forceCallback: string[];
+                                                readonly forceContext: string[];
                                             } | U | U_1 | U_2 | U_3 | U_4 | U_5 | U_6 | U_7 | U_8;
                                             error(): string;
                                             get(): import("./configDescriber").ValidationResult<{
@@ -833,6 +895,7 @@ export declare const CoreConfigurationSchema: {
                                                 readonly builderClasses: string[];
                                                 readonly forceMaterialized: string[];
                                                 readonly forceCallback: string[];
+                                                readonly forceContext: string[];
                                             } | U | U_1 | U_2 | U_3 | U_4 | U_5 | U_6 | U_7 | U_8>;
                                             or<U_9>(x: U_9): {
                                                 box: import("./configDescriber").ValidationResult<{
@@ -846,6 +909,7 @@ export declare const CoreConfigurationSchema: {
                                                     readonly builderClasses: string[];
                                                     readonly forceMaterialized: string[];
                                                     readonly forceCallback: string[];
+                                                    readonly forceContext: string[];
                                                 } | U | U_1 | U_2 | U_3 | U_4 | U_5 | U_6 | U_7 | U_8 | U_9>;
                                                 success(): boolean;
                                                 unwrap(): {
@@ -859,6 +923,7 @@ export declare const CoreConfigurationSchema: {
                                                     readonly builderClasses: string[];
                                                     readonly forceMaterialized: string[];
                                                     readonly forceCallback: string[];
+                                                    readonly forceContext: string[];
                                                 } | U | U_1 | U_2 | U_3 | U_4 | U_5 | U_6 | U_7 | U_8 | U_9;
                                                 error(): string;
                                                 get(): import("./configDescriber").ValidationResult<{
@@ -872,6 +937,7 @@ export declare const CoreConfigurationSchema: {
                                                     readonly builderClasses: string[];
                                                     readonly forceMaterialized: string[];
                                                     readonly forceCallback: string[];
+                                                    readonly forceContext: string[];
                                                 } | U | U_1 | U_2 | U_3 | U_4 | U_5 | U_6 | U_7 | U_8 | U_9>;
                                                 or<U_10>(x: U_10): any;
                                             };

package/build/lib/src/config.js CHANGED Viewed

@@ -27,6 +27,7 @@ export const CoreConfigurationSchema = D.object({
     builderClasses: T.stringArray(),
     forceMaterialized: T.stringArray(),
     forceCallback: T.stringArray(),
+    forceContext: T.stringArray(),
 });
 export const defaultCoreConfiguration = {
     TypePrefix: "",
@@ -39,6 +40,7 @@ export const defaultCoreConfiguration = {
     builderClasses: [],
     forceMaterialized: [],
     forceCallback: [],
+    forceContext: [],
 };
 let currentConfig = defaultCoreConfiguration;
 export function setDefaultConfiguration(config) {

package/build/lib/src/peer-generation/PeerLibrary.js CHANGED Viewed

@@ -152,6 +152,8 @@ export class PeerLibrary {
             return entry;
         const qualifiedName = type.name.split(".");
         let pointOfViewNamespace = idl.fetchNamespaceFrom(type.parent);
+        // TODO: Choose what to do if `rootEntries.some(it => idl.isNamespace(it))`
+        // One of possible options - `rootEntries = rootEntries.flatMap(it => idl.isNamespace(it) ? it.members : it)` - cause error
         rootEntries !== null && rootEntries !== void 0 ? rootEntries : (rootEntries = this.files.flatMap(it => it.entries));
         if (1 === qualifiedName.length) {
             const predefined = rootEntries.filter(it => isInIdlizeInternal(it));
@@ -248,6 +250,17 @@ export class PeerLibrary {
         if (idl.isReferenceType(type)) {
             if (isImportAttr(type))
                 return new ImportTypeConvertor(param, this.targetNameConvertorInstance.convert(type));
+            // TODO: special cases for interop types.
+            switch (type.name) {
+                case 'KBoolean': return new BooleanConvertor(param);
+                case 'KInt': return new NumericConvertor(param, idl.IDLI32Type);
+                case 'KFloat': return new NumericConvertor(param, idl.IDLF32Type);
+                case 'KLong': return new NumericConvertor(param, idl.IDLI64Type);
+                case 'KDouble': return new NumericConvertor(param, idl.IDLF64Type);
+                case 'KStringPtr': return new StringConvertor(param);
+                case 'number': return new NumberConvertor(param);
+                case 'KPointer': return new PointerConvertor(param);
+            }
             const decl = this.resolveTypeReference(type);
             return this.declarationConvertor(param, type, decl);
         }

package/build/lib/src/peer-generation/PeerMethod.js CHANGED Viewed

@@ -1,19 +1,6 @@
-/*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 import { generatorTypePrefix } from "../config";
 import { asPromise } from "../idl";
+import { isVMContextMethod } from "../LanguageWriters/ArgConvertors";
 import { mangleMethodName, MethodModifier } from "../LanguageWriters/LanguageWriter";
 import { capitalize, isDefined } from "../util";
 import { PrimitiveTypesInstance } from "./PrimitiveType";
@@ -71,7 +58,6 @@ export class PeerMethod {
         return !((_a = this.method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(MethodModifier.STATIC));
     }
     generateAPIParameters(converter) {
-        var _a;
         const args = this.argAndOutConvertors.map(it => {
             let isPointer = it.isPointerType();
             return `${isPointer ? "const " : ""}${converter.convert(it.nativeType())}${isPointer ? "*" : ""} ${it.param}`;
@@ -81,7 +67,7 @@ export class PeerMethod {
             args.unshift(`${receiver.argType} ${receiver.argName}`);
         if (!!asPromise(this.method.signature.returnType))
             args.unshift(`${generatorTypePrefix()}AsyncWorkerPtr asyncWorker`);
-        if (!!asPromise(this.method.signature.returnType) || ((_a = this.method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(MethodModifier.THROWS)))
+        if (isVMContextMethod(this.method))
             args.unshift(`${generatorTypePrefix()}VMContext vmContext`);
         return args;
     }

package/build/lib/src/peer-generation/isMaterialized.js CHANGED Viewed

@@ -47,7 +47,22 @@ export function isMaterialized(declaration, resolver) {
     return false;
 }
 export function isStaticMaterialized(declaration, resolver) {
-    return isMaterialized(declaration, resolver) && (declaration.methods.length > 0 && declaration.methods.every(it => it.isStatic)) && !declaration.properties.length && !declaration.constructors.length;
+    if (isMaterialized(declaration, resolver)) {
+        if (declaration.properties.length || declaration.constructors.length)
+            return false;
+        if (!declaration.methods.every(it => it.isStatic))
+            return false;
+        if (idl.hasSuperType(declaration)) {
+            const superType = resolver.resolveTypeReference(idl.getSuperType(declaration));
+            if (!superType || !idl.isInterface(superType)) {
+                console.log(`Unable to resolve ${idl.getSuperType(declaration).name} type, consider ${declaration.name} to be not materialized`);
+                return false;
+            }
+            return isStaticMaterialized(superType, resolver);
+        }
+        return true;
+    }
+    return false;
 }
 export function isMaterializedType(type, resolver) {
     if (!idl.isReferenceType(type))

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@idlizer/core",
-  "version": "2.0.43",
+  "version": "2.1.0",
   "description": "",
   "types": "build/lib/src/index.d.ts",
   "exports": {
@@ -34,7 +34,7 @@
   },
   "keywords": [],
   "dependencies": {
-    "@koalaui/interop": "1.5.8",
+    "@koalaui/interop": "1.5.9",
     "typescript": "4.9.5",
     "@types/node": "^18.0.0"
   },