@idlizer/core 2.1.9-arktscgen-8 → 2.1.10-arktscgen-2

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

@@ -13,7 +13,6 @@
  * limitations under the License.
  */
 import * as idl from "../idl";
-import { indentedBy } from "../util";
 import * as fs from "fs";
 import { RuntimeType } from "./common";
 export class TernaryExpression {
@@ -143,13 +142,14 @@ export class ExpressionStatement {
     }
 }
 export class BlockStatement {
-    constructor(statements, inScope = true) {
+    constructor(statements, inScope = true, newLine = true) {
         this.statements = statements;
         this.inScope = inScope;
+        this.newLine = newLine;
     }
     write(writer) {
         if (this.inScope) {
-            writer.print("{");
+            this.newLine ? writer.print("{") : writer.printer.appendLastString(" {");
             writer.pushIndent();
         }
         this.statements.forEach(s => s.write(writer));
@@ -175,7 +175,12 @@ export class IfStatement {
             }
         });
         if (this.elseStatement !== undefined) {
-            writer.print("else");
+            if ((this.thenStatement instanceof BlockStatement) && this.thenStatement.inScope) {
+                writer.printer.appendLastString(" else");
+            }
+            else {
+                writer.print("else");
+            }
             this.writeBody(writer, this.elseStatement, () => {
                 if (this.insideElseOp) {
                     this.insideElseOp();
@@ -206,7 +211,7 @@ export class MultiBranchIfStatement {
                 writer.print(`if (${expr.asString()}) {`);
             }
             else {
-                writer.print(`else if (${expr.asString()}) {`);
+                writer.printer.appendLastString(` else if (${expr.asString()}) {`);
             }
             writer.pushIndent();
             stmt.write(writer);
@@ -214,7 +219,7 @@ export class MultiBranchIfStatement {
             writer.print("}");
         });
         if (this.statements.length > 0 && this.elseStatement !== undefined) {
-            writer.print("else {");
+            writer.printer.appendLastString(" else {");
             writer.pushIndent();
             this.elseStatement.write(writer);
             writer.popIndent();
@@ -268,21 +273,17 @@ export class LambdaExpression {
         this.resolver = resolver;
         this.body = body;
     }
-    bodyAsString() {
-        var _a;
+    bodyAsString(isScoped = false) {
         const writer = this.originalWriter.fork();
         if (this.body) {
-            for (const stmt of this.body) {
-                stmt.write(writer);
-            }
+            writer.writeStatement(new BlockStatement(this.body, isScoped, false));
         }
         writer.features.forEach(([feature, module]) => {
             this.originalWriter.addFeature(feature, module);
         });
-        return (this.body ? ((_a = this.body) === null || _a === void 0 ? void 0 : _a.length) > 1 ? '\n' : '' : '').concat(writer.getOutput()
-            .filter(line => line !== "")
-            .map(line => indentedBy(line.endsWith('{') || line.endsWith('}') || line.endsWith(';') ? line : `${line};`, 1))
-            .join("\n"));
+        return writer.getOutput()
+            .map(line => (line.endsWith('{') || line.endsWith('}') || line.endsWith(';')) ? line : `${line};`)
+            .join("\n");
     }
 }
 ////////////////////////////////////////////////////////////////

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

@@ -166,7 +166,7 @@ export class TSTypeNameConvertor {
             case idl.IDLDate:
                 return 'Date';
             case idl.IDLBufferType:
-                return 'NativeBuffer';
+                return 'ArrayBuffer';
             case idl.IDLInteropReturnBufferType:
                 return `KInteropReturnBuffer`;
         }

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

@@ -123,7 +123,7 @@ export declare class CJLanguageWriter extends LanguageWriter {
     makeReturn(expr: LanguageExpression): LanguageStatement;
     makeStatement(expr: LanguageExpression): LanguageStatement;
     makeLoop(counter: string, limit: string, statement?: LanguageStatement): LanguageStatement;
-    makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;
+    makeMapForEach(map: string, key: string, value: string, body: LanguageStatement[]): LanguageStatement;
     makeDefinedCheck(value: string): LanguageExpression;
     makeNewObject(objectName: string, params?: LanguageExpression[]): LanguageExpression;
     writePrintLog(message: string): 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, ExpressionStatement, FieldModifier, LambdaExpression, LanguageWriter, MethodModifier, MethodSignature, ReturnStatement, StringExpression } from "../LanguageWriter";
+import { AssignStatement, BlockStatement, ExpressionStatement, FieldModifier, LambdaExpression, LanguageWriter, MethodModifier, MethodSignature, ReturnStatement, StringExpression } from "../LanguageWriter";
 import { Language } from "../../Language";
 import { indentedBy, isDefined } from "../../util";
 ////////////////////////////////////////////////////////////////
@@ -145,16 +145,16 @@ class CJLoopStatement {
     }
 }
 class CJMapForEachStatement {
-    constructor(map, key, value, op) {
+    constructor(map, key, value, body) {
         this.map = map;
         this.key = key;
         this.value = value;
-        this.op = op;
+        this.body = body;
     }
     write(writer) {
         writer.print(`for ((${this.key}, ${this.value}) in ${this.map}) {`);
         writer.pushIndent();
-        this.op();
+        writer.writeStatement(new BlockStatement(this.body, false));
         writer.popIndent();
         writer.print(`}`);
     }
@@ -483,8 +483,8 @@ export class CJLanguageWriter extends LanguageWriter {
     makeLoop(counter, limit, statement) {
         return new CJLoopStatement(counter, limit, statement);
     }
-    makeMapForEach(map, key, value, op) {
-        return new CJMapForEachStatement(map, key, value, op);
+    makeMapForEach(map, key, value, body) {
+        return new CJMapForEachStatement(map, key, value, body);
     }
     makeDefinedCheck(value) {
         return new CJCheckDefinedExpression(this.escapeKeyword(value));

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

@@ -92,7 +92,7 @@ export declare class CppLanguageWriter extends CLikeLanguageWriter {
     makeUnionVariantCast(value: string, type: string, convertor: ArgConvertor, index: number): LanguageExpression;
     makeStaticMethodCall(receiver: string, method: string, params: LanguageExpression[], nullable?: boolean): LanguageExpression;
     makeLoop(counter: string, limit: string, statement?: LanguageStatement): LanguageStatement;
-    makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;
+    makeMapForEach(map: string, key: string, value: string, body: LanguageStatement[]): LanguageStatement;
     makeArrayInit(type: IDLContainerType): LanguageExpression;
     makeClassInit(type: IDLType, paramenters: LanguageExpression[]): LanguageExpression;
     makeMapInit(type: IDLType): LanguageExpression;

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

@@ -123,18 +123,18 @@ class CppMapResizeStatement {
     }
 }
 class CppMapForEachStatement {
-    constructor(map, key, value, op) {
+    constructor(map, key, value, body) {
         this.map = map;
         this.key = key;
         this.value = value;
-        this.op = op;
+        this.body = body;
     }
     write(writer) {
         writer.print(`for (int32_t i = 0; i < ${this.map}.size; i++) {`);
         writer.pushIndent();
         writer.print(`auto ${this.key} = ${this.map}.keys[i];`);
         writer.print(`auto ${this.value} = ${this.map}.values[i];`);
-        this.op();
+        writer.writeStatement(new BlockStatement(this.body, false));
         writer.popIndent();
         writer.print(`}`);
     }
@@ -179,7 +179,7 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
     }
     fork(options) {
         var _a;
-        return new CppLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.primitivesTypes);
+        return new CppLanguageWriter(new IndentedPrinter([], this.indentDepth()), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.primitivesTypes);
     }
     writeDeclaration(name, signature, modifiers, postfix) {
         const realName = this.classMode === 'normal' ? name : `${this.currentClass.at(0)}::${name}`;
@@ -320,8 +320,8 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
     makeLoop(counter, limit, statement) {
         return new CLikeLoopStatement(counter, limit, statement);
     }
-    makeMapForEach(map, key, value, op) {
-        return new CppMapForEachStatement(map, key, value, op);
+    makeMapForEach(map, key, value, body) {
+        return new CppMapForEachStatement(map, key, value, body);
     }
     makeArrayInit(type) {
         return this.makeString(`{}`);

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

@@ -7,6 +7,12 @@ import * as idl from '../../idl';
 import { IdlNameConvertor } from "../nameConvertor";
 import { RuntimeType } from "../common";
 import { ReferenceResolver } from "../../peer-generation/ReferenceResolver";
+export declare class ETSStringExpression implements LanguageExpression {
+    value: string;
+    constructor(value: string);
+    private changeQuotes;
+    asString(): string;
+}
 export declare class EtsAssignStatement implements LanguageStatement {
     variableName: string;
     type: IDLType | undefined;
@@ -44,7 +50,8 @@ export declare class ETSLanguageWriter extends TSLanguageWriter {
     }): LanguageWriter;
     makeAssign(variableName: string, type: IDLType | undefined, expr: LanguageExpression, isDeclared?: boolean, isConst?: boolean, options?: MakeAssignOptions): LanguageStatement;
     makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
-    makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;
+    makeString(value: string): LanguageExpression;
+    makeMapForEach(map: string, key: string, value: string, body: LanguageStatement[]): LanguageStatement;
     makeMapSize(map: string): LanguageExpression;
     get supportedModifiers(): MethodModifier[];
     runtimeType(param: ArgConvertor, valueType: string, value: string): void;

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

@@ -13,7 +13,7 @@
  * limitations under the License.
  */
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { LambdaExpression, MethodModifier } from "../LanguageWriter";
+import { BlockStatement, LambdaExpression, MethodModifier } from "../LanguageWriter";
 import { TSCastExpression, TSLanguageWriter } from "./TsLanguageWriter";
 import { getExtAttribute, IDLThisType } from '../../idl';
 import { AggregateConvertor, CustomTypeConvertor, InterfaceConvertor, MaterializedClassConvertor } from "../ArgConvertors";
@@ -22,6 +22,23 @@ import { convertDeclaration } from "../nameConvertor";
 import { createDeclarationNameConvertor } from "../../peer-generation/idl/IdlNameConvertor";
 import { Language } from "../../Language";
 ////////////////////////////////////////////////////////////////
+//                        EXPRESSIONS                         //
+////////////////////////////////////////////////////////////////
+export class ETSStringExpression {
+    constructor(value) {
+        this.value = value;
+    }
+    changeQuotes(value) {
+        return `'${value.substring(1, value.length - 1)}'`;
+    }
+    asString() {
+        if (this.value.startsWith('"') && this.value.endsWith('"')) {
+            return this.changeQuotes(this.value);
+        }
+        return this.value;
+    }
+}
+////////////////////////////////////////////////////////////////
 //                         STATEMENTS                         //
 ////////////////////////////////////////////////////////////////
 export class EtsAssignStatement {
@@ -49,18 +66,18 @@ export class EtsAssignStatement {
     }
 }
 class ArkTSMapForEachStatement {
-    constructor(map, key, value, op) {
+    constructor(map, key, value, body) {
         this.map = map;
         this.key = key;
         this.value = value;
-        this.op = op;
+        this.body = body;
     }
     write(writer) {
         writer.print(`for (const pair of ${this.map}) {`);
         writer.pushIndent();
         writer.print(`const ${this.key} = pair[0]`);
         writer.print(`const ${this.value} = pair[1]`);
-        this.op();
+        writer.writeStatement(new BlockStatement(this.body, false));
         writer.popIndent();
         writer.print(`}`);
     }
@@ -126,7 +143,7 @@ export class ETSLambdaExpression extends LambdaExpression {
             isRetTypeCallback = resolved !== undefined && idl.isCallback(resolved);
         }
         return `(${params.join(", ")})${isRetTypeCallback
-            ? "" : `:${this.convertor.convert(this.signature.returnType)}`} => { ${this.bodyAsString()} }`;
+            ? "" : `:${this.convertor.convert(this.signature.returnType)}`} =>${this.bodyAsString(true)}`;
     }
 }
 ////////////////////////////////////////////////////////////////
@@ -160,7 +177,7 @@ export class ETSLanguageWriter extends TSLanguageWriter {
     }
     fork(options) {
         var _a;
-        return new ETSLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.arrayConvertor);
+        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);
     }
     makeAssign(variableName, type, expr, isDeclared = true, isConst = true, options) {
         return new EtsAssignStatement(variableName, type, expr, isDeclared, isConst, options);
@@ -168,8 +185,11 @@ export class ETSLanguageWriter extends TSLanguageWriter {
     makeLambda(signature, body) {
         return new ETSLambdaExpression(this, this.typeConvertor, signature, this.resolver, body);
     }
-    makeMapForEach(map, key, value, op) {
-        return new ArkTSMapForEachStatement(map, key, value, op);
+    makeString(value) {
+        return new ETSStringExpression(value);
+    }
+    makeMapForEach(map, key, value, body) {
+        return new ArkTSMapForEachStatement(map, key, value, body);
     }
     makeMapSize(map) {
         return this.makeString(`${super.makeMapSize(map).asString()}`); // TODO: cast really needed?

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

@@ -49,7 +49,7 @@ export declare class JavaLanguageWriter extends CLikeLanguageWriter {
     makeReturn(expr: LanguageExpression): LanguageStatement;
     makeDefinedCheck(value: string): LanguageExpression;
     makeLoop(counter: string, limit: string, statement?: LanguageStatement): LanguageStatement;
-    makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;
+    makeMapForEach(map: string, key: string, value: string, body: LanguageStatement[]): LanguageStatement;
     makeMapSize(map: string): LanguageExpression;
     makeCast(value: LanguageExpression, node: idl.IDLNode, options?: MakeCastOptions): LanguageExpression;
     makeStatement(expr: LanguageExpression): LanguageStatement;

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

@@ -14,7 +14,7 @@
  */
 import { Language } from '../../Language';
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { AssignStatement, FieldModifier, LambdaExpression, Method, MethodModifier, MethodSignature, NamedMethodSignature, } from "../LanguageWriter";
+import { AssignStatement, BlockStatement, FieldModifier, LambdaExpression, Method, MethodModifier, MethodSignature, NamedMethodSignature, } from "../LanguageWriter";
 import { CLikeExpressionStatement, CLikeLanguageWriter, CLikeLoopStatement, CLikeReturnStatement } from "./CLikeLanguageWriter";
 import * as idl from '../../idl';
 import { RuntimeType } from "../common";
@@ -30,7 +30,7 @@ class JavaLambdaExpression extends LambdaExpression {
     }
     asString() {
         const params = this.signature.args.map((it, i) => `${idl.forceAsNamedNode(it).name} ${this.signature.argName(i)}`);
-        return `(${params.join(", ")}) -> { ${this.bodyAsString()} }`;
+        return `(${params.join(", ")}) ->${this.bodyAsString(true)}`;
     }
 }
 export class JavaCastExpression {
@@ -66,11 +66,11 @@ export class JavaAssignStatement extends AssignStatement {
     }
 }
 class JavaMapForEachStatement {
-    constructor(map, key, value, op) {
+    constructor(map, key, value, body) {
         this.map = map;
         this.key = key;
         this.value = value;
-        this.op = op;
+        this.body = body;
     }
     write(writer) {
         const entryVar = `${this.map}Entry`;
@@ -78,7 +78,7 @@ class JavaMapForEachStatement {
         writer.pushIndent();
         writer.print(`var ${this.key} = ${entryVar}.getKey();`);
         writer.print(`var ${this.value} = ${entryVar}.getValue();`);
-        this.op();
+        writer.writeStatement(new BlockStatement(this.body, false));
         writer.popIndent();
         writer.print(`}`);
     }
@@ -103,7 +103,7 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
     }
     fork(options) {
         var _a;
-        return new JavaLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor);
+        return new JavaLanguageWriter(new IndentedPrinter([], this.indentDepth()), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor);
     }
     writeClass(name, op, superClass, interfaces, generics, isDeclared, isExport = true) {
         let genericsClause = (generics === null || generics === void 0 ? void 0 : generics.length) ? `<${generics.join(', ')}> ` : ``;
@@ -194,8 +194,8 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
     makeLoop(counter, limit, statement) {
         return new CLikeLoopStatement(counter, limit, statement);
     }
-    makeMapForEach(map, key, value, op) {
-        return new JavaMapForEachStatement(map, key, value, op);
+    makeMapForEach(map, key, value, body) {
+        return new JavaMapForEachStatement(map, key, value, body);
     }
     makeMapSize(map) {
         return this.makeString(`${map}.size()`);

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

@@ -102,7 +102,7 @@ export declare class KotlinLanguageWriter extends LanguageWriter {
     makeLambdaReturn(expr: LanguageExpression): LanguageStatement;
     makeStatement(expr: LanguageExpression): LanguageStatement;
     makeLoop(counter: string, limit: string, statement?: LanguageStatement): LanguageStatement;
-    makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;
+    makeMapForEach(map: string, key: string, value: string, body: LanguageStatement[]): LanguageStatement;
     writePrintLog(message: string): void;
     makeCast(value: LanguageExpression, node: idl.IDLNode, options?: MakeCastOptions): LanguageExpression;
     typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;

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

@@ -15,7 +15,7 @@
 import * as idl from '../../idl';
 import { Language } from '../../Language';
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { AssignStatement, DelegationType, ExpressionStatement, FieldModifier, LambdaExpression, LanguageWriter, Method, MethodModifier, MethodSignature, ReturnStatement } from "../LanguageWriter";
+import { AssignStatement, BlockStatement, DelegationType, ExpressionStatement, FieldModifier, LambdaExpression, LanguageWriter, Method, MethodModifier, MethodSignature, ReturnStatement } from "../LanguageWriter";
 import { RuntimeType } from "../common";
 import { isDefined } from "../../util";
 import { removePoints } from '../convertors/CJConvertors';
@@ -108,16 +108,16 @@ export class KotlinEnumWithGetter {
     }
 }
 class KotlinMapForEachStatement {
-    constructor(map, key, value, op) {
+    constructor(map, key, value, body) {
         this.map = map;
         this.key = key;
         this.value = value;
-        this.op = op;
+        this.body = body;
     }
     write(writer) {
         writer.print(`for ((${this.key}, ${this.value}) in ${this.map}) {`);
         writer.pushIndent();
-        this.op();
+        writer.writeStatement(new BlockStatement(this.body, false));
         writer.popIndent();
         writer.print(`}`);
     }
@@ -460,8 +460,8 @@ export class KotlinLanguageWriter extends LanguageWriter {
     makeLoop(counter, limit, statement) {
         return new KotlinLoopStatement(counter, limit, statement);
     }
-    makeMapForEach(map, key, value, op) {
-        return new KotlinMapForEachStatement(map, key, value, op);
+    makeMapForEach(map, key, value, body) {
+        return new KotlinMapForEachStatement(map, key, value, body);
     }
     writePrintLog(message) {
         this.print(`println(\"${message}\")`);

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

@@ -76,7 +76,7 @@ export declare class TSLanguageWriter extends LanguageWriter {
     makeReturn(expr: LanguageExpression): LanguageStatement;
     makeStatement(expr: LanguageExpression): LanguageStatement;
     makeLoop(counter: string, limit: string, statement?: LanguageStatement): LanguageStatement;
-    makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;
+    makeMapForEach(map: string, key: string, value: string, body: LanguageStatement[]): LanguageStatement;
     writePrintLog(message: string): void;
     makeCast(value: LanguageExpression, node: idl.IDLNode, options?: MakeCastOptions): LanguageExpression;
     typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;

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

@@ -36,7 +36,7 @@ export class TSLambdaExpression extends LambdaExpression {
             const maybeOptional = idl.isOptionalType(it) ? "?" : "";
             return `${this.signature.argName(i)}${maybeOptional}: ${this.convertor.convert(it)}`;
         });
-        return `(${params.join(", ")}): ${this.convertor.convert(this.signature.returnType)} => { ${this.bodyAsString()} }`;
+        return `(${params.join(", ")}): ${this.convertor.convert(this.signature.returnType)} =>${this.bodyAsString(true)}`;
     }
 }
 export class TSCastExpression {
@@ -93,16 +93,16 @@ class TSLoopStatement {
     }
 }
 class TSMapForEachStatement {
-    constructor(map, key, value, op) {
+    constructor(map, key, value, body) {
         this.map = map;
         this.key = key;
         this.value = value;
-        this.op = op;
+        this.body = body;
     }
     write(writer) {
         writer.print(`for (const [${this.key}, ${this.value}] of ${this.map}) {`);
         writer.pushIndent();
-        this.op();
+        writer.writeStatement(new BlockStatement(this.body, false));
         writer.popIndent();
         writer.print(`}`);
     }
@@ -133,7 +133,7 @@ export class TSLanguageWriter extends LanguageWriter {
     }
     fork(options) {
         var _a;
-        return new TSLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.language);
+        return new TSLanguageWriter(new IndentedPrinter([], this.indentDepth()), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.language);
     }
     getNodeName(type) {
         // another stub. Bad one.
@@ -316,8 +316,8 @@ export class TSLanguageWriter extends LanguageWriter {
     makeLoop(counter, limit, statement) {
         return new TSLoopStatement(counter, limit, statement);
     }
-    makeMapForEach(map, key, value, op) {
-        return new TSMapForEachStatement(map, key, value, op);
+    makeMapForEach(map, key, value, body) {
+        return new TSMapForEachStatement(map, key, value, body);
     }
     writePrintLog(message) {
         this.print(`console.log("${message}")`);