@idlizer/arktscgen 2.1.10-arktscgen-3 → 2.1.10-arktscgen-4

package/lib/index.js

@@ -3834,6 +3834,8 @@ 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";
@@ -3845,11 +3847,13 @@ var IDLExtendedAttributes;
     IDLExtendedAttributes["TypeAnnotations"] = "TypeAnnotations";
     IDLExtendedAttributes["TypeArguments"] = "TypeArguments";
     IDLExtendedAttributes["TypeParameters"] = "TypeParameters";
+    IDLExtendedAttributes["TypeParametersDefaults"] = "TypeParametersDefaults";
     IDLExtendedAttributes["VerbatimDts"] = "VerbatimDts";
     IDLExtendedAttributes["HandWrittenImplementation"] = "HandWrittenImplementation";
     IDLExtendedAttributes["ExtraMethod"] = "ExtraMethod";
     IDLExtendedAttributes["OverloadAlias"] = "OverloadAlias";
     IDLExtendedAttributes["OverloadPriority"] = "OverloadPriority";
+    IDLExtendedAttributes["TransformOnSerialize"] = "TransformOnSerialize";
 })(IDLExtendedAttributes || (IDLExtendedAttributes = {}));
 var IDLAccessorAttribute;
 (function (IDLAccessorAttribute) {
@@ -4188,6 +4192,7 @@ const IDLSerializerBuffer = createPrimitiveType('SerializerBuffer');
 const IDLFunctionType = createPrimitiveType('Function');
 const IDLCustomObjectType = createPrimitiveType('CustomObject');
 createPrimitiveType('InteropReturnBuffer');
+const IDLNullTypeName = "idlize.stdlib.Null";
 function createNamespace(name, members, nodeInitializer) {
     return Object.assign(Object.assign({ kind: IDLKind.Namespace, members: members !== null && members !== void 0 ? members : [], name: name }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
@@ -4559,23 +4564,29 @@ function escapeIDLKeyword(name) {
 const printedIndentInc = "[[indent-inc]]";
 const printedIndentDec = "[[indent-dec]]";
 function printType(type, options) {
+    var _a;
     if (!type)
         throw new Error("Missing type");
     if (isInterface$1(type))
         return type.name;
-    if (isOptionalType(type))
-        return `(${printType(type.type)} or ${IDLUndefinedType.name})`;
+    if (isOptionalType(type)) {
+        if (hasExtAttribute(type, IDLExtendedAttributes.UnionOnlyNull))
+            return `(${printType(type.type)} or ${IDLNullTypeName})`;
+        else if (hasExtAttribute(type, IDLExtendedAttributes.UnionWithNull))
+            return `(${printType(type.type)} or ${IDLUndefinedType.name} or${IDLNullTypeName})`;
+        else
+            return `(${printType(type.type)} or ${IDLUndefinedType.name})`;
+    }
     if (isPrimitiveType(type))
         return type.name;
     if (isContainerType(type))
         return `${type.containerKind}<${type.elementType.map(it => printType(it)).join(", ")}>`;
     if (isReferenceType(type)) {
-        const extAttrs = type.extendedAttributes ? Array.from(type.extendedAttributes) : [];
         if (type.typeArguments)
-            extAttrs.push({ name: IDLExtendedAttributes.TypeArguments, value: type.typeArguments.map(it => printType(it)).join(",") });
-        if (!extAttrs.length)
+            updateExtAttribute(type, IDLExtendedAttributes.TypeArguments, type.typeArguments.map(it => printType(it)).join(","));
+        if (!((_a = type.extendedAttributes) === null || _a === void 0 ? void 0 : _a.length))
             return type.name;
-        let res = `[${quoteAttributeValues(extAttrs)}] ${type.name}`;
+        let res = `[${quoteAttributeValues(type.extendedAttributes)}] ${type.name}`;
         if (options === null || options === void 0 ? void 0 : options.bracketsAroundReferenceTypeWithExtAttrs)
             return `(${res})`;
         return res;
@@ -4645,18 +4656,31 @@ function printExtendedAttributes(idl, indentLevel) {
             break;
     }
     const attributes = Array.from(idl.extendedAttributes || []);
-    if (typeParameters === null || typeParameters === void 0 ? void 0 : typeParameters.length)
+    if ((typeParameters === null || typeParameters === void 0 ? void 0 : typeParameters.length) && !attributes.find(x => x.name === IDLExtendedAttributes.TypeParameters))
         attributes.push({ name: IDLExtendedAttributes.TypeParameters, value: typeParameters.join(",") });
-    if (typeArguments === null || typeArguments === void 0 ? void 0 : typeArguments.length)
+    if ((typeArguments === null || typeArguments === void 0 ? void 0 : typeArguments.length) && !attributes.find(x => x.name === IDLExtendedAttributes.TypeArguments))
         attributes.push({ name: IDLExtendedAttributes.TypeArguments, value: typeArguments.map(it => printType(it)).join(",") });
     if (idl.documentation) {
         let docs = {
             name: IDLExtendedAttributes.Documentation,
             value: idl.documentation
         };
-        attributes.push(docs);
+        attributes.unshift(docs);
+    }
+    // Deduplicate
+    const names = new Set();
+    const actualAttributes = [];
+    for (const attr of attributes) {
+        if (names.has(attr.name)) {
+            continue;
+        }
+        names.add(attr.name);
+        actualAttributes.push(attr);
+    }
+    if (actualAttributes.length == 0) {
+        return [];
     }
-    const attrSpec = quoteAttributeValues(attributes);
+    const attrSpec = quoteAttributeValues(actualAttributes);
     return attrSpec ? [`[${attrSpec}]`] : [];
 }
 const attributesToQuote = new Set([
@@ -4668,6 +4692,7 @@ const attributesToQuote = new Set([
     IDLExtendedAttributes.TraceKey,
     IDLExtendedAttributes.TypeArguments,
     IDLExtendedAttributes.TypeParameters,
+    IDLExtendedAttributes.TypeParametersDefaults,
 ]);
 function quoteAttributeValues(attributes) {
     return attributes === null || attributes === void 0 ? void 0 : attributes.map(it => {
@@ -4856,6 +4881,17 @@ function getExtAttribute(node, name) {
     var _a, _b;
     return (_b = (_a = node.extendedAttributes) === null || _a === void 0 ? void 0 : _a.find(it => it.name === name)) === null || _b === void 0 ? void 0 : _b.value;
 }
+function removeExtAttribute(node, name) {
+    if (node.extendedAttributes) {
+        node.extendedAttributes = node.extendedAttributes.filter(it => it.name !== name);
+    }
+}
+function updateExtAttribute(node, name, value) {
+    var _a;
+    removeExtAttribute(node, name);
+    (_a = node.extendedAttributes) !== null && _a !== void 0 ? _a : (node.extendedAttributes = []);
+    node.extendedAttributes.push({ name, value });
+}
 const IDLContainerUtils = {
     isRecord: (x) => isContainerType(x) && x.containerKind === 'record',
     isSequence: (x) => isContainerType(x) && x.containerKind === 'sequence',
@@ -4904,11 +4940,30 @@ function linearizeNamespaceMembers(entries) {
     return linearized;
 }
 
+const stdlibModule = {
+    name: "__stdlib",
+    packages: [""],
+    useFoldersLayout: false,
+    external: true,
+    tsLikePackage: "__stdlib"
+};
 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;
@@ -4931,7 +4986,7 @@ function getApplicableModuleFor(packageName) {
     if (applicableModules.length === 0) {
         if (packageName === '') {
             console.error("WARNING: use current module for empty package");
-            return currentModule();
+            return stdlibModule;
         }
         if (packageName.startsWith(`idlize.`)) {
             return currentModule();
@@ -5256,8 +5311,11 @@ class LambdaExpression {
         if (this.body) {
             writer.writeStatement(new BlockStatement(this.body, isScoped, false));
         }
-        writer.features.forEach(([feature, module]) => {
-            this.originalWriter.addFeature(feature, module);
+        writer.features.forEach((feature) => {
+            if (feature.type === "raw")
+                this.originalWriter.addFeature(feature.feature, feature.module);
+            else
+                this.originalWriter.addFeature(feature.node);
         });
         return writer.getOutput()
             .map(line => (line.endsWith('{') || line.endsWith('}') || line.endsWith(';')) ? line : `${line};`)
@@ -5392,8 +5450,11 @@ class LanguageWriter {
         return this.printer.indentDepth();
     }
     maybeSemicolon() { return ";"; }
-    addFeature(feature, module) {
-        this.features.push([feature, module]);
+    addFeature(featureOrNode, module) {
+        if (typeof featureOrNode === "string")
+            this.features.push({ type: "raw", feature: featureOrNode, module: module });
+        else
+            this.features.push({ type: "idl", node: featureOrNode });
     }
     // version of makeCast which uses TypeCheck.typeCast<T>(value) call for ETS language writer
     // Use it only if TypeChecker class is added as import to the generated file
@@ -5459,7 +5520,7 @@ class LanguageWriter {
     makeThis() {
         return new StringExpression("this");
     }
-    makeNull(value) {
+    makeNull(type) {
         return new StringExpression("null");
     }
     makeVoid() {
@@ -6144,12 +6205,14 @@ const IncorrectLiteral = new DiagnosticMessageGroup("error", "IncorrectLiteral",
 const IncorrectIdentifier = new DiagnosticMessageGroup("error", "IncorrectIdentifier", "Incorrect identifier");
 const UnexpectedToken = new DiagnosticMessageGroup("error", "UnexpectedToken", "Unexpected token");
 const UnexpectedEndOfFile = new DiagnosticMessageGroup("fatal", "UnexpectedEndOfFile", "Unexpected end of file");
+const UnrecognizedSymbols = new DiagnosticMessageGroup("fatal", "UnrecognizedSymbols", "Unrecognized symbols");
 const UnsupportedSyntax = new DiagnosticMessageGroup("error", "UnsupportedSyntax", "Unsupported syntax");
 const WrongDeclarationPlacement = new DiagnosticMessageGroup("error", "WrongDeclarationPlacement", "Wrong declaration placement");
 const ExpectedPrimitiveType = new DiagnosticMessageGroup("error", "ExpectedPrimitiveType", "Expected primitive type");
 const ExpectedReferenceType = new DiagnosticMessageGroup("error", "ExpectedReferenceType", "Expected reference type");
 const ExpectedGenericArguments = new DiagnosticMessageGroup("error", "ExpectedGenericArguments", "Expected generic arguments");
 const UnexpectedGenericArguments = new DiagnosticMessageGroup("error", "UnexpectedGenericArguments", "Unexpected generic arguments");
+const InlineParsingDepthExceeded = new DiagnosticMessageGroup("fatal", "InlineParsingDepthExceeded", "Inline parsing depth exceeded");
 class FatalParserException extends Error {
     constructor(diagnosticMessages) {
         super();
@@ -6181,7 +6244,7 @@ class Parser {
         // TypeParameters support
         this._generics = [];
         // TypeArguments parsing support
-        this._enableInLiteralParsing = false;
+        this._inLiteralParsingLevel = 0;
         // symTokens = ["(", ")", "[", "]", "{", "}", ",", "...", ":", ";", "<", "=", ">", "?"]
         this._reDecimal = /-?(?=[0-9]*\.|[0-9]+[eE])(([0-9]+\.[0-9]*|[0-9]*\.[0-9]+)([Ee][-+]?[0-9]+)?|[0-9]+[Ee][-+]?[0-9]+)/y;
         this._reInteger = /-?(0([Xx][0-9A-Fa-f]+|[0-7]*)|[1-9][0-9]*)/y;
@@ -6269,17 +6332,17 @@ class Parser {
             this._curToken = { kind: TokenKind.End, value: "", location: { documentPath: this.fileName, lines: this.lines, range: { start: pos, end: pos } } };
             return;
         }
-        if (this._enableInLiteralParsing && this.content[this._curOffset] == "\"") {
+        if (this._inLiteralParsingLevel && (this.content[this._curOffset] == "\"" || this.content[this._curOffset] == "'")) {
             // TypeArguments parsing support
             const pos = { line: this._curLine + 1, character: this._curOffset - this.offsets[this._curLine] + 1 };
-            this._curToken = { kind: TokenKind.Symbol, value: "\"", location: { documentPath: this.fileName, lines: this.lines, range: { start: pos, end: pos } } };
+            this._curToken = { kind: TokenKind.Symbol, value: this.content[this._curOffset], location: { documentPath: this.fileName, lines: this.lines, range: { start: pos, end: pos } } };
             this._curOffset += 1;
             return;
         }
         const token = ((_d = (_c = (_b = (_a = this._match(this._reDecimal, TokenKind.Literal)) !== null && _a !== void 0 ? _a : this._match(this._reInteger, TokenKind.Literal)) !== null && _b !== void 0 ? _b : this._match(this._reString, TokenKind.Literal)) !== null && _c !== void 0 ? _c : this._match(this._reWords, TokenKind.Words)) !== null && _d !== void 0 ? _d : this._match(this._reSymbol, TokenKind.Symbol));
         if (!token) {
             const pos = { line: this._curLine + 1, character: this._curOffset - this.offsets[this._curLine] + 1 };
-            ParsingFatal.throwDiagnosticMessage([{ documentPath: this.fileName, lines: this.lines, range: { start: pos, end: pos } }], "Unrecognized symbols");
+            UnrecognizedSymbols.throwDiagnosticMessage([{ documentPath: this.fileName, lines: this.lines, range: { start: pos, end: pos } }]);
         }
         // Uncomment in case of parser debugging
         // if (token) {
@@ -6573,28 +6636,32 @@ class Parser {
                 duplicates.add(name.value);
             }
             names.add(name.value);
-            if (name.value == IDLExtendedAttributes.TypeArguments) {
+            if (name.value == IDLExtendedAttributes.TypeArguments || name.value == IDLExtendedAttributes.TypeParametersDefaults) {
                 // TypeArguments parsing support
                 try {
-                    this._enableInLiteralParsing = true;
+                    this._inLiteralParsingLevel += 1;
+                    if (this._inLiteralParsingLevel > 2) {
+                        InlineParsingDepthExceeded.throwDiagnosticMessage([this.curLocation]);
+                    }
                     this.skip("=");
                     const vloc = this.trackLocation();
                     const start = this._curOffset; // Already after first quote
-                    this.skip("\"");
+                    this.skip(this._inLiteralParsingLevel == 2 ? "'" : "\"");
                     const types = this.parseTypeList();
                     const end = this._curOffset - 1; // Already after second quote
-                    this._enableInLiteralParsing = false;
-                    this.skip("\"");
+                    this._inLiteralParsingLevel -= 1;
+                    // Note that second this._inLiteralParsingLevel comparison happens after decrement
+                    this.skip(this._inLiteralParsingLevel == 1 ? "'" : "\"");
                     const stringValue = this.content.slice(start, end);
                     ext.push({ name: name.value, value: stringValue, typesValue: types, nameLocation: name.location, valueLocation: vloc() });
                 }
                 catch (e) {
-                    this.skipToAfter("\"");
+                    if (e instanceof DiagnosticException && e.diagnosticMessage.severity != "fatal") {
+                        this.skipToAfter("\"");
+                    }
+                    this._inLiteralParsingLevel = 0;
                     throw e;
                 }
-                finally {
-                    this._enableInLiteralParsing = false;
-                }
             }
             else {
                 let value;
@@ -6766,9 +6833,9 @@ class Parser {
         const name = this.parseSingleIdentifier();
         this.skip("=");
         const value = this.parseLiteral();
-        const extracted = extractLiteral(value);
         this.skip(";");
-        return createConstant(name.value, type, extracted.extractedString, { extendedAttributes: ext, nodeLocation: sloc(), nameLocation: name.location, valueLocation: value.location });
+        // Note that raw value (with quoted strings) is used here, that provides compatibility with older code (while being different from `dictionary` processing)
+        return createConstant(name.value, type, value.value, { extendedAttributes: ext, nodeLocation: sloc(), nameLocation: name.location, valueLocation: value.location });
     }
     parseAttribute() {
         const sloc = this.trackLocation();
@@ -6852,11 +6919,14 @@ class Parser {
         const sloc = this.trackLocation();
         const type = this.parsePrimitiveType();
         const name = this.parseSingleIdentifier();
-        this.skip("=");
-        const value = this.parseLiteral();
-        const extracted = extractLiteral(value);
+        let value;
+        let extracted;
+        if (this.seeAndSkip("=")) {
+            value = this.parseLiteral();
+            extracted = extractLiteral(value);
+        }
         this.skip(";");
-        return createEnumMember(name.value, undefined, type, extracted.extractedValue, { extendedAttributes: ext, nodeLocation: sloc(), nameLocation: name.location, valueLocation: value.location });
+        return createEnumMember(name.value, undefined, type, extracted === null || extracted === void 0 ? void 0 : extracted.extractedValue, { extendedAttributes: ext, nodeLocation: sloc(), nameLocation: name.location, valueLocation: value === null || value === void 0 ? void 0 : value.location });
     }
     parsePackage() {
         const sloc = this.trackLocation();
@@ -7022,6 +7092,93 @@ const builtinTypesList = [IDLPointerType, IDLVoidType, IDLBooleanType,
 const builtinTypes = new Map(builtinTypesList.map(x => [x.name, x]));
 const builtinGenericTypeNames = new Set(["sequence", "record", "Promise"]);
 
+/*
+ * Copyright (c) 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.
+ */
+function lineDigitCount(message) {
+    let count = 0;
+    for (let part of message.parts) {
+        let range = part.location.range;
+        if (range == null) {
+            continue;
+        }
+        count = Math.max(count, range.start.line.toString().length, range.end.line.toString().length);
+    }
+    return count;
+}
+function paddedLineNo(digits, line) {
+    let s = line.toString();
+    if (s.length < digits) {
+        return " ".repeat(digits - s.length) + s;
+    }
+    return s;
+}
+function formatLine(digits, lines, lineNo) {
+    return `${paddedLineNo(digits, lineNo)} | ${lines[lineNo - 1]}`;
+}
+function formatUnderline(indent, lines, lineNo, range, edgeChar, midChar, message) {
+    if (lineNo == range.start.line && lineNo == range.end.line) {
+        let len = range.end.character - range.start.character + 1;
+        return `${indent} | ${" ".repeat(range.start.character - 1)}${edgeChar}${len > 2 ? midChar.repeat(len - 2) : ""}${len > 1 ? edgeChar : ""} ${message}`;
+    }
+    if (lineNo == range.start.line) {
+        let len = lines[lineNo - 1].length - range.start.character;
+        return `${indent} | ${" ".repeat(range.start.character - 1)}${edgeChar}${len > 1 ? midChar.repeat(len - 1) : ""}`;
+    }
+    if (lineNo == range.end.line) {
+        let len = range.end.character;
+        return `${indent} | ${len > 1 ? midChar.repeat(len - 1) : ""}${edgeChar} ${message}`;
+    }
+    return `${indent} | ${midChar.repeat(lines[lineNo - 1].length)}`;
+}
+function outputDiagnosticMessageFormatted(message) {
+    if (message.parts.length == 0) {
+        return;
+    }
+    console.log(`${message.severity}[${message.code}]: ${message.codeDescription}`);
+    let digits = lineDigitCount(message);
+    let indent = " ".repeat(digits);
+    let first = true;
+    let lastPath = "";
+    for (let part of message.parts) {
+        const location = part.location;
+        if (location.range != null && location.lines != null) {
+            let range = location.range;
+            let lines = location.lines;
+            console.log(`${indent}${lastPath != part.location.documentPath ? "-->" : ":::"} ${part.location.documentPath}:${range.start.line}:${range.start.character}`);
+            console.log(`${indent} |`);
+            const last = Math.min(range.end.line + 1, lines.length - 1);
+            for (let i = Math.max(range.start.line - 1, 1); i <= last; ++i) {
+                console.log(formatLine(digits, lines, i));
+                if (i >= range.start.line && i <= range.end.line) {
+                    console.log(formatUnderline(indent, lines, i, range, "^", first ? "-" : "~", part.message));
+                }
+            }
+        }
+        else {
+            console.log(`${indent}--> ${part.location.documentPath}`);
+            if (message.parts.length > 1) {
+                console.log(`${indent} # ${part.message}`);
+            }
+        }
+        first = false;
+        lastPath = part.location.documentPath;
+    }
+    console.log(`${indent} = ${message.parts[0].message}`);
+    console.log();
+}
+
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -7039,6 +7196,10 @@ const builtinGenericTypeNames = new Set(["sequence", "record", "Promise"]);
 function getTokens(node) {
     return node.tokens;
 }
+const extendedAttributesWithTypesValue = [
+    IDLExtendedAttributes.TypeArguments,
+    IDLExtendedAttributes.TypeParametersDefaults,
+];
 const syntheticTypes = new Map();
 function addSyntheticType(name, type) {
     if (syntheticTypes.has(name)) {
@@ -7050,9 +7211,8 @@ class IDLDeserializer {
     enterGenericScope(generics) {
         this.genericsScopes.push(new Set(generics !== null && generics !== void 0 ? generics : []));
     }
-    constructor(info, inheritanceMode = 'multiple') {
+    constructor(info) {
         this.info = info;
-        this.inheritanceMode = inheritanceMode;
         this.namespacePathNames = [];
         this.currentPackage = [];
         this.genericsScopes = [];
@@ -7149,7 +7309,7 @@ class IDLDeserializer {
             node.inheritance.forEach(it => {
                 const attributes = it.extAttrs;
                 const parentTypeArgs = this.extractTypeArguments(file, attributes !== null && attributes !== void 0 ? attributes : [], IDLExtendedAttributes.TypeArguments);
-                const attrs = this.toExtendedAttributes(attributes !== null && attributes !== void 0 ? attributes : []); // ?.filter(it => it.name !== idl.IDLExtendedAttributes.TypeArguments)
+                const attrs = this.toExtendedAttributes(file, attributes !== null && attributes !== void 0 ? attributes : []); // ?.filter(it => it.name !== idl.IDLExtendedAttributes.TypeArguments)
                 const ref = createReferenceType(it.inheritance, parentTypeArgs, {
                     extendedAttributes: attrs
                 });
@@ -7169,7 +7329,7 @@ class IDLDeserializer {
             .map(it => this.toIDLCallable(file, it)), generics, {
             fileName: file,
             documentation: this.makeDocs(node),
-            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
         });
         this.genericsScopes.pop();
         this.info.set(result, getTokens(node));
@@ -7185,6 +7345,8 @@ class IDLDeserializer {
             // is it IDLStringType?
             const refType = createReferenceType(type);
             refType.fileName = file;
+            // Here is a bug: type.extAttrs are ignored, so typeArguments on ([TypeArguments="T"] Something) are always lost
+            // That must be fixed together with fixing non-generic placeholders on generic types in pipelines (like WrappedBuilder)
             refType.typeArguments = this.extractTypeArguments(file, extAttrs, IDLExtendedAttributes.TypeArguments);
             return refType;
         }
@@ -7242,7 +7404,7 @@ class IDLDeserializer {
                 idlRefType = ref;
             }
             idlRefType.fileName = file;
-            idlRefType.extendedAttributes = this.toExtendedAttributes(combinedExtAttrs);
+            idlRefType.extendedAttributes = this.toExtendedAttributes(file, combinedExtAttrs);
             return this.withInfo(type, idlRefType);
         }
         if (isSequenceTypeDescription(type) || isPromiseTypeDescription(type) || isRecordTypeDescription(type)) {
@@ -7270,7 +7432,7 @@ class IDLDeserializer {
             isAsync: node.async,
         }, {
             documentation: this.makeDocs(node),
-            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
         }, generics));
         this.genericsScopes.pop();
         return result;
@@ -7283,8 +7445,6 @@ class IDLDeserializer {
         const generics = this.extractGenerics(node.extAttrs);
         this.enterGenericScope(generics);
         const returnType = this.toIDLType(file, node.idlType, node.extAttrs);
-        if (isReferenceType(returnType))
-            returnType.typeArguments = this.extractTypeArguments(file, node.extAttrs, IDLExtendedAttributes.TypeArguments);
         const result = this.withInfo(node, createMethod((_a = node.name) !== null && _a !== void 0 ? _a : "", node.arguments.map(it => this.toIDLParameter(file, it !== null && it !== void 0 ? it : new Map())), returnType, {
             isStatic: node.special === "static",
             isAsync: node.async,
@@ -7292,7 +7452,7 @@ class IDLDeserializer {
             isFree
         }, {
             documentation: this.makeDocs(node),
-            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
         }, generics));
         this.genericsScopes.pop();
         return result;
@@ -7300,7 +7460,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),
+            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
         }));
     }
     toIDLParameter(file, node) {
@@ -7313,7 +7473,7 @@ class IDLDeserializer {
         this.enterGenericScope(generics);
         const result = createCallback(node.name, node.arguments.map(it => this.toIDLParameter(file, it)), this.toIDLType(file, node.idlType, undefined), {
             fileName: file,
-            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
             documentation: this.makeDocs(node),
         }, generics);
         if (node.extAttrs.find(it => it.name === "Synthetic")) {
@@ -7327,7 +7487,7 @@ class IDLDeserializer {
         const generics = this.extractGenerics(node.extAttrs);
         this.enterGenericScope(generics);
         const result = this.withInfo(node, createTypedef(node.name, this.toIDLType(file, node.idlType, undefined, node.name), generics, {
-            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
             documentation: this.makeDocs(node),
             fileName: file,
         }));
@@ -7340,7 +7500,7 @@ class IDLDeserializer {
     toIDLDictionary(file, node) {
         const result = createEnum(node.name, [], {
             documentation: this.makeDocs(node),
-            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
             fileName: file,
         });
         result.elements = node.members.map(it => this.toIDLEnumMember(file, it, result));
@@ -7348,7 +7508,7 @@ class IDLDeserializer {
     }
     toIDLNamespace(file, node) {
         const namespace = createNamespace(node.name, [], {
-            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
             fileName: file
         });
         this.namespacePathNames.push(node.name);
@@ -7358,7 +7518,7 @@ class IDLDeserializer {
     }
     toIDLVersion(file, node) {
         return this.withInfo(node, createVersion(node.value, {
-            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
             fileName: file
         }));
     }
@@ -7366,7 +7526,7 @@ class IDLDeserializer {
         return this.withInfo(node, createProperty(node.name, this.toIDLType(file, node.idlType, undefined), node.readonly, node.special === "static", isOptional(node), {
             documentation: this.makeDocs(node),
             fileName: file,
-            extendedAttributes: this.toExtendedAttributes(node.extAttrs)
+            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs)
         }));
     }
     toIDLEnumMember(file, node, parent) {
@@ -7385,12 +7545,18 @@ class IDLDeserializer {
             throw new Error(`Not representable enum initializer: ${JSON.stringify(node.default)}. Found in ${file}`);
         }
         return this.withInfo(node, createEnumMember(node.name, parent, this.toIDLType(file, node.idlType, undefined), initializer, {
-            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
         }));
     }
-    toExtendedAttributes(extAttrs) {
+    toExtendedAttributes(file, extAttrs) {
         return extAttrs.map(it => {
-            return this.withInfo(it, { name: it.name, value: this.toExtendedAttributeValue(it) });
+            return this.withInfo(it, {
+                name: it.name,
+                value: this.toExtendedAttributeValue(it),
+                typesValue: extendedAttributesWithTypesValue.includes(it.name)
+                    ? this.extractTypeArguments(file, extAttrs, it.name)
+                    : undefined
+            });
         });
     }
     toExtendedAttributeValue(attr) {
@@ -7406,7 +7572,7 @@ class IDLDeserializer {
         const result = createEnum(node.name, [], {
             fileName: file,
             documentation: this.makeDocs(node),
-            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
         });
         result.elements = node.values.map((it) => createEnumMember(it.value, result, IDLNumberType, undefined));
         return this.withInfo(node, result);
@@ -7609,8 +7775,36 @@ function compareParsingResults(oldFile, newFile) {
     if (paths.size > 0) {
         DifferenceFound.reportDiagnosticMessage([newFile.nodeLocation], "Differences found in those paths:\n" + [...paths].join("\n"));
     }
+    return paths.size == 0;
 }
-function parseIdlNew(fileName, content, registerSynthetics) {
+function parseIDLFile(fileName, content, quiet) {
+    const previousDiagnosticsCount = DiagnosticMessageGroup.allGroupsEntries.length;
+    try {
+        let newFile;
+        // Temporarily is set to use old parser by default
+        // Old parser has a bug, it ignores extended attributes on return types, but some pipelines depend on that behavior
+        // So pipelines and old parser must be fixed before permanent switch to a new parser
+        const mode = process.env.IDLPARSE;
+        if (mode === "compare" || mode === "old") {
+            newFile = parseIDLFileOld(fileName, content);
+            if (mode === "old") {
+                return newFile;
+            }
+        }
+        const file = parseIDLFileNew(fileName, content, mode !== "compare");
+        if (mode === "compare") {
+            compareParsingResults(file, newFile);
+            return newFile;
+        }
+        return file;
+    }
+    finally {
+        if (DiagnosticMessageGroup.allGroupsEntries.length != previousDiagnosticsCount) {
+            DiagnosticMessageGroup.allGroupsEntries.slice(previousDiagnosticsCount).map(it => outputDiagnosticMessageFormatted(it));
+        }
+    }
+}
+function parseIDLFileNew(fileName, content, registerSynthetics) {
     let file = new Parser(fileName, content).parseIDL();
     const ancestors = [];
     const namespaces = [];
@@ -7646,18 +7840,10 @@ function parseIdlNew(fileName, content, registerSynthetics) {
     });
     return file;
 }
-function toIDLFile(fileName, { content, inheritanceMode = 'multiple' } = {}) {
+function parseIDLFileOld(fileName, content) {
     var _a, _b, _c;
-    let newFile;
-    const mode = process.env.IDLPARSE;
-    if (mode == "compare" || mode == "new") {
-        newFile = parseIdlNew(fileName, content, mode == "new");
-        if (mode == "new") {
-            return [newFile, new Map()];
-        }
-    }
     const lexicalInfo = new Map();
-    const deserializer = new IDLDeserializer(lexicalInfo, inheritanceMode);
+    const deserializer = new IDLDeserializer(lexicalInfo);
     if (undefined === content) {
         try {
             content = fs__namespace.readFileSync(fileName).toString();
@@ -7706,11 +7892,7 @@ function toIDLFile(fileName, { content, inheritanceMode = 'multiple' } = {}) {
             node.nameLocation = nameLocation;
         }
     });
-    if (mode == "compare") {
-        compareParsingResults(file, newFile);
-        return [newFile, new Map()];
-    }
-    return [file, lexicalInfo];
+    return file;
 }
 function prepareOffsets(lines) {
     let offsets = [];
@@ -8227,7 +8409,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}`);
     }
@@ -8487,6 +8669,9 @@ class TSLanguageWriter extends LanguageWriter {
     pushNamespace(namespace, options) {
         this.namespaceStack.push(namespace);
         const declaredPrefix = options.isDeclared ? "declare " : "";
+        if (options.isDefault) {
+            this.print(`export default ${namespace}`);
+        }
         this.print(`export ${declaredPrefix}namespace ${namespace} {`);
         if (options.ident)
             this.pushIndent();
@@ -8655,7 +8840,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) {
@@ -8712,7 +8899,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) {
@@ -9043,9 +9238,6 @@ class ETSLanguageWriter extends TSLanguageWriter {
         this.arrayConvertor = arrayConvertor;
     }
     pushNamespace(namespace, options) {
-        if (options.isDefault) {
-            this.print(`export default ${namespace}`);
-        }
         super.pushNamespace(namespace, options);
     }
     fork(options) {
@@ -9382,7 +9574,7 @@ class InterfaceConvertor extends BaseArgConvertor {
     convertorSerialize(param, value, writer) {
         const accessor = getSerializerName(this.declaration);
         writer.addFeature(accessor, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
-        return writer.makeStatement(writer.makeStaticMethodCall(accessor, 'write', [writer.makeString(`${param}Serializer`), writer.makeString(value)]));
+        return writer.makeStatement(writer.makeStaticMethodCall(accessor, 'write', [writer.makeString(`${param}Serializer`), writer.makeString(writer.escapeKeyword(value))]));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
         const accessor = getSerializerName(this.declaration);
@@ -9477,7 +9669,6 @@ class MaterializedClassConvertor extends BaseArgConvertor {
             case Language.CPP:
                 return `static_cast<${generatorTypePrefix()}${qualifiedName(this.declaration, "_", "namespace.name")}>(${param})`;
             case Language.JAVA:
-            case Language.KOTLIN:
             case Language.CJ:
                 return `MaterializedBase.toPeerPtr(${writer.escapeKeyword(param)})`;
             default:
@@ -10043,16 +10234,22 @@ const ModuleConfigurationSchema = D.object({
     external: D.maybe(D.boolean()),
     packages: T.stringArray(),
     useFoldersLayout: D.maybe(D.boolean()),
+    tsLikePackage: D.maybe(D.string()),
 });
 const HookMethodSchema = D.object({
     hookName: D.string(),
     replaceImplementation: D.boolean()
 });
+const TransformOnSerializeSchema = D.object({
+    from: D.string(),
+    to: D.string(),
+});
 D.object({
     ApiKind: D.number(),
     TypePrefix: D.string(),
     LibraryPrefix: D.string(),
     OptionalPrefix: D.string(),
+    transformOnSerialize: D.array(TransformOnSerializeSchema),
     rootComponents: T.stringArray(),
     standaloneComponents: T.stringArray(),
     parameterized: T.stringArray(),
@@ -10074,6 +10271,7 @@ const defaultCoreConfiguration = {
     TypePrefix: "",
     LibraryPrefix: "",
     OptionalPrefix: "",
+    transformOnSerialize: [],
     rootComponents: [],
     standaloneComponents: [],
     parameterized: [],
@@ -12434,6 +12632,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
@@ -13313,7 +13537,7 @@ class Importer {
             return it;
         }
         this.seen.add(it);
-        this.import(it, "../../reexport-for-generated");
+        this.import(it, "../../src/reexport-for-generated");
         return it;
     }
     import(name, from) {
@@ -13477,21 +13701,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`);
             },
@@ -13502,6 +13740,7 @@ class BindingReturnValueTypeConvertor extends TopLevelTypeConvertor {
             boolean: plain,
             undefined: plain
         });
+        this.importer = importer;
     }
 }
 
@@ -13542,7 +13781,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) {
@@ -14307,12 +14546,12 @@ class DynamicEmitter {
         this.generatorVersion = `Unknown`;
         this.logDir = `./out/log-idl`;
         this.logCount = 0;
-        this.bridgesPrinter = new SingleFileEmitter((idl) => new BridgesPrinter(this.config, idl).print(), `libarkts/native/src/generated/bridges.cc`, `bridges.cc`, true);
-        this.bindingsPrinter = new SingleFileEmitter((idl) => new BindingsPrinter(idl).print(), `libarkts/src/generated/Es2pandaNativeModule.ts`, `Es2pandaNativeModule.ts`, true);
-        this.enumsPrinter = new SingleFileEmitter((idl) => new EnumsPrinter(idl).print(), `libarkts/src/generated/Es2pandaEnums.ts`, `Es2pandaEnums.ts`, true);
-        this.indexPrinter = new SingleFileEmitter((idl) => new IndexPrinter(idl).print(), `libarkts/src/generated/index.ts`, `index.ts`, true);
-        this.peersPrinter = new MultiFileEmitter((idl) => new AllPeersPrinter(this.config, idl).print(), `libarkts/src/generated/peers`, `peer.ts`, true);
-        this.factoryPrinter = new SingleFileEmitter((idl) => new FactoryPrinter(this.config, idl).print(), `libarkts/src/generated/factory.ts`, `factory.ts`, true);
+        this.bridgesPrinter = new SingleFileEmitter((idl) => new BridgesPrinter(this.config, idl).print(), `libarkts/generated/native/bridges.cc`, `bridges.cc`, true);
+        this.bindingsPrinter = new SingleFileEmitter((idl) => new BindingsPrinter(idl).print(), `libarkts/generated/Es2pandaNativeModule.ts`, `Es2pandaNativeModule.ts`, true);
+        this.enumsPrinter = new SingleFileEmitter((idl) => new EnumsPrinter(idl).print(), `libarkts/generated/Es2pandaEnums.ts`, `Es2pandaEnums.ts`, true);
+        this.indexPrinter = new SingleFileEmitter((idl) => new IndexPrinter(idl).print(), `libarkts/generated/index.ts`, `index.ts`, true);
+        this.peersPrinter = new MultiFileEmitter((idl) => new AllPeersPrinter(this.config, idl).print(), `libarkts/generated/peers`, `peer.ts`, true);
+        this.factoryPrinter = new SingleFileEmitter((idl) => new FactoryPrinter(this.config, idl).print(), `libarkts/generated/factory.ts`, `factory.ts`, true);
         const myJson = path__namespace$1.resolve(__dirname, '..', 'package.json');
         if (fs__namespace$1.existsSync(myJson)) {
             this.generatorVersion = (_b = (_a = lib.parse(fs__namespace$1.readFileSync(myJson).toString())) === null || _a === void 0 ? void 0 : _a.version) !== null && _b !== void 0 ? _b : `Unknown`;
@@ -14706,7 +14945,7 @@ function main() {
     if (options.initialize) {
         new StaticEmitter(options.outputDir, options.pandaSdkPath).emit();
     }
-    new DynamicEmitter(options.outputDir, options.pandaSdkPath, toIDLFile(path__namespace$1.join(options.pandaSdkPath, pandaSdkIdlFilePath), { inheritanceMode: 'single' })[0], new Config(new IgnoreOptions(options.optionsFile), new NonNullableOptions(options.optionsFile), new IrHackOptions(options.optionsFile), new CodeFragmentOptions(options.optionsFile), new ExtraParameters(options.optionsFile)), options.debug).emit();
+    new DynamicEmitter(options.outputDir, options.pandaSdkPath, parseIDLFile(path__namespace$1.join(options.pandaSdkPath, pandaSdkIdlFilePath)), new Config(new IgnoreOptions(options.optionsFile), new NonNullableOptions(options.optionsFile), new IrHackOptions(options.optionsFile), new CodeFragmentOptions(options.optionsFile), new ExtraParameters(options.optionsFile)), options.debug).emit();
 }
 main();
 //# sourceMappingURL=index.js.map