@idlizer/core 2.0.31 → 2.0.33

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/LanguageWriter.d.ts

@@ -147,13 +147,14 @@ export declare enum FieldModifier {
 export declare enum MethodModifier {
     PUBLIC = 0,
     PRIVATE = 1,
-    STATIC = 2,
-    NATIVE = 3,
-    INLINE = 4,
-    GETTER = 5,
-    SETTER = 6,
-    PROTECTED = 7,
-    FREE = 8
+    PROTECTED = 2,
+    STATIC = 3,
+    NATIVE = 4,
+    INLINE = 5,
+    GETTER = 6,
+    SETTER = 7,
+    THROWS = 8,
+    FREE = 9
 }
 export declare enum ClassModifier {
     PUBLIC = 0,
@@ -214,6 +215,7 @@ export declare abstract class LanguageWriter {
     printer: IndentedPrinter;
     resolver: ReferenceResolver;
     language: Language;
+    protected namespaceStack: string[];
     constructor(printer: IndentedPrinter, resolver: ReferenceResolver, // TODO make protected again
     language: Language);
     indentDepth(): number;

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

@@ -309,13 +309,14 @@ export var MethodModifier;
 (function (MethodModifier) {
     MethodModifier[MethodModifier["PUBLIC"] = 0] = "PUBLIC";
     MethodModifier[MethodModifier["PRIVATE"] = 1] = "PRIVATE";
-    MethodModifier[MethodModifier["STATIC"] = 2] = "STATIC";
-    MethodModifier[MethodModifier["NATIVE"] = 3] = "NATIVE";
-    MethodModifier[MethodModifier["INLINE"] = 4] = "INLINE";
-    MethodModifier[MethodModifier["GETTER"] = 5] = "GETTER";
-    MethodModifier[MethodModifier["SETTER"] = 6] = "SETTER";
-    MethodModifier[MethodModifier["PROTECTED"] = 7] = "PROTECTED";
-    MethodModifier[MethodModifier["FREE"] = 8] = "FREE";
+    MethodModifier[MethodModifier["PROTECTED"] = 2] = "PROTECTED";
+    MethodModifier[MethodModifier["STATIC"] = 3] = "STATIC";
+    MethodModifier[MethodModifier["NATIVE"] = 4] = "NATIVE";
+    MethodModifier[MethodModifier["INLINE"] = 5] = "INLINE";
+    MethodModifier[MethodModifier["GETTER"] = 6] = "GETTER";
+    MethodModifier[MethodModifier["SETTER"] = 7] = "SETTER";
+    MethodModifier[MethodModifier["THROWS"] = 8] = "THROWS";
+    MethodModifier[MethodModifier["FREE"] = 9] = "FREE";
 })(MethodModifier || (MethodModifier = {}));
 export var ClassModifier;
 (function (ClassModifier) {
@@ -396,6 +397,7 @@ export class LanguageWriter {
         this.printer = printer;
         this.resolver = resolver;
         this.language = language;
+        this.namespaceStack = [];
     }
     indentDepth() {
         return this.printer.indentDepth();
@@ -731,6 +733,7 @@ export class LanguageWriter {
      * Writes closing brace of namespace block and removes one level of indent
      */
     popNamespace(ident = true) {
+        this.namespaceStack.pop();
         if (ident)
             this.popIndent();
         this.print(`}`);

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.d.ts

@@ -2,7 +2,6 @@ import * as idl from "../../idl";
 import { TSTypeNameConvertor } from "./TSConvertors";
 export declare class ETSTypeNameConvertor extends TSTypeNameConvertor {
     convertTypeReference(type: idl.IDLReferenceType): string;
-    convertEnum(node: idl.IDLEnum): string;
     convertContainer(type: idl.IDLContainerType): string;
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
     protected productType(decl: idl.IDLInterface, isTuple: boolean, includeFieldNames: boolean): string;

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);
             }
@@ -40,13 +40,6 @@ export class ETSTypeNameConvertor extends TSTypeNameConvertor {
         }
         return typeName;
     }
-    convertEnum(node) {
-        let ns = idl.getNamespaceName(node).split('.').join('_');
-        if (ns !== '') {
-            ns += '_';
-        }
-        return ns + node.name;
-    }
     convertContainer(type) {
         if (idl.IDLContainerUtils.isSequence(type)) {
             switch (type.elementType[0]) {

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

@@ -25,10 +25,10 @@ export class TSTypeNameConvertor {
         return node.name;
     }
     convertInterface(node) {
-        return node.name;
+        return idl.getFQName(node);
     }
     convertEnum(node) {
-        return node.name;
+        return idl.getFQName(node);
     }
     convertTypedef(node) {
         return node.name;

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

@@ -63,7 +63,8 @@ export class ArkTSEnumEntityStatement {
         this.isExport = isExport;
     }
     write(writer) {
-        const enumName = convertDeclaration(createDeclarationNameConvertor(Language.ARKTS), this.enumEntity);
+        let enumName = convertDeclaration(createDeclarationNameConvertor(Language.ARKTS), this.enumEntity);
+        enumName = enumName.split('.').at(-1);
         const members = this.enumEntity.elements
             .flatMap((member, index) => {
             var _a;
@@ -93,7 +94,10 @@ export class ArkTSEnumEntityStatement {
             }
             return res;
         });
+        const nss = idl.getNamespacesPathFor(this.enumEntity);
+        nss.forEach(it => writer.pushNamespace(it.name));
         writer.writeEnum(enumName, members);
+        nss.forEach(() => writer.popNamespace());
     }
 }
 export class ETSLambdaExpression extends LambdaExpression {
@@ -113,7 +117,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 +241,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

@@ -124,6 +124,7 @@ export class TSLanguageWriter extends LanguageWriter {
     }
     maybeSemicolon() { return ""; }
     pushNamespace(namespace, ident = true) {
+        this.namespaceStack.push(namespace);
         this.print(`export namespace ${namespace} {`);
         if (ident)
             this.pushIndent();
@@ -133,7 +134,14 @@ export class TSLanguageWriter extends LanguageWriter {
         return new TSLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.language);
     }
     getNodeName(type) {
-        return this.typeConvertor.convert(type);
+        // just stub.
+        // language writers and name convertors are subject to rework for namespaces
+        const row = this.typeConvertor.convert(type);
+        const nsPrefix = this.namespaceStack.join('.') + '.';
+        if (row.startsWith(nsPrefix)) {
+            return row.substring(nsPrefix.length);
+        }
+        return row;
     }
     writeClass(name, op, superClass, interfaces, generics, isDeclared, isAbstract) {
         let extendsClause = superClass ? ` extends ${superClass}` : '';
@@ -377,12 +385,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.d.ts

@@ -11,7 +11,7 @@ export declare class CustomPrintVisitor {
     printMetadata(node: IDLEnum): void;
     printConstant(node: IDLConstant): void;
     printInterface(node: IDLInterface): void;
-    printMethod(node: IDLMethod | IDLConstructor | IDLCallable, isGlobal?: boolean): void;
+    printMethod(node: IDLMethod | IDLConstructor | IDLCallable, forceAsFree?: boolean): void;
     paramText(paramOrTag: IDLParameter | SignatureTag): string;
     printProperty(node: IDLProperty): void;
     printEnum(node: IDLEnum): void;

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

@@ -12,11 +12,12 @@
  * 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";
+import { warn } from "../util";
 export class CustomPrintVisitor {
     constructor(resolver, language) {
         this.resolver = resolver;
@@ -27,7 +28,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 +84,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 +94,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 +120,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));
@@ -135,8 +137,7 @@ export class CustomPrintVisitor {
             this.print("}");
         }
     }
-    // TODO: namespace-related-to-rework: drop 'isGlobal'
-    printMethod(node, isGlobal = false) {
+    printMethod(node, forceAsFree = false) {
         const returnType = node.returnType && !(isConstructor(node) && this.currentInterface.subkind === IDLInterfaceSubkind.Class)
             ? `: ${this.printTypeForTS(node.returnType, true)}` : "";
         const name = isConstructor(node)
@@ -145,13 +146,16 @@ export class CustomPrintVisitor {
         const typeParams = (node.typeParameters && node.typeParameters.length > 0) ? `<${node.typeParameters.join(",")}>` : "";
         let preamble = "";
         if (!isCallable(node)) {
-            const isStatic = isMethod(node) && node.isStatic && !node.isFree;
+            let isStatic = isMethod(node) && node.isStatic;
             const isProtected = hasExtAttribute(node, IDLExtendedAttributes.Protected);
             const isOptional = isMethod(node) && node.isOptional;
-            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 ? "?" : ""}`;
+            let isFree = isMethod(node) && node.isFree;
+            if (forceAsFree) {
+                isStatic = false;
+                isFree = true;
+            }
+            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 +191,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,10 +208,11 @@ 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");
+            //throw new Error("not implemented yet")
+            warn("Typedef-with-Import is not implemented yet");
             // if (definition && !isTypedef(definition) && !hasExtAttribute(definition, IDLExtendedAttributes.Namespace)) {
             //     console.log(`Has better definition for ${node.name}: ${definition.fileName} ${definition.kind}`)
             //     return
@@ -217,7 +222,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 +234,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 +296,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