@idlizer/core 2.0.26 → 2.0.27

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

@@ -236,7 +236,7 @@ export declare class TypeAliasConvertor extends ProxyConvertor {
 export declare class CustomTypeConvertor extends BaseArgConvertor {
     readonly customTypeName: string;
     private readonly isGenericType;
-    constructor(param: string, customTypeName: string, isGenericType?: boolean, tsType?: string);
+    constructor(param: string, customTypeName: string, isGenericType: boolean, tsType: string);
     convertorArg(param: string, writer: LanguageWriter): string;
     /** todo: check */
     convertorSerialize(param: string, value: string, printer: LanguageWriter): void;

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

@@ -19,9 +19,9 @@ import { RuntimeType } from "./common";
 import { generatorTypePrefix } from "../config";
 import { hashCodeFromString, warn } from "../util";
 import { UnionRuntimeTypeChecker } from "../peer-generation/unions";
-import { InteropNameConvertor } from "./convertors/InteropConvertors";
+import { CppNameConvertor } from "./convertors/CppConvertors";
 import { createEmptyReferenceResolver } from "../peer-generation/ReferenceResolver";
-import { CppInteropConvertor } from "./convertors/CppConvertors";
+import { CppConvertor } from "./convertors/CppConvertors";
 import { PrimitiveTypesInstance } from "../peer-generation/PrimitiveType";
 export class BaseArgConvertor {
     constructor(idlType, runtimeTypes, isScoped, useArray, param) {
@@ -221,7 +221,7 @@ export class NumericConvertor extends BaseArgConvertor {
     constructor(param, type) {
         // check numericPrimitiveTypes.include(type)
         super(type, [RuntimeType.NUMBER], false, false, param);
-        this.interopNameConvertor = new InteropNameConvertor(createEmptyReferenceResolver());
+        this.interopNameConvertor = new CppNameConvertor(createEmptyReferenceResolver());
     }
     convertorArg(param, writer) {
         return param;
@@ -672,11 +672,11 @@ export class TypeAliasConvertor extends ProxyConvertor {
     }
 }
 export class CustomTypeConvertor extends BaseArgConvertor {
-    constructor(param, customTypeName, isGenericType = false, tsType) {
+    constructor(param, customTypeName, isGenericType, tsType) {
         super(idl.createReferenceType(tsType !== null && tsType !== void 0 ? tsType : "Object"), [RuntimeType.OBJECT], false, true, param);
         this.customTypeName = customTypeName;
         this.isGenericType = isGenericType;
-        warnCustomObject(`${tsType}`);
+        warnCustomObject(`${customTypeName}: ${tsType}`);
     }
     convertorArg(param, writer) {
         throw new Error("Must never be used");
@@ -811,7 +811,7 @@ export class UnionConvertor extends BaseArgConvertor {
             printer.popIndent();
             printer.print(`}`);
         });
-        this.unionChecker.reportConflicts((_a = this.library.getCurrentContext()) !== null && _a !== void 0 ? _a : "<unknown context>");
+        this.unionChecker.reportConflicts((_a = this.library.getCurrentContext()) !== null && _a !== void 0 ? _a : "<unknown context>", printer);
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
         const statements = [];
@@ -1028,7 +1028,7 @@ export function generateCallbackKindValue(callback) {
     return hashCodeFromString(name);
 }
 export function generateCallbackAPIArguments(library, callback) {
-    const nameConvertor = new CppInteropConvertor(library);
+    const nameConvertor = new CppConvertor(library);
     const args = [`const ${PrimitiveTypesInstance.Int32.getText()} resourceId`];
     args.push(...callback.parameters.map(it => {
         const target = library.toDeclaration(it.type);

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

@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 import * as idl from "../idl";
+import { indentedBy } from "../util";
 import * as fs from "fs";
 import { RuntimeType } from "./common";
 export class TernaryExpression {
@@ -31,6 +32,8 @@ export class NaryOpExpression {
         this.args = args;
     }
     asString() {
+        if (this.args.length === 1)
+            return this.args[0].asString();
         return `${this.args.map(arg => `(${arg.asString()})`).join(` ${this.op} `)}`;
     }
 }
@@ -275,16 +278,17 @@ export class LambdaExpression {
         this.body = body;
     }
     bodyAsString() {
+        var _a;
         const writer = this.originalWriter.fork();
         if (this.body) {
             for (const stmt of this.body) {
                 stmt.write(writer);
             }
         }
-        return writer.getOutput()
+        return (this.body ? ((_a = this.body) === null || _a === void 0 ? void 0 : _a.length) > 1 ? '\n' : '' : '').concat(writer.getOutput()
             .filter(line => line !== "")
-            .map(line => line.endsWith('{') || line.endsWith('}') || line.endsWith(';') ? line : `${line};`)
-            .join("\n");
+            .map(line => indentedBy(line.endsWith('{') || line.endsWith('}') || line.endsWith(';') ? line : `${line};`, 1))
+            .join("\n"));
     }
 }
 ////////////////////////////////////////////////////////////////

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

@@ -1,20 +1,60 @@
 import * as idl from '../../idl';
-import { IdlNameConvertor } from "../nameConvertor";
-import { InteropConvertor, InteropReturnTypeConvertor } from './InteropConvertors';
+import { IdlNameConvertor, NodeConvertor, TypeConvertor } from "../nameConvertor";
 import { InteropArgConvertor } from './InteropConvertors';
 import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
-export declare class CppInteropConvertor extends InteropConvertor implements IdlNameConvertor {
+export interface ConvertResult {
+    text: string;
+    noPrefix: boolean;
+}
+export declare class GenericCppConvertor implements NodeConvertor<ConvertResult> {
+    protected resolver: ReferenceResolver;
+    constructor(resolver: ReferenceResolver);
+    private make;
+    convertNode(node: idl.IDLNode): ConvertResult;
+    convertNamespace(node: idl.IDLNamespace): ConvertResult;
+    convertInterface(node: idl.IDLInterface): ConvertResult;
+    convertEnum(node: idl.IDLEnum): ConvertResult;
+    convertTypedef(node: idl.IDLTypedef): ConvertResult;
+    convertCallback(node: idl.IDLCallback): ConvertResult;
+    convertMethod(node: idl.IDLMethod): ConvertResult;
+    convertConstant(node: idl.IDLConstant): ConvertResult;
+    convertOptional(type: idl.IDLOptionalType): ConvertResult;
+    convertUnion(type: idl.IDLUnionType): ConvertResult;
+    convertContainer(type: idl.IDLContainerType): ConvertResult;
+    convertImport(type: idl.IDLReferenceType, _: string): ConvertResult;
+    convertTypeReference(type: idl.IDLReferenceType): ConvertResult;
+    convertTypeParameter(type: idl.IDLTypeParameterType): ConvertResult;
+    convertPrimitiveType(type: idl.IDLPrimitiveType): ConvertResult;
+    private enumName;
+    private computeTargetTypeLiteralName;
+}
+export declare class CppConvertor extends GenericCppConvertor implements IdlNameConvertor {
     private unwrap;
     convert(node: idl.IDLNode): string;
 }
+export declare class CppNameConvertor implements IdlNameConvertor {
+    protected resolver: ReferenceResolver;
+    private readonly cppConvertor;
+    constructor(resolver: ReferenceResolver);
+    convert(node: idl.IDLNode): string;
+}
 export declare class CppInteropArgConvertor extends InteropArgConvertor {
     static INSTANCE: CppInteropArgConvertor;
     convertOptional(type: idl.IDLOptionalType): string;
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
 }
-export declare class CppReturnTypeConvertor extends InteropReturnTypeConvertor {
-    protected resolver: ReferenceResolver;
+export declare class CppReturnTypeConvertor implements TypeConvertor<string> {
+    private resolver;
+    private convertor;
     constructor(resolver: ReferenceResolver);
+    isVoid(returnType: idl.IDLType): boolean;
+    convert(type: idl.IDLType): string;
+    convertContainer(type: idl.IDLContainerType): string;
+    convertImport(type: idl.IDLReferenceType, importClause: string): string;
+    convertOptional(type: idl.IDLOptionalType): string;
+    convertPrimitiveType(type: idl.IDLPrimitiveType): string;
+    convertTypeParameter(type: idl.IDLTypeParameterType): string;
     convertTypeReference(type: idl.IDLReferenceType): string;
+    convertUnion(type: idl.IDLUnionType): string;
 }
 //# sourceMappingURL=CppConvertors.d.ts.map

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

@@ -14,11 +14,159 @@
  */
 import * as idl from '../../idl';
 import { generatorConfiguration } from "../../config";
-import { InteropConvertor, InteropReturnTypeConvertor } from './InteropConvertors';
+import { convertNode, convertType } from "../nameConvertor";
 import { PrimitiveTypesInstance } from '../../peer-generation/PrimitiveType';
 import { InteropArgConvertor } from './InteropConvertors';
-import { isMaterialized } from '../../peer-generation/Materialized';
-export class CppInteropConvertor extends InteropConvertor {
+import { maybeTransformManagedCallback } from '../ArgConvertors';
+import { qualifiedName } from '../../peer-generation/idl/common';
+import { capitalize } from '../../util';
+import { isMaterialized } from '../../peer-generation/isMaterialized';
+export class GenericCppConvertor {
+    constructor(resolver) {
+        this.resolver = resolver;
+    }
+    make(text, noPrefix = false) {
+        return { text, noPrefix };
+    }
+    convertNode(node) {
+        return convertNode(this, node);
+    }
+    convertNamespace(node) {
+        throw new Error("Internal error: namespaces are not allowed on the interop layer");
+    }
+    convertInterface(node) {
+        switch (node.subkind) {
+            case idl.IDLInterfaceSubkind.AnonymousInterface:
+                return node.name
+                    ? this.make(node.name)
+                    : this.make(this.computeTargetTypeLiteralName(node), true);
+            case idl.IDLInterfaceSubkind.Interface:
+            case idl.IDLInterfaceSubkind.Class:
+                if (idl.hasExtAttribute(node, idl.IDLExtendedAttributes.Predefined)) {
+                    return this.make(node.name, true);
+                }
+                return this.make(node.name);
+            case idl.IDLInterfaceSubkind.Tuple:
+                return node.name
+                    ? this.make(node.name)
+                    : this.make(`Tuple_${node.properties.map(it => this.convertNode(idl.maybeOptional(it.type, it.isOptional)).text).join("_")}`, true);
+        }
+    }
+    convertEnum(node) {
+        return this.make(this.enumName(node));
+    }
+    convertTypedef(node) {
+        return this.make(node.name);
+    }
+    convertCallback(node) {
+        return this.make(generatorConfiguration().LibraryPrefix + node.name, true);
+    }
+    convertMethod(node) {
+        return this.make(node.name);
+    }
+    convertConstant(node) {
+        return this.make(node.name);
+    }
+    /////////////////////////////////////////////////////////////////////////////////////////
+    convertOptional(type) {
+        return this.convertNode(type.type);
+    }
+    convertUnion(type) {
+        return this.make(type.name, false);
+    }
+    convertContainer(type) {
+        if (idl.IDLContainerUtils.isPromise(type)) {
+            return this.make(`Promise_${this.convertNode(type.elementType[0]).text}`);
+        }
+        if (idl.IDLContainerUtils.isSequence(type)) {
+            if (type.elementType[0] === idl.IDLU8Type) {
+                return this.make(`uint8_t*`, true);
+            }
+            return this.make(`Array_${this.convertNode(type.elementType[0]).text}`, true);
+        }
+        if (idl.IDLContainerUtils.isRecord(type)) {
+            return this.make(`Map_${this.convertNode(type.elementType[0]).text}_${this.convertNode(type.elementType[1]).text}`, true);
+        }
+        throw new Error(`Unmapped container type ${idl.DebugUtils.debugPrintType(type)}`);
+    }
+    convertImport(type, _) {
+        return this.make(idl.IDLCustomObjectType.name);
+    }
+    convertTypeReference(type) {
+        var _a;
+        const refName = type.name;
+        switch (refName) {
+            case "object":
+            case "Object":
+                return this.make('CustomObject');
+        }
+        if (generatorConfiguration().param("parameterized").includes(refName)) {
+            return this.make('CustomObject');
+        }
+        let decl = this.resolver.toDeclaration(type);
+        if (idl.isCallback(decl)) {
+            decl = (_a = maybeTransformManagedCallback(decl)) !== null && _a !== void 0 ? _a : decl;
+        }
+        if (idl.isType(decl)) {
+            if (idl.isReferenceType(decl)) {
+                return this.make(`${capitalize(decl.name)}`);
+            }
+            return this.convertNode(decl);
+        }
+        let res = this.convertNode(decl);
+        if (type.name === "Optional")
+            res = this.make("Opt_" + res.text, true);
+        return res;
+    }
+    convertTypeParameter(type) {
+        return this.make('CustomObject');
+    }
+    convertPrimitiveType(type) {
+        switch (type) {
+            case idl.IDLVoidType: return this.make('void', true);
+            case idl.IDLI8Type: return this.make(`Int8`);
+            case idl.IDLU8Type: return this.make(`UInt8`);
+            case idl.IDLI16Type: return this.make(`Int16`);
+            case idl.IDLU16Type: return this.make(`UInt16`);
+            case idl.IDLI32Type: return this.make(`Int32`);
+            case idl.IDLU32Type: return this.make(`UInt32`);
+            case idl.IDLI64Type: return this.make(`Int64`);
+            case idl.IDLU64Type: return this.make(`UInt64`);
+            case idl.IDLF32Type: return this.make(`Float32`);
+            case idl.IDLF64Type: return this.make(`Float64`);
+            case idl.IDLNumberType: return this.make(`Number`);
+            case idl.IDLStringType: return this.make(`String`);
+            case idl.IDLBooleanType: return this.make(`Boolean`);
+            case idl.IDLBigintType: return this.make(`UInt64`); // TODO add arbitrary precision numeric type
+            case idl.IDLPointerType: return this.make('NativePointer');
+            case idl.IDLUnknownType:
+            case idl.IDLCustomObjectType:
+            case idl.IDLAnyType: return this.make(`CustomObject`);
+            case idl.IDLUndefinedType: return this.make(`Undefined`);
+            case idl.IDLLengthType: return this.make(`Length`);
+            case idl.IDLFunctionType: return this.make(`Function`);
+            case idl.IDLDate: return this.make(`Date`);
+            case idl.IDLBufferType: return this.make('Buffer');
+            case idl.IDLPointerType: return this.make('Pointer');
+        }
+        throw new Error(`Unmapped primitive type ${idl.DebugUtils.debugPrintType(type)}`);
+    }
+    enumName(target) {
+        return qualifiedName(target, "_");
+    }
+    computeTargetTypeLiteralName(decl) {
+        const map = new Map();
+        for (const prop of decl.properties) {
+            const type = this.convertNode(prop.type);
+            const values = map.has(type.text) ? map.get(type.text) : [];
+            values.push(prop.name);
+            map.set(type.text, values);
+        }
+        const names = Array.from(map.keys()).map(key => `${key}_${map.get(key).join('_')}`);
+        return `Literal_${names.join('_')}`;
+    }
+}
+export class CppConvertor extends GenericCppConvertor {
     unwrap(type, result) {
         const conf = generatorConfiguration();
         if (idl.isType(type) && idl.isOptionalType(type)) {
@@ -37,6 +185,15 @@ export class CppInteropConvertor extends InteropConvertor {
         return this.unwrap(node, this.convertNode(node));
     }
 }
+export class CppNameConvertor {
+    constructor(resolver) {
+        this.resolver = resolver;
+        this.cppConvertor = new GenericCppConvertor(resolver);
+    }
+    convert(node) {
+        return this.cppConvertor.convertNode(node).text;
+    }
+}
 export class CppInteropArgConvertor extends InteropArgConvertor {
     convertOptional(type) {
         return PrimitiveTypesInstance.NativePointer.getText();
@@ -56,16 +213,50 @@ export class CppInteropArgConvertor extends InteropArgConvertor {
     }
 }
 CppInteropArgConvertor.INSTANCE = new CppInteropArgConvertor();
-export class CppReturnTypeConvertor extends InteropReturnTypeConvertor {
+export class CppReturnTypeConvertor {
     constructor(resolver) {
-        super();
         this.resolver = resolver;
+        this.convertor = new CppConvertor(resolver);
+    }
+    isVoid(returnType) {
+        return this.convert(returnType) == 'void';
+    }
+    convert(type) {
+        return convertType(this, type);
+    }
+    convertContainer(type) {
+        // Promise return is done as CPS callback, thus return type is void.
+        if (idl.IDLContainerUtils.isPromise(type))
+            return 'void';
+        return this.convertor.convert(type);
+    }
+    convertImport(type, importClause) {
+        return this.convertor.convert(type);
+    }
+    convertOptional(type) {
+        return this.convertor.convert(type);
+    }
+    convertPrimitiveType(type) {
+        if (type == idl.IDLUndefinedType)
+            return 'void';
+        if (type == idl.IDLStringType)
+            return 'void';
+        if (type == idl.IDLNumberType)
+            return generatorConfiguration().param("TypePrefix") + 'Int32'; // :(
+        return this.convertor.convert(type);
+    }
+    convertTypeParameter(type) {
+        return this.convertor.convert(type);
     }
     convertTypeReference(type) {
-        const resolved = this.resolver.resolveTypeReference(type);
-        if (resolved && idl.isInterface(resolved) && isMaterialized(resolved, this.resolver))
-            return generatorConfiguration().param("TypePrefix") + type.name;
-        return super.convertTypeReference(type);
+        const decl = this.resolver.resolveTypeReference(type);
+        if (decl && idl.isInterface(decl) && isMaterialized(decl, this.resolver)) {
+            return generatorConfiguration().param("TypePrefix") + decl.name;
+        }
+        return this.convertor.convert(type);
+    }
+    convertUnion(type) {
+        return this.convertor.convert(type);
     }
 }
 //# sourceMappingURL=CppConvertors.js.map

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

@@ -1,43 +1,12 @@
 import * as idl from '../../idl';
 import { PeerMethod } from '../../peer-generation/PeerMethod';
 import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
-import { IdlNameConvertor, NodeConvertor, TypeConvertor } from '../nameConvertor';
-export interface ConvertResult {
-    text: string;
-    noPrefix: boolean;
-}
-export declare class InteropConvertor implements NodeConvertor<ConvertResult> {
-    protected resolver: ReferenceResolver;
-    constructor(resolver: ReferenceResolver);
-    private make;
-    convertNode(node: idl.IDLNode): ConvertResult;
-    convertNamespace(node: idl.IDLNamespace): ConvertResult;
-    convertInterface(node: idl.IDLInterface): ConvertResult;
-    convertEnum(node: idl.IDLEnum): ConvertResult;
-    convertTypedef(node: idl.IDLTypedef): ConvertResult;
-    convertCallback(node: idl.IDLCallback): ConvertResult;
-    convertMethod(node: idl.IDLMethod): ConvertResult;
-    convertConstant(node: idl.IDLConstant): ConvertResult;
-    convertOptional(type: idl.IDLOptionalType): ConvertResult;
-    convertUnion(type: idl.IDLUnionType): ConvertResult;
-    convertContainer(type: idl.IDLContainerType): ConvertResult;
-    convertImport(type: idl.IDLReferenceType, _: string): ConvertResult;
-    convertTypeReference(type: idl.IDLReferenceType): ConvertResult;
-    convertTypeParameter(type: idl.IDLTypeParameterType): ConvertResult;
-    convertPrimitiveType(type: idl.IDLPrimitiveType): ConvertResult;
-    private enumName;
-    private computeTargetTypeLiteralName;
-}
-export declare class InteropNameConvertor implements IdlNameConvertor {
-    protected resolver: ReferenceResolver;
-    private readonly interopConvertor;
-    constructor(resolver: ReferenceResolver);
-    convert(node: idl.IDLNode): string;
-}
+import { TypeConvertor } from '../nameConvertor';
 export declare class InteropReturnTypeConvertor implements TypeConvertor<string> {
-    protected readonly resolver?: ReferenceResolver | undefined;
-    constructor(resolver?: ReferenceResolver | undefined);
+    protected readonly resolver: ReferenceResolver;
+    constructor(resolver: ReferenceResolver);
     isVoid(method: PeerMethod): boolean;
+    isReturnInteropBuffer(type: idl.IDLType): boolean;
     convert(type: idl.IDLType): string;
     convertContainer(type: idl.IDLContainerType): string;
     convertImport(type: idl.IDLReferenceType, importClause: string): string;

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

@@ -12,167 +12,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { generatorConfiguration } from '../../config';
 import * as idl from '../../idl';
-import { qualifiedName } from '../../peer-generation/idl/common';
+import { isMaterialized } from '../../peer-generation/isMaterialized';
 import { PrimitiveTypesInstance } from '../../peer-generation/PrimitiveType';
-import { capitalize } from '../../util';
-import { maybeTransformManagedCallback } from '../ArgConvertors';
-import { convertNode, convertType } from '../nameConvertor';
-export class InteropConvertor {
-    constructor(resolver) {
-        this.resolver = resolver;
-    }
-    make(text, noPrefix = false) {
-        return { text, noPrefix };
-    }
-    convertNode(node) {
-        return convertNode(this, node);
-    }
-    convertNamespace(node) {
-        throw new Error("Internal error: namespaces are not allowed on the interop layer");
-    }
-    convertInterface(node) {
-        switch (node.subkind) {
-            case idl.IDLInterfaceSubkind.AnonymousInterface:
-                return node.name
-                    ? this.make(node.name)
-                    : this.make(this.computeTargetTypeLiteralName(node), true);
-            case idl.IDLInterfaceSubkind.Interface:
-            case idl.IDLInterfaceSubkind.Class:
-                if (idl.hasExtAttribute(node, idl.IDLExtendedAttributes.Predefined)) {
-                    return this.make(node.name, true);
-                }
-                return this.make(node.name);
-            case idl.IDLInterfaceSubkind.Tuple:
-                return node.name
-                    ? this.make(node.name)
-                    : this.make(`Tuple_${node.properties.map(it => this.convertNode(idl.maybeOptional(it.type, it.isOptional)).text).join("_")}`, true);
-        }
-    }
-    convertEnum(node) {
-        return this.make(this.enumName(node));
-    }
-    convertTypedef(node) {
-        return this.make(node.name);
-    }
-    convertCallback(node) {
-        return this.make(generatorConfiguration().LibraryPrefix + node.name, true);
-    }
-    convertMethod(node) {
-        return this.make(node.name);
-    }
-    convertConstant(node) {
-        return this.make(node.name);
-    }
-    /////////////////////////////////////////////////////////////////////////////////////////
-    convertOptional(type) {
-        return this.convertNode(type.type);
-    }
-    convertUnion(type) {
-        return this.make(type.name, false);
-    }
-    convertContainer(type) {
-        if (idl.IDLContainerUtils.isPromise(type)) {
-            return this.make(`Promise_${this.convertNode(type.elementType[0]).text}`);
-        }
-        if (idl.IDLContainerUtils.isSequence(type)) {
-            if (type.elementType[0] === idl.IDLU8Type) {
-                return this.make(`uint8_t*`, true);
-            }
-            return this.make(`Array_${this.convertNode(type.elementType[0]).text}`, true);
-        }
-        if (idl.IDLContainerUtils.isRecord(type)) {
-            return this.make(`Map_${this.convertNode(type.elementType[0]).text}_${this.convertNode(type.elementType[1]).text}`, true);
-        }
-        throw new Error(`Unmapped container type ${idl.DebugUtils.debugPrintType(type)}`);
-    }
-    convertImport(type, _) {
-        return this.make(idl.IDLCustomObjectType.name);
-    }
-    convertTypeReference(type) {
-        var _a;
-        const refName = type.name;
-        switch (refName) {
-            case "object":
-            case "Object":
-                return this.make('CustomObject');
-        }
-        if (generatorConfiguration().param("parameterized").includes(refName)) {
-            return this.make('CustomObject');
-        }
-        let decl = this.resolver.toDeclaration(type);
-        if (idl.isCallback(decl)) {
-            decl = (_a = maybeTransformManagedCallback(decl)) !== null && _a !== void 0 ? _a : decl;
-        }
-        if (idl.isType(decl)) {
-            if (idl.isReferenceType(decl)) {
-                return this.make(`${capitalize(decl.name)}`);
-            }
-            return this.convertNode(decl);
-        }
-        let res = this.convertNode(decl);
-        if (type.name === "Optional")
-            res = this.make("Opt_" + res.text, true);
-        return res;
-    }
-    convertTypeParameter(type) {
-        return this.make('CustomObject');
-    }
-    convertPrimitiveType(type) {
-        switch (type) {
-            case idl.IDLVoidType: return this.make('void', true);
-            case idl.IDLI8Type: return this.make(`Int8`);
-            case idl.IDLU8Type: return this.make(`UInt8`);
-            case idl.IDLI16Type: return this.make(`Int16`);
-            case idl.IDLU16Type: return this.make(`UInt16`);
-            case idl.IDLI32Type: return this.make(`Int32`);
-            case idl.IDLU32Type: return this.make(`UInt32`);
-            case idl.IDLI64Type: return this.make(`Int64`);
-            case idl.IDLU64Type: return this.make(`UInt64`);
-            case idl.IDLF32Type: return this.make(`Float32`);
-            case idl.IDLF64Type: return this.make(`Float64`);
-            case idl.IDLNumberType: return this.make(`Number`);
-            case idl.IDLStringType: return this.make(`String`);
-            case idl.IDLBooleanType: return this.make(`Boolean`);
-            case idl.IDLBigintType: return this.make(`UInt64`); // TODO add arbitrary precision numeric type
-            case idl.IDLPointerType: return this.make('NativePointer');
-            case idl.IDLUnknownType:
-            case idl.IDLCustomObjectType:
-            case idl.IDLAnyType: return this.make(`CustomObject`);
-            case idl.IDLUndefinedType: return this.make(`Undefined`);
-            case idl.IDLLengthType: return this.make(`Length`);
-            case idl.IDLFunctionType: return this.make(`Function`);
-            case idl.IDLDate: return this.make(`Date`);
-            case idl.IDLBufferType: return this.make('Buffer');
-            case idl.IDLPointerType: return this.make('Pointer');
-        }
-        throw new Error(`Unmapped primitive type ${idl.DebugUtils.debugPrintType(type)}`);
-    }
-    enumName(target) {
-        return qualifiedName(target, "_");
-    }
-    computeTargetTypeLiteralName(decl) {
-        const map = new Map();
-        for (const prop of decl.properties) {
-            const type = this.convertNode(prop.type);
-            const values = map.has(type.text) ? map.get(type.text) : [];
-            values.push(prop.name);
-            map.set(type.text, values);
-        }
-        const names = Array.from(map.keys()).map(key => `${key}_${map.get(key).join('_')}`);
-        return `Literal_${names.join('_')}`;
-    }
-}
-export class InteropNameConvertor {
-    constructor(resolver) {
-        this.resolver = resolver;
-        this.interopConvertor = new InteropConvertor(resolver);
-    }
-    convert(node) {
-        return this.interopConvertor.convertNode(node).text;
-    }
-}
+import { convertType } from '../nameConvertor';
+const KInteropReturnBuffer = 'KInteropReturnBuffer';
 export class InteropReturnTypeConvertor {
     constructor(resolver) {
         this.resolver = resolver;
@@ -180,22 +24,24 @@ export class InteropReturnTypeConvertor {
     isVoid(method) {
         return this.convert(method.returnType) === idl.IDLVoidType.name;
     }
+    isReturnInteropBuffer(type) {
+        return this.convert(type) === KInteropReturnBuffer;
+    }
     convert(type) {
         return convertType(this, type);
     }
     convertContainer(type) {
-        if (idl.IDLContainerUtils.isSequence(type) || idl.IDLContainerUtils.isPromise(type)) {
+        if (idl.IDLContainerUtils.isPromise(type)) {
             // TODO return array by some way
             return "void";
         }
-        else
-            return PrimitiveTypesInstance.NativePointer.getText();
+        return KInteropReturnBuffer;
     }
     convertImport(type, importClause) {
         throw new Error(`Cannot pass import type ${type.name} through interop`);
     }
     convertOptional(type) {
-        return this.convert(type.type);
+        return 'KInteropReturnBuffer';
     }
     convertPrimitiveType(type) {
         switch (type) {
@@ -215,10 +61,10 @@ export class InteropReturnTypeConvertor {
             case idl.IDLBigintType: return PrimitiveTypesInstance.Int64.getText();
             case idl.IDLAnyType:
             case idl.IDLBufferType:
-            case idl.IDLStringType:
             case idl.IDLThisType:
             case idl.IDLUndefinedType:
             case idl.IDLUnknownType:
+            case idl.IDLStringType:
             case idl.IDLVoidType: return idl.IDLVoidType.name;
             case idl.IDLPointerType: return PrimitiveTypesInstance.NativePointer.getText();
         }
@@ -230,14 +76,23 @@ export class InteropReturnTypeConvertor {
     convertTypeReference(type) {
         if (type.name.endsWith("Attribute"))
             return idl.IDLVoidType.name;
-        // Callbacks and array types return by value
-        if (this.resolver && idl.isCallback(this.resolver.toDeclaration(type))) {
-            return type.name;
+        const decl = this.resolver.resolveTypeReference(type);
+        if (decl) {
+            // Callbacks and array types return by value
+            if (idl.isCallback(this.resolver.toDeclaration(type))) {
+                return type.name;
+            }
+            if (idl.isInterface(decl)) {
+                if (isMaterialized(decl, this.resolver)) {
+                    return PrimitiveTypesInstance.NativePointer.getText();
+                }
+                return KInteropReturnBuffer;
+            }
         }
-        return PrimitiveTypesInstance.NativePointer.getText();
+        return KInteropReturnBuffer;
     }
     convertUnion(type) {
-        return PrimitiveTypesInstance.NativePointer.getText();
+        return KInteropReturnBuffer;
     }
 }
 export class InteropArgConvertor {

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

@@ -3,7 +3,7 @@ import { Language } from "../Language";
 import { PrimitiveTypesInstance } from "../peer-generation/PrimitiveType";
 import { createEmptyReferenceResolver } from "../peer-generation/ReferenceResolver";
 import { CJIDLTypeToForeignStringConvertor, CJInteropArgConvertor, CJTypeNameConvertor } from "./convertors/CJConvertors";
-import { CppInteropArgConvertor, CppInteropConvertor } from "./convertors/CppConvertors";
+import { CppInteropArgConvertor, CppConvertor } from "./convertors/CppConvertors";
 import { ETSTypeNameConvertor } from "./convertors/ETSConvertors";
 import { InteropArgConvertor } from "./convertors/InteropConvertors";
 import { JavaInteropArgConvertor, JavaTypeNameConvertor } from "./convertors/JavaConvertors";
@@ -19,9 +19,9 @@ export function createLanguageWriter(language, resolver) {
     const printer = new IndentedPrinter();
     switch (language) {
         case Language.TS: return new TSLanguageWriter(printer, resolver, new TSTypeNameConvertor(resolver));
-        case Language.ARKTS: return new ETSLanguageWriter(printer, resolver, new ETSTypeNameConvertor(resolver), new CppInteropConvertor(resolver));
+        case Language.ARKTS: return new ETSLanguageWriter(printer, resolver, new ETSTypeNameConvertor(resolver), new CppConvertor(resolver));
         case Language.JAVA: return new JavaLanguageWriter(printer, resolver, new JavaTypeNameConvertor(resolver));
-        case Language.CPP: return new CppLanguageWriter(printer, resolver, new CppInteropConvertor(resolver), PrimitiveTypesInstance);
+        case Language.CPP: return new CppLanguageWriter(printer, resolver, new CppConvertor(resolver), PrimitiveTypesInstance);
         case Language.CJ: return new CJLanguageWriter(printer, resolver, new CJTypeNameConvertor(resolver), new CJIDLTypeToForeignStringConvertor(resolver));
         default: throw new Error(`Language ${language.toString()} is not supported`);
     }

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

@@ -29,7 +29,8 @@ export declare class CJMatchExpression implements LanguageExpression {
     matchValue: LanguageExpression;
     matchCases: LanguageExpression[];
     caseBlocks: LanguageExpression[];
-    constructor(matchValue: LanguageExpression, matchCases: LanguageExpression[], caseBlocks: LanguageExpression[]);
+    indentDepth?: number | undefined;
+    constructor(matchValue: LanguageExpression, matchCases: LanguageExpression[], caseBlocks: LanguageExpression[], indentDepth?: number | undefined);
     asString(): string;
 }
 export declare class CJTernaryExpression implements LanguageExpression {
@@ -139,6 +140,8 @@ export declare class CJLanguageWriter extends LanguageWriter {
     makeEquals(args: LanguageExpression[]): LanguageExpression;
     runtimeType(param: ArgConvertor, valueType: string, value: string): void;
     escapeKeyword(word: string): string;
+    pushNamespace(namespace: string, ident?: boolean): void;
+    popNamespace(ident?: boolean): void;
     castToInt(value: string, bitness: 8 | 32): string;
     castToBoolean(value: string): string;
     makeLengthSerializer(serializer: string, value: string): LanguageStatement | undefined;

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

@@ -18,7 +18,7 @@ import { CJKeywords } from "../../languageSpecificKeywords";
 import { RuntimeType } from "../common";
 import { AssignStatement, ExpressionStatement, FieldModifier, LambdaExpression, LanguageWriter, MethodModifier, MethodSignature, ReturnStatement, StringExpression } from "../LanguageWriter";
 import { Language } from "../../Language";
-import { isDefined } from "../../util";
+import { indentedBy, isDefined } from "../../util";
 ////////////////////////////////////////////////////////////////
 //                        EXPRESSIONS                         //
 ////////////////////////////////////////////////////////////////
@@ -64,19 +64,21 @@ export class CJUnionCastExpression {
     }
 }
 export class CJMatchExpression {
-    constructor(matchValue, matchCases, caseBlocks) {
+    constructor(matchValue, matchCases, caseBlocks, indentDepth) {
         this.matchValue = matchValue;
         this.matchCases = matchCases;
         this.caseBlocks = caseBlocks;
+        this.indentDepth = indentDepth;
     }
     asString() {
+        var _a, _b, _c;
         let output = [];
         output.push(`match (${this.matchValue.asString()}) {`);
         for (let index in this.matchCases) {
-            output.push(`case ${this.matchCases[index].asString()} => ${this.caseBlocks[index].asString()} `);
+            output.push(indentedBy(`case ${this.matchCases[index].asString()} => ${this.caseBlocks[index].asString()}`, ((_a = this.indentDepth) !== null && _a !== void 0 ? _a : 0) + 1));
         }
-        output.push(`case _ => throw Exception(\"Unmatched pattern ${this.matchValue.asString()}\")`);
-        output.push(`}`);
+        output.push(indentedBy(`case _ => throw Exception(\"Unmatched pattern ${this.matchValue.asString()}\")`, ((_b = this.indentDepth) !== null && _b !== void 0 ? _b : 1) + 1));
+        output.push(indentedBy(`}`, ((_c = this.indentDepth) !== null && _c !== void 0 ? _c : 1)));
         return output.join('\n');
     }
 }
@@ -482,7 +484,7 @@ export class CJLanguageWriter extends LanguageWriter {
         return this.makeString("Option.None");
     }
     makeUnwrapOptional(expression) {
-        return new CJMatchExpression(expression, [this.makeString('Some(serializer)')], [this.makeString('serializer')]);
+        return new CJMatchExpression(expression, [this.makeString('Some(serializer)')], [this.makeString('serializer')], this.indentDepth());
     }
     makeValueFromOption(value, destinationConvertor) {
         return this.makeString(`${value}`);
@@ -498,7 +500,7 @@ export class CJLanguageWriter extends LanguageWriter {
         return this.makeStatement(this.makeMethodCall(keyAccessor, "set", [this.makeString(key), this.makeString(value)]));
     }
     makeNull(value) {
-        return new StringExpression(`None<${value}>`);
+        return new StringExpression(`Option.None`);
     }
     getTagType() {
         return idl.createReferenceType("Tags");
@@ -545,6 +547,8 @@ export class CJLanguageWriter extends LanguageWriter {
     escapeKeyword(word) {
         return CJKeywords.has(word) ? word + "_" : word;
     }
+    pushNamespace(namespace, ident = true) { }
+    popNamespace(ident = true) { }
     castToInt(value, bitness) {
         return `Int${bitness}(${value})`;
     }

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

@@ -9,6 +9,7 @@ export interface LibraryFileInterface {
 export interface LibraryInterface extends ReferenceResolver {
     language: Language;
     get files(): LibraryFileInterface[];
+    get libraryPackages(): string[] | undefined;
     typeConvertor(param: string, type: idl.IDLType, isOptionalParam?: boolean): ArgConvertor;
     declarationConvertor(param: string, type: idl.IDLReferenceType, declaration: idl.IDLEntry | undefined): ArgConvertor;
     getInteropName(node: idl.IDLNode): string;

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

@@ -86,7 +86,6 @@ export interface IDLNamedNode extends IDLNode {
 export interface IDLEntry extends IDLNode, IDLNamedNode {
     _idlEntryBrand: any;
     comment?: string;
-    scope?: IDLEntry[];
     namespace?: IDLNamespace;
 }
 export interface IDLType extends IDLNode {

package/build/lib/src/idl.js

@@ -98,7 +98,7 @@ export var IDLInterfaceSubkind;
     IDLInterfaceSubkind[IDLInterfaceSubkind["Tuple"] = 3] = "Tuple";
 })(IDLInterfaceSubkind || (IDLInterfaceSubkind = {}));
 export function forEachChild(node, cbEnter, cbLeave) {
-    var _a, _b, _c;
+    var _a, _b;
     cbEnter(node);
     switch (node.kind) {
         case IDLKind.Namespace:
@@ -111,7 +111,6 @@ export function forEachChild(node, cbEnter, cbLeave) {
             concrete.properties.forEach((value) => forEachChild(value, cbEnter, cbLeave));
             concrete.methods.forEach((value) => forEachChild(value, cbEnter, cbLeave));
             concrete.callables.forEach((value) => forEachChild(value, cbEnter, cbLeave));
-            (_a = concrete.scope) === null || _a === void 0 ? void 0 : _a.forEach((value) => forEachChild(value, cbEnter, cbLeave));
             break;
         }
         case IDLKind.Method:
@@ -119,14 +118,14 @@ export function forEachChild(node, cbEnter, cbLeave) {
         case IDLKind.Callback:
         case IDLKind.Constructor: {
             let concrete = node;
-            (_b = concrete.parameters) === null || _b === void 0 ? void 0 : _b.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+            (_a = concrete.parameters) === null || _a === void 0 ? void 0 : _a.forEach((value) => forEachChild(value, cbEnter, cbLeave));
             if (concrete.returnType)
                 forEachChild(concrete.returnType, cbEnter, cbLeave);
             break;
         }
         case IDLKind.UnionType: {
             let concrete = node;
-            (_c = concrete.types) === null || _c === void 0 ? void 0 : _c.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+            (_b = concrete.types) === null || _b === void 0 ? void 0 : _b.forEach((value) => forEachChild(value, cbEnter, cbLeave));
             break;
         }
         case IDLKind.OptionalType: {
@@ -746,14 +745,6 @@ export function printScoped(idl) {
     throw new Error(`Unexpected scoped: ${idl.kind} ${idl.name}`);
 }
 export function printInterface(idl) {
-    idl.methods
-        .map(it => {
-        let result = it.scope;
-        it.scope = undefined;
-        return result;
-    })
-        .filter(isDefined)
-        .forEach(scope => idl.scope ? idl.scope.push(...scope) : idl.scope = scope);
     return [
         ...printExtendedAttributes(idl, 0),
         `interface ${idl.name}${hasSuperType(idl) ? ": " + printType(idl.inheritance[0]) : ""} {`,
@@ -852,7 +843,6 @@ export function toIDLString(entries, options) {
     let indent = 0;
     const generatedIdl = entries
         .map(it => printIDL(it, options))
-        .concat(printScopes(entries))
         .flat()
         .filter(isDefined)
         .filter(it => it.length > 0)
@@ -872,12 +862,6 @@ export function verifyIDLString(source) {
     webidl2.validate(webidl2.parse(source));
     return true;
 }
-function printScopes(entries) {
-    return entries
-        .map((it) => it.scope)
-        .filter(isDefined)
-        .flatMap((it) => it.map(printScoped));
-}
 export function hasExtAttribute(node, attribute) {
     var _a;
     return ((_a = node.extendedAttributes) === null || _a === void 0 ? void 0 : _a.find((it) => it.name == attribute)) != undefined;

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

@@ -37,6 +37,7 @@ export * from "./peer-generation/PeerClass";
 export * from "./peer-generation/PeerMethod";
 export * from "./peer-generation/BuilderClass";
 export * from "./peer-generation/Materialized";
+export * from "./peer-generation/isMaterialized";
 export * from "./peer-generation/unions";
 export * from "./LanguageWriters";
 export * from "./peer-generation/ReferenceResolver";

package/build/lib/src/index.js

@@ -51,6 +51,7 @@ export * from "./peer-generation/PeerClass";
 export * from "./peer-generation/PeerMethod";
 export * from "./peer-generation/BuilderClass";
 export * from "./peer-generation/Materialized";
+export * from "./peer-generation/isMaterialized";
 export * from "./peer-generation/unions";
 export * from "./LanguageWriters";
 export * from "./peer-generation/ReferenceResolver";

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

@@ -4,7 +4,6 @@ import { Field, Method } from '../LanguageWriters/LanguageWriter';
 import { PeerClassBase } from './PeerClass';
 import { PeerMethod } from './PeerMethod';
 import { ReferenceResolver } from './ReferenceResolver';
-export declare function isMaterialized(declaration: idl.IDLInterface, resolver: ReferenceResolver): boolean;
 export declare class MaterializedField {
     field: Field;
     argConvertor: ArgConvertor;

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

@@ -12,42 +12,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { generatorConfiguration } from '../config';
 import * as idl from '../idl';
-import { CppReturnTypeConvertor } from '../LanguageWriters/convertors/CppConvertors';
 import { copyMethod, Method, MethodModifier, NamedMethodSignature } from '../LanguageWriters/LanguageWriter';
 import { capitalize } from '../util';
-import { isBuilderClass } from './BuilderClass';
 import { qualifiedName } from './idl/common';
 import { PeerMethod } from './PeerMethod';
-export function isMaterialized(declaration, resolver) {
-    if (!idl.isInterfaceSubkind(declaration) && !idl.isClassSubkind(declaration))
-        return false;
-    if (idl.isHandwritten(declaration) || isBuilderClass(declaration))
-        return false;
-    for (const forceMaterialized of generatorConfiguration().param("forceMaterialized")) {
-        if (declaration.name == forceMaterialized)
-            return true;
-    }
-    for (const ignore of generatorConfiguration().param("ignoreMaterialized")) {
-        if (declaration.name.endsWith(ignore))
-            return false;
-    }
-    // A materialized class is a class or an interface with methods
-    // excluding components and related classes
-    if (declaration.methods.length > 0 || declaration.constructors.length > 0)
-        return true;
-    // Or a class or an interface derived from materialized class
-    if (idl.hasSuperType(declaration)) {
-        const superType = resolver.resolveTypeReference(idl.getSuperType(declaration));
-        if (!superType || !idl.isInterface(superType)) {
-            console.log(`Unable to resolve ${idl.getSuperType(declaration).name} type, consider ${declaration.name} to be not materialized`);
-            return false;
-        }
-        return isMaterialized(superType, resolver);
-    }
-    return false;
-}
 export class MaterializedField {
     constructor(field, argConvertor, outArgConvertor, isNullableOriginalTypeField) {
         this.field = field;
@@ -76,28 +45,14 @@ export class MaterializedMethod extends PeerMethod {
         }
     }
     dummyReturnValue(resolver) {
-        var _a;
         if (this.method.name === "ctor")
-            return `(${this.originalParentName}Peer*) 100`;
+            return `(Ark_${this.originalParentName}) 100`;
         if (this.method.name === "getFinalizer")
             return `fnPtr<KNativePointer>(dummyClassFinalizer)`;
-        if ((_a = this.method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(MethodModifier.STATIC)) {
-            if (this.method.signature.returnType === idl.IDLNumberType) {
-                return '100';
-            }
-            if (this.method.signature.returnType === idl.IDLBooleanType) {
-                return '0';
-            }
-            const convertor = new CppReturnTypeConvertor(resolver);
-            return `(${convertor.convert(this.returnType)}) 300`;
-        }
-        if (idl.isReferenceType(this.method.signature.returnType)) {
-            return "{}";
-        }
         return undefined;
     }
     get receiverType() {
-        return `${this.originalParentName}Peer*`;
+        return `Ark_${this.originalParentName}`;
     }
     get apiCall() {
         return "GetAccessors()";
@@ -110,7 +65,7 @@ export class MaterializedMethod extends PeerMethod {
             return undefined;
         return {
             argName: 'peer',
-            argType: `${this.originalParentName}Peer*`
+            argType: `Ark_${this.originalParentName}`
         };
     }
     getImplementationName() {

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

@@ -10,6 +10,7 @@ import { PeerFile } from './PeerFile';
 import { LayoutManager, LayoutManagerStrategy } from './LayoutManager';
 export declare class PeerLibrary implements LibraryInterface {
     language: Language;
+    libraryPackages: string[] | undefined;
     layout: LayoutManager;
     private _syntheticEntries;
     /** @deprecated PeerLibrary should contain only SDK entries */
@@ -22,7 +23,7 @@ export declare class PeerLibrary implements LibraryInterface {
     get materializedToGenerate(): MaterializedClass[];
     readonly predefinedDeclarations: idl.IDLInterface[];
     readonly globalScopeInterfaces: idl.IDLInterface[];
-    constructor(language: Language);
+    constructor(language: Language, libraryPackages: string[] | undefined);
     name: string;
     readonly customComponentMethods: string[];
     createLanguageWriter(language?: Language): LanguageWriter;
@@ -38,6 +39,8 @@ export declare class PeerLibrary implements LibraryInterface {
     findFileByOriginalFilename(filename: string): PeerFile | undefined;
     mapType(type: idl.IDLType): string;
     resolveTypeReference(type: idl.IDLReferenceType, pointOfView?: idl.IDLEntry, rootEntries?: idl.IDLEntry[]): idl.IDLEntry | undefined;
+    resolvePackageName(entry: idl.IDLEntry): string;
+    hasInLibrary(entry: idl.IDLEntry): boolean;
     typeConvertor(param: string, type: idl.IDLType, isOptionalParam?: boolean): ArgConvertor;
     declarationConvertor(param: string, type: idl.IDLReferenceType, declaration: idl.IDLEntry | undefined): ArgConvertor;
     private customConvertor;

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

@@ -17,16 +17,16 @@ import * as idl from '../idl';
 import { Language } from '../Language';
 import { createLanguageWriter } from '../LanguageWriters';
 import { BufferConvertor, CallbackConvertor, DateConvertor, MapConvertor, PointerConvertor, TupleConvertor, TypeAliasConvertor, AggregateConvertor, StringConvertor, ClassConvertor, ArrayConvertor, FunctionConvertor, OptionConvertor, NumberConvertor, NumericConvertor, CustomTypeConvertor, UnionConvertor, MaterializedClassConvertor, BooleanConvertor, EnumConvertor, UndefinedConvertor, VoidConvertor, ImportTypeConvertor, InterfaceConvertor, BigIntToU64Convertor, } from "../LanguageWriters/ArgConvertors";
-import { InteropNameConvertor } from '../LanguageWriters/convertors/InteropConvertors';
+import { CppNameConvertor } from '../LanguageWriters/convertors/CppConvertors';
 import { CJTypeNameConvertor } from '../LanguageWriters/convertors/CJConvertors';
-import { CppInteropConvertor } from '../LanguageWriters/convertors/CppConvertors';
+import { CppConvertor } from '../LanguageWriters/convertors/CppConvertors';
 import { ETSTypeNameConvertor } from '../LanguageWriters/convertors/ETSConvertors';
 import { JavaTypeNameConvertor } from '../LanguageWriters/convertors/JavaConvertors';
 import { TSTypeNameConvertor } from '../LanguageWriters/convertors/TSConvertors';
 import { isBuilderClass } from './BuilderClass';
 import { generateSyntheticFunctionName, isImportAttr } from './idl/common';
-import { isMaterialized } from './Materialized';
 import { LayoutManager } from './LayoutManager';
+import { isMaterialized } from './isMaterialized';
 export class PeerLibrary {
     /** @deprecated PeerLibrary should contain only SDK entries */
     get syntheticEntries() {
@@ -41,8 +41,9 @@ export class PeerLibrary {
     get materializedToGenerate() {
         return Array.from(this.materializedClasses.values()).filter(it => it.needBeGenerated);
     }
-    constructor(language) {
+    constructor(language, libraryPackages) {
         this.language = language;
+        this.libraryPackages = libraryPackages;
         this.layout = LayoutManager.Empty();
         this._syntheticEntries = [];
         this.files = [];
@@ -53,7 +54,7 @@ export class PeerLibrary {
         this.name = "";
         this.customComponentMethods = [];
         this.targetNameConvertorInstance = this.createTypeNameConvertor(this.language);
-        this.interopNameConvertorInstance = new InteropNameConvertor(this);
+        this.interopNameConvertorInstance = new CppNameConvertor(this);
     }
     createLanguageWriter(language) {
         return createLanguageWriter(language !== null && language !== void 0 ? language : this.language, this);
@@ -64,7 +65,7 @@ export class PeerLibrary {
             case Language.ARKTS: return new ETSTypeNameConvertor(this);
             case Language.JAVA: return new JavaTypeNameConvertor(this);
             case Language.CJ: return new CJTypeNameConvertor(this);
-            case Language.CPP: return new CppInteropConvertor(this);
+            case Language.CPP: return new CppConvertor(this);
         }
         throw new Error(`IdlNameConvertor for ${language} is not implemented`);
     }
@@ -165,6 +166,23 @@ export class PeerLibrary {
         } // end of block to remove
         return undefined; // empty result
     }
+    resolvePackageName(entry) {
+        var _a;
+        if (this._syntheticEntries.includes(entry))
+            return ((_a = this.libraryPackages) === null || _a === void 0 ? void 0 : _a.length) ? this.libraryPackages[0] : this.files[0].packageName();
+        while (entry.namespace) {
+            entry = entry.namespace;
+        }
+        for (const file of this.files) {
+            if (file.entries.includes(entry))
+                return file.packageName();
+        }
+        throw new Error(`Package name for entry ${entry.name} was not found`);
+    }
+    hasInLibrary(entry) {
+        var _a, _b;
+        return !((_a = this.libraryPackages) === null || _a === void 0 ? void 0 : _a.length) || ((_b = this.libraryPackages) === null || _b === void 0 ? void 0 : _b.includes(this.resolvePackageName(entry)));
+    }
     typeConvertor(param, type, isOptionalParam = false) {
         if (isOptionalParam) {
             return new OptionConvertor(this, param, idl.maybeUnwrapOptionalType(type));
@@ -194,7 +212,7 @@ export class PeerLibrary {
                 case idl.IDLUndefinedType: return new UndefinedConvertor(param);
                 case idl.IDLVoidType: return new VoidConvertor(param);
                 case idl.IDLUnknownType:
-                case idl.IDLAnyType: return new CustomTypeConvertor(param, "Any");
+                case idl.IDLAnyType: return new CustomTypeConvertor(param, "Any", false, "Object");
                 default: throw new Error(`Unconverted primitive ${idl.DebugUtils.debugPrintType(type)}`);
             }
         }
@@ -215,7 +233,7 @@ export class PeerLibrary {
         }
         if (idl.isTypeParameterType(type)) {
             // TODO: unlikely correct.
-            return new CustomTypeConvertor(param, this.targetNameConvertorInstance.convert(type), true);
+            return new CustomTypeConvertor(param, this.targetNameConvertorInstance.convert(type), true, `<${type.name}>`);
         }
         throw new Error(`Cannot convert: ${type.kind}`);
     }
@@ -267,7 +285,7 @@ export class PeerLibrary {
     customConvertor(param, typeName, type) {
         switch (typeName) {
             case `Object`:
-                return new CustomTypeConvertor(param, "Object");
+                return new CustomTypeConvertor(param, "Object", false, "Object");
             case `Date`:
                 return new DateConvertor(param);
             case `Function`:

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

@@ -19,6 +19,7 @@ export declare class PrimitiveTypeList {
     readonly Tag: PrimitiveType;
     readonly Materialized: PrimitiveType;
     readonly CustomObject: PrimitiveType;
+    readonly String: PrimitiveType;
 }
 export declare const PrimitiveTypesInstance: PrimitiveTypeList;
 //# sourceMappingURL=PrimitiveType.d.ts.map

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

@@ -37,6 +37,7 @@ export class PrimitiveTypeList {
         this.Tag = new PrimitiveType(`Tag`);
         this.Materialized = new PrimitiveType(`Materialized`, true);
         this.CustomObject = new PrimitiveType(`CustomObject`, true);
+        this.String = new PrimitiveType(`String`);
     }
     static get UndefinedTag() {
         return "INTEROP_TAG_UNDEFINED";

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

@@ -0,0 +1,4 @@
+import * as idl from '../idl';
+import { ReferenceResolver } from './ReferenceResolver';
+export declare function isMaterialized(declaration: idl.IDLInterface, resolver: ReferenceResolver): boolean;
+//# sourceMappingURL=isMaterialized.d.ts.map

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

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { generatorConfiguration } from '../config';
+import * as idl from '../idl';
+import { isBuilderClass } from './BuilderClass';
+export function isMaterialized(declaration, resolver) {
+    if (!idl.isInterfaceSubkind(declaration) && !idl.isClassSubkind(declaration))
+        return false;
+    if (idl.isHandwritten(declaration) || isBuilderClass(declaration))
+        return false;
+    for (const forceMaterialized of generatorConfiguration().param("forceMaterialized")) {
+        if (declaration.name == forceMaterialized)
+            return true;
+    }
+    for (const ignore of generatorConfiguration().param("ignoreMaterialized")) {
+        if (declaration.name.endsWith(ignore))
+            return false;
+    }
+    // A materialized class is a class or an interface with methods
+    // excluding components and related classes
+    if (declaration.methods.length > 0 || declaration.constructors.length > 0)
+        return true;
+    // Or a class or an interface derived from materialized class
+    if (idl.hasSuperType(declaration)) {
+        const superType = resolver.resolveTypeReference(idl.getSuperType(declaration));
+        if (!superType || !idl.isInterface(superType)) {
+            console.log(`Unable to resolve ${idl.getSuperType(declaration).name} type, consider ${declaration.name} to be not materialized`);
+            return false;
+        }
+        return isMaterialized(superType, resolver);
+    }
+    return false;
+}
+//# sourceMappingURL=isMaterialized.js.map

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

@@ -23,7 +23,7 @@ export declare class UnionRuntimeTypeChecker {
     constructor(convertors: ArgConvertor[]);
     private checkConflicts;
     makeDiscriminator(value: string, convertorIndex: number, writer: LanguageWriter): LanguageExpression;
-    reportConflicts(context: string | undefined): void;
+    reportConflicts(context: string | undefined, writer: LanguageWriter): void;
 }
 export declare function flattenUnionType(library: LibraryInterface, type: IDLType): IDLType;
 //# sourceMappingURL=unions.d.ts.map

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

@@ -15,6 +15,7 @@
 import { convertType } from "../LanguageWriters";
 import { IDLCustomObjectType, IDLUndefinedType, isType, isUnionType } from '../idl';
 import { typeOrUnion } from "./idl/common";
+import { CustomTypeConvertor } from "../LanguageWriters/ArgConvertors";
 import { RuntimeType } from "../LanguageWriters/common";
 export class UnionFlattener {
     constructor(resolver) {
@@ -92,10 +93,20 @@ export class UnionRuntimeTypeChecker {
             writer.makeUnionVariantCondition(convertor, value, `${value}_type`, RuntimeType[it], convertorIndex, runtimeTypeIndex)
         ])));
     }
-    reportConflicts(context) {
+    reportConflicts(context, writer) {
         if (this.discriminators.filter(([discriminator, _, __]) => discriminator === undefined).length > 1) {
-            this.discriminators.forEach(([discr, conv, n]) => console.log(`   ${n} : ${conv.constructor.name} : ${discr ? discr.asString() : "<undefined>"}`));
-            throw new Error(`runtime type conflict in \`${context}\``);
+            let report = `Union discrimination code can not be generated for \`${context}\`.\n`;
+            report += `Possible reasons for that are too similar or unresolved types in union (see below).\n`;
+            report += ` #  | type                          | duplicated properties         | resolved | discriminator expression\n`;
+            const properties = Array.from(this.duplicateMembers).join(",").padEnd(30);
+            this.discriminators.forEach(([discr, conv, n]) => {
+                const num = n.toString().padEnd(3);
+                const typename = conv.targetType(writer).padEnd(30);
+                const resolved = (conv instanceof CustomTypeConvertor ? "no" : "yes").padEnd(9);
+                const discriminator = discr ? discr.asString() : "<undefined>";
+                report += ` ${num}| ${typename}| ${properties}| ${resolved}| ${discriminator}\n`;
+            });
+            throw new Error(report);
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idlizer/core",
-  "version": "2.0.26",
+  "version": "2.0.27",
   "description": "",
   "types": "build/lib/src/index.d.ts",
   "exports": {
@@ -34,7 +34,7 @@
   },
   "keywords": [],
   "dependencies": {
-    "@koalaui/interop": "1.5.1",
+    "@koalaui/interop": "1.5.2",
     "typescript": "4.9.5",
     "@types/node": "^18.0.0"
   },