@idlizer/core 2.1.10-arktscgen-5 → 2.1.10-arktscgen-6

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

@@ -12,24 +12,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import * as webidl2 from "webidl2";
-import * as fs from "fs";
-import { isAttribute, isCallback, isClass, isConstant, isConstructor, isDictionary, isEnum, isInterface, isOperation, isOptional, isPromiseTypeDescription, isRecordTypeDescription, isSequenceTypeDescription, isSingleTypeDescription, isTypedef, isUnionTypeDescription, isUnspecifiedGenericTypeDescription } from "./webidl2-utils";
-import { toString } from "./toString";
 import * as idl from "../idl";
-import { isDefined, warn } from "../util";
-import { collapseTypes, generateSyntheticUnionName } from "../peer-generation/idl/common";
-import { commonRange } from "../diagnostictypes";
-import { DiagnosticMessageGroup, LoadingFatal, ParsingFatal, InternalFatal } from "../diagnosticmessages";
-import { FatalParserException, Parser } from "./parser";
+import { warn } from "../util";
+import { DiagnosticMessageGroup } from "../diagnosticmessages";
+import { 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)) {
@@ -40,495 +27,29 @@ export function addSyntheticType(name, type) {
 export function resolveSyntheticType(type) {
     return syntheticTypes.get(type.name);
 }
-class IDLDeserializer {
-    enterGenericScope(generics) {
-        this.genericsScopes.push(new Set(generics !== null && generics !== void 0 ? generics : []));
-    }
-    constructor(info) {
-        this.info = info;
-        this.namespacePathNames = [];
-        this.currentPackage = [];
-        this.genericsScopes = [];
-    }
-    ///
-    withInfo(from, result) {
-        this.info.set(result, getTokens(from));
-        return result;
-    }
-    setPackage(pkg) {
-        this.currentPackage = pkg;
-    }
-    ///
-    sanitizeTypeParameter(param) {
-        const extendsIdx = param.indexOf('extends');
-        if (extendsIdx !== -1) {
-            return param.substring(0, extendsIdx).trim();
-        }
-        const eqIdx = param.indexOf('=');
-        if (eqIdx !== -1) {
-            return param.substring(0, eqIdx).trim();
-        }
-        return param;
-    }
-    extractGenerics(extAttrs) {
-        var _a, _b;
-        return (_b = (_a = this.findExtendedAttribute(extAttrs, idl.IDLExtendedAttributes.TypeParameters)) === null || _a === void 0 ? void 0 : _a.split(",")) === null || _b === void 0 ? void 0 : _b.map(it => this.sanitizeTypeParameter(it));
-    }
-    ///
-    toIDLNode(file, node) {
-        return this.toIDLNodeForward(file, node);
-    }
-    toIDLNodeForward(file, node) {
-        if (isEnum(node)) {
-            return this.toIDLEnum(file, node);
-        }
-        if (this.isImport(node)) {
-            return this.toIDLImport(node);
-        }
-        if (isClass(node)) {
-            return this.toIDLInterface(file, node);
-        }
-        if (isInterface(node)) {
-            return this.toIDLInterface(file, node);
-        }
-        if (isCallback(node)) {
-            return this.toIDLCallback(file, node);
-        }
-        if (isTypedef(node)) {
-            return this.toIDLTypedef(file, node);
-        }
-        if (isDictionary(node)) {
-            return this.toIDLDictionary(file, node);
-        }
-        if (this.isNamespace(node)) {
-            return this.toIDLNamespace(file, node);
-        }
-        if (this.isVersion(node)) {
-            return this.toIDLVersion(file, node);
-        }
-        if (isAttribute(node)) {
-            return this.toIDLProperty(file, node);
-        }
-        if (isOperation(node)) {
-            return this.toIDLMethod(file, node, true);
-        }
-        if (isConstant(node)) {
-            return this.toIDLConstant(file, node);
-        }
-        throw new Error(`unexpected node type: ${toString(node)}`);
-    }
-    toIDLImport(node) {
-        return this.withInfo(node, idl.createImport(node.clause.split("."), node.alias || undefined));
-    }
-    interfaceSubkind(node) {
-        var _a, _b;
-        const nodeIDLEntity = (_b = (_a = node.extAttrs.find(it => it.name === "Entity")) === null || _a === void 0 ? void 0 : _a.rhs) === null || _b === void 0 ? void 0 : _b.value;
-        switch (nodeIDLEntity) {
-            case idl.IDLEntity.Class: return idl.IDLInterfaceSubkind.Class;
-            case idl.IDLEntity.Literal: return idl.IDLInterfaceSubkind.AnonymousInterface;
-            case idl.IDLEntity.Tuple: return idl.IDLInterfaceSubkind.Tuple;
-            default: return idl.IDLInterfaceSubkind.Interface;
-        }
-    }
-    toIDLInterface(file, node) {
-        const generics = this.extractGenerics(node.extAttrs);
-        this.enterGenericScope(generics);
-        const subkind = this.interfaceSubkind(node);
-        const result = idl.createInterface(node.name, subkind, (() => {
-            if (!node.inheritance) {
-                return [];
-            }
-            const implementations = [];
-            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(file, attributes !== null && attributes !== void 0 ? attributes : []); // ?.filter(it => it.name !== idl.IDLExtendedAttributes.TypeArguments)
-                const ref = idl.createReferenceType(it.inheritance, parentTypeArgs, {
-                    extendedAttributes: attrs
-                });
-                implementations.push(ref);
-            });
-            return implementations;
-        })(), node.members
-            .filter(isConstructor)
-            .map(it => this.toIDLConstructor(file, it)), [], node.members
-            .filter(isAttribute)
-            .map(it => this.toIDLProperty(file, it)), node.members
-            .filter(isOperation)
-            .filter(it => !this.isCallable(it))
-            .map(it => this.toIDLMethod(file, it, false)), node.members
-            .filter(isOperation)
-            .filter(it => this.isCallable(it))
-            .map(it => this.toIDLCallable(file, it)), generics, {
-            fileName: file,
-            documentation: this.makeDocs(node),
-            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
-        });
-        this.genericsScopes.pop();
-        this.info.set(result, getTokens(node));
-        if (node.extAttrs.find(it => it.name === "Synthetic")) {
-            const fqName = this.currentPackage.concat(this.namespacePathNames).concat([node.name]).join('.');
-            addSyntheticType(fqName, result);
-        }
-        return result;
-    }
-    toIDLType(file, type, extAttrs, suggestedName) {
-        var _a;
-        if (typeof type === "string") {
-            // 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;
-        }
-        if (type.nullable) {
-            return this.withInfo(type, idl.createOptionalType(this.toIDLType(file, Object.assign(Object.assign({}, type), { nullable: false }), extAttrs)));
-        }
-        if (isUnionTypeDescription(type)) {
-            let types = type.idlType
-                .map(it => this.toIDLType(file, it, undefined))
-                .filter(isDefined);
-            if (types.includes(idl.IDLUndefinedType)) {
-                types = types.filter(it => it !== idl.IDLUndefinedType);
-                return this.withInfo(type, idl.createOptionalType(collapseTypes(types)));
-            }
-            const name = suggestedName !== null && suggestedName !== void 0 ? suggestedName : generateSyntheticUnionName(types);
-            return this.withInfo(type, idl.createUnionType(types, name));
-        }
-        if (isSingleTypeDescription(type)) {
-            // must match with primitive types in idl.ts
-            switch (type.idlType) {
-                case idl.IDLPointerType.name: return idl.IDLPointerType;
-                case idl.IDLVoidType.name: return idl.IDLVoidType;
-                case idl.IDLBooleanType.name: return idl.IDLBooleanType;
-                case idl.IDLObjectType.name: return idl.IDLObjectType;
-                case idl.IDLI8Type.name: return idl.IDLI8Type;
-                case idl.IDLU8Type.name: return idl.IDLU8Type;
-                case idl.IDLI16Type.name: return idl.IDLI16Type;
-                case idl.IDLU16Type.name: return idl.IDLU16Type;
-                case idl.IDLI32Type.name: return idl.IDLI32Type;
-                case idl.IDLU32Type.name: return idl.IDLU32Type;
-                case idl.IDLI64Type.name: return idl.IDLI64Type;
-                case idl.IDLU64Type.name: return idl.IDLU64Type;
-                case idl.IDLF32Type.name: return idl.IDLF32Type;
-                case idl.IDLF64Type.name: return idl.IDLF64Type;
-                case idl.IDLBigintType.name: return idl.IDLBigintType;
-                case idl.IDLNumberType.name: return idl.IDLNumberType;
-                case idl.IDLStringType.name: return idl.IDLStringType;
-                case idl.IDLAnyType.name: return idl.IDLAnyType;
-                case idl.IDLUndefinedType.name: return idl.IDLUndefinedType;
-                case idl.IDLUnknownType.name: return idl.IDLUnknownType;
-                case idl.IDLObjectType.name: return idl.IDLObjectType;
-                case idl.IDLThisType.name: return idl.IDLThisType;
-                case idl.IDLDate.name: return idl.IDLDate;
-                case idl.IDLBufferType.name: return idl.IDLBufferType;
-                case idl.IDLSerializerBuffer.name: return idl.IDLSerializerBuffer;
-            }
-            const combinedExtAttrs = ((_a = type.extAttrs) !== null && _a !== void 0 ? _a : []).concat(extAttrs !== null && extAttrs !== void 0 ? extAttrs : []);
-            let idlRefType;
-            if (this.genericsScopes.some(it => it.has(type.idlType))) {
-                idlRefType = idl.createTypeParameterReference(type.idlType);
-            }
-            else {
-                const ref = idl.createReferenceType(type.idlType);
-                ref.typeArguments = this.extractTypeArguments(file, combinedExtAttrs, idl.IDLExtendedAttributes.TypeArguments);
-                idlRefType = ref;
-            }
-            idlRefType.fileName = file;
-            idlRefType.extendedAttributes = this.toExtendedAttributes(file, combinedExtAttrs);
-            return this.withInfo(type, idlRefType);
-        }
-        if (isSequenceTypeDescription(type) || isPromiseTypeDescription(type) || isRecordTypeDescription(type)) {
-            return this.withInfo(type, idl.createContainerType(type.generic, type.idlType.map(it => this.toIDLType(file, it, undefined))));
-        }
-        if (isUnspecifiedGenericTypeDescription(type)) {
-            return this.withInfo(type, idl.createUnspecifiedGenericType(type.generic, type.idlType.map(it => this.toIDLType(file, it, undefined))));
-        }
-        throw new Error(`unexpected type: ${toString(type)}`);
-    }
-    toIDLCallable(file, node) {
-        var _a;
-        if (!node.idlType) {
-            throw new Error(`method with no type ${toString(node)}`);
-        }
-        const generics = this.extractGenerics(node.extAttrs);
-        this.enterGenericScope(generics);
-        const returnType = this.toIDLType(file, node.idlType, node.extAttrs);
-        if (idl.isReferenceType(returnType)) {
-            const returnTypeArgs = this.extractTypeArguments(file, node.extAttrs, idl.IDLExtendedAttributes.TypeArguments);
-            returnType.typeArguments = returnTypeArgs;
-        }
-        const result = this.withInfo(node, idl.createCallable((_a = node.name) !== null && _a !== void 0 ? _a : "", node.arguments.map(it => this.toIDLParameter(file, it)), returnType, {
-            isStatic: node.special === "static",
-            isAsync: node.async,
-        }, {
-            documentation: this.makeDocs(node),
-            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
-        }, generics));
-        this.genericsScopes.pop();
-        return result;
-    }
-    toIDLMethod(file, node, isFree = false) {
-        var _a;
-        if (!node.idlType) {
-            throw new Error(`method with no type ${toString(node)}`);
-        }
-        const generics = this.extractGenerics(node.extAttrs);
-        this.enterGenericScope(generics);
-        const returnType = this.toIDLType(file, node.idlType, node.extAttrs);
-        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,
-            isOptional: isOptional(node),
-            isFree
-        }, {
-            documentation: this.makeDocs(node),
-            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
-        }, generics));
-        this.genericsScopes.pop();
-        return result;
-    }
-    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(file, node.extAttrs),
-        }));
-    }
-    toIDLParameter(file, node) {
-        return this.withInfo(node, idl.createParameter(node.name, this.toIDLType(file, node.idlType, node.extAttrs), node.optional, node.variadic, {
-            fileName: file,
-        }));
-    }
-    toIDLCallback(file, node) {
-        const generics = this.extractGenerics(node.extAttrs);
-        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(file, node.extAttrs),
-            documentation: this.makeDocs(node),
-        }, generics);
-        if (node.extAttrs.find(it => it.name === "Synthetic")) {
-            const fqName = this.currentPackage.concat(this.namespacePathNames).concat([node.name]).join('.');
-            addSyntheticType(fqName, result);
-        }
-        this.genericsScopes.pop();
-        return this.withInfo(node, result);
-    }
-    toIDLTypedef(file, node) {
-        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(file, node.extAttrs),
-            documentation: this.makeDocs(node),
-            fileName: file,
-        }));
-        this.genericsScopes.pop();
-        return result;
-    }
-    toIDLConstant(file, node) {
-        return this.withInfo(node, idl.createConstant(node.name, this.toIDLType(file, node.idlType, undefined), this.constantValue(node)));
-    }
-    toIDLDictionary(file, node) {
-        const result = idl.createEnum(node.name, [], {
-            documentation: this.makeDocs(node),
-            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
-            fileName: file,
-        });
-        result.elements = node.members.map(it => this.toIDLEnumMember(file, it, result));
-        return this.withInfo(node, result);
-    }
-    toIDLNamespace(file, node) {
-        const namespace = idl.createNamespace(node.name, [], {
-            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
-            fileName: file
-        });
-        this.namespacePathNames.push(node.name);
-        namespace.members = node.members.map(it => this.toIDLNodeForward(file, it));
-        this.namespacePathNames.pop();
-        return this.withInfo(node, namespace);
-    }
-    toIDLVersion(file, node) {
-        return this.withInfo(node, idl.createVersion(node.value, {
-            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
-            fileName: file
-        }));
-    }
-    toIDLProperty(file, node) {
-        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(file, node.extAttrs)
-        }));
-    }
-    toIDLEnumMember(file, node, parent) {
-        var _a, _b, _c;
-        let initializer = undefined;
-        if (((_a = node.default) === null || _a === void 0 ? void 0 : _a.type) == "string") {
-            initializer = this.unescapeString(node.default.value);
-        }
-        else if (((_b = node.default) === null || _b === void 0 ? void 0 : _b.type) == "number") {
-            initializer = +((_c = node.default) === null || _c === void 0 ? void 0 : _c.value);
-        }
-        else if (node.default == null) {
-            initializer = undefined;
-        }
-        else {
-            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(file, node.extAttrs),
-        }));
-    }
-    toExtendedAttributes(file, extAttrs) {
-        return extAttrs.map(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) {
-        var _a, _b;
-        // TODO: be smarter about RHS.
-        if (((_a = attr.rhs) === null || _a === void 0 ? void 0 : _a.value) instanceof Array)
-            return attr.rhs.value.map(v => v.value).join(",");
-        if (typeof ((_b = attr.rhs) === null || _b === void 0 ? void 0 : _b.value) === 'string')
-            return this.unescapeString(attr.rhs.value);
-        return;
-    }
-    toIDLEnum(file, node) {
-        const result = idl.createEnum(node.name, [], {
-            fileName: file,
-            documentation: this.makeDocs(node),
-            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);
-    }
-    ///
-    isNamespace(node) {
-        return node.type === 'namespace';
-    }
-    isVersion(node) {
-        return node.type === 'version';
-    }
-    isPackage(node) {
-        return node.type === 'package';
-    }
-    isImport(node) {
-        return node.type === 'import';
-    }
-    isCallable(node) {
-        return node.extAttrs.some(it => it.name == idl.IDLExtendedAttributes.CallSignature);
+export function toIdlType(fileName, content) {
+    const previousDiagnosticsCount = DiagnosticMessageGroup.allGroupsEntries.length;
+    try {
+        const idlType = new Parser(fileName, content).parseIDLType();
+        idlType.fileName = fileName;
+        return idlType;
     }
-    ///
-    splitTypeArguments(line) {
-        let buffer = "";
-        let brackets = 0;
-        const result = [];
-        for (const letter of line) {
-            if (letter === ',' && brackets === 0) {
-                result.push(buffer);
-                buffer = '';
-                continue;
-            }
-            if (letter === '<') {
-                brackets += 1;
-            }
-            if (letter === '>') {
-                brackets -= 1;
-            }
-            buffer += letter;
-        }
-        if (buffer.length) {
-            result.push(buffer);
+    finally {
+        if (DiagnosticMessageGroup.allGroupsEntries.length != previousDiagnosticsCount) {
+            DiagnosticMessageGroup.allGroupsEntries.slice(previousDiagnosticsCount).map(it => outputDiagnosticMessageFormatted(it));
         }
-        return result;
     }
-    extractTypeArguments(file, extAttrs, attribute) {
-        var _a;
-        const attr = extAttrs === null || extAttrs === void 0 ? void 0 : extAttrs.find(it => it.name === attribute);
-        if (!attr)
-            return undefined;
-        let value = this.toExtendedAttributeValue(attr);
-        return (_a = this.splitTypeArguments(value)) === null || _a === void 0 ? void 0 : _a.map(it => { var _a; return this.toIDLType(file, (_a = webidl2.parseType(it.replaceAll('\'', '"'), file)) !== null && _a !== void 0 ? _a : it); });
+}
+export function toIdlTypeList(fileName, content) {
+    const previousDiagnosticsCount = DiagnosticMessageGroup.allGroupsEntries.length;
+    try {
+        return new Parser(fileName, content).parseIDLTypeList();
     }
-    constantValue(node) {
-        switch (node.value.type) {
-            case "string":
-                return `"${node.value.value}"`;
-            case "number":
-                return node.value.value;
-            case "boolean":
-                return node.value.value.toString();
-            case "null":
-                return "null";
-            case "Infinity":
-                return "Infinity";
-            case "NaN":
-                return "NaN";
-            case "sequence":
-                return `[${node.value.value.join(',')}]`;
-            case "dictionary":
-                return `new Map()`;
-            default:
-                return "undefined";
+    finally {
+        if (DiagnosticMessageGroup.allGroupsEntries.length != previousDiagnosticsCount) {
+            DiagnosticMessageGroup.allGroupsEntries.slice(previousDiagnosticsCount).map(it => outputDiagnosticMessageFormatted(it));
         }
     }
-    unescapeString(value) {
-        if (!value.length || value[0] !== '"')
-            return value;
-        value = value.slice(1, -1);
-        value = value.replace(/\\((['"\\bfnrtv])|([0-7]{1-3})|x([0-9a-fA-F]{2})|u([0-9a-fA-F]{4}))/g, (_, all, c, oct, h2, u4) => {
-            if (c !== undefined) {
-                switch (c) {
-                    case "'": return "'";
-                    case '"': return '"';
-                    case "\\": return "\\";
-                    case "b": return "\b";
-                    case "f": return "\f";
-                    case "n": return "\n";
-                    case "r": return "\r";
-                    case "t": return "\t";
-                    case "v": return "\v";
-                }
-            }
-            else if (oct !== undefined) {
-                return String.fromCharCode(parseInt(oct, 8));
-            }
-            else if (h2 !== undefined) {
-                return String.fromCharCode(parseInt(h2, 16));
-            }
-            else if (u4 !== undefined) {
-                return String.fromCharCode(parseInt(u4, 16));
-            }
-            throw new Error(`unknown escape sequence: ${_}`);
-        });
-        return value;
-    }
-    makeDocs(node) {
-        let docs = undefined;
-        node.extAttrs.forEach(it => {
-            var _a;
-            if (it.name == "Documentation")
-                docs = (_a = it.rhs) === null || _a === void 0 ? void 0 : _a.value;
-        });
-        return docs;
-    }
-    findExtendedAttribute(extAttrs, name) {
-        const attr = extAttrs.find(it => it.name === name);
-        return attr ? this.toExtendedAttributeValue(attr) : undefined;
-    }
-}
-export function toIdlType(fileName, content) {
-    const lexicalInfo = new Map();
-    const deserializer = new IDLDeserializer(lexicalInfo);
-    return deserializer.toIDLType(fileName, webidl2.parseType(content, fileName));
 }
 const DifferenceFound = new DiagnosticMessageGroup("error", "DifferenceFound", "Difference found");
 const noCompare = new Set(["parent", "fileName", "nodeLocation", "nameLocation", "valueLocation", "typesValue", "text"]);
@@ -607,6 +128,11 @@ function compareDeep(oldData, newData, paths) {
     }
     return [];
 }
+export function compareNodes(a, b) {
+    const paths = new Set();
+    compareDeep(a, b, paths);
+    return paths.size === 0;
+}
 export function compareParsingResults(oldFile, newFile) {
     const paths = new Set();
     compareDeep(oldFile, newFile, paths);
@@ -618,32 +144,16 @@ export function compareParsingResults(oldFile, newFile) {
 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;
+        return parseIDLFileNew(fileName, content);
     }
     finally {
         if (!quiet && DiagnosticMessageGroup.allGroupsEntries.length != previousDiagnosticsCount) {
-            DiagnosticMessageGroup.allGroupsEntries.slice(previousDiagnosticsCount).map(it => outputDiagnosticMessageFormatted(it));
+            DiagnosticMessageGroup.allGroupsEntries.slice(previousDiagnosticsCount).forEach(it => outputDiagnosticMessageFormatted(it));
         }
     }
 }
-export function parseIDLFileNew(fileName, content, registerSynthetics) {
-    let file = new Parser(fileName, content).parseIDL();
+export function parseIDLFileNew(fileName, content) {
+    let file = new Parser(fileName, content).parseIDLFile();
     const ancestors = [];
     const namespaces = [];
     // Mimic old parser and deserialize.ts behavior:
@@ -651,15 +161,10 @@ export function parseIDLFileNew(fileName, content, registerSynthetics) {
     // 2. Add `parent`.
     // 3. Possibly register node with `addSyntheticType` if "Synthetic" is in attributes
     idl.forEachChild(file, (node) => {
-        var _a;
         if (idl.isPrimitiveType(node)) {
             return;
         }
         node.fileName = fileName;
-        if (registerSynthetics && idl.isEntry(node) && ((_a = node.extendedAttributes) === null || _a === void 0 ? void 0 : _a.some(it => it.name === "Synthetic"))) {
-            const fqName = file.packageClause.concat(namespaces).concat([node.name]).join('.');
-            addSyntheticType(fqName, node);
-        }
         if (ancestors.length) {
             node.parent = ancestors[ancestors.length - 1];
         }
@@ -678,121 +183,4 @@ export function parseIDLFileNew(fileName, content, registerSynthetics) {
     });
     return file;
 }
-function parseIDLFileOld(fileName, content) {
-    var _a, _b, _c;
-    const lexicalInfo = new Map();
-    const deserializer = new IDLDeserializer(lexicalInfo);
-    if (undefined === content) {
-        try {
-            content = fs.readFileSync(fileName).toString();
-        }
-        catch (e) {
-            content = "";
-            throw new FatalParserException([LoadingFatal.reportDiagnosticMessage([{ documentPath: fileName }], (_a = e.message) !== null && _a !== void 0 ? _a : "")]);
-        }
-    }
-    let lines = (_b = content.match(/[^\r\n]*(\n|\r\n)?/g)) !== null && _b !== void 0 ? _b : [];
-    const offsets = prepareOffsets(lines);
-    lines = lines.map((s) => s.replace(/(\n|\r\n)$/, ""));
-    const parsed = { fileName, lines, offsets, lexicalInfo };
-    let packageClause = [];
-    let rawParsingResults;
-    try {
-        rawParsingResults = webidl2.parse(content);
-    }
-    catch (e) {
-        if (e.name == "WebIDLParseError") {
-            let tokens = e.tokens;
-            let range = tokens.length > 0 ? rangeForToken(offsets, tokens[0]) : undefined;
-            throw new FatalParserException([ParsingFatal.reportDiagnosticMessage([{ documentPath: fileName, range, lines }], e.bareMessage)]);
-        }
-        throw new FatalParserException([InternalFatal.reportDiagnosticMessage([{ documentPath: fileName, lines }], (_c = e.message) !== null && _c !== void 0 ? _c : "")]);
-    }
-    const entries = rawParsingResults
-        .filter(it => {
-        if (!it.type)
-            return false;
-        if (deserializer.isPackage(it)) {
-            packageClause = it.clause.split(".");
-            deserializer.setPackage(packageClause);
-            return false;
-        }
-        return true;
-    })
-        .map(it => deserializer.toIDLNode(fileName, it));
-    let file = idl.createFile(entries, fileName, packageClause);
-    file.text = content;
-    file = idl.linkParentBack(file);
-    idl.forEachChild(file, (node) => {
-        node.nodeLocation = locationForNode(parsed, node);
-        const nameLocation = locationForNode(parsed, node, "name");
-        if (nameLocation.range) {
-            node.nameLocation = nameLocation;
-        }
-    });
-    return file;
-}
-function prepareOffsets(lines) {
-    let offsets = [];
-    let offset = 0;
-    for (let line of lines) {
-        let plus = line.length;
-        offsets.push(offset);
-        offset += plus;
-    }
-    return offsets;
-}
-function locationForNode(parsed, node, component) {
-    if (node.kind == idl.IDLKind.File) {
-        return { documentPath: parsed.fileName, lines: parsed.lines };
-    }
-    return { documentPath: parsed.fileName, range: rangeForNode(parsed, node, component), lines: parsed.lines };
-}
-function rangeForNode(parsed, node, component) {
-    var _a;
-    let info = parsed.lexicalInfo.get(node);
-    if (info == null) {
-        // Proper solution will require fixes with inheritance tokens in Idlize/core and custom webidl2.js
-        // So now we are extracting from what we have
-        if (node.parent) {
-            return (_a = rangeForNode(parsed, node.parent, "inheritance")) !== null && _a !== void 0 ? _a : rangeForNode(parsed, node.parent);
-        }
-        return;
-    }
-    let range;
-    for (let k of Object.keys(info)) {
-        if (component && k != component) {
-            continue;
-        }
-        let named = info[k];
-        if (named == null) {
-            continue;
-        }
-        if (named.value == null) {
-            if (k == "inheritance" && Array.isArray(named)) {
-                for (let inh of named) {
-                    if (inh.inheritance == null) {
-                        continue;
-                    }
-                    let newRange = rangeForToken(parsed.offsets, inh.inheritance);
-                    range = range ? commonRange(range, newRange) : newRange;
-                }
-            }
-            continue;
-        }
-        let newRange = rangeForToken(parsed.offsets, named);
-        range = range ? commonRange(range, newRange) : newRange;
-    }
-    return range;
-}
-function rangeForToken(offsets, token) {
-    let dif = token.value.length - 1;
-    if (dif < 0) {
-        dif = 0;
-    }
-    let endline = token.line + (token.value.match(/\n/g) || []).length;
-    let character = token.position - offsets[token.line - 1] + 1;
-    let endcharacter = token.position + dif - offsets[endline - 1] + 1;
-    return { start: { line: token.line, character: character }, end: { line: endline, character: endcharacter } };
-}
 //# sourceMappingURL=deserialize.js.map