@abaplint/transpiler 2.12.10 → 2.12.12

package/build/src/expressions/compare.js

@@ -53,13 +53,13 @@ class CompareTranspiler {
                 const field = concat.replace(" IS NOT REQUESTED", "").toLowerCase();
                 return new chunk_1.Chunk().appendString(pre + "INPUT && INPUT." + field + " === undefined && INPUT.importing?." + field + " === undefined");
             }
-            if (concat.startsWith("NOT ") || concat.includes(" IS NOT INSTANCE OF ")) {
-                const cname = node.findDirectExpression(core_1.Expressions.ClassName)?.concatTokens();
-                return new chunk_1.Chunk().appendString("abap.compare.instance_of(").appendChunk(s0).appendString(`, ${cname}) === false`);
-            }
-            else if (concat.includes(" IS INSTANCE OF ")) {
-                const cname = node.findDirectExpression(core_1.Expressions.ClassName)?.concatTokens();
-                return new chunk_1.Chunk().appendString("abap.compare.instance_of(").appendChunk(s0).appendString(`, ${cname})`);
+            if (concat.includes(" IS INSTANCE OF ")) {
+                const notted = concat.startsWith("NOT ") || concat.includes(" IS NOT INSTANCE OF ");
+                const falsed = notted ? " === false" : "";
+                const expr = node.findDirectExpression(core_1.Expressions.ClassName);
+                const cname = expr?.concatTokens();
+                const lookup = traversal.lookupClassOrInterface(cname, expr?.getFirstToken());
+                return new chunk_1.Chunk().appendString("abap.compare.instance_of(").appendChunk(s0).appendString(`, ${lookup})` + falsed);
             }
         }
         else if (sources.length === 2 && node.findDirectTokenByText("IN")) {

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

@@ -25,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) {
@@ -51,117 +53,22 @@ class ValueBodyTranspiler {
                 ret.appendString(".set(" + source.getCode() + ".clone())");
             }
             else if (child.get() instanceof core_1.Expressions.For && child instanceof core_1.Nodes.ExpressionNode) {
-                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);
-                    if (whereNode) {
-                        const where = traversal.traverse(whereNode).getCode();
-                        loopWhere = `, {"where": async ` + where + `}`;
-                    }
-                    const base = loop.findDirectExpression(core_1.Expressions.ValueBase);
-                    if (base) {
-                        throw new Error("ValueBody FOR todo, base, " + body.concatTokens());
-                    }
-                    let targetDeclare = "";
-                    let targetAction = "";
-                    const fs = loop.findDirectExpression(core_1.Expressions.TargetFieldSymbol);
-                    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);`;
+                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 {
-                        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();`;
-                    }
-                    const llet = child.findDirectExpression(core_1.Expressions.Let);
-                    if (llet) {
-                        targetAction += new let_1.LetTranspiler().transpile(llet, traversal).getCode();
+                        break;
                     }
-                    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})()";
-                }
-                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 letSection = letCode === "" ? "" : "  " + letCode.replace(/\n/g, "\n  ") + "\n";
-                    const condCode = traversal.traverse(cond).getCode();
-                    const val = new type_name_or_infer_1.TypeNameOrInfer().transpile(typ, traversal).getCode();
-                    const preCheck = hasWhile ? `  if (!(${condCode})) {\n    break;\n  }\n` : "";
-                    let postLoop = `  ${incrementLine}\n`;
-                    if (hasUntil) {
-                        postLoop += `  if (${condCode}) {\n    break;\n  }\n`;
-                    }
-                    ret = new chunk_1.Chunk().appendString(`await (async () => {
-${declare}
-${counterName}.set(${start});
-const VAL = ${val};
-while (true) {
-${preCheck}${letSection}  VAL`);
-                    post = ";\n" + postLoop + "}\nreturn VAL;\n})()";
                 }
+                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
@@ -183,6 +90,203 @@ ${preCheck}${letSection}  VAL`);
         }
         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);
+                if (whereNode) {
+                    const where = traversal.traverse(whereNode).getCode();
+                    loopWhere = `, {"where": async ` + where + `}`;
+                }
+                const base = loop.findDirectExpression(core_1.Expressions.ValueBase);
+                if (base) {
+                    throw new Error("ValueBody FOR todo, base, " + body.concatTokens());
+                }
+                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(${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()} = ${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();
+                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 {
+                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: "}",
+                });
+            }
+        }
+        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;
+            }
+            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;
+    }
 }
 exports.ValueBodyTranspiler = ValueBodyTranspiler;
 //# sourceMappingURL=value_body.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.12.10",
+  "version": "2.12.12",
   "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.113.240",
+    "@abaplint/core": "^2.113.246",
     "source-map": "^0.7.6"
   },
   "devDependencies": {