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

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

@@ -3,7 +3,6 @@ export declare class Language {
     extension: string;
     static TS: Language;
     static ARKTS: Language;
-    static JAVA: Language;
     static CPP: Language;
     static CJ: Language;
     static KOTLIN: Language;

package/build/lib/src/Language.js

@@ -26,7 +26,6 @@ export class Language {
     static fromString(name) {
         switch (name) {
             case "arkts": return Language.ARKTS;
-            case "java": return Language.JAVA;
             case "ts": return Language.TS;
             case "cangjie": return Language.CJ;
             case "cpp": return Language.CPP;
@@ -37,7 +36,6 @@ export class Language {
 }
 Language.TS = new Language("TS", ".ts");
 Language.ARKTS = new Language("ArkTS", ".ts"); // using .ts for ArkTS until we get rit of tsc preprocessing
-Language.JAVA = new Language("Java", ".java");
 Language.CPP = new Language("C++", ".cc");
 Language.CJ = new Language("CangJie", ".cj");
 Language.KOTLIN = new Language("Kotlin", ".kt");

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

@@ -6,7 +6,7 @@ import { LibraryInterface } from "../LibraryInterface";
 import { ReferenceResolver } from "../peer-generation/ReferenceResolver";
 import { PeerLibrary } from "../peer-generation/PeerLibrary";
 import { PeerMethodSignature } from "../peer-generation/PeerMethod";
-export declare function getSerializerName(declaration: idl.IDLEntry): string;
+export declare function getSerializerName(library: LibraryInterface, language: Language, declaration: idl.IDLEntry): string;
 export interface ArgConvertor {
     param: string;
     idlType: idl.IDLType;
@@ -106,8 +106,9 @@ export declare class NumberConvertor extends BaseArgConvertor {
     isPointerType(): boolean;
 }
 export declare class NumericConvertor extends BaseArgConvertor {
+    protected library: LibraryInterface;
     private readonly interopNameConvertor;
-    constructor(param: string, type: idl.IDLPrimitiveType);
+    constructor(library: LibraryInterface, param: string, type: idl.IDLPrimitiveType);
     convertorArg(param: string, writer: LanguageWriter): string;
     convertorSerialize(param: string, value: string, writer: LanguageWriter): LanguageStatement;
     convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;

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

@@ -20,14 +20,15 @@ import { generatorConfiguration, generatorTypePrefix } from "../config";
 import { capitalize, getExtractor, getTransformer, hashCodeFromString, throwException, warn } from "../util";
 import { UnionRuntimeTypeChecker } from "../peer-generation/unions";
 import { CppConvertor, CppNameConvertor } from "./convertors/CppConvertors";
-import { createEmptyReferenceResolver } from "../peer-generation/ReferenceResolver";
 import { PrimitiveTypesInstance } from "../peer-generation/PrimitiveType";
-import { qualifiedName } from "../peer-generation/idl/common";
 import { LayoutNodeRole } from "../peer-generation/LayoutManager";
 import { PeerMethodSignature } from "../peer-generation/PeerMethod";
 import { isInExternalModule } from "../peer-generation/modules";
-export function getSerializerName(declaration) {
-    return `${idl.getQualifiedName(declaration, "namespace.name").split('.').join('_')}_serializer`;
+import { isTopLevelConflicted } from "../peer-generation/ConflictingDeclarations";
+export function getSerializerName(library, language, declaration) {
+    const qualifier = isTopLevelConflicted(library, language, declaration)
+        ? "package.namespace.name" : "namespace.name";
+    return `${idl.getQualifiedName(declaration, qualifier).split('.').join('_')}_serializer`;
 }
 export function isDirectConvertedType(originalType, library) {
     const debug = false;
@@ -298,10 +299,11 @@ export class NumberConvertor extends BaseArgConvertor {
     }
 }
 export class NumericConvertor extends BaseArgConvertor {
-    constructor(param, type) {
+    constructor(library, param, type) {
         // check numericPrimitiveTypes.include(type)
         super(type, [RuntimeType.NUMBER], false, false, param);
-        this.interopNameConvertor = new CppNameConvertor(createEmptyReferenceResolver());
+        this.library = library;
+        this.interopNameConvertor = new CppNameConvertor(this.library);
     }
     convertorArg(param, writer) {
         return param;
@@ -577,12 +579,12 @@ export class InterfaceConvertor extends BaseArgConvertor {
         throw new Error("Must never be used");
     }
     convertorSerialize(param, value, writer) {
-        const accessor = getSerializerName(this.declaration);
+        const accessor = getSerializerName(this.library, writer.language, this.declaration);
         writer.addFeature(accessor, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
         return writer.makeStatement(writer.makeStaticMethodCall(accessor, 'write', [writer.makeString(`${param}Serializer`), writer.makeString(writer.escapeKeyword(value))]));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
-        const accessor = getSerializerName(this.declaration);
+        const accessor = getSerializerName(this.library, writer.language, this.declaration);
         writer.addFeature(accessor, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
         return assigneer(writer.makeStaticMethodCall(accessor, 'read', [writer.makeString(deserializerName)]));
     }
@@ -888,7 +890,7 @@ export class OptionConvertor extends BaseArgConvertor {
         const bufferType = this.nativeType();
         statements.push(writer.makeAssign(bufferName, bufferType, writer.language === Language.CPP ? undefined : writer.makeNull(this.type), true, false)); // maybe change to generic None
         const thenStatement = new BlockStatement([
-            this.typeConvertor.convertorDeserialize(`${bufferName}_`, deserializerName, (expr) => {
+            this.typeConvertor.convertorDeserialize(`${bufferName}Opt`, deserializerName, (expr) => {
                 const receiver = writer.language === Language.CPP
                     ? `${bufferName}.value` : bufferName;
                 return writer.makeAssign(receiver, undefined, expr, false);
@@ -1018,10 +1020,10 @@ export class MaterializedClassConvertor extends BaseArgConvertor {
         this.declaration = declaration;
     }
     convertorArg(param, writer) {
+        const nameConvertor = this.library.createTypeNameConvertor(Language.CPP);
         switch (writer.language) {
             case Language.CPP:
-                return `static_cast<${generatorTypePrefix()}${qualifiedName(this.declaration, "_", "namespace.name")}>(${param})`;
-            case Language.JAVA:
+                return `static_cast<${nameConvertor.convert(this.declaration)}>(${param})`;
             case Language.CJ:
                 return `MaterializedBase.toPeerPtr(${writer.escapeKeyword(param)})`;
             default:
@@ -1033,12 +1035,12 @@ export class MaterializedClassConvertor extends BaseArgConvertor {
         }
     }
     convertorSerialize(param, value, printer) {
-        const accessorRoot = getSerializerName(this.declaration);
+        const accessorRoot = getSerializerName(this.library, printer.language, this.declaration);
         printer.addFeature(accessorRoot, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
         return printer.makeStatement(printer.makeStaticMethodCall(accessorRoot, 'write', [printer.makeString(`${param}Serializer`), printer.makeString(value)]));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
-        const accessorRoot = getSerializerName(this.declaration);
+        const accessorRoot = getSerializerName(this.library, writer.language, this.declaration);
         writer.addFeature(accessorRoot, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
         const readStatement = writer.makeCast(writer.makeStaticMethodCall(accessorRoot, "read", [writer.makeString(deserializerName)]), this.declaration);
         return assigneer(readStatement);
@@ -1115,8 +1117,10 @@ export class CallbackConvertor extends BaseArgConvertor {
                 writer.makeStatement(writer.makeMethodCall(`${param}Serializer`, "writePointer", [writer.makeCast(new StringExpression(`${value}.callSync`), idl.IDLPointerType, { unsafe: true })]))
             ], false);
         }
-        if (this.isTransformed)
-            value = `CallbackTransformer.transformFrom${this.library.getInteropName(this.decl)}(${value})`;
+        if (this.isTransformed) {
+            const convertor = this.library.createTypeNameConvertor(Language.CPP);
+            value = `CallbackTransformer.transformFrom${convertor.convert(this.decl)}(${value})`;
+        }
         return writer.makeStatement(writer.makeMethodCall(`${param}Serializer`, `holdAndWriteCallback`, [writer.makeString(`${value}`)]));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer, useSyncVersion = true) {
@@ -1221,7 +1225,7 @@ function warnCustomObject(type, msg) {
 }
 export const CallbackKind = "CallbackKind";
 export function generateCallbackKindName(callback) {
-    return `Kind_${callback.name}`;
+    return `KIND_${callback.name.toUpperCase()}`;
 }
 export function generateCallbackKindAccess(callback, language) {
     const name = generateCallbackKindName(callback);

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

@@ -146,7 +146,9 @@ export declare enum FieldModifier {
     FINAL = 5,
     VOLATILE = 6,
     INTERNAL = 7,
-    OVERRIDE = 8
+    OVERRIDE = 8,
+    GET = 9,
+    SET = 10
 }
 export declare enum MethodModifier {
     PUBLIC = 0,
@@ -254,6 +256,7 @@ export declare abstract class LanguageWriter {
     })[];
     addFeature(node: idl.IDLEntry | idl.IDLReferenceType): void;
     addFeature(feature: string, module: string): void;
+    abstract get interopModule(): string;
     abstract writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[], generics?: string[], isDeclared?: boolean, isExport?: boolean): void;
     abstract writeEnum(name: string, members: {
         name: string;
@@ -280,6 +283,7 @@ export declare abstract class LanguageWriter {
     }, initExpr?: LanguageExpression): void;
     abstract writeTypeDeclaration(decl: idl.IDLTypedef): void;
     abstract writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
+    abstract writeImports(moduleName: string, importedFeatures: string[], aliases: string[]): 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

@@ -307,6 +307,8 @@ export var FieldModifier;
     FieldModifier[FieldModifier["VOLATILE"] = 6] = "VOLATILE";
     FieldModifier[FieldModifier["INTERNAL"] = 7] = "INTERNAL";
     FieldModifier[FieldModifier["OVERRIDE"] = 8] = "OVERRIDE";
+    FieldModifier[FieldModifier["GET"] = 9] = "GET";
+    FieldModifier[FieldModifier["SET"] = 10] = "SET";
 })(FieldModifier || (FieldModifier = {}));
 export var MethodModifier;
 (function (MethodModifier) {

package/build/lib/src/LanguageWriters/convertors/CJConvertors.d.ts

@@ -32,5 +32,4 @@ export declare class CJIDLTypeToForeignStringConvertor extends CJTypeNameConvert
 export declare class CJInteropArgConvertor extends InteropArgConvertor {
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
 }
-export declare function removePoints(s: string): string;
 //# sourceMappingURL=CJConvertors.d.ts.map

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

@@ -15,6 +15,7 @@
 import * as idl from '../../idl';
 import { CJKeywords } from '../../languageSpecificKeywords';
 import { generateSyntheticIdlNodeName } from '../../peer-generation/idl/common';
+import { removePoints } from '../../util';
 import { convertNode, convertType } from '../nameConvertor';
 import { InteropArgConvertor } from './InteropConvertors';
 export class CJTypeNameConvertor {
@@ -199,7 +200,4 @@ export class CJInteropArgConvertor extends InteropArgConvertor {
         return super.convertPrimitiveType(type);
     }
 }
-export function removePoints(s) {
-    return s.split(/[\.\-]/g).join('_');
-}
 //# sourceMappingURL=CJConvertors.js.map

package/build/lib/src/LanguageWriters/convertors/CppConvertors.d.ts

@@ -1,15 +1,15 @@
 import * as idl from '../../idl';
 import { IdlNameConvertor, NodeConvertor, TypeConvertor } from "../nameConvertor";
 import { InteropArgConvertor } from './InteropConvertors';
-import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
+import { LibraryInterface } from '../../LibraryInterface';
 export interface ConvertResult {
     text: string;
     noPrefix: boolean;
     resolvedType: idl.IDLType;
 }
 export declare class GenericCppConvertor implements NodeConvertor<ConvertResult> {
-    protected resolver: ReferenceResolver;
-    constructor(resolver: ReferenceResolver);
+    protected library: LibraryInterface;
+    constructor(library: LibraryInterface);
     private make;
     convertNode(node: idl.IDLNode): ConvertResult;
     convertNamespace(node: idl.IDLNamespace): ConvertResult;
@@ -36,9 +36,9 @@ export declare class CppConvertor extends GenericCppConvertor implements IdlName
     convert(node: idl.IDLNode): string;
 }
 export declare class CppNameConvertor implements IdlNameConvertor {
-    protected resolver: ReferenceResolver;
+    protected library: LibraryInterface;
     private readonly cppConvertor;
-    constructor(resolver: ReferenceResolver);
+    constructor(library: LibraryInterface);
     convert(node: idl.IDLNode): string;
 }
 export declare class CppInteropArgConvertor extends InteropArgConvertor {
@@ -47,9 +47,9 @@ export declare class CppInteropArgConvertor extends InteropArgConvertor {
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
 }
 export declare class CppReturnTypeConvertor implements TypeConvertor<string> {
-    private resolver;
+    private library;
     private convertor;
-    constructor(resolver: ReferenceResolver);
+    constructor(library: LibraryInterface);
     isVoid(returnType: idl.IDLType): boolean;
     convert(type: idl.IDLType): string;
     convertContainer(type: idl.IDLContainerType): string;

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

@@ -13,18 +13,30 @@
  * limitations under the License.
  */
 import * as idl from '../../idl';
-import { generatorConfiguration, generatorTypePrefix } from "../../config";
+import { generatorConfiguration } from "../../config";
 import { convertNode, convertType } from "../nameConvertor";
 import { PrimitiveTypesInstance } from '../../peer-generation/PrimitiveType';
 import { InteropArgConvertor } from './InteropConvertors';
 import { maybeTransformManagedCallback } from '../ArgConvertors';
 import { qualifiedName } from '../../peer-generation/idl/common';
-import { capitalize } from '../../util';
-import { isMaterialized } from '../../peer-generation/isMaterialized';
-import { isInIdlizeInternal } from '../../idlize';
+import { isInIdlizeInternal } from '../../idl';
+import { isTopLevelConflicted } from '../../peer-generation/ConflictingDeclarations';
+import { Language } from '../../Language';
+function isSubtypeTopLevelConflicted(library, node) {
+    let hasConflicts = false;
+    idl.forEachChild(node, (child) => {
+        if (idl.isReferenceType(child)) {
+            const decl = library.resolveTypeReference(child);
+            if (decl) {
+                hasConflicts || (hasConflicts = isTopLevelConflicted(library, Language.CPP, decl));
+            }
+        }
+    });
+    return hasConflicts;
+}
 export class GenericCppConvertor {
-    constructor(resolver) {
-        this.resolver = resolver;
+    constructor(library) {
+        this.library = library;
     }
     make(text, resolvedType, noPrefix = false) {
         return { text, noPrefix, resolvedType };
@@ -78,6 +90,12 @@ export class GenericCppConvertor {
         return this.make(prefix + converted.text, type, true);
     }
     convertUnion(type) {
+        if (isSubtypeTopLevelConflicted(this.library, type)) {
+            if (type.parent && idl.isTypedef(type.parent)) {
+                return this.make(type.parent.name, type, false);
+            }
+            return this.make('Union_' + type.types.map(it => convertType(this, it).text).join("_"), type, false);
+        }
         return this.make(type.name, type, false);
     }
     convertContainer(type) {
@@ -108,14 +126,11 @@ export class GenericCppConvertor {
         if (generatorConfiguration().parameterized.includes(refName)) {
             return this.make('CustomObject', idl.IDLCustomObjectType);
         }
-        let decl = this.resolver.toDeclaration(type);
+        let decl = this.library.toDeclaration(type);
         if (idl.isCallback(decl)) {
-            decl = (_a = maybeTransformManagedCallback(decl, this.resolver)) !== null && _a !== void 0 ? _a : decl;
+            decl = (_a = maybeTransformManagedCallback(decl, this.library)) !== null && _a !== void 0 ? _a : decl;
         }
         if (idl.isType(decl)) {
-            if (idl.isReferenceType(decl)) {
-                return this.make(`${capitalize(decl.name)}`, decl);
-            }
             return this.convertNode(decl);
         }
         let res = this.convertNode(decl);
@@ -159,6 +174,9 @@ export class GenericCppConvertor {
         throw new Error(`Unmapped primitive type ${idl.DebugUtils.debugPrintType(type)}`);
     }
     qualifiedName(target) {
+        if (idl.isEntry(target) && isTopLevelConflicted(this.library, Language.CPP, target)) {
+            return qualifiedName(target, "_", "package.namespace.name");
+        }
         return qualifiedName(target, "_", "namespace.name");
     }
     computeTargetTypeLiteralName(decl) {
@@ -188,10 +206,10 @@ export class CppConvertor extends GenericCppConvertor {
     isPrimitiveOrPrimitiveAlias(type) {
         if (!idl.isType(type))
             return false;
-        const { resolver } = this;
+        const { library } = this;
         const seen = new Set;
         while (type && idl.isReferenceType(type)) {
-            const resolved = resolver.resolveTypeReference(type);
+            const resolved = library.resolveTypeReference(type);
             if (!resolved)
                 return false;
             if (!idl.isTypedef(resolved))
@@ -208,9 +226,9 @@ export class CppConvertor extends GenericCppConvertor {
     }
 }
 export class CppNameConvertor {
-    constructor(resolver) {
-        this.resolver = resolver;
-        this.cppConvertor = new GenericCppConvertor(resolver);
+    constructor(library) {
+        this.library = library;
+        this.cppConvertor = new GenericCppConvertor(library);
     }
     convert(node) {
         return this.cppConvertor.convertNode(node).text;
@@ -236,9 +254,9 @@ export class CppInteropArgConvertor extends InteropArgConvertor {
 }
 CppInteropArgConvertor.INSTANCE = new CppInteropArgConvertor();
 export class CppReturnTypeConvertor {
-    constructor(resolver) {
-        this.resolver = resolver;
-        this.convertor = new CppConvertor(resolver);
+    constructor(library) {
+        this.library = library;
+        this.convertor = new CppConvertor(library);
     }
     isVoid(returnType) {
         return this.convert(returnType) == 'void';
@@ -271,10 +289,6 @@ export class CppReturnTypeConvertor {
         return this.convertor.convert(type);
     }
     convertTypeReference(type) {
-        const decl = this.resolver.resolveTypeReference(type);
-        if (decl && idl.isInterface(decl) && isMaterialized(decl, this.resolver)) {
-            return generatorTypePrefix() + qualifiedName(decl, "_", "namespace.name");
-        }
         return this.convertor.convert(type);
     }
     convertUnion(type) {

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

@@ -16,7 +16,7 @@ import * as idl from '../../idl';
 import { generateSyntheticIdlNodeName } from '../../peer-generation/idl/common';
 import { isMaterialized } from '../../peer-generation/isMaterialized';
 import { convertNode, convertType } from '../nameConvertor';
-import { removePoints } from './CJConvertors';
+import { removePoints } from '../../util';
 import { InteropReturnTypeConvertor } from './InteropConvertors';
 export class KotlinTypeNameConvertor {
     constructor(resolver) {
@@ -55,6 +55,11 @@ export class KotlinTypeNameConvertor {
     }
     convertContainer(type) {
         if (idl.IDLContainerUtils.isSequence(type)) {
+            switch (type.elementType[0]) {
+                case idl.IDLU8Type: return "UByteArray";
+                case idl.IDLI32Type: return "IntArray";
+                case idl.IDLF32Type: return "FloatArray";
+            }
             return `ArrayList<${convertType(this, type.elementType[0])}>`;
         }
         if (idl.IDLContainerUtils.isRecord(type)) {
@@ -93,7 +98,7 @@ export class KotlinTypeNameConvertor {
             case idl.IDLUnknownType:
             case idl.IDLCustomObjectType: return 'Any';
             case idl.IDLThisType: return 'this';
-            case idl.IDLObjectType: return 'Object';
+            case idl.IDLObjectType: return 'Any';
             case idl.IDLAnyType: return 'Any';
             case idl.IDLUndefinedType: return 'Nothing?';
             case idl.IDLPointerType: return 'KPointer';
@@ -135,7 +140,6 @@ const KLong = "KLong";
 const KFloat = "KFloat";
 const KDouble = "KDouble";
 const KNativePointer = "KNativePointer";
-const KInteropNumber = "KInteropNumber";
 const KStringPtr = "KStringPtr";
 const KInteropReturnBuffer = "KInteropReturnBuffer";
 const KInteropBuffer = "KInteropBuffer";
@@ -154,7 +158,7 @@ export class KotlinCInteropReturnTypeConvertor extends InteropReturnTypeConverto
             case idl.IDLF16Type:
             case idl.IDLF32Type:
             case idl.IDLF64Type: return KInt;
-            case idl.IDLNumberType: return KInteropNumber;
+            case idl.IDLNumberType: return KDouble;
             case idl.IDLBooleanType: return KBoolean;
             case idl.IDLBigintType: return KLong;
             case idl.IDLAnyType:
@@ -218,7 +222,7 @@ export class KotlinCInteropArgConvertor {
             case idl.IDLU32Type: return KInt;
             case idl.IDLF32Type: return KFloat;
             case idl.IDLF64Type: return KDouble;
-            case idl.IDLNumberType: return KInteropNumber;
+            case idl.IDLNumberType: return KDouble;
             case idl.IDLBigintType: return KLong;
             case idl.IDLSerializerBuffer: return KSerializerBuffer;
             case idl.IDLBooleanType:

package/build/lib/src/LanguageWriters/convertors/TSConvertors.d.ts

@@ -1,9 +1,10 @@
 import * as idl from '../../idl';
-import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
+import { LibraryInterface } from '../../LibraryInterface';
 import { IdlNameConvertor, NodeConvertor, TypeConvertor } from '../nameConvertor';
 export declare class TSTypeNameConvertor implements NodeConvertor<string>, IdlNameConvertor {
-    protected resolver: ReferenceResolver;
-    constructor(resolver: ReferenceResolver);
+    protected library: LibraryInterface;
+    constructor(library: LibraryInterface);
+    protected mangleTopLevel(decl: idl.IDLEntry): string | undefined;
     convert(node: idl.IDLNode): string;
     convertNamespace(node: idl.IDLNamespace): string;
     convertInterface(node: idl.IDLInterface): string;
@@ -22,7 +23,6 @@ export declare class TSTypeNameConvertor implements NodeConvertor<string>, IdlNa
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
     protected processTupleType(idlProperty: idl.IDLProperty): idl.IDLProperty;
     protected createTypeSubstitution(parameters: string[] | undefined, args: idl.IDLType[] | undefined): Map<string, idl.IDLType>;
-    protected applySubstitution(subst: Map<string, idl.IDLType>, type: idl.IDLType): idl.IDLType;
     protected mapCallback(decl: idl.IDLCallback, args?: idl.IDLType[]): string;
     protected productType(decl: idl.IDLInterface, args: idl.IDLType[] | undefined, isTuple: boolean, includeFieldNames: boolean): string;
     protected mapFunctionType(typeArgs: string[]): string;

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

@@ -13,11 +13,26 @@
  * limitations under the License.
  */
 import * as idl from '../../idl';
+import { Language } from '../../Language';
+import { isTopLevelConflicted } from '../../peer-generation/ConflictingDeclarations';
+import { isDeclaredInCurrentFile, LayoutNodeRole } from '../../peer-generation/LayoutManager';
 import { maybeRestoreGenerics } from '../../transformers/GenericTransformer';
 import { convertNode, convertType } from '../nameConvertor';
 export class TSTypeNameConvertor {
-    constructor(resolver) {
-        this.resolver = resolver;
+    constructor(library) {
+        this.library = library;
+    }
+    mangleTopLevel(decl) {
+        if (!isDeclaredInCurrentFile(this.library.layout, { node: decl, role: LayoutNodeRole.INTERFACE }) && isTopLevelConflicted(this.library, Language.TS, decl)) {
+            const namespaces = idl.getNamespacesPathFor(decl);
+            if (namespaces.length === 0) {
+                return idl.getQualifiedName(decl, "package.namespace.name").replaceAll('.', '_');
+            }
+            const [rootNamespace, ...otherNamespaces] = idl.getNamespacesPathFor(decl);
+            const mangledRoot = idl.getQualifiedName(rootNamespace, "package.namespace.name").replaceAll('.', '_');
+            return [mangledRoot, ...otherNamespaces, decl.name].join(".");
+        }
+        return undefined;
     }
     convert(node) {
         return convertNode(this, node);
@@ -26,18 +41,22 @@ export class TSTypeNameConvertor {
         return node.name;
     }
     convertInterface(node) {
-        return idl.getQualifiedName(node, "namespace.name");
+        var _a;
+        return (_a = this.mangleTopLevel(node)) !== null && _a !== void 0 ? _a : idl.getQualifiedName(node, "namespace.name");
     }
     convertEnum(node) {
-        return idl.getQualifiedName(node, "namespace.name");
+        var _a;
+        return (_a = this.mangleTopLevel(node)) !== null && _a !== void 0 ? _a : idl.getQualifiedName(node, "namespace.name");
     }
     convertTypedef(node) {
-        return node.name;
+        var _a;
+        return (_a = this.mangleTopLevel(node)) !== null && _a !== void 0 ? _a : idl.getQualifiedName(node, "namespace.name");
     }
     convertCallback(node) {
+        var _a;
         return idl.isSyntheticEntry(node)
             ? this.mapCallback(node)
-            : node.name;
+            : (_a = this.mangleTopLevel(node)) !== null && _a !== void 0 ? _a : node.name;
     }
     convertMethod(node) {
         return node.name;
@@ -90,14 +109,14 @@ export class TSTypeNameConvertor {
     convertTypeReferenceAsImport(type, importClause) {
         var _a;
         const maybeTypeArguments = ((_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.length) ? `<${type.typeArguments.join(', ')}>` : "";
-        let decl = this.resolver.resolveTypeReference(type);
+        let decl = this.library.resolveTypeReference(type);
         if (decl)
             return `${decl.name}${maybeTypeArguments}`;
         return `${type.name}${maybeTypeArguments}`;
     }
     convertTypeReference(type) {
-        var _a, _b;
-        let decl = this.resolver.resolveTypeReference(type);
+        var _a, _b, _c;
+        let decl = this.library.resolveTypeReference(type);
         if (decl) {
             if (idl.isSyntheticEntry(decl)) {
                 if (idl.isCallback(decl)) {
@@ -116,10 +135,10 @@ export class TSTypeNameConvertor {
                 // (can not cast MyEnum to exact MyEnum.Value1)
                 decl = decl.parent;
             }
-            let maybeRestoredGeneric = maybeRestoreGenerics(type, this.resolver);
+            let maybeRestoredGeneric = maybeRestoreGenerics(type, this.library);
             if (maybeRestoredGeneric) {
                 type = maybeRestoredGeneric;
-                decl = this.resolver.resolveTypeReference(maybeRestoredGeneric);
+                decl = this.library.resolveTypeReference(maybeRestoredGeneric);
             }
             let typeSpec = type.name;
             let typeArgs = (_b = (_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => this.convert(it))) !== null && _b !== void 0 ? _b : [];
@@ -131,7 +150,7 @@ export class TSTypeNameConvertor {
             if (decl) {
                 const path = idl.getNamespacesPathFor(decl).map(it => it.name);
                 path.push(decl.name);
-                return `${path.join(".")}${maybeTypeArguments}`;
+                return `${(_c = this.mangleTopLevel(decl)) !== null && _c !== void 0 ? _c : path.join(".")}${maybeTypeArguments}`;
             }
             return `${type.name}${maybeTypeArguments}`;
         }
@@ -192,27 +211,16 @@ export class TSTypeNameConvertor {
         }
         return subst;
     }
-    applySubstitution(subst, type) {
-        var _a;
-        if (idl.isContainerType(type)) {
-            return idl.createContainerType(type.containerKind, type.elementType.map(it => this.applySubstitution(subst, it)));
-        }
-        if (idl.isReferenceType(type)) {
-            return idl.createReferenceType(type.name, (_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => this.applySubstitution(subst, it)));
-        }
-        if (idl.isTypeParameterType(type)) {
-            const record = subst.get(type.name);
-            if (record) {
-                return record;
-            }
-        }
-        return type;
-    }
     mapCallback(decl, args) {
         const subst = this.createTypeSubstitution(decl.typeParameters, args);
         const parameters = decl.parameters.map(it => {
+            if (subst.size == 0)
+                return it;
             const param = idl.clone(it);
-            param.type = this.applySubstitution(subst, param.type);
+            param.parent = it.parent;
+            const type = applySubstitution(subst, param.type);
+            updateParent(param, type);
+            param.type = type;
             return param;
         });
         const params = parameters.map(it => `${it.isVariadic ? "..." : ""}${it.name}${it.isOptional ? "?" : ""}: ${this.convert(it.type)}${it.isVariadic ? "[]" : ""}`);
@@ -223,8 +231,13 @@ export class TSTypeNameConvertor {
         const name = `${isTuple ? "[" : "{"} ${decl.properties
             .map(it => isTuple ? this.processTupleType(it) : it)
             .map(it => {
+            if (subst.size == 0)
+                return it;
             const prop = idl.clone(it);
-            prop.type = this.applySubstitution(subst, prop.type);
+            prop.parent = it.parent;
+            const type = applySubstitution(subst, prop.type);
+            updateParent(prop, type);
+            prop.type = type;
             return prop;
         })
             .map(it => {
@@ -287,4 +300,34 @@ export class TSInteropArgConvertor {
         throw new Error("Cannot pass union types through interop");
     }
 }
+function applySubstitution(subst, type) {
+    var _a;
+    if (idl.isContainerType(type)) {
+        return idl.createContainerType(type.containerKind, type.elementType.map(it => applySubstitution(subst, it)));
+    }
+    if (idl.isReferenceType(type)) {
+        return idl.createReferenceType(type.name, (_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => applySubstitution(subst, it)));
+    }
+    if (idl.isTypeParameterType(type)) {
+        const record = subst.get(type.name);
+        if (record) {
+            return record;
+        }
+    }
+    return type;
+}
+// Update parents to properly find a file for conflicted types
+function updateParent(parent, type) {
+    type.parent = parent;
+    if (idl.isOptionalType(type))
+        updateParent(type, type.type);
+    if (idl.isUnionType(type))
+        updateParents(type, type.types);
+    if (idl.isContainerType(type))
+        updateParents(type, type.elementType);
+}
+function updateParents(parent, types) {
+    for (const type of types)
+        updateParent(parent, type);
+}
 //# sourceMappingURL=TSConvertors.js.map

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

@@ -1,8 +1,8 @@
 import { Language } from "../Language";
-import { ReferenceResolver } from "../peer-generation/ReferenceResolver";
+import { LibraryInterface } from "../LibraryInterface";
 import { LanguageWriter } from "./LanguageWriter";
 import { TypeConvertor } from "./nameConvertor";
 export * from "./nameConvertor";
-export declare function createLanguageWriter(language: Language, resolver?: ReferenceResolver): LanguageWriter;
+export declare function createLanguageWriter(language: Language, library: LibraryInterface): LanguageWriter;
 export declare function createInteropArgConvertor(language: Language): TypeConvertor<string>;
 //# sourceMappingURL=index.d.ts.map