@idlizer/core 2.1.10-arktscgen-3a → 2.1.10-arktscgen-4

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

@@ -343,5 +343,17 @@ export declare function generateCallbackKindAccess(callback: idl.IDLCallback, la
 export declare function generateCallbackKindValue(callback: idl.IDLCallback): number;
 export declare function generateCallbackAPIArguments(library: LibraryInterface, callback: idl.IDLCallback): string[];
 export declare function maybeTransformManagedCallback(callback: idl.IDLCallback, library: ReferenceResolver): idl.IDLCallback | undefined;
+export declare class TransformOnSerializeConvertor extends BaseArgConvertor {
+    protected library: PeerLibrary;
+    protected managedDeclaration: idl.IDLEntry;
+    protected target: idl.IDLType;
+    private targetConvertor;
+    constructor(param: string, library: PeerLibrary, managedDeclaration: idl.IDLEntry, target: idl.IDLType);
+    isPointerType(): boolean;
+    nativeType(): idl.IDLType;
+    convertorArg(param: string, writer: LanguageWriter): string;
+    convertorSerialize(param: string, value: string, writer: LanguageWriter): LanguageStatement;
+    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+}
 export declare function createOutArgConvertor(library: PeerLibrary, type: idl.IDLType | undefined, otherParams: string[]): ArgConvertor | undefined;
 //# sourceMappingURL=ArgConvertors.d.ts.map

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

@@ -17,7 +17,7 @@ import { Language } from "../Language";
 import { BlockStatement, PrintHint, StringExpression, MethodModifier, NamedMethodSignature, ProxyStatement, ExpressionStatement } from "./LanguageWriter";
 import { RuntimeType } from "./common";
 import { generatorConfiguration, generatorTypePrefix } from "../config";
-import { capitalize, getExtractor, hashCodeFromString, throwException, warn } from "../util";
+import { capitalize, getExtractor, getTransformer, hashCodeFromString, throwException, warn } from "../util";
 import { UnionRuntimeTypeChecker } from "../peer-generation/unions";
 import { CppConvertor, CppNameConvertor } from "./convertors/CppConvertors";
 import { createEmptyReferenceResolver } from "../peer-generation/ReferenceResolver";
@@ -579,7 +579,7 @@ export class InterfaceConvertor extends BaseArgConvertor {
     convertorSerialize(param, value, writer) {
         const accessor = getSerializerName(this.declaration);
         writer.addFeature(accessor, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
-        return writer.makeStatement(writer.makeStaticMethodCall(accessor, 'write', [writer.makeString(`${param}Serializer`), writer.makeString(value)]));
+        return writer.makeStatement(writer.makeStaticMethodCall(accessor, 'write', [writer.makeString(`${param}Serializer`), writer.makeString(writer.escapeKeyword(value))]));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
         const accessor = getSerializerName(this.declaration);
@@ -1022,7 +1022,6 @@ export class MaterializedClassConvertor extends BaseArgConvertor {
             case Language.CPP:
                 return `static_cast<${generatorTypePrefix()}${qualifiedName(this.declaration, "_", "namespace.name")}>(${param})`;
             case Language.JAVA:
-            case Language.KOTLIN:
             case Language.CJ:
                 return `MaterializedBase.toPeerPtr(${writer.escapeKeyword(param)})`;
             default:
@@ -1295,6 +1294,59 @@ class PromiseOutArgConvertor extends BaseArgConvertor {
         return true;
     }
 }
+export class TransformOnSerializeConvertor extends BaseArgConvertor {
+    constructor(param, library, managedDeclaration, target) {
+        const targetConvertor = library.typeConvertor(param, target);
+        super(target, targetConvertor.runtimeTypes, false, targetConvertor.useArray, param);
+        this.library = library;
+        this.managedDeclaration = managedDeclaration;
+        this.target = target;
+        this.targetConvertor = targetConvertor;
+    }
+    isPointerType() {
+        return this.targetConvertor.isPointerType();
+    }
+    nativeType() {
+        return this.targetConvertor.nativeType();
+    }
+    convertorArg(param, writer) {
+        throw new Error("Method not implemented.");
+    }
+    convertorSerialize(param, value, writer) {
+        if (writer.language === Language.CPP) {
+            return this.targetConvertor.convertorSerialize(param, value, writer);
+        }
+        if (idl.isReferenceType(this.target)) {
+            writer.addFeature(this.target);
+        }
+        const transformerInfo = getTransformer(this.library, this.managedDeclaration, this.target);
+        const transformCallExpression = transformerInfo.receiver
+            ? writer.makeMethodCall(transformerInfo.receiver, transformerInfo.method, [writer.makeString(value)])
+            : writer.makeFunctionCall(transformerInfo.method, [writer.makeString(value)]);
+        const statements = [
+            writer.makeAssign(`${value}Transformed`, this.target, transformCallExpression, true),
+            this.targetConvertor.convertorSerialize(param, `${value}Transformed`, writer)
+        ];
+        return writer.makeBlock(statements, false);
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        if (writer.language === Language.CPP) {
+            return this.targetConvertor.convertorDeserialize(bufferName, deserializerName, assigneer, writer);
+        }
+        if (idl.isReferenceType(this.target)) {
+            writer.addFeature(this.target);
+        }
+        const targetDeserialize = this.targetConvertor.convertorDeserialize(`${bufferName}D`, deserializerName, (expr) => writer.makeAssign(`${bufferName}Deserialized`, this.target, expr, true), writer);
+        const transformerInfo = getTransformer(this.library, this.target, this.managedDeclaration);
+        const transformCallExpression = transformerInfo.receiver
+            ? writer.makeMethodCall(transformerInfo.receiver, transformerInfo.method, [writer.makeString(`${bufferName}Deserialized`)])
+            : writer.makeFunctionCall(transformerInfo.method, [writer.makeString(`${bufferName}Deserialized`)]);
+        return writer.makeBlock([
+            targetDeserialize,
+            assigneer(transformCallExpression)
+        ], false);
+    }
+}
 export function createOutArgConvertor(library, type, otherParams) {
     if (type && idl.isContainerType(type) && idl.IDLContainerUtils.isPromise(type)) {
         const param = (entropy) => `outputArgumentForReturningPromise${entropy || ''}`;

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

@@ -244,7 +244,15 @@ export declare abstract class LanguageWriter {
     language: Language);
     indentDepth(): number;
     maybeSemicolon(): string;
-    features: [string, string][];
+    features: ({
+        type: "raw";
+        feature: string;
+        module: string;
+    } | {
+        type: "idl";
+        node: idl.IDLEntry | idl.IDLReferenceType;
+    })[];
+    addFeature(node: idl.IDLEntry | idl.IDLReferenceType): void;
     addFeature(feature: string, module: string): void;
     abstract writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[], generics?: string[], isDeclared?: boolean, isExport?: boolean): void;
     abstract writeEnum(name: string, members: {

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

@@ -278,8 +278,11 @@ export class LambdaExpression {
         if (this.body) {
             writer.writeStatement(new BlockStatement(this.body, isScoped, false));
         }
-        writer.features.forEach(([feature, module]) => {
-            this.originalWriter.addFeature(feature, module);
+        writer.features.forEach((feature) => {
+            if (feature.type === "raw")
+                this.originalWriter.addFeature(feature.feature, feature.module);
+            else
+                this.originalWriter.addFeature(feature.node);
         });
         return writer.getOutput()
             .map(line => (line.endsWith('{') || line.endsWith('}') || line.endsWith(';')) ? line : `${line};`)
@@ -421,8 +424,11 @@ export class LanguageWriter {
         return this.printer.indentDepth();
     }
     maybeSemicolon() { return ";"; }
-    addFeature(feature, module) {
-        this.features.push([feature, module]);
+    addFeature(featureOrNode, module) {
+        if (typeof featureOrNode === "string")
+            this.features.push({ type: "raw", feature: featureOrNode, module: module });
+        else
+            this.features.push({ type: "idl", node: featureOrNode });
     }
     // version of makeCast which uses TypeCheck.typeCast<T>(value) call for ETS language writer
     // Use it only if TypeChecker class is added as import to the generated file

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

@@ -149,7 +149,7 @@ export class CJTypeNameConvertor {
         throw new Error(`Unsupported IDL primitive ${idl.DebugUtils.debugPrintType(type)}`);
     }
     callbackType(decl) {
-        const params = decl.parameters.map(it => `${CJKeywords.has(it.name) ? it.name.concat("_") : it.name}: ${this.convert(it.type)}`);
+        const params = decl.parameters.map(it => `${CJKeywords.has(it.name) ? it.name.concat("_") : it.name}: ${it.isOptional ? "?" : ""}${this.convert(it.type)}`);
         return `((${params.join(", ")}) -> ${this.convert(decl.returnType)})`;
     }
     productType(decl, isTuple, includeFieldNames) {

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

@@ -158,6 +158,8 @@ export declare class CJLanguageWriter extends LanguageWriter {
     popNamespace(options: {
         ident: boolean;
     }): void;
+    instanceOf(value: string, type: idl.IDLType): LanguageExpression;
+    discriminate(value: string, index: number, type: idl.IDLType, runtimeTypes: RuntimeType[]): string;
     castToInt(value: string, bitness: 8 | 32): string;
     castToBoolean(value: string): string;
 }

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

@@ -324,21 +324,6 @@ export class CJLanguageWriter extends LanguageWriter {
         this.writeDeclaration(name, signature, modifiers);
     }
     writeConstructorImplementation(className, signature, op, delegationCall, modifiers) {
-        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) => `${this.escapeKeyword(signature.argName(index))}: ${this.getNodeName(it)}`).join(", ")}) {`);
-            this.pushIndent();
-            let lessArgs = (_a = signature.args) === null || _a === void 0 ? void 0 : _a.slice(0, -i).map((_, i) => this.escapeKeyword(signature.argName(i))).join(', ');
-            for (let idx = 0; idx < i; idx++) {
-                lessArgs = lessArgs.concat(`${i == signature.args.length && idx == 0 ? '' : ', '}Option.None`);
-            }
-            this.print(`this(${lessArgs})`);
-            this.popIndent();
-            this.printer.print(`}`);
-            i += 1;
-        }
         this.printer.print(`${modifiers ? modifiers.map((it) => MethodModifier[it].toLowerCase()).join(' ') + ' ' : ''}init(${signature.args.map((it, index) => `${this.escapeKeyword(signature.argName(index))}: ${this.getNodeName(idl.maybeOptional(it, signature.isArgOptional(index)))}`).join(", ")}) {`);
         this.pushIndent();
         if (delegationCall) {
@@ -574,6 +559,17 @@ export class CJLanguageWriter extends LanguageWriter {
     }
     pushNamespace(namespace, options) { }
     popNamespace(options) { }
+    instanceOf(value, type) {
+        return this.makeString(`${value} is ${this.getNodeName(type)}`);
+    }
+    discriminate(value, index, type, runtimeTypes) {
+        if (runtimeTypes.includes(RuntimeType.UNDEFINED)) {
+            return `${value}.isNone()`;
+        }
+        else {
+            return `${value}.getSelector() == ${index}`;
+        }
+    }
     castToInt(value, bitness) {
         return `Int${bitness}(${this.escapeKeyword(value)})`;
     }

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

@@ -176,9 +176,6 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         this.arrayConvertor = arrayConvertor;
     }
     pushNamespace(namespace, options) {
-        if (options.isDefault) {
-            this.print(`export default ${namespace}`);
-        }
         super.pushNamespace(namespace, options);
     }
     fork(options) {

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

@@ -127,6 +127,9 @@ export class TSLanguageWriter extends LanguageWriter {
     pushNamespace(namespace, options) {
         this.namespaceStack.push(namespace);
         const declaredPrefix = options.isDeclared ? "declare " : "";
+        if (options.isDefault) {
+            this.print(`export default ${namespace}`);
+        }
         this.print(`export ${declaredPrefix}namespace ${namespace} {`);
         if (options.ident)
             this.pushIndent();