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

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;
@@ -274,9 +265,9 @@ export declare class CustomTypeConvertor extends BaseArgConvertor {
     isPointerType(): boolean;
 }
 export declare class OptionConvertor extends BaseArgConvertor {
-    type: idl.IDLType;
+    type: idl.IDLOptionalType;
     private readonly typeConvertor;
-    constructor(library: LibraryInterface, param: string, type: idl.IDLType);
+    constructor(library: LibraryInterface, param: string, type: idl.IDLOptionalType);
     convertorArg(param: string, writer: LanguageWriter): string;
     convertorSerialize(param: string, value: string, printer: LanguageWriter): LanguageStatement;
     convertorCArg(param: string): 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) {
@@ -876,7 +851,7 @@ export class CustomTypeConvertor extends BaseArgConvertor {
 export class OptionConvertor extends BaseArgConvertor {
     // TODO: be smarter here, and for smth like Length|undefined or number|undefined pass without serializer.
     constructor(library, param, type) {
-        let conv = library.typeConvertor(param, type);
+        let conv = library.typeConvertor(param, type.type);
         let currentConv = conv;
         while (currentConv instanceof ProxyConvertor) {
             currentConv = currentConv.convertor;
@@ -897,7 +872,7 @@ export class OptionConvertor extends BaseArgConvertor {
     }
     convertorSerialize(param, value, printer) {
         const valueValue = `${value}TmpValue`.replaceAll('.', '_');
-        return printer.makeCondition(printer.makeDefinedCheck(value), new BlockStatement([
+        return printer.makeCondition(printer.makeDefinedCheck(value, this.type), new BlockStatement([
             printer.makeStatement(printer.makeMethodCall(`${param}Serializer`, "writeInt8", [printer.makeRuntimeType(RuntimeType.OBJECT)])),
             printer.makeAssign(valueValue, undefined, printer.makeValueFromOption(value, this.typeConvertor), true),
             this.typeConvertor.convertorSerialize(param, this.typeConvertor.getObjectAccessor(printer.language, valueValue), printer)
@@ -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.CPP ? undefined : writer.makeNull(this.type), true, false)); // maybe change to generic None
         const thenStatement = new BlockStatement([
             this.typeConvertor.convertorDeserialize(`${bufferName}_`, deserializerName, (expr) => {
                 const receiver = writer.language === Language.CPP
@@ -925,10 +900,10 @@ export class OptionConvertor extends BaseArgConvertor {
         return writer.makeBlock(statements, false);
     }
     nativeType() {
-        return idl.createOptionalType(this.type);
+        return this.type;
     }
     interopType() {
-        return idl.createOptionalType(this.type);
+        return this.type;
     }
     isPointerType() {
         return true;

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;
@@ -311,7 +316,7 @@ export declare abstract class LanguageWriter {
     writeStaticBlock(op: (writer: this) => void): void;
     makeRef(type: idl.IDLType, _options?: MakeRefOptions): idl.IDLType;
     makeThis(): LanguageExpression;
-    makeNull(value?: string): LanguageExpression;
+    makeNull(type?: idl.IDLOptionalType): LanguageExpression;
     makeVoid(): LanguageExpression;
     makeLambdaReturn(expr?: LanguageExpression): LanguageStatement;
     makeRuntimeTypeCondition(typeVarName: string, equals: boolean, type: RuntimeType, varName?: string): LanguageExpression;
@@ -325,7 +330,7 @@ export declare abstract class LanguageWriter {
     makeNativeCall(nativeModule: NativeModuleType, method: string, params: LanguageExpression[], nullable?: boolean): LanguageExpression;
     makeBlock(statements: LanguageStatement[], inScope?: boolean): BlockStatement;
     nativeReceiver(nativeModule: NativeModuleType): string;
-    abstract makeDefinedCheck(value: string, isTag?: boolean): LanguageExpression;
+    abstract makeDefinedCheck(value: string, type?: idl.IDLOptionalType, isTag?: boolean): LanguageExpression;
     makeRuntimeTypeDefinedCheck(runtimeType: string): LanguageExpression;
     makeCondition(condition: LanguageExpression, thenStatement: LanguageStatement, elseStatement?: LanguageStatement, insideIfOp?: () => void, insideElseOp?: () => void): LanguageStatement;
     makeMultiBranchCondition(conditions: BranchStatement[], elseStatement?: LanguageStatement): LanguageStatement;
@@ -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;
@@ -486,7 +488,7 @@ export class LanguageWriter {
     makeThis() {
         return new StringExpression("this");
     }
-    makeNull(value) {
+    makeNull(type) {
         return new StringExpression("null");
     }
     makeVoid() {

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

@@ -46,7 +46,15 @@ export class TSTypeNameConvertor {
         return node.name;
     }
     convertOptional(type) {
-        return `${this.convert(type.type)} | undefined`;
+        if (idl.hasExtAttribute(type, idl.IDLExtendedAttributes.UnionOnlyNull)) {
+            return `${this.convert(type.type)} | null`;
+        }
+        else if (idl.hasExtAttribute(type, idl.IDLExtendedAttributes.UnionWithNull)) {
+            return `${this.convert(type.type)} | null | undefined`;
+        }
+        else {
+            return `${this.convert(type.type)} | undefined`;
+        }
     }
     convertUnion(type) {
         return type.types.
@@ -248,9 +256,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";
@@ -136,7 +136,7 @@ export declare class CJLanguageWriter extends LanguageWriter {
     makeRuntimeType(rt: RuntimeType): LanguageExpression;
     protected makeRuntimeTypeGetterCall(value: string): LanguageExpression;
     makeMapInsert(keyAccessor: string, key: string, valueAccessor: string, value: string): LanguageStatement;
-    makeNull(value?: string): LanguageExpression;
+    makeNull(): LanguageExpression;
     getTagType(): idl.IDLType;
     getRuntimeType(): idl.IDLType;
     makeTupleAssign(receiver: string, fields: string[]): LanguageStatement;
@@ -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();
@@ -527,8 +527,8 @@ export class CJLanguageWriter extends LanguageWriter {
     makeMapInsert(keyAccessor, key, valueAccessor, value) {
         return this.makeStatement(this.makeMethodCall(keyAccessor, "add", [this.makeString(key), this.makeString(value)]));
     }
-    makeNull(value) {
-        return new StringExpression(`Option.None`);
+    makeNull() {
+        return this.makeUndefined();
     }
     getTagType() {
         return idl.createReferenceType("Tags");

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

@@ -101,7 +101,7 @@ export declare class CppLanguageWriter extends CLikeLanguageWriter {
     makeCast(expr: LanguageExpression, node: IDLNode, options?: MakeCastOptions): LanguageExpression;
     makePointerPropertyAccessExpression(expression: string, name: string): CppPointerPropertyAccessExpression;
     writePrintLog(message: string): void;
-    makeDefinedCheck(value: string, isTag?: boolean): LanguageExpression;
+    makeDefinedCheck(value: string, type?: idl.IDLOptionalType, isTag?: boolean): LanguageExpression;
     makeSetUnionSelector(value: string, index: string): LanguageStatement;
     makeSetOptionTag(value: string, tag: LanguageExpression): LanguageStatement;
     getObjectAccessor(convertor: BaseArgConvertor, value: string, args?: ObjectArgs): string;

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

@@ -347,7 +347,7 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
     writePrintLog(message) {
         this.print(`printf("${message}\\n");`);
     }
-    makeDefinedCheck(value, isTag) {
+    makeDefinedCheck(value, type, isTag) {
         return this.makeString(isTag ? `${value} != ${PrimitiveTypeList.UndefinedTag}`
             : `runtimeType(${value}) != ${PrimitiveTypeList.UndefinedRuntime}`);
     }

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;
@@ -69,7 +66,7 @@ export declare class TSLanguageWriter extends LanguageWriter {
     writeTypeDeclaration(decl: idl.IDLTypedef): void;
     writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
     private writeDeclaration;
-    makeNull(): LanguageExpression;
+    makeNull(type?: idl.IDLOptionalType): LanguageExpression;
     makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression | undefined, isDeclared?: boolean, isConst?: boolean, options?: MakeAssignOptions): LanguageStatement;
     makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
     makeThrowError(message: string): LanguageStatement;
@@ -83,7 +80,7 @@ export declare class TSLanguageWriter extends LanguageWriter {
     getObjectAccessor(convertor: ArgConvertor, value: string, args?: ObjectArgs): string;
     makeUndefined(): LanguageExpression;
     makeRuntimeType(rt: RuntimeType): LanguageExpression;
-    makeDefinedCheck(value: string): LanguageExpression;
+    makeDefinedCheck(value: string, type?: idl.IDLOptionalType): LanguageExpression;
     makeTupleAlloc(option: string): LanguageStatement;
     makeArrayInit(type: idl.IDLContainerType, size?: number): LanguageExpression;
     makeClassInit(type: idl.IDLType, paramenters: LanguageExpression[]): LanguageExpression;

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

@@ -295,7 +295,9 @@ export class TSLanguageWriter extends LanguageWriter {
         const normalizedArgs = signature.args.map((it, i) => idl.isOptionalType(it) && signature.isArgOptional(i) ? idl.maybeUnwrapOptionalType(it) : it);
         this.printer.print(`${prefix}${name}${typeParams}(${normalizedArgs.map((it, index) => `${this.escapeKeyword(signature.argName(index))}${signature.isArgOptional(index) ? "?" : ``}: ${this.getNodeName(it)}${signature.argDefault(index) ? ' = ' + signature.argDefault(index) : ""}`).join(", ")})${needReturn ? ": " + this.getNodeName(signature.returnType) : ""}${needBracket ? " {" : ""}`);
     }
-    makeNull() {
+    makeNull(type) {
+        if (type && idl.hasExtAttribute(type, idl.IDLExtendedAttributes.UnionOnlyNull))
+            return new StringExpression("null");
         return new StringExpression("undefined");
     }
     makeAssign(variableName, type, expr, isDeclared = true, isConst = true, options) {
@@ -352,7 +354,15 @@ export class TSLanguageWriter extends LanguageWriter {
     makeRuntimeType(rt) {
         return this.makeString(`RuntimeType.${RuntimeType[rt]}`);
     }
-    makeDefinedCheck(value) {
+    makeDefinedCheck(value, type) {
+        if (type) {
+            if (idl.hasExtAttribute(type, idl.IDLExtendedAttributes.UnionWithNull)) {
+                return this.makeString(`${value} !== undefined && ${value} !== null`);
+            }
+            else if (idl.hasExtAttribute(type, idl.IDLExtendedAttributes.UnionOnlyNull)) {
+                return this.makeString(`${value} !== null`);
+            }
+        }
         return this.makeString(`${value} !== undefined`);
     }
     makeTupleAlloc(option) {

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

@@ -55,10 +55,13 @@ export declare enum IDLExtendedAttributes {
     Interfaces = "Interfaces",
     NativeModule = "NativeModule",
     Optional = "Optional",
+    UnionOnlyNull = "OptionalOnlyNull",
+    UnionWithNull = "OptionalWithNull",
     OriginalEnumMemberName = "OriginalEnumMemberName",
     OriginalGenericName = "OriginalGenericName",
     Predefined = "Predefined",
     Protected = "Protected",
+    Abstract = "Abstract",
     Synthetic = "Synthetic",
     Throws = "Throws",
     TraceKey = "TraceKey",

package/build/lib/src/idl.js

@@ -74,10 +74,13 @@ export var IDLExtendedAttributes;
     IDLExtendedAttributes["Interfaces"] = "Interfaces";
     IDLExtendedAttributes["NativeModule"] = "NativeModule";
     IDLExtendedAttributes["Optional"] = "Optional";
+    IDLExtendedAttributes["UnionOnlyNull"] = "OptionalOnlyNull";
+    IDLExtendedAttributes["UnionWithNull"] = "OptionalWithNull";
     IDLExtendedAttributes["OriginalEnumMemberName"] = "OriginalEnumMemberName";
     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/index.d.ts

@@ -51,6 +51,7 @@ export * from "./peer-generation/unions";
 export * from "./peer-generation/getSuperType";
 export * from "./transformers/FqnTransformer";
 export * from "./transformers/GenericTransformer";
+export * from "./transformers/NullTransformer";
 export * from "./LanguageWriters";
 export * from "./peer-generation/ReferenceResolver";
 export * from "./peer-generation/idl/common";

package/build/lib/src/index.js

@@ -65,6 +65,7 @@ export * from "./peer-generation/unions";
 export * from "./peer-generation/getSuperType";
 export * from "./transformers/FqnTransformer";
 export * from "./transformers/GenericTransformer";
+export * from "./transformers/NullTransformer";
 export * from "./LanguageWriters";
 export * from "./peer-generation/ReferenceResolver";
 export * from "./peer-generation/idl/common";

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';
@@ -280,10 +280,10 @@ export class PeerLibrary {
     }
     typeConvertor(param, type, isOptionalParam = false) {
         if (isOptionalParam) {
-            return new OptionConvertor(this, param, idl.maybeUnwrapOptionalType(type));
+            return new OptionConvertor(this, param, idl.isOptionalType(type) ? type : idl.createOptionalType(type));
         }
         if (idl.isOptionalType(type)) {
-            return new OptionConvertor(this, param, type.type);
+            return new OptionConvertor(this, param, type);
         }
         if (idl.isPrimitiveType(type)) {
             switch (type) {
@@ -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);
@@ -420,7 +420,8 @@ export class PeerLibrary {
             case `Record`:
                 return new CustomTypeConvertor(param, "Record", false, "Record<string, string>");
             case `Optional`:
-                return new OptionConvertor(this, param, type.typeArguments[0]);
+                throw new Error("Not expected to have reference type named Optional");
+            // return new OptionConvertor(this, param, type.typeArguments![0])
         }
         return undefined;
     }

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/build/lib/src/peer-generation/modules.d.ts

@@ -1,5 +1,13 @@
 import { ModuleConfiguration } from "../config";
 import * as idl from "../idl";
+/**
+ * Is source submodule of target.
+ * Every source is submodule if target is empty string
+ * @example `isSubmodule("a.b.c", "a") === true`
+ * @example `isSubmodule("a", "a.b.c") === false`
+ * @example `isSubmodule("a.b.cd", "a.b.c") === false`
+ */
+export declare function isSubmodule(source: string, target: string): boolean;
 export declare function isInModule(node: idl.IDLNode, module: ModuleConfiguration): boolean;
 export declare function isInModule(packageName: string, module: ModuleConfiguration): boolean;
 export declare function isInExternalModule(node: idl.IDLNode): boolean;

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

@@ -1,10 +1,22 @@
 import { generatorConfiguration } from "../config";
 import * as idl from "../idl";
 const modulesCache = new Map();
+/**
+ * Is source submodule of target.
+ * Every source is submodule if target is empty string
+ * @example `isSubmodule("a.b.c", "a") === true`
+ * @example `isSubmodule("a", "a.b.c") === false`
+ * @example `isSubmodule("a.b.cd", "a.b.c") === false`
+ */
+export function isSubmodule(source, target) {
+    return source === target
+        || target === ""
+        || source.startsWith(target + '.');
+}
 export function isInModule(nodeOrPackage, module) {
     if (typeof nodeOrPackage === 'object')
         return isInModule(idl.getPackageName(nodeOrPackage), module);
-    return module.packages.some(modulePackage => nodeOrPackage.startsWith(modulePackage));
+    return module.packages.some(modulePackage => isSubmodule(nodeOrPackage, modulePackage));
 }
 export function isInExternalModule(node) {
     var _a;

package/build/lib/src/transformers/NullTransformer.d.ts

@@ -0,0 +1,4 @@
+import * as idl from "../idl";
+export declare const NULL_REFERENCE = "idlize.stdlib.Null";
+export declare function inplaceNullsAsUndefined(node: idl.IDLNode): void;
+//# sourceMappingURL=NullTransformer.d.ts.map

package/build/lib/src/transformers/NullTransformer.js

@@ -0,0 +1,34 @@
+import * as idl from "../idl";
+import { generateSyntheticUnionName } from "../peer-generation/idl/common";
+export const NULL_REFERENCE = "idlize.stdlib.Null";
+export function inplaceNullsAsUndefined(node) {
+    idl.updateEachChild(node, (child) => {
+        var _a;
+        if (idl.isOptionalType(child)) {
+            if (idl.isUnionType(child.type) && child.type.types.some(isNullReference)) {
+                child.type.types = child.type.types.filter(it => !isNullReference(it));
+                child.type.name = generateSyntheticUnionName(child.type.types);
+                if (child.type.types.length === 1) {
+                    child.type = child.type.types[0];
+                }
+                (_a = child.extendedAttributes) !== null && _a !== void 0 ? _a : (child.extendedAttributes = []);
+                child.extendedAttributes.push({ name: idl.IDLExtendedAttributes.UnionWithNull });
+                return child;
+            }
+        }
+        else if (idl.isUnionType(child)) {
+            if (child.types.some(isNullReference)) {
+                child.types = child.types.filter(it => !isNullReference(it));
+                child.name = generateSyntheticUnionName(child.types);
+                return idl.createOptionalType(child.types.length > 1 ? child : child.types[0], { extendedAttributes: [{
+                            name: idl.IDLExtendedAttributes.UnionOnlyNull
+                        }] });
+            }
+        }
+        return child;
+    });
+}
+function isNullReference(node) {
+    return idl.isReferenceType(node) && node.name === NULL_REFERENCE;
+}
+//# sourceMappingURL=NullTransformer.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idlizer/core",
-  "version": "2.1.10-arktscgen-2",
+  "version": "2.1.10-arktscgen-3a",
   "description": "",
   "types": "build/lib/src/index.d.ts",
   "exports": {
@@ -33,7 +33,7 @@
   },
   "keywords": [],
   "dependencies": {
-    "@koalaui/interop": "1.7.9",
+    "@koalaui/interop": "1.7.10",
     "typescript": "4.9.5",
     "@types/node": "^18.0.0"
   },
@@ -47,6 +47,7 @@
   "scripts": {
     "test": "mocha",
     "clean": "rimraf -g build",
-    "compile": "tsc -b ."
+    "compile:self": "tsc -b .",
+    "compile": "npm run compile:self"
   }
 }