@idlizer/core 2.0.31 → 2.0.32

package/build/lib/src/LanguageWriters/ArgConvertors.d.ts

@@ -3,6 +3,7 @@ import { Language } from "../Language";
 import { LanguageExpression, LanguageStatement, LanguageWriter, ExpressionAssigner } from "./LanguageWriter";
 import { RuntimeType } from "./common";
 import { LibraryInterface } from "../LibraryInterface";
+import { ReferenceResolver } from "../peer-generation/ReferenceResolver";
 export interface ArgConvertor {
     param: string;
     idlType: idl.IDLType;
@@ -220,7 +221,7 @@ export declare class DateConvertor extends BaseArgConvertor {
 }
 export declare class ProxyConvertor extends BaseArgConvertor {
     convertor: ArgConvertor;
-    constructor(convertor: ArgConvertor, suggestedName?: string);
+    constructor(convertor: ArgConvertor, suggestedReference?: idl.IDLReferenceType);
     convertorArg(param: string, writer: LanguageWriter): string;
     convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
     convertorSerialize(param: string, value: string, printer: LanguageWriter): void;
@@ -323,5 +324,5 @@ export declare function generateCallbackKindName(callback: idl.IDLCallback): str
 export declare function generateCallbackKindAccess(callback: idl.IDLCallback, language: Language): string;
 export declare function generateCallbackKindValue(callback: idl.IDLCallback): number;
 export declare function generateCallbackAPIArguments(library: LibraryInterface, callback: idl.IDLCallback): string[];
-export declare function maybeTransformManagedCallback(callback: idl.IDLCallback): idl.IDLCallback | undefined;
+export declare function maybeTransformManagedCallback(callback: idl.IDLCallback, library: ReferenceResolver): idl.IDLCallback | undefined;
 //# sourceMappingURL=ArgConvertors.d.ts.map

package/build/lib/src/LanguageWriters/ArgConvertors.js

@@ -154,7 +154,7 @@ export class StringConvertor extends BaseArgConvertor {
 }
 export class EnumConvertor extends BaseArgConvertor {
     constructor(param, enumEntry) {
-        super(idl.createReferenceType(enumEntry.name, undefined, enumEntry), [idl.isStringEnum(enumEntry) ? RuntimeType.STRING : RuntimeType.NUMBER], false, false, param);
+        super(idl.createReferenceType(enumEntry), [idl.isStringEnum(enumEntry) ? RuntimeType.STRING : RuntimeType.NUMBER], false, false, param);
         this.enumEntry = enumEntry;
     }
     convertorArg(param, writer) {
@@ -163,19 +163,19 @@ export class EnumConvertor extends BaseArgConvertor {
     convertorSerialize(param, value, writer) {
         value =
             idl.isStringEnum(this.enumEntry)
-                ? writer.ordinalFromEnum(writer.makeString(value), idl.createReferenceType(this.enumEntry.name, undefined, this.enumEntry)).asString()
+                ? writer.ordinalFromEnum(writer.makeString(value), idl.createReferenceType(this.enumEntry)).asString()
                 : writer.makeEnumCast(value, false, this);
         writer.writeMethodCall(`${param}Serializer`, "writeInt32", [value]);
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
         const readExpr = writer.makeMethodCall(`${deserializerName}`, "readInt32", []);
         const enumExpr = idl.isStringEnum(this.enumEntry)
-            ? writer.enumFromOrdinal(readExpr, idl.createReferenceType(this.enumEntry.name, undefined, this.enumEntry))
-            : writer.makeCast(readExpr, idl.createReferenceType(this.enumEntry.name, undefined, this.enumEntry));
+            ? writer.enumFromOrdinal(readExpr, idl.createReferenceType(this.enumEntry))
+            : writer.makeCast(readExpr, idl.createReferenceType(this.enumEntry));
         return assigneer(enumExpr);
     }
     nativeType() {
-        return idl.createReferenceType(this.enumEntry.name, undefined, this.enumEntry);
+        return idl.createReferenceType(this.enumEntry);
     }
     interopType() {
         return idl.IDLI32Type;
@@ -388,7 +388,7 @@ export class AggregateConvertor extends BaseArgConvertor {
         return writer.makeCast(writer.makeString(`{${content}}`), this.idlType);
     }
     nativeType() {
-        return idl.createReferenceType(this.decl.name, undefined, this.decl);
+        return idl.createReferenceType(this.decl);
     }
     interopType() {
         throw new Error("Must never be used");
@@ -421,7 +421,7 @@ export class TupleConvertor extends AggregateConvertor {
         return writer.makeCast(writer.makeString(`[${fields.map(it => it[1].asString()).join(', ')}]`), this.idlType);
     }
     nativeType() {
-        return idl.createReferenceType(this.decl.name, undefined, this.decl);
+        return idl.createReferenceType(this.decl);
     }
     interopType() {
         throw new Error("Must never be used");
@@ -439,7 +439,7 @@ export class TupleConvertor extends AggregateConvertor {
 }
 export class InterfaceConvertor extends BaseArgConvertor {
     constructor(library, name /* change to IDLReferenceType */, param, declaration) {
-        super(idl.createReferenceType(name, undefined, declaration), [RuntimeType.OBJECT], false, true, param);
+        super(idl.createReferenceType(declaration), [RuntimeType.OBJECT], false, true, param);
         this.library = library;
         this.declaration = declaration;
     }
@@ -637,8 +637,8 @@ export class DateConvertor extends BaseArgConvertor {
     }
 }
 export class ProxyConvertor extends BaseArgConvertor {
-    constructor(convertor, suggestedName) {
-        super(suggestedName ? idl.createReferenceType(suggestedName, undefined, convertor.idlType) : convertor.idlType, convertor.runtimeTypes, convertor.isScoped, convertor.useArray, convertor.param);
+    constructor(convertor, suggestedReference) {
+        super(suggestedReference ? suggestedReference : convertor.idlType, convertor.runtimeTypes, convertor.isScoped, convertor.useArray, convertor.param);
         this.convertor = convertor;
     }
     convertorArg(param, writer) {
@@ -668,7 +668,7 @@ export class ProxyConvertor extends BaseArgConvertor {
 }
 export class TypeAliasConvertor extends ProxyConvertor {
     constructor(library, param, typedef) {
-        super(library.typeConvertor(param, typedef.type), typedef.name);
+        super(library.typeConvertor(param, typedef.type), idl.createReferenceType(typedef));
     }
 }
 export class CustomTypeConvertor extends BaseArgConvertor {
@@ -888,7 +888,7 @@ export class FunctionConvertor extends BaseArgConvertor {
 }
 export class MaterializedClassConvertor extends BaseArgConvertor {
     constructor(param, declaration) {
-        super(idl.createReferenceType(declaration.name, undefined, declaration), [RuntimeType.OBJECT], false, true, param);
+        super(idl.createReferenceType(declaration), [RuntimeType.OBJECT], false, true, param);
         this.declaration = declaration;
     }
     convertorArg(param, writer) {
@@ -900,11 +900,11 @@ export class MaterializedClassConvertor extends BaseArgConvertor {
         ])));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
-        const readStatement = writer.makeCast(writer.makeMethodCall(`${deserializerName}`, `read${this.declaration.name}`, []), idl.createReferenceType(this.declaration.name, undefined, this.declaration));
+        const readStatement = writer.makeCast(writer.makeMethodCall(`${deserializerName}`, `read${this.declaration.name}`, []), idl.createReferenceType(this.declaration));
         return assigneer(readStatement);
     }
     nativeType() {
-        return idl.createReferenceType(this.declaration.name, undefined, this.declaration);
+        return idl.createReferenceType(this.declaration);
     }
     interopType() {
         throw new Error("Must never be used");
@@ -952,7 +952,7 @@ export class ImportTypeConvertor extends BaseArgConvertor {
 }
 export class CallbackConvertor extends BaseArgConvertor {
     constructor(library, param, decl) {
-        super(idl.createReferenceType(decl.name, undefined, decl), [RuntimeType.FUNCTION], false, true, param);
+        super(idl.createReferenceType(decl), [RuntimeType.FUNCTION], false, true, param);
         this.library = library;
         this.decl = decl;
     }
@@ -961,7 +961,7 @@ export class CallbackConvertor extends BaseArgConvertor {
     }
     get transformedDecl() {
         var _a;
-        return (_a = maybeTransformManagedCallback(this.decl)) !== null && _a !== void 0 ? _a : this.decl;
+        return (_a = maybeTransformManagedCallback(this.decl, this.library)) !== null && _a !== void 0 ? _a : this.decl;
     }
     convertorArg(param, writer) {
         throw new Error("Must never be used");
@@ -998,7 +998,7 @@ export class CallbackConvertor extends BaseArgConvertor {
         return assigneer(result);
     }
     nativeType() {
-        return idl.createReferenceType(this.transformedDecl.name, undefined, this.decl);
+        return idl.createReferenceType(this.decl);
     }
     isPointerType() {
         return true;
@@ -1042,9 +1042,9 @@ export function generateCallbackAPIArguments(library, callback) {
     }
     return args;
 }
-export function maybeTransformManagedCallback(callback) {
+export function maybeTransformManagedCallback(callback, library) {
     if (callback.name === "CustomBuilder")
-        return idl.createCallback("CustomNodeBuilder", [idl.createParameter("parentNode", idl.IDLPointerType)], idl.IDLPointerType, { extendedAttributes: [{ name: idl.IDLExtendedAttributes.Synthetic }] });
+        return library.resolveTypeReference(idl.createReferenceType("CustomNodeBuilder"));
     return undefined;
 }
 //# sourceMappingURL=ArgConvertors.js.map

package/build/lib/src/LanguageWriters/convertors/CppConvertors.js

@@ -13,7 +13,7 @@
  * limitations under the License.
  */
 import * as idl from '../../idl';
-import { generatorConfiguration } from "../../config";
+import { generatorConfiguration, generatorTypePrefix } from "../../config";
 import { convertNode, convertType } from "../nameConvertor";
 import { PrimitiveTypesInstance } from '../../peer-generation/PrimitiveType';
 import { InteropArgConvertor } from './InteropConvertors';
@@ -105,7 +105,7 @@ export class GenericCppConvertor {
         }
         let decl = this.resolver.toDeclaration(type);
         if (idl.isCallback(decl)) {
-            decl = (_a = maybeTransformManagedCallback(decl)) !== null && _a !== void 0 ? _a : decl;
+            decl = (_a = maybeTransformManagedCallback(decl, this.resolver)) !== null && _a !== void 0 ? _a : decl;
         }
         if (idl.isType(decl)) {
             if (idl.isReferenceType(decl)) {
@@ -239,8 +239,6 @@ export class CppReturnTypeConvertor {
     convertPrimitiveType(type) {
         if (type == idl.IDLUndefinedType)
             return 'void';
-        if (type == idl.IDLStringType)
-            return 'void';
         if (type == idl.IDLNumberType)
             return generatorConfiguration().TypePrefix + 'Int32'; // :(
         return this.convertor.convert(type);
@@ -251,7 +249,7 @@ export class CppReturnTypeConvertor {
     convertTypeReference(type) {
         const decl = this.resolver.resolveTypeReference(type);
         if (decl && idl.isInterface(decl) && isMaterialized(decl, this.resolver)) {
-            return generatorConfiguration().TypePrefix + decl.name;
+            return generatorTypePrefix() + decl.name;
         }
         return this.convertor.convert(type);
     }

package/build/lib/src/LanguageWriters/convertors/ETSConvertors.js

@@ -28,7 +28,7 @@ export class ETSTypeNameConvertor extends TSTypeNameConvertor {
         const types = type.name.split(".");
         if (types.length > 1) {
             // Takes only name without the namespace prefix
-            const decl = this.resolver.resolveTypeReference(idl.createReferenceType(types.slice(-1).join(), undefined, type));
+            const decl = this.resolver.resolveTypeReference(idl.createReferenceType(types.slice(-1).join()));
             if (decl !== undefined) {
                 return convertDeclaration(createDeclarationNameConvertor(Language.ARKTS), decl);
             }

package/build/lib/src/LanguageWriters/writers/CJLanguageWriter.js

@@ -186,7 +186,7 @@ export class CJEnumWithGetter {
         }
         let enumName = this.enumEntity.name;
         writer.writeClass(enumName, () => {
-            const enumType = idl.createReferenceType(enumName, undefined, this.enumEntity);
+            const enumType = idl.createReferenceType(this.enumEntity);
             members.forEach(it => {
                 writer.writeFieldDeclaration(it.name, enumType, [FieldModifier.PUBLIC, FieldModifier.STATIC, FieldModifier.FINAL], false, writer.makeString(`${enumName}(${it.numberId})`));
             });

package/build/lib/src/LanguageWriters/writers/CppLanguageWriter.js

@@ -243,7 +243,7 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
         this.print(`#include <${path}>`);
     }
     makeRef(type, options) {
-        return createReferenceType(`${this.stringifyTypeWithReceiver(type, options === null || options === void 0 ? void 0 : options.receiver)}&`, undefined, type);
+        return createReferenceType(`${this.stringifyTypeWithReceiver(type, options === null || options === void 0 ? void 0 : options.receiver)}&`);
     }
     makeThis() {
         return new StringExpression("*this");

package/build/lib/src/LanguageWriters/writers/ETSLanguageWriter.js

@@ -113,7 +113,7 @@ export class ETSLambdaExpression extends LambdaExpression {
         // Issue: https://rnd-gitlab-msc.huawei.com/rus-os-team/virtual-machines-and-tools/panda/-/issues/21333
         let isRetTypeCallback = idl.isCallback(this.signature.returnType);
         if (idl.isReferenceType(this.signature.returnType)) {
-            const resolved = this.resolver.resolveTypeReference(idl.createReferenceType(this.signature.returnType.name, undefined, this.signature.returnType));
+            const resolved = this.resolver.resolveTypeReference(this.signature.returnType);
             isRetTypeCallback = resolved !== undefined && idl.isCallback(resolved);
         }
         return `(${params.join(", ")})${isRetTypeCallback
@@ -237,7 +237,7 @@ export class ETSLanguageWriter extends TSLanguageWriter {
                 ? convertor.nativeType().types[runtimeTypeIndex]
                 : idl.maybeUnwrapOptionalType(convertor.nativeType());
             if (idlType !== undefined && idl.isReferenceType(idlType)) {
-                const resolved = this.resolver.resolveTypeReference(idl.createReferenceType(idlType.name, undefined, idlType));
+                const resolved = this.resolver.resolveTypeReference(idlType);
                 type = resolved != undefined && idl.isEnum(resolved) ? RuntimeType[RuntimeType.OBJECT] : type;
             }
         }

package/build/lib/src/LanguageWriters/writers/TsLanguageWriter.js

@@ -377,12 +377,15 @@ export class TSLanguageWriter extends LanguageWriter {
         return TSKeywords.has(keyword) ? keyword + "_" : keyword;
     }
     makeDiscriminatorConvertor(convertor, value, index) {
-        const decl = this.resolver.resolveTypeReference(idl.createReferenceType(this.getNodeName(convertor.nativeType()), undefined, convertor.idlType));
+        const convertorNativeType = convertor.nativeType();
+        const decl = this.resolver.resolveTypeReference(idl.isReferenceType(convertorNativeType)
+            ? convertorNativeType
+            : idl.createReferenceType(this.getNodeName(convertorNativeType)));
         if (decl === undefined || !idl.isEnum(decl)) {
             throwException(`The type reference ${decl === null || decl === void 0 ? void 0 : decl.name} must be Enum`);
         }
         const ordinal = idl.isStringEnum(decl)
-            ? this.ordinalFromEnum(this.makeCast(this.makeString(this.getObjectAccessor(convertor, value)), convertor.idlType), idl.createReferenceType(this.getNodeName(convertor.nativeType()), undefined, convertor.idlType))
+            ? this.ordinalFromEnum(this.makeCast(this.makeString(this.getObjectAccessor(convertor, value)), convertor.idlType), idl.createReferenceType(this.getNodeName(convertor.nativeType())))
             : this.makeUnionVariantCast(this.getObjectAccessor(convertor, value), this.getNodeName(idl.IDLI32Type), convertor, index);
         const { low, high } = idl.extremumOfOrdinals(decl);
         return this.discriminatorFromExpressions(value, convertor.runtimeTypes[0], [

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

@@ -12,8 +12,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { indentedBy } from "../util";
-import { IDLEntity, IDLKind, getExtAttribute, getVerbatimDts, hasExtAttribute, isCallback, isConstructor, isContainerType, isEnum, isInterface, isMethod, isPrimitiveType, isProperty, isReferenceType, isSyntheticEntry, isTypeParameterType, isTypedef, isUnionType, isPackage, isImport, isVersion, isNamespace, IDLExtendedAttributes, IDLAccessorAttribute, IDLVoidType, IDLStringType, IDLUndefinedType, isCallable, getSuperType, IDLAnyType, IDLContainerUtils, DebugUtils, mixMethodParametersAndTags, createReferenceType, transformMethodsAsync2ReturnPromise, isNamedNode, IDLThisType, isOptionalType, IDLI8Type, IDLU8Type, IDLI16Type, IDLU16Type, IDLI32Type, IDLU32Type, IDLI64Type, IDLU64Type, IDLF16Type, IDLF32Type, IDLF64Type, IDLBufferType, isUnspecifiedGenericType, IDLUnknownType, IDLBooleanType, IDLNumberType, IDLPointerType, IDLInterfaceSubkind, escapeIDLKeyword, getNamespacesPathFor } from "../idl";
+import { indentedBy, isInNamespace } from "../util";
+import { IDLEntity, IDLKind, getExtAttribute, getVerbatimDts, hasExtAttribute, isCallback, isConstructor, isContainerType, isEnum, isInterface, isMethod, isPrimitiveType, isProperty, isReferenceType, isSyntheticEntry, isTypeParameterType, isTypedef, isUnionType, isPackage, isImport, isVersion, isNamespace, IDLExtendedAttributes, IDLAccessorAttribute, IDLVoidType, IDLStringType, IDLUndefinedType, isCallable, getSuperType, IDLAnyType, IDLContainerUtils, DebugUtils, mixMethodParametersAndTags, createReferenceType, transformMethodsAsync2ReturnPromise, isNamedNode, IDLThisType, isOptionalType, IDLI8Type, IDLU8Type, IDLI16Type, IDLU16Type, IDLI32Type, IDLU32Type, IDLI64Type, IDLU64Type, IDLF16Type, IDLF32Type, IDLF64Type, IDLBufferType, isUnspecifiedGenericType, IDLUnknownType, IDLBooleanType, IDLNumberType, IDLPointerType, IDLInterfaceSubkind, escapeIDLKeyword, getNamespacesPathFor, IDLBigintType } from "../idl";
 import * as webidl2 from "webidl2";
 import { resolveSyntheticType, toIDLNode } from "./deserialize";
 import { Language } from "../Language";
@@ -27,7 +27,8 @@ export class CustomPrintVisitor {
     visit(node, wrapNamespaces = false) {
         const namespacesPath = wrapNamespaces ? getNamespacesPathFor(node) : [];
         for (const namespace of namespacesPath) {
-            this.print(`${namespace.namespace ? "" : "declare "}namespace ${namespace.name} {`);
+            const isTopmost = namespacesPath[0] === namespace;
+            this.print(`${!isTopmost ? "" : "declare "}namespace ${namespace.name} {`);
             this.pushIndent();
         }
         if (hasExtAttribute(node, IDLExtendedAttributes.TSType) && this.language == Language.TS)
@@ -82,7 +83,7 @@ export class CustomPrintVisitor {
             this.print(exports);
     }
     printConstant(node) {
-        this.print(`${node.namespace ? "" : "declare "}const ${node.name} : ${isPrimitiveType(node.type) ? "" : "typeof"} ${this.printTypeForTS(node.type)} = ${node.value}`);
+        this.print(`${isInNamespace(node) ? "" : "declare "}const ${node.name} : ${isPrimitiveType(node.type) ? "" : "typeof"} ${this.printTypeForTS(node.type)} = ${node.value}`);
     }
     printInterface(node) {
         var _a;
@@ -92,13 +93,13 @@ export class CustomPrintVisitor {
             typeSpec = "WrappedBuilder<Args extends any[]>";
         const entity = (_a = getExtAttribute(node, IDLExtendedAttributes.Entity)) !== null && _a !== void 0 ? _a : IDLEntity.Interface;
         if (entity === IDLEntity.Literal) {
-            this.print(`${node.namespace ? "" : "declare "}type ${typeSpec} = ${this.literal(node, false, true)}`);
+            this.print(`${isInNamespace(node) ? "" : "declare "}type ${typeSpec} = ${this.literal(node, false, true)}`);
         }
         else if (entity === IDLEntity.Tuple) {
-            this.print(`${node.namespace ? "" : "declare "}type ${typeSpec} = ${this.literal(node, true, false)}`);
+            this.print(`${isInNamespace(node) ? "" : "declare "}type ${typeSpec} = ${this.literal(node, true, false)}`);
         }
         else if (entity === IDLEntity.NamedTuple) {
-            this.print(`${node.namespace ? "" : "declare "}type ${typeSpec} = ${this.literal(node, true, true)}`);
+            this.print(`${isInNamespace(node) ? "" : "declare "}type ${typeSpec} = ${this.literal(node, true, true)}`);
         }
         else {
             // restore globalScope
@@ -118,7 +119,7 @@ export class CustomPrintVisitor {
             }
             if (interfaces.length > 0)
                 typeSpec += ` ${keyword} ${interfaces.map(it => this.toTypeName(it)).join(", ")}`;
-            this.print(`${node.namespace ? "" : "declare "}${entity.toLowerCase()} ${typeSpec} {`);
+            this.print(`${isInNamespace(node) ? "" : "declare "}${entity.toLowerCase()} ${typeSpec} {`);
             this.currentInterface = node;
             this.pushIndent();
             node.constructors.map(it => this.visit(it));
@@ -151,7 +152,8 @@ export class CustomPrintVisitor {
             const isFree = isMethod(node) && node.isFree;
             if (isGlobal && !isFree) // TODO: namespace-related-to-rework
                 throw new Error("internal error");
-            preamble = `${isFree ? `${node.namespace ? "" : "declare "}function ` : ""}${isProtected ? "protected " : ""}${isStatic ? "static " : ""}${name}${isOptional ? "?" : ""}`;
+            const inNamespace = getNamespacesPathFor(node).length > 0;
+            preamble = `${isFree ? `${isInNamespace(node) ? "" : "declare "}function ` : ""}${isProtected ? "protected " : ""}${isStatic ? "static " : ""}${name}${isOptional ? "?" : ""}`;
         }
         this.print(`${preamble}${typeParams}(${mixMethodParametersAndTags(node).map(p => this.paramText(p)).join(", ")})${returnType};`);
     }
@@ -187,7 +189,7 @@ export class CustomPrintVisitor {
         }
     }
     printEnum(node) {
-        this.print(`${node.namespace ? "" : "declare "}enum ${node.name} {`);
+        this.print(`${isInNamespace(node) ? "" : "declare "}enum ${node.name} {`);
         this.pushIndent();
         node.elements.forEach(it => {
             const initializer = (it.type === IDLStringType ? `"${it.initializer}"` : `${it.initializer}`);
@@ -204,7 +206,7 @@ export class CustomPrintVisitor {
         // Let's skip imported declarations
         if (isTypedef(node) &&
             hasExtAttribute(node, IDLExtendedAttributes.Import)) {
-            let definition = this.resolver(createReferenceType(node.name, undefined, node));
+            let definition = this.resolver(createReferenceType(node));
             // TODO: handle namespace case better!
             // TODO: namespace-related-to-rework
             throw new Error("not implemented yet");
@@ -217,7 +219,7 @@ export class CustomPrintVisitor {
             : hasExtAttribute(node, IDLExtendedAttributes.Import) ? IDLAnyType.name
                 : this.printTypeForTS(node.type);
         const typeParams = node.typeParameters && node.typeParameters.length > 0 ? `<${node.typeParameters.join(",")}>` : "";
-        this.print(`${node.namespace ? '' : 'declare '}type ${getName(node)}${typeParams} = ${text};`);
+        this.print(`${isInNamespace(node) ? '' : 'declare '}type ${getName(node)}${typeParams} = ${text};`);
     }
     printVersion(node) {
         let text = node.value.join(".");
@@ -229,17 +231,17 @@ export class CustomPrintVisitor {
             this.print(verbatimDts);
             return;
         }
-        this.print(`${node.namespace ? "" : "declare "} namespace ${node.name} {`);
+        this.print(`${isInNamespace(node) ? "" : "declare "} namespace ${node.name} {`);
         this.pushIndent();
         node.members.forEach(member => this.visit(member));
         this.popIndent();
         this.print("}");
     }
     printImport(node) {
-        this.print(`// import ${node.name}`);
+        this.print(`// import ${node.clause.join(".")}${node.name ? " as " : ""}${node.name || ""}`);
     }
     printPackage(node) {
-        this.print(`// package ${node.name}`);
+        this.print(`// package ${node.clause.join(".")}`);
     }
     checkVerbatim(node) {
         let verbatim = getExtAttribute(node, IDLExtendedAttributes.VerbatimDts);
@@ -291,6 +293,7 @@ export class CustomPrintVisitor {
                 case IDLStringType: return "string";
                 case IDLVoidType: return "void";
                 case IDLThisType: return "T";
+                case IDLBigintType:
                 case IDLPointerType: return "number|bigint";
                 default: throw new Error(`Unknown primitive type ${DebugUtils.debugPrintType(type)}`);
             }

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

@@ -1,9 +1,8 @@
 import * as webidl2 from "webidl2";
 import * as idl from "../idl";
-import * as lib from "../library";
 export declare function addSyntheticType(name: string, type: idl.IDLEntry): void;
 export declare function resolveSyntheticType(type: idl.IDLReferenceType): idl.IDLEntry | undefined;
 export declare function toIDLNode(file: string, node: webidl2.IDLRootType): idl.IDLEntry;
 export declare function toIDL(file: string): idl.IDLEntry[];
-export declare function toIDLFile(fileName: string): lib.IDLFile;
+export declare function toIDLFile(fileName: string): idl.IDLFile;
 //# sourceMappingURL=deserialize.d.ts.map

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

@@ -29,9 +29,7 @@ export function resolveSyntheticType(type) {
     return syntheticTypes.get(type.name);
 }
 export function toIDLNode(file, node) {
-    const result = toIDLNodeForward(file, node);
-    idl.linkNamespacesBack(result);
-    return result;
+    return toIDLNodeForward(file, node);
 }
 function toIDLNodeForward(file, node) {
     if (isEnum(node)) {
@@ -88,11 +86,15 @@ function isCallable(node) {
     return node.extAttrs.some(it => it.name == "Invoke");
 }
 function toIDLPackage(node) {
-    return idl.createPackage(node.nameValue);
+    if (node.clause.startsWith('"')) { // TODO: remove after new schema formation
+        //node.clause = node.clause.substring(1, node.clause.length - 1)
+        throw new Error("Obsolete IDL-source syntax detected");
+    }
+    return idl.createPackage(node.clause.split("."));
 }
 function toIDLImport(node) {
     // console.log(node)
-    return idl.createImport(node.nameValue);
+    return idl.createImport(node.clause.split("."), node.alias || undefined);
 }
 function toIDLInterface(file, node) {
     var _a;
@@ -373,12 +375,8 @@ export function toIDL(file) {
 }
 export function toIDLFile(fileName) {
     const content = fs.readFileSync(fileName).toString();
-    const entities = webidl2.parse(content).map(it => toIDLNode(fileName, it));
-    const pack = entities.find(idl.isPackage);
-    return {
-        fileName,
-        entities,
-        package: pack,
-    };
+    const entries = webidl2.parse(content).map(it => toIDLNode(fileName, it));
+    const file = idl.createFile(entries, fileName);
+    return idl.linkParentBack(file);
 }
 //# sourceMappingURL=deserialize.js.map

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

@@ -21,7 +21,8 @@ export declare enum IDLKind {
     TypeParameterType = 18,
     OptionalType = 19,
     Version = 20,
-    Namespace = 21
+    Namespace = 21,
+    File = 22
 }
 export declare enum IDLEntity {
     Class = "Class",
@@ -75,10 +76,15 @@ export interface IDLExtendedAttribute {
 export interface IDLNode {
     _idlNodeBrand: any;
     kind: IDLKind;
+    parent?: IDLNode;
     fileName?: string;
     extendedAttributes?: IDLExtendedAttribute[];
     documentation?: string;
 }
+export interface IDLFile extends IDLNode {
+    entries: IDLEntry[];
+    fileName?: string;
+}
 export interface IDLNamedNode extends IDLNode {
     _idlNamedNodeBrand: any;
     name: string;
@@ -86,7 +92,6 @@ export interface IDLNamedNode extends IDLNode {
 export interface IDLEntry extends IDLNode, IDLNamedNode {
     _idlEntryBrand: any;
     comment?: string;
-    namespace?: IDLNamespace;
 }
 export interface IDLType extends IDLNode {
     _idlTypeBrand: any;
@@ -112,7 +117,6 @@ export interface IDLContainerType extends IDLType {
 export interface IDLReferenceType extends IDLType, IDLNamedNode {
     kind: IDLKind.ReferenceType;
     typeArguments?: IDLType[];
-    namespace?: IDLNamespace;
 }
 export interface IDLUnspecifiedGenericType extends IDLType, IDLNamedNode {
     kind: IDLKind.UnspecifiedGenericType;
@@ -204,10 +208,11 @@ export interface IDLInterface extends IDLEntry {
 }
 export interface IDLPackage extends IDLEntry {
     kind: IDLKind.Package;
+    clause: string[];
 }
 export interface IDLImport extends IDLEntry {
     kind: IDLKind.Import;
-    importClause?: string[];
+    clause: string[];
 }
 export interface IDLNamespace extends IDLEntry {
     kind: IDLKind.Namespace;
@@ -220,6 +225,7 @@ export interface IDLCallback extends IDLEntry, IDLSignature {
 export declare function forEachChild(node: IDLNode, cbEnter: (entry: IDLNode) => void, cbLeave?: (entry: IDLNode) => void): void;
 export declare function isNamedNode(type: IDLNode): type is IDLNamedNode;
 export declare function forceAsNamedNode(type: IDLNode): IDLNamedNode;
+export declare function isFile(node: IDLNode): node is IDLFile;
 export declare function isUndefinedType(type: IDLNode): type is IDLPrimitiveType;
 export declare function isVoidType(type: IDLNode): type is IDLPrimitiveType;
 export declare function isPrimitiveType(type: IDLNode): type is IDLPrimitiveType;
@@ -294,21 +300,25 @@ export type IDLNodeInitializer = {
     documentation?: string;
 };
 export declare function createNamespace(name: string, extendedAttributes?: IDLExtendedAttribute[], fileName?: string): IDLNamespace;
-export declare function linkNamespacesBack(node: IDLNode): void;
+export declare function linkParentBack<T extends IDLNode>(node: T): T;
 export declare function getNamespacesPathFor(entry: IDLEntry): IDLNamespace[];
+export declare function getFileFor(entry: IDLNode): IDLFile | undefined;
 export declare function isEqualByQualifedName(a?: IDLEntry, b?: IDLEntry): boolean;
+export declare function getPackageClause(entry: IDLFile | IDLEntry): string[];
+export declare function getPackageName(entry: IDLFile | IDLEntry): string;
 export declare function getNamespaceName(a: IDLEntry): string;
 export declare function getFQName(a: IDLEntry): string;
 export declare function createVersion(value: string[], extendedAttributes?: IDLExtendedAttribute[], fileName?: string): IDLVersion;
 export declare function fetchNamespaceFrom(pointOfView?: IDLNode): IDLNamespace | undefined;
-export declare function createReferenceType(name: string, typeArguments?: IDLType[], pointOfView?: IDLNode): IDLReferenceType;
+export declare function createReferenceType(name: string, typeArguments?: IDLType[]): IDLReferenceType;
 export declare function createReferenceType(source: IDLEntry, typeArguments?: IDLType[]): IDLReferenceType;
 export declare function createUnspecifiedGenericType(name: string, typeArguments: IDLType[]): IDLUnspecifiedGenericType;
 export declare function entityToType(entity: IDLNode): IDLType;
 export declare function createContainerType(container: IDLContainerKind, element: IDLType[]): IDLContainerType;
 export declare function createUnionType(types: IDLType[], name?: string): IDLUnionType;
-export declare function createPackage(name: string): IDLPackage;
-export declare function createImport(name: string, importClause?: string[], nodeInitializer?: IDLNodeInitializer): IDLImport;
+export declare function createFile(entries: IDLEntry[], fileName?: string): IDLFile;
+export declare function createPackage(clause: string[]): IDLPackage;
+export declare function createImport(clause: string[], name?: string, nodeInitializer?: IDLNodeInitializer): IDLImport;
 export declare function createEnum(name: string, elements: IDLEnumMember[], nodeInitializer: IDLNodeInitializer): IDLEnum;
 export declare function createEnumMember(name: string, parent: IDLEnum, type: IDLPrimitiveType, initializer: number | string | undefined, nodeInitializer?: IDLNodeInitializer): IDLEnumMember;
 export declare function createInterface(name: string, subkind: IDLInterfaceSubkind, inheritance?: IDLReferenceType[], constructors?: IDLConstructor[], constants?: IDLConstant[], properties?: IDLProperty[], methods?: IDLMethod[], callables?: IDLCallable[], typeParameters?: string[], nodeInitializer?: IDLNodeInitializer): IDLInterface;

package/build/lib/src/idl.js

@@ -40,6 +40,7 @@ export var IDLKind;
     IDLKind[IDLKind["OptionalType"] = 19] = "OptionalType";
     IDLKind[IDLKind["Version"] = 20] = "Version";
     IDLKind[IDLKind["Namespace"] = 21] = "Namespace";
+    IDLKind[IDLKind["File"] = 22] = "File";
 })(IDLKind || (IDLKind = {}));
 export var IDLEntity;
 (function (IDLEntity) {
@@ -101,6 +102,9 @@ export function forEachChild(node, cbEnter, cbLeave) {
     var _a, _b;
     cbEnter(node);
     switch (node.kind) {
+        case IDLKind.File:
+            node.entries.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+            break;
         case IDLKind.Namespace:
             node.members.forEach((value) => forEachChild(value, cbEnter, cbLeave));
             break;
@@ -187,6 +191,9 @@ export function forceAsNamedNode(type) {
     }
     return type;
 }
+export function isFile(node) {
+    return node.kind === IDLKind.File;
+}
 export function isUndefinedType(type) {
     return isPrimitiveType(type) && type.name === IDLUndefinedType.name;
 }
@@ -346,29 +353,41 @@ export function createNamespace(name, extendedAttributes, fileName) {
         _idlNamedNodeBrand: innerIdlSymbol,
     };
 }
-export function linkNamespacesBack(node) {
-    let namespacePath = [];
-    forEachChild(node, child => {
-        if (isEntry(child) || isReferenceType(child)) {
-            if (!child.namespace)
-                child.namespace = namespacePath.length ? namespacePath[namespacePath.length - 1] : undefined;
-        }
-        if (isNamespace(child))
-            namespacePath.push(child);
-    }, child => {
-        if (isNamespace(child))
-            namespacePath.pop();
+export function linkParentBack(node) {
+    const parentStack = [];
+    forEachChild(node, (node) => {
+        if (isPrimitiveType(node))
+            return;
+        if (parentStack.length)
+            node.parent = parentStack[parentStack.length - 1];
+        parentStack.push(node);
+    }, (node) => {
+        if (isPrimitiveType(node))
+            return;
+        parentStack.pop();
     });
+    return node;
 }
 export function getNamespacesPathFor(entry) {
-    let iterator = entry.namespace;
+    let iterator = entry.parent;
     const result = [];
     while (iterator) {
-        result.unshift(iterator);
-        iterator = iterator.namespace;
+        if (isNamespace(iterator))
+            result.unshift(iterator);
+        iterator = iterator.parent;
     }
     return result;
 }
+export function getFileFor(entry) {
+    let iterator = entry;
+    while (iterator) {
+        if (isFile(iterator))
+            return iterator;
+        iterator = iterator.parent;
+    }
+    console.warn(`Entry ${JSON.stringify(entry)} does not have IDLFile in parents`);
+    return undefined;
+}
 export function isEqualByQualifedName(a, b) {
     if (a === b)
         return true;
@@ -376,17 +395,28 @@ export function isEqualByQualifedName(a, b) {
         return false;
     if (a.kind !== b.kind || a.name !== b.name)
         return false;
-    return isEqualByQualifedName(a.namespace, b.namespace);
+    return getFQName(a) === getFQName(b);
+}
+export function getPackageClause(entry) {
+    let file = getFileFor(entry);
+    if (!file)
+        return [];
+    for (const child of file.entries)
+        if (isPackage(child))
+            return child.clause;
+    // console.warn("Expected to have one IDLPackage inside IDLFile. Using empty package name")
+    return [];
+}
+export function getPackageName(entry) {
+    return getPackageClause(entry).join(".");
 }
 export function getNamespaceName(a) {
     return getNamespacesPathFor(a).map(it => it.name).join('.');
 }
 export function getFQName(a) {
-    let ns = getNamespaceName(a);
-    if (ns !== '') {
-        ns += '.';
-    }
-    return ns + a.name;
+    // TODO package name is very dirty now, waiting for Alexander Rekunkov PR
+    // return [...getPackageClause(a), ...getNamespacesPathFor(a).map(it => it.name), a.name].join('.')
+    return [...getNamespacesPathFor(a).map(it => it.name), a.name].join('.');
 }
 export function createVersion(value, extendedAttributes, fileName) {
     return {
@@ -401,30 +431,26 @@ export function createVersion(value, extendedAttributes, fileName) {
     };
 }
 export function fetchNamespaceFrom(pointOfView) {
-    if (pointOfView) {
-        if (isNamespace(pointOfView))
-            return pointOfView;
-        if (isEntry(pointOfView) || isReferenceType(pointOfView))
-            return pointOfView.namespace;
+    let node = pointOfView;
+    while (node) {
+        if (isNamespace(node))
+            return node;
+        node = node.parent;
     }
     return undefined;
 }
-export function createReferenceType(nameOrSource, typeArguments, pointOfView) {
+export function createReferenceType(nameOrSource, typeArguments) {
     let name;
-    let namespace;
     if (typeof nameOrSource === 'string') {
         name = nameOrSource;
-        namespace = fetchNamespaceFrom(pointOfView);
     }
     else {
-        name = nameOrSource.name;
-        namespace = fetchNamespaceFrom(nameOrSource);
+        name = getFQName(nameOrSource);
     }
     return {
         kind: IDLKind.ReferenceType,
         name,
         typeArguments,
-        namespace: namespace,
         _idlNodeBrand: innerIdlSymbol,
         _idlTypeBrand: innerIdlSymbol,
         _idlNamedNodeBrand: innerIdlSymbol,
@@ -444,7 +470,12 @@ export function entityToType(entity) {
     if (isType(entity)) {
         return entity;
     }
-    return createReferenceType(forceAsNamedNode(entity).name, undefined, entity);
+    else if (isEntry(entity)) {
+        return createReferenceType(entity);
+    }
+    else {
+        throw new Error(`Expected to have IDLType or IDLEntry, got ${entity}`);
+    }
 }
 export function createContainerType(container, element) {
     return {
@@ -467,17 +498,26 @@ export function createUnionType(types, name) {
         _idlNamedNodeBrand: innerIdlSymbol,
     };
 }
-export function createPackage(name) {
+export function createFile(entries, fileName) {
+    return {
+        kind: IDLKind.File,
+        entries: entries,
+        fileName,
+        _idlNodeBrand: innerIdlSymbol,
+    };
+}
+export function createPackage(clause) {
     return {
         kind: IDLKind.Package,
-        name,
+        name: "",
+        clause,
         _idlNodeBrand: innerIdlSymbol,
         _idlEntryBrand: innerIdlSymbol,
         _idlNamedNodeBrand: innerIdlSymbol,
     };
 }
-export function createImport(name, importClause, nodeInitializer) {
-    return Object.assign(Object.assign({ kind: IDLKind.Import, name, importClause: importClause }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
+export function createImport(clause, name, nodeInitializer) {
+    return Object.assign(Object.assign({ kind: IDLKind.Import, name: name || "", clause }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
 export function createEnum(name, elements, nodeInitializer) {
     return Object.assign(Object.assign({ kind: IDLKind.Enum, name: name, elements: elements }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
@@ -713,13 +753,15 @@ export function printMethod(idl) {
     ];
 }
 export function printPackage(idl) {
+    if (!idl.clause.length)
+        return [];
     return [
-        `package "${idl.name}";`
+        `package ${idl.clause.join(".")};`
     ];
 }
 export function printImport(idl) {
     return [
-        `import "${idl.name}";`
+        `import ${idl.clause.join(".")}${idl.name ? " as " : ""}${idl.name};`
     ];
 }
 export function printNamespace(idl) {

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

@@ -1,4 +1,14 @@
 import * as ts from "typescript";
-import { GenerateOptions, GenericVisitor } from "./options";
-export declare function generate<T>(inputDirs: string[], inputFiles: string[], outputDir: string, visitorFactory: (sourceFile: ts.SourceFile, typeChecker: ts.TypeChecker) => GenericVisitor<T>, options: GenerateOptions<T>): void;
+import { GenerateOptions } from "./options";
+export interface GenerateVisitor<T> {
+    visitPhase1(): T;
+    visitPhase2?(siblings: {
+        [key in string]: {
+            tsSourceFile: ts.SourceFile;
+            visitor: GenerateVisitor<T>;
+            result: T;
+        };
+    }): T;
+}
+export declare function generate<T>(inputDirs: string[], inputFiles: string[], outputDir: string, visitorFactory: (sourceFile: ts.SourceFile, program: ts.Program, compilerHost: ts.CompilerHost) => GenerateVisitor<T>, options: GenerateOptions<T>): void;
 //# sourceMappingURL=idlize.d.ts.map

package/build/lib/src/idlize.js

@@ -62,7 +62,8 @@ export function generate(inputDirs, inputFiles, outputDir, visitorFactory, optio
         });
     }
     input = Array.from(new Set(input.map(p => path.resolve(p)))).sort();
-    let program = ts.createProgram(input.concat([path.join(__dirname, "../stdlib.d.ts")]), options.compilerOptions);
+    let compilerHost = ts.createCompilerHost(options.compilerOptions);
+    let program = ts.createProgram(input.concat([path.join(__dirname, "../stdlib.d.ts")]), options.compilerOptions, compilerHost);
     if (options.enableLog) {
         console.log("Initialized TypeScript program with input files:", input);
     }
@@ -70,23 +71,37 @@ export function generate(inputDirs, inputFiles, outputDir, visitorFactory, optio
         fs.mkdirSync(outputDir, { recursive: true });
     const typeChecker = program.getTypeChecker();
     (_a = options.onBegin) === null || _a === void 0 ? void 0 : _a.call(options, outputDir, typeChecker);
+    const dtsFileName2Visitor = {};
     for (const sourceFile of program.getSourceFiles()) {
-        const resolvedSourceFile = path.resolve(sourceFile.fileName);
-        const isInDir = resolvedInputDirs.some(dir => resolvedSourceFile.startsWith(dir));
-        const isExplicitFile = input.some(f => path.resolve(f) === resolvedSourceFile);
+        const resolvedSourceFileName = path.resolve(sourceFile.fileName);
+        const isInDir = resolvedInputDirs.some(dir => resolvedSourceFileName.startsWith(dir));
+        const isExplicitFile = input.some(f => path.resolve(f) === resolvedSourceFileName);
         if (!isInDir && !isExplicitFile) {
             if (options.enableLog) {
-                console.log(`Skipping file: ${resolvedSourceFile}`);
+                console.log(`Skipping file: ${resolvedSourceFileName}`);
             }
             continue;
         }
         if (options.enableLog) {
-            console.log(`Processing file: ${resolvedSourceFile}`);
+            console.log(`Processing file: ${resolvedSourceFileName}`);
         }
         // Walk the tree to search for classes
-        const visitor = visitorFactory(sourceFile, typeChecker);
-        const output = visitor.visitWholeFile();
-        (_b = options.onSingleFile) === null || _b === void 0 ? void 0 : _b.call(options, output, outputDir, sourceFile);
+        const visitor = visitorFactory(sourceFile, program, compilerHost);
+        const result = visitor.visitPhase1();
+        dtsFileName2Visitor[sourceFile.fileName] = {
+            tsSourceFile: sourceFile,
+            visitor,
+            result
+        };
+    }
+    for (const resolvedSourceFileName in dtsFileName2Visitor) {
+        const visitorStaff = dtsFileName2Visitor[resolvedSourceFileName];
+        if (visitorStaff.visitor.visitPhase2)
+            visitorStaff.result = visitorStaff.visitor.visitPhase2(dtsFileName2Visitor);
+    }
+    for (const resolvedSourceFileName in dtsFileName2Visitor) {
+        const visitorStaff = dtsFileName2Visitor[resolvedSourceFileName];
+        (_b = options.onSingleFile) === null || _b === void 0 ? void 0 : _b.call(options, visitorStaff.result, outputDir, visitorStaff.tsSourceFile);
     }
     (_c = options.onEnd) === null || _c === void 0 ? void 0 : _c.call(options, outputDir);
     if (options.enableLog) {

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

@@ -1,14 +1,9 @@
 import * as idl from './idl';
 export interface IDLLibrary {
-    readonly files: readonly IDLFile[];
+    readonly files: readonly idl.IDLFile[];
 }
-export interface IDLFile {
-    fileName: string;
-    package?: idl.IDLPackage;
-    entities: idl.IDLNode[];
-}
-declare function createLibrary(files: IDLFile[]): IDLLibrary;
-declare function toLibrary(ii: Iterable<IDLFile>): IDLLibrary;
+declare function createLibrary(files: idl.IDLFile[]): IDLLibrary;
+declare function toLibrary(ii: Iterable<idl.IDLFile>): IDLLibrary;
 declare function serializeParam(params: unknown): string;
 export interface LibraryQuery<A, R> {
     fn: (x: A) => R;
@@ -44,8 +39,8 @@ export declare const lib: {
     lens: typeof lens;
     query: typeof query;
     select: {
-        files(): LibraryReducer<readonly IDLFile[]>;
-        nodes(params: EntitiesParams): LibraryQuery<readonly IDLFile[], idl.IDLNode[]>;
+        files(): LibraryReducer<readonly idl.IDLFile[]>;
+        nodes(params: EntitiesParams): LibraryQuery<readonly idl.IDLFile[], idl.IDLNode[]>;
         entries(): LibraryQuery<idl.IDLNode[], idl.IDLEntry[]>;
         interfaces(): LibraryQuery<idl.IDLNode[], idl.IDLInterface[]>;
         hasExt<T extends idl.IDLNode>(attr: idl.IDLExtendedAttributes): LibraryQuery<T[], T[]>;

package/build/lib/src/library.js

@@ -148,7 +148,7 @@ const select = {
             return [node];
         }
         return req(key, xs => {
-            return xs.flatMap(x => x.entities).flatMap(go);
+            return xs.flatMap(x => x.entries).flatMap(go);
         });
     },
     entries() {
@@ -166,7 +166,7 @@ const select = {
     name(name) {
         return reduce(`select.by.name.${name}`, lib => {
             return lib.files.flatMap(it => {
-                return it.entities.flatMap(it => {
+                return it.entries.flatMap(it => {
                     if (idl.isNamedNode(it) && it.name === name) {
                         return [it];
                     }

package/build/lib/src/peer-generation/PeerFile.d.ts

@@ -2,13 +2,14 @@ import * as idl from '../idl';
 import { PeerClass } from "./PeerClass";
 import { LibraryFileInterface } from '../LibraryInterface';
 export declare class PeerFile implements LibraryFileInterface {
-    readonly originalFilename: string;
-    readonly entries: idl.IDLEntry[];
+    readonly file: idl.IDLFile;
     readonly isPredefined: boolean;
     readonly peers: Map<string, PeerClass>;
-    constructor(originalFilename: string, entries: idl.IDLEntry[], isPredefined?: boolean);
+    constructor(file: idl.IDLFile, isPredefined?: boolean);
     packageName(): string;
     package(): idl.IDLPackage | undefined;
     get peersToGenerate(): PeerClass[];
+    get entries(): idl.IDLEntry[];
+    get originalFilename(): string;
 }
 //# sourceMappingURL=PeerFile.d.ts.map

package/build/lib/src/peer-generation/PeerFile.js

@@ -14,9 +14,8 @@
  */
 import * as idl from '../idl';
 export class PeerFile {
-    constructor(originalFilename, entries, isPredefined = false) {
-        this.originalFilename = originalFilename;
-        this.entries = entries;
+    constructor(file, isPredefined = false) {
+        this.file = file;
         this.isPredefined = isPredefined;
         this.peers = new Map();
     }
@@ -37,5 +36,13 @@ export class PeerFile {
         const peers = Array.from(this.peers.values());
         return peers;
     }
+    // TODO just to not refactor too much in one PR
+    get entries() {
+        return this.file.entries;
+    }
+    // TODO just to not refactor too much in one PR
+    get originalFilename() {
+        return this.file.fileName;
+    }
 }
 //# sourceMappingURL=PeerFile.js.map

package/build/lib/src/peer-generation/PeerLibrary.d.ts

@@ -10254,10 +10254,8 @@ export declare class PeerLibrary implements LibraryInterface {
     asIDLLibrary(): IDLLibrary;
     get globalScopeInterfaces(): idl.IDLInterface[];
     layout: LayoutManager;
-    private _syntheticEntries;
-    /** @deprecated PeerLibrary should contain only SDK entries */
-    get syntheticEntries(): idl.IDLEntry[];
-    initSyntheticEntries(entries: idl.IDLEntry[]): void;
+    private _syntheticFile;
+    initSyntheticEntries(file: idl.IDLFile): void;
     readonly files: PeerFile[];
     readonly builderClasses: Map<string, BuilderClass>;
     get buildersToGenerate(): BuilderClass[];
@@ -10279,8 +10277,8 @@ export declare class PeerLibrary implements LibraryInterface {
     setCurrentContext(context: string | undefined): void;
     findFileByOriginalFilename(filename: string): PeerFile | undefined;
     mapType(type: idl.IDLType): string;
-    resolveTypeReference(type: idl.IDLReferenceType, pointOfView?: idl.IDLEntry, rootEntries?: idl.IDLEntry[]): idl.IDLEntry | undefined;
-    resolvePackageName(entry: idl.IDLEntry): string;
+    resolveTypeReference(type: idl.IDLReferenceType): idl.IDLEntry | undefined;
+    private resolveTypeReferenceScoped;
     hasInLibrary(entry: idl.IDLEntry): boolean;
     typeConvertor(param: string, type: idl.IDLType, isOptionalParam?: boolean): ArgConvertor;
     declarationConvertor(param: string, type: idl.IDLReferenceType, declaration: idl.IDLEntry | undefined): ArgConvertor;

package/build/lib/src/peer-generation/PeerLibrary.js

@@ -40,21 +40,13 @@ export class PeerLibrary {
             return this._cachedIdlLibrary;
         }
         this._cachedIdlLibrary = {
-            files: this.files.map(file => ({
-                fileName: file.originalFilename,
-                entities: file.entries,
-                package: file.package()
-            }))
+            files: this.files.map(file => file.file)
         };
         return this._cachedIdlLibrary;
     }
     get globalScopeInterfaces() { return query(this.asIDLLibrary(), lenses.globals); }
-    /** @deprecated PeerLibrary should contain only SDK entries */
-    get syntheticEntries() {
-        return this._syntheticEntries;
-    }
-    initSyntheticEntries(entries) {
-        this._syntheticEntries = entries;
+    initSyntheticEntries(file) {
+        this._syntheticFile = file;
     }
     get buildersToGenerate() {
         return Array.from(this.builderClasses.values()).filter(it => it.needBeGenerated);
@@ -66,7 +58,7 @@ export class PeerLibrary {
         this.language = language;
         this.libraryPackages = libraryPackages;
         this.layout = LayoutManager.Empty();
-        this._syntheticEntries = [];
+        this._syntheticFile = idl.createFile([]);
         this.files = [];
         this.builderClasses = new Map();
         this.materializedClasses = new Map();
@@ -110,7 +102,7 @@ export class PeerLibrary {
     createContinuationCallbackReference(continuationType) {
         const continuationParameters = this.createContinuationParameters(continuationType);
         const syntheticName = generateSyntheticFunctionName(continuationParameters, idl.IDLVoidType);
-        return idl.createReferenceType(syntheticName, undefined, continuationType);
+        return idl.createReferenceType(syntheticName);
     }
     getCurrentContext() {
         return this.context;
@@ -124,15 +116,15 @@ export class PeerLibrary {
     mapType(type) {
         return this.targetNameConvertorInstance.convert(type);
     }
-    resolveTypeReference(type, pointOfView, rootEntries) {
-        const entry = this.syntheticEntries.find(it => it.name === type.name);
+    resolveTypeReference(type) {
+        return this.resolveTypeReferenceScoped(type);
+    }
+    resolveTypeReferenceScoped(type, pointOfView, rootEntries) {
+        const entry = this._syntheticFile.entries.find(it => it.name === type.name);
         if (entry)
             return entry;
         const qualifiedName = type.name.split(".");
-        pointOfView !== null && pointOfView !== void 0 ? pointOfView : (pointOfView = type.namespace);
-        let pointOfViewNamespace = !pointOfView || idl.isNamespace(pointOfView)
-            ? pointOfView
-            : pointOfView.namespace;
+        let pointOfViewNamespace = idl.fetchNamespaceFrom(type.parent);
         rootEntries !== null && rootEntries !== void 0 ? rootEntries : (rootEntries = this.files.flatMap(it => it.entries));
         if (1 === qualifiedName.length) {
             const predefined = rootEntries.filter(it => idl.hasExtAttribute(it, idl.IDLExtendedAttributes.Predefined));
@@ -152,9 +144,12 @@ export class PeerLibrary {
                 if (!candidates.length)
                     break;
                 if (qualifiedNamePart === qualifiedName.length - 1) {
-                    return candidates.length == 1
+                    const target = candidates.length == 1
                         ? candidates[0]
                         : candidates.find(it => !idl.hasExtAttribute(it, idl.IDLExtendedAttributes.Import)); // probably the wrong logic here
+                    if (target && idl.isImport(target)) // Temporary disable Import declarations
+                        return undefined;
+                    return target;
                 }
                 entries = [];
                 for (const candidate of candidates) {
@@ -166,7 +161,7 @@ export class PeerLibrary {
                         entries.push(...candidate.constants, ...candidate.properties, ...candidate.methods);
                 }
             }
-            pointOfViewNamespace = pointOfViewNamespace === null || pointOfViewNamespace === void 0 ? void 0 : pointOfViewNamespace.namespace;
+            pointOfViewNamespace = idl.fetchNamespaceFrom(pointOfViewNamespace === null || pointOfViewNamespace === void 0 ? void 0 : pointOfViewNamespace.parent);
         }
         // TODO: remove the next block after namespaces out of quarantine
         if (!pointOfView) {
@@ -174,7 +169,7 @@ export class PeerLibrary {
             const traverseNamespaces = (entry) => {
                 if (entry && idl.isNamespace(entry) && entry.members.length) {
                     //console.log(`Try alien namespace '${idl.getNamespacesPathFor(entry.members[0]).map(obj => obj.name).join(".")}' to resolve name '${type.name}'`)
-                    const resolved = this.resolveTypeReference(type, entry, rootEntries);
+                    const resolved = this.resolveTypeReferenceScoped(type, entry, rootEntries);
                     if (resolved)
                         resolveds.push(resolved);
                     entry.members.forEach(traverseNamespaces);
@@ -186,22 +181,9 @@ export class PeerLibrary {
         } // end of block to remove
         return undefined; // empty result
     }
-    resolvePackageName(entry) {
-        var _a;
-        if (this._syntheticEntries.includes(entry))
-            return ((_a = this.libraryPackages) === null || _a === void 0 ? void 0 : _a.length) ? this.libraryPackages[0] : this.files[0].packageName();
-        while (entry.namespace) {
-            entry = entry.namespace;
-        }
-        for (const file of this.files) {
-            if (file.entries.includes(entry))
-                return file.packageName();
-        }
-        throw new Error(`Package name for entry ${entry.name} was not found`);
-    }
     hasInLibrary(entry) {
         var _a, _b;
-        return !((_a = this.libraryPackages) === null || _a === void 0 ? void 0 : _a.length) || ((_b = this.libraryPackages) === null || _b === void 0 ? void 0 : _b.includes(this.resolvePackageName(entry)));
+        return !((_a = this.libraryPackages) === null || _a === void 0 ? void 0 : _a.length) || ((_b = this.libraryPackages) === null || _b === void 0 ? void 0 : _b.includes(idl.getPackageName(entry)));
     }
     typeConvertor(param, type, isOptionalParam = false) {
         if (isOptionalParam) {

package/build/lib/src/peer-generation/idl/common.js

@@ -39,9 +39,9 @@ export function qualifiedName(decl, languageOrDelimiter) {
     const delimiter = typeof languageOrDelimiter === "string"
         ? languageOrDelimiter
         : (languageOrDelimiter === Language.CPP ? '_' : '.');
-    if (idl.isEntry(decl) && decl.namespace)
-        return qualifiedName(decl.namespace, delimiter) + delimiter + idl.forceAsNamedNode(decl).name;
-    return idl.forceAsNamedNode(decl).name;
+    if (!idl.isEntry(decl))
+        throw new Error(`Expected to have an IDLEntry, got ${idl.IDLKind[decl.kind]}`);
+    return idl.getFQName(decl).split(".").join(delimiter);
 }
 export function collapseTypes(types, name) {
     const seenNames = new Set();

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

@@ -1,4 +1,5 @@
 import * as ts from "typescript";
+import * as idl from "./idl";
 import { Language } from './Language';
 export interface NameWithType {
     name?: ts.DeclarationName;
@@ -80,4 +81,5 @@ export declare class Lazy<T> {
     get value(): T;
 }
 export declare function lazy<T>(factory: () => T): Lazy<T>;
+export declare function isInNamespace(node: idl.IDLEntry): boolean;
 //# sourceMappingURL=util.d.ts.map

package/build/lib/src/util.js

@@ -15,6 +15,7 @@
 import * as path from 'path';
 import * as fs from "fs";
 import * as ts from "typescript";
+import * as idl from "./idl";
 import { Language } from './Language';
 /** True if this is visible outside this file, false otherwise */
 export function isNodePublic(node) {
@@ -635,4 +636,7 @@ export class Lazy {
 export function lazy(factory) {
     return new Lazy(factory);
 }
+export function isInNamespace(node) {
+    return idl.getNamespacesPathFor(node).length > 0;
+}
 //# sourceMappingURL=util.js.map

package/build/lib/src/visitor.js

@@ -103,7 +103,7 @@ export class IDLDependencyCollector {
     }
     visitSupertype(type) {
         if (idl.isInterface(type)) {
-            return this.walk(idl.createReferenceType(type.name, undefined, type));
+            return this.walk(idl.createReferenceType(type));
         }
         return this.walk(type);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idlizer/core",
-  "version": "2.0.31",
+  "version": "2.0.32",
   "description": "",
   "types": "build/lib/src/index.d.ts",
   "exports": {

package/webidl2.js/dist/webidl2.js

@@ -2073,32 +2073,35 @@ class Import extends _base_js__WEBPACK_IMPORTED_MODULE_0__.Base {
       return;
     }
     const tokens = { import: importKeyword };
-    tokens.name =
+    tokens.clause =
       tokeniser.consumeKind("string") ||
+      tokeniser.consumeKind("identifier") ||
       tokeniser.error("Incomplete import statement");
+    tokens.as = tokeniser.consume("as");
+    if (tokens.as)
+      tokens.alias =
+        tokeniser.consumeKind("identifier") ||
+        tokeniser.error("Incomplete import statement");
     tokens.termination =
       tokeniser.consume(";") ||
       tokeniser.error("No terminating ; for import statement");
     const ret = (0,_helpers_js__WEBPACK_IMPORTED_MODULE_1__.autoParenter)(new Import({ source: tokeniser.source, tokens }));
-    ret.nameValue = tokens.name.value;
+    ret.clause = tokens.clause.value;
+    ret.alias = tokens.alias?.value;
     return ret.this;
   }
 
   get type() {
     return "import";
   }
-  get target() {
-    return (0,_helpers_js__WEBPACK_IMPORTED_MODULE_1__.unescape)(this.tokens.target.value);
-  }
-  get import() {
-    return (0,_helpers_js__WEBPACK_IMPORTED_MODULE_1__.unescape)(this.tokens.importName.value);
-  }
 
   write(w) {
     return w.ts.definition(
       w.ts.wrap([
         w.token(this.tokens.import),
-        w.reference_token(this.tokens.name, this),
+        w.reference_token(this.tokens.clause, this),
+        w.token(this.tokens.as),
+        w.token(this.tokens.alias),
         w.token(this.tokens.termination),
       ]),
       { data: this },
@@ -2838,27 +2841,26 @@ class Package extends _base_js__WEBPACK_IMPORTED_MODULE_0__.Base {
       return;
     }
     const tokens = { base: packageKeyword };
-    tokens.name =
-      tokeniser.consumeKind("string") || tokeniser.error("No name for package");
+    tokens.clause =
+      tokeniser.consumeKind("string") ||
+      tokeniser.consumeKind("identifier") ||
+      tokeniser.error("No clause for package");
     tokens.termination =
       tokeniser.consume(";") || tokeniser.error("No semicolon after package");
     const ret = (0,_helpers_js__WEBPACK_IMPORTED_MODULE_1__.autoParenter)(new Package({ source: tokeniser.source, tokens }));
-    ret.nameValue = tokens.name.value;
+    ret.clause = tokens.clause.value;
     return ret.this;
   }
 
   get type() {
     return "package";
   }
-  get name() {
-    return (0,_helpers_js__WEBPACK_IMPORTED_MODULE_1__.unescape)(this.tokens.name.value);
-  }
 
   write(w) {
     return w.ts.definition(
       w.ts.wrap([
         w.token(this.tokens.base),
-        w.reference_token(this.tokens.name, this),
+        w.reference_token(this.tokens.clause, this),
         w.token(this.tokens.termination),
       ]),
       { data: this },
@@ -3640,6 +3642,7 @@ const argumentNameKeywords = [
   "unrestricted",
   "package",
   "import",
+  "as",
   "version",
 ];
 
@@ -3733,9 +3736,7 @@ function tokenise(str) {
         const token = tokens[lastIndex];
         if (result !== -1) {
           if (reserved.includes(token.value)) {
-            const message = `${(0,_productions_helpers_js__WEBPACK_IMPORTED_MODULE_1__.unescape)(
-              token.value,
-            )} is a reserved identifier and must not be used.`;
+            const message = `${(0,_productions_helpers_js__WEBPACK_IMPORTED_MODULE_1__.unescape)(token.value)} is a reserved identifier and must not be used.`;
             throw new WebIDLParseError(
               (0,_error_js__WEBPACK_IMPORTED_MODULE_0__.syntaxError)(tokens, lastIndex, null, message),
             );