@abaplint/transpiler 2.13.85 → 2.13.87

package/build/src/expressions/constant.js

@@ -85,8 +85,10 @@ class ConstantTranspiler {
         return new chunk_1.Chunk(`todo, Constant`);
     }
     handleCharacter(res) {
-        const foo = res.replace(/''/g, "'");
-        let length = foo.length - 2;
+        // length of the value: strip the enclosing quotes first, an escaped
+        // quote ('') inside counts as one character and must not merge with them
+        const inner = res.substring(1, res.length - 1).replace(/''/g, "'");
+        let length = inner.length;
         if (length <= 0) {
             // note: Characters cannot have length = zero, 1 is minimum
             length = 1;

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

@@ -5,5 +5,6 @@ import { Traversal } from "../traversal";
 export declare class SourceTranspiler implements IExpressionTranspiler {
     private readonly addGet;
     constructor(addGet?: boolean);
+    private concatOperands;
     transpile(node: Nodes.ExpressionNode, traversal: Traversal, context?: AbstractType): Chunk;
 }

package/build/src/expressions/source.js

@@ -15,10 +15,50 @@ class SourceTranspiler {
     constructor(addGet = false) {
         this.addGet = addGet;
     }
+    // the operands of a chain of & / && (the rearranger leaves them as a binary
+    // tree of Source nodes); an empty list when the node is not such a chain
+    concatOperands(node) {
+        const children = node.getChildren();
+        if (children.length !== 3) {
+            return [];
+        }
+        const op = children[1];
+        if (!(op instanceof core_1.Nodes.TokenNode) || (op.getFirstToken().getStr() !== "&&" && op.getFirstToken().getStr() !== "&")) {
+            return [];
+        }
+        const side = (c) => {
+            if (c instanceof core_1.Nodes.ExpressionNode && c.get() instanceof core_1.Expressions.Source) {
+                const inner = this.concatOperands(c);
+                return inner.length > 0 ? inner : [c];
+            }
+            const wrapped = new core_1.Nodes.ExpressionNode(new core_1.Expressions.Source());
+            wrapped.setChildren([c]);
+            return [wrapped];
+        };
+        return [...side(children[0]), ...side(children[2])];
+    }
     transpile(node, traversal, context) {
         let ret = new chunk_1.Chunk();
         const post = new chunk_1.Chunk();
         const children = node.getChildren();
+        // a & b & c ... : one flat concat([a, b, c]) instead of one nested
+        // concat( ) per operand (a long chain would otherwise exhaust the stack
+        // of a parser with a small budget, e.g. a service worker's)
+        const operands = this.concatOperands(node);
+        if (operands.length > 2) {
+            const flat = new chunk_1.Chunk().appendString("abap.operators.concat([");
+            for (let i = 0; i < operands.length; i++) {
+                if (i > 0) {
+                    flat.appendString(",");
+                }
+                flat.appendChunk(new SourceTranspiler(false).transpile(operands[i], traversal, context));
+            }
+            flat.appendString("])");
+            if (this.addGet) {
+                flat.appendString(".get()");
+            }
+            return flat;
+        }
         // Pre-scan for unary prefix +/- tokens (WDashW / WPlusW) before any expression
         let prefixNegated = false;
         let startIdx = 0;

package/build/src/initialization.js

@@ -117,7 +117,8 @@ globalThis.abap = new runtime.ABAP();\n`;
                 || obj instanceof abaplint.Objects.Oauth2Profile
                 || obj instanceof abaplint.Objects.WebMIME
                 || obj instanceof abaplint.Objects.TypePool
-                || obj instanceof abaplint.Objects.TableType) {
+                || obj instanceof abaplint.Objects.TableType
+                || obj instanceof abaplint.Objects.View) {
                 list.push(imp(`${escapeNamespaceFilename(obj.getName().toLowerCase())}.${obj.getType().toLowerCase()}`));
             }
         }

package/build/src/keywords.js

@@ -20,7 +20,11 @@ exports.DEFAULT_KEYWORDS = new Set([
     "throw", "throws", "transient", "true",
     "try", "typeof", "var", "void",
     "delete",
-    "volatile", "while", "yield"
+    "volatile", "while", "yield",
+    // both produce a SyntaxError in the emitted module: they are reserved words
+    // in JavaScript and legal ABAP names. "super" is NOT in this list on purpose -
+    // the emitted code uses the JS `super` for ABAP's `super->method( )`, and
+    // escaping it turns that call into `$super.get().method()`
+    "case", "with"
 ]);
-// "with"
 //# sourceMappingURL=keywords.js.map

package/build/src/rearranger.js

@@ -189,7 +189,23 @@ class Rearranger {
             return node;
         }
         const withoutLast = node.getChildren().slice(0, children.length - 1);
-        const flat = withoutLast.concat(last.getChildren());
+        // The nested children come up so that precedence can be decided across
+        // the whole chain, and everything before the nested operator has to
+        // arrive as one operand. For "a * b / c" that is already true, b being a
+        // single Source. For "a * CONV f( b ) / c" it is not: CONV is five
+        // children, and hoisting them one by one puts the type name and the
+        // body beside the arithmetic, where the transpiler reads them as
+        // operands and loses the rest of the expression. So the head is wrapped
+        // back into one Source before it moves.
+        const nested = last.getChildren();
+        const firstOperator = nested.findIndex((c) => c instanceof core_1.Nodes.ExpressionNode && c.get() instanceof core_1.Expressions.ArithOperator);
+        let head = nested.slice(0, firstOperator);
+        if (head.length > 1) {
+            const operand = new core_1.Nodes.ExpressionNode(last.get());
+            operand.setChildren(head);
+            head = [operand];
+        }
+        const flat = withoutLast.concat(head, nested.slice(firstOperator));
         node.setChildren(flat);
         return node;
     }

package/build/src/statements/select.js

@@ -93,9 +93,11 @@ class SelectTranspiler {
                 where = sqlCond;
             }
         }
+        let whereClause = "";
         if (where) {
-            select += "WHERE " + new expressions_1.SQLCondTranspiler().transpile(where, traversal, table).getCode() + " ";
+            whereClause = "WHERE " + new expressions_1.SQLCondTranspiler().transpile(where, traversal, table).getCode() + " ";
         }
+        select += whereClause;
         const groupBy = node.findFirstExpression(abaplint.Expressions.SQLGroupBy);
         if (groupBy) {
             select += new sql_group_by_1.SQLGroupByTranspiler().transpile(groupBy, traversal).getCode() + " ";
@@ -136,6 +138,7 @@ class SelectTranspiler {
                 else {
                     const code = new expressions_1.FieldChainTranspiler(true).transpile(chain, traversal).getCode();
                     select = select.replace(search, `" + ${code} + "`);
+                    whereClause = whereClause.replace(search, `" + ${code} + "`);
                 }
             }
         }
@@ -163,14 +166,17 @@ class SelectTranspiler {
             const unique2 = unique_identifier_1.UniqueIdentifier.get();
             const fn = node.findFirstExpression(abaplint.Expressions.SQLForAllEntries)?.findDirectExpression(abaplint.Expressions.SQLSource);
             const faeTranspiled = new expressions_1.SQLSourceTranspiler().transpile(fn, traversal).getCode();
+            // ABAP semantics: with an empty driving table the whole WHERE condition is ignored
+            const selectEmpty = select.replace(whereClause, "");
             select = select.replace(new RegExp(" " + escapeRegExp(faeTranspiled), "g"), " " + unique);
             select = select.replace(unique + ".get().table_line.get()", unique + ".get()"); // there can be only one?
-            let by = `Object.keys(${target}.getRowType().get())`;
-            if (keys.length > 0) {
-                by = JSON.stringify(keys);
-            }
+            // FOR ALL ENTRIES removes duplicate rows from the result: duplicates of
+            // the selected columns, so de-duplicate by the target's components. The
+            // DB key alone is wrong for projections (INTO CORRESPONDING FIELDS
+            // without the key fields crashed on the missing component names)
+            const by = `Object.keys(${target}.getRowType().get())`;
             const code = `if (${faeTranspiled}.array().length === 0) {
-  throw new Error("FAE, todo, empty table");
+  await abap.statements.select(${target}, {select: "${selectEmpty.trim()}"${extra}});
 } else {
   const ${unique2} = ${faeTranspiled}.array();
   ${target}.clear();

package/build/src/structures/function_module.js

@@ -87,16 +87,16 @@ class FunctionModuleTranspiler {
                 direction = "importing";
             }
             // note: all directions are optional
-            let name = p.name.toLowerCase();
-            if (traversal.options?.keywords?.some(a => a === name)) {
-                name += "_";
-            }
-            ret += `let ${name} = INPUT.${direction}?.${name};\n`;
+            const name = p.name.toLowerCase();
+            // a parameter named like a JavaScript keyword, RETURN on every BAPI,
+            // is declared the way the function body refers to it
+            const variable = traversal_1.Traversal.prefixVariable(name);
+            ret += `let ${variable} = INPUT.${direction}?.${name};\n`;
             const type = scope?.findVariable(name)?.getType();
             if (type !== undefined && p.optional === true) {
                 // todo, set DEFAULT value
-                ret += `if (${name} === undefined) {
-  ${name} = ${transpile_types_1.TranspileTypes.toType(type)};
+                ret += `if (${variable} === undefined) {
+  ${variable} = ${transpile_types_1.TranspileTypes.toType(type)};
 }\n`;
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.13.85",
+  "version": "2.13.87",
   "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.120.48",
+    "@abaplint/core": "^2.120.52",
     "source-map": "^0.8.0"
   },
   "devDependencies": {
     "@types/chai": "^5.2.3",
     "@types/mocha": "^10.0.10",
     "chai": "^6.2.2",
-    "mocha": "^12.0.0",
+    "mocha": "^12.0.1",
     "source-map-support": "^0.5.21",
     "typescript": "^6.0.3"
   }