@idlizer/core 2.1.10-arktscgen-2 → 2.1.10-arktscgen-3

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

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

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

@@ -322,31 +322,6 @@ export class NumericConvertor extends BaseArgConvertor {
         return false;
     }
 }
-// TODO use NumericConvertor when double is implemented as interop type
-export class DoubleConvertor extends BaseArgConvertor {
-    constructor(param) {
-        // check numericPrimitiveTypes.include(type)
-        super(idl.IDLF64Type, [RuntimeType.NUMBER], false, true, param);
-    }
-    convertorArg(param, writer) {
-        return param;
-    }
-    convertorSerialize(param, value, writer) {
-        return writer.makeStatement(writer.makeMethodCall(`${param}Serializer`, `writeFloat64`, [writer.makeString(value)]));
-    }
-    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
-        return assigneer(writer.makeString(`${deserializerName}.readFloat64()`));
-    }
-    nativeType() {
-        return this.idlType;
-    }
-    interopType() {
-        return this.idlType;
-    }
-    isPointerType() {
-        return false;
-    }
-}
 export class BigIntToU64Convertor extends BaseArgConvertor {
     constructor(param) {
         super(idl.IDLBigintType, [RuntimeType.BIGINT], false, false, param);
@@ -518,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) {
@@ -911,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

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

@@ -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;

package/build/lib/src/from-idl/deserialize.js

@@ -289,6 +289,7 @@ class IDLDeserializer {
     toIDLConstructor(file, node) {
         return this.withInfo(node, idl.createConstructor(node.arguments.map(it => this.toIDLParameter(file, it)), undefined, {
             documentation: this.makeDocs(node),
+            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
         }));
     }
     toIDLParameter(file, node) {

package/build/lib/src/from-idl/parser.d.ts

@@ -5,12 +5,12 @@ export declare class FatalParserException extends Error {
     constructor(diagnosticMessages?: DiagnosticMessage[]);
 }
 declare enum TokenKind {
-    Words = "Words",
-    Literal = "Literal",
-    Symbol = "Symbol",
-    Comment = "Comment",
-    Whitespace = "Space",
-    End = "End"
+    Words = 0,
+    Literal = 1,
+    Symbol = 2,
+    Comment = 3,
+    Whitespace = 4,
+    End = 5
 }
 interface Token {
     kind: TokenKind;

package/build/lib/src/from-idl/parser.js

@@ -39,12 +39,12 @@ export class FatalParserException extends Error {
 }
 var TokenKind;
 (function (TokenKind) {
-    TokenKind["Words"] = "Words";
-    TokenKind["Literal"] = "Literal";
-    TokenKind["Symbol"] = "Symbol";
-    TokenKind["Comment"] = "Comment";
-    TokenKind["Whitespace"] = "Space";
-    TokenKind["End"] = "End";
+    TokenKind[TokenKind["Words"] = 0] = "Words";
+    TokenKind[TokenKind["Literal"] = 1] = "Literal";
+    TokenKind[TokenKind["Symbol"] = 2] = "Symbol";
+    TokenKind[TokenKind["Comment"] = 3] = "Comment";
+    TokenKind[TokenKind["Whitespace"] = 4] = "Whitespace";
+    TokenKind[TokenKind["End"] = 5] = "End";
 })(TokenKind || (TokenKind = {}));
 const supportedDeclarations = new Set(["attribute", "callback", "const", "constructor", "dictionary",
     "enum", "import", "interface", "namespace", "package", "typedef", "version"]);
@@ -97,13 +97,17 @@ export class Parser {
     }
     parseIDL() {
         var _a;
+        trac("parseIDL");
         const previousDiagnosticsCount = DiagnosticMessageGroup.allGroupsEntries.length;
         try {
-            trac("parseIDL");
             this._lexerNext();
             this._prevToken = this._curToken;
             let file = this.parseFile();
             file.text = this.content;
+            if (DiagnosticMessageGroup.allGroupsEntries.length != previousDiagnosticsCount) {
+                // Empty for now, messages will be added in following `catch`.
+                throw new FatalParserException();
+            }
             return file;
         }
         catch (e) {

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

@@ -59,6 +59,7 @@ export declare enum IDLExtendedAttributes {
     OriginalGenericName = "OriginalGenericName",
     Predefined = "Predefined",
     Protected = "Protected",
+    Abstract = "Abstract",
     Synthetic = "Synthetic",
     Throws = "Throws",
     TraceKey = "TraceKey",

package/build/lib/src/idl.js

@@ -78,6 +78,7 @@ export var IDLExtendedAttributes;
     IDLExtendedAttributes["OriginalGenericName"] = "OriginalGenericName";
     IDLExtendedAttributes["Predefined"] = "Predefined";
     IDLExtendedAttributes["Protected"] = "Protected";
+    IDLExtendedAttributes["Abstract"] = "Abstract";
     IDLExtendedAttributes["Synthetic"] = "Synthetic";
     IDLExtendedAttributes["Throws"] = "Throws";
     IDLExtendedAttributes["TraceKey"] = "TraceKey";

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

@@ -13,10 +13,11 @@ export declare class MaterializedField {
     constructor(field: Field, argConvertor: ArgConvertor, outArgConvertor?: ArgConvertor | undefined, isNullableOriginalTypeField?: boolean | undefined, extraMethodName?: string | undefined);
 }
 export declare class MaterializedMethod extends PeerMethod {
+    decl: idl.IDLConstructor | idl.IDLMethod | undefined;
     implementationParentName: string;
-    constructor(sig: PeerMethodSignature, originalParentName: string, implementationParentName: string, returnType: idl.IDLType, isCallSignature: boolean, uniqueOverloadName: string, method: Method);
+    constructor(decl: idl.IDLConstructor | idl.IDLMethod | undefined, sig: PeerMethodSignature, originalParentName: string, implementationParentName: string, returnType: idl.IDLType, isCallSignature: boolean, uniqueOverloadName: string, method: Method);
     tsReturnType(): idl.IDLType | undefined;
-    getPrivateMethod(): MaterializedMethod;
+    getPrivateMethod(asProtected?: boolean): MaterializedMethod;
     withReturnType(returnType: idl.IDLType): MaterializedMethod;
 }
 export declare function copyMaterializedMethod(method: MaterializedMethod, overrides: {
@@ -36,9 +37,10 @@ export declare class MaterializedClass implements PeerClassBase {
     readonly methods: MaterializedMethod[];
     readonly needBeGenerated: boolean;
     readonly taggedMethods: idl.IDLMethod[];
+    readonly isRefCounted: boolean;
     constructor(decl: idl.IDLInterface, className: string, isInterface: boolean, isStaticMaterialized: boolean, superClass: idl.IDLReferenceType | undefined, interfaces: idl.IDLReferenceType[] | undefined, generics: string[] | undefined, fields: MaterializedField[], ctors: MaterializedMethod[], // zero size when used for global functions
     finalizer: MaterializedMethod | undefined, // undefined when used for global functions
-    methods: MaterializedMethod[], needBeGenerated?: boolean, taggedMethods?: idl.IDLMethod[]);
+    methods: MaterializedMethod[], needBeGenerated?: boolean, taggedMethods?: idl.IDLMethod[], isRefCounted?: boolean);
     getImplementationName(): string;
     generatedName(isCallSignature: boolean): string;
     private _isGlobal;

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

@@ -27,14 +27,15 @@ export class MaterializedField {
     }
 }
 export class MaterializedMethod extends PeerMethod {
-    constructor(sig, originalParentName, implementationParentName, returnType, isCallSignature, uniqueOverloadName, method) {
-        super(sig, originalParentName, returnType, isCallSignature, uniqueOverloadName, method);
+    constructor(decl, sig, originalParentName, implementationParentName, returnType, isCallSignature, uniqueOverloadName, method) {
+        super(decl, sig, originalParentName, returnType, isCallSignature, uniqueOverloadName, method);
+        this.decl = decl;
         this.implementationParentName = implementationParentName;
     }
     tsReturnType() {
         return this.method.signature.returnType;
     }
-    getPrivateMethod() {
+    getPrivateMethod(asProtected = false) {
         var _a, _b;
         let privateMethod = this;
         if (!((_a = privateMethod.method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(MethodModifier.PRIVATE))) {
@@ -43,7 +44,8 @@ export class MaterializedMethod extends PeerMethod {
                     modifiers: ((_b = this.method.modifiers) !== null && _b !== void 0 ? _b : [])
                         .filter(it => it !== MethodModifier.PUBLIC)
                         .filter(it => it !== MethodModifier.OVERRIDE)
-                        .concat([MethodModifier.PRIVATE])
+                        .filter(it => !asProtected || (it !== MethodModifier.PRIVATE))
+                        .concat([asProtected ? MethodModifier.PROTECTED : MethodModifier.PRIVATE])
                 })
             });
         }
@@ -59,12 +61,12 @@ export class MaterializedMethod extends PeerMethod {
 }
 export function copyMaterializedMethod(method, overrides) {
     var _a;
-    return new MaterializedMethod(method.sig, method.originalParentName, method.implementationParentName, method.returnType, method.isCallSignature, method.uniqueOverloadName, (_a = overrides.method) !== null && _a !== void 0 ? _a : method.method);
+    return new MaterializedMethod(method.decl, method.sig, method.originalParentName, method.implementationParentName, method.returnType, method.isCallSignature, method.uniqueOverloadName, (_a = overrides.method) !== null && _a !== void 0 ? _a : method.method);
 }
 export class MaterializedClass {
     constructor(decl, className, isInterface, isStaticMaterialized, superClass, interfaces, generics, fields, ctors, // zero size when used for global functions
     finalizer, // undefined when used for global functions
-    methods, needBeGenerated = true, taggedMethods = []) {
+    methods, needBeGenerated = true, taggedMethods = [], isRefCounted = false) {
         this.decl = decl;
         this.className = className;
         this.isInterface = isInterface;
@@ -78,6 +80,7 @@ export class MaterializedClass {
         this.methods = methods;
         this.needBeGenerated = needBeGenerated;
         this.taggedMethods = taggedMethods;
+        this.isRefCounted = isRefCounted;
         this._isGlobal = false;
     }
     getImplementationName() {
@@ -97,7 +100,7 @@ export function createDestroyPeerMethod(clazz) {
     if (clazz.isGlobalScope() || clazz.isStaticMaterialized) {
         return undefined;
     }
-    return new MaterializedMethod(new PeerMethodSignature(PeerMethodSignature.DESTROY, '%NEVER_USED$', [], idl.IDLVoidType, clazz.decl), idl.getQualifiedName(clazz.decl, "namespace.name").split('.').join('_'), clazz.getImplementationName(), idl.IDLVoidType, false, PeerMethodSignature.DESTROY, new Method(PeerMethodSignature.DESTROY, new NamedMethodSignature(idl.IDLVoidType, [idl.createReferenceType(clazz.decl)], ['peer'])));
+    return new MaterializedMethod(undefined, new PeerMethodSignature(PeerMethodSignature.DESTROY, '%NEVER_USED$', [], idl.IDLVoidType, clazz.decl), idl.getQualifiedName(clazz.decl, "namespace.name").split('.').join('_'), clazz.getImplementationName(), idl.IDLVoidType, false, PeerMethodSignature.DESTROY, new Method(PeerMethodSignature.DESTROY, new NamedMethodSignature(idl.IDLVoidType, [idl.createReferenceType(clazz.decl)], ['peer'])));
 }
 export function getInternalClassName(name) {
     return `${name}Internal`;

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

@@ -1,4 +1,4 @@
-import { IDLFile, IDLProperty } from "../idl";
+import { IDLFile, IDLInterface, IDLProperty } from "../idl";
 import { PeerMethod } from "./PeerMethod";
 export interface PeerClassBase {
     generatedName(isCallSignature: boolean): string;
@@ -8,10 +8,11 @@ export interface ComponentBuilderInfo {
     peerMethodName: string;
 }
 export declare class PeerClass implements PeerClassBase {
+    readonly decl: IDLInterface;
     readonly file: IDLFile;
     readonly componentName: string;
     readonly originalFilename: string;
-    constructor(file: IDLFile, componentName: string, originalFilename: string);
+    constructor(decl: IDLInterface, file: IDLFile, componentName: string, originalFilename: string);
     generatedName(isCallSignature: boolean): string;
     methods: PeerMethod[];
     componentBuilderInfos: ComponentBuilderInfo[];

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

@@ -16,7 +16,8 @@ import { IDLI32Type, IDLPointerType } from "../idl";
 import { PeerMethod, PeerMethodArg, PeerMethodSignature } from "./PeerMethod";
 import { Method, MethodModifier, NamedMethodSignature } from "../LanguageWriters/LanguageWriter";
 export class PeerClass {
-    constructor(file, componentName, originalFilename) {
+    constructor(decl, file, componentName, originalFilename) {
+        this.decl = decl;
         this.file = file;
         this.componentName = componentName;
         this.originalFilename = originalFilename;
@@ -37,6 +38,6 @@ export class PeerClass {
 export function createConstructPeerMethod(clazz) {
     // TODO here is class FQName needed, but can not calculate if from current PeerClass data
     const classFQN = [clazz.componentName];
-    return new PeerMethod(new PeerMethodSignature(PeerMethodSignature.CTOR, classFQN.concat(PeerMethodSignature.CTOR).join('_'), [new PeerMethodArg('id', IDLI32Type), new PeerMethodArg('flags', IDLI32Type)], IDLPointerType), clazz.componentName, IDLPointerType, false, PeerMethodSignature.CTOR, new Method('construct', new NamedMethodSignature(IDLPointerType, [IDLI32Type, IDLI32Type], ['id', 'flags']), [MethodModifier.STATIC]));
+    return new PeerMethod(undefined, new PeerMethodSignature(PeerMethodSignature.CTOR, classFQN.concat(PeerMethodSignature.CTOR).join('_'), [new PeerMethodArg('id', IDLI32Type), new PeerMethodArg('flags', IDLI32Type)], IDLPointerType), clazz.componentName, IDLPointerType, false, PeerMethodSignature.CTOR, new Method('construct', new NamedMethodSignature(IDLPointerType, [IDLI32Type, IDLI32Type], ['id', 'flags']), [MethodModifier.STATIC]));
 }
 //# sourceMappingURL=PeerClass.js.map

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

@@ -17,7 +17,7 @@ import * as idl from '../idl';
 import { resolveNamedNode } from '../resolveNamedNode';
 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, BigIntToU64Convertor, ObjectConvertor, DoubleConvertor, } 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, ObjectConvertor, } from "../LanguageWriters/ArgConvertors";
 import { CppNameConvertor } from '../LanguageWriters/convertors/CppConvertors';
 import { CJTypeNameConvertor } from '../LanguageWriters/convertors/CJConvertors';
 import { CppConvertor } from '../LanguageWriters/convertors/CppConvertors';
@@ -297,7 +297,7 @@ export class PeerLibrary {
                 case idl.IDLU64Type: return new NumericConvertor(param, type);
                 case idl.IDLF16Type: return new NumericConvertor(param, type);
                 case idl.IDLF32Type: return new NumericConvertor(param, type);
-                case idl.IDLF64Type: return new DoubleConvertor(param);
+                case idl.IDLF64Type: return new NumericConvertor(param, type);
                 case idl.IDLBigintType: return new BigIntToU64Convertor(param);
                 case idl.IDLSerializerBuffer: new PointerConvertor(param);
                 case idl.IDLPointerType: return new PointerConvertor(param);

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

@@ -27,13 +27,14 @@ export declare class PeerMethodSignature {
     static get DESTROY(): string;
 }
 export declare class PeerMethod {
+    decl: idl.IDLConstructor | idl.IDLMethod | idl.IDLCallable | idl.IDLProperty | undefined;
     sig: PeerMethodSignature;
     originalParentName: string;
     returnType: IDLType;
     isCallSignature: boolean;
     uniqueOverloadName: string;
     method: Method;
-    constructor(sig: PeerMethodSignature, originalParentName: string, returnType: IDLType, isCallSignature: boolean, uniqueOverloadName: string, method: Method);
+    constructor(decl: idl.IDLConstructor | idl.IDLMethod | idl.IDLCallable | idl.IDLProperty | undefined, sig: PeerMethodSignature, originalParentName: string, returnType: IDLType, isCallSignature: boolean, uniqueOverloadName: string, method: Method);
     argConvertors(library: PeerLibrary): ArgConvertor[];
     argAndOutConvertors(library: PeerLibrary): ArgConvertor[];
 }

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

@@ -80,11 +80,12 @@ export class PeerMethodSignature {
     static get DESTROY() { return "destroyPeer"; }
 }
 export class PeerMethod {
-    constructor(sig, originalParentName, returnType, isCallSignature, 
+    constructor(decl, sig, originalParentName, returnType, isCallSignature, 
     // arkts specific feature, where overloads - are different functions grouped by overload keyword.
     // Must be moved to interface description as so as `method` field
     uniqueOverloadName, method) {
         var _a, _b;
+        this.decl = decl;
         this.sig = sig;
         this.originalParentName = originalParentName;
         this.returnType = returnType;

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

@@ -1,5 +1,6 @@
 import * as idl from '../idl';
 import { ReferenceResolver } from './ReferenceResolver';
+export declare function getExtendsChain(declaration: idl.IDLInterface, resolver: ReferenceResolver): idl.IDLReferenceType[];
 export declare function getSuper(declaration: idl.IDLInterface, resolver: ReferenceResolver): idl.IDLInterface | undefined;
 export declare function getSuperType(declaration: idl.IDLInterface, resolver: ReferenceResolver): idl.IDLReferenceType | undefined;
 //# sourceMappingURL=getSuperType.d.ts.map

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

@@ -44,6 +44,15 @@ function getSuperTuple(declaration, resolver) {
     }
     return [resolved, fst];
 }
+export function getExtendsChain(declaration, resolver) {
+    let extendsChain = [];
+    let resolved = getSuperTuple(declaration, resolver);
+    while (resolved) {
+        extendsChain.push(resolved[1]);
+        resolved = getSuperTuple(resolved[0], resolver);
+    }
+    return extendsChain;
+}
 export function getSuper(declaration, resolver) {
     var _a;
     return (_a = getSuperTuple(declaration, resolver)) === null || _a === void 0 ? void 0 : _a[0];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idlizer/core",
-  "version": "2.1.10-arktscgen-2",
+  "version": "2.1.10-arktscgen-3",
   "description": "",
   "types": "build/lib/src/index.d.ts",
   "exports": {
@@ -47,6 +47,7 @@
   "scripts": {
     "test": "mocha",
     "clean": "rimraf -g build",
-    "compile": "tsc -b ."
+    "compile:self": "tsc -b .",
+    "compile": "npm run compile:self"
   }
 }