@idlizer/core 2.1.9-arktscgen-9 → 2.1.10-arktscgen-3

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

@@ -493,7 +493,7 @@ export class AggregateConvertor extends BaseArgConvertor {
             statements.push(assigneer(writer.makeString(bufferName)));
         }
         else if (writer.language == Language.CJ) {
-            const resultExpression = writer.makeString(`${writer.getNodeName(this.idlType)}(${this.decl.properties.map(prop => `${bufferName}_${prop.name}`).join(", ")})`);
+            const resultExpression = writer.makeString(`${writer.getNodeName(this.idlType)}(${this.decl.properties.map(prop => `${bufferName}${capitalize(prop.name)}`).join(", ")})`);
             statements.push(assigneer(resultExpression));
         }
         else if (writer.language == Language.KOTLIN) {
@@ -886,7 +886,7 @@ export class OptionConvertor extends BaseArgConvertor {
         const statements = [];
         statements.push(writer.makeAssign(runtimeBufferName, undefined, writer.makeCast(writer.makeString(`${deserializerName}.readInt8()`), writer.getRuntimeType()), true));
         const bufferType = this.nativeType();
-        statements.push(writer.makeAssign(bufferName, bufferType, (writer.language == Language.CJ || writer.language == Language.KOTLIN) ? writer.makeNull() : undefined, true, false));
+        statements.push(writer.makeAssign(bufferName, bufferType, (writer.language == Language.CJ || writer.language == Language.KOTLIN) ? writer.makeNull(bufferName) : undefined, true, false)); // maybe change to generic None
         const thenStatement = new BlockStatement([
             this.typeConvertor.convertorDeserialize(`${bufferName}_`, deserializerName, (expr) => {
                 const receiver = writer.language === Language.CPP
@@ -1120,7 +1120,7 @@ export class CallbackConvertor extends BaseArgConvertor {
             value = `CallbackTransformer.transformFrom${this.library.getInteropName(this.decl)}(${value})`;
         return writer.makeStatement(writer.makeMethodCall(`${param}Serializer`, `holdAndWriteCallback`, [writer.makeString(`${value}`)]));
     }
-    convertorDeserialize(bufferName, deserializerName, assigneer, writer, useSyncVersion = false) {
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer, useSyncVersion = true) {
         if (writer.language == Language.CPP) {
             const callerInvocation = writer.makeString(`getManagedCallbackCaller(${generateCallbackKindAccess(this.transformedDecl, writer.language)})`);
             const callerSyncInvocation = writer.makeString(`getManagedCallbackCallerSync(${generateCallbackKindAccess(this.transformedDecl, writer.language)})`);
@@ -1181,11 +1181,13 @@ export class CallbackConvertor extends BaseArgConvertor {
             ...continuation,
             new ExpressionStatement(useSyncVersion
                 ? writer.makeNativeCall(this.interopModuleName, `_CallCallbackSync`, [
+                    writer.makeString(generatorConfiguration().ApiKind.toString()),
                     writer.makeString(generateCallbackKindValue(this.decl).toString()),
                     writer.makeSerializedBufferGetter(`${argsSerializer}Serializer`),
                     writer.makeString(`${argsSerializer}Serializer.length()`),
                 ])
                 : writer.makeNativeCall(this.interopModuleName, `_CallCallback`, [
+                    writer.makeString(generatorConfiguration().ApiKind.toString()),
                     writer.makeString(generateCallbackKindValue(this.decl).toString()),
                     writer.makeSerializedBufferGetter(`${argsSerializer}Serializer`),
                     writer.makeString(`${argsSerializer}Serializer.length()`),

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

@@ -230,6 +230,11 @@ export interface ObjectArgs {
 export interface PrinterLike {
     getOutput(): string[];
 }
+export interface NamespaceOptions {
+    ident: boolean;
+    isDeclared?: boolean;
+    isDefault?: boolean;
+}
 export declare abstract class LanguageWriter {
     printer: IndentedPrinter;
     resolver: ReferenceResolver;
@@ -298,7 +303,7 @@ export declare abstract class LanguageWriter {
     }): LanguageWriter;
     concat(other: PrinterLike): this;
     printTo(file: string): void;
-    writeLines(lines: string): void;
+    writeLines(lines: string | stringOrNone[]): void;
     writeGetterImplementation(method: Method, op: (writer: this) => void): void;
     writeSetterImplementation(method: Method, op: (writer: this) => void): void;
     writeSuperCall(params: string[]): void;
@@ -381,10 +386,7 @@ export declare abstract class LanguageWriter {
      * Writes `namespace <namespace> {` and adds extra indent
      * @param namespace Namespace to begin
      */
-    pushNamespace(namespace: string, options: {
-        ident: boolean;
-        isDeclared?: boolean;
-    }): void;
+    pushNamespace(namespace: string, options: NamespaceOptions): void;
     /**
      * Writes closing brace of namespace block and removes one level of indent
      */

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

@@ -440,7 +440,9 @@ export class LanguageWriter {
         fs.writeFileSync(file, this.getOutput().join("\n"));
     }
     writeLines(lines) {
-        lines.split("\n").forEach(it => this.print(it));
+        if (typeof lines === 'string')
+            lines = lines.split("\n");
+        lines.forEach(it => this.print(it));
     }
     writeGetterImplementation(method, op) {
         var _a;

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

@@ -14,6 +14,7 @@
  */
 import * as idl from '../../idl';
 import { CJKeywords } from '../../languageSpecificKeywords';
+import { generateSyntheticIdlNodeName } from '../../peer-generation/idl/common';
 import { convertNode, convertType } from '../nameConvertor';
 import { InteropArgConvertor } from './InteropConvertors';
 export class CJTypeNameConvertor {
@@ -33,7 +34,7 @@ export class CJTypeNameConvertor {
         return `Option<${this.convert(type.type)}>`;
     }
     convertUnion(type) {
-        return type.name;
+        return "Union_" + type.types.map(it => generateSyntheticIdlNodeName(it)).join("_");
     }
     convertContainer(type) {
         if (idl.IDLContainerUtils.isSequence(type)) {

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

@@ -122,9 +122,11 @@ export class InteropArgConvertor {
         switch (type) {
             case idl.IDLI64Type: return "KLong";
             case idl.IDLU64Type: return "KLong";
+            case idl.IDLU8Type: return "KInt";
             case idl.IDLI32Type: return "KInt";
             case idl.IDLU32Type: return "KInt";
             case idl.IDLF32Type: return "KFloat";
+            case idl.IDLF64Type: return "KDouble";
             case idl.IDLNumberType: return 'KInteropNumber';
             case idl.IDLBigintType: return 'KLong';
             case idl.IDLSerializerBuffer: return 'KSerializerBuffer';

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

@@ -154,6 +154,8 @@ export class JavaTypeNameConvertor {
             case 'KLong': return 'long';
             case 'float32':
             case 'KFloat': return 'float';
+            case 'float64':
+            case 'KDouble': return 'double';
             case 'KUint8ArrayPtr': return 'byte[]';
             case 'KInt32ArrayPtr': return 'int[]';
             case 'KFloat32ArrayPtr': return 'float[]';
@@ -191,6 +193,7 @@ export class JavaInteropArgConvertor extends InteropArgConvertor {
             case idl.IDLI32Type: return "int";
             case idl.IDLU32Type: return "int";
             case idl.IDLF32Type: return "float";
+            case idl.IDLF64Type: return "double";
             case idl.IDLBigintType: return "long";
             case idl.IDLSerializerBuffer: return "long";
             case idl.IDLFunctionType: return "int";

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

@@ -133,6 +133,7 @@ const KBoolean = "KBoolean";
 const KInt = "KInt";
 const KLong = "KLong";
 const KFloat = "KFloat";
+const KDouble = "KDouble";
 const KNativePointer = "KNativePointer";
 const KInteropNumber = "KInteropNumber";
 const KStringPtr = "KStringPtr";
@@ -216,6 +217,7 @@ export class KotlinCInteropArgConvertor {
             case idl.IDLI32Type: return KInt;
             case idl.IDLU32Type: return KInt;
             case idl.IDLF32Type: return KFloat;
+            case idl.IDLF64Type: return KDouble;
             case idl.IDLNumberType: return KInteropNumber;
             case idl.IDLBigintType: return KLong;
             case idl.IDLSerializerBuffer: return KSerializerBuffer;

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

@@ -166,7 +166,7 @@ export class TSTypeNameConvertor {
             case idl.IDLDate:
                 return 'Date';
             case idl.IDLBufferType:
-                return 'NativeBuffer';
+                return 'ArrayBuffer';
             case idl.IDLInteropReturnBufferType:
                 return `KInteropReturnBuffer`;
         }
@@ -248,9 +248,11 @@ export class TSInteropArgConvertor {
         switch (type) {
             case idl.IDLI64Type: return "KLong";
             case idl.IDLU64Type: return "KLong";
+            case idl.IDLU8Type: return "KInt";
             case idl.IDLI32Type: return "KInt";
             case idl.IDLU32Type: return "KInt";
             case idl.IDLF32Type: return "KFloat";
+            case idl.IDLF64Type: return "KDouble";
             case idl.IDLNumberType: return 'number';
             case idl.IDLBigintType: return 'bigint';
             case idl.IDLBooleanType:

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

@@ -2,7 +2,7 @@ import * as idl from "../../idl";
 import { IndentedPrinter } from "../../IndentedPrinter";
 import { ArgConvertor, BaseArgConvertor } from "../ArgConvertors";
 import { RuntimeType } from "../common";
-import { AssignStatement, DelegationCall, FieldModifier, LanguageExpression, LanguageStatement, LanguageWriter, MakeCastOptions, Method, MethodModifier, MethodSignature, ObjectArgs } from "../LanguageWriter";
+import { AssignStatement, DelegationCall, FieldModifier, LanguageExpression, LanguageStatement, LanguageWriter, MakeCastOptions, Method, MethodModifier, MethodSignature, NamespaceOptions, ObjectArgs } from "../LanguageWriter";
 import { IdlNameConvertor } from "../nameConvertor";
 import { Language } from "../../Language";
 import { ReferenceResolver } from "../../peer-generation/ReferenceResolver";
@@ -154,10 +154,7 @@ 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, options: {
-        ident: boolean;
-        isDeclared?: boolean;
-    }): void;
+    pushNamespace(namespace: string, options: NamespaceOptions): void;
     popNamespace(options: {
         ident: boolean;
     }): void;

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

@@ -16,7 +16,7 @@ import * as idl from "../../idl";
 import { IndentedPrinter } from "../../IndentedPrinter";
 import { CJKeywords } from "../../languageSpecificKeywords";
 import { RuntimeType } from "../common";
-import { AssignStatement, BlockStatement, ExpressionStatement, FieldModifier, LambdaExpression, LanguageWriter, MethodModifier, MethodSignature, ReturnStatement, StringExpression } from "../LanguageWriter";
+import { AssignStatement, BlockStatement, DelegationType, ExpressionStatement, FieldModifier, LambdaExpression, LanguageWriter, MethodModifier, MethodSignature, ReturnStatement } from "../LanguageWriter";
 import { Language } from "../../Language";
 import { indentedBy, isDefined } from "../../util";
 ////////////////////////////////////////////////////////////////
@@ -40,7 +40,7 @@ export class CJCheckDefinedExpression {
         this.value = value;
     }
     asString() {
-        return `${this.value}.isSome()`;
+        return `let Some(${this.value}) <- ${this.value}`;
     }
 }
 export class CJCastExpression {
@@ -328,22 +328,22 @@ export class CJLanguageWriter extends LanguageWriter {
         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.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(`${className}(${lessArgs})`);
+            this.print(`this(${lessArgs})`);
             this.popIndent();
             this.printer.print(`}`);
             i += 1;
         }
-        this.printer.print(`${modifiers ? modifiers.map((it) => MethodModifier[it].toLowerCase()).join(' ') + ' ' : ''}${className}(${signature.args.map((it, index) => `${this.escapeKeyword(signature.argName(index))}: ${this.getNodeName(idl.maybeOptional(it, signature.isArgOptional(index)))}`).join(", ")}) {`);
+        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) {
-            // TBD: check delegationType to write "this" or "super"
-            this.print(`super(${delegationCall.delegationArgs.map(it => it.asString()).join(", ")})`);
+            const delegationType = ((delegationCall === null || delegationCall === void 0 ? void 0 : delegationCall.delegationType) == DelegationType.THIS) ? "this" : "super";
+            this.print(`${delegationType}(${delegationCall.delegationArgs.map(it => it.asString()).join(", ")})`);
         }
         op(this);
         this.popIndent();
@@ -528,7 +528,7 @@ export class CJLanguageWriter extends LanguageWriter {
         return this.makeStatement(this.makeMethodCall(keyAccessor, "add", [this.makeString(key), this.makeString(value)]));
     }
     makeNull(value) {
-        return new StringExpression(`Option.None`);
+        return this.makeUndefined();
     }
     getTagType() {
         return idl.createReferenceType("Tags");

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

@@ -1,5 +1,5 @@
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { LambdaExpression, LanguageExpression, LanguageStatement, LanguageWriter, MakeAssignOptions, MakeCastOptions, Method, MethodModifier, MethodSignature } from "../LanguageWriter";
+import { LambdaExpression, LanguageExpression, LanguageStatement, LanguageWriter, MakeAssignOptions, MakeCastOptions, Method, MethodModifier, MethodSignature, NamespaceOptions } from "../LanguageWriter";
 import { TSLanguageWriter } from "./TsLanguageWriter";
 import { IDLEnum, IDLType } from '../../idl';
 import { ArgConvertor } from "../ArgConvertors";
@@ -45,6 +45,7 @@ export declare function makeArrayTypeCheckCall(valueAccessor: string, typeName:
 export declare class ETSLanguageWriter extends TSLanguageWriter {
     private arrayConvertor;
     constructor(printer: IndentedPrinter, resolver: ReferenceResolver, typeConvertor: IdlNameConvertor, arrayConvertor: IdlNameConvertor);
+    pushNamespace(namespace: string, options: NamespaceOptions): void;
     fork(options?: {
         resolver?: ReferenceResolver;
     }): LanguageWriter;

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

@@ -175,6 +175,12 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         super(printer, resolver, typeConvertor, Language.ARKTS);
         this.arrayConvertor = arrayConvertor;
     }
+    pushNamespace(namespace, options) {
+        if (options.isDefault) {
+            this.print(`export default ${namespace}`);
+        }
+        super.pushNamespace(namespace, options);
+    }
     fork(options) {
         var _a;
         return new ETSLanguageWriter(new IndentedPrinter([], this.indentDepth()), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.arrayConvertor);

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

@@ -1,7 +1,7 @@
 import * as idl from '../../idl';
 import { Language } from '../../Language';
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { AssignStatement, DelegationCall, FieldModifier, LanguageExpression, LanguageStatement, LanguageWriter, MakeAssignOptions, MakeCastOptions, Method, MethodModifier, MethodSignature, ObjectArgs } from "../LanguageWriter";
+import { AssignStatement, DelegationCall, FieldModifier, LanguageExpression, LanguageStatement, LanguageWriter, MakeAssignOptions, MakeCastOptions, Method, MethodModifier, MethodSignature, NamespaceOptions, ObjectArgs } from "../LanguageWriter";
 import { ArgConvertor } from "../ArgConvertors";
 import { IdlNameConvertor } from "../nameConvertor";
 import { RuntimeType } from "../common";
@@ -141,10 +141,7 @@ export declare class KotlinLanguageWriter extends LanguageWriter {
     makeNewObject(objectName: string, params?: LanguageExpression[]): LanguageExpression;
     escapeKeyword(keyword: string): string;
     makeStaticBlock(op: (writer: LanguageWriter) => void): void;
-    pushNamespace(namespace: string, options: {
-        ident: boolean;
-        isDeclared?: boolean;
-    }): void;
+    pushNamespace(namespace: string, options: NamespaceOptions): void;
     popNamespace(options: {
         ident: boolean;
     }): void;

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

@@ -1,7 +1,7 @@
 import * as idl from '../../idl';
 import { Language } from '../../Language';
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { DelegationCall, FieldModifier, LambdaExpression, LanguageExpression, LanguageStatement, LanguageWriter, MakeAssignOptions, MakeCastOptions, Method, MethodModifier, MethodSignature, ObjectArgs, ReturnStatement } from "../LanguageWriter";
+import { DelegationCall, FieldModifier, LambdaExpression, LanguageExpression, LanguageStatement, LanguageWriter, MakeAssignOptions, MakeCastOptions, Method, MethodModifier, MethodSignature, NamespaceOptions, ObjectArgs, ReturnStatement } from "../LanguageWriter";
 import { ArgConvertor } from "../ArgConvertors";
 import { IdlNameConvertor } from "../nameConvertor";
 import { RuntimeType } from "../common";
@@ -32,10 +32,7 @@ export declare class TSLanguageWriter extends LanguageWriter {
     protected typeConvertor: IdlNameConvertor;
     constructor(printer: IndentedPrinter, resolver: ReferenceResolver, typeConvertor: IdlNameConvertor, language?: Language);
     maybeSemicolon(): string;
-    pushNamespace(namespace: string, options: {
-        ident: boolean;
-        isDeclared?: boolean;
-    }): void;
+    pushNamespace(namespace: string, options: NamespaceOptions): void;
     fork(options?: {
         resolver?: ReferenceResolver;
     }): LanguageWriter;