@idlizer/arktscgen 2.1.10-arktscgen-2 → 2.1.10-arktscgen-3a

package/lib/index.js

@@ -3834,10 +3834,13 @@ var IDLExtendedAttributes;
     IDLExtendedAttributes["Interfaces"] = "Interfaces";
     IDLExtendedAttributes["NativeModule"] = "NativeModule";
     IDLExtendedAttributes["Optional"] = "Optional";
+    IDLExtendedAttributes["UnionOnlyNull"] = "OptionalOnlyNull";
+    IDLExtendedAttributes["UnionWithNull"] = "OptionalWithNull";
     IDLExtendedAttributes["OriginalEnumMemberName"] = "OriginalEnumMemberName";
     IDLExtendedAttributes["OriginalGenericName"] = "OriginalGenericName";
     IDLExtendedAttributes["Predefined"] = "Predefined";
     IDLExtendedAttributes["Protected"] = "Protected";
+    IDLExtendedAttributes["Abstract"] = "Abstract";
     IDLExtendedAttributes["Synthetic"] = "Synthetic";
     IDLExtendedAttributes["Throws"] = "Throws";
     IDLExtendedAttributes["TraceKey"] = "TraceKey";
@@ -4904,10 +4907,22 @@ function linearizeNamespaceMembers(entries) {
 }
 
 const modulesCache = new Map();
+/**
+ * Is source submodule of target.
+ * Every source is submodule if target is empty string
+ * @example `isSubmodule("a.b.c", "a") === true`
+ * @example `isSubmodule("a", "a.b.c") === false`
+ * @example `isSubmodule("a.b.cd", "a.b.c") === false`
+ */
+function isSubmodule(source, target) {
+    return source === target
+        || target === ""
+        || source.startsWith(target + '.');
+}
 function isInModule(nodeOrPackage, module) {
     if (typeof nodeOrPackage === 'object')
         return isInModule(getPackageName(nodeOrPackage), module);
-    return module.packages.some(modulePackage => nodeOrPackage.startsWith(modulePackage));
+    return module.packages.some(modulePackage => isSubmodule(nodeOrPackage, modulePackage));
 }
 function isInExternalModule(node) {
     var _a;
@@ -5410,7 +5425,9 @@ class LanguageWriter {
         fs__namespace.writeFileSync(file, this.getOutput().join("\n"));
     }
     writeLines(lines) {
-        lines.split("\n").forEach(it => this.print(it));
+        if (typeof lines === 'string')
+            lines = lines.split("\n");
+        lines.forEach(it => this.print(it));
     }
     writeGetterImplementation(method, op) {
         var _a;
@@ -5456,7 +5473,7 @@ class LanguageWriter {
     makeThis() {
         return new StringExpression("this");
     }
-    makeNull(value) {
+    makeNull(type) {
         return new StringExpression("null");
     }
     makeVoid() {
@@ -6155,12 +6172,12 @@ class FatalParserException extends Error {
 }
 var TokenKind;
 (function (TokenKind) {
-    TokenKind["Words"] = "Words";
-    TokenKind["Literal"] = "Literal";
-    TokenKind["Symbol"] = "Symbol";
-    TokenKind["Comment"] = "Comment";
-    TokenKind["Whitespace"] = "Space";
-    TokenKind["End"] = "End";
+    TokenKind[TokenKind["Words"] = 0] = "Words";
+    TokenKind[TokenKind["Literal"] = 1] = "Literal";
+    TokenKind[TokenKind["Symbol"] = 2] = "Symbol";
+    TokenKind[TokenKind["Comment"] = 3] = "Comment";
+    TokenKind[TokenKind["Whitespace"] = 4] = "Whitespace";
+    TokenKind[TokenKind["End"] = 5] = "End";
 })(TokenKind || (TokenKind = {}));
 const supportedDeclarations = new Set(["attribute", "callback", "const", "constructor", "dictionary",
     "enum", "import", "interface", "namespace", "package", "typedef", "version"]);
@@ -6170,10 +6187,6 @@ const interfaceContent = new Set([IDLKind.Constructor, IDLKind.Const, IDLKind.Pr
 const globalContent = new Set([IDLKind.Namespace, IDLKind.Interface, IDLKind.Enum, IDLKind.Method, IDLKind.Typedef, IDLKind.Callback, IDLKind.Import, IDLKind.Version, IDLKind.Const]);
 const havingBlocks = new Set([IDLKind.Namespace, IDLKind.Interface, IDLKind.Enum]);
 const modifierTokens = new Set(["static", "readonly", "async"]);
-// Uncomment in case of parser debugging
-function trac(s) {
-    // console.log(s)
-}
 class Parser {
     constructor(fileName, content) {
         var _a, _b;
@@ -6214,11 +6227,14 @@ class Parser {
         var _a;
         const previousDiagnosticsCount = DiagnosticMessageGroup.allGroupsEntries.length;
         try {
-            trac("parseIDL");
             this._lexerNext();
             this._prevToken = this._curToken;
             let file = this.parseFile();
             file.text = this.content;
+            if (DiagnosticMessageGroup.allGroupsEntries.length != previousDiagnosticsCount) {
+                // Empty for now, messages will be added in following `catch`.
+                throw new FatalParserException();
+            }
             return file;
         }
         catch (e) {
@@ -7298,6 +7314,7 @@ class IDLDeserializer {
     toIDLConstructor(file, node) {
         return this.withInfo(node, createConstructor(node.arguments.map(it => this.toIDLParameter(file, it)), undefined, {
             documentation: this.makeDocs(node),
+            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
         }));
     }
     toIDLParameter(file, node) {
@@ -8224,7 +8241,7 @@ class CppLanguageWriter extends CLikeLanguageWriter {
     writePrintLog(message) {
         this.print(`printf("${message}\\n");`);
     }
-    makeDefinedCheck(value, isTag) {
+    makeDefinedCheck(value, type, isTag) {
         return this.makeString(isTag ? `${value} != ${PrimitiveTypeList.UndefinedTag}`
             : `runtimeType(${value}) != ${PrimitiveTypeList.UndefinedRuntime}`);
     }
@@ -8652,7 +8669,9 @@ class TSLanguageWriter extends LanguageWriter {
         const normalizedArgs = signature.args.map((it, i) => isOptionalType(it) && signature.isArgOptional(i) ? maybeUnwrapOptionalType(it) : it);
         this.printer.print(`${prefix}${name}${typeParams}(${normalizedArgs.map((it, index) => `${this.escapeKeyword(signature.argName(index))}${signature.isArgOptional(index) ? "?" : ``}: ${this.getNodeName(it)}${signature.argDefault(index) ? ' = ' + signature.argDefault(index) : ""}`).join(", ")})${needReturn ? ": " + this.getNodeName(signature.returnType) : ""}${needBracket ? " {" : ""}`);
     }
-    makeNull() {
+    makeNull(type) {
+        if (type && hasExtAttribute(type, IDLExtendedAttributes.UnionOnlyNull))
+            return new StringExpression("null");
         return new StringExpression("undefined");
     }
     makeAssign(variableName, type, expr, isDeclared = true, isConst = true, options) {
@@ -8709,7 +8728,15 @@ class TSLanguageWriter extends LanguageWriter {
     makeRuntimeType(rt) {
         return this.makeString(`RuntimeType.${RuntimeType[rt]}`);
     }
-    makeDefinedCheck(value) {
+    makeDefinedCheck(value, type) {
+        if (type) {
+            if (hasExtAttribute(type, IDLExtendedAttributes.UnionWithNull)) {
+                return this.makeString(`${value} !== undefined && ${value} !== null`);
+            }
+            else if (hasExtAttribute(type, IDLExtendedAttributes.UnionOnlyNull)) {
+                return this.makeString(`${value} !== null`);
+            }
+        }
         return this.makeString(`${value} !== undefined`);
     }
     makeTupleAlloc(option) {
@@ -9039,6 +9066,12 @@ class ETSLanguageWriter extends TSLanguageWriter {
         super(printer, resolver, typeConvertor, Language.ARKTS);
         this.arrayConvertor = arrayConvertor;
     }
+    pushNamespace(namespace, options) {
+        if (options.isDefault) {
+            this.print(`export default ${namespace}`);
+        }
+        super.pushNamespace(namespace, options);
+    }
     fork(options) {
         var _a;
         return new ETSLanguageWriter(new IndentedPrinter([], this.indentDepth()), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.arrayConvertor);
@@ -9323,7 +9356,7 @@ class AggregateConvertor extends BaseArgConvertor {
             statements.push(assigneer(writer.makeString(bufferName)));
         }
         else if (writer.language == Language.CJ) {
-            const resultExpression = writer.makeString(`${writer.getNodeName(this.idlType)}(${this.decl.properties.map(prop => `${bufferName}_${prop.name}`).join(", ")})`);
+            const resultExpression = writer.makeString(`${writer.getNodeName(this.idlType)}(${this.decl.properties.map(prop => `${bufferName}${capitalize(prop.name)}`).join(", ")})`);
             statements.push(assigneer(resultExpression));
         }
         else if (writer.language == Language.KOTLIN) {
@@ -12425,6 +12458,32 @@ class Typechecker {
         }
         return ancestor === Config.defaultAncestor;
     }
+    hasDescendants(ref) {
+        const iface = isReferenceType(ref) ? this.resolveReference(ref) : ref;
+        if (!iface || !isInterface$1(iface)) {
+            return false;
+        }
+        const lookupScopes = [];
+        const parent = iface.parent;
+        if (parent && isNamespace(parent)) {
+            lookupScopes.push(...this.namespaces.filter(ns => ns.name === parent.name));
+        }
+        else {
+            lookupScopes.push(this.file);
+        }
+        const visitInterfaces = (node, cb) => {
+            switch (node.kind) {
+                case IDLKind.File:
+                    return node.entries.some((value) => visitInterfaces(value, cb));
+                case IDLKind.Namespace:
+                    return node.members.some((value) => visitInterfaces(value, cb));
+                case IDLKind.Interface:
+                    return cb(node);
+            }
+            return false;
+        };
+        return lookupScopes.some(scope => visitInterfaces(scope, (node) => node.name !== iface.name && this.isHeir(node, iface.name)));
+    }
     isPeer(node) {
         if (node.name === Config.astNodeCommonAncestor)
             return false; // TODO: is handwritten
@@ -12887,19 +12946,22 @@ class BridgesPrinter extends InteropPrinter {
             writer.writeStatements(writer.makeStatement(nativeCall), writer.makeReturn(writer.makeString('')));
         }
         else {
-            writer.writeStatements(writer.makeAssign(BridgesConstructions.result, undefined, nativeCall, true, false), writer.makeReturn(writer.makeString(this.maybeDropConst(this.makeReturnExpression(node.returnType), node))));
+            writer.writeStatements(writer.makeAssign(BridgesConstructions.result, undefined, nativeCall, true, false), writer.makeReturn(this.makeReturnExpression(node)));
         }
     }
-    makeReturnExpression(returnType) {
-        if (isSequence(returnType)) {
-            return BridgesConstructions.sequenceConstructor(BridgesConstructions.result, BridgesConstructions.sequenceLengthUsage);
-        }
-        if (isString(returnType)) {
-            return BridgesConstructions.stringConstructor(BridgesConstructions.result);
+    makeReturnExpression(node) {
+        const makeStringCtor = () => BridgesConstructions.stringConstructor(BridgesConstructions.result);
+        const makeSequenceCtor = () => BridgesConstructions.sequenceConstructor(BridgesConstructions.result, BridgesConstructions.sequenceLengthUsage);
+        const expr = this.maybeDropConst(node, isSequence(node.returnType) ? makeSequenceCtor() :
+            isString(node.returnType) ? makeStringCtor() :
+                BridgesConstructions.result);
+        if (isSequence(node.returnType)) {
+            // writer.makeTernary annoys by adding the extra parentheses
+            return this.writer.makeString(`${BridgesConstructions.sequenceLengthUsage} ? ${expr} : nullptr`);
         }
-        return BridgesConstructions.result;
+        return this.writer.makeString(expr);
     }
-    maybeDropConst(value, node) {
+    maybeDropConst(node, value) {
         if (this.typechecker.isConstReturnValue(node)) {
             return BridgesConstructions.dropConstCast(value);
         }
@@ -13465,21 +13527,35 @@ class BindingParameterTypeConvertor extends TopLevelTypeConvertor {
  * limitations under the License.
  */
 class BindingReturnValueTypeConvertor extends TopLevelTypeConvertor {
-    constructor(typechecker) {
+    constructor(typechecker, importer) {
         const plain = (type) => (writer, call) => call;
-        const wrap = (wrapWith) => (writer, call) => writer.makeFunctionCall(wrapWith, [call]);
+        const wrap = (wrapWith, ...args) => (writer, call) => writer.makeFunctionCall(wrapWith, [call, ...args.map(a => writer.makeString(a))]);
+        const isAstNode = (ref) => (isReferenceType(ref) || isInterface$1(ref)) && this.typechecker.isHeir(ref, Config.astNodeCommonAncestor);
+        const makeArgs = (type) => {
+            const iface = isReferenceType(type)
+                ? this.typechecker.resolveReference(type)
+                : undefined;
+            if (iface && isAstNode(iface) && !this.typechecker.hasDescendants(iface)) {
+                const astNodeTypeName = this.typechecker.nodeTypeName(iface);
+                if (astNodeTypeName) {
+                    importer.withEnumImport(Config.nodeTypeAttribute);
+                    return [astNodeTypeName];
+                }
+            }
+            return [];
+        };
         super(typechecker, {
-            sequence: (type) => wrap(PeersConstructions.arrayOfPointersToArrayOfPeers),
+            sequence: (type) => wrap(PeersConstructions.arrayOfPointersToArrayOfPeers, ...makeArgs(type.elementType[0])),
             string: (type) => wrap(PeersConstructions.receiveString),
-            reference: (type) => this.typechecker.isHeir(type, Config.astNodeCommonAncestor)
-                ? wrap(PeersConstructions.unpackNonNullable)
+            reference: (type) => isAstNode(type)
+                ? wrap(PeersConstructions.unpackNonNullable, ...makeArgs(type))
                 : wrap(baseNameString(type.name)),
             optional: (type) => {
-                if (isReferenceType(type.type)) {
-                    if (this.typechecker.isHeir(type.type, Config.astNodeCommonAncestor)) {
-                        return wrap(PeersConstructions.unpackNullable);
-                    }
-                    return wrap(PeersConstructions.newOf(baseNameString(type.type.name)));
+                const innerType = type.type;
+                if (isReferenceType(innerType)) {
+                    return isAstNode(innerType)
+                        ? wrap(PeersConstructions.unpackNullable, ...makeArgs(innerType))
+                        : wrap(PeersConstructions.newOf(baseNameString(innerType.name)));
                 }
                 throwException(`unexpected optional of non-reference type`);
             },
@@ -13490,6 +13566,7 @@ class BindingReturnValueTypeConvertor extends TopLevelTypeConvertor {
             boolean: plain,
             undefined: plain
         });
+        this.importer = importer;
     }
 }
 
@@ -13530,7 +13607,7 @@ class PeerPrinter extends SingleFilePrinter {
         this.typechecker = new Typechecker(this.idl);
         this.importer = new Importer(this.typechecker, `.`, this.node.name);
         this.bindingParameterTypeConvertor = new BindingParameterTypeConvertor(this.typechecker);
-        this.bindingReturnValueTypeConvertor = new BindingReturnValueTypeConvertor(this.typechecker);
+        this.bindingReturnValueTypeConvertor = new BindingReturnValueTypeConvertor(this.typechecker, this.importer);
         this.parent = (_a = parent(this.node)) !== null && _a !== void 0 ? _a : Config.defaultAncestor;
         this.writer = new TSLanguageWriter(new IndentedPrinter(), createEmptyReferenceResolver(), { convert: (node) => convertAndImport(this.importer, new class extends LibraryTypeConvertor {
                 convertTypeReference(type) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idlizer/arktscgen",
-  "version": "2.1.10-arktscgen-2",
+  "version": "2.1.10-arktscgen-3a",
   "description": "",
   "main": "lib/index.js",
   "bin": "lib/index.js",
@@ -19,7 +19,7 @@
   "license": "Apache-2.0",
   "keywords": [],
   "dependencies": {
-    "@idlizer/core": "2.1.10-arktscgen-2",
+    "@idlizer/core": "2.1.10-arktscgen-3a",
     "@types/node": "^18.0.0",
     "commander": "^10.0.0",
     "typescript": "^4.9.5"
@@ -38,7 +38,8 @@
   },
   "scripts": {
     "compile:core": "npm run --prefix ../core compile",
-    "compile": "npm run compile:core && rollup -c",
+    "compile:self": "rollup -c",
+    "compile": "npm run compile:core && npm run compile:self",
     "external:test": "npm run --prefix ../external/ui2abc/libarkts run",
     "external:clean": "rimraf ../external/ui2abc/libarkts/src/generated/peers",
     "external:generate": "npm run compile && node . --panda-sdk-path ../external/incremental/tools/panda/node_modules/@panda/sdk/ --output-dir ../external/ui2abc/ --options-file ../external/ui2abc/libarkts/generator/options.json5 --debug --no-initialize",

package/templates/factory.ts

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,

package/templates/peer.ts

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,

package/build/libarkts-copy/src/arkts-api/ChainExpressionFilter.ts

@@ -1,79 +0,0 @@
-/*
- * Copyright (c) 2022-2025 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import { BlockStatement, ChainExpression, Expression, isChainExpression, isMemberExpression, MemberExpression } from "src/generated";
-import { AbstractVisitor } from "./AbstractVisitor";
-import { AstNode } from "./peers/AstNode"
-import { factory } from "./factory/nodeFactory";
-import { Es2pandaTokenType, Es2pandaVariableDeclarationKind, Es2pandaVariableDeclaratorFlag } from "src/generated/Es2pandaEnums";
-
-
-export class ChainExpressionFilter extends AbstractVisitor {
-    static counter = 0
-    transformChainExpression(node: ChainExpression): Expression {
-        const expression = node.expression
-        if (expression == undefined) return node
-        if (!isMemberExpression(expression)) return node
-        return this.transformMemberExpression(expression)
-    }
-    transformMemberExpression(expression: MemberExpression): Expression {
-        const temporaryVarName = `chaintmp%%_${ChainExpressionFilter.counter++}`
-        return factory.createBlockExpression(
-            [
-                factory.createVariableDeclaration(
-                    Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_LET,
-                    [
-                        factory.createVariableDeclarator(
-                            Es2pandaVariableDeclaratorFlag.VARIABLE_DECLARATOR_FLAG_LET,
-                            factory.createIdentifier(temporaryVarName),
-                            expression.object
-                        )
-                    ],
-                    undefined
-                ),
-                factory.createExpressionStatement(
-                    factory.createConditionalExpression(
-                        factory.createBinaryExpression(
-                            factory.createIdentifier(temporaryVarName, undefined),
-                            factory.createUndefinedLiteral(),
-                            Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_STRICT_EQUAL
-                        ),
-                        factory.createUndefinedLiteral(),
-                        factory.createMemberExpression(
-                            factory.createIdentifier(temporaryVarName, undefined),
-                            expression.property,
-                            expression.kind,
-                            expression.isComputed,
-                            false
-                        )
-                    )
-                )
-            ]
-        )
-    }
-
-
-    visitor(beforeChildren: BlockStatement): BlockStatement
-    visitor(beforeChildren: AstNode): AstNode {
-        const node = this.visitEachChild(beforeChildren)
-        if (isChainExpression(node)) {
-            return this.transformChainExpression(node)
-        }
-        if (isMemberExpression(node) && node.isOptional) {
-            return this.transformMemberExpression(node)
-        }
-        return node
-    }
-}