@idlizer/core 2.0.26 → 2.0.28

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

@@ -212,9 +212,10 @@ export interface PrinterLike {
 }
 export declare abstract class LanguageWriter {
     printer: IndentedPrinter;
-    protected resolver: ReferenceResolver;
+    resolver: ReferenceResolver;
     language: Language;
-    constructor(printer: IndentedPrinter, resolver: ReferenceResolver, language: Language);
+    constructor(printer: IndentedPrinter, resolver: ReferenceResolver, // TODO make protected again
+    language: Language);
     indentDepth(): number;
     maybeSemicolon(): string;
     abstract writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[], generics?: string[], isDeclared?: boolean, isExport?: boolean): void;
@@ -319,7 +320,7 @@ export declare abstract class LanguageWriter {
     makeSignature(returnType: idl.IDLType, parameters: idl.IDLParameter[]): MethodSignature;
     makeNamedSignature(returnType: idl.IDLType, parameters: idl.IDLParameter[]): NamedMethodSignature;
     makeNativeMethodNamedSignature(returnType: idl.IDLType, parameters: idl.IDLParameter[]): NamedMethodSignature;
-    makeSerializerConstructorSignature(): NamedMethodSignature | undefined;
+    makeSerializerConstructorSignatures(): NamedMethodSignature[] | undefined;
     mapFieldModifier(modifier: FieldModifier): string;
     mapMethodModifier(modifier: MethodModifier): string;
     /**

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"));
     }
 }
 ////////////////////////////////////////////////////////////////
@@ -387,7 +391,8 @@ export class NamedMethodSignature extends MethodSignature {
 //                    LANGUAGE WRITER                         //
 ////////////////////////////////////////////////////////////////
 export class LanguageWriter {
-    constructor(printer, resolver, language) {
+    constructor(printer, resolver, // TODO make protected again
+    language) {
         this.printer = printer;
         this.resolver = resolver;
         this.language = language;
@@ -588,7 +593,7 @@ export class LanguageWriter {
     makeNativeMethodNamedSignature(returnType, parameters) {
         return this.makeNamedSignature(returnType, parameters);
     }
-    makeSerializerConstructorSignature() {
+    makeSerializerConstructorSignatures() {
         return undefined;
     }
     mapFieldModifier(modifier) {

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().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().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().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;