@abaplint/transpiler 2.12.9 → 2.12.11

package/build/src/expressions/source.js

@@ -218,7 +218,7 @@ class SourceTranspiler {
             }
         }
         ret.appendChunk(post);
-        //    console.dir(ret.getCode());
+        //    console.dir("return: " + ret.getCode());
         return ret;
     }
 }

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

@@ -3,4 +3,8 @@ import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class ValueBodyTranspiler {
     transpile(typ: Nodes.ExpressionNode, body: Nodes.ExpressionNode, traversal: Traversal): Chunk;
+    private buildForChain;
+    private appendBlocks;
+    private appendBlock;
+    private blocksToString;
 }

package/build/src/expressions/value_body.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValueBodyTranspiler = 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 value_body_line_1 = require("./value_body_line");
@@ -24,7 +25,9 @@ class ValueBodyTranspiler {
         let post = "";
         let extraFields = "";
         const hasLines = body.findDirectExpression(core_1.Expressions.ValueBodyLine) !== undefined;
-        for (const child of body.getChildren()) {
+        const children = body.getChildren();
+        for (let i = 0; i < children.length; i++) {
+            const child = children[i];
             if (child.get() instanceof core_1.Expressions.FieldAssignment && child instanceof core_1.Nodes.ExpressionNode) {
                 const transpiled = new field_assignment_1.FieldAssignmentTranspiler().transpile(child, traversal, context).getCode();
                 if (hasLines === false) {
@@ -50,15 +53,58 @@ class ValueBodyTranspiler {
                 ret.appendString(".set(" + source.getCode() + ".clone())");
             }
             else if (child.get() instanceof core_1.Expressions.For && child instanceof core_1.Nodes.ExpressionNode) {
-                if (["THEN", "UNTIL", "WHILE", "FROM", "TO", "GROUPS"].some(token => child.findDirectTokenByText(token))) {
-                    throw new Error("ValueBody FOR todo, " + body.concatTokens());
+                const forNodes = [];
+                let idx = i;
+                while (idx < children.length) {
+                    const candidate = children[idx];
+                    if (candidate.get() instanceof core_1.Expressions.For && candidate instanceof core_1.Nodes.ExpressionNode) {
+                        forNodes.push(candidate);
+                        idx++;
+                    }
+                    else {
+                        break;
+                    }
                 }
-                const loop = child.findDirectExpression(core_1.Expressions.InlineLoopDefinition);
-                if (loop === undefined) {
+                i = idx - 1;
+                const result = this.buildForChain(forNodes, typ, traversal, body);
+                ret = result.chunk;
+                post = result.post;
+            }
+            else if (child instanceof core_1.Nodes.TokenNode && child.getFirstToken().getStr().toUpperCase() === "DEFAULT") {
+                // note: this is last in the body, so its okay to prepend and postpend
+                const sources = body.findDirectExpressions(core_1.Expressions.Source);
+                const deflt = traversal.traverse(sources[1]).getCode();
+                const pre = `(await (async () => { try { return `;
+                ret = new chunk_1.Chunk().appendString(pre + ret.getCode());
+                post += `; } catch (error) { if (abap.isLineNotFound(error)) { return ${deflt}; } throw error; } })())`;
+            }
+            else if (child instanceof core_1.Nodes.TokenNode && child.getFirstToken().getStr().toUpperCase() === "OPTIONAL") {
+                // note: this is last in the body, so its okay to prepend and postpend
+                const pre = `(await (async () => { try { return `;
+                ret = new chunk_1.Chunk().appendString(pre + ret.getCode());
+                post += `; } catch (error) { if (abap.isLineNotFound(error)) { return ${transpile_types_1.TranspileTypes.toType(context)}; } throw error; } })())`;
+            }
+            else {
+                throw new Error("ValueBodyTranspiler, unknown " + child.get().constructor.name + " \"" + child.concatTokens()) + "\"";
+            }
+        }
+        return ret.appendString(post);
+    }
+    buildForChain(forNodes, typ, traversal, body) {
+        const val = new type_name_or_infer_1.TypeNameOrInfer().transpile(typ, traversal).getCode();
+        const chunk = new chunk_1.Chunk();
+        const preLoopDecls = [];
+        const descriptors = [];
+        const levelIndents = [];
+        let uniqueCounter = 1;
+        for (const child of forNodes) {
+            const loop = child.findDirectExpression(core_1.Expressions.InlineLoopDefinition);
+            if (loop) {
+                if (["THEN", "UNTIL", "WHILE", "FROM", "TO", "GROUPS"].some(token => child.findDirectTokenByText(token))) {
                     throw new Error("ValueBody FOR todo, " + body.concatTokens());
                 }
                 let loopWhere = "";
-                const whereNode = child?.findDirectExpression(core_1.Expressions.ComponentCond);
+                const whereNode = child.findDirectExpression(core_1.Expressions.ComponentCond);
                 if (whereNode) {
                     const where = traversal.traverse(whereNode).getCode();
                     loopWhere = `, {"where": async ` + where + `}`;
@@ -70,51 +116,176 @@ class ValueBodyTranspiler {
                 let targetDeclare = "";
                 let targetAction = "";
                 const fs = loop.findDirectExpression(core_1.Expressions.TargetFieldSymbol);
+                const uniqueName = `unique${uniqueCounter++}`;
                 if (fs) {
                     targetDeclare = new statements_1.FieldSymbolTranspiler().transpile(fs, traversal).getCode();
                     const targetName = new source_field_symbol_1.SourceFieldSymbolTranspiler().transpile(fs, traversal).getCode();
-                    targetAction = `${targetName}.assign(unique1);`;
+                    targetAction = `${targetName}.assign(${uniqueName});`;
                 }
                 else {
                     const field = traversal.traverse(loop.findDirectExpression(core_1.Expressions.TargetField));
                     if (field === undefined) {
                         throw new Error("ValueBody FOR empty field todo, " + body.concatTokens());
                     }
-                    targetAction = `const ${field.getCode()} = unique1.clone();`;
+                    targetAction = `const ${field.getCode()} = ${uniqueName}.clone();`;
                 }
                 const llet = child.findDirectExpression(core_1.Expressions.Let);
                 if (llet) {
                     targetAction += new let_1.LetTranspiler().transpile(llet, traversal).getCode();
                 }
+                const preBodyStatements = [];
+                if (targetAction !== "") {
+                    preBodyStatements.push(targetAction);
+                }
                 const source = traversal.traverse(loop.findDirectExpression(core_1.Expressions.Source)).getCode();
-                const val = new type_name_or_infer_1.TypeNameOrInfer().transpile(typ, traversal).getCode();
-                ret = new chunk_1.Chunk().appendString(`await (async () => {
-${targetDeclare}
-const VAL = ${val};
-for await (const unique1 of abap.statements.loop(${source}${loopWhere})) {
-  ${targetAction}
-  VAL`);
-                post = ";\n}\nreturn VAL;\n})()";
+                if (targetDeclare !== "") {
+                    preLoopDecls.push(targetDeclare);
+                }
+                const descriptor = {
+                    beforeLoop: [],
+                    open: `for await (const ${uniqueName} of abap.statements.loop(${source}${loopWhere})) {`,
+                    preBody: preBodyStatements,
+                    postBody: [],
+                    close: "}",
+                };
+                const loopTokens = loop.concatTokens().toUpperCase();
+                const indexTarget = loopTokens.includes("INDEX INTO") ? loop.findExpressionAfterToken("INTO") : undefined;
+                if (indexTarget && indexTarget instanceof core_1.Nodes.ExpressionNode) {
+                    const indexCode = traversal.traverse(indexTarget).getCode();
+                    const counterName = `unique${uniqueCounter++}`;
+                    descriptor.beforeLoop.push(`let ${counterName} = 1;`);
+                    descriptor.preBody.push(`const ${indexCode} = new abap.types.Integer().set(${counterName});`);
+                    descriptor.postBody.push(`${counterName}++;`);
+                }
+                descriptors.push(descriptor);
             }
-            else if (child instanceof core_1.Nodes.TokenNode && child.getFirstToken().getStr().toUpperCase() === "DEFAULT") {
-                // note: this is last in the body, so its okay to prepend and postpend
-                const sources = body.findDirectExpressions(core_1.Expressions.Source);
-                const deflt = traversal.traverse(sources[1]).getCode();
-                const pre = `(await (async () => { try { return `;
-                ret = new chunk_1.Chunk().appendString(pre + ret.getCode());
-                post += `; } catch (error) { if (abap.isLineNotFound(error)) { return ${deflt}; } throw error; } })())`;
+            else {
+                const counter = child.findDirectExpression(core_1.Expressions.InlineFieldDefinition);
+                if (counter === undefined) {
+                    throw new Error("ValueBody FOR todo, " + body.concatTokens());
+                }
+                if (["GROUPS", "FROM", "TO"].some(token => child.findDirectTokenByText(token))) {
+                    throw new Error("ValueBody FOR todo, " + body.concatTokens());
+                }
+                if (child.findDirectExpression(core_1.Expressions.ComponentCond)) {
+                    throw new Error("ValueBody FOR todo, component cond, " + body.concatTokens());
+                }
+                const cond = child.findDirectExpression(core_1.Expressions.Cond);
+                if (cond === undefined) {
+                    throw new Error("ValueBody FOR missing condition, " + body.concatTokens());
+                }
+                const hasUntil = child.findDirectTokenByText("UNTIL") !== undefined;
+                const hasWhile = child.findDirectTokenByText("WHILE") !== undefined;
+                if ((hasUntil ? 1 : 0) + (hasWhile ? 1 : 0) !== 1) {
+                    throw new Error("ValueBody FOR todo, condition, " + body.concatTokens());
+                }
+                const fieldExpr = counter.findDirectExpression(core_1.Expressions.Field);
+                const fieldName = fieldExpr?.concatTokens().toLowerCase();
+                if (fieldName === undefined) {
+                    throw new Error("ValueBody FOR todo, inline field, " + body.concatTokens());
+                }
+                const scope = traversal.findCurrentScopeByToken(counter.getFirstToken());
+                const variable = scope?.findVariable(fieldName);
+                if (variable === undefined) {
+                    throw new Error("ValueBody FOR todo, variable, " + body.concatTokens());
+                }
+                const declare = transpile_types_1.TranspileTypes.declare(variable);
+                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 = child.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 incrementLine = `${counterName}.set(${incrementExpression});`;
+                const llet = child.findDirectExpression(core_1.Expressions.Let);
+                let letCode = "";
+                if (llet) {
+                    letCode = new let_1.LetTranspiler().transpile(llet, traversal).getCode();
+                }
+                const condCode = traversal.traverse(cond).getCode();
+                const preCheck = hasWhile ? `if (!(${condCode})) {\n  break;\n}` : "";
+                const postLoop = [];
+                postLoop.push(incrementLine);
+                if (hasUntil) {
+                    postLoop.push(`if (${condCode}) {\n  break;\n}`);
+                }
+                descriptors.push({
+                    beforeLoop: [declare, `${counterName}.set(${start});`],
+                    open: "while (true) {",
+                    preBody: [preCheck, letCode].filter(s => s !== ""),
+                    postBody: postLoop,
+                    close: "}",
+                });
             }
-            else if (child instanceof core_1.Nodes.TokenNode && child.getFirstToken().getStr().toUpperCase() === "OPTIONAL") {
-                // note: this is last in the body, so its okay to prepend and postpend
-                const pre = `(await (async () => { try { return `;
-                ret = new chunk_1.Chunk().appendString(pre + ret.getCode());
-                post += `; } catch (error) { if (abap.isLineNotFound(error)) { return ${transpile_types_1.TranspileTypes.toType(context)}; } throw error; } })())`;
+        }
+        if (descriptors.length === 0) {
+            throw new Error("ValueBodyTranspiler FOR internal error");
+        }
+        chunk.appendString("await (async () => {\n");
+        this.appendBlocks(chunk, preLoopDecls, "");
+        chunk.appendString(`const VAL = ${val};\n`);
+        let indent = "";
+        for (const desc of descriptors) {
+            this.appendBlocks(chunk, desc.beforeLoop, indent);
+            chunk.appendString(indent + desc.open + "\n");
+            indent += "  ";
+            levelIndents.push(indent);
+            this.appendBlocks(chunk, desc.preBody, indent);
+        }
+        chunk.appendString(indent + "VAL");
+        let post = ";\n";
+        for (let i = descriptors.length - 1; i >= 0; i--) {
+            const desc = descriptors[i];
+            const currentIndent = levelIndents[i] ?? "";
+            post += this.blocksToString(desc.postBody, currentIndent);
+            const parentIndent = currentIndent.substring(0, Math.max(0, currentIndent.length - 2));
+            post += parentIndent + desc.close + "\n";
+        }
+        post += "return VAL;\n})()";
+        return { chunk, post };
+    }
+    appendBlocks(chunk, blocks, indent) {
+        for (const block of blocks) {
+            this.appendBlock(chunk, block, indent);
+        }
+    }
+    appendBlock(chunk, block, indent) {
+        if (block === "") {
+            return;
+        }
+        const lines = block.split("\n");
+        for (const line of lines) {
+            const clean = line.replace(/\r/g, "");
+            if (clean.trim() === "") {
+                continue;
             }
-            else {
-                throw new Error("ValueBodyTranspiler, unknown " + child.get().constructor.name + " \"" + child.concatTokens()) + "\"";
+            chunk.appendString(indent + clean + "\n");
+        }
+    }
+    blocksToString(blocks, indent) {
+        let ret = "";
+        for (const block of blocks) {
+            if (block === "") {
+                continue;
+            }
+            const lines = block.split("\n");
+            for (const line of lines) {
+                const clean = line.replace(/\r/g, "");
+                if (clean.trim() === "") {
+                    continue;
+                }
+                ret += indent + clean + "\n";
             }
         }
-        return ret.appendString(post);
+        return ret;
     }
 }
 exports.ValueBodyTranspiler = ValueBodyTranspiler;

package/build/src/index.js

@@ -51,7 +51,7 @@ class Transpiler {
             databaseSetup: dbSetup,
             reg: reg,
         };
-        progress?.set(reg.getObjectCount(false), "Building");
+        progress?.set(reg.getObjectCount().total, "Building");
         for (const obj of reg.getObjects()) {
             await progress?.tick("Building, " + obj.getName());
             if (obj instanceof abaplint.Objects.TypePool) {

package/build/src/rearranger.js

@@ -101,6 +101,10 @@ class Rearranger {
             || !(secondLast.get() instanceof core_1.Expressions.ArithOperator)) {
             return node;
         }
+        const nestedArith = last.findDirectExpressions(core_1.Expressions.ArithOperator);
+        if (nestedArith.length === 0) {
+            return node;
+        }
         const withoutLast = node.getChildren().slice(0, children.length - 1);
         const flat = withoutLast.concat(last.getChildren());
         node.setChildren(flat);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.12.9",
+  "version": "2.12.11",
   "description": "Transpiler",
   "main": "build/src/index.js",
   "typings": "build/src/index.d.ts",
@@ -29,14 +29,14 @@
   "author": "abaplint",
   "license": "MIT",
   "dependencies": {
-    "@abaplint/core": "^2.113.234",
+    "@abaplint/core": "^2.113.240",
     "source-map": "^0.7.6"
   },
   "devDependencies": {
     "@types/chai": "^4.3.20",
     "@types/mocha": "^10.0.10",
     "chai": "^4.5.0",
-    "mocha": "^11.7.4",
+    "mocha": "^11.7.5",
     "source-map-support": "^0.5.21",
     "typescript": "^5.9.3"
   }