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

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

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

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

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

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

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

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

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

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

package/build/lib/src/LanguageWriters/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.

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

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

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

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

package/build/lib/src/LanguageWriters/writers/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.js

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

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

@@ -66,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;
@@ -80,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

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