@idlizer/core 2.1.9-arktscgen-9 → 2.1.10-arktscgen-3

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

@@ -35,11 +35,13 @@ export declare enum IDLEntity {
 }
 export declare enum IDLExtendedAttributes {
     Accessor = "Accessor",
+    Annotations = "Annotations",
     Async = "Async",
     CallSignature = "CallSignature",
     CommonMethod = "CommonMethod",
     Component = "Component",
     ComponentInterface = "ComponentInterface",
+    ComponentModifier = "ComponentModifier",
     Deprecated = "Deprecated",
     Documentation = "Documentation",
     DtsName = "DtsName",
@@ -57,14 +59,18 @@ export declare enum IDLExtendedAttributes {
     OriginalGenericName = "OriginalGenericName",
     Predefined = "Predefined",
     Protected = "Protected",
+    Abstract = "Abstract",
     Synthetic = "Synthetic",
     Throws = "Throws",
     TraceKey = "TraceKey",
+    TypeAnnotations = "TypeAnnotations",
     TypeArguments = "TypeArguments",
     TypeParameters = "TypeParameters",
     VerbatimDts = "VerbatimDts",
     HandWrittenImplementation = "HandWrittenImplementation",
-    ExtraMethod = "ExtraMethod"
+    ExtraMethod = "ExtraMethod",
+    OverloadAlias = "OverloadAlias",
+    OverloadPriority = "OverloadPriority"
 }
 export declare enum IDLAccessorAttribute {
     Getter = "Getter",
@@ -73,6 +79,9 @@ export declare enum IDLAccessorAttribute {
 export interface IDLExtendedAttribute {
     name: string;
     value?: string;
+    typesValue?: IDLType[];
+    nameLocation?: Location;
+    valueLocation?: Location;
 }
 export interface IDLNode {
     _idlNodeBrand: any;
@@ -296,6 +305,9 @@ export type IDLNodeInitializer = {
     extendedAttributes?: IDLExtendedAttribute[];
     fileName?: string;
     documentation?: string;
+    nodeLocation?: Location;
+    nameLocation?: Location;
+    valueLocation?: Location;
 };
 export declare function createNamespace(name: string, members?: IDLEntry[], nodeInitializer?: IDLNodeInitializer): IDLNamespace;
 export declare function linkParentBack<T extends IDLNode>(node: T): T;

package/build/lib/src/idl.js

@@ -54,11 +54,13 @@ export var IDLEntity;
 export var IDLExtendedAttributes;
 (function (IDLExtendedAttributes) {
     IDLExtendedAttributes["Accessor"] = "Accessor";
+    IDLExtendedAttributes["Annotations"] = "Annotations";
     IDLExtendedAttributes["Async"] = "Async";
     IDLExtendedAttributes["CallSignature"] = "CallSignature";
     IDLExtendedAttributes["CommonMethod"] = "CommonMethod";
     IDLExtendedAttributes["Component"] = "Component";
     IDLExtendedAttributes["ComponentInterface"] = "ComponentInterface";
+    IDLExtendedAttributes["ComponentModifier"] = "ComponentModifier";
     IDLExtendedAttributes["Deprecated"] = "Deprecated";
     IDLExtendedAttributes["Documentation"] = "Documentation";
     IDLExtendedAttributes["DtsName"] = "DtsName";
@@ -76,14 +78,18 @@ export var IDLExtendedAttributes;
     IDLExtendedAttributes["OriginalGenericName"] = "OriginalGenericName";
     IDLExtendedAttributes["Predefined"] = "Predefined";
     IDLExtendedAttributes["Protected"] = "Protected";
+    IDLExtendedAttributes["Abstract"] = "Abstract";
     IDLExtendedAttributes["Synthetic"] = "Synthetic";
     IDLExtendedAttributes["Throws"] = "Throws";
     IDLExtendedAttributes["TraceKey"] = "TraceKey";
+    IDLExtendedAttributes["TypeAnnotations"] = "TypeAnnotations";
     IDLExtendedAttributes["TypeArguments"] = "TypeArguments";
     IDLExtendedAttributes["TypeParameters"] = "TypeParameters";
     IDLExtendedAttributes["VerbatimDts"] = "VerbatimDts";
     IDLExtendedAttributes["HandWrittenImplementation"] = "HandWrittenImplementation";
     IDLExtendedAttributes["ExtraMethod"] = "ExtraMethod";
+    IDLExtendedAttributes["OverloadAlias"] = "OverloadAlias";
+    IDLExtendedAttributes["OverloadPriority"] = "OverloadPriority";
 })(IDLExtendedAttributes || (IDLExtendedAttributes = {}));
 export var IDLAccessorAttribute;
 (function (IDLAccessorAttribute) {

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

@@ -58,5 +58,6 @@ export * from "./from-idl/IDLLinter";
 export { fromIDL, scanIDL } from "./from-idl/common";
 export { idlToDtsString, CustomPrintVisitor } from "./from-idl/DtsPrinter";
 export { toIDLFile, addSyntheticType, resolveSyntheticType, IDLTokenInfoMap } from "./from-idl/deserialize";
+export { Parser, FatalParserException } from "./from-idl/parser";
 export { D, ConfigTypeInfer, ConfigSchema, inspectSchema } from './configDescriber';
 //# sourceMappingURL=index.d.ts.map

package/build/lib/src/index.js

@@ -72,5 +72,6 @@ export * from "./from-idl/IDLLinter";
 export { fromIDL, scanIDL } from "./from-idl/common";
 export { idlToDtsString, CustomPrintVisitor } from "./from-idl/DtsPrinter";
 export { toIDLFile, addSyntheticType, resolveSyntheticType } from "./from-idl/deserialize";
+export { Parser, FatalParserException } from "./from-idl/parser";
 export { D, inspectSchema } from './configDescriber';
 //# sourceMappingURL=index.js.map

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

@@ -6,7 +6,7 @@ export declare enum LayoutNodeRole {
     COMPONENT = 3,
     SERIALIZER = 4
 }
-export type LayoutTargetDescriptionHint = 'component.implementation' | 'component.interface' | 'component.function';
+export type LayoutTargetDescriptionHint = 'component.implementation' | 'component.interface' | 'component.function' | 'component.modifier';
 export interface LayoutTargetDescription {
     node: IDLEntry;
     role: LayoutNodeRole;

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

@@ -13,10 +13,11 @@ export declare class MaterializedField {
     constructor(field: Field, argConvertor: ArgConvertor, outArgConvertor?: ArgConvertor | undefined, isNullableOriginalTypeField?: boolean | undefined, extraMethodName?: string | undefined);
 }
 export declare class MaterializedMethod extends PeerMethod {
+    decl: idl.IDLConstructor | idl.IDLMethod | undefined;
     implementationParentName: string;
-    constructor(sig: PeerMethodSignature, originalParentName: string, implementationParentName: string, returnType: idl.IDLType, isCallSignature: boolean, method: Method);
+    constructor(decl: idl.IDLConstructor | idl.IDLMethod | undefined, sig: PeerMethodSignature, originalParentName: string, implementationParentName: string, returnType: idl.IDLType, isCallSignature: boolean, uniqueOverloadName: string, method: Method);
     tsReturnType(): idl.IDLType | undefined;
-    getPrivateMethod(): MaterializedMethod;
+    getPrivateMethod(asProtected?: boolean): MaterializedMethod;
     withReturnType(returnType: idl.IDLType): MaterializedMethod;
 }
 export declare function copyMaterializedMethod(method: MaterializedMethod, overrides: {
@@ -36,9 +37,10 @@ export declare class MaterializedClass implements PeerClassBase {
     readonly methods: MaterializedMethod[];
     readonly needBeGenerated: boolean;
     readonly taggedMethods: idl.IDLMethod[];
+    readonly isRefCounted: boolean;
     constructor(decl: idl.IDLInterface, className: string, isInterface: boolean, isStaticMaterialized: boolean, superClass: idl.IDLReferenceType | undefined, interfaces: idl.IDLReferenceType[] | undefined, generics: string[] | undefined, fields: MaterializedField[], ctors: MaterializedMethod[], // zero size when used for global functions
     finalizer: MaterializedMethod | undefined, // undefined when used for global functions
-    methods: MaterializedMethod[], needBeGenerated?: boolean, taggedMethods?: idl.IDLMethod[]);
+    methods: MaterializedMethod[], needBeGenerated?: boolean, taggedMethods?: idl.IDLMethod[], isRefCounted?: boolean);
     getImplementationName(): string;
     generatedName(isCallSignature: boolean): string;
     private _isGlobal;

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

@@ -27,14 +27,15 @@ export class MaterializedField {
     }
 }
 export class MaterializedMethod extends PeerMethod {
-    constructor(sig, originalParentName, implementationParentName, returnType, isCallSignature, method) {
-        super(sig, originalParentName, returnType, isCallSignature, method);
+    constructor(decl, sig, originalParentName, implementationParentName, returnType, isCallSignature, uniqueOverloadName, method) {
+        super(decl, sig, originalParentName, returnType, isCallSignature, uniqueOverloadName, method);
+        this.decl = decl;
         this.implementationParentName = implementationParentName;
     }
     tsReturnType() {
         return this.method.signature.returnType;
     }
-    getPrivateMethod() {
+    getPrivateMethod(asProtected = false) {
         var _a, _b;
         let privateMethod = this;
         if (!((_a = privateMethod.method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(MethodModifier.PRIVATE))) {
@@ -43,7 +44,8 @@ export class MaterializedMethod extends PeerMethod {
                     modifiers: ((_b = this.method.modifiers) !== null && _b !== void 0 ? _b : [])
                         .filter(it => it !== MethodModifier.PUBLIC)
                         .filter(it => it !== MethodModifier.OVERRIDE)
-                        .concat([MethodModifier.PRIVATE])
+                        .filter(it => !asProtected || (it !== MethodModifier.PRIVATE))
+                        .concat([asProtected ? MethodModifier.PROTECTED : MethodModifier.PRIVATE])
                 })
             });
         }
@@ -59,12 +61,12 @@ export class MaterializedMethod extends PeerMethod {
 }
 export function copyMaterializedMethod(method, overrides) {
     var _a;
-    return new MaterializedMethod(method.sig, method.originalParentName, method.implementationParentName, method.returnType, method.isCallSignature, (_a = overrides.method) !== null && _a !== void 0 ? _a : method.method);
+    return new MaterializedMethod(method.decl, method.sig, method.originalParentName, method.implementationParentName, method.returnType, method.isCallSignature, method.uniqueOverloadName, (_a = overrides.method) !== null && _a !== void 0 ? _a : method.method);
 }
 export class MaterializedClass {
     constructor(decl, className, isInterface, isStaticMaterialized, superClass, interfaces, generics, fields, ctors, // zero size when used for global functions
     finalizer, // undefined when used for global functions
-    methods, needBeGenerated = true, taggedMethods = []) {
+    methods, needBeGenerated = true, taggedMethods = [], isRefCounted = false) {
         this.decl = decl;
         this.className = className;
         this.isInterface = isInterface;
@@ -78,6 +80,7 @@ export class MaterializedClass {
         this.methods = methods;
         this.needBeGenerated = needBeGenerated;
         this.taggedMethods = taggedMethods;
+        this.isRefCounted = isRefCounted;
         this._isGlobal = false;
     }
     getImplementationName() {
@@ -97,7 +100,7 @@ export function createDestroyPeerMethod(clazz) {
     if (clazz.isGlobalScope() || clazz.isStaticMaterialized) {
         return undefined;
     }
-    return new MaterializedMethod(new PeerMethodSignature(PeerMethodSignature.DESTROY, '%NEVER_USED$', [], idl.IDLVoidType, clazz.decl), idl.getQualifiedName(clazz.decl, "namespace.name").split('.').join('_'), clazz.getImplementationName(), idl.IDLVoidType, false, new Method('destroyPeer', new NamedMethodSignature(idl.IDLVoidType, [idl.createReferenceType(clazz.decl)], ['peer'])));
+    return new MaterializedMethod(undefined, new PeerMethodSignature(PeerMethodSignature.DESTROY, '%NEVER_USED$', [], idl.IDLVoidType, clazz.decl), idl.getQualifiedName(clazz.decl, "namespace.name").split('.').join('_'), clazz.getImplementationName(), idl.IDLVoidType, false, PeerMethodSignature.DESTROY, new Method(PeerMethodSignature.DESTROY, new NamedMethodSignature(idl.IDLVoidType, [idl.createReferenceType(clazz.decl)], ['peer'])));
 }
 export function getInternalClassName(name) {
     return `${name}Internal`;

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

@@ -1,15 +1,21 @@
-import { IDLFile, IDLProperty } from "../idl";
+import { IDLFile, IDLInterface, IDLProperty } from "../idl";
 import { PeerMethod } from "./PeerMethod";
 export interface PeerClassBase {
     generatedName(isCallSignature: boolean): string;
 }
+export interface ComponentBuilderInfo {
+    uniqueOverloadName: string;
+    peerMethodName: string;
+}
 export declare class PeerClass implements PeerClassBase {
+    readonly decl: IDLInterface;
     readonly file: IDLFile;
     readonly componentName: string;
     readonly originalFilename: string;
-    constructor(file: IDLFile, componentName: string, originalFilename: string);
+    constructor(decl: IDLInterface, file: IDLFile, componentName: string, originalFilename: string);
     generatedName(isCallSignature: boolean): string;
     methods: PeerMethod[];
+    componentBuilderInfos: ComponentBuilderInfo[];
     originalClassName: string | undefined;
     originalInterfaceName: string | undefined;
     originalParentName: string | undefined;

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

@@ -16,11 +16,13 @@ import { IDLI32Type, IDLPointerType } from "../idl";
 import { PeerMethod, PeerMethodArg, PeerMethodSignature } from "./PeerMethod";
 import { Method, MethodModifier, NamedMethodSignature } from "../LanguageWriters/LanguageWriter";
 export class PeerClass {
-    constructor(file, componentName, originalFilename) {
+    constructor(decl, file, componentName, originalFilename) {
+        this.decl = decl;
         this.file = file;
         this.componentName = componentName;
         this.originalFilename = originalFilename;
         this.methods = [];
+        this.componentBuilderInfos = [];
         this.originalClassName = undefined;
         this.originalInterfaceName = undefined;
         this.originalParentName = undefined;
@@ -36,6 +38,6 @@ export class PeerClass {
 export function createConstructPeerMethod(clazz) {
     // TODO here is class FQName needed, but can not calculate if from current PeerClass data
     const classFQN = [clazz.componentName];
-    return new PeerMethod(new PeerMethodSignature(PeerMethodSignature.CTOR, classFQN.concat(PeerMethodSignature.CTOR).join('_'), [new PeerMethodArg('id', IDLI32Type), new PeerMethodArg('flags', IDLI32Type)], IDLPointerType), clazz.componentName, IDLPointerType, false, new Method('construct', new NamedMethodSignature(IDLPointerType, [IDLI32Type, IDLI32Type], ['id', 'flags']), [MethodModifier.STATIC]));
+    return new PeerMethod(undefined, new PeerMethodSignature(PeerMethodSignature.CTOR, classFQN.concat(PeerMethodSignature.CTOR).join('_'), [new PeerMethodArg('id', IDLI32Type), new PeerMethodArg('flags', IDLI32Type)], IDLPointerType), clazz.componentName, IDLPointerType, false, PeerMethodSignature.CTOR, new Method('construct', new NamedMethodSignature(IDLPointerType, [IDLI32Type, IDLI32Type], ['id', 'flags']), [MethodModifier.STATIC]));
 }
 //# sourceMappingURL=PeerClass.js.map

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

@@ -10297,6 +10297,7 @@ export declare class PeerLibrary implements LibraryInterface {
     getInteropName(node: idl.IDLNode): string;
     toDeclaration(type: idl.IDLType | idl.IDLTypedef | idl.IDLCallback | idl.IDLEnum | idl.IDLInterface): idl.IDLEntry | idl.IDLType;
     setFileLayout(strategy: LayoutManagerStrategy): void;
+    withFileLayout(strategy: LayoutManagerStrategy, op: () => void): void;
 }
 export declare const ArkInt32: idl.IDLPrimitiveType;
 export declare const ArkInt64: idl.IDLPrimitiveType;

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

@@ -474,6 +474,12 @@ export class PeerLibrary {
     setFileLayout(strategy) {
         this.layout = new LayoutManager(strategy);
     }
+    withFileLayout(strategy, op) {
+        const old = this.layout;
+        this.layout = new LayoutManager(strategy);
+        op();
+        this.layout = old;
+    }
 }
 export const ArkInt32 = idl.IDLI32Type;
 export const ArkInt64 = idl.IDLI64Type;

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

@@ -8,6 +8,11 @@ export declare class PeerMethodArg {
     readonly type: idl.IDLType;
     constructor(name: string, type: idl.IDLType);
 }
+export type OverloadInfo = {
+    postfix: string;
+    alias?: string;
+    priority?: number;
+};
 export declare class PeerMethodSignature {
     readonly name: string;
     readonly fqname: string;
@@ -16,18 +21,20 @@ export declare class PeerMethodSignature {
     readonly context: idl.IDLEntry | undefined;
     readonly modifiers: (MethodModifier.FORCE_CONTEXT | MethodModifier.THROWS)[];
     constructor(name: string, fqname: string, args: PeerMethodArg[], returnType: idl.IDLType, context?: idl.IDLEntry | undefined, modifiers?: (MethodModifier.FORCE_CONTEXT | MethodModifier.THROWS)[]);
-    static generateOverloadPostfix(decl: idl.IDLConstructor | idl.IDLMethod | idl.IDLCallable | idl.IDLProperty): string;
+    static mangleOverloadedName(decl: idl.IDLConstructor | idl.IDLMethod | idl.IDLCallable | idl.IDLProperty): OverloadInfo;
     static get CTOR(): string;
     static get GET_FINALIZER(): string;
     static get DESTROY(): string;
 }
 export declare class PeerMethod {
+    decl: idl.IDLConstructor | idl.IDLMethod | idl.IDLCallable | idl.IDLProperty | undefined;
     sig: PeerMethodSignature;
     originalParentName: string;
     returnType: IDLType;
     isCallSignature: boolean;
+    uniqueOverloadName: string;
     method: Method;
-    constructor(sig: PeerMethodSignature, originalParentName: string, returnType: IDLType, isCallSignature: boolean, method: Method);
+    constructor(decl: idl.IDLConstructor | idl.IDLMethod | idl.IDLCallable | idl.IDLProperty | undefined, sig: PeerMethodSignature, originalParentName: string, returnType: IDLType, isCallSignature: boolean, uniqueOverloadName: string, method: Method);
     argConvertors(library: PeerLibrary): ArgConvertor[];
     argAndOutConvertors(library: PeerLibrary): ArgConvertor[];
 }

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

@@ -36,9 +36,15 @@ export class PeerMethodSignature {
         this.context = context;
         this.modifiers = modifiers;
     }
-    static generateOverloadPostfix(decl) {
+    static mangleOverloadedName(decl) {
         if (!decl.parent)
-            return ``;
+            return { postfix: "", };
+        let alias;
+        let forcedPriority;
+        if (idl.hasExtAttribute(decl, idl.IDLExtendedAttributes.OverloadAlias)) {
+            alias = idl.getExtAttribute(decl, idl.IDLExtendedAttributes.OverloadAlias);
+            forcedPriority = Number.parseInt(idl.getExtAttribute(decl, idl.IDLExtendedAttributes.OverloadPriority));
+        }
         let sameNamed = [];
         if (idl.isMethod(decl) || idl.isProperty(decl)) {
             let members = [];
@@ -59,19 +65,32 @@ export class PeerMethodSignature {
         else {
             throw new Error("unexpected type of declaration");
         }
-        return sameNamed.length > 1 ? sameNamed.indexOf(decl).toString() : '';
+        return sameNamed.length > 1 ? {
+            postfix: sameNamed.indexOf(decl).toString(),
+            alias,
+            priority: forcedPriority !== null && forcedPriority !== void 0 ? forcedPriority : sameNamed.indexOf(decl)
+        } : {
+            postfix: '',
+            alias,
+            priority: forcedPriority,
+        };
     }
     static get CTOR() { return "construct"; }
     static get GET_FINALIZER() { return "getFinalizer"; }
     static get DESTROY() { return "destroyPeer"; }
 }
 export class PeerMethod {
-    constructor(sig, originalParentName, returnType, isCallSignature, method) {
+    constructor(decl, sig, originalParentName, returnType, isCallSignature, 
+    // arkts specific feature, where overloads - are different functions grouped by overload keyword.
+    // Must be moved to interface description as so as `method` field
+    uniqueOverloadName, method) {
         var _a, _b;
+        this.decl = decl;
         this.sig = sig;
         this.originalParentName = originalParentName;
         this.returnType = returnType;
         this.isCallSignature = isCallSignature;
+        this.uniqueOverloadName = uniqueOverloadName;
         this.method = method;
         // todo remove me
         if ((_a = method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(MethodModifier.FORCE_CONTEXT))

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

@@ -1,5 +1,6 @@
 import * as idl from '../idl';
 import { ReferenceResolver } from './ReferenceResolver';
+export declare function getExtendsChain(declaration: idl.IDLInterface, resolver: ReferenceResolver): idl.IDLReferenceType[];
 export declare function getSuper(declaration: idl.IDLInterface, resolver: ReferenceResolver): idl.IDLInterface | undefined;
 export declare function getSuperType(declaration: idl.IDLInterface, resolver: ReferenceResolver): idl.IDLReferenceType | undefined;
 //# sourceMappingURL=getSuperType.d.ts.map

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

@@ -44,6 +44,15 @@ function getSuperTuple(declaration, resolver) {
     }
     return [resolved, fst];
 }
+export function getExtendsChain(declaration, resolver) {
+    let extendsChain = [];
+    let resolved = getSuperTuple(declaration, resolver);
+    while (resolved) {
+        extendsChain.push(resolved[1]);
+        resolved = getSuperTuple(resolved[0], resolver);
+    }
+    return extendsChain;
+}
 export function getSuper(declaration, resolver) {
     var _a;
     return (_a = getSuperTuple(declaration, resolver)) === null || _a === void 0 ? void 0 : _a[0];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idlizer/core",
-  "version": "2.1.9-arktscgen-9",
+  "version": "2.1.10-arktscgen-3",
   "description": "",
   "types": "build/lib/src/index.d.ts",
   "exports": {
@@ -27,19 +27,27 @@
     "webidl2.js/dist/**/*.js",
     "webidl2.js/package.json"
   ],
-  "type": "module",
   "engines": {
     "npm": ">= 8",
     "node": ">= 18"
   },
   "keywords": [],
   "dependencies": {
-    "@koalaui/interop": "1.7.6",
+    "@koalaui/interop": "1.7.9",
     "typescript": "4.9.5",
     "@types/node": "^18.0.0"
   },
+  "devDependencies": {
+    "@koalaui/harness": "1.7.6+devel",
+    "@koalaui/ets-tsc": "4.9.5-r5",
+    "@types/mocha": "^9.1.0",
+    "mocha": "^9.2.2",
+    "ts-node": "^10.9.2"
+  },
   "scripts": {
+    "test": "mocha",
     "clean": "rimraf -g build",
-    "compile": "tsc -b ."
+    "compile:self": "tsc -b .",
+    "compile": "npm run compile:self"
   }
 }