@idlizer/core 2.0.32 → 2.0.35

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

@@ -16,7 +16,7 @@ import * as idl from "../idl";
 import { Language } from "../Language";
 import { PrintHint, BlockStatement, StringExpression } from "./LanguageWriter";
 import { RuntimeType } from "./common";
-import { generatorTypePrefix } from "../config";
+import { generatorConfiguration, generatorTypePrefix } from "../config";
 import { hashCodeFromString, warn } from "../util";
 import { UnionRuntimeTypeChecker } from "../peer-generation/unions";
 import { CppNameConvertor } from "./convertors/CppConvertors";
@@ -888,11 +888,19 @@ export class FunctionConvertor extends BaseArgConvertor {
 }
 export class MaterializedClassConvertor extends BaseArgConvertor {
     constructor(param, declaration) {
-        super(idl.createReferenceType(declaration), [RuntimeType.OBJECT], false, true, param);
+        super(idl.createReferenceType(declaration), [RuntimeType.OBJECT], false, false, param);
         this.declaration = declaration;
     }
     convertorArg(param, writer) {
-        throw new Error("Must never be used");
+        switch (writer.language) {
+            case Language.CPP:
+                return `static_cast<${generatorConfiguration().TypePrefix}${this.declaration.name}>(${param})`;
+            case Language.JAVA:
+            case Language.CJ:
+                return `MaterializedBase.toPeerPtr(${param})`;
+            default:
+                return `toPeerPtr(${param})`;
+        }
     }
     convertorSerialize(param, value, printer) {
         printer.writeStatement(printer.makeStatement(printer.makeMethodCall(`${param}Serializer`, `write${this.declaration.name}`, [
@@ -907,7 +915,7 @@ export class MaterializedClassConvertor extends BaseArgConvertor {
         return idl.createReferenceType(this.declaration);
     }
     interopType() {
-        throw new Error("Must never be used");
+        return idl.IDLPointerType;
     }
     isPointerType() {
         return false;

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,7 +215,8 @@ export declare abstract class LanguageWriter {
     printer: IndentedPrinter;
     resolver: ReferenceResolver;
     language: Language;
-    constructor(printer: IndentedPrinter, resolver: ReferenceResolver, // TODO make protected again
+    protected namespaceStack: string[];
+    constructor(printer: IndentedPrinter, resolver: ReferenceResolver, // TODO make protected again (or better rework LWs)
     language: Language);
     indentDepth(): number;
     maybeSemicolon(): string;
@@ -233,6 +235,7 @@ export declare abstract class LanguageWriter {
     abstract writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
     abstract writeMethodImplementation(method: Method, op: (writer: this) => void): void;
     abstract writeProperty(propName: string, propType: idl.IDLType, mutable?: boolean, getterLambda?: (writer: this) => void, setterLambda?: (writer: this) => void): void;
+    abstract writeTypeDeclaration(decl: idl.IDLTypedef): void;
     abstract makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression | undefined, isDeclared: boolean, isConst?: boolean, options?: MakeAssignOptions): LanguageStatement;
     abstract makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
     abstract makeThrowError(message: string): LanguageStatement;

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) {
@@ -391,11 +392,12 @@ export class NamedMethodSignature extends MethodSignature {
 //                    LANGUAGE WRITER                         //
 ////////////////////////////////////////////////////////////////
 export class LanguageWriter {
-    constructor(printer, resolver, // TODO make protected again
+    constructor(printer, resolver, // TODO make protected again (or better rework LWs)
     language) {
         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/CJConvertors.js

@@ -106,7 +106,8 @@ export class CJTypeNameConvertor {
             case idl.IDLF64Type: return 'Float64';
             case idl.IDLPointerType: return 'UInt64';
             case idl.IDLVoidType: return 'Unit';
-            case idl.IDLBufferType: return 'Array<UInt8>';
+            case idl.IDLBufferType:
+            case idl.IDLInteropReturnBufferType: return 'Array<UInt8>';
         }
         throw new Error(`Unsupported IDL primitive ${idl.DebugUtils.debugPrintType(type)}`);
     }

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

@@ -239,8 +239,6 @@ export class CppReturnTypeConvertor {
     convertPrimitiveType(type) {
         if (type == idl.IDLUndefinedType)
             return 'void';
-        if (type == idl.IDLNumberType)
-            return generatorConfiguration().TypePrefix + 'Int32'; // :(
         return this.convertor.convert(type);
     }
     convertTypeParameter(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

@@ -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]) {
@@ -84,6 +77,7 @@ export class ETSTypeNameConvertor extends TSTypeNameConvertor {
             case idl.IDLStringType: return 'string';
             case idl.IDLFunctionType: return 'Object';
             case idl.IDLBufferType: return 'NativeBuffer';
+            case idl.IDLBigintType: return 'long';
         }
         return super.convertPrimitiveType(type);
     }

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

@@ -35,13 +35,13 @@ export class InteropReturnTypeConvertor {
             // TODO return array by some way
             return "void";
         }
-        return "void";
+        return KInteropReturnBuffer;
     }
     convertImport(type, importClause) {
         throw new Error(`Cannot pass import type ${type.name} through interop`);
     }
     convertOptional(type) {
-        return 'void';
+        return KInteropReturnBuffer;
     }
     convertPrimitiveType(type) {
         switch (type) {
@@ -55,8 +55,8 @@ export class InteropReturnTypeConvertor {
             case idl.IDLU64Type:
             case idl.IDLF16Type:
             case idl.IDLF32Type:
-            case idl.IDLF64Type:
-            case idl.IDLNumberType: return PrimitiveTypesInstance.Int32.getText();
+            case idl.IDLF64Type: return PrimitiveTypesInstance.Int32.getText();
+            case idl.IDLNumberType: return PrimitiveTypesInstance.Number.getText();
             case idl.IDLBooleanType: return PrimitiveTypesInstance.Boolean.getText();
             case idl.IDLBigintType: return PrimitiveTypesInstance.Int64.getText();
             case idl.IDLAnyType:
@@ -64,8 +64,8 @@ export class InteropReturnTypeConvertor {
             case idl.IDLThisType:
             case idl.IDLUndefinedType:
             case idl.IDLUnknownType:
-            case idl.IDLStringType:
             case idl.IDLVoidType: return idl.IDLVoidType.name;
+            case idl.IDLStringType: return PrimitiveTypesInstance.String.getText();
             case idl.IDLPointerType: return PrimitiveTypesInstance.NativePointer.getText();
         }
         throw new Error(`Cannot pass primitive type ${type.name} through interop`);
@@ -110,10 +110,12 @@ export class InteropArgConvertor {
     }
     convertPrimitiveType(type) {
         switch (type) {
+            case idl.IDLI64Type: return "KLong";
+            case idl.IDLU64Type: return "KLong";
             case idl.IDLI32Type: return "KInt";
             case idl.IDLF32Type: return "KFloat";
-            case idl.IDLNumberType: return 'number';
-            case idl.IDLBigintType: return 'bigint';
+            case idl.IDLNumberType: return 'number'; // should be removed! It is KInteropNumber or smth
+            case idl.IDLBigintType: return 'bigint'; // should be removed! It is KLong or smth
             case idl.IDLBooleanType:
             case idl.IDLFunctionType: return 'KInt';
             case idl.IDLStringType: return 'KStringPtr';
@@ -122,7 +124,7 @@ export class InteropArgConvertor {
             case idl.IDLDate: return 'KLong';
             case idl.IDLUndefinedType:
             case idl.IDLVoidType: return PrimitiveTypesInstance.NativePointer.getText();
-            case idl.IDLPointerType: return "KPointer"; //PrimitiveType.NativePointer.getText()
+            case idl.IDLPointerType: return 'KPointer'; // return PrimitiveTypesInstance.NativePointer.getText()
         }
         throw new Error(`Cannot pass primitive type ${type.name} through interop`);
     }

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

@@ -90,6 +90,7 @@ export declare class CJLanguageWriter extends LanguageWriter {
     writeMethodDeclaration(name: string, signature: MethodSignature, modifiers?: MethodModifier[]): void;
     writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
     writeProperty(propName: string, propType: idl.IDLType, mutable?: boolean, getterLambda?: (writer: this) => void, setterLambda?: (writer: this) => void): void;
+    writeTypeDeclaration(decl: idl.IDLTypedef): void;
     writeMethodImplementation(method: Method, op: (writer: this) => void): void;
     writeCJForeign(op: (writer: CJLanguageWriter) => void): void;
     private writeDeclaration;

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

@@ -373,6 +373,9 @@ export class CJLanguageWriter extends LanguageWriter {
         this.popIndent();
         this.print(`}`);
     }
+    writeTypeDeclaration(decl) {
+        throw new Error(`writeTypeDeclaration not implemented`);
+    }
     writeMethodImplementation(method, op) {
         this.writeDeclaration(method.name, method.signature, method.modifiers, " {");
         this.pushIndent();

package/build/lib/src/LanguageWriters/writers/CppLanguageWriter.d.ts

@@ -1,4 +1,4 @@
-import { IDLContainerType, IDLEnum, IDLNode, IDLType } from '../../idl';
+import { IDLContainerType, IDLEnum, IDLNode, IDLType, IDLTypedef } from '../../idl';
 import { ArgConvertor, BaseArgConvertor } from "../ArgConvertors";
 import { PrimitiveTypeList } from "../../peer-generation/PrimitiveType";
 import { AssignStatement, FieldModifier, LanguageExpression, LanguageStatement, LanguageWriter, MakeAssignOptions, MakeCastOptions, MakeRefOptions, Method, PrintHint, MethodModifier, MethodSignature, NamedMethodSignature, ObjectArgs } from "../LanguageWriter";
@@ -46,6 +46,7 @@ export declare class CppLanguageWriter extends CLikeLanguageWriter {
     writeFieldDeclaration(name: string, type: IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
     writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
     writeProperty(propName: string, propType: IDLType, mutable?: boolean): void;
+    writeTypeDeclaration(decl: IDLTypedef): void;
     /**
      * Writes multiline comments decorated with stars
      */

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

@@ -220,6 +220,9 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
     writeProperty(propName, propType, mutable = true) {
         throw new Error("writeProperty for c++ is not implemented yet.");
     }
+    writeTypeDeclaration(decl) {
+        throw new Error(`writeTypeDeclaration not implemented`);
+    }
     /**
      * Writes multiline comments decorated with stars
      */

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

@@ -54,7 +54,13 @@ class ArkTSMapForEachStatement {
         this.op = op;
     }
     write(writer) {
-        writer.print(`// TODO: map serialization not implemented`);
+        writer.print(`for (const pair of ${this.map}) {`);
+        writer.pushIndent();
+        writer.print(`const ${this.key} = pair[0]`);
+        writer.print(`const ${this.value} = pair[1]`);
+        this.op();
+        writer.popIndent();
+        writer.print(`}`);
     }
 }
 export class ArkTSEnumEntityStatement {
@@ -63,7 +69,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 +100,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 {

package/build/lib/src/LanguageWriters/writers/JavaLanguageWriter.d.ts

@@ -41,6 +41,7 @@ export declare class JavaLanguageWriter extends CLikeLanguageWriter {
     writeNativeMethodDeclaration(name: string, signature: MethodSignature): void;
     writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
     writeProperty(propName: string, propType: idl.IDLType): void;
+    writeTypeDeclaration(decl: idl.IDLTypedef): void;
     makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression, isDeclared?: boolean, isConst?: boolean): LanguageStatement;
     makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
     makeReturn(expr: LanguageExpression): LanguageStatement;

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

@@ -152,6 +152,9 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
     writeProperty(propName, propType) {
         throw new Error("writeProperty for Java is not implemented yet.");
     }
+    writeTypeDeclaration(decl) {
+        throw new Error(`Type declarations do not exist in Java, use something else`);
+    }
     makeAssign(variableName, type, expr, isDeclared = true, isConst = true) {
         return new JavaAssignStatement(variableName, type, expr, isDeclared, isConst);
     }

package/build/lib/src/LanguageWriters/writers/TsLanguageWriter.d.ts

@@ -54,6 +54,7 @@ export declare class TSLanguageWriter extends LanguageWriter {
     writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
     writeMethodImplementation(method: Method, op: (writer: this) => void): void;
     writeProperty(propName: string, propType: idl.IDLType): void;
+    writeTypeDeclaration(decl: idl.IDLTypedef): void;
     private writeDeclaration;
     makeNull(): LanguageExpression;
     makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression | undefined, isDeclared?: boolean, isConst?: boolean, options?: MakeAssignOptions): LanguageStatement;

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}` : '';
@@ -226,16 +234,22 @@ export class TSLanguageWriter extends LanguageWriter {
     writeProperty(propName, propType) {
         throw new Error("writeProperty for TS is not implemented yet.");
     }
+    writeTypeDeclaration(decl) {
+        var _a;
+        const type = this.getNodeName(decl.type);
+        const typeParams = ((_a = decl.typeParameters) === null || _a === void 0 ? void 0 : _a.length) ? `<${decl.typeParameters.join(",").replace("[]", "")}>` : "";
+        this.print(`export type ${decl.name}${typeParams} = ${type};`);
+    }
     writeDeclaration(name, signature, needReturn, needBracket, modifiers, generics) {
         var _a;
         let prefix = !modifiers ? undefined : this.supportedModifiers
             .filter(it => modifiers.includes(it))
             .map(it => this.mapMethodModifier(it)).join(" ");
         if (modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.GETTER)) {
-            prefix = `get ${prefix}`;
+            prefix = `${prefix} get`;
         }
         else if (modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.SETTER)) {
-            prefix = `set ${prefix}`;
+            prefix = `${prefix} set`;
             needReturn = false;
         }
         else if (modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.FREE)) {

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

@@ -1,5 +1,5 @@
 import { stringOrNone } from "../util";
-import { IDLCallback, IDLConstructor, IDLEntry, IDLEnum, IDLInterface, IDLMethod, IDLParameter, IDLProperty, IDLTypedef, IDLNamespace, IDLImport, IDLPackage, IDLReferenceType, IDLCallable, IDLConstant, SignatureTag, IDLVersion } from "../idl";
+import { IDLCallback, IDLConstructor, IDLEntry, IDLEnum, IDLInterface, IDLMethod, IDLParameter, IDLProperty, IDLTypedef, IDLNamespace, IDLFile, IDLImport, IDLReferenceType, IDLCallable, IDLConstant, SignatureTag, IDLVersion } from "../idl";
 import { Language } from "../Language";
 export declare class CustomPrintVisitor {
     private resolver;
@@ -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;
@@ -19,7 +19,7 @@ export declare class CustomPrintVisitor {
     printVersion(node: IDLVersion): void;
     printNamespace(node: IDLNamespace): void;
     printImport(node: IDLImport): void;
-    printPackage(node: IDLPackage): void;
+    printPackage(node: IDLFile): void;
     checkVerbatim(node: IDLEntry): void;
     private indent;
     indented(input: string): string;

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

@@ -13,10 +13,10 @@
  * limitations under the License.
  */
 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 { IDLEntity, IDLKind, getExtAttribute, getVerbatimDts, hasExtAttribute, isCallback, isConstructor, isContainerType, isEnum, isInterface, isMethod, isPrimitiveType, isProperty, isReferenceType, isSyntheticEntry, isTypeParameterType, isTypedef, isUnionType, isImport, isVersion, isNamespace, IDLExtendedAttributes, IDLAccessorAttribute, IDLVoidType, IDLStringType, IDLUndefinedType, isCallable, 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 { resolveSyntheticType, toIDLFile } from "./deserialize";
 import { Language } from "../Language";
+import { warn } from "../util";
 export class CustomPrintVisitor {
     constructor(resolver, language) {
         this.resolver = resolver;
@@ -39,9 +39,6 @@ export class CustomPrintVisitor {
         else if (isMethod(node) || isConstructor(node) || isCallable(node)) {
             this.printMethod(node);
         }
-        else if (isPackage(node)) {
-            this.printPackage(node);
-        }
         else if (isImport(node)) {
             this.printImport(node);
         }
@@ -102,12 +99,6 @@ export class CustomPrintVisitor {
             this.print(`${isInNamespace(node) ? "" : "declare "}type ${typeSpec} = ${this.literal(node, true, true)}`);
         }
         else {
-            // restore globalScope
-            if (hasExtAttribute(node, IDLExtendedAttributes.GlobalScope)) {
-                node.methods.map(it => this.printMethod(it, true));
-                node.constants.map(it => this.printConstant(it));
-                return;
-            }
             let interfaces = node.inheritance;
             let keyword = "extends";
             if (node.subkind === IDLInterfaceSubkind.Class) {
@@ -123,8 +114,8 @@ export class CustomPrintVisitor {
             this.currentInterface = node;
             this.pushIndent();
             node.constructors.map(it => this.visit(it));
-            node.properties.map(it => this.visit(it));
-            node.methods.map(it => this.visit(it));
+            node.properties.filter(it => !it.isStatic).map(it => this.visit(it));
+            node.methods.filter(it => !it.isStatic).map(it => this.visit(it));
             node.callables.map(it => this.visit(it));
             let verbatim = getVerbatimDts(node);
             if (verbatim) {
@@ -136,8 +127,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)
@@ -146,12 +136,14 @@ 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");
+            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 ? "?" : ""}`;
         }
@@ -209,7 +201,8 @@ export class CustomPrintVisitor {
             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
@@ -241,7 +234,7 @@ export class CustomPrintVisitor {
         this.print(`// import ${node.clause.join(".")}${node.name ? " as " : ""}${node.name || ""}`);
     }
     printPackage(node) {
-        this.print(`// package ${node.clause.join(".")}`);
+        this.print(`// package ${node.packageClause.join(".")}`);
     }
     checkVerbatim(node) {
         let verbatim = getExtAttribute(node, IDLExtendedAttributes.VerbatimDts);
@@ -350,10 +343,9 @@ export class CustomPrintVisitor {
 }
 export function idlToDtsString(name, content) {
     let printer = new CustomPrintVisitor(resolveSyntheticType, Language.TS);
-    webidl2.parse(content)
-        .filter(it => !!it.type)
-        .map(it => toIDLNode(name, it))
-        .forEach(it => {
+    const idlFile = toIDLFile(name, content);
+    printer.printPackage(idlFile);
+    idlFile.entries.forEach(it => {
         transformMethodsAsync2ReturnPromise(it);
         printer.visit(it);
     });

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

@@ -1,5 +1,5 @@
-import { IDLEntry } from "../idl";
+import { IDLFile } from "../idl";
 export declare function fromIDL(inputDirs: string | string[], inputFiles: string | string[] | undefined, outputDir: string, extension: string, verbose: boolean, transform: (name: string, content: string) => string): void;
-export declare function scanIDL(inputDir: string, inputFile: string | undefined): IDLEntry[][];
+export declare function scanIDL(inputDir: string, inputFile: string | undefined): IDLFile[];
 export declare const licence = "/*\n * Copyright (c) 2024 Huawei Device Co., Ltd.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n";
 //# sourceMappingURL=common.d.ts.map

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

@@ -14,8 +14,7 @@
  */
 import * as fs from "fs";
 import * as path from "path";
-import * as webidl2 from "webidl2";
-import { toIDLNode } from "./deserialize";
+import { toIDLFile } from "./deserialize";
 import { zip } from "../util";
 function getFilesRecursive(dirPath, arrayOfFiles = []) {
     let files = fs.readdirSync(dirPath);
@@ -66,12 +65,7 @@ export function scanIDL(inputDir, inputFile) {
         ? [path.join(inputDir, inputFile)]
         : fs.readdirSync(inputDir)
             .map((elem) => path.join(inputDir, elem));
-    return files
-        .map((file) => {
-        let content = fs.readFileSync(file).toString();
-        let parsed = webidl2.parse(content);
-        return parsed.filter(it => !!it.type).map(it => toIDLNode(file, it));
-    });
+    return files.map(it => toIDLFile(it));
 }
 export const licence = `/*
  * Copyright (c) 2024 Huawei Device Co., Ltd.

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

@@ -1,8 +1,5 @@
-import * as webidl2 from "webidl2";
 import * as idl from "../idl";
 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): idl.IDLFile;
+export declare function toIDLFile(fileName: string, content?: string): idl.IDLFile;
 //# sourceMappingURL=deserialize.d.ts.map