@abaplint/transpiler 2.13.48 → 2.13.50

package/build/src/db/schema_generation/database_schema_generator.d.ts

@@ -3,3 +3,4 @@ export interface DatabaseSchemaGenerator {
     buildVIEW(view: abaplint.Objects.View): string;
     buildTABL(view: abaplint.Objects.Table): string;
 }
+export declare function packedTypeToDatabase(type: abaplint.BasicTypes.PackedType): string;

package/build/src/db/schema_generation/database_schema_generator.js

@@ -1,3 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.packedTypeToDatabase = packedTypeToDatabase;
+function packedTypeToDatabase(type) {
+    const precision = type.getLength() * 2 - 1;
+    return `DECIMAL(${precision},${type.getDecimals()})`;
+}
 //# sourceMappingURL=database_schema_generator.js.map

package/build/src/db/schema_generation/pg_database_schema.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PGDatabaseSchema = void 0;
 const abaplint = __importStar(require("@abaplint/core"));
+const database_schema_generator_1 = require("./database_schema_generator");
 const _database_schema_reuse_1 = require("./_database_schema_reuse");
 const QUOTE = "\"";
 class PGDatabaseSchema {
@@ -99,7 +100,7 @@ class PGDatabaseSchema {
             return `REAL`;
         }
         else if (type instanceof abaplint.BasicTypes.PackedType) {
-            return `DECIMAL(${type.getLength()},${type.getDecimals()})`;
+            return (0, database_schema_generator_1.packedTypeToDatabase)(type);
         }
         else if (type instanceof abaplint.BasicTypes.VoidType) {
             throw `Type of ${errorInfo}-${fieldname} is VoidType(${type.getVoided()}), make sure the type is known, enable strict syntax checking`;

package/build/src/db/schema_generation/snowflake_database_schema.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SnowflakeDatabaseSchema = void 0;
 const abaplint = __importStar(require("@abaplint/core"));
+const database_schema_generator_1 = require("./database_schema_generator");
 class SnowflakeDatabaseSchema {
     reg;
     constructor(reg) {
@@ -98,7 +99,7 @@ class SnowflakeDatabaseSchema {
             return `REAL`;
         }
         else if (type instanceof abaplint.BasicTypes.PackedType) {
-            return `DECIMAL(${type.getLength()},${type.getDecimals()})`;
+            return (0, database_schema_generator_1.packedTypeToDatabase)(type);
         }
         else if (type instanceof abaplint.BasicTypes.VoidType) {
             throw `Type of ${errorInfo}-${fieldname} is VoidType(${type.getVoided()}), make sure the type is known, enable strict syntax checking`;

package/build/src/db/schema_generation/sqlite_database_schema.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SQLiteDatabaseSchema = void 0;
 const abaplint = __importStar(require("@abaplint/core"));
+const database_schema_generator_1 = require("./database_schema_generator");
 const _database_schema_reuse_1 = require("./_database_schema_reuse");
 const QUOTE = "'";
 class SQLiteDatabaseSchema {
@@ -100,7 +101,7 @@ class SQLiteDatabaseSchema {
             return `REAL`;
         }
         else if (type instanceof abaplint.BasicTypes.PackedType) {
-            return `DECIMAL(${type.getLength()},${type.getDecimals()})`;
+            return (0, database_schema_generator_1.packedTypeToDatabase)(type);
         }
         else if (type instanceof abaplint.BasicTypes.VoidType) {
             throw `Type of ${errorInfo}-${fieldname} is VoidType(${type.getVoided()}), make sure the type is known, enable strict syntax checking`;

package/build/src/expressions/filter_body.d.ts

@@ -3,4 +3,9 @@ import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class FilterBodyTranspiler {
     transpile(typ: Nodes.ExpressionNode, body: Nodes.ExpressionNode, traversal: Traversal): Chunk;
+    private transpileSingle;
+    private transpileIn;
+    private transpileInCondition;
+    private transpileInCompare;
+    private filterOperand;
 }

package/build/src/expressions/filter_body.js

@@ -2,39 +2,151 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FilterBodyTranspiler = void 0;
 const core_1 = require("@abaplint/core");
+const traversal_1 = require("../traversal");
 const chunk_1 = require("../chunk");
 const type_name_or_infer_1 = require("./type_name_or_infer");
 const transpile_types_1 = require("../transpile_types");
 const unique_identifier_1 = require("../unique_identifier");
+const component_chain_simple_1 = require("./component_chain_simple");
 class FilterBodyTranspiler {
     transpile(typ, body, traversal) {
         if (!(typ.get() instanceof core_1.Expressions.TypeNameOrInfer)) {
             throw new Error("FilterBodyTranspiler, Expected TypeNameOrInfer");
         }
-        else if (body.findDirectTokenByText("EXCEPT")) {
-            return new chunk_1.Chunk(`(() => { throw new Error("FilterBodyTranspiler EXCEPT in, not supported, transpiler"); })()`);
+        const sources = body.findDirectExpressions(core_1.Expressions.Source);
+        if (sources.length === 0) {
+            throw new Error("FilterBodyTranspiler, source not found");
         }
-        const source = traversal.traverse(body.findDirectExpression(core_1.Expressions.Source)).getCode();
+        const source = traversal.traverse(sources[0]).getCode();
         const type = new type_name_or_infer_1.TypeNameOrInfer().findType(typ, traversal);
         const target = transpile_types_1.TranspileTypes.toType(type);
+        const whereNode = body.findDirectExpression(core_1.Expressions.ComponentCond);
+        if (whereNode === undefined) {
+            throw new Error("FilterBodyTranspiler, WHERE not found");
+        }
+        if (sources.length > 1) {
+            return this.transpileIn(target, source, traversal.traverse(sources[1]).getCode(), whereNode, body.findDirectTokenByText("EXCEPT") !== undefined, body, traversal);
+        }
+        return this.transpileSingle(target, source, whereNode, body.findDirectTokenByText("EXCEPT") !== undefined, body, traversal);
+    }
+    transpileSingle(target, source, whereNode, except, body, traversal) {
+        const result = unique_identifier_1.UniqueIdentifier.get();
+        const row = unique_identifier_1.UniqueIdentifier.get();
+        const where = traversal.traverse(whereNode).getCode();
+        const options = [];
+        options.push(except ? `where: async (I) => !((${where})(I))` : `where: async ${where}`);
+        const key = body.findDirectExpression(core_1.Expressions.SimpleName);
+        if (key) {
+            options.push(`usingKey: "${key.concatTokens().toLowerCase()}"`);
+        }
         const ret = new chunk_1.Chunk();
         ret.appendString("(await (async () => {\n");
-        let loopWhere = "";
-        const whereNode = body.findDirectExpression(core_1.Expressions.ComponentCond);
-        if (whereNode) {
-            const where = traversal.traverse(whereNode).getCode();
-            loopWhere = `, {"where": async ` + where + `}`;
-        }
-        const id = unique_identifier_1.UniqueIdentifier.get();
-        const loop = unique_identifier_1.UniqueIdentifier.get();
-        ret.appendString(`const ${id} = ${target};\n`);
-        ret.appendString(`for await (const ${loop} of abap.statements.loop(${source}${loopWhere})) {\n`);
-        ret.appendString(`abap.statements.insertInternal({"table": ${id}, "data": ${loop}});\n`);
-        ret.appendString(`}\n`);
-        ret.appendString(`return ${id};\n`);
+        ret.appendString(`const ${result} = ${target};\n`);
+        ret.appendString(`for await (const ${row} of abap.statements.loop(${source}, {${options.join(", ")}})) {\n`);
+        ret.appendString(`abap.statements.insertInternal({"table": ${result}, "data": ${row}});\n`);
+        ret.appendString("}\n");
+        ret.appendString(`return ${result};\n`);
         ret.appendString("})())");
         return ret;
     }
+    transpileIn(target, source, filterSource, whereNode, except, body, traversal) {
+        const result = unique_identifier_1.UniqueIdentifier.get();
+        const sourceRow = unique_identifier_1.UniqueIdentifier.get();
+        const filterRow = unique_identifier_1.UniqueIdentifier.get();
+        const matched = unique_identifier_1.UniqueIdentifier.get();
+        const condition = this.transpileInCondition(whereNode, traversal, sourceRow, filterRow);
+        const key = body.findDirectExpression(core_1.Expressions.SimpleName);
+        const filterOptions = key ? `, {usingKey: "${key.concatTokens().toLowerCase()}"}` : "";
+        const selection = except ? `!${matched}` : matched;
+        const ret = new chunk_1.Chunk();
+        ret.appendString("(await (async () => {\n");
+        ret.appendString(`const ${result} = ${target};\n`);
+        ret.appendString(`for await (const ${sourceRow} of abap.statements.loop(${source})) {\n`);
+        ret.appendString(`let ${matched} = false;\n`);
+        ret.appendString(`for await (const ${filterRow} of abap.statements.loop(${filterSource}${filterOptions})) {\n`);
+        ret.appendString(`if (${condition}) {\n`);
+        ret.appendString(`${matched} = true;\n`);
+        ret.appendString("break;\n}\n}\n");
+        ret.appendString(`if (${selection}) {\n`);
+        ret.appendString(`abap.statements.insertInternal({"table": ${result}, "data": ${sourceRow}});\n`);
+        ret.appendString("}\n}\n");
+        ret.appendString(`return ${result};\n`);
+        ret.appendString("})())");
+        return ret;
+    }
+    transpileInCondition(node, traversal, sourceRow, filterRow) {
+        if (node.get() instanceof core_1.Expressions.ComponentCompare) {
+            return this.transpileInCompare(node, traversal, sourceRow, filterRow);
+        }
+        let ret = "";
+        for (const child of node.getChildren()) {
+            if (child instanceof core_1.Nodes.ExpressionNode) {
+                ret += this.transpileInCondition(child, traversal, sourceRow, filterRow);
+            }
+            else {
+                switch (child.concatTokens().toUpperCase()) {
+                    case "AND":
+                        ret += " && ";
+                        break;
+                    case "OR":
+                        ret += " || ";
+                        break;
+                    case "NOT":
+                        ret += "!";
+                        break;
+                    case "(":
+                        ret += "(";
+                        break;
+                    case ")":
+                        ret += ")";
+                        break;
+                    default: throw new Error("FilterBodyTranspiler, unexpected condition token " + child.concatTokens());
+                }
+            }
+        }
+        return ret;
+    }
+    transpileInCompare(node, traversal, sourceRow, filterRow) {
+        const leftNode = node.findDirectExpression(core_1.Expressions.ComponentChainSimple);
+        if (leftNode === undefined) {
+            throw new Error("FilterBodyTranspiler, comparison component not found");
+        }
+        const left = new component_chain_simple_1.ComponentChainSimpleTranspiler(`${sourceRow}.get().`).transpile(leftNode, traversal).getCode();
+        const sources = node.findDirectExpressions(core_1.Expressions.Source);
+        const concat = node.concatTokens().toUpperCase();
+        const negate = concat.startsWith("NOT ") ? "!" : "";
+        const operator = node.findDirectExpression(core_1.Expressions.CompareOperator);
+        if (operator && sources[0]) {
+            const compare = traversal.traverse(operator).getCode();
+            return `${negate}abap.compare.${compare}(${left}, ${this.filterOperand(sources[0], traversal, filterRow)})`;
+        }
+        if (concat.includes(" BETWEEN ") && sources.length === 2) {
+            const between = `abap.compare.ge(${left}, ${this.filterOperand(sources[0], traversal, filterRow)}) && `
+                + `abap.compare.le(${left}, ${this.filterOperand(sources[1], traversal, filterRow)})`;
+            return concat.includes(" NOT BETWEEN ") ? `!(${between})` : `(${between})`;
+        }
+        if (concat.endsWith("IS INITIAL")) {
+            return `${negate}abap.compare.initial(${left})`;
+        }
+        else if (concat.endsWith("IS NOT INITIAL")) {
+            return `!abap.compare.initial(${left})`;
+        }
+        throw new Error("FilterBodyTranspiler, unsupported IN comparison " + node.concatTokens());
+    }
+    filterOperand(source, traversal, filterRow) {
+        const code = traversal.traverse(source).getCode();
+        const sourceField = source.findFirstExpression(core_1.Expressions.SourceField);
+        const name = sourceField?.findDirectExpression(core_1.Expressions.Field)?.concatTokens();
+        if (name === undefined) {
+            return code;
+        }
+        const escaped = traversal_1.Traversal.escapeNamespace(name)?.replace("~", "$").toLowerCase();
+        const variable = traversal_1.Traversal.prefixVariable(traversal_1.Traversal.escapeNamespace(name));
+        if (escaped === undefined || code.startsWith(variable) === false) {
+            return code;
+        }
+        return `${filterRow}.get().${escaped}` + code.substring(variable.length);
+    }
 }
 exports.FilterBodyTranspiler = FilterBodyTranspiler;
 //# sourceMappingURL=filter_body.js.map

package/build/src/expressions/reduce_body.d.ts

@@ -3,7 +3,11 @@ import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class ReduceBodyTranspiler {
     transpile(typ: Nodes.ExpressionNode, body: Nodes.ExpressionNode, traversal: Traversal): Chunk;
-    private transpileIndex;
+    private describeFor;
+    private describeGroupsFor;
+    private describeIndexFor;
     private declareInit;
     private transpileNext;
+    private appendBlocks;
+    private appendBlock;
 }

package/build/src/expressions/reduce_body.js

@@ -6,141 +6,278 @@ const traversal_1 = require("../traversal");
 const chunk_1 = require("../chunk");
 const transpile_types_1 = require("../transpile_types");
 const target_1 = require("./target");
+const let_1 = require("./let");
+const statements_1 = require("../statements");
+const source_field_symbol_1 = require("./source_field_symbol");
+const unique_identifier_1 = require("../unique_identifier");
 class ReduceBodyTranspiler {
     transpile(typ, body, traversal) {
         if (!(typ.get() instanceof core_1.Expressions.TypeNameOrInfer)) {
             throw new Error("ReduceBodyTranspiler, Expected TypeNameOrInfer");
         }
-        else if (body.findDirectExpression(core_1.Expressions.Let) !== undefined) {
-            return new chunk_1.Chunk(`(() => { throw new Error("ReduceBodyTranspiler LET, not supported, transpiler"); })()`);
-        }
         const forExpressions = body.findDirectExpressions(core_1.Expressions.For);
-        const forExpression = forExpressions[0];
         if (forExpressions.length === 0) {
             throw new Error("ReduceBodyTranspiler, expected FOR");
         }
-        else if (forExpressions.length > 1) {
-            throw new Error("ReduceBodyTranspiler, multiple FOR not supported, " + body.concatTokens());
-        }
-        const loopExpression = forExpression.findDirectExpression(core_1.Expressions.InlineLoopDefinition);
-        if (loopExpression === undefined) {
-            // index based FOR, eg. "FOR i = 1 WHILE i <= 5"
-            return this.transpileIndex(body, forExpression, traversal);
-        }
-        else if (["THEN", "UNTIL", "WHILE", "FROM", "TO", "GROUPS"].some(token => forExpression.findDirectTokenByText(token))) {
-            throw new Error("ValueBody FOR todo, " + body.concatTokens());
-        }
-        const loopSource = traversal.traverse(loopExpression?.findDirectExpression(core_1.Expressions.Source)).getCode();
-        const loopVariable = traversal.traverse(loopExpression?.findDirectExpression(core_1.Expressions.TargetField)
-            || loopExpression?.findDirectExpression(core_1.Expressions.TargetFieldSymbol)).getCode();
-        //    const type = new TypeNameOrInfer().findType(typ, traversal);
-        //    const target = TranspileTypes.toType(type);
         const ret = new chunk_1.Chunk();
         ret.appendString("(await (async () => {\n");
-        let loopWhere = "";
-        const whereNode = forExpression?.findDirectExpression(core_1.Expressions.ComponentCond);
-        if (whereNode) {
-            const where = traversal.traverse(whereNode).getCode();
-            loopWhere = `, {"where": async ` + where + `}`;
+        const outerLet = body.findDirectExpression(core_1.Expressions.Let);
+        if (outerLet) {
+            ret.appendString(new let_1.LetTranspiler().transpile(outerLet, traversal).getCode() + "\n");
         }
-        /*
-        const returnId = UniqueIdentifier.get();
-        ret.appendString(`const ${returnId} = ${target};\n`);
-        */
         const returnField = this.declareInit(body, traversal, ret);
-        ret.appendString(`for await (const ${loopVariable} of abap.statements.loop(${loopSource}${loopWhere})) {\n`);
-        ret.appendString(this.transpileNext(body, traversal));
-        ret.appendString(`}\n`);
+        const declarations = [];
+        const descriptors = forExpressions.map(forExpression => this.describeFor(forExpression, body, traversal, declarations));
+        for (const declaration of declarations) {
+            ret.appendString(declaration + "\n");
+        }
+        let indent = "";
+        const levelIndents = [];
+        for (const descriptor of descriptors) {
+            this.appendBlocks(ret, descriptor.beforeLoop, indent);
+            ret.appendString(indent + descriptor.open + "\n");
+            indent += "  ";
+            levelIndents.push(indent);
+            this.appendBlocks(ret, descriptor.preBody, indent);
+        }
+        this.appendBlock(ret, this.transpileNext(body, traversal), indent);
+        for (let i = descriptors.length - 1; i >= 0; i--) {
+            const descriptor = descriptors[i];
+            const currentIndent = levelIndents[i];
+            this.appendBlocks(ret, descriptor.postBody, currentIndent);
+            indent = currentIndent.substring(0, Math.max(0, currentIndent.length - 2));
+            ret.appendString(indent + descriptor.close + "\n");
+        }
         ret.appendString(`return ${returnField};\n`);
         ret.appendString("})())");
         return ret;
     }
-    transpileIndex(body, forExpression, traversal) {
-        if (["FROM", "TO", "GROUPS"].some(token => forExpression.findDirectTokenByText(token))) {
-            throw new Error("ValueBody FOR todo, " + body.concatTokens());
+    describeFor(forExpression, body, traversal, declarations) {
+        if (forExpression.findDirectTokenByText("GROUPS")) {
+            return this.describeGroupsFor(forExpression, body, traversal);
         }
-        const counter = forExpression.findDirectExpression(core_1.Expressions.InlineFieldDefinition);
-        if (counter === undefined) {
-            throw new Error("ValueBody FOR todo, " + body.concatTokens());
+        const loopExpression = forExpression.findDirectExpression(core_1.Expressions.InlineLoopDefinition);
+        if (loopExpression === undefined) {
+            return this.describeIndexFor(forExpression, body, traversal);
+        }
+        const sourceNode = loopExpression.findDirectExpression(core_1.Expressions.Source);
+        if (sourceNode === undefined) {
+            throw new Error("ReduceBodyTranspiler FOR missing source, " + body.concatTokens());
+        }
+        const loopSource = traversal.traverse(sourceNode).getCode();
+        const options = [];
+        const whereNode = forExpression.findDirectExpression(core_1.Expressions.ComponentCond);
+        if (whereNode) {
+            options.push("where: async " + traversal.traverse(whereNode).getCode());
+        }
+        const fromNode = forExpression.findExpressionAfterToken("FROM");
+        if (fromNode && fromNode instanceof core_1.Nodes.ExpressionNode) {
+            options.push("from: " + traversal.traverse(fromNode).getCode());
+        }
+        const toNode = forExpression.findExpressionAfterToken("TO");
+        if (toNode && toNode instanceof core_1.Nodes.ExpressionNode) {
+            options.push("to: " + traversal.traverse(toNode).getCode());
+        }
+        const keyNode = loopExpression.findExpressionAfterToken("KEY");
+        if (keyNode) {
+            options.push(`usingKey: "${keyNode.concatTokens().toLowerCase()}"`);
+        }
+        const unique = unique_identifier_1.UniqueIdentifier.get();
+        const preBody = [];
+        const postBody = [];
+        const fieldSymbol = loopExpression.findDirectExpression(core_1.Expressions.TargetFieldSymbol);
+        if (fieldSymbol) {
+            declarations.push(new statements_1.FieldSymbolTranspiler().transpile(fieldSymbol, traversal).getCode());
+            const target = new source_field_symbol_1.SourceFieldSymbolTranspiler().transpile(fieldSymbol, traversal).getCode();
+            preBody.push(`${target}.assign(${unique});`);
+            postBody.push(`${target}.unassign();`);
+        }
+        else {
+            const field = loopExpression.findDirectExpression(core_1.Expressions.TargetField);
+            if (field === undefined) {
+                throw new Error("ReduceBodyTranspiler FOR missing target, " + body.concatTokens());
+            }
+            preBody.push(`const ${traversal.traverse(field).getCode()} = ${unique}.clone();`);
+        }
+        const indexTarget = loopExpression.findExpressionAfterToken("INTO");
+        const beforeLoop = [];
+        if (indexTarget && indexTarget instanceof core_1.Nodes.ExpressionNode) {
+            const indexName = unique_identifier_1.UniqueIdentifier.get();
+            const indexCode = traversal.traverse(indexTarget).getCode();
+            beforeLoop.push(`let ${indexName} = 1;`);
+            preBody.push(`const ${indexCode} = new abap.types.Integer().set(${indexName});`);
+            postBody.push(`${indexName}++;`);
+        }
+        const letNode = forExpression.findDirectExpression(core_1.Expressions.Let);
+        if (letNode) {
+            preBody.push(new let_1.LetTranspiler().transpile(letNode, traversal).getCode());
         }
+        const opts = options.length === 0 ? "" : `, {${options.join(", ")}}`;
+        return {
+            beforeLoop,
+            open: `for await (const ${unique} of abap.statements.loop(${loopSource}${opts})) {`,
+            preBody,
+            postBody,
+            close: "}",
+        };
+    }
+    describeGroupsFor(forExpression, body, traversal) {
+        const targets = forExpression.findDirectExpressions(core_1.Expressions.TargetField);
+        const source = forExpression.findDirectExpression(core_1.Expressions.Source);
+        const groupBy = forExpression.findDirectExpression(core_1.Expressions.FieldChain);
+        if (targets.length !== 2 || source === undefined || groupBy === undefined) {
+            throw new Error("ReduceBodyTranspiler invalid GROUPS FOR, " + body.concatTokens());
+        }
+        const groupTarget = traversal.traverse(targets[0]).getCode();
+        const memberTarget = traversal.traverse(targets[1]).getCode();
+        const sourceCode = traversal.traverse(source).getCode();
+        const groupByCode = traversal.traverse(groupBy).getCode();
+        const groups = unique_identifier_1.UniqueIdentifier.get();
+        const row = unique_identifier_1.UniqueIdentifier.get();
+        const key = unique_identifier_1.UniqueIdentifier.get();
+        const rawKey = unique_identifier_1.UniqueIdentifier.get();
+        const entry = unique_identifier_1.UniqueIdentifier.get();
+        const generator = `(async function*() {\n`
+            + `const ${groups} = new Map();\n`
+            + `for await (const ${row} of abap.statements.loop(${sourceCode})) {\n`
+            + `const ${memberTarget} = ${row}.clone();\n`
+            + `const ${key} = ${groupByCode};\n`
+            + `const ${rawKey} = ${key}.get();\n`
+            + `let ${entry} = ${groups}.get(${rawKey});\n`
+            + `if (${entry} === undefined) {\n`
+            + `${entry} = {key: ${key}.clone(), members: []};\n`
+            + `${groups}.set(${rawKey}, ${entry});\n`
+            + `}\n`
+            + `${entry}.members.push(${row});\n`
+            + `}\n`
+            + `for (const value of ${groups}.values()) { yield value; }\n`
+            + `})()`;
+        const loopEntry = unique_identifier_1.UniqueIdentifier.get();
+        return {
+            beforeLoop: [],
+            open: `for await (const ${loopEntry} of ${generator}) {`,
+            preBody: [
+                `const ${groupTarget} = ${loopEntry}.key.clone();`,
+                `const ${memberTarget} = ${loopEntry}.members[0].clone();`,
+            ],
+            postBody: [],
+            close: "}",
+        };
+    }
+    describeIndexFor(forExpression, body, traversal) {
+        const counter = forExpression.findDirectExpression(core_1.Expressions.InlineFieldDefinition);
         const cond = forExpression.findDirectExpression(core_1.Expressions.Cond);
-        if (cond === undefined) {
-            throw new Error("ValueBody FOR missing condition, " + body.concatTokens());
+        if (counter === undefined || cond === undefined) {
+            throw new Error("ReduceBodyTranspiler invalid index FOR, " + body.concatTokens());
         }
         const hasUntil = forExpression.findDirectTokenByText("UNTIL") !== undefined;
         const hasWhile = forExpression.findDirectTokenByText("WHILE") !== undefined;
         if ((hasUntil ? 1 : 0) + (hasWhile ? 1 : 0) !== 1) {
-            throw new Error("ValueBody FOR todo, condition, " + body.concatTokens());
+            throw new Error("ReduceBodyTranspiler index FOR requires WHILE or UNTIL, " + body.concatTokens());
         }
         const fieldName = counter.findDirectExpression(core_1.Expressions.Field)?.concatTokens().toLowerCase();
-        if (fieldName === undefined) {
-            throw new Error("ValueBody FOR todo, inline field, " + body.concatTokens());
+        const source = counter.findDirectExpression(core_1.Expressions.Source);
+        if (fieldName === undefined || source === undefined) {
+            throw new Error("ReduceBodyTranspiler invalid index definition, " + body.concatTokens());
         }
-        const scope = traversal.findCurrentScopeByToken(counter.getFirstToken());
-        const variable = scope?.findVariable(fieldName);
+        const variable = traversal.findCurrentScopeByToken(counter.getFirstToken())?.findVariable(fieldName);
         if (variable === undefined) {
-            throw new Error("ValueBody FOR todo, variable, " + body.concatTokens());
+            throw new Error(`ReduceBodyTranspiler: variable ${fieldName} not found`);
         }
         const counterName = traversal_1.Traversal.prefixVariable(fieldName);
-        const startSource = counter.findDirectExpression(core_1.Expressions.Source);
-        if (startSource === undefined) {
-            throw new Error("ValueBody FOR missing initial value, " + body.concatTokens());
-        }
-        const start = traversal.traverse(startSource).getCode();
         const thenExpr = forExpression.findExpressionAfterToken("THEN");
-        let incrementExpression = "";
-        if (thenExpr && thenExpr instanceof core_1.Nodes.ExpressionNode) {
-            incrementExpression = traversal.traverse(thenExpr).getCode();
-        }
-        else {
-            incrementExpression = `abap.operators.add(${counterName}, new abap.types.Integer().set(1))`;
-        }
+        const increment = thenExpr && thenExpr instanceof core_1.Nodes.ExpressionNode
+            ? traversal.traverse(thenExpr).getCode()
+            : `abap.operators.add(${counterName}, new abap.types.Integer().set(1))`;
         const condCode = traversal.traverse(cond).getCode();
-        const ret = new chunk_1.Chunk();
-        ret.appendString("(await (async () => {\n");
-        const returnField = this.declareInit(body, traversal, ret);
-        ret.appendString(transpile_types_1.TranspileTypes.declare(variable) + `\n`);
-        ret.appendString(`${counterName}.set(${start});\n`);
-        ret.appendString(`while (true) {\n`);
+        const preBody = [];
+        const postBody = [`${counterName}.set(${increment});`];
         if (hasWhile) {
-            ret.appendString(`if (!(${condCode})) {\nbreak;\n}\n`);
+            preBody.push(`if (!(${condCode})) {\nbreak;\n}`);
+        }
+        const letNode = forExpression.findDirectExpression(core_1.Expressions.Let);
+        if (letNode) {
+            preBody.push(new let_1.LetTranspiler().transpile(letNode, traversal).getCode());
         }
-        ret.appendString(this.transpileNext(body, traversal));
-        ret.appendString(`${counterName}.set(${incrementExpression});\n`);
         if (hasUntil) {
-            ret.appendString(`if (${condCode}) {\nbreak;\n}\n`);
+            postBody.push(`if (${condCode}) {\nbreak;\n}`);
         }
-        ret.appendString(`}\n`);
-        ret.appendString(`return ${returnField};\n`);
-        ret.appendString("})())");
-        return ret;
+        return {
+            beforeLoop: [transpile_types_1.TranspileTypes.declare(variable), `${counterName}.set(${traversal.traverse(source).getCode()});`],
+            open: "while (true) {",
+            preBody,
+            postBody,
+            close: "}",
+        };
     }
     declareInit(body, traversal, ret) {
         let returnField = "";
         for (const init of body.findDirectExpressions(core_1.Expressions.InlineFieldDefinition)) {
-            const fieldName = init.findDirectExpression(core_1.Expressions.Field).concatTokens().toLowerCase();
-            returnField = fieldName;
-            const scope = traversal.findCurrentScopeByToken(init.getFirstToken());
-            const variable = scope?.findVariable(fieldName);
+            const fieldName = init.findDirectExpression(core_1.Expressions.Field)?.concatTokens().toLowerCase();
+            if (fieldName === undefined) {
+                throw new Error("ReduceBodyTranspiler INIT missing field");
+            }
+            if (returnField === "") {
+                returnField = traversal_1.Traversal.prefixVariable(fieldName);
+            }
+            const variable = traversal.findCurrentScopeByToken(init.getFirstToken())?.findVariable(fieldName);
             if (variable === undefined) {
                 throw new Error(`ReduceBodyTranspiler: variable ${fieldName} not found`);
             }
-            ret.appendString(transpile_types_1.TranspileTypes.declare(variable) + `\n`);
+            const target = traversal_1.Traversal.prefixVariable(fieldName);
+            ret.appendString(transpile_types_1.TranspileTypes.declare(variable) + "\n");
+            const source = init.findDirectExpression(core_1.Expressions.Source);
+            if (source) {
+                ret.appendString(`${target}.set(${traversal.traverse(source).getCode()});\n`);
+            }
+        }
+        if (returnField === "") {
+            throw new Error("ReduceBodyTranspiler INIT missing");
         }
         return returnField;
     }
     transpileNext(body, traversal) {
         let ret = "";
-        for (const nextChild of body.findDirectExpression(core_1.Expressions.ReduceNext)?.getChildren() || []) {
-            if (nextChild.get() instanceof core_1.Expressions.SimpleTarget && nextChild instanceof core_1.Nodes.ExpressionNode) {
-                ret += new target_1.TargetTranspiler().transpile(nextChild, traversal).getCode() + ".set(";
+        const children = body.findDirectExpression(core_1.Expressions.ReduceNext)?.getChildren() || [];
+        for (let i = 0; i < children.length; i++) {
+            const child = children[i];
+            if (!(child instanceof core_1.Nodes.ExpressionNode) || !(child.get() instanceof core_1.Expressions.SimpleTarget)) {
+                continue;
             }
-            else if (nextChild.get() instanceof core_1.Expressions.Source && nextChild instanceof core_1.Nodes.ExpressionNode) {
-                ret += traversal.traverse(nextChild).getCode() + ");\n";
+            const source = children.slice(i + 1).find(candidate => candidate instanceof core_1.Nodes.ExpressionNode && candidate.get() instanceof core_1.Expressions.Source);
+            if (!(source instanceof core_1.Nodes.ExpressionNode)) {
+                throw new Error("ReduceBodyTranspiler NEXT missing source");
             }
+            const target = new target_1.TargetTranspiler().transpile(child, traversal).getCode();
+            const value = traversal.traverse(source).getCode();
+            const between = children.slice(i + 1, children.indexOf(source)).map(candidate => candidate.concatTokens()).join("");
+            const operators = {
+                "+=": "add",
+                "-=": "minus",
+                "*=": "multiply",
+                "/=": "divide",
+                "&&=": "concat",
+            };
+            const operator = operators[between];
+            ret += operator
+                ? `${target}.set(abap.operators.${operator}(${target}, ${value}));\n`
+                : `${target}.set(${value});\n`;
+            i = children.indexOf(source);
         }
         return ret;
     }
+    appendBlocks(ret, blocks, indent) {
+        for (const block of blocks) {
+            this.appendBlock(ret, block, indent);
+        }
+    }
+    appendBlock(ret, block, indent) {
+        for (const line of block.split("\n")) {
+            if (line.trim() !== "") {
+                ret.appendString(indent + line.replace(/\r/g, "") + "\n");
+            }
+        }
+    }
 }
 exports.ReduceBodyTranspiler = ReduceBodyTranspiler;
 //# sourceMappingURL=reduce_body.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.13.48",
+  "version": "2.13.50",
   "description": "Transpiler",
   "main": "build/src/index.js",
   "typings": "build/src/index.d.ts",
@@ -29,7 +29,7 @@
   "author": "abaplint",
   "license": "MIT",
   "dependencies": {
-    "@abaplint/core": "^2.120.9",
+    "@abaplint/core": "^2.120.18",
     "source-map": "^0.7.6"
   },
   "devDependencies": {