@idlizer/core 2.0.41 → 2.0.43

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

@@ -227,7 +227,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;
@@ -315,7 +315,8 @@ 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;
+    tryWriteQuick(method: Method): void;
+    writeNativeMethodDeclaration(method: Method): void;
     writeUnsafeNativeMethodDeclaration(name: string, signature: MethodSignature): void;
     pushIndent(): void;
     popIndent(): void;

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

@@ -565,8 +565,10 @@ export class LanguageWriter {
     makeStatement(expr) {
         return new ExpressionStatement(expr);
     }
-    writeNativeMethodDeclaration(name, signature, isNative) {
-        this.writeMethodDeclaration(name, signature);
+    tryWriteQuick(method) { }
+    writeNativeMethodDeclaration(method) {
+        this.tryWriteQuick(method);
+        this.writeMethodDeclaration(method.name, method.signature);
     }
     writeUnsafeNativeMethodDeclaration(name, signature) {
         return;

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

@@ -30,6 +30,7 @@ export declare class GenericCppConvertor implements NodeConvertor<ConvertResult>
 }
 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;
@@ -42,7 +43,7 @@ export class GenericCppConvertor {
                     : this.make(this.computeTargetTypeLiteralName(node), true);
             case idl.IDLInterfaceSubkind.Interface:
             case idl.IDLInterfaceSubkind.Class:
-                if (idl.hasExtAttribute(node, idl.IDLExtendedAttributes.Predefined)) {
+                if (isInIdlizeInternal(node)) {
                     return this.make(node.name, true);
                 }
                 return this.make(node.name);
@@ -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));
     }

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,7 +96,7 @@ 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;
+    writeNativeMethodDeclaration(method: Method): void;
     makeEnumCast(enumName: string, _unsafe: boolean, _convertor: ArgConvertor | undefined): string;
     makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression, isDeclared?: boolean, isConst?: boolean): LanguageStatement;
     makeClassInit(type: idl.IDLType, parameters: LanguageExpression[]): 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,10 +404,11 @@ 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) {
         return `${enumName}.value`;

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

@@ -41,7 +41,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;

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

@@ -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) {

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

@@ -1,5 +1,5 @@
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { LambdaExpression, LanguageExpression, LanguageStatement, LanguageWriter, MakeCastOptions, MethodModifier, MethodSignature, ObjectArgs } from "../LanguageWriter";
+import { LambdaExpression, LanguageExpression, LanguageStatement, LanguageWriter, MakeCastOptions, Method, MethodModifier, MethodSignature, ObjectArgs } from "../LanguageWriter";
 import { TSLanguageWriter } from "./TsLanguageWriter";
 import { IDLEnum, IDLType } from '../../idl';
 import { ArgConvertor } from "../ArgConvertors";
@@ -28,6 +28,8 @@ export declare class ETSLambdaExpression extends LambdaExpression {
     asString(): string;
 }
 export declare function generateTypeCheckerName(typeName: string): string;
+export declare function generateEnumToOrdinalName(typeName: string): string;
+export declare function generateEnumFromOrdinalName(typeName: string): string;
 export declare function makeArrayTypeCheckCall(valueAccessor: string, typeName: string, writer: LanguageWriter): LanguageExpression;
 export declare class ETSLanguageWriter extends TSLanguageWriter {
     private arrayConvertor;
@@ -35,7 +37,6 @@ export declare class ETSLanguageWriter extends TSLanguageWriter {
     fork(options?: {
         resolver?: ReferenceResolver;
     }): LanguageWriter;
-    writeNativeMethodDeclaration(name: string, signature: MethodSignature): void;
     makeAssign(variableName: string, type: IDLType | undefined, expr: LanguageExpression, isDeclared?: boolean, isConst?: boolean): LanguageStatement;
     makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
     makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;
@@ -45,7 +46,7 @@ export declare class ETSLanguageWriter extends TSLanguageWriter {
     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;
-    ordinalFromEnum(value: LanguageExpression, _: idl.IDLType): LanguageExpression;
+    ordinalFromEnum(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
     makeDiscriminatorFromFields(convertor: {
         targetType: (writer: LanguageWriter) => string;
     }, value: string, accessors: string[], duplicates: Set<string>): LanguageExpression;
@@ -54,6 +55,10 @@ 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;

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

@@ -16,7 +16,7 @@ import { IndentedPrinter } from "../../IndentedPrinter";
 import { LambdaExpression, MethodModifier } from "../LanguageWriter";
 import { TSCastExpression, TSLanguageWriter } from "./TsLanguageWriter";
 import { getExtAttribute, IDLI32Type, IDLThisType } from '../../idl';
-import { AggregateConvertor, ArrayConvertor, CustomTypeConvertor, InterfaceConvertor, MaterializedClassConvertor, OptionConvertor, UnionConvertor } from "../ArgConvertors";
+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";
@@ -138,6 +138,14 @@ export function generateTypeCheckerName(typeName) {
         .replaceAll('.', ''); // Todo: hack for namespaces
     return `is${typeName.replaceAll('[]', 'Brackets')}`;
 }
+export function generateEnumToOrdinalName(typeName) {
+    typeName = typeName.split(".").join("_");
+    return `${typeName}_ToOrdinal`;
+}
+export function generateEnumFromOrdinalName(typeName) {
+    typeName = typeName.split(".").join("_");
+    return `${typeName}_FromOrdinal`;
+}
 export function makeArrayTypeCheckCall(valueAccessor, typeName, writer) {
     return writer.makeMethodCall("TypeChecker", generateTypeCheckerName(typeName), [writer.makeString(valueAccessor)
     ]);
@@ -154,12 +162,6 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         var _a;
         return new ETSLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.arrayConvertor);
     }
-    writeNativeMethodDeclaration(name, signature) {
-        if (signature.returnType === IDLThisType) {
-            throw new Error('static method can not return this!');
-        }
-        this.writeMethodDeclaration(name, signature, [MethodModifier.STATIC, MethodModifier.NATIVE]);
-    }
     makeAssign(variableName, type, expr, isDeclared = true, isConst = true) {
         return new EtsAssignStatement(variableName, type, expr, isDeclared, isConst);
     }
@@ -190,10 +192,11 @@ export class ETSLanguageWriter extends TSLanguageWriter {
     }
     enumFromOrdinal(value, enumEntry) {
         const enumName = this.getNodeName(enumEntry);
-        return this.makeString(`${value.asString()} as ${enumName}`);
+        return this.makeMethodCall('TypeChecker', generateEnumFromOrdinalName(enumName), [this.makeString(value.asString())]);
     }
-    ordinalFromEnum(value, _) {
-        return this.makeCast(this.makeString(`${value.asString()}`), IDLI32Type);
+    ordinalFromEnum(value, enumEntry) {
+        const enumName = this.getNodeName(enumEntry);
+        return this.makeMethodCall('TypeChecker', generateEnumToOrdinalName(enumName), [this.makeString(value.asString())]);
     }
     makeDiscriminatorFromFields(convertor, value, accessors, duplicates) {
         if (convertor instanceof AggregateConvertor
@@ -223,6 +226,34 @@ 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.");
     }
@@ -289,6 +320,9 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         if (convertor instanceof InterfaceConvertor || convertor instanceof MaterializedClassConvertor) {
             return makeInterfaceTypeCheckerCall(value, this.getNodeName(convertor.idlType), convertor.declaration.properties.filter(it => !it.isStatic).map(it => it.name), duplicateMembers, this);
         }
+        if (convertor instanceof BufferConvertor) {
+            return makeInterfaceTypeCheckerCall(value, this.getNodeName(convertor.idlType), [], new Set(), this);
+        }
         if (convertor instanceof AggregateConvertor) {
             return makeInterfaceTypeCheckerCall(value, convertor.aliasName !== undefined ? convertor.aliasName : this.getNodeName(convertor.idlType), convertor.members.map(it => it[0]), duplicateMembers, this);
         }

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

@@ -35,10 +35,10 @@ export declare class JavaLanguageWriter extends CLikeLanguageWriter {
         resolver?: ReferenceResolver;
     }): LanguageWriter;
     writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[], generics?: string[], isDeclared?: boolean, isExport?: boolean): 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: idl.IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
-    writeNativeMethodDeclaration(name: string, signature: MethodSignature): void;
+    writeNativeMethodDeclaration(method: Method): void;
     writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
     writeProperty(propName: string, propType: idl.IDLType): void;
     writeTypeDeclaration(decl: idl.IDLTypedef): void;

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

@@ -116,7 +116,7 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
         this.popIndent();
         this.printer.print(`}`);
     }
-    writeInterface(name, op, superInterfaces) {
+    writeInterface(name, op, superInterfaces, generics) {
         let extendsClause = superInterfaces ? ` extends ${superInterfaces.join(",")}` : '';
         this.printer.print(`interface ${name}${extendsClause} {`);
         this.pushIndent();
@@ -136,8 +136,8 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
         let prefix = this.makeFieldModifiersList(modifiers);
         this.printer.print(`${prefix} ${(this.getNodeName(type))} ${name}${initExpr ? ` = ${initExpr.asString()}` : ""};`);
     }
-    writeNativeMethodDeclaration(name, signature) {
-        this.writeMethodDeclaration(name, signature, [MethodModifier.STATIC, MethodModifier.NATIVE]);
+    writeNativeMethodDeclaration(method) {
+        this.writeMethodDeclaration(method.name, method.signature, [MethodModifier.STATIC, MethodModifier.NATIVE]);
     }
     writeConstructorImplementation(className, signature, op, superCall, modifiers) {
         this.printer.print(`${modifiers ? modifiers.map((it) => MethodModifier[it].toLowerCase()).join(' ') : ''} ${className}(${signature.args.map((it, index) => `${this.getNodeName(it)} ${signature.argName(index)}`).join(", ")}) {`);

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

@@ -38,7 +38,7 @@ export declare class TSLanguageWriter extends LanguageWriter {
     }): LanguageWriter;
     getNodeName(type: idl.IDLNode): string;
     writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[], generics?: string[], isDeclared?: boolean, isAbstract?: boolean): void;
-    writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[], isDeclared?: boolean): void;
+    writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[], generics?: string[], isDeclared?: boolean): void;
     writeFunctionDeclaration(name: string, signature: MethodSignature): void;
     writeFunctionImplementation(name: string, signature: MethodSignature, op: (writer: this) => void): void;
     private generateFunctionDeclaration;
@@ -49,7 +49,7 @@ export declare class TSLanguageWriter extends LanguageWriter {
         numberId: number;
     }[]): void;
     writeFieldDeclaration(name: string, type: idl.IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
-    writeNativeMethodDeclaration(name: string, signature: MethodSignature, isNative?: boolean): void;
+    writeNativeMethodDeclaration(method: Method): void;
     writeMethodDeclaration(name: string, signature: MethodSignature, modifiers?: MethodModifier[]): void;
     writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
     writeMethodImplementation(method: Method, op: (writer: this) => void): void;

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

@@ -17,8 +17,9 @@ 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 { throwException } from "../../util";
+import { rightmostIndexOf, throwException } from "../../util";
 import { TSKeywords } from '../../languageSpecificKeywords';
+import { isOptionalType } from "../../idl";
 ////////////////////////////////////////////////////////////////
 //                        EXPRESSIONS                         //
 ////////////////////////////////////////////////////////////////
@@ -155,9 +156,10 @@ export class TSLanguageWriter extends LanguageWriter {
         this.popIndent();
         this.printer.print(`}`);
     }
-    writeInterface(name, op, superInterfaces, isDeclared) {
+    writeInterface(name, op, superInterfaces, generics, isDeclared) {
+        const genericsClause = (generics === null || generics === void 0 ? void 0 : generics.length) ? `<${generics.join(", ")}>` : '';
         let extendsClause = superInterfaces ? ` extends ${superInterfaces.join(",")}` : '';
-        this.printer.print(`export ${isDeclared ? "declare " : ""}interface ${name}${extendsClause} {`);
+        this.printer.print(`export ${isDeclared ? "declare " : ""}interface ${name}${genericsClause}${extendsClause} {`);
         this.pushIndent();
         op(this);
         this.popIndent();
@@ -174,7 +176,11 @@ export class TSLanguageWriter extends LanguageWriter {
         this.printer.print('}');
     }
     generateFunctionDeclaration(name, signature) {
-        const args = signature.args.map((it, index) => `${signature.argName(index)}${idl.isOptionalType(it) ? '?' : ''}: ${this.getNodeName(it)}`);
+        const rightmostRegularParameterIndex = rightmostIndexOf(signature.args, it => !isOptionalType(it));
+        const args = signature.args.map((it, index) => {
+            const optionalToken = idl.isOptionalType(it) && index > rightmostRegularParameterIndex ? '?' : '';
+            return `${signature.argName(index)}${optionalToken}: ${this.getNodeName(it)}`;
+        });
         const returnType = this.getNodeName(signature.returnType);
         return `export function ${name}(${args.join(", ")}): ${returnType}`;
     }
@@ -202,7 +208,9 @@ export class TSLanguageWriter extends LanguageWriter {
             prefix += " ";
         this.printer.print(`${prefix}${name}${optional ? "?" : ""}: ${this.getNodeName(type)}${init}`);
     }
-    writeNativeMethodDeclaration(name, signature, isNative) {
+    writeNativeMethodDeclaration(method) {
+        let name = method.name;
+        let signature = method.signature;
         this.writeMethodImplementation(new Method(name, signature, [MethodModifier.STATIC]), writer => {
             const selfCallExpression = writer.makeFunctionCall(`this.${name}`, signature.args.map((_, i) => writer.makeString(this.escapeKeyword(signature.argName(i)))));
             writer.writeStatement(new IfStatement(new NaryOpExpression("==", [writer.makeFunctionCall("this._LoadOnce", []), writer.makeString("true")]), new BlockStatement([
@@ -272,7 +280,7 @@ export class TSLanguageWriter extends LanguageWriter {
         canBeOptional.reverse();
         const isOptional = signature.args.map((it, i) => idl.isOptionalType(it) && canBeOptional[i] && !isSetter);
         const normalizedArgs = signature.args.map((it, i) => idl.isOptionalType(it) && isOptional[i] ? idl.maybeUnwrapOptionalType(it) : it);
-        this.printer.print(`${prefix}${name}${typeParams}(${normalizedArgs.map((it, index) => `${this.escapeKeyword(signature.argName(index))}${isOptional[index] ? "?" : ""}: ${this.getNodeName(it)}${signature.argDefault(index) ? ' = ' + signature.argDefault(index) : ""}`).join(", ")})${needReturn ? ": " + this.getNodeName(signature.returnType) : ""} ${needBracket ? "{" : ""}`);
+        this.printer.print(`${prefix}${name}${typeParams}(${normalizedArgs.map((it, index) => `${this.escapeKeyword(signature.argName(index))}${isOptional[index] ? "?" : ""}: ${this.getNodeName(it)}${signature.argDefault(index) ? ' = ' + signature.argDefault(index) : ""}`).join(", ")})${needReturn ? ": " + this.getNodeName(signature.returnType) : ""}${needBracket ? " {" : ""}`);
     }
     makeNull() {
         return new StringExpression("undefined");
@@ -364,7 +372,7 @@ export class TSLanguageWriter extends LanguageWriter {
         return this.makeAssign(receiver, undefined, this.makeString(`[${fields.map(it => `${it}!`).join(",")}]`), false);
     }
     get supportedModifiers() {
-        return [MethodModifier.PUBLIC, MethodModifier.PRIVATE, MethodModifier.STATIC];
+        return [MethodModifier.PUBLIC, MethodModifier.PRIVATE, MethodModifier.PROTECTED, MethodModifier.STATIC];
     }
     get supportedFieldModifiers() {
         return [FieldModifier.PUBLIC, FieldModifier.PRIVATE, FieldModifier.PROTECTED, FieldModifier.READONLY, FieldModifier.STATIC];