@idlizer/core 2.0.43 → 2.1.2

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

@@ -1,9 +1,10 @@
 import * as idl from "../idl";
 import { Language } from "../Language";
-import { LanguageExpression, LanguageStatement, LanguageWriter, ExpressionAssigner } from "./LanguageWriter";
+import { ExpressionAssigner, LanguageExpression, LanguageStatement, LanguageWriter, Method } from "./LanguageWriter";
 import { RuntimeType } from "./common";
 import { LibraryInterface } from "../LibraryInterface";
 import { ReferenceResolver } from "../peer-generation/ReferenceResolver";
+import { PeerLibrary } from "../peer-generation/PeerLibrary";
 export interface ArgConvertor {
     param: string;
     idlType: idl.IDLType;
@@ -14,6 +15,7 @@ export interface ArgConvertor {
     convertorArg(param: string, writer: LanguageWriter): string;
     convertorSerialize(param: string, value: string, writer: LanguageWriter): void;
     convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    holdResource(resourceName: string, holder: string, writer: LanguageWriter): void;
     interopType(): idl.IDLType;
     nativeType(): idl.IDLType;
     targetType(writer: LanguageWriter): string;
@@ -22,6 +24,9 @@ export interface ArgConvertor {
     getMembers(): string[];
     getObjectAccessor(languge: Language, value: string, args?: Record<string, string>, writer?: LanguageWriter): string;
 }
+export declare function isDirectConvertedType(originalType: idl.IDLType | undefined, library: PeerLibrary): boolean;
+export declare function isVMContextMethod(method: Method): boolean;
+export declare function isDirectMethod(method: Method, library: PeerLibrary): boolean;
 export declare abstract class BaseArgConvertor implements ArgConvertor {
     idlType: idl.IDLType;
     runtimeTypes: RuntimeType[];
@@ -29,6 +34,7 @@ export declare abstract class BaseArgConvertor implements ArgConvertor {
     useArray: boolean;
     param: string;
     protected constructor(idlType: idl.IDLType, runtimeTypes: RuntimeType[], isScoped: boolean, useArray: boolean, param: string);
+    holdResource(_resourceName: string, _holder: string, _writer: LanguageWriter): void;
     nativeType(): idl.IDLType;
     isPointerType(): boolean;
     interopType(): idl.IDLType;
@@ -116,6 +122,16 @@ export declare class BigIntToU64Convertor extends BaseArgConvertor {
     interopType(): idl.IDLType;
     isPointerType(): boolean;
 }
+export declare class ObjectConvertor extends BaseArgConvertor {
+    constructor(param: string);
+    convertorArg(param: string, writer: LanguageWriter): string;
+    convertorSerialize(param: string, value: string, printer: LanguageWriter): void;
+    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    holdResource(name: string, holder: string, writer: LanguageWriter): void;
+    nativeType(): idl.IDLType;
+    interopType(): idl.IDLType;
+    isPointerType(): boolean;
+}
 export declare class PointerConvertor extends BaseArgConvertor {
     constructor(param: string);
     convertorArg(param: string, writer: LanguageWriter): string;

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

@@ -14,15 +14,74 @@
  */
 import * as idl from "../idl";
 import { Language } from "../Language";
-import { PrintHint, BlockStatement, StringExpression } from "./LanguageWriter";
+import { BlockStatement, PrintHint, StringExpression, MethodModifier } from "./LanguageWriter";
 import { RuntimeType } from "./common";
 import { generatorTypePrefix } from "../config";
 import { hashCodeFromString, warn } from "../util";
 import { UnionRuntimeTypeChecker } from "../peer-generation/unions";
-import { CppNameConvertor } from "./convertors/CppConvertors";
+import { CppConvertor, CppNameConvertor } from "./convertors/CppConvertors";
 import { createEmptyReferenceResolver } from "../peer-generation/ReferenceResolver";
-import { CppConvertor } from "./convertors/CppConvertors";
 import { PrimitiveTypesInstance } from "../peer-generation/PrimitiveType";
+import { qualifiedName } from "../peer-generation/idl/common";
+export function isDirectConvertedType(originalType, library) {
+    const debug = false;
+    if (originalType == undefined)
+        return true; // TODO: is it correct?
+    if (debug)
+        console.log(`IDL type ${idl.DebugUtils.debugPrintType(originalType)}`);
+    if (originalType == idl.IDLInteropReturnBufferType) {
+        return false;
+    }
+    if (originalType == idl.IDLSerializerBuffer)
+        return true;
+    let convertor = library.typeConvertor("x", originalType, false);
+    // Resolve aliases.
+    while (convertor instanceof TypeAliasConvertor) {
+        convertor = convertor.convertor;
+    }
+    if (convertor instanceof ArrayConvertor ||
+        convertor instanceof CustomTypeConvertor ||
+        convertor instanceof UnionConvertor ||
+        convertor instanceof CallbackConvertor ||
+        convertor instanceof MapConvertor ||
+        convertor instanceof TupleConvertor ||
+        convertor instanceof AggregateConvertor ||
+        convertor instanceof OptionConvertor) {
+        return false;
+    }
+    let type = convertor.interopType();
+    if (debug)
+        console.log(`converted type ${idl.DebugUtils.debugPrintType(originalType)}`);
+    let result = type == idl.IDLI8Type || type == idl.IDLU8Type
+        || type == idl.IDLI16Type || type == idl.IDLU16Type
+        || type == idl.IDLI32Type || type == idl.IDLU32Type
+        || type == idl.IDLF32Type
+        || type == idl.IDLI64Type || type == idl.IDLU64Type
+        || type == idl.IDLPointerType
+        || type == idl.IDLBooleanType
+        || type == idl.IDLVoidType
+        || type == idl.IDLUndefinedType
+        || type == idl.IDLSerializerBuffer
+        || type == idl.IDLNumberType;
+    if (!result && debug)
+        console.log(`type ${idl.DebugUtils.debugPrintType(type)} is not direct`);
+    return result;
+}
+export function isVMContextMethod(method) {
+    var _a, _b;
+    return !!idl.asPromise(method.signature.returnType) ||
+        !!((_a = method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(MethodModifier.THROWS)) ||
+        !!((_b = method.modifiers) === null || _b === void 0 ? void 0 : _b.includes(MethodModifier.FORCE_CONTEXT));
+}
+export function isDirectMethod(method, library) {
+    if (isVMContextMethod(method)) {
+        return false;
+    }
+    let result = isDirectConvertedType(method.signature.returnType, library) &&
+        method.signature.args.every((arg) => isDirectConvertedType(arg, library));
+    // if (!result) console.log(`method ${method.name} is not direct`)
+    return result;
+}
 export class BaseArgConvertor {
     constructor(idlType, runtimeTypes, isScoped, useArray, param) {
         this.idlType = idlType;
@@ -31,6 +90,7 @@ export class BaseArgConvertor {
         this.useArray = useArray;
         this.param = param;
     }
+    holdResource(_resourceName, _holder, _writer) { }
     nativeType() {
         throw new Error("Define");
     }
@@ -158,14 +218,10 @@ export class EnumConvertor extends BaseArgConvertor {
         this.enumEntry = enumEntry;
     }
     convertorArg(param, writer) {
-        return writer.makeEnumCast(writer.escapeKeyword(param), false, this);
+        return writer.makeEnumCast(this.enumEntry, writer.escapeKeyword(param));
     }
     convertorSerialize(param, value, writer) {
-        value =
-            idl.isStringEnum(this.enumEntry)
-                ? writer.ordinalFromEnum(writer.makeString(value), idl.createReferenceType(this.enumEntry)).asString()
-                : writer.makeEnumCast(value, false, this);
-        writer.writeMethodCall(`${param}Serializer`, "writeInt32", [value]);
+        writer.writeMethodCall(`${param}Serializer`, "writeInt32", [writer.makeEnumCast(this.enumEntry, value)]);
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
         const readExpr = writer.makeMethodCall(`${deserializerName}`, "readInt32", []);
@@ -265,6 +321,50 @@ export class BigIntToU64Convertor extends BaseArgConvertor {
         return false;
     }
 }
+export class ObjectConvertor extends BaseArgConvertor {
+    constructor(param) {
+        super(idl.IDLAnyType, [
+            RuntimeType.BIGINT,
+            RuntimeType.BOOLEAN,
+            RuntimeType.FUNCTION,
+            RuntimeType.MATERIALIZED,
+            RuntimeType.NUMBER,
+            RuntimeType.OBJECT,
+            RuntimeType.STRING,
+            RuntimeType.SYMBOL,
+            RuntimeType.UNDEFINED
+        ], false, true, param);
+    }
+    convertorArg(param, writer) {
+        return writer.escapeKeyword(param);
+    }
+    convertorSerialize(param, value, printer) {
+        if (printer.language === Language.CPP) {
+            printer.writeMethodCall(`${param}Serializer`, "writeObject", [value]);
+        }
+        else {
+            printer.writeMethodCall(`${param}Serializer`, "holdAndWriteObject", [value]);
+        }
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        return assigneer(writer.makeCast(writer.makeMethodCall(deserializerName, 'readObject', []), this.idlType, { optional: false }));
+    }
+    holdResource(name, holder, writer) {
+        writer.writeStatement(writer.makeAssign(name, idl.createReferenceType(`CallbackResource`), writer.makeString(`{${this.param}.resource.resourceId, holdManagedCallbackResource, releaseManagedCallbackResource}`), true));
+        writer.writeExpressionStatement(writer.makeMethodCall(holder, 'holdCallbackResource', [
+            writer.makeString('&' + name)
+        ]));
+    }
+    nativeType() {
+        return idl.IDLAnyType;
+    }
+    interopType() {
+        return idl.IDLAnyType;
+    }
+    isPointerType() {
+        return true;
+    }
+}
 export class PointerConvertor extends BaseArgConvertor {
     constructor(param) {
         // check numericPrimitiveTypes.include(type)
@@ -456,7 +556,9 @@ export class InterfaceConvertor extends BaseArgConvertor {
         return this.idlType;
     }
     interopType() {
-        throw new Error("Must never be used");
+        // Actually shouldn't be used!
+        // throw new Error("Must never be used")
+        return idl.IDLObjectType;
     }
     isPointerType() {
         return true;
@@ -889,7 +991,7 @@ export class MaterializedClassConvertor extends BaseArgConvertor {
     convertorArg(param, writer) {
         switch (writer.language) {
             case Language.CPP:
-                return `static_cast<${generatorTypePrefix()}${this.declaration.name}>(${param})`;
+                return `static_cast<${generatorTypePrefix()}${qualifiedName(this.declaration, "_")}>(${param})`;
             case Language.JAVA:
             case Language.CJ:
                 return `MaterializedBase.toPeerPtr(${param})`;
@@ -898,12 +1000,12 @@ export class MaterializedClassConvertor extends BaseArgConvertor {
         }
     }
     convertorSerialize(param, value, printer) {
-        printer.writeStatement(printer.makeStatement(printer.makeMethodCall(`${param}Serializer`, `write${this.declaration.name}`, [
+        printer.writeStatement(printer.makeStatement(printer.makeMethodCall(`${param}Serializer`, `write${qualifiedName(this.declaration, "_")}`, [
             printer.makeString(value)
         ])));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
-        const readStatement = writer.makeCast(writer.makeMethodCall(`${deserializerName}`, `read${this.declaration.name}`, []), idl.createReferenceType(this.declaration));
+        const readStatement = writer.makeCast(writer.makeMethodCall(`${deserializerName}`, `read${qualifiedName(this.declaration, "_")}`, []), idl.createReferenceType(this.declaration));
         return assigneer(readStatement);
     }
     nativeType() {

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

@@ -154,7 +154,8 @@ export declare enum MethodModifier {
     GETTER = 6,
     SETTER = 7,
     THROWS = 8,
-    FREE = 9
+    FREE = 9,
+    FORCE_CONTEXT = 10
 }
 export declare enum ClassModifier {
     PUBLIC = 0,
@@ -172,6 +173,7 @@ export declare class Method {
     signature: MethodSignature;
     modifiers: MethodModifier[] | undefined;
     generics?: string[] | undefined;
+    private static knownReferenceTypes;
     constructor(name: string, signature: MethodSignature, modifiers?: MethodModifier[] | undefined, generics?: string[] | undefined);
 }
 export declare class PrintHint {
@@ -234,7 +236,13 @@ export declare abstract class LanguageWriter {
     abstract writeMethodDeclaration(name: string, signature: MethodSignature, modifiers?: MethodModifier[]): void;
     abstract writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
     abstract writeMethodImplementation(method: Method, op: (writer: this) => void): void;
-    abstract writeProperty(propName: string, propType: idl.IDLType, mutable?: boolean, getterLambda?: (writer: this) => void, setterLambda?: (writer: this) => void): void;
+    abstract writeProperty(propName: string, propType: idl.IDLType, modifiers: FieldModifier[], getter?: {
+        method: Method;
+        op?: () => void;
+    }, setter?: {
+        method: Method;
+        op: () => void;
+    }): void;
     abstract writeTypeDeclaration(decl: idl.IDLTypedef): void;
     abstract writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
     abstract makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression | undefined, isDeclared: boolean, isConst?: boolean, options?: MakeAssignOptions): LanguageStatement;
@@ -263,7 +271,7 @@ export declare abstract class LanguageWriter {
     abstract get supportedFieldModifiers(): FieldModifier[];
     abstract enumFromOrdinal(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
     abstract ordinalFromEnum(value: LanguageExpression, enumReference: idl.IDLType): LanguageExpression;
-    abstract makeEnumCast(enumName: string, unsafe: boolean, convertor: ArgConvertor | undefined): string;
+    abstract makeEnumCast(enumEntry: idl.IDLEnum, enumName: string): string;
     abstract getNodeName(type: idl.IDLNode): string;
     abstract fork(options?: {
         resolver?: ReferenceResolver;
@@ -315,7 +323,6 @@ export declare abstract class LanguageWriter {
     makeString(value: string): LanguageExpression;
     makeNaryOp(op: string, args: LanguageExpression[]): LanguageExpression;
     makeStatement(expr: LanguageExpression): LanguageStatement;
-    tryWriteQuick(method: Method): void;
     writeNativeMethodDeclaration(method: Method): void;
     writeUnsafeNativeMethodDeclaration(name: string, signature: MethodSignature): void;
     pushIndent(): void;
@@ -331,7 +338,7 @@ export declare abstract class LanguageWriter {
     /**
      * TODO: replace me with {@link makeUnsafeCast_}
      */
-    makeUnsafeCast(convertor: ArgConvertor, param: string): string;
+    makeUnsafeCast(param: string): string;
     makeUnsafeCast_(value: LanguageExpression, type: idl.IDLType, typeOptions?: PrintHint): string;
     runtimeType(param: ArgConvertor, valueType: string, value: string): void;
     makeDiscriminatorFromFields(convertor: {
@@ -346,6 +353,7 @@ export declare abstract class LanguageWriter {
     discriminatorFromExpressions(value: string, runtimeType: RuntimeType, exprs: LanguageExpression[]): LanguageExpression;
     makeDiscriminatorConvertor(_convertor: ArgConvertor, _value: string, _index: number): LanguageExpression | undefined;
     makeNot(expr: LanguageExpression): LanguageExpression;
+    makeSerializedBufferGetter(serializer: string): LanguageExpression;
     makeEquals(args: LanguageExpression[]): LanguageExpression;
     castToInt(value: string, bitness: 8 | 32): string;
     castToBoolean(value: string): string;

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

@@ -317,6 +317,7 @@ export var MethodModifier;
     MethodModifier[MethodModifier["SETTER"] = 7] = "SETTER";
     MethodModifier[MethodModifier["THROWS"] = 8] = "THROWS";
     MethodModifier[MethodModifier["FREE"] = 9] = "FREE";
+    MethodModifier[MethodModifier["FORCE_CONTEXT"] = 10] = "FORCE_CONTEXT";
 })(MethodModifier || (MethodModifier = {}));
 export var ClassModifier;
 (function (ClassModifier) {
@@ -339,6 +340,10 @@ export class Method {
         this.generics = generics;
     }
 }
+// Mostly for synthetic methods.
+Method.knownReferenceTypes = [
+    'KInt', 'KPointer', 'undefined' /* This one looks like a bug */
+];
 export class PrintHint {
     constructor(hint) {
         this.hint = hint;
@@ -565,9 +570,7 @@ export class LanguageWriter {
     makeStatement(expr) {
         return new ExpressionStatement(expr);
     }
-    tryWriteQuick(method) { }
     writeNativeMethodDeclaration(method) {
-        this.tryWriteQuick(method);
         this.writeMethodDeclaration(method.name, method.signature);
     }
     writeUnsafeNativeMethodDeclaration(name, signature) {
@@ -609,7 +612,7 @@ export class LanguageWriter {
     /**
      * TODO: replace me with {@link makeUnsafeCast_}
      */
-    makeUnsafeCast(convertor, param) {
+    makeUnsafeCast(param) {
         return `unsafeCast<int32>(${param})`;
     }
     makeUnsafeCast_(value, type, typeOptions) {
@@ -660,6 +663,9 @@ export class LanguageWriter {
     makeNot(expr) {
         return this.makeString(`!(${expr.asString()})`);
     }
+    makeSerializedBufferGetter(serializer) {
+        return this.makeMethodCall(serializer, `asBuffer`, []);
+    }
     makeEquals(args) {
         return this.makeNaryOp("===", args);
     }

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

@@ -25,7 +25,7 @@ export declare class GenericCppConvertor implements NodeConvertor<ConvertResult>
     convertTypeReference(type: idl.IDLReferenceType): ConvertResult;
     convertTypeParameter(type: idl.IDLTypeParameterType): ConvertResult;
     convertPrimitiveType(type: idl.IDLPrimitiveType): ConvertResult;
-    private enumName;
+    private qualifiedName;
     private computeTargetTypeLiteralName;
 }
 export declare class CppConvertor extends GenericCppConvertor implements IdlNameConvertor {

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

@@ -39,34 +39,34 @@ export class GenericCppConvertor {
         switch (node.subkind) {
             case idl.IDLInterfaceSubkind.AnonymousInterface:
                 return node.name
-                    ? this.make(node.name)
+                    ? this.make(this.qualifiedName(node))
                     : this.make(this.computeTargetTypeLiteralName(node), true);
             case idl.IDLInterfaceSubkind.Interface:
             case idl.IDLInterfaceSubkind.Class:
                 if (isInIdlizeInternal(node)) {
-                    return this.make(node.name, true);
+                    return this.make(this.qualifiedName(node), true);
                 }
-                return this.make(node.name);
+                return this.make(this.qualifiedName(node));
             case idl.IDLInterfaceSubkind.Tuple:
                 return node.name
-                    ? this.make(node.name)
+                    ? this.make(this.qualifiedName(node))
                     : this.make(`Tuple_${node.properties.map(it => this.convertNode(idl.maybeOptional(it.type, it.isOptional)).text).join("_")}`, true);
         }
     }
     convertEnum(node) {
-        return this.make(this.enumName(node));
+        return this.make(this.qualifiedName(node));
     }
     convertTypedef(node) {
-        return this.make(node.name);
+        return this.make(this.qualifiedName(node));
     }
     convertCallback(node) {
-        return this.make(generatorConfiguration().LibraryPrefix + node.name, true);
+        return this.make(generatorConfiguration().LibraryPrefix + this.qualifiedName(node), true);
     }
     convertMethod(node) {
         return this.make(node.name);
     }
     convertConstant(node) {
-        return this.make(node.name);
+        return this.make(this.qualifiedName(node));
     }
     /////////////////////////////////////////////////////////////////////////////////////////
     convertOptional(type) {
@@ -140,19 +140,20 @@ export class GenericCppConvertor {
             case idl.IDLBooleanType: return this.make(`Boolean`);
             case idl.IDLBigintType: return this.make(`UInt64`); // TODO add arbitrary precision numeric type
             case idl.IDLPointerType: return this.make('NativePointer');
+            case idl.IDLCustomObjectType: return this.make('CustomObject');
             case idl.IDLUnknownType:
-            case idl.IDLCustomObjectType:
-            case idl.IDLAnyType: return this.make(`CustomObject`);
+            case idl.IDLAnyType: return this.make(`Object`);
             case idl.IDLUndefinedType: return this.make(`Undefined`);
             case idl.IDLLengthType: return this.make(`Length`);
             case idl.IDLFunctionType: return this.make(`Function`);
             case idl.IDLDate: return this.make(`Date`);
             case idl.IDLBufferType: return this.make('Buffer');
             case idl.IDLPointerType: return this.make('Pointer');
+            case idl.IDLSerializerBuffer: return { text: 'KSerializerBuffer', noPrefix: true };
         }
         throw new Error(`Unmapped primitive type ${idl.DebugUtils.debugPrintType(type)}`);
     }
-    enumName(target) {
+    qualifiedName(target) {
         return qualifiedName(target, "_");
     }
     computeTargetTypeLiteralName(decl) {
@@ -218,7 +219,8 @@ export class CppInteropArgConvertor extends InteropArgConvertor {
             case idl.IDLBooleanType: return PrimitiveTypesInstance.Boolean.getText();
             case idl.IDLI32Type: return PrimitiveTypesInstance.Int32.getText();
             case idl.IDLNumberType: return "KInteropNumber";
-            case idl.IDLBufferType: return "Ark_Buffer";
+            case idl.IDLSerializerBuffer: return "KSerializerBuffer";
+            case idl.IDLBufferType: return "KInteropBuffer";
             case idl.IDLLengthType: return "KLength";
             case idl.IDLFunctionType: return PrimitiveTypesInstance.Int32.getText();
             case idl.IDLDate: return PrimitiveTypesInstance.Int64.getText();
@@ -262,7 +264,7 @@ export class CppReturnTypeConvertor {
     convertTypeReference(type) {
         const decl = this.resolver.resolveTypeReference(type);
         if (decl && idl.isInterface(decl) && isMaterialized(decl, this.resolver)) {
-            return generatorTypePrefix() + decl.name;
+            return generatorTypePrefix() + qualifiedName(decl, "_");
         }
         return this.convertor.convert(type);
     }

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

@@ -76,7 +76,6 @@ export class ETSTypeNameConvertor extends TSTypeNameConvertor {
                 return 'number';
             case idl.IDLStringType: return 'string';
             case idl.IDLFunctionType: return 'Object';
-            case idl.IDLBufferType: return 'NativeBuffer';
             case idl.IDLBigintType: return 'long';
         }
         return super.convertPrimitiveType(type);

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

@@ -88,6 +88,9 @@ export class InteropReturnTypeConvertor {
                 }
                 return KInteropReturnBuffer;
             }
+            if (idl.isEnum(decl)) {
+                return PrimitiveTypesInstance.Int32.getText();
+            }
         }
         return "void";
     }
@@ -116,6 +119,7 @@ export class InteropArgConvertor {
             case idl.IDLF32Type: return "KFloat";
             case idl.IDLNumberType: return 'KInteropNumber';
             case idl.IDLBigintType: return 'KLong';
+            case idl.IDLSerializerBuffer: return 'KSerializerBuffer';
             case idl.IDLBooleanType:
             case idl.IDLFunctionType: return 'KInt';
             case idl.IDLStringType: return 'KStringPtr';

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

@@ -122,6 +122,7 @@ export class TSTypeNameConvertor {
             case idl.IDLAnyType: return 'any';
             case idl.IDLUndefinedType: return 'undefined';
             case idl.IDLPointerType: return 'KPointer';
+            case idl.IDLSerializerBuffer: return 'KSerializerBuffer';
             case idl.IDLVoidType: return 'void';
             case idl.IDLBooleanType: return 'boolean';
             case idl.IDLI32Type:
@@ -145,7 +146,7 @@ export class TSTypeNameConvertor {
             case idl.IDLDate:
                 return 'Date';
             case idl.IDLBufferType:
-                return `ArrayBuffer`;
+                return 'NativeBuffer';
             case idl.IDLInteropReturnBufferType:
                 return `KInteropReturnBuffer`;
         }

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

@@ -89,15 +89,23 @@ export declare class CJLanguageWriter extends LanguageWriter {
     writeFieldDeclaration(name: string, type: idl.IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
     writeMethodDeclaration(name: string, signature: MethodSignature, modifiers?: MethodModifier[]): void;
     writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
-    writeProperty(propName: string, propType: idl.IDLType, mutable?: boolean, getterLambda?: (writer: this) => void, setterLambda?: (writer: this) => void): void;
     writeTypeDeclaration(decl: idl.IDLTypedef): void;
     writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
     writeMethodImplementation(method: Method, op: (writer: this) => void): void;
+    writeProperty(propName: string, propType: idl.IDLType, modifiers: FieldModifier[], getter?: {
+        method: Method;
+        op?: () => void;
+    }, setter?: {
+        method: Method;
+        op: () => void;
+    }): void;
+    writeGetterImplementation(method: Method, op?: (writer: this) => void): void;
+    writeSetterImplementation(method: Method, op: (writer: this) => void): void;
     writeCJForeign(op: (writer: CJLanguageWriter) => void): void;
     private writeDeclaration;
     writeNativeFunctionCall(printer: LanguageWriter, name: string, signature: MethodSignature): void;
     writeNativeMethodDeclaration(method: Method): void;
-    makeEnumCast(enumName: string, _unsafe: boolean, _convertor: ArgConvertor | undefined): string;
+    makeEnumCast(_enumEntry: idl.IDLEnum, enumName: string): string;
     makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression, isDeclared?: boolean, isConst?: boolean): LanguageStatement;
     makeClassInit(type: idl.IDLType, parameters: LanguageExpression[]): LanguageExpression;
     makeArrayInit(type: idl.IDLContainerType, size?: number): LanguageExpression;

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

@@ -348,33 +348,6 @@ export class CJLanguageWriter extends LanguageWriter {
         this.popIndent();
         this.printer.print(`}`);
     }
-    writeProperty(propName, propType, mutable, getterLambda, setterLambda) {
-        let shortName = propName.concat("_container");
-        if (!getterLambda) {
-            this.print(`private var ${shortName}: ${this.getNodeName(propType)}`);
-        }
-        this.print(`${mutable ? "mut " : ""}prop ${propName}: ${this.getNodeName(propType)} {`);
-        this.pushIndent();
-        this.print(`get() {`);
-        this.pushIndent();
-        if (getterLambda) {
-            getterLambda(this);
-        }
-        else {
-            this.print(`return ${shortName}`);
-        }
-        this.popIndent();
-        this.print(`}`);
-        if (mutable) {
-            this.print(`set(x) { ${shortName} = x }`);
-            this.pushIndent();
-            if (setterLambda)
-                setterLambda(this);
-            this.popIndent();
-        }
-        this.popIndent();
-        this.print(`}`);
-    }
     writeTypeDeclaration(decl) {
         throw new Error(`writeTypeDeclaration not implemented`);
     }
@@ -389,6 +362,51 @@ export class CJLanguageWriter extends LanguageWriter {
         this.popIndent();
         this.printer.print(`}`);
     }
+    writeProperty(propName, propType, modifiers, getter, setter) {
+        let containerName = propName.concat("_container");
+        let truePropName = this.escapeKeyword(propName);
+        if (getter) {
+            if (!getter.op) {
+                this.print(`private var ${containerName}: ${this.getNodeName(propType)}`);
+            }
+        }
+        let isStatic = modifiers.includes(FieldModifier.STATIC);
+        let isMutable = !modifiers.includes(FieldModifier.READONLY);
+        this.print(`public ${isMutable ? "mut " : ""}${isStatic ? "static " : "open "}prop ${truePropName}: ${this.getNodeName(propType)}`);
+        if (getter) {
+            this.print('{');
+            this.pushIndent();
+            this.writeGetterImplementation(getter.method, getter.op);
+            if (isMutable) {
+                if (setter) {
+                    this.writeSetterImplementation(setter.method, setter ? setter.op : (writer) => { this.print(`${containerName} = ${truePropName}`); });
+                }
+                else {
+                    this.print(`set(${truePropName}) {`);
+                    this.pushIndent();
+                    this.print(`${containerName} = ${truePropName}`);
+                    this.popIndent();
+                    this.print(`}`);
+                }
+            }
+            this.popIndent();
+            this.print('}');
+        }
+    }
+    writeGetterImplementation(method, op) {
+        this.print(`get() {`);
+        this.pushIndent();
+        op ? op(this) : this.print(`return ${method.signature.argsNames.map(arg => `${arg}_container`).join(', ')}`);
+        this.popIndent();
+        this.print('}');
+    }
+    writeSetterImplementation(method, op) {
+        this.print(`set(${method.signature.argsNames.join(', ')}) {`);
+        this.pushIndent();
+        op(this);
+        this.popIndent();
+        this.print('}');
+    }
     writeCJForeign(op) {
         this.print(`foreign {`);
         this.pushIndent();
@@ -399,7 +417,7 @@ export class CJLanguageWriter extends LanguageWriter {
     writeDeclaration(name, signature, modifiers, postfix) {
         let prefix = modifiers === null || modifiers === void 0 ? void 0 : modifiers.filter(it => this.supportedModifiers.includes(it)).map(it => this.mapMethodModifier(it)).join(" ");
         prefix = prefix ? prefix + " " : "";
-        this.print(`${prefix}func ${name}(${signature.args.map((it, index) => `${this.escapeKeyword(signature.argName(index))}: ${this.getNodeName(it)}`).join(", ")}): ${this.getNodeName(signature.returnType)}${postfix !== null && postfix !== void 0 ? postfix : ""}`);
+        this.print(`${prefix}${((modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.SETTER)) || (modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.GETTER))) ? '' : 'func '}${name}(${signature.args.map((it, index) => `${this.escapeKeyword(signature.argName(index))}: ${this.getNodeName(it)}`).join(", ")}): ${this.getNodeName(signature.returnType)}${postfix !== null && postfix !== void 0 ? postfix : ""}`);
     }
     writeNativeFunctionCall(printer, name, signature) {
         printer.print(`return unsafe { ${name}(${signature.args.map((it, index) => `${signature.argName(index)}`).join(", ")}) }`);
@@ -410,7 +428,7 @@ export class CJLanguageWriter extends LanguageWriter {
         name = name.startsWith('_') ? name.slice(1) : name;
         this.print(`func ${name}(${signture}): ${this.typeForeignConvertor.convert(method.signature.returnType)}`);
     }
-    makeEnumCast(enumName, _unsafe, _convertor) {
+    makeEnumCast(_enumEntry, enumName) {
         return `${enumName}.value`;
     }
     makeAssign(variableName, type, expr, isDeclared = true, isConst = true) {

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

@@ -7,6 +7,7 @@ import { IdlNameConvertor } from "../nameConvertor";
 import { RuntimeType } from "../common";
 import { IndentedPrinter } from "../../IndentedPrinter";
 import { ReferenceResolver } from "../../peer-generation/ReferenceResolver";
+import * as idl from "../../idl";
 export declare class CppCastExpression implements LanguageExpression {
     convertor: IdlNameConvertor;
     value: LanguageExpression;
@@ -45,7 +46,13 @@ export declare class CppLanguageWriter extends CLikeLanguageWriter {
     writeMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;
     writeFieldDeclaration(name: string, type: IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
     writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
-    writeProperty(propName: string, propType: IDLType, mutable?: boolean): void;
+    writeProperty(propName: string, propType: IDLType, modifiers: FieldModifier[], getter?: {
+        method: Method;
+        op: () => void;
+    }, setter?: {
+        method: Method;
+        op: () => void;
+    }): void;
     writeTypeDeclaration(decl: IDLTypedef): void;
     writeConstant(constName: string, constType: IDLType, constVal?: string): void;
     /**
@@ -102,9 +109,9 @@ export declare class CppLanguageWriter extends CLikeLanguageWriter {
     get supportedFieldModifiers(): FieldModifier[];
     enumFromOrdinal(value: LanguageExpression, type: IDLType): LanguageExpression;
     ordinalFromEnum(value: LanguageExpression, _: IDLType): LanguageExpression;
-    makeUnsafeCast(convertor: ArgConvertor, param: string): string;
+    makeUnsafeCast(param: string): string;
     makeUnsafeCast_(value: LanguageExpression, type: IDLType, typeOptions?: PrintHint): string;
-    makeEnumCast(value: string, _unsafe: boolean, convertor: ArgConvertor | undefined): string;
+    makeEnumCast(enumEntry: idl.IDLEnum, value: string): string;
     escapeKeyword(name: string): string;
     makeEnumEntity(enumEntity: IDLEnum, isExport: boolean): LanguageStatement;
     private decayTypeName;