@idlizer/core 2.1.2 → 2.1.7

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

@@ -18,385 +18,517 @@ import { isAttribute, isCallback, isClass, isConstant, isConstructor, isDictiona
 import { toString } from "./toString";
 import * as idl from "../idl";
 import { isDefined, warn } from "../util";
-import { generateSyntheticUnionName } from "../peer-generation/idl/common";
+import { collapseTypes, generateSyntheticUnionName } from "../peer-generation/idl/common";
+function getTokens(node) {
+    return node.tokens;
+}
 const syntheticTypes = new Map();
 export function addSyntheticType(name, type) {
-    if (syntheticTypes.has(name))
-        warn(`duplicate synthetic type name "${name}"`); ///throw?
+    if (syntheticTypes.has(name)) {
+        warn(`duplicate synthetic type name "${name}"`);
+    }
     syntheticTypes.set(name, type);
 } // check
 export function resolveSyntheticType(type) {
     return syntheticTypes.get(type.name);
 }
-function toIDLNode(file, node) {
-    return toIDLNodeForward(file, node);
-}
-function toIDLNodeForward(file, node) {
-    if (isEnum(node)) {
-        return toIDLEnum(file, node);
+class IDLDeserializer {
+    enterGenericScope(generics) {
+        this.genericsScopes.push(new Set(generics !== null && generics !== void 0 ? generics : []));
     }
-    if (isImport(node)) {
-        return toIDLImport(node);
+    constructor(info, inheritanceMode = 'multiple') {
+        this.info = info;
+        this.inheritanceMode = inheritanceMode;
+        this.namespacePathNames = [];
+        this.currentPackage = [];
+        this.genericsScopes = [];
     }
-    if (isClass(node)) {
-        return toIDLInterface(file, node);
+    ///
+    withInfo(from, result) {
+        this.info.set(result, getTokens(from));
+        return result;
     }
-    if (isInterface(node)) {
-        return toIDLInterface(file, node);
+    setPackage(pkg) {
+        this.currentPackage = pkg;
     }
-    if (isCallback(node)) {
-        return toIDLCallback(file, node);
+    ///
+    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;
     }
-    if (isTypedef(node)) {
-        return toIDLTypedef(file, node);
+    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));
     }
-    if (isDictionary(node)) {
-        return toIDLDictionary(file, node);
+    ///
+    toIDLNode(file, node) {
+        return this.toIDLNodeForward(file, node);
     }
-    if (isNamespace(node)) {
-        return toIDLNamespace(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)}`);
     }
-    if (isVersion(node)) {
-        return toIDLVersion(file, node);
+    toIDLImport(node) {
+        return this.withInfo(node, idl.createImport(node.clause.split("."), node.alias || undefined));
     }
-    if (isAttribute(node)) {
-        return toIDLProperty(file, node);
+    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;
+        if (nodeIDLEntity == idl.IDLEntity.Class)
+            return idl.IDLInterfaceSubkind.Class;
+        if (nodeIDLEntity == idl.IDLEntity.Interface)
+            return idl.IDLInterfaceSubkind.Interface;
+        if (nodeIDLEntity == idl.IDLEntity.Tuple)
+            return idl.IDLInterfaceSubkind.Tuple;
+        return idl.IDLInterfaceSubkind.Interface;
     }
-    if (isOperation(node)) {
-        return toIDLMethod(file, node);
+    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 = [];
+            let extension = undefined;
+            node.inheritance.forEach(it => {
+                var _a;
+                const attributes = it.extAttrs;
+                const parentTypeArgs = this.extractTypeArguments(file, attributes !== null && attributes !== void 0 ? attributes : [], idl.IDLExtendedAttributes.TypeArguments);
+                const attrs = (_a = this.toExtendedAttributes(attributes !== null && attributes !== void 0 ? attributes : [])) === null || _a === void 0 ? void 0 : _a.filter(it => it.name !== idl.IDLExtendedAttributes.TypeArguments);
+                const baseClass = attrs === null || attrs === void 0 ? void 0 : attrs.find(it => it.name === idl.IDLExtendedAttributes.Extends);
+                const ref = idl.createReferenceType(it.inheritance, parentTypeArgs, {
+                    extendedAttributes: attrs
+                });
+                if (baseClass) {
+                    extension = ref;
+                }
+                else {
+                    implementations.push(ref);
+                }
+            });
+            if (subkind === idl.IDLInterfaceSubkind.Class && extension === undefined && this.inheritanceMode === 'multiple') {
+                extension = idl.IDLTopType;
+            }
+            if (extension) {
+                return [extension, ...implementations];
+            }
+            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(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;
     }
-    if (isConstant(node)) {
-        return toIDLConstant(file, node);
+    toIDLType(file, type, extAttrs, suggestedName) {
+        var _a;
+        if (typeof type === "string") {
+            // is it IDLStringType?
+            const refType = idl.createReferenceType(type);
+            refType.fileName = file;
+            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(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)}`);
     }
-    throw new Error(`unexpected node type: ${toString(node)}`);
-}
-function isNamespace(node) {
-    return node.type === 'namespace';
-}
-function isVersion(node) {
-    return node.type === 'version';
-}
-function isPackage(node) {
-    return node.type === 'package';
-}
-function isImport(node) {
-    return node.type === 'import';
-}
-function isCallable(node) {
-    return node.extAttrs.some(it => it.name == "Invoke");
-}
-function toIDLImport(node) {
-    // console.log(node)
-    return idl.createImport(node.clause.split("."), node.alias || undefined);
-}
-function 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;
-    if (nodeIDLEntity == idl.IDLEntity.Class)
-        return idl.IDLInterfaceSubkind.Class;
-    if (nodeIDLEntity == idl.IDLEntity.Interface)
-        return idl.IDLInterfaceSubkind.Interface;
-    if (nodeIDLEntity == idl.IDLEntity.Tuple)
-        return idl.IDLInterfaceSubkind.Tuple;
-    return idl.IDLInterfaceSubkind.Interface;
-}
-function toIDLInterface(file, node) {
-    var _a;
-    const result = idl.createInterface(node.name, interfaceSubkind(node), (() => {
-        var _a, _b;
-        if (!node.inheritance)
-            return [];
-        const parentTypeArgs = extractTypeArguments(file, (_a = node.inheritanceExtAttrs) !== null && _a !== void 0 ? _a : [], idl.IDLExtendedAttributes.TypeArguments);
-        const parentType = idl.createReferenceType(node.inheritance, parentTypeArgs);
-        parentType.fileName = file;
-        if (node.inheritanceExtAttrs)
-            parentType.extendedAttributes = (_b = toExtendedAttributes(node.inheritanceExtAttrs)) === null || _b === void 0 ? void 0 : _b.filter(it => it.name !== idl.IDLExtendedAttributes.TypeArguments);
-        return [parentType];
-    })(), node.members
-        .filter(isConstructor)
-        .map(it => toIDLConstructor(file, it)), [], node.members
-        .filter(isAttribute)
-        .map(it => toIDLProperty(file, it)), node.members
-        .filter(isOperation)
-        .filter(it => !isCallable(it))
-        .map(it => toIDLMethod(file, it)), node.members
-        .filter(isOperation)
-        .filter(it => isCallable(it))
-        .map(it => toIDLCallable(file, it)), (_a = findExtendedAttribute(node.extAttrs, idl.IDLExtendedAttributes.TypeParameters)) === null || _a === void 0 ? void 0 : _a.split(","), {
-        fileName: file,
-        documentation: makeDocs(node),
-        extendedAttributes: toExtendedAttributes(node.extAttrs),
-    });
-    if (node.extAttrs.find(it => it.name === "Synthetic"))
-        addSyntheticType(node.name, result);
-    return result;
-}
-function 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 = toExtendedAttributeValue(attr);
-    return (_a = value === null || value === void 0 ? void 0 : value.split(",") // TODO need real parsing here. What about "<T, Map<K, Callback<K,R>>, U>"
-    ) === null || _a === void 0 ? void 0 : _a.map(it => toIDLType(file, it));
-}
-function toIDLType(file, type, extAttrs) {
-    var _a;
-    if (typeof type === "string") {
-        // is it IDLStringType?
-        const refType = idl.createReferenceType(type);
-        refType.fileName = file;
-        refType.typeArguments = extractTypeArguments(file, extAttrs, idl.IDLExtendedAttributes.TypeArguments);
-        return refType;
-    }
-    if (type.nullable) {
-        return idl.createOptionalType(toIDLType(file, Object.assign(Object.assign({}, type), { nullable: false }), extAttrs));
-    }
-    if (isUnionTypeDescription(type)) {
-        const types = type.idlType
-            .map(it => toIDLType(file, it))
-            .filter(isDefined);
-        const name = generateSyntheticUnionName(types);
-        return idl.createUnionType(types, name);
-    }
-    if (isSingleTypeDescription(type)) {
-        switch (type.idlType) {
-            case idl.IDLUnknownType.name: return idl.IDLUnknownType;
-            case idl.IDLObjectType.name: return idl.IDLObjectType;
-            case idl.IDLAnyType.name: return idl.IDLAnyType;
-            case idl.IDLBooleanType.name: return idl.IDLBooleanType;
-            case idl.IDLNumberType.name: return idl.IDLNumberType;
-            case idl.IDLStringType.name: return idl.IDLStringType;
-            case idl.IDLUndefinedType.name: return idl.IDLUndefinedType;
-            case idl.IDLVoidType.name: return idl.IDLVoidType;
-            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.IDLPointerType.name: return idl.IDLPointerType;
-            case idl.IDLBufferType.name: return idl.IDLBufferType;
-        }
-        const combinedExtAttrs = ((_a = type.extAttrs) !== null && _a !== void 0 ? _a : []).concat(extAttrs !== null && extAttrs !== void 0 ? extAttrs : []);
-        const idlRefType = idl.createReferenceType(type.idlType);
-        idlRefType.fileName = file;
-        idlRefType.typeArguments = extractTypeArguments(file, combinedExtAttrs, idl.IDLExtendedAttributes.TypeArguments);
-        idlRefType.extendedAttributes = toExtendedAttributes(combinedExtAttrs);
-        return idlRefType;
-    }
-    if (isSequenceTypeDescription(type) || isPromiseTypeDescription(type) || isRecordTypeDescription(type)) {
-        return idl.createContainerType(type.generic, type.idlType.map(it => toIDLType(file, it)));
-    }
-    if (isUnspecifiedGenericTypeDescription(type)) {
-        return idl.createUnspecifiedGenericType(type.generic, type.idlType.map(it => toIDLType(file, it)));
-    }
-    throw new Error(`unexpected type: ${toString(type)}`);
-}
-function toIDLCallable(file, node) {
-    var _a, _b;
-    if (!node.idlType) {
-        throw new Error(`method with no type ${toString(node)}`);
-    }
-    const returnType = toIDLType(file, node.idlType, node.extAttrs);
-    if (idl.isReferenceType(returnType)) {
-        const returnTypeArgs = extractTypeArguments(file, node.extAttrs, idl.IDLExtendedAttributes.TypeArguments);
-        returnType.typeArguments = returnTypeArgs;
-    }
-    return idl.createCallable((_a = node.name) !== null && _a !== void 0 ? _a : "", node.arguments.map(it => toIDLParameter(file, it)), returnType, {
-        isStatic: node.special === "static",
-        isAsync: node.async,
-    }, {
-        documentation: makeDocs(node),
-        extendedAttributes: toExtendedAttributes(node.extAttrs),
-    }, (_b = findExtendedAttribute(node.extAttrs, idl.IDLExtendedAttributes.TypeParameters)) === null || _b === void 0 ? void 0 : _b.split(","));
-}
-function toIDLMethod(file, node) {
-    var _a, _b;
-    if (!node.idlType) {
-        throw new Error(`method with no type ${toString(node)}`);
-    }
-    const returnType = toIDLType(file, node.idlType, node.extAttrs);
-    if (idl.isReferenceType(returnType))
-        returnType.typeArguments = extractTypeArguments(file, node.extAttrs, idl.IDLExtendedAttributes.TypeArguments);
-    return idl.createMethod((_a = node.name) !== null && _a !== void 0 ? _a : "", node.arguments.map(it => toIDLParameter(file, it)), returnType, {
-        isStatic: node.special === "static",
-        isAsync: node.async,
-        isOptional: isOptional(node),
-        isFree: false, // TODO: namespace-related-to-rework
-    }, {
-        documentation: makeDocs(node),
-        extendedAttributes: toExtendedAttributes(node.extAttrs),
-    }, (_b = findExtendedAttribute(node.extAttrs, idl.IDLExtendedAttributes.TypeParameters)) === null || _b === void 0 ? void 0 : _b.split(","));
-}
-function toIDLConstructor(file, node) {
-    return idl.createConstructor(node.arguments.map(it => toIDLParameter(file, it)), undefined, {
-        documentation: makeDocs(node),
-    });
-}
-function toIDLParameter(file, node) {
-    return idl.createParameter(node.name, toIDLType(file, node.idlType, node.extAttrs), node.optional, node.variadic, {
-        fileName: file,
-    });
-}
-function toIDLCallback(file, node) {
-    const result = idl.createCallback(node.name, node.arguments.map(it => toIDLParameter(file, it)), toIDLType(file, node.idlType), {
-        fileName: file,
-        extendedAttributes: toExtendedAttributes(node.extAttrs),
-        documentation: makeDocs(node),
-    });
-    if (node.extAttrs.find(it => it.name === "Synthetic"))
-        addSyntheticType(node.name, result);
-    return result;
-}
-function toIDLTypedef(file, node) {
-    var _a;
-    return idl.createTypedef(node.name, toIDLType(file, node.idlType), (_a = findExtendedAttribute(node.extAttrs, idl.IDLExtendedAttributes.TypeParameters)) === null || _a === void 0 ? void 0 : _a.split(","), {
-        extendedAttributes: toExtendedAttributes(node.extAttrs),
-        documentation: makeDocs(node),
-        fileName: file,
-    });
-}
-function toIDLConstant(file, node) {
-    return idl.createConstant(node.name, toIDLType(file, node.idlType), constantValue(node));
-}
-function 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";
+    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(node.extAttrs),
+        }, generics));
+        this.genericsScopes.pop();
+        return result;
     }
-}
-function toIDLDictionary(file, node) {
-    const result = idl.createEnum(node.name, [], {
-        documentation: makeDocs(node),
-        extendedAttributes: toExtendedAttributes(node.extAttrs),
-        fileName: file,
-    });
-    result.elements = node.members.map(it => toIDLEnumMember(file, it, result));
-    return result;
-}
-function toIDLNamespace(file, node) {
-    const namespace = idl.createNamespace(node.name, toExtendedAttributes(node.extAttrs), file);
-    namespace.members = node.members.map(it => toIDLNodeForward(file, it));
-    return namespace;
-}
-function toIDLVersion(file, node) {
-    return idl.createVersion(node.value, toExtendedAttributes(node.extAttrs), file);
-}
-function toIDLProperty(file, node) {
-    return idl.createProperty(node.name, toIDLType(file, node.idlType), node.readonly, node.special === "static", isOptional(node), {
-        documentation: makeDocs(node),
-        fileName: file,
-        extendedAttributes: toExtendedAttributes(node.extAttrs)
-    });
-}
-function 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";
-            }
+    toIDLMethod(file, node, isFree = false) {
+        var _a;
+        if (!node.idlType) {
+            throw new Error(`method with no type ${toString(node)}`);
         }
-        else if (oct !== undefined) {
-            return String.fromCharCode(parseInt(oct, 8));
+        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,
+            isOptional: isOptional(node),
+            isFree
+        }, {
+            documentation: this.makeDocs(node),
+            extendedAttributes: this.toExtendedAttributes(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),
+        }));
+    }
+    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(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);
         }
-        else if (h2 !== undefined) {
-            return String.fromCharCode(parseInt(h2, 16));
+        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(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(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(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(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(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 (u4 !== undefined) {
-            return String.fromCharCode(parseInt(u4, 16));
+        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);
         }
-        throw new Error(`unknown escape sequence: ${_}`);
-    });
-    return value;
-}
-function 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 = unescapeString(node.default.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(node.extAttrs),
+        }));
     }
-    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);
+    toExtendedAttributes(extAttrs) {
+        return extAttrs.map(it => {
+            return this.withInfo(it, { name: it.name, value: this.toExtendedAttributeValue(it) });
+        });
     }
-    else if (node.default == null) {
-        initializer = 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;
     }
-    else {
-        throw new Error(`Not representable enum initializer: ${node.default}`);
+    toIDLEnum(file, node) {
+        const result = idl.createEnum(node.name, [], {
+            fileName: file,
+            documentation: this.makeDocs(node),
+            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+        });
+        result.elements = node.values.map((it) => idl.createEnumMember(it.value, result, idl.IDLNumberType, undefined));
+        return this.withInfo(node, result);
     }
-    return idl.createEnumMember(node.name, parent, toIDLType(file, node.idlType), initializer, {
-        extendedAttributes: toExtendedAttributes(node.extAttrs),
-    });
-}
-function toExtendedAttributes(extAttrs) {
-    return extAttrs.map(it => {
-        return { name: it.name, value: toExtendedAttributeValue(it) };
-    });
-}
-function 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 unescapeString(attr.rhs.value);
-    return;
-}
-function makeDocs(node) {
-    let docs = undefined;
-    node.extAttrs.forEach(it => {
+    ///
+    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);
+    }
+    ///
+    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);
+        }
+        return result;
+    }
+    extractTypeArguments(file, extAttrs, attribute) {
         var _a;
-        if (it.name == "Documentation")
-            docs = (_a = it.rhs) === null || _a === void 0 ? void 0 : _a.value;
-    });
-    return docs;
-}
-function toIDLEnum(file, node) {
-    const result = idl.createEnum(node.name, [], {
-        fileName: file,
-        documentation: makeDocs(node),
-        extendedAttributes: toExtendedAttributes(node.extAttrs),
-    });
-    result.elements = node.values.map((it) => idl.createEnumMember(it.value, result, idl.IDLNumberType, undefined));
-    return result;
-}
-function findExtendedAttribute(extAttrs, name) {
-    const attr = extAttrs.find(it => it.name === name);
-    return attr ? toExtendedAttributeValue(attr) : undefined;
+        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); });
+    }
+    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";
+        }
+    }
+    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 toIDLFile(fileName, content) {
+export function toIDLFile(fileName, { content, inheritanceMode = 'multiple' } = {}) {
+    const lexicalInfo = new Map();
+    const deserializer = new IDLDeserializer(lexicalInfo, inheritanceMode);
     if (undefined === content)
         content = fs.readFileSync(fileName).toString();
     let packageClause = [];
@@ -404,14 +536,16 @@ export function toIDLFile(fileName, content) {
         .filter(it => {
         if (!it.type)
             return false;
-        if (isPackage(it)) {
+        if (deserializer.isPackage(it)) {
             packageClause = it.clause.split(".");
+            deserializer.setPackage(packageClause);
             return false;
         }
         return true;
     })
-        .map(it => toIDLNode(fileName, it));
+        .map(it => deserializer.toIDLNode(fileName, it));
     const file = idl.createFile(entries, fileName, packageClause);
-    return idl.linkParentBack(file);
+    file.text = content;
+    return [idl.linkParentBack(file), lexicalInfo];
 }
 //# sourceMappingURL=deserialize.js.map