@idlizer/core 2.0.23 → 2.0.25

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

@@ -106,6 +106,15 @@ export declare class NumericConvertor extends BaseArgConvertor {
     interopType(): idl.IDLType;
     isPointerType(): boolean;
 }
+export declare class BigIntToU64Convertor extends BaseArgConvertor {
+    constructor(param: string);
+    convertorArg(param: string, writer: LanguageWriter): string;
+    convertorSerialize(param: string, value: string, printer: LanguageWriter): void;
+    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    nativeType(): idl.IDLType;
+    interopType(): idl.IDLType;
+    isPointerType(): boolean;
+}
 export declare class PointerConvertor extends BaseArgConvertor {
     constructor(param: string);
     convertorArg(param: string, writer: LanguageWriter): string;

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

@@ -242,6 +242,29 @@ export class NumericConvertor extends BaseArgConvertor {
         return false;
     }
 }
+export class BigIntToU64Convertor extends BaseArgConvertor {
+    constructor(param) {
+        super(idl.IDLBigintType, [RuntimeType.BIGINT], false, false, param);
+    }
+    convertorArg(param, writer) {
+        return writer.escapeKeyword(param);
+    }
+    convertorSerialize(param, value, printer) {
+        printer.writeMethodCall(`${param}Serializer`, "writeUInt64", [value]);
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        return assigneer(writer.makeCast(writer.makeString(`${deserializerName}.readUInt64()`), this.idlType, { optional: false }));
+    }
+    nativeType() {
+        return idl.IDLU64Type;
+    }
+    interopType() {
+        return idl.IDLU64Type;
+    }
+    isPointerType() {
+        return false;
+    }
+}
 export class PointerConvertor extends BaseArgConvertor {
     constructor(param) {
         // check numericPrimitiveTypes.include(type)
@@ -887,7 +910,7 @@ export class MaterializedClassConvertor extends BaseArgConvertor {
         throw new Error("Must never be used");
     }
     isPointerType() {
-        return true;
+        return false;
     }
     unionDiscriminator(value, index, writer, duplicates) {
         if (idl.isInterface(this.declaration)) {

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

@@ -1,7 +1,8 @@
 import * as idl from '../../idl';
 import { IdlNameConvertor } from "../nameConvertor";
-import { InteropConvertor } from './InteropConvertors';
+import { InteropConvertor, InteropReturnTypeConvertor } from './InteropConvertors';
 import { InteropArgConvertor } from './InteropConvertors';
+import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
 export declare class CppInteropConvertor extends InteropConvertor implements IdlNameConvertor {
     private unwrap;
     convert(node: idl.IDLNode): string;
@@ -11,4 +12,9 @@ export declare class CppInteropArgConvertor extends InteropArgConvertor {
     convertOptional(type: idl.IDLOptionalType): string;
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
 }
+export declare class CppReturnTypeConvertor extends InteropReturnTypeConvertor {
+    protected resolver: ReferenceResolver;
+    constructor(resolver: ReferenceResolver);
+    convertTypeReference(type: idl.IDLReferenceType): string;
+}
 //# sourceMappingURL=CppConvertors.d.ts.map

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

@@ -14,9 +14,10 @@
  */
 import * as idl from '../../idl';
 import { generatorConfiguration } from "../../config";
-import { InteropConvertor } from './InteropConvertors';
+import { InteropConvertor, InteropReturnTypeConvertor } from './InteropConvertors';
 import { PrimitiveTypesInstance } from '../../peer-generation/PrimitiveType';
 import { InteropArgConvertor } from './InteropConvertors';
+import { isMaterialized } from '../../peer-generation/Materialized';
 export class CppInteropConvertor extends InteropConvertor {
     unwrap(type, result) {
         const conf = generatorConfiguration();
@@ -55,4 +56,16 @@ export class CppInteropArgConvertor extends InteropArgConvertor {
     }
 }
 CppInteropArgConvertor.INSTANCE = new CppInteropArgConvertor();
+export class CppReturnTypeConvertor extends InteropReturnTypeConvertor {
+    constructor(resolver) {
+        super();
+        this.resolver = resolver;
+    }
+    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);
+    }
+}
 //# sourceMappingURL=CppConvertors.js.map

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

@@ -135,6 +135,7 @@ export class InteropConvertor {
             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:
@@ -211,6 +212,7 @@ export class InteropReturnTypeConvertor {
             case idl.IDLF64Type:
             case idl.IDLNumberType: return PrimitiveTypesInstance.Int32.getText();
             case idl.IDLBooleanType: return PrimitiveTypesInstance.Boolean.getText();
+            case idl.IDLBigintType: return PrimitiveTypesInstance.Int64.getText();
             case idl.IDLAnyType:
             case idl.IDLBufferType:
             case idl.IDLStringType:

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

@@ -152,7 +152,7 @@ class CPPThrowErrorStatement {
         this.message = message;
     }
     write(writer) {
-        writer.print(`throw "${this.message}";`);
+        writer.print(`INTEROP_FATAL("${this.message}");`);
     }
 }
 ////////////////////////////////////////////////////////////////

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

@@ -302,6 +302,7 @@ export declare function getFQName(a: IDLEntry): string;
 export declare function createVersion(value: string[], extendedAttributes?: IDLExtendedAttribute[], fileName?: string): IDLVersion;
 export declare function fetchNamespaceFrom(pointOfView?: IDLNode): IDLNamespace | undefined;
 export declare function createReferenceType(name: string, typeArguments?: IDLType[], pointOfView?: IDLNode): IDLReferenceType;
+export declare function createReferenceType(source: IDLEntry, typeArguments?: IDLType[]): IDLReferenceType;
 export declare function createUnspecifiedGenericType(name: string, typeArguments: IDLType[]): IDLUnspecifiedGenericType;
 export declare function entityToType(entity: IDLNode): IDLType;
 export declare function createContainerType(container: IDLContainerKind, element: IDLType[]): IDLContainerType;

package/build/lib/src/idl.js

@@ -409,12 +409,22 @@ export function fetchNamespaceFrom(pointOfView) {
     }
     return undefined;
 }
-export function createReferenceType(name, typeArguments, pointOfView) {
+export function createReferenceType(nameOrSource, typeArguments, pointOfView) {
+    let name;
+    let namespace;
+    if (typeof nameOrSource === 'string') {
+        name = nameOrSource;
+        namespace = fetchNamespaceFrom(pointOfView);
+    }
+    else {
+        name = nameOrSource.name;
+        namespace = fetchNamespaceFrom(nameOrSource);
+    }
     return {
         kind: IDLKind.ReferenceType,
         name,
         typeArguments,
-        namespace: fetchNamespaceFrom(pointOfView),
+        namespace: namespace,
         _idlNodeBrand: innerIdlSymbol,
         _idlTypeBrand: innerIdlSymbol,
         _idlNamedNodeBrand: innerIdlSymbol,

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

@@ -19,7 +19,7 @@ export declare class MaterializedMethod extends PeerMethod {
     get peerMethodName(): string;
     get implNamespaceName(): string;
     get toStringName(): string;
-    get dummyReturnValue(): string | undefined;
+    dummyReturnValue(resolver: ReferenceResolver): string | undefined;
     get receiverType(): string;
     get apiCall(): string;
     get apiKind(): string;

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

@@ -14,17 +14,20 @@
  */
 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.isHandwritten(declaration) ||
-        isBuilderClass(declaration) ||
-        declaration.subkind === idl.IDLInterfaceSubkind.AnonymousInterface ||
-        declaration.subkind === idl.IDLInterfaceSubkind.Tuple) {
+    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))
@@ -32,7 +35,7 @@ export function isMaterialized(declaration, resolver) {
     }
     // A materialized class is a class or an interface with methods
     // excluding components and related classes
-    if (declaration.methods.length > 0)
+    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)) {
@@ -72,7 +75,7 @@ export class MaterializedMethod extends PeerMethod {
             default: return super.toStringName;
         }
     }
-    get dummyReturnValue() {
+    dummyReturnValue(resolver) {
         var _a;
         if (this.method.name === "ctor")
             return `(${this.originalParentName}Peer*) 100`;
@@ -85,7 +88,8 @@ export class MaterializedMethod extends PeerMethod {
             if (this.method.signature.returnType === idl.IDLBooleanType) {
                 return '0';
             }
-            return `(void*) 300`;
+            const convertor = new CppReturnTypeConvertor(resolver);
+            return `(${convertor.convert(this.returnType)}) 300`;
         }
         if (idl.isReferenceType(this.method.signature.returnType)) {
             return "{}";

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

@@ -16,7 +16,7 @@ import { warn } from 'console';
 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, } from "../LanguageWriters/ArgConvertors";
+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 { CJTypeNameConvertor } from '../LanguageWriters/convertors/CJConvertors';
 import { CppInteropConvertor } from '../LanguageWriters/convertors/CppConvertors';
@@ -185,6 +185,7 @@ export class PeerLibrary {
                 case idl.IDLF16Type: return new NumericConvertor(param, type);
                 case idl.IDLF32Type: return new NumericConvertor(param, type);
                 case idl.IDLF64Type: return new NumericConvertor(param, type);
+                case idl.IDLBigintType: return new BigIntToU64Convertor(param);
                 case idl.IDLPointerType: return new PointerConvertor(param);
                 case idl.IDLBufferType: return new BufferConvertor(param);
                 case idl.IDLBooleanType: return new BooleanConvertor(param);

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

@@ -2,6 +2,7 @@ import { IDLType } from "../idl";
 import { IdlNameConvertor } from "../LanguageWriters";
 import { ArgConvertor } from "../LanguageWriters/ArgConvertors";
 import { Method } from "../LanguageWriters/LanguageWriter";
+import { ReferenceResolver } from "./ReferenceResolver";
 export declare class PeerMethod {
     originalParentName: string;
     argConvertors: ArgConvertor[];
@@ -17,7 +18,7 @@ export declare class PeerMethod {
     get implNamespaceName(): string;
     get implName(): string;
     get toStringName(): string;
-    get dummyReturnValue(): string | undefined;
+    dummyReturnValue(resolver: ReferenceResolver): string | undefined;
     get receiverType(): string;
     get apiCall(): string;
     get apiKind(): string;

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

@@ -48,7 +48,7 @@ export class PeerMethod {
     get toStringName() {
         return this.method.name;
     }
-    get dummyReturnValue() {
+    dummyReturnValue(resolver) {
         return undefined;
     }
     get receiverType() {

package/package.json

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