@idlizer/core 2.0.38 → 2.0.40

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

@@ -16,7 +16,7 @@ import * as idl from "../idl";
 import { Language } from "../Language";
 import { PrintHint, BlockStatement, StringExpression } from "./LanguageWriter";
 import { RuntimeType } from "./common";
-import { generatorConfiguration, generatorTypePrefix } from "../config";
+import { generatorTypePrefix } from "../config";
 import { hashCodeFromString, warn } from "../util";
 import { UnionRuntimeTypeChecker } from "../peer-generation/unions";
 import { CppNameConvertor } from "./convertors/CppConvertors";
@@ -509,7 +509,7 @@ export class ArrayConvertor extends BaseArgConvertor {
         const statements = [];
         const arrayType = this.idlType;
         statements.push(writer.makeAssign(lengthBuffer, idl.IDLI32Type, writer.makeString(`${deserializerName}.readInt32()`), true));
-        statements.push(writer.makeAssign(bufferName, arrayType, writer.makeArrayInit(this.type), true, false));
+        statements.push(writer.makeAssign(bufferName, arrayType, writer.makeArrayInit(this.type, lengthBuffer), true, false));
         statements.push(writer.makeArrayResize(bufferName, writer.getNodeName(arrayType), lengthBuffer, deserializerName));
         statements.push(writer.makeLoop(counterBuffer, lengthBuffer, this.elementConvertor.convertorDeserialize(`${bufferName}_buf`, deserializerName, (expr) => {
             return writer.makeAssign(writer.makeArrayAccess(bufferName, counterBuffer).asString(), undefined, expr, false);
@@ -549,7 +549,7 @@ export class MapConvertor extends BaseArgConvertor {
     convertorSerialize(param, value, printer) {
         // Map size.
         const mapSize = printer.makeMapSize(value);
-        printer.writeMethodCall(`${param}Serializer`, "writeInt32", [mapSize.asString()]);
+        printer.writeMethodCall(`${param}Serializer`, "writeInt32", [printer.castToInt(mapSize.asString(), 32)]);
         printer.writeStatement(printer.makeMapForEach(value, `${value}_key`, `${value}_value`, () => {
             this.keyConvertor.convertorSerialize(param, `${value}_key`, printer);
             this.valueConvertor.convertorSerialize(param, `${value}_value`, printer);
@@ -750,12 +750,7 @@ export class OptionConvertor extends BaseArgConvertor {
         const statements = [];
         statements.push(writer.makeAssign(runtimeBufferName, undefined, writer.makeCast(writer.makeString(`${deserializerName}.readInt8()`), writer.getRuntimeType()), true));
         const bufferType = this.nativeType();
-        if (writer.language == Language.CJ) {
-            statements.push(writer.makeAssign(bufferName, bufferType, idl.isOptionalType(bufferType) ? writer.makeString('Option.None') : undefined, true, false));
-        }
-        else {
-            statements.push(writer.makeAssign(bufferName, bufferType, undefined, true, false));
-        }
+        statements.push(writer.makeAssign(bufferName, bufferType, writer.language == Language.CJ ? writer.makeNull() : undefined, true, false));
         const thenStatement = new BlockStatement([
             this.typeConvertor.convertorDeserialize(`${bufferName}_`, deserializerName, (expr) => {
                 const receiver = writer.language === Language.CPP
@@ -894,7 +889,7 @@ export class MaterializedClassConvertor extends BaseArgConvertor {
     convertorArg(param, writer) {
         switch (writer.language) {
             case Language.CPP:
-                return `static_cast<${generatorConfiguration().TypePrefix}${this.declaration.name}>(${param})`;
+                return `static_cast<${generatorTypePrefix()}${this.declaration.name}>(${param})`;
             case Language.JAVA:
             case Language.CJ:
                 return `MaterializedBase.toPeerPtr(${param})`;

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

@@ -249,7 +249,7 @@ export declare abstract class LanguageWriter {
     abstract writePrintLog(message: string): void;
     abstract makeUndefined(): LanguageExpression;
     makeUnwrapOptional(expression: LanguageExpression): LanguageExpression;
-    abstract makeArrayInit(type: idl.IDLContainerType, size?: number): LanguageExpression;
+    abstract makeArrayInit(type: idl.IDLContainerType, size?: number | string): LanguageExpression;
     abstract makeClassInit(type: idl.IDLType, paramenters: LanguageExpression[]): LanguageExpression;
     abstract makeMapInit(type: idl.IDLType): LanguageExpression;
     abstract makeMapInsert(keyAccessor: string, key: string, valueAccessor: string, value: string): LanguageStatement;
@@ -336,7 +336,7 @@ export declare abstract class LanguageWriter {
     makeDiscriminatorFromFields(convertor: {
         targetType: (writer: LanguageWriter) => string;
     }, value: string, accessors: string[], duplicates: Set<string>): LanguageExpression;
-    makeCallIsResource(value: string): LanguageExpression;
+    makeIsTypeCall(value: string, decl: idl.IDLInterface): LanguageExpression;
     makeEnumEntity(enumEntity: idl.IDLEnum, isExport: boolean): LanguageStatement;
     makeFieldModifiersList(modifiers: FieldModifier[] | undefined, customFieldFilter?: (field: FieldModifier) => boolean): string;
     escapeKeyword(keyword: string): string;
@@ -349,7 +349,6 @@ export declare abstract class LanguageWriter {
     castToInt(value: string, bitness: 8 | 32): string;
     castToBoolean(value: string): string;
     makeCallIsObject(value: string): LanguageExpression;
-    makeCallIsArrayBuffer(value: string): LanguageExpression;
     instanceOf(convertor: ArgConvertor, value: string, _duplicateMembers?: Set<string>): LanguageExpression;
     typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;
     makeLengthSerializer(serializer: string, value: string): LanguageStatement | undefined;

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

@@ -619,8 +619,8 @@ export class LanguageWriter {
     makeDiscriminatorFromFields(convertor, value, accessors, duplicates) {
         return this.makeString(`(${this.makeNaryOp("||", accessors.map(it => this.makeString(`${value}!.hasOwnProperty("${it}")`))).asString()})`);
     }
-    makeCallIsResource(value) {
-        return this.makeString(`isResource(${value})`);
+    makeIsTypeCall(value, decl) {
+        return this.makeString(`is${decl.name}(${value})`);
     }
     makeEnumEntity(enumEntity, isExport) {
         return new TsEnumEntityStatement(enumEntity, isExport);
@@ -666,9 +666,6 @@ export class LanguageWriter {
     makeCallIsObject(value) {
         return this.makeString(`typeof ${value} === "object"`);
     }
-    makeCallIsArrayBuffer(value) {
-        return this.makeString(`${value} instanceof ArrayBuffer`);
-    }
     instanceOf(convertor, value, _duplicateMembers) {
         return this.makeString(`${value} instanceof ${this.getNodeName(convertor.idlType)}`);
     }

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

@@ -37,6 +37,9 @@ export class CJTypeNameConvertor {
             const stringes = type.elementType.slice(0, 2).map(it => convertType(this, it));
             return `Map<${stringes[0]}, ${stringes[1]}>`;
         }
+        if (idl.IDLContainerUtils.isPromise(type)) {
+            return `Any`;
+        }
         throw new Error(`IDL type ${idl.DebugUtils.debugPrintType(type)} not supported`);
     }
     convertNamespace(node) {
@@ -106,13 +109,14 @@ export class CJTypeNameConvertor {
             case idl.IDLF64Type: return 'Float64';
             case idl.IDLPointerType: return 'UInt64';
             case idl.IDLVoidType: return 'Unit';
-            case idl.IDLBufferType:
+            case idl.IDLBufferType: return 'Array<UInt8>';
             case idl.IDLInteropReturnBufferType: return 'Array<UInt8>';
+            case idl.IDLBigintType: return 'Int64';
         }
         throw new Error(`Unsupported IDL primitive ${idl.DebugUtils.debugPrintType(type)}`);
     }
     callbackType(decl) {
-        const params = decl.parameters.map(it => `${it.name}: ${it.isOptional ? "?" : ""}${this.convert(it.type)}`);
+        const params = decl.parameters.map(it => `${it.name}: ${this.convert(it.type)}`);
         return `((${params.join(", ")}) -> ${this.convert(decl.returnType)})`;
     }
     productType(decl, isTuple, includeFieldNames) {
@@ -126,6 +130,7 @@ export class CJIDLTypeToForeignStringConvertor extends CJTypeNameConvertor {
         if (idl.isPrimitiveType(type)) {
             switch (type) {
                 case idl.IDLStringType: return 'CString';
+                case idl.IDLInteropReturnBufferType: return 'KInteropReturnBuffer';
             }
         }
         if (idl.isContainerType(type)) {

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

@@ -178,9 +178,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/InteropConvertors.js

@@ -60,11 +60,11 @@ export class InteropReturnTypeConvertor {
             case idl.IDLBooleanType: return PrimitiveTypesInstance.Boolean.getText();
             case idl.IDLBigintType: return PrimitiveTypesInstance.Int64.getText();
             case idl.IDLAnyType:
-            case idl.IDLBufferType:
             case idl.IDLThisType:
             case idl.IDLUndefinedType:
             case idl.IDLUnknownType:
             case idl.IDLVoidType: return idl.IDLVoidType.name;
+            case idl.IDLBufferType: return KInteropReturnBuffer; /* ArkTS can not return buffer as language object yet */
             case idl.IDLStringType: return PrimitiveTypesInstance.String.getText();
             case idl.IDLPointerType: return PrimitiveTypesInstance.NativePointer.getText();
         }

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

@@ -152,7 +152,7 @@ class CJMapForEachStatement {
         this.op = op;
     }
     write(writer) {
-        writer.print(`for ((key, value) in ${this.map}) {`);
+        writer.print(`for ((${this.key}, ${this.value}) in ${this.map}) {`);
         writer.pushIndent();
         this.op();
         writer.popIndent();
@@ -266,7 +266,9 @@ export class CJLanguageWriter extends LanguageWriter {
         return new CJLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.typeForeignConvertor);
     }
     getNodeName(type) {
-        return this.typeConvertor.convert(type);
+        // rework for proper namespace logic
+        let name = this.typeConvertor.convert(type).split('.');
+        return name[name.length - 1];
     }
     writeClass(name, op, superClass, interfaces, generics) {
         let extendsClause = superClass ? `${superClass}` : undefined;
@@ -417,7 +419,7 @@ export class CJLanguageWriter extends LanguageWriter {
         throw new Error(`makeClassInit`);
     }
     makeArrayInit(type, size) {
-        return this.makeString(`ArrayList<${this.getNodeName(type.elementType[0])}>(${size !== null && size !== void 0 ? size : ''})`);
+        return this.makeString(`ArrayList<${this.getNodeName(type.elementType[0])}>(Int64(${size !== null && size !== void 0 ? size : ''}))`);
     }
     makeMapInit(type) {
         throw new Error(`TBD`);
@@ -491,7 +493,7 @@ export class CJLanguageWriter extends LanguageWriter {
         return this.makeString("Option.None");
     }
     makeUnwrapOptional(expression) {
-        return new CJMatchExpression(expression, [this.makeString('Some(serializer)')], [this.makeString('serializer')], this.indentDepth());
+        return new CJMatchExpression(expression, [this.makeString(`Some(unwrap_value)`)], [this.makeString(`unwrap_value`)], this.indentDepth());
     }
     makeValueFromOption(value, destinationConvertor) {
         return this.makeString(`${value}`);

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

@@ -50,7 +50,7 @@ export declare class ETSLanguageWriter extends TSLanguageWriter {
         targetType: (writer: LanguageWriter) => string;
     }, value: string, accessors: string[], duplicates: Set<string>): LanguageExpression;
     makeValueFromOption(value: string, destinationConvertor: ArgConvertor): LanguageExpression;
-    makeCallIsResource(value: string): LanguageExpression;
+    makeIsTypeCall(value: string, decl: idl.IDLInterface): LanguageExpression;
     makeEnumEntity(enumEntity: IDLEnum, isExport: boolean): LanguageStatement;
     getObjectAccessor(convertor: ArgConvertor, value: string, args?: ObjectArgs): string;
     writeMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;

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

@@ -210,8 +210,8 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         }
         return super.makeValueFromOption(value, destinationConvertor);
     }
-    makeCallIsResource(value) {
-        return this.makeString(`isResource(${value})`);
+    makeIsTypeCall(value, decl) {
+        return makeInterfaceTypeCheckerCall(value, decl.name, decl.properties.map(it => it.name), new Set(), this);
     }
     makeEnumEntity(enumEntity, isExport) {
         return new ArkTSEnumEntityStatement(enumEntity, isExport);
@@ -234,7 +234,8 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         if (!idl.isEnum(decl)) {
             throwException(`Declaration type must be Enum`);
         }
-        return this.makeCast(this.makeString(`${value}${idl.isStringEnum(decl) ? "" : ".valueOf()"}`), IDLI32Type).asString();
+        // ((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()))) {
@@ -315,18 +316,7 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         return new TSCastExpression(value, `${this.getNodeName(type)}`, (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
     }
 }
-const builtInInterfaceTypes = new Map([
-    ["Resource",
-        (writer, value) => writer.makeCallIsResource(value)],
-    ["Object",
-        (writer, value) => writer.makeCallIsObject(value)],
-    ["ArrayBuffer",
-        (writer, value) => writer.makeCallIsArrayBuffer(value)]
-]);
 function makeInterfaceTypeCheckerCall(valueAccessor, interfaceName, allFields, duplicates, writer) {
-    if (builtInInterfaceTypes.has(interfaceName)) {
-        return builtInInterfaceTypes.get(interfaceName)(writer, valueAccessor);
-    }
     return writer.makeMethodCall("TypeChecker", generateTypeCheckerName(interfaceName), [writer.makeString(valueAccessor),
         ...allFields.map(it => {
             return writer.makeString(duplicates.has(it) ? "true" : "false");

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

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

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

@@ -8,6 +8,7 @@ export interface CoreConfiguration {
     readonly ignoreMaterialized: string[];
     readonly builderClasses: string[];
     readonly forceMaterialized: string[];
+    readonly forceCallback: string[];
 }
 export declare const defaultCoreConfuguration: CoreConfiguration;
 export declare function setDefaultConfiguration<T extends CoreConfiguration>(config: T): void;

package/build/lib/src/config.js

@@ -22,6 +22,7 @@ export const defaultCoreConfuguration = {
     ignoreMaterialized: [],
     builderClasses: [],
     forceMaterialized: [],
+    forceCallback: [],
 };
 let currentConfig = defaultCoreConfuguration;
 export function setDefaultConfiguration(config) {

package/build/lib/src/from-idl/deserialize.js

@@ -113,8 +113,6 @@ function toIDLInterface(file, node) {
         documentation: makeDocs(node),
         extendedAttributes: toExtendedAttributes(node.extAttrs),
     });
-    if (result.inheritance.length && idl.isReferenceType(result.inheritance[0]))
-        result.inheritance[0].typeArguments = extractTypeArguments(file, node.extAttrs, idl.IDLExtendedAttributes.TypeArguments);
     if (node.extAttrs.find(it => it.name === "Synthetic"))
         addSyntheticType(node.name, result);
     return result;

package/build/lib/src/peer-generation/idl/IdlNameConvertor.d.ts

@@ -20,10 +20,19 @@ export declare class ETSDeclarationNameConvertor extends DeclarationNameConverto
     convertEnum(decl: idl.IDLEnum): string;
     static readonly I: ETSDeclarationNameConvertor;
 }
+export declare class CJDeclarationNameConvertor extends DeclarationNameConvertor {
+    convertInterface(decl: idl.IDLInterface): string;
+    convertEnum(decl: idl.IDLEnum): string;
+    static readonly I: CJDeclarationNameConvertor;
+}
 export declare class ETSFeatureNameConvertor extends DeclarationNameConvertor {
     convertEnum(decl: idl.IDLEnum): string;
     static readonly I: ETSFeatureNameConvertor;
 }
+export declare class CJFeatureNameConvertor extends DeclarationNameConvertor {
+    convertEnum(decl: idl.IDLEnum): string;
+    static readonly I: CJFeatureNameConvertor;
+}
 export declare function createDeclarationNameConvertor(language: Language): DeclarationNameConvertor;
 export declare function createFeatureNameConvertor(language: Language): DeclarationNameConvertor;
 //# sourceMappingURL=IdlNameConvertor.d.ts.map

package/build/lib/src/peer-generation/idl/IdlNameConvertor.js

@@ -57,6 +57,15 @@ export class ETSDeclarationNameConvertor extends DeclarationNameConvertor {
     }
 }
 ETSDeclarationNameConvertor.I = new ETSDeclarationNameConvertor();
+export class CJDeclarationNameConvertor extends DeclarationNameConvertor {
+    convertInterface(decl) {
+        return decl.name;
+    }
+    convertEnum(decl) {
+        return decl.name;
+    }
+}
+CJDeclarationNameConvertor.I = new CJDeclarationNameConvertor();
 export class ETSFeatureNameConvertor extends DeclarationNameConvertor {
     convertEnum(decl) {
         const namespace = idl.getNamespacesPathFor(decl).map(it => it.name);
@@ -66,13 +75,19 @@ export class ETSFeatureNameConvertor extends DeclarationNameConvertor {
     }
 }
 ETSFeatureNameConvertor.I = new ETSFeatureNameConvertor();
+export class CJFeatureNameConvertor extends DeclarationNameConvertor {
+    convertEnum(decl) {
+        return decl.name;
+    }
+}
+CJFeatureNameConvertor.I = new CJFeatureNameConvertor();
 export function createDeclarationNameConvertor(language) {
     switch (language) {
         case Language.ARKTS: return ETSDeclarationNameConvertor.I;
         case Language.JAVA:
         case Language.CPP:
-        case Language.CJ:
         case Language.TS: return DeclarationNameConvertor.I;
+        case Language.CJ: CJDeclarationNameConvertor.I;
         default: throw new Error(`Language ${language.toString()} is not supported`);
     }
 }
@@ -81,8 +96,8 @@ export function createFeatureNameConvertor(language) {
         case Language.ARKTS: return ETSFeatureNameConvertor.I;
         case Language.JAVA:
         case Language.CPP:
-        case Language.CJ:
         case Language.TS: return TSFeatureNameConvertor.I;
+        case Language.CJ: return CJFeatureNameConvertor.I;
         default: throw new Error(`Language ${language.toString()} is not supported`);
     }
 }

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

@@ -24,6 +24,9 @@ export function isMaterialized(declaration, resolver) {
         if (declaration.name == forceMaterialized)
             return true;
     }
+    if (generatorConfiguration().forceCallback.includes(declaration.name)) {
+        return false;
+    }
     for (const ignore of generatorConfiguration().ignoreMaterialized) {
         if (declaration.name.endsWith(ignore))
             return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idlizer/core",
-  "version": "2.0.38",
+  "version": "2.0.40",
   "description": "",
   "types": "build/lib/src/index.d.ts",
   "exports": {

package/webidl2.js/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Robin Berjon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.