@idlizer/core 2.1.5 → 2.1.7

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

@@ -263,7 +263,6 @@ export declare class CustomTypeConvertor extends BaseArgConvertor {
     isPointerType(): boolean;
 }
 export declare class OptionConvertor extends BaseArgConvertor {
-    private library;
     type: idl.IDLType;
     private readonly typeConvertor;
     constructor(library: LibraryInterface, param: string, type: idl.IDLType);

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

@@ -47,7 +47,6 @@ export function isDirectConvertedType(originalType, library) {
         convertor instanceof MapConvertor ||
         convertor instanceof TupleConvertor ||
         convertor instanceof AggregateConvertor ||
-        convertor instanceof UnionConvertor ||
         convertor instanceof OptionConvertor ||
         convertor instanceof ImportTypeConvertor) {
         // try { console.log(`convertor is ${convertor.constructor.name} for ${JSON.stringify(originalType)}`) } catch (e) {}
@@ -809,12 +808,18 @@ export class OptionConvertor extends BaseArgConvertor {
     // TODO: be smarter here, and for smth like Length|undefined or number|undefined pass without serializer.
     constructor(library, param, type) {
         let conv = library.typeConvertor(param, type);
+        let currentConv = conv;
+        while (currentConv instanceof ProxyConvertor) {
+            currentConv = currentConv.convertor;
+        }
+        if (currentConv instanceof OptionConvertor) {
+            conv = currentConv.typeConvertor;
+        }
         let runtimeTypes = conv.runtimeTypes;
         if (!runtimeTypes.includes(RuntimeType.UNDEFINED)) {
             runtimeTypes.push(RuntimeType.UNDEFINED);
         }
         super(idl.createOptionalType(conv.idlType), runtimeTypes, conv.isScoped, true, param);
-        this.library = library;
         this.type = type;
         this.typeConvertor = conv;
     }
@@ -940,7 +945,7 @@ export class UnionConvertor extends BaseArgConvertor {
             return { expr, stmt };
         });
         statements.push(writer.makeMultiBranchCondition(branches, writer.makeThrowError(`One of the branches for ${bufferName} has to be chosen through deserialisation.`)));
-        statements.push(assigneer(writer.makeCast(writer.makeString(bufferName), this.type)));
+        statements.push(assigneer(writer.makeCast(writer.makeString(bufferName), this.nativeType())));
         return new BlockStatement(statements, false);
     }
     nativeType() {

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

@@ -242,8 +242,8 @@ export declare abstract class LanguageWriter {
     }, op?: (writer: this) => void): void;
     abstract writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[], generics?: string[], isDeclared?: boolean): void;
     abstract writeFieldDeclaration(name: string, type: idl.IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
-    abstract writeFunctionDeclaration(name: string, signature: MethodSignature): void;
-    abstract writeFunctionImplementation(name: string, signature: MethodSignature, op: (writer: this) => void): void;
+    abstract writeFunctionDeclaration(name: string, signature: MethodSignature, generics?: string[]): void;
+    abstract writeFunctionImplementation(name: string, signature: MethodSignature, op: (writer: this) => void, generics?: string[]): void;
     abstract writeMethodDeclaration(name: string, signature: MethodSignature, modifiers?: MethodModifier[]): void;
     abstract writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
     abstract writeMethodImplementation(method: Method, op: (writer: this) => void): void;
@@ -377,11 +377,16 @@ export declare abstract class LanguageWriter {
      * Writes `namespace <namespace> {` and adds extra indent
      * @param namespace Namespace to begin
      */
-    pushNamespace(namespace: string, ident?: boolean): void;
+    pushNamespace(namespace: string, options: {
+        ident: boolean;
+        isDeclared?: boolean;
+    }): void;
     /**
      * Writes closing brace of namespace block and removes one level of indent
      */
-    popNamespace(ident?: boolean): void;
+    popNamespace(options: {
+        ident: boolean;
+    }): void;
     static _isReferenceRelativeToNamespaces: boolean;
     static get isReferenceRelativeToNamespaces(): boolean;
     static relativeReferences<T>(isRelative: boolean, op: () => T): T;

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

@@ -694,17 +694,17 @@ export class LanguageWriter {
      * Writes `namespace <namespace> {` and adds extra indent
      * @param namespace Namespace to begin
      */
-    pushNamespace(namespace, ident = true) {
+    pushNamespace(namespace, options) {
         this.print(`namespace ${namespace} {`);
-        if (ident)
+        if (options.ident)
             this.pushIndent();
     }
     /**
      * Writes closing brace of namespace block and removes one level of indent
      */
-    popNamespace(ident = true) {
+    popNamespace(options) {
         this.namespaceStack.pop();
-        if (ident)
+        if (options.ident)
             this.popIndent();
         this.print(`}`);
     }

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

@@ -32,4 +32,5 @@ 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

@@ -48,13 +48,13 @@ export class CJTypeNameConvertor {
         throw new Error(`IDL type ${idl.DebugUtils.debugPrintType(type)} not supported`);
     }
     convertNamespace(node) {
-        throw new Error('Method not implemented.');
+        return node.name;
     }
     convertInterface(node) {
-        return node.name;
+        return removePoints(idl.getNamespaceName(node).concat(node.name));
     }
     convertEnum(node) {
-        return node.name;
+        return removePoints(idl.getNamespaceName(node).concat(node.name));
     }
     convertTypedef(node) {
         return node.name;
@@ -95,13 +95,18 @@ export class CJTypeNameConvertor {
                 return this.productType(decl, isTuple, !isTuple);
             }
         }
-        return type.name;
+        let name = type.name.split('.');
+        if (decl) {
+            return idl.getNamespacesPathFor(decl).map(ns => ns.name).join().concat(name[name.length - 1]);
+        }
+        return name[name.length - 1];
     }
     convertTypeParameter(type) {
         return type.name;
     }
     convertPrimitiveType(type) {
         switch (type) {
+            case idl.IDLThisType: return 'this';
             case idl.IDLStringType: return 'String';
             case idl.IDLBooleanType: return 'Bool';
             case idl.IDLNumberType: return 'Float64';
@@ -123,6 +128,10 @@ export class CJTypeNameConvertor {
             case idl.IDLBigintType: return 'Int64';
             case idl.IDLSerializerBuffer: return 'KSerializerBuffer';
             case idl.IDLAnyType: return 'Any';
+            case idl.IDLDate: return 'DateTime';
+            case idl.IDLUnknownType:
+            case idl.IDLFunctionType:
+            case idl.IDLCustomObjectType: return 'Any';
         }
         throw new Error(`Unsupported IDL primitive ${idl.DebugUtils.debugPrintType(type)}`);
     }
@@ -131,8 +140,6 @@ export class CJTypeNameConvertor {
         return `((${params.join(", ")}) -> ${this.convert(decl.returnType)})`;
     }
     productType(decl, isTuple, includeFieldNames) {
-        if (!isTuple)
-            throw new Error('Only tuples supported from IDL synthetic types for now');
         return decl.name;
     }
 }
@@ -178,4 +185,7 @@ 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

@@ -5,6 +5,7 @@ import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
 export interface ConvertResult {
     text: string;
     noPrefix: boolean;
+    resolvedType: idl.IDLType;
 }
 export declare class GenericCppConvertor implements NodeConvertor<ConvertResult> {
     protected resolver: ReferenceResolver;

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

@@ -26,8 +26,8 @@ export class GenericCppConvertor {
     constructor(resolver) {
         this.resolver = resolver;
     }
-    make(text, noPrefix = false) {
-        return { text, noPrefix };
+    make(text, resolvedType, noPrefix = false) {
+        return { text, noPrefix, resolvedType };
     }
     convertNode(node) {
         return convertNode(this, node);
@@ -39,60 +39,65 @@ export class GenericCppConvertor {
         switch (node.subkind) {
             case idl.IDLInterfaceSubkind.AnonymousInterface:
                 return node.name
-                    ? this.make(this.qualifiedName(node))
-                    : this.make(this.computeTargetTypeLiteralName(node), true);
+                    ? this.make(this.qualifiedName(node), idl.createReferenceType(node))
+                    : this.make(this.computeTargetTypeLiteralName(node), idl.createReferenceType(node), true);
             case idl.IDLInterfaceSubkind.Interface:
             case idl.IDLInterfaceSubkind.Class:
                 if (isInIdlizeInternal(node)) {
-                    return this.make(this.qualifiedName(node), true);
+                    return this.make(this.qualifiedName(node), idl.createReferenceType(node), true);
                 }
-                return this.make(this.qualifiedName(node));
+                return this.make(this.qualifiedName(node), idl.createReferenceType(node));
             case idl.IDLInterfaceSubkind.Tuple:
                 return node.name
-                    ? this.make(this.qualifiedName(node))
-                    : this.make(`Tuple_${node.properties.map(it => this.convertNode(idl.maybeOptional(it.type, it.isOptional)).text).join("_")}`, true);
+                    ? this.make(this.qualifiedName(node), idl.createReferenceType(node))
+                    : this.make(`Tuple_${node.properties.map(it => this.convertNode(idl.maybeOptional(it.type, it.isOptional)).text).join("_")}`, idl.createReferenceType(node), true);
         }
     }
     convertEnum(node) {
-        return this.make(this.qualifiedName(node));
+        return this.make(this.qualifiedName(node), idl.createReferenceType(node));
     }
     convertTypedef(node) {
-        return this.make(this.qualifiedName(node));
+        return this.make(this.qualifiedName(node), idl.createReferenceType(node));
     }
     convertCallback(node) {
-        return this.make(generatorConfiguration().LibraryPrefix + this.qualifiedName(node), true);
+        return this.make(generatorConfiguration().LibraryPrefix + this.qualifiedName(node), idl.createReferenceType(node), true);
     }
     convertMethod(node) {
-        return this.make(node.name);
+        return this.make(node.name, idl.createReferenceType(node));
     }
     convertConstant(node) {
-        return this.make(this.qualifiedName(node));
+        return this.make(this.qualifiedName(node), idl.createReferenceType(node));
     }
     /////////////////////////////////////////////////////////////////////////////////////////
     convertOptional(type) {
-        return { text: generatorConfiguration().OptionalPrefix + this.convertNode(type.type).text, noPrefix: true };
+        const converted = this.convertNode(type.type);
+        const prefix = generatorConfiguration().OptionalPrefix;
+        if (idl.isOptionalType(converted.resolvedType)) {
+            return converted;
+        }
+        return this.make(prefix + converted.text, type, true);
     }
     convertUnion(type) {
-        return this.make(type.name, false);
+        return this.make(type.name, type, false);
     }
     convertContainer(type) {
         if (idl.IDLContainerUtils.isPromise(type)) {
-            return this.make(`Promise_${this.convertNode(type.elementType[0]).text}`);
+            return this.make(`Promise_${this.convertNode(type.elementType[0]).text}`, type);
         }
         if (idl.IDLContainerUtils.isSequence(type)) {
             if (type.elementType[0] === idl.IDLU8Type) {
-                return this.make(`uint8_t*`, true);
+                return this.make(`uint8_t*`, type, true);
             }
-            return this.make(`Array_${this.convertNode(type.elementType[0]).text}`, true);
+            return this.make(`Array_${this.convertNode(type.elementType[0]).text}`, type, true);
         }
         if (idl.IDLContainerUtils.isRecord(type)) {
-            return this.make(`Map_${this.convertNode(type.elementType[0]).text}_${this.convertNode(type.elementType[1]).text}`, true);
+            return this.make(`Map_${this.convertNode(type.elementType[0]).text}_${this.convertNode(type.elementType[1]).text}`, type, true);
         }
         throw new Error(`Unmapped container type ${idl.DebugUtils.debugPrintType(type)}`);
     }
     convertImport(type) {
         console.warn("Imports are not implemented yet");
-        return this.make(idl.IDLCustomObjectType.name);
+        return this.make(idl.IDLCustomObjectType.name, idl.IDLCustomObjectType);
     }
     convertTypeReferenceAsImport(type, _) {
         return this.convertTypeReference(type);
@@ -100,14 +105,8 @@ export class GenericCppConvertor {
     convertTypeReference(type) {
         var _a;
         const refName = type.name;
-        switch (refName) {
-            case "object":
-            case "Object":
-                // treat object as interop resource
-                return this.make('Object');
-        }
         if (generatorConfiguration().parameterized.includes(refName)) {
-            return this.make('CustomObject');
+            return this.make('CustomObject', idl.IDLCustomObjectType);
         }
         let decl = this.resolver.toDeclaration(type);
         if (idl.isCallback(decl)) {
@@ -115,45 +114,47 @@ export class GenericCppConvertor {
         }
         if (idl.isType(decl)) {
             if (idl.isReferenceType(decl)) {
-                return this.make(`${capitalize(decl.name)}`);
+                return this.make(`${capitalize(decl.name)}`, decl);
             }
             return this.convertNode(decl);
         }
         let res = this.convertNode(decl);
         if (type.name === "Optional")
-            res = this.make("Opt_" + res.text, true);
+            res = this.make("Opt_" + res.text, idl.createOptionalType(type.typeArguments[0]), true);
         return res;
     }
     convertTypeParameter(type) {
-        return this.make('CustomObject');
+        return this.make('CustomObject', idl.IDLCustomObjectType);
     }
     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(`Int64`); // TODO add arbitrary precision numeric type
-            case idl.IDLPointerType: return this.make('NativePointer');
-            case idl.IDLCustomObjectType: return this.make('CustomObject');
+            case idl.IDLThisType: // maybe fix it in another level?
+            case idl.IDLVoidType: return this.make('void', type, true);
+            case idl.IDLI8Type: return this.make(`Int8`, type);
+            case idl.IDLU8Type: return this.make(`UInt8`, type);
+            case idl.IDLI16Type: return this.make(`Int16`, type);
+            case idl.IDLU16Type: return this.make(`UInt16`, type);
+            case idl.IDLI32Type: return this.make(`Int32`, type);
+            case idl.IDLU32Type: return this.make(`UInt32`, type);
+            case idl.IDLI64Type: return this.make(`Int64`, type);
+            case idl.IDLU64Type: return this.make(`UInt64`, type);
+            case idl.IDLF32Type: return this.make(`Float32`, type);
+            case idl.IDLF64Type: return this.make(`Float64`, type);
+            case idl.IDLNumberType: return this.make(`Number`, type);
+            case idl.IDLStringType: return this.make(`String`, type);
+            case idl.IDLBooleanType: return this.make(`Boolean`, type);
+            case idl.IDLBigintType: return this.make(`Int64`, type); // TODO add arbitrary precision numeric type
+            case idl.IDLPointerType: return this.make('NativePointer', type);
+            case idl.IDLCustomObjectType: return this.make('CustomObject', type);
             case idl.IDLUnknownType:
-            case idl.IDLAnyType: return this.make(`Object`);
-            case idl.IDLUndefinedType: return this.make(`Undefined`);
-            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');
-            case idl.IDLSerializerBuffer: return { text: 'KSerializerBuffer', noPrefix: true };
+            case idl.IDLObjectType:
+            case idl.IDLAnyType: return this.make(`Object`, type);
+            case idl.IDLUndefinedType: return this.make(`Undefined`, type);
+            case idl.IDLFunctionType: return this.make(`Function`, type);
+            case idl.IDLDate: return this.make(`Date`, type);
+            case idl.IDLBufferType: return this.make('Buffer', type);
+            case idl.IDLPointerType: return this.make('Pointer', type);
+            case idl.IDLSerializerBuffer: return this.make('KSerializerBuffer', type, true);
         }
         throw new Error(`Unmapped primitive type ${idl.DebugUtils.debugPrintType(type)}`);
     }

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

@@ -4,7 +4,7 @@ export declare class ETSTypeNameConvertor extends TSTypeNameConvertor {
     convertTypeReference(type: idl.IDLReferenceType): string;
     convertContainer(type: idl.IDLContainerType): string;
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
-    protected productType(decl: idl.IDLInterface, isTuple: boolean, includeFieldNames: boolean): string;
+    protected productType(decl: idl.IDLInterface, args: idl.IDLType[] | undefined, isTuple: boolean, includeFieldNames: boolean): string;
     protected processTupleType(idlProperty: idl.IDLProperty): idl.IDLProperty;
     protected mapCallback(decl: idl.IDLCallback): string;
     protected mapFunctionType(typeArgs: string[]): string;

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

@@ -70,11 +70,11 @@ export class ETSTypeNameConvertor extends TSTypeNameConvertor {
         }
         return super.convertPrimitiveType(type);
     }
-    productType(decl, isTuple, includeFieldNames) {
+    productType(decl, args, isTuple, includeFieldNames) {
         if (decl.subkind === idl.IDLInterfaceSubkind.AnonymousInterface) {
             return decl.name;
         }
-        return super.productType(decl, isTuple, includeFieldNames);
+        return super.productType(decl, args, isTuple, includeFieldNames);
     }
     processTupleType(idlProperty) {
         if (idlProperty.isOptional) {

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

@@ -66,6 +66,7 @@ export class InteropReturnTypeConvertor {
             case idl.IDLThisType:
             case idl.IDLUndefinedType:
             case idl.IDLUnknownType:
+            case idl.IDLObjectType:
             case idl.IDLVoidType: return idl.IDLVoidType.name;
             case idl.IDLBufferType: return KInteropReturnBuffer; /* ArkTS can not return buffer as language object yet */
             case idl.IDLStringType: return PrimitiveTypesInstance.String.getText();

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

@@ -21,8 +21,10 @@ export declare class TSTypeNameConvertor implements NodeConvertor<string>, IdlNa
     convertTypeParameter(type: idl.IDLTypeParameterType): string;
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
     protected processTupleType(idlProperty: idl.IDLProperty): idl.IDLProperty;
-    protected mapCallback(decl: idl.IDLCallback): string;
-    protected productType(decl: idl.IDLInterface, isTuple: boolean, includeFieldNames: boolean): string;
+    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;
 }
 export declare class TSInteropArgConvertor implements TypeConvertor<string> {

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

@@ -88,19 +88,16 @@ export class TSTypeNameConvertor {
     }
     convertTypeReference(type) {
         var _a, _b;
-        if (type.name === idl.IDLObjectType.name) {
-            return type.name;
-        }
         let decl = this.resolver.resolveTypeReference(type);
         if (decl) {
             if (idl.isSyntheticEntry(decl)) {
                 if (idl.isCallback(decl)) {
-                    return this.mapCallback(decl);
+                    return this.mapCallback(decl, type.typeArguments);
                 }
                 const entity = idl.getExtAttribute(decl, idl.IDLExtendedAttributes.Entity);
                 if (entity) {
                     const isTuple = entity === idl.IDLEntity.Tuple;
-                    return this.productType(decl, isTuple, !isTuple);
+                    return this.productType(decl, type.typeArguments, isTuple, !isTuple);
                 }
             }
             // FIXME: isEnumMember is not TYPE!
@@ -133,8 +130,9 @@ export class TSTypeNameConvertor {
         switch (type) {
             case idl.IDLFunctionType: return 'Function';
             case idl.IDLUnknownType:
-            case idl.IDLCustomObjectType: return 'unknown';
+            case idl.IDLCustomObjectType: return 'any';
             case idl.IDLThisType: return 'this';
+            case idl.IDLObjectType: return 'Object';
             case idl.IDLAnyType: return 'any';
             case idl.IDLUndefinedType: return 'undefined';
             case idl.IDLPointerType: return 'KPointer';
@@ -171,13 +169,50 @@ export class TSTypeNameConvertor {
     processTupleType(idlProperty) {
         return idlProperty;
     }
-    mapCallback(decl) {
-        const params = decl.parameters.map(it => `${it.isVariadic ? "..." : ""}${it.name}${it.isOptional ? "?" : ""}: ${this.convert(it.type)}${it.isVariadic ? "[]" : ""}`);
+    createTypeSubstitution(parameters, args) {
+        const subst = new Map();
+        if (args && parameters) {
+            for (let i = 0; i < args.length && i < parameters.length; ++i) {
+                subst.set(parameters[i], args[i]);
+            }
+        }
+        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 => {
+            const param = idl.clone(it);
+            param.type = this.applySubstitution(subst, param.type);
+            return param;
+        });
+        const params = parameters.map(it => `${it.isVariadic ? "..." : ""}${it.name}${it.isOptional ? "?" : ""}: ${this.convert(it.type)}${it.isVariadic ? "[]" : ""}`);
         return `((${params.join(", ")}) => ${this.convert(decl.returnType)})`;
     }
-    productType(decl, isTuple, includeFieldNames) {
+    productType(decl, args, isTuple, includeFieldNames) {
+        const subst = this.createTypeSubstitution(decl.typeParameters, args);
         const name = `${isTuple ? "[" : "{"} ${decl.properties
             .map(it => isTuple ? this.processTupleType(it) : it)
+            .map(it => {
+            const prop = idl.clone(it);
+            prop.type = this.applySubstitution(subst, prop.type);
+            return prop;
+        })
             .map(it => {
             const type = this.convert(it.type);
             return it.isOptional

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

@@ -155,8 +155,13 @@ 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;
+    pushNamespace(namespace: string, options: {
+        ident: boolean;
+        isDeclared?: boolean;
+    }): void;
+    popNamespace(options: {
+        ident: boolean;
+    }): void;
     castToInt(value: string, bitness: 8 | 32): string;
     castToBoolean(value: string): string;
 }

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

@@ -267,8 +267,7 @@ export class CJLanguageWriter extends LanguageWriter {
     }
     getNodeName(type) {
         // rework for proper namespace logic
-        let name = this.typeConvertor.convert(type).split('.');
-        return name[name.length - 1];
+        return this.typeConvertor.convert(type);
     }
     writeClass(name, op, superClass, interfaces, generics) {
         let extendsClause = superClass ? `${superClass}` : undefined;
@@ -320,13 +319,13 @@ export class CJLanguageWriter extends LanguageWriter {
         if (nullable) {
             if (receiver == 'this') {
                 this.printer.print('let thisObj = this');
-                super.writeMethodCall('thisObj', method, params, false);
+                super.writeMethodCall('thisObj', this.escapeKeyword(method), params, false);
                 return;
             }
             this.printer.print(`if (let Some(${receiver}) <- ${receiver}) { ${receiver}.${method}(${params.join(", ")}) }`);
         }
         else {
-            super.writeMethodCall(receiver, method, params, nullable);
+            super.writeMethodCall(receiver, this.escapeKeyword(method), params, nullable);
         }
     }
     writeFieldDeclaration(name, type, modifiers, optional, initExpr) {
@@ -339,7 +338,22 @@ export class CJLanguageWriter extends LanguageWriter {
         this.writeDeclaration(name, signature, modifiers);
     }
     writeConstructorImplementation(className, signature, op, superCall, modifiers) {
-        this.printer.print(`${modifiers ? modifiers.map((it) => MethodModifier[it].toLowerCase()).join(' ') + ' ' : ''}${className}(${signature.args.map((it, index) => `${signature.argName(index)}: ${this.getNodeName(it)}`).join(", ")}) {`);
+        var _a;
+        let i = 1;
+        while (signature.isArgOptional(signature.args.length - i)) {
+            let smallerSignature = signature.args.slice(0, -i);
+            this.printer.print(`${modifiers ? modifiers.map((it) => MethodModifier[it].toLowerCase()).join(' ') + ' ' : ''}init (${smallerSignature.map((it, index) => `${signature.argName(index)}: ${this.getNodeName(it)}`).join(", ")}) {`);
+            this.pushIndent();
+            let smallerArgs = (_a = signature.args) === null || _a === void 0 ? void 0 : _a.slice(0, -i).map((_, i) => signature.argName(i)).join(', ');
+            for (let idx = 0; idx < i; idx++) {
+                smallerArgs = smallerArgs.concat(`${i == signature.args.length && idx == 0 ? '' : ', '}Option.None`);
+            }
+            this.print(`${className}(${smallerArgs})`);
+            this.popIndent();
+            this.printer.print(`}`);
+            i += 1;
+        }
+        this.printer.print(`${modifiers ? modifiers.map((it) => MethodModifier[it].toLowerCase()).join(' ') + ' ' : ''}${className}(${signature.args.map((it, index) => `${signature.argName(index)}: ${this.getNodeName(idl.maybeOptional(it, signature.isArgOptional(index)))}`).join(", ")}) {`);
         this.pushIndent();
         if (superCall) {
             this.print(`super(${superCall.signature.args.map((_, i) => superCall === null || superCall === void 0 ? void 0 : superCall.signature.argName(i)).join(", ")})`);
@@ -416,8 +430,8 @@ export class CJLanguageWriter extends LanguageWriter {
     }
     writeDeclaration(name, signature, modifiers, postfix) {
         let prefix = modifiers === null || modifiers === void 0 ? void 0 : modifiers.filter(it => this.supportedModifiers.includes(it)).map(it => this.mapMethodModifier(it)).join(" ");
-        prefix = prefix ? prefix + " " : "";
-        this.print(`${prefix}${((modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.SETTER)) || (modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.GETTER))) ? '' : 'func '}${name}(${signature.args.map((it, index) => `${this.escapeKeyword(signature.argName(index))}: ${this.getNodeName(it)}`).join(", ")}): ${this.getNodeName(signature.returnType)}${postfix !== null && postfix !== void 0 ? postfix : ""}`);
+        prefix = prefix ? prefix + " " : "public ";
+        this.print(`${prefix}${((modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.SETTER)) || (modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.GETTER))) ? '' : `${((modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.STATIC)) || (modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.PRIVATE))) ? '' : 'open '}func `}${this.escapeKeyword(name)}(${signature.args.map((it, index) => `${this.escapeKeyword(signature.argName(index))}: ${this.getNodeName(idl.maybeOptional(it, signature.isArgOptional(index)))}`).join(", ")})${this.getNodeName(signature.returnType) == 'this' ? '' : `: ${this.getNodeName(signature.returnType)}`}${postfix !== null && postfix !== void 0 ? postfix : ""}`);
     }
     writeNativeFunctionCall(printer, name, signature) {
         printer.print(`return unsafe { ${name}(${signature.args.map((it, index) => `${signature.argName(index)}`).join(", ")}) }`);
@@ -570,10 +584,10 @@ export class CJLanguageWriter extends LanguageWriter {
         this.writeStatement(this.makeAssign(valueType, undefined, this.makeRuntimeTypeGetterCall(value), false));
     }
     escapeKeyword(word) {
-        return CJKeywords.has(word) ? word + "_" : word;
+        return CJKeywords.has(word) ? word.concat("_") : word;
     }
-    pushNamespace(namespace, ident = true) { }
-    popNamespace(ident = true) { }
+    pushNamespace(namespace, options) { }
+    popNamespace(options) { }
     castToInt(value, bitness) {
         return `Int${bitness}(${value})`;
     }

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

@@ -73,6 +73,9 @@ export declare class ETSLanguageWriter extends TSLanguageWriter {
     typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;
     makeTypeCast(value: LanguageExpression, type: idl.IDLType, options?: MakeCastOptions): LanguageExpression;
     makeCast(value: LanguageExpression, node: idl.IDLNode, options?: MakeCastOptions): LanguageExpression;
+    static _isUseTypeChecker: boolean;
+    static get isUseTypeChecker(): boolean;
+    static useTypeChecker<T>(isUseTypeChecker: boolean, op: () => T): T;
 }
 export declare function makeEnumTypeCheckerCall(valueAccessor: string, enumName: string, writer: LanguageWriter): LanguageExpression;
 //# sourceMappingURL=ETSLanguageWriter.d.ts.map