@idlizer/core 2.1.10-arktscgen-7 → 2.1.10-arktscgen-9

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

@@ -17,14 +17,15 @@ import { Language } from "../Language";
 import { BlockStatement, PrintHint, StringExpression, NamedMethodSignature, ProxyStatement, ExpressionStatement } from "./LanguageWriter";
 import { RuntimeType } from "./common";
 import { generatorConfiguration, generatorTypePrefix } from "../config";
-import { capitalize, getExtractor, getTransformer, hashCodeFromString, throwException, warn } from "../util";
+import { capitalize, getExtractor, entryToFunctionName as entryToFunctionName, getTransformer, hashCodeFromString, throwException, warn } from "../util";
 import { UnionRuntimeTypeChecker } from "../peer-generation/unions";
 import { CppConvertor, CppNameConvertor } from "./convertors/CppConvertors";
 import { PrimitiveTypesInstance } from "../peer-generation/PrimitiveType";
 import { LayoutNodeRole } from "../peer-generation/LayoutManager";
 import { isInExternalModule } from "../peer-generation/modules";
+import { maybeRestoreGenerics } from "../transformers/GenericTransformer";
 export function getSerializerName(_library, _language, declaration) {
-    return `${idl.getQualifiedName(declaration, "package.namespace.name").split('.').map(capitalize).join('')}SerializerImpl`;
+    return entryToFunctionName(_language, declaration, "", "SerializerImpl");
 }
 export class BaseArgConvertor {
     constructor(idlType, runtimeTypes, isScoped, useArray, param) {
@@ -900,8 +901,9 @@ export class UnionConvertor extends BaseArgConvertor {
             statements.push(printer.makeAssign(varName, undefined, printer.makeUnionVariantCast(convertor.getObjectAccessor(printer.language, value), printer.getNodeName(convertor.idlType), convertor, index), true));
             statements.push(convertor.convertorSerialize(param, varName, printer));
         }
+        const genericDiscriminator = withGenericDiscriminator(this.library, this.memberConvertors, value, discriminator, type, printer);
         const stmt = new BlockStatement(statements, false);
-        return { expr: discriminator, stmt };
+        return { expr: genericDiscriminator, stmt };
     }
     makeArrayBranch(param, value, printer, arrayConvertorItems) {
         if (arrayConvertorItems.length == 0)
@@ -1349,4 +1351,25 @@ export function createOutArgConvertor(library, type, otherParams) {
     }
     return undefined;
 }
+function withGenericDiscriminator(library, convertors, value, discriminator, type, writer) {
+    if (writer.language == Language.CPP)
+        return discriminator;
+    if (!idl.isReferenceType(type))
+        return discriminator;
+    const mayBeGeneric = maybeRestoreGenerics(type, writer.resolver);
+    if (mayBeGeneric == undefined)
+        return discriminator;
+    const count = convertors
+        .map(it => it.idlType)
+        .filter(it => idl.isReferenceType(it))
+        .map(it => idl.isReferenceType(it) ? maybeRestoreGenerics(it, writer.resolver) : undefined)
+        .filter(it => it && idl.isReferenceType(it) && it.name == mayBeGeneric.name)
+        .length;
+    if (count < 2)
+        return discriminator;
+    writer.addFeature("typechecks", library.layout.handwrittenPackage());
+    const decl = writer.resolver.resolveTypeReference(type);
+    const checkGenericFunc = entryToFunctionName(writer.language, decl, "isGeneric_", "");
+    return writer.makeAnd(discriminator, writer.makeFunctionCall(`typechecks.${checkGenericFunc}`, [writer.makeString(value)]));
+}
 //# sourceMappingURL=ArgConvertors.js.map

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

@@ -168,7 +168,8 @@ export declare enum MethodModifier {
     THROWS = 8,
     FREE = 9,
     FORCE_CONTEXT = 10,
-    OVERRIDE = 11
+    OVERRIDE = 11,
+    OPEN = 12
 }
 export declare enum ClassModifier {
     PUBLIC = 0,
@@ -326,7 +327,8 @@ export declare abstract class LanguageWriter {
     writeStatements(...statements: LanguageStatement[]): void;
     writeExpressionStatement(smth: LanguageExpression): void;
     writeExpressionStatements(...statements: LanguageExpression[]): void;
-    writeStaticBlock(op: (writer: this) => void): void;
+    writePrefixedBlock(prefix: string, op: (writer: this) => void): void;
+    writeStaticInitBlock(op: (writer: this) => void): void;
     makeRef(type: idl.IDLType, _options?: MakeRefOptions): idl.IDLType;
     makeThis(): LanguageExpression;
     makeNull(type?: idl.IDLOptionalType): LanguageExpression;
@@ -387,12 +389,14 @@ export declare abstract class LanguageWriter {
     makeHasOwnProperty(value: string, property: string, propertyTypeName?: string): LanguageExpression;
     discriminate(value: string, index: number, type: idl.IDLType, runtimeTypes: RuntimeType[]): string;
     makeNot(expr: LanguageExpression): LanguageExpression;
+    makeAnd(...args: LanguageExpression[]): LanguageExpression;
+    makeOr(...args: LanguageExpression[]): LanguageExpression;
     makeSerializedBufferGetter(serializer: string): LanguageExpression;
     makeEquals(args: LanguageExpression[]): LanguageExpression;
     castToInt(value: string, bitness: 8 | 32): string;
     castToBoolean(value: string): string;
     makeCallIsObject(value: string): LanguageExpression;
-    makeStaticBlock(op: (writer: LanguageWriter) => void): void;
+    writeStaticEntitiesBlock(op: (writer: LanguageWriter) => void): void;
     instanceOf(value: string, type: idl.IDLType): LanguageExpression;
     typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;
     /**

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

@@ -337,6 +337,7 @@ export var MethodModifier;
     MethodModifier[MethodModifier["FREE"] = 9] = "FREE";
     MethodModifier[MethodModifier["FORCE_CONTEXT"] = 10] = "FORCE_CONTEXT";
     MethodModifier[MethodModifier["OVERRIDE"] = 11] = "OVERRIDE";
+    MethodModifier[MethodModifier["OPEN"] = 12] = "OPEN";
 })(MethodModifier || (MethodModifier = {}));
 export var ClassModifier;
 (function (ClassModifier) {
@@ -496,13 +497,16 @@ export class LanguageWriter {
     writeExpressionStatements(...statements) {
         statements.forEach(it => this.writeExpressionStatement(it));
     }
-    writeStaticBlock(op) {
-        this.print("static {");
+    writePrefixedBlock(prefix, op) {
+        this.print(`${prefix} {`);
         this.pushIndent();
         op(this);
         this.popIndent();
         this.print("}");
     }
+    writeStaticInitBlock(op) {
+        this.writePrefixedBlock("static", op);
+    }
     makeRef(type, _options) {
         return type;
     }
@@ -683,6 +687,12 @@ export class LanguageWriter {
     makeNot(expr) {
         return this.makeString(`!(${expr.asString()})`);
     }
+    makeAnd(...args) {
+        return this.makeNaryOp("&&", args);
+    }
+    makeOr(...args) {
+        return this.makeNaryOp("||", args);
+    }
     makeSerializedBufferGetter(serializer) {
         return this.makeMethodCall(serializer, `asBuffer`, []);
     }
@@ -694,7 +704,7 @@ export class LanguageWriter {
     makeCallIsObject(value) {
         return this.makeString(`typeof ${value} === "object"`);
     }
-    makeStaticBlock(op) {
+    writeStaticEntitiesBlock(op) {
         op(this);
     }
     instanceOf(value, type) {

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

@@ -229,7 +229,7 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         // The explicit cast forces ui2abc to call valueOf on an int, which fails the compilation
         // TODO Fix this cast
         if (bitness === 8)
-            return `(${value}).toChar()`;
+            return `(${value}).toByte()`;
         return `(${value}).toInt()`; // FIXME: is there int8 in ARKTS?
     }
     castToBoolean(value) { return `${value} ? true : false`; }

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

@@ -148,7 +148,7 @@ export declare class KotlinLanguageWriter extends LanguageWriter {
     makeCallIsObject(value: string): LanguageExpression;
     makeNewObject(objectName: string, params?: LanguageExpression[]): LanguageExpression;
     escapeKeyword(keyword: string): string;
-    makeStaticBlock(op: (writer: LanguageWriter) => void): void;
+    writeStaticEntitiesBlock(op: (writer: LanguageWriter) => void): void;
     pushNamespace(namespace: string, options: NamespaceOptions): void;
     popNamespace(options: {
         ident: boolean;

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

@@ -85,7 +85,7 @@ export class KotlinEnumWithGetter {
         let mangledName = removePoints(idl.getQualifiedName(this.enumEntity, 'namespace.name'));
         writer.writeClass(mangledName, () => {
             const enumType = idl.createReferenceType(this.enumEntity);
-            writer.makeStaticBlock(() => {
+            writer.writeStaticEntitiesBlock(() => {
                 members.forEach(it => {
                     writer.writeFieldDeclaration(it.name, enumType, [FieldModifier.PUBLIC, FieldModifier.STATIC, FieldModifier.FINAL], false, writer.makeString(`${mangledName}(${it.stringId ? `\"${it.stringId}\"` : it.numberId})`));
                 });
@@ -236,11 +236,11 @@ export class KotlinLanguageWriter extends LanguageWriter {
     maybeSemicolon() { return ""; }
     writeClass(name, op, superClass, interfaces, generics, isDeclared, isAbstract) {
         let extendsClause = superClass ? `${superClass}` : undefined;
-        let implementsClause = interfaces ? `${interfaces.join(' , ')}` : undefined;
+        let implementsClause = interfaces ? `${interfaces.join(', ')}` : undefined;
         let inheritancePart = [extendsClause, implementsClause]
             .filter(isDefined)
-            .join(' , ');
-        inheritancePart = inheritancePart.length != 0 ? ' : '.concat(inheritancePart) : '';
+            .join(', ');
+        inheritancePart = inheritancePart.length != 0 ? ': '.concat(inheritancePart) : '';
         this.printer.print(`public open class ${name}${inheritancePart} {`);
         this.pushIndent();
         op(this);
@@ -590,7 +590,7 @@ export class KotlinLanguageWriter extends LanguageWriter {
         throw new Error("Not implemented");
     }
     get supportedModifiers() {
-        return [MethodModifier.PUBLIC, MethodModifier.PRIVATE, MethodModifier.OVERRIDE];
+        return [MethodModifier.PUBLIC, MethodModifier.PROTECTED, MethodModifier.PRIVATE, MethodModifier.OVERRIDE, MethodModifier.OPEN];
     }
     get supportedFieldModifiers() {
         return [FieldModifier.PUBLIC, FieldModifier.PRIVATE, FieldModifier.PROTECTED, FieldModifier.READONLY, FieldModifier.OVERRIDE];
@@ -619,12 +619,8 @@ export class KotlinLanguageWriter extends LanguageWriter {
     escapeKeyword(keyword) {
         return keyword;
     }
-    makeStaticBlock(op) {
-        this.printer.print('companion object {');
-        this.printer.pushIndent();
-        op(this);
-        this.popIndent();
-        this.printer.print('}');
+    writeStaticEntitiesBlock(op) {
+        this.writePrefixedBlock("companion object", op);
     }
     pushNamespace(namespace, options) { }
     popNamespace(options) { }

package/build/lib/src/from-idl/parser.d.ts

@@ -31,7 +31,7 @@ interface Token {
     value: string;
     location: Location;
 }
-type ModifierToken = "static" | "readonly" | "async";
+type ModifierToken = "static" | "readonly" | "async" | "optional";
 type ModifiersContainer = {
     [Key in ModifierToken]?: Token;
 };

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

@@ -69,7 +69,7 @@ const unsupportedDeclarations = new Set(["deleter", "getter", "includes", "inher
 const interfaceContent = new Set([idl.IDLKind.Constructor, idl.IDLKind.Const, idl.IDLKind.Property, idl.IDLKind.Method, idl.IDLKind.Callable]);
 const globalContent = new Set([idl.IDLKind.Namespace, idl.IDLKind.Interface, idl.IDLKind.Enum, idl.IDLKind.Method, idl.IDLKind.Typedef, idl.IDLKind.Callback, idl.IDLKind.Import, idl.IDLKind.Version, idl.IDLKind.Const]);
 const havingBlocks = new Set([idl.IDLKind.Namespace, idl.IDLKind.Interface, idl.IDLKind.Enum]);
-const modifierTokens = new Set(["static", "readonly", "async"]);
+const modifierTokens = new Set(["static", "readonly", "async", "optional"]);
 // Uncomment in case of parser debugging
 function trac(s) {
     // console.log(s)
@@ -402,7 +402,7 @@ export class Parser {
             }
             switch (this.curValue) {
                 case "attribute":
-                    this.assertPossibleModifiers("static", "readonly");
+                    this.assertPossibleModifiers("static", "readonly", "optional");
                     return this.parseAttribute();
                 case "callback":
                     return this.parseCallback();
@@ -737,7 +737,7 @@ export class Parser {
         const ext = this.consumeCurrentExtended();
         const isReadonly = !!this.currentModifiers.readonly;
         const isStatic = !!this.currentModifiers.static;
-        const isOptional = extractOptional(ext);
+        let isOptional = !!this.currentModifiers.optional || extractOptional(ext);
         this.skip("attribute");
         const type = this.parseType();
         const name = this.parseSingleIdentifier();

package/build/lib/src/idl/dump.js

@@ -128,8 +128,9 @@ export class IDLWriter {
     printProperty(idl) {
         const staticMod = idl.isStatic ? "static " : "";
         const readonlyMod = idl.isReadonly ? "readonly " : "";
+        const optional = idl.isOptional ? "optional " : "";
         return this.printExtendedAttributes(idl)
-            .print(`${staticMod}${readonlyMod}attribute ${nameWithType(idl)};`);
+            .print(`${staticMod}${readonlyMod}${optional}attribute ${nameWithType(idl)};`);
     }
     printExtendedAttributes(idl) {
         var _a;

package/build/lib/src/peer-generation/PeerLibrary.d.ts

@@ -10255,6 +10255,7 @@ export declare class PeerLibrary implements LibraryInterface {
     language: Language;
     interopNativeModule: NativeModuleType;
     readonly useMemoM3: boolean;
+    readonly useComponentNamedOverloads: boolean;
     private _cachedIdlLibrary?;
     asIDLLibrary(): IDLLibrary;
     get globals(): GlobalScopeDeclarations[];
@@ -10266,7 +10267,7 @@ export declare class PeerLibrary implements LibraryInterface {
     private resolver;
     readonly materializedClasses: Map<string, MaterializedClass>;
     get orderedMaterialized(): MaterializedClass[];
-    constructor(language: Language, interopNativeModule: NativeModuleType, useMemoM3?: boolean);
+    constructor(language: Language, interopNativeModule: NativeModuleType, useMemoM3?: boolean, useComponentNamedOverloads?: boolean);
     name: string;
     readonly customComponentMethods: string[];
     createLanguageWriter(language?: Language): LanguageWriter;

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

@@ -91,10 +91,11 @@ export class PeerLibrary {
         return Array.from(this.materializedClasses.values()).filter(it => it.needBeGenerated)
             .sort((a, b) => accessorName(a.decl).localeCompare(accessorName(b.decl)));
     }
-    constructor(language, interopNativeModule, useMemoM3 = false) {
+    constructor(language, interopNativeModule, useMemoM3 = false, useComponentNamedOverloads = true) {
         this.language = language;
         this.interopNativeModule = interopNativeModule;
         this.useMemoM3 = useMemoM3;
+        this.useComponentNamedOverloads = useComponentNamedOverloads;
         this.layout = LayoutManager.Empty();
         this._files = [];
         this.auxFiles = [];

package/build/lib/src/transformers/FqnTransformer.js

@@ -10,14 +10,24 @@ class FqnTransformer extends IdlTransformer {
         this.resolver = resolver;
     }
     visit(node) {
-        var _a;
+        var _a, _b;
+        const defaultGenericReferenceAttribute = (_a = node.extendedAttributes) === null || _a === void 0 ? void 0 : _a.find(a => a.name === idl.IDLExtendedAttributes.TypeParametersDefaults);
+        if (defaultGenericReferenceAttribute && defaultGenericReferenceAttribute.typesValue) {
+            const fqVisited = defaultGenericReferenceAttribute.typesValue.map(type => {
+                const tmpType = idl.clone(type);
+                tmpType.parent = node;
+                return this.visit(tmpType);
+            });
+            defaultGenericReferenceAttribute.typesValue = fqVisited;
+            return this.visitEachChild(node);
+        }
         if (idl.isReferenceType(node)) {
             const resolved = this.resolver.resolveTypeReference(node);
             if (resolved === undefined) {
                 this.resolver.resolveTypeReference(node);
                 throw new Error("Can not expand FQN for " + idl.DebugUtils.debugPrintType(node));
             }
-            return idl.createReferenceType(idl.getFQName(resolved), (_a = node.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => this.visit(it)), idl.cloneNodeInitializer(node));
+            return idl.createReferenceType(idl.getFQName(resolved), (_b = node.typeArguments) === null || _b === void 0 ? void 0 : _b.map(it => this.visit(it)), idl.cloneNodeInitializer(node));
         }
         return this.visitEachChild(node);
     }

package/build/lib/src/transformers/GenericTransformer.js

@@ -139,7 +139,7 @@ class GenericsTransformer extends IdlTransformer {
                 throw new Error(`Unsupported generics target ${resolved.kind}`);
             }
             const inplacedRef = idl.createReferenceType(idl.deriveQualifiedNameFrom(monomorphisedEntryName(resolved, ref.typeArguments, this.options), resolved), undefined, idl.cloneNodeInitializer(ref));
-            if (!this.resolver.resolveTypeReference(inplacedRef)) {
+            if (!this.resolver.resolveTypeReference(inplacedRef, { unresolvedOk: true })) {
                 const monomorphizedEntry = this.visit(this.monomorphizeEntry(resolved, ref.typeArguments));
                 this.producer({ anchor: idl.getFQName(resolved), produced: monomorphizedEntry });
             }

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

@@ -26,6 +26,7 @@ export declare function renameDtsToInterfaces(fileName: string, language: Langua
 export declare function renameClassToBuilderClass(className: string, language: Language, withFileExtension?: boolean): string;
 export declare function renameClassToMaterialized(className: string, language: Language, withFileExtension?: boolean): string;
 export declare function throwException(message: string): never;
+export declare function entryToFunctionName(_language: Language, declaration: idl.IDLEntry, prefix: string, postfix: string): string;
 /**
  * Add a prefix to an enum value which camel case name coincidence
  * with the the same upper case name for an another enum value

package/build/lib/src/util.js

@@ -194,6 +194,9 @@ export function renameClassToMaterialized(className, language, withFileExtension
 export function throwException(message) {
     throw new Error(message);
 }
+export function entryToFunctionName(_language, declaration, prefix, postfix) {
+    return `${prefix}${idl.getQualifiedName(declaration, "package.namespace.name").split('.').map(capitalize).join('')}${postfix}`;
+}
 /**
  * Add a prefix to an enum value which camel case name coincidence
  * with the the same upper case name for an another enum value

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@idlizer/core",
-    "version": "2.1.10-arktscgen-7",
+    "version": "2.1.10-arktscgen-9",
     "description": "",
     "types": "build/lib/src/index.d.ts",
     "exports": {
@@ -36,7 +36,7 @@
         "mocha": "^9.2.2",
         "ts-node": "^10.9.2",
         "typescript": "4.9.5",
-        "@types/node": "^18.0.0",
+        "@types/node": "^18.19.127",
         "rimraf": "^6.0.1"
     },
     "scripts": {