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

package/build/lib/src/config.js

@@ -22,16 +22,22 @@ export const ModuleConfigurationSchema = D.object({
     external: D.maybe(D.boolean()),
     packages: T.stringArray(),
     useFoldersLayout: D.maybe(D.boolean()),
+    tsLikePackage: D.maybe(D.string()),
 });
 export const HookMethodSchema = D.object({
     hookName: D.string(),
     replaceImplementation: D.boolean()
 });
+export const TransformOnSerializeSchema = D.object({
+    from: D.string(),
+    to: D.string(),
+});
 export const CoreConfigurationSchema = 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(),
@@ -53,6 +59,7 @@ export const defaultCoreConfiguration = {
     TypePrefix: "",
     LibraryPrefix: "",
     OptionalPrefix: "",
+    transformOnSerialize: [],
     rootComponents: [],
     standaloneComponents: [],
     parameterized: [],

package/build/lib/src/formatter.js

@@ -78,9 +78,12 @@ export function outputDiagnosticMessageFormatted(message) {
             let lines = location.lines;
             console.log(`${indent}${lastPath != part.location.documentPath ? "-->" : ":::"} ${part.location.documentPath}:${range.start.line}:${range.start.character}`);
             console.log(`${indent} |`);
-            for (let i = range.start.line; i <= range.end.line; ++i) {
+            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));
-                console.log(formatUnderline(indent, lines, i, range, "^", first ? "-" : "~", part.message));
+                if (i >= range.start.line && i <= range.end.line) {
+                    console.log(formatUnderline(indent, lines, i, range, "^", first ? "-" : "~", part.message));
+                }
             }
         }
         else {

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

@@ -14,7 +14,7 @@
  */
 import { indentedBy, isInNamespace } from "../util";
 import { IDLEntity, IDLKind, getExtAttribute, getVerbatimDts, hasExtAttribute, isCallback, isConstructor, isContainerType, isEnum, isInterface, isMethod, isPrimitiveType, isProperty, isReferenceType, isSyntheticEntry, isTypeParameterType, isTypedef, isUnionType, isImport, isVersion, isNamespace, IDLExtendedAttributes, IDLAccessorAttribute, IDLVoidType, IDLStringType, IDLUndefinedType, isCallable, IDLAnyType, IDLContainerUtils, DebugUtils, mixMethodParametersAndTags, createReferenceType, transformMethodsAsync2ReturnPromise, linearizeNamespaceMembers, isNamedNode, IDLThisType, isOptionalType, IDLI8Type, IDLU8Type, IDLI16Type, IDLU16Type, IDLI32Type, IDLU32Type, IDLI64Type, IDLU64Type, IDLF16Type, IDLF32Type, IDLF64Type, IDLBufferType, isUnspecifiedGenericType, IDLUnknownType, IDLBooleanType, IDLNumberType, IDLPointerType, IDLInterfaceSubkind, escapeIDLKeyword, getNamespacesPathFor, IDLBigintType, IDLDate, IDLFunctionType, getQualifiedName, IDLObjectType } from "../idl";
-import { resolveSyntheticType, toIDLFile } from "./deserialize";
+import { resolveSyntheticType, parseIDLFile } from "./deserialize";
 import { Language } from "../Language";
 import { warn } from "../util";
 import { isInIdlize } from "../idlize";
@@ -359,7 +359,7 @@ export class CustomPrintVisitor {
 }
 export function idlToDtsString(name, content) {
     let printer = new CustomPrintVisitor(resolveSyntheticType, Language.TS);
-    const [idlFile] = toIDLFile(name, { content });
+    const idlFile = parseIDLFile(name, content);
     printer.printPackage(idlFile);
     linearizeNamespaceMembers(idlFile.entries).forEach(it => {
         transformMethodsAsync2ReturnPromise(it);

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

@@ -14,7 +14,7 @@
  */
 import * as fs from "fs";
 import * as path from "path";
-import { toIDLFile } from "./deserialize";
+import { parseIDLFile } from "./deserialize";
 import { zip } from "../util";
 function getFilesRecursive(dirPath, arrayOfFiles = []) {
     let files = fs.readdirSync(dirPath);
@@ -65,7 +65,7 @@ export function scanIDL(inputDir, inputFile) {
         ? [path.join(inputDir, inputFile)]
         : fs.readdirSync(inputDir)
             .map((elem) => path.join(inputDir, elem));
-    return files.map(it => toIDLFile(it)[0]);
+    return files.map(it => parseIDLFile(it));
 }
 export const licence = `/*
  * Copyright (c) 2024 Huawei Device Co., Ltd.

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

@@ -4,12 +4,8 @@ export type WebIDLTokenCollection = Record<string, webidl2.Token | null | undefi
 export type IDLTokenInfoMap = Map<unknown, WebIDLTokenCollection>;
 export declare function addSyntheticType(name: string, type: idl.IDLEntry): void;
 export declare function resolveSyntheticType(type: idl.IDLReferenceType): idl.IDLEntry | undefined;
-type IDLInheritanceMode = 'single' | 'multiple';
-interface ToIDLFileProps {
-    inheritanceMode?: IDLInheritanceMode;
-    content?: string;
-}
 export declare function toIdlType(fileName: string, content: string): idl.IDLType;
-export declare function toIDLFile(fileName: string, { content, inheritanceMode }?: ToIDLFileProps): [idl.IDLFile, IDLTokenInfoMap];
-export {};
+export declare function compareParsingResults(oldFile: idl.IDLFile, newFile: idl.IDLFile): boolean;
+export declare function parseIDLFile(fileName: string, content?: string, quiet?: boolean): idl.IDLFile;
+export declare function parseIDLFileNew(fileName: string, content?: string, registerSynthetics?: boolean): idl.IDLFile;
 //# sourceMappingURL=deserialize.d.ts.map

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

@@ -22,9 +22,14 @@ import { collapseTypes, generateSyntheticUnionName } from "../peer-generation/id
 import { commonRange } from "../diagnostictypes";
 import { DiagnosticMessageGroup, LoadingFatal, ParsingFatal, InternalFatal } from "../diagnosticmessages";
 import { FatalParserException, Parser } from "./parser";
+import { outputDiagnosticMessageFormatted } from "../formatter";
 function getTokens(node) {
     return node.tokens;
 }
+const extendedAttributesWithTypesValue = [
+    idl.IDLExtendedAttributes.TypeArguments,
+    idl.IDLExtendedAttributes.TypeParametersDefaults,
+];
 const syntheticTypes = new Map();
 export function addSyntheticType(name, type) {
     if (syntheticTypes.has(name)) {
@@ -39,9 +44,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 = [];
@@ -138,7 +142,7 @@ class IDLDeserializer {
             node.inheritance.forEach(it => {
                 const attributes = it.extAttrs;
                 const parentTypeArgs = this.extractTypeArguments(file, attributes !== null && attributes !== void 0 ? attributes : [], idl.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 = idl.createReferenceType(it.inheritance, parentTypeArgs, {
                     extendedAttributes: attrs
                 });
@@ -158,7 +162,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));
@@ -174,6 +178,8 @@ class IDLDeserializer {
             // is it IDLStringType?
             const refType = idl.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, idl.IDLExtendedAttributes.TypeArguments);
             return refType;
         }
@@ -231,7 +237,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)) {
@@ -259,7 +265,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;
@@ -272,8 +278,6 @@ class IDLDeserializer {
         const generics = this.extractGenerics(node.extAttrs);
         this.enterGenericScope(generics);
         const returnType = this.toIDLType(file, node.idlType, node.extAttrs);
-        if (idl.isReferenceType(returnType))
-            returnType.typeArguments = this.extractTypeArguments(file, node.extAttrs, idl.IDLExtendedAttributes.TypeArguments);
         const result = this.withInfo(node, idl.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,
@@ -281,7 +285,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;
@@ -289,7 +293,7 @@ class IDLDeserializer {
     toIDLConstructor(file, node) {
         return this.withInfo(node, idl.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) {
@@ -302,7 +306,7 @@ class IDLDeserializer {
         this.enterGenericScope(generics);
         const result = idl.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")) {
@@ -316,7 +320,7 @@ class IDLDeserializer {
         const generics = this.extractGenerics(node.extAttrs);
         this.enterGenericScope(generics);
         const result = this.withInfo(node, idl.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,
         }));
@@ -329,7 +333,7 @@ class IDLDeserializer {
     toIDLDictionary(file, node) {
         const result = idl.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));
@@ -337,7 +341,7 @@ class IDLDeserializer {
     }
     toIDLNamespace(file, node) {
         const namespace = idl.createNamespace(node.name, [], {
-            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
             fileName: file
         });
         this.namespacePathNames.push(node.name);
@@ -347,7 +351,7 @@ class IDLDeserializer {
     }
     toIDLVersion(file, node) {
         return this.withInfo(node, idl.createVersion(node.value, {
-            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
             fileName: file
         }));
     }
@@ -355,7 +359,7 @@ class IDLDeserializer {
         return this.withInfo(node, idl.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) {
@@ -374,12 +378,18 @@ class IDLDeserializer {
             throw new Error(`Not representable enum initializer: ${JSON.stringify(node.default)}. Found in ${file}`);
         }
         return this.withInfo(node, idl.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) {
@@ -395,7 +405,7 @@ class IDLDeserializer {
         const result = idl.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) => idl.createEnumMember(it.value, result, idl.IDLNumberType, undefined));
         return this.withInfo(node, result);
@@ -517,7 +527,7 @@ class IDLDeserializer {
 }
 export function toIdlType(fileName, content) {
     const lexicalInfo = new Map();
-    const deserializer = new IDLDeserializer(lexicalInfo, 'multiple');
+    const deserializer = new IDLDeserializer(lexicalInfo);
     return deserializer.toIDLType(fileName, webidl2.parseType(content, fileName));
 }
 const DifferenceFound = new DiagnosticMessageGroup("error", "DifferenceFound", "Difference found");
@@ -597,14 +607,42 @@ function compareDeep(oldData, newData, paths) {
     }
     return [];
 }
-function compareParsingResults(oldFile, newFile) {
+export function compareParsingResults(oldFile, newFile) {
     const paths = new Set();
     compareDeep(oldFile, newFile, paths);
     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) {
+export 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 (!quiet && DiagnosticMessageGroup.allGroupsEntries.length != previousDiagnosticsCount) {
+            DiagnosticMessageGroup.allGroupsEntries.slice(previousDiagnosticsCount).map(it => outputDiagnosticMessageFormatted(it));
+        }
+    }
+}
+export function parseIDLFileNew(fileName, content, registerSynthetics) {
     let file = new Parser(fileName, content).parseIDL();
     const ancestors = [];
     const namespaces = [];
@@ -640,18 +678,10 @@ function parseIdlNew(fileName, content, registerSynthetics) {
     });
     return file;
 }
-export 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.readFileSync(fileName).toString();
@@ -700,11 +730,7 @@ export 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 = [];

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

@@ -33,7 +33,7 @@ export declare class Parser {
     _curToken: Token;
     _prevToken: Token;
     _generics: string[][];
-    _enableInLiteralParsing: boolean;
+    _inLiteralParsingLevel: number;
     _match(re: RegExp, kind: TokenKind): Token | undefined;
     _reDecimal: RegExp;
     _reInteger: RegExp;

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

@@ -15,7 +15,7 @@
 import * as fs from "fs";
 import * as idl from "../idl";
 import { DiagnosticException } from "../diagnostictypes";
-import { DiagnosticMessageGroup, LoadingFatal, ParsingFatal, InternalFatal } from "../diagnosticmessages";
+import { DiagnosticMessageGroup, LoadingFatal, InternalFatal } from "../diagnosticmessages";
 const DuplicateModifier = new DiagnosticMessageGroup("error", "DuplicateModifier", "Duplicate modifier", "Duplicate of");
 const NotApplicableModifier = new DiagnosticMessageGroup("error", "NotApplicableModifier", "Not applicable modifier");
 const DuplicatePackageDeclaration = new DiagnosticMessageGroup("error", "DuplicatePackageDeclaration", "Duplicate package declaration", "Duplicate of");
@@ -25,12 +25,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");
 export class FatalParserException extends Error {
     constructor(diagnosticMessages) {
         super();
@@ -66,7 +68,7 @@ export 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;
@@ -157,17 +159,17 @@ export 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) {
@@ -473,28 +475,32 @@ export class Parser {
                 duplicates.add(name.value);
             }
             names.add(name.value);
-            if (name.value == idl.IDLExtendedAttributes.TypeArguments) {
+            if (name.value == idl.IDLExtendedAttributes.TypeArguments || name.value == idl.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;
@@ -676,9 +682,9 @@ export class Parser {
         const name = this.parseSingleIdentifier();
         this.skip("=");
         const value = this.parseLiteral();
-        const extracted = extractLiteral(value);
         this.skip(";");
-        return idl.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 idl.createConstant(name.value, type, value.value, { extendedAttributes: ext, nodeLocation: sloc(), nameLocation: name.location, valueLocation: value.location });
     }
     parseAttribute() {
         trac("parseAttribute");
@@ -768,11 +774,14 @@ export 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 idl.createEnumMember(name.value, undefined, type, extracted.extractedValue, { extendedAttributes: ext, nodeLocation: sloc(), nameLocation: name.location, valueLocation: value.location });
+        return idl.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() {
         trac("parsePackage");

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

@@ -68,11 +68,13 @@ export declare enum IDLExtendedAttributes {
     TypeAnnotations = "TypeAnnotations",
     TypeArguments = "TypeArguments",
     TypeParameters = "TypeParameters",
+    TypeParametersDefaults = "TypeParametersDefaults",
     VerbatimDts = "VerbatimDts",
     HandWrittenImplementation = "HandWrittenImplementation",
     ExtraMethod = "ExtraMethod",
     OverloadAlias = "OverloadAlias",
-    OverloadPriority = "OverloadPriority"
+    OverloadPriority = "OverloadPriority",
+    TransformOnSerialize = "TransformOnSerialize"
 }
 export declare enum IDLAccessorAttribute {
     Getter = "Getter",
@@ -303,6 +305,7 @@ export declare const IDLSerializerBuffer: IDLPrimitiveType;
 export declare const IDLFunctionType: IDLPrimitiveType;
 export declare const IDLCustomObjectType: IDLPrimitiveType;
 export declare const IDLInteropReturnBufferType: IDLPrimitiveType;
+export declare const IDLNullTypeName = "idlize.stdlib.Null";
 export type IDLNodeInitializer = {
     extendedAttributes?: IDLExtendedAttribute[];
     fileName?: string;
@@ -396,6 +399,8 @@ export declare function toIDLString(file: IDLFile, options: Partial<IDLPrintOpti
 export declare function verifyIDLString(source: string): true;
 export declare function hasExtAttribute(node: IDLNode, attribute: IDLExtendedAttributes): boolean;
 export declare function getExtAttribute(node: IDLNode, name: IDLExtendedAttributes): stringOrNone;
+export declare function removeExtAttribute(node: IDLNode, name: IDLExtendedAttributes): void;
+export declare function updateExtAttribute(node: IDLNode, name: IDLExtendedAttributes, value: string | undefined): void;
 export declare function getVerbatimDts(node: IDLEntry): stringOrNone;
 export declare const IDLContainerUtils: {
     isRecord: (x: IDLNode) => boolean;
@@ -406,6 +411,7 @@ export declare const IDLContainerUtils: {
  * @returns tuple of qualifier name and real type name
  */
 export declare function decomposeQualifiedName(type: IDLReferenceType): [string | undefined, string];
+export declare function qualifiedNameStartsWith(node: IDLNode | string[], template: string[]): boolean;
 export declare function maybeUnwrapOptionalType(type: IDLType): IDLType;
 export declare function maybeOptional(type: IDLType, optional?: boolean): IDLType;
 export declare const DebugUtils: {