@abaplint/transpiler 2.13.96 → 2.13.98

package/build/src/chunk.js

@@ -170,7 +170,8 @@ class Chunk {
         }
         const indentationByLine = this.mappings.length > 0 ? [] : undefined;
         for (const l of this.raw.split("\n")) {
-            if (l.startsWith("}")) {
+            // trimStart, a pre-indented closing brace must still close its level
+            if (l.trimStart().startsWith("}")) {
                 i = i - 1;
             }
             // clamp so unbalanced braces never produce a negative indent/shift

package/build/src/expressions/reduce_body.js

@@ -31,22 +31,18 @@ class ReduceBodyTranspiler {
         for (const declaration of declarations) {
             ret.appendString(declaration + "\n");
         }
-        let indent = "";
-        const levelIndents = [];
+        // no manual indentation, Chunk.runIndentationLogic indents by brace depth,
+        // pre-indented closing braces would not be recognized and drift the indentation
         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.appendBlocks(ret, descriptor.beforeLoop);
+            ret.appendString(descriptor.open + "\n");
+            this.appendBlocks(ret, descriptor.preBody);
         }
-        this.appendBlock(ret, this.transpileNext(body, traversal), indent);
+        this.appendBlock(ret, this.transpileNext(body, traversal));
         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");
+            this.appendBlocks(ret, descriptor.postBody);
+            ret.appendString(descriptor.close + "\n");
         }
         ret.appendString(`return ${returnField};\n`);
         ret.appendString("})())");
@@ -266,15 +262,15 @@ class ReduceBodyTranspiler {
         }
         return ret;
     }
-    appendBlocks(ret, blocks, indent) {
+    appendBlocks(ret, blocks) {
         for (const block of blocks) {
-            this.appendBlock(ret, block, indent);
+            this.appendBlock(ret, block);
         }
     }
-    appendBlock(ret, block, indent) {
+    appendBlock(ret, block) {
         for (const line of block.split("\n")) {
             if (line.trim() !== "") {
-                ret.appendString(indent + line.replace(/\r/g, "") + "\n");
+                ret.appendString(line.replace(/\r/g, "") + "\n");
             }
         }
     }

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

@@ -4,7 +4,9 @@ import { IExpressionTranspiler } from "./_expression_transpiler";
 import { Traversal } from "../traversal";
 export declare class SourceTranspiler implements IExpressionTranspiler {
     private readonly addGet;
-    constructor(addGet?: boolean);
+    private readonly int8;
+    /** int8: the calculation type is int8, each operation gets its left operand as an int8 */
+    constructor(addGet?: boolean, int8?: boolean);
     private concatOperands;
     transpile(node: Nodes.ExpressionNode, traversal: Traversal, context?: AbstractType): Chunk;
 }

package/build/src/expressions/source.js

@@ -9,11 +9,15 @@ const corresponding_body_1 = require("./corresponding_body");
 const filter_body_1 = require("./filter_body");
 const reduce_body_1 = require("./reduce_body");
 const transpile_types_1 = require("../transpile_types");
+const let_1 = require("./let");
 const value_body_1 = require("./value_body");
 class SourceTranspiler {
     addGet;
-    constructor(addGet = false) {
+    int8;
+    /** int8: the calculation type is int8, each operation gets its left operand as an int8 */
+    constructor(addGet = false, int8 = false) {
         this.addGet = addGet;
+        this.int8 = int8;
     }
     // 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
@@ -81,6 +85,8 @@ class SourceTranspiler {
                 break;
             }
         }
+        // int8: whether the operand left of the next operator is already an int8
+        let leftIsInt8 = false;
         for (let i = startIdx; i < children.length; i++) {
             const c = children[i];
             const isLast = i === children.length - 1;
@@ -98,7 +104,18 @@ class SourceTranspiler {
                     ret.appendChunk(traversal.traverse(c));
                 }
                 else if (c.get() instanceof core_1.Expressions.ArithOperator) {
-                    ret = new chunk_1.Chunk().appendChunk(traversal.traverse(c)).appendString("(").appendChunk(ret).appendString(",");
+                    // "/" rounds in calculation type int8, the runtime's divide() does not know the target
+                    const operator = this.int8 === true && c.concatTokens().trim() === "/"
+                        ? new chunk_1.Chunk().append("abap.operators.divideInt8", c, traversal)
+                        : traversal.traverse(c);
+                    if (this.int8 === true && leftIsInt8 === false) {
+                        ret = new chunk_1.Chunk().appendChunk(operator).appendString("(new abap.types.Integer8().set(").appendChunk(ret).appendString("),");
+                    }
+                    else {
+                        ret = new chunk_1.Chunk().appendChunk(operator).appendString("(").appendChunk(ret).appendString(",");
+                    }
+                    // the result of an operation with an int8 operand is an int8
+                    leftIsInt8 = true;
                     post.appendString(")");
                     if (this.addGet) {
                         post.append(".get()", c, traversal);
@@ -115,7 +132,8 @@ class SourceTranspiler {
                     }
                 }
                 else if (c.get() instanceof core_1.Expressions.Source) {
-                    ret.appendChunk(new SourceTranspiler(this.addGet).transpile(c, traversal));
+                    ret.appendChunk(new SourceTranspiler(this.addGet, this.int8).transpile(c, traversal));
+                    leftIsInt8 = c.findDirectExpression(core_1.Expressions.ArithOperator) !== undefined;
                 }
                 else if (c.get() instanceof core_1.Expressions.Arrow) {
                     ret = new chunk_1.Chunk().appendString("(").appendChunk(ret).appendString(").get().");
@@ -151,13 +169,19 @@ class SourceTranspiler {
                     }
                     ret = new chunk_1.Chunk().appendString(new _1.TypeNameOrInfer().transpile(typ, traversal).getCode());
                     ret.appendString(".set(");
-                    // todo: handle LET
                     const context = new _1.TypeNameOrInfer().findType(typ, traversal);
-                    ret.appendString(new SourceTranspiler().transpile(c.getFirstChild(), traversal, context).getCode());
+                    const convSource = c.findDirectExpression(core_1.Expressions.Source);
+                    ret.appendString(new SourceTranspiler().transpile(convSource, traversal, context).getCode());
                     ret.appendString(")");
                     if (this.addGet) {
                         ret.appendString(".get()");
                     }
+                    const convLet = c.findDirectExpression(core_1.Expressions.Let);
+                    if (convLet) {
+                        // the LET bindings are declared in a scope of their own, before the value is built
+                        const letCode = new let_1.LetTranspiler().transpile(convLet, traversal).getCode();
+                        ret = new chunk_1.Chunk().appendString(`(await (async () => { ${letCode} return ${ret.getCode()}; })())`);
+                    }
                 }
                 else if (c.get() instanceof core_1.Expressions.ValueBody) {
                     continue;

package/build/src/expressions/value_body.js

@@ -30,6 +30,7 @@ class ValueBodyTranspiler {
         const outerLetCode = outerLet === undefined
             ? undefined
             : new let_1.LetTranspiler().transpile(outerLet, traversal).getCode();
+        let hasFor = false;
         const children = body.getChildren();
         for (let i = 0; i < children.length; i++) {
             const child = children[i];
@@ -72,6 +73,7 @@ class ValueBodyTranspiler {
                     }
                 }
                 i = idx - 1;
+                hasFor = true;
                 const result = this.buildForChain(forNodes, typ, traversal, body, baseCode, outerLetCode);
                 ret = result.chunk;
                 post = result.post;
@@ -99,14 +101,18 @@ class ValueBodyTranspiler {
                 throw new Error("ValueBodyTranspiler, unknown " + child.get().constructor.name + " \"" + child.concatTokens()) + "\"";
             }
         }
-        return ret.appendString(post);
+        ret.appendString(post);
+        if (outerLetCode !== undefined && hasFor === false) {
+            // without FOR the LET bindings are declared here, in a scope of their own, before the value is built
+            ret = new chunk_1.Chunk().appendString(`(await (async () => { ${outerLetCode} return ${ret.getCode()}; })())`);
+        }
+        return ret;
     }
     buildForChain(forNodes, typ, traversal, body, baseCode, outerLetCode) {
         const val = baseCode ?? new type_name_or_infer_1.TypeNameOrInfer().transpile(typ, traversal).getCode();
         const chunk = new chunk_1.Chunk();
         const preLoopDecls = outerLetCode === undefined ? [] : [outerLetCode];
         const descriptors = [];
-        const levelIndents = [];
         let uniqueCounter = 1;
         for (const child of forNodes) {
             const loop = child.findDirectExpression(core_1.Expressions.InlineLoopDefinition);
@@ -222,11 +228,11 @@ class ValueBodyTranspiler {
                     letCode = new let_1.LetTranspiler().transpile(llet, traversal).getCode();
                 }
                 const condCode = traversal.traverse(cond).getCode();
-                const preCheck = hasWhile ? `if (!(${condCode})) {\n  break;\n}` : "";
+                const preCheck = hasWhile ? `if (!(${condCode})) {\nbreak;\n}` : "";
                 const postLoop = [];
                 postLoop.push(incrementLine);
                 if (hasUntil) {
-                    postLoop.push(`if (${condCode}) {\n  break;\n}`);
+                    postLoop.push(`if (${condCode}) {\nbreak;\n}`);
                 }
                 descriptors.push({
                     beforeLoop: [declare, `${counterName}.set(${start});`],
@@ -241,34 +247,31 @@ class ValueBodyTranspiler {
             throw new Error("ValueBodyTranspiler FOR internal error");
         }
         chunk.appendString("await (async () => {\n");
-        this.appendBlocks(chunk, preLoopDecls, "");
+        this.appendBlocks(chunk, preLoopDecls);
         chunk.appendString(`const VAL = ${val};\n`);
-        let indent = "";
+        // no manual indentation, Chunk.runIndentationLogic indents by brace depth,
+        // pre-indented closing braces would not be recognized and drift the indentation
         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);
+            this.appendBlocks(chunk, desc.beforeLoop);
+            chunk.appendString(desc.open + "\n");
+            this.appendBlocks(chunk, desc.preBody);
         }
-        chunk.appendString(indent + "VAL");
+        chunk.appendString("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 += this.blocksToString(desc.postBody);
+            post += desc.close + "\n";
         }
         post += "return VAL;\n})()";
         return { chunk, post };
     }
-    appendBlocks(chunk, blocks, indent) {
+    appendBlocks(chunk, blocks) {
         for (const block of blocks) {
-            this.appendBlock(chunk, block, indent);
+            this.appendBlock(chunk, block);
         }
     }
-    appendBlock(chunk, block, indent) {
+    appendBlock(chunk, block) {
         if (block === "") {
             return;
         }
@@ -278,10 +281,10 @@ class ValueBodyTranspiler {
             if (clean.trim() === "") {
                 continue;
             }
-            chunk.appendString(indent + clean + "\n");
+            chunk.appendString(clean + "\n");
         }
     }
-    blocksToString(blocks, indent) {
+    blocksToString(blocks) {
         let ret = "";
         for (const block of blocks) {
             if (block === "") {
@@ -293,7 +296,7 @@ class ValueBodyTranspiler {
                 if (clean.trim() === "") {
                     continue;
                 }
-                ret += indent + clean + "\n";
+                ret += clean + "\n";
             }
         }
         return ret;

package/build/src/statements/assign.js

@@ -43,15 +43,16 @@ class AssignTranspiler {
         if (node?.findFirstExpression(abaplint.Expressions.TableExpression) === undefined) {
             return code;
         }
+        // not indented, Chunk.runIndentationLogic indents by brace depth
         return `(await (async () => {
-  try {
-    return ${code};
-  } catch (error) {
-    if (abap.isLineNotFound(error)) {
-      return undefined;
-    }
-    throw error;
-  }
+try {
+return ${code};
+} catch (error) {
+if (abap.isLineNotFound(error)) {
+return undefined;
+}
+throw error;
+}
 })())`;
     }
     transpile(node, traversal) {

package/build/src/statements/call.js

@@ -145,7 +145,7 @@ class CallTranspiler {
         post += `\nabap.builtin.sy.get().subrc.set(0);
 } catch (e) {
 if (e.classic) {
-  switch (e.classic.toUpperCase()) {\n`;
+switch (e.classic.toUpperCase()) {\n`;
         for (const e of node.findAllExpressions(abaplint.Expressions.ParameterException)) {
             const name = e.getFirstToken().getStr().toUpperCase();
             // todo, also handle SimpleChain,
@@ -164,9 +164,9 @@ if (e.classic) {
                 post += `case "${name}": abap.builtin.sy.get().subrc.set(${value}); break;\n`;
             }
         }
-        post += `  }
+        post += `}
 } else {
-  throw e;
+throw e;
 }
 }`;
         return { pre, post };

package/build/src/statements/call_function.js

@@ -65,12 +65,13 @@ class CallFunctionTranspiler {
         }
         const calling = node.findExpressionAfterToken("CALLING");
         const dest = node.findDirectExpression(abaplint.Expressions.Destination)?.findDirectExpression(abaplint.Expressions.Source);
-        if (dest) {
+        const updateTask = node.findDirectTokenByText("UPDATE") !== undefined;
+        if (dest && updateTask === false) {
             const s = new expressions_1.SourceTranspiler(true).transpile(dest, traversal);
             param = param.replace("{", ",").replace(/}$/, "");
             ret.appendString(`await abap.statements.callFunction({name:${fmname},destination:${s.getCode()}${param}});`);
         }
-        else if (calling) {
+        else if (calling && updateTask === false) {
             param = param.replace("{", ",").replace(/}$/, "");
             // typically used in combination with STARTING NEW TASK so dont await,
             ret.appendString(`abap.statements.callFunction({name:${fmname},calling:this.${calling.concatTokens().toLowerCase()}${param}});`);
@@ -80,7 +81,13 @@ class CallFunctionTranspiler {
             const call = `abap.FunctionModules[${fmname}]`;
             // eslint-disable-next-line max-len
             ret.appendString(`if (${call} === undefined) { if (${illegalFunc} === undefined) { throw "CX_SY_DYN_CALL_ILLEGAL_FUNC not found"; } else { throw await new ${illegalFunc}().constructor_({function: new abap.types.String().set(${fmname})});} }\n`);
-            ret.appendString(`await ${call}(${param});`);
+            if (updateTask) {
+                param = param.replace("{", ",").replace(/}$/, "");
+                ret.appendString(`await abap.statements.callFunction({name:${fmname},updateTask:true${param}});`);
+            }
+            else {
+                ret.appendString(`await ${call}(${param});`);
+            }
         }
         if (exceptions) {
             const build = call_1.CallTranspiler.buildExceptions(exceptions);

package/build/src/statements/create_data.js

@@ -83,7 +83,7 @@ class CreateDataTranspiler {
         }
         const handle = node.findExpressionAfterToken("HANDLE");
         if (handle) {
-            const so = traversal.traverse(node.findDirectExpression(abaplint.Expressions.Source));
+            const so = traversal.traverse(handle);
             const lookup = traversal.lookupClassOrInterface("KERNEL_CREATE_DATA_HANDLE", node.getFirstToken());
             const call = `await ${lookup}.call({handle: ${so.getCode()}, dref: ${target.getCode()}});`;
             return new chunk_1.Chunk().append(`if (${lookup} === undefined) throw new Error("CreateData, kernel class missing");\n${call}`, node, traversal);

package/build/src/statements/generate_subroutine.d.ts

@@ -3,5 +3,7 @@ import { IStatementTranspiler } from "./_statement_transpiler";
 import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class GenerateSubroutineTranspiler implements IStatementTranspiler {
-    transpile(_node: abaplint.Nodes.StatementNode, _traversal: Traversal): Chunk;
+    transpile(node: abaplint.Nodes.StatementNode, traversal: Traversal): Chunk;
+    /** the expression directly after the addition keyword, MESSAGE does not match MESSAGE-ID */
+    private findAddition;
 }

package/build/src/statements/generate_subroutine.js

@@ -1,10 +1,80 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GenerateSubroutineTranspiler = void 0;
+const abaplint = __importStar(require("@abaplint/core"));
 const chunk_1 = require("../chunk");
+// GENERATE SUBROUTINE POOL cannot be supported, there is no compiler at runtime.
+// The statement is refused without an exception: sy-subrc = 8 (documented as "other
+// generation error"), NAME initial, MESSAGE filled, LINE 0 and WORD initial. This is
+// a refusal of its own, not what a system answers; the other additions are left untouched.
 class GenerateSubroutineTranspiler {
-    transpile(_node, _traversal) {
-        return new chunk_1.Chunk(`throw new Error("GenerateSubroutine, not supported, transpiler");`);
+    transpile(node, traversal) {
+        const ret = new chunk_1.Chunk();
+        const name = this.findAddition(node, "NAME");
+        if (name) {
+            ret.appendString(traversal.traverse(name).getCode() + ".clear();\n");
+        }
+        const message = this.findAddition(node, "MESSAGE");
+        if (message) {
+            ret.appendString(traversal.traverse(message).getCode() + `.set("GENERATE SUBROUTINE POOL is not supported");\n`);
+        }
+        const line = this.findAddition(node, "LINE");
+        if (line) {
+            ret.appendString(traversal.traverse(line).getCode() + ".set(0);\n");
+        }
+        const word = this.findAddition(node, "WORD");
+        if (word) {
+            ret.appendString(traversal.traverse(word).getCode() + ".clear();\n");
+        }
+        ret.append("abap.builtin.sy.get().subrc.set(8);", node, traversal);
+        return ret;
+    }
+    /** the expression directly after the addition keyword, MESSAGE does not match MESSAGE-ID */
+    findAddition(node, keyword) {
+        const children = node.getChildren();
+        for (let i = 0; i < children.length - 1; i++) {
+            const child = children[i];
+            const next = children[i + 1];
+            if (child instanceof abaplint.Nodes.TokenNode
+                && child.getFirstToken().getStr().toUpperCase() === keyword
+                && next instanceof abaplint.Nodes.ExpressionNode) {
+                return next;
+            }
+        }
+        return undefined;
     }
 }
 exports.GenerateSubroutineTranspiler = GenerateSubroutineTranspiler;

package/build/src/statements/move.d.ts

@@ -4,4 +4,6 @@ import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class MoveTranspiler implements IStatementTranspiler {
     transpile(node: abaplint.Nodes.StatementNode, traversal: Traversal): Chunk;
+    private isInt8Calculation;
+    private integerOperands;
 }

package/build/src/statements/move.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MoveTranspiler = void 0;
 const abaplint = __importStar(require("@abaplint/core"));
 const chunk_1 = require("../chunk");
+const source_1 = require("../expressions/source");
 class MoveTranspiler {
     transpile(node, traversal) {
         const sourceExpression = node.findDirectExpression(abaplint.Expressions.Source);
@@ -55,7 +56,9 @@ class MoveTranspiler {
             ret.appendString(target + `.set(abap.alphaIn(${tSource.getCode()}, ${target}, ${target}));`);
             return ret;
         }
-        let source = traversal.traverse(sourceExpression);
+        let source = this.isInt8Calculation(node, sourceExpression, targetExpressions.length, traversal)
+            ? new source_1.SourceTranspiler(false, true).transpile(sourceExpression, traversal)
+            : traversal.traverse(sourceExpression);
         const second = node.getChildren()[1]?.concatTokens();
         switch (second) {
             case "?=":
@@ -117,6 +120,72 @@ class MoveTranspiler {
         }
         return ret;
     }
+    // The calculation type of an arithmetic expression comes from its operands and the target
+    // field, the type with the largest range wins. With operands of type i or int8 it is int8
+    // when the target or an operand is int8: i * i into int8 is exact up to 2^62, and "/"
+    // rounds. The runtime decides by the operands alone and does not know the target, so here
+    // the operands are converted to int8 before the calculation. Only for an i or int8 target
+    // and operands whose type is known to be i or int8, and not for **, which counts as f
+    isInt8Calculation(node, source, targets, traversal) {
+        if (source === undefined
+            || targets !== 1
+            || source.findFirstExpression(abaplint.Expressions.ArithOperator) === undefined) {
+            return false;
+        }
+        const scope = traversal.findCurrentScopeByToken(node.getFirstToken());
+        const target = traversal.determineType(node, scope);
+        const found = { int8: target instanceof abaplint.BasicTypes.Integer8Type };
+        if (found.int8 === false && !(target instanceof abaplint.BasicTypes.IntegerType)) {
+            return false;
+        }
+        return this.integerOperands(source, scope, found) && found.int8;
+    }
+    integerOperands(node, scope, found) {
+        for (const c of node.getChildren()) {
+            if (c instanceof abaplint.Nodes.TokenNode) {
+                if (["(", ")", "-", "+"].includes(c.getFirstToken().getStr()) === false) {
+                    return false;
+                }
+            }
+            else if (c.get() instanceof abaplint.Expressions.Source) {
+                if (this.integerOperands(c, scope, found) === false) {
+                    return false;
+                }
+            }
+            else if (c.get() instanceof abaplint.Expressions.ArithOperator) {
+                if (["+", "-", "*", "/", "DIV", "MOD"].includes(c.concatTokens().toUpperCase()) === false) {
+                    return false;
+                }
+            }
+            else if (c.get() instanceof abaplint.Expressions.Constant) {
+                const integer = c.findDirectExpression(abaplint.Expressions.Integer);
+                if (integer === undefined) {
+                    return false;
+                }
+                else if (Math.abs(parseInt(integer.concatTokens().replace(/ /g, ""), 10)) > 2147483647) {
+                    // the transpiler makes an int8 of a literal outside the range of i
+                    found.int8 = true;
+                }
+            }
+            else if (c.get() instanceof abaplint.Expressions.FieldChain) {
+                const children = c.getChildren();
+                if (children.length !== 1) {
+                    return false;
+                }
+                const type = scope?.findVariable(children[0].concatTokens())?.getType();
+                if (!(type instanceof abaplint.BasicTypes.IntegerType) && !(type instanceof abaplint.BasicTypes.Integer8Type)) {
+                    return false;
+                }
+                if (type instanceof abaplint.BasicTypes.Integer8Type) {
+                    found.int8 = true;
+                }
+            }
+            else {
+                return false;
+            }
+        }
+        return true;
+    }
 }
 exports.MoveTranspiler = MoveTranspiler;
 //# sourceMappingURL=move.js.map

package/build/src/statements/perform.js

@@ -44,16 +44,18 @@ class PerformTranspiler {
             return new chunk_1.Chunk(`throw new Error("PerformTranspiler FormName not found");`);
         }
         else if (node.concatTokens().toUpperCase().includes(" IN PROGRAM ")) {
-            // todo: throw exception if not found?
             const expression = node.findExpressionAfterToken("PROGRAM");
             let ref = "";
+            let program = "";
             if (expression?.get() instanceof abaplint.Expressions.Dynamic) {
                 const name = expression.getChildren()[1].concatTokens() + ".get().trimEnd()";
                 ref = `abap.Forms['PROG-' + ${name} + '-${formName.concatTokens().toUpperCase()}']`;
+                program = `'PROG-' + ${name} + '-'`;
             }
             else {
                 const progName = expression?.concatTokens().toUpperCase();
                 ref = `abap.Forms['PROG-${progName}-${formName.concatTokens().toUpperCase()}']`;
+                program = `'PROG-${progName}-'`;
             }
             const params = [];
             // hacky hack
@@ -65,6 +67,16 @@ class PerformTranspiler {
             if (node.concatTokens().toUpperCase().includes(" IF FOUND")) {
                 call = `if (${ref} !== undefined) { ${call} }`;
             }
+            else {
+                // the form is missing from a program whose forms are registered: CX_SY_DYN_CALL_ILLEGAL_FORM,
+                // no form of the program is registered: CX_SY_PROGRAM_NOT_FOUND
+                const raise = (name) => {
+                    const cls = traversal.lookupClassOrInterface(`'${name}'`, node.getFirstToken(), true);
+                    return `if (${cls} === undefined) { throw "${name} not found"; } else { throw await new ${cls}().constructor_(); }`;
+                };
+                const loaded = `Object.keys(abap.Forms).some(k => k.startsWith(${program}))`;
+                call = `if (${ref} === undefined) { if (${loaded}) { ${raise("CX_SY_DYN_CALL_ILLEGAL_FORM")} } else { ${raise("CX_SY_PROGRAM_NOT_FOUND")} } }\n` + call;
+            }
             return new chunk_1.Chunk(call);
         }
         else {

package/build/src/statements/select.js

@@ -184,24 +184,25 @@ class SelectTranspiler {
             // 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())`;
+            // generated code is not indented, Chunk.runIndentationLogic indents by brace depth
             const dedup = `if (!(${target} instanceof abap.types.HashedTable) && ${target}.getOptions()?.primaryKey?.type !== "SORTED") {
-    abap.statements.sort(${target}, {by: ${by}.map(k => { return {component: k}; })});
-    await abap.statements.deleteInternal(${target}, {adjacent: true, allFields: true});
-  }`;
+abap.statements.sort(${target}, {by: ${by}.map(k => { return {component: k}; })});
+await abap.statements.deleteInternal(${target}, {adjacent: true, allFields: true});
+}`;
             const at = where.startsWith("WHERE ") ? select.indexOf(where) : -1;
             // UP TO with ORDER BY keeps the first n rows in that order; the blocks
             // trim after the de-duplicating sort, so that pair stays row by row
             if (concat.startsWith("SELECT SINGLE ") || at < 0 || (upTo && orderBy)) {
                 const code = `if (${faeTranspiled}.array().length === 0) {
-  await abap.statements.select(${target}, {select: "${selectEmpty.trim()}"${extra}});
+await abap.statements.select(${target}, {select: "${selectEmpty.trim()}"${extra}});
 } else {
-  const ${unique2} = ${faeTranspiled}.array();
-  ${target}.clear();
-  for await (const ${unique} of ${unique2}) {
-    await abap.statements.select(${target}, {select: "${select.trim()}"${extra}}, {appending: true});
-  }
-  ${dedup}
-  abap.builtin.sy.get().dbcnt.set(${target}.getArrayLength());
+const ${unique2} = ${faeTranspiled}.array();
+${target}.clear();
+for await (const ${unique} of ${unique2}) {
+await abap.statements.select(${target}, {select: "${select.trim()}"${extra}}, {appending: true});
+}
+${dedup}
+abap.builtin.sy.get().dbcnt.set(${target}.getArrayLength());
 }`;
                 return new chunk_1.Chunk().append(code, node, traversal);
             }
@@ -229,29 +230,29 @@ class SelectTranspiler {
             const unique3 = unique_identifier_1.UniqueIdentifier.get();
             const unique4 = unique_identifier_1.UniqueIdentifier.get();
             const code = `if (${faeTranspiled}.array().length === 0) {
-  await abap.statements.select(${target}, {select: "${selectEmpty.trim()}"${extra}});
+await abap.statements.select(${target}, {select: "${selectEmpty.trim()}"${extra}});
+} else {
+const ${unique2} = ${faeTranspiled}.array();
+${target}.clear();
+const ${unique3} = (${unique}) => "(${condition})";
+for (let ${unique4} = 0; ${unique4} < ${unique2}.length; ${unique4} += 50) {
+const ${unique4}where = ${unique2}.slice(${unique4}, ${unique4} + 50).map(${unique3}).join(" OR ");
+await abap.statements.select(${target}, {select: "${head}WHERE " + ${unique4}where + " ${tail.trim()}"${extra}}, {appending: true});
+}
+${dedup}
+const ${unique4}max = ${upToCode};
+if (${unique4}max > 0 && ${target}.getArrayLength() > ${unique4}max) {
+if (${target} instanceof abap.types.HashedTable) {
+for (const ${unique4}row of ${target}.array().slice(${unique4}max)) {
+await abap.statements.deleteInternal(${target}, {fromValue: ${unique4}row});
+}
 } else {
-  const ${unique2} = ${faeTranspiled}.array();
-  ${target}.clear();
-  const ${unique3} = (${unique}) => "(${condition})";
-  for (let ${unique4} = 0; ${unique4} < ${unique2}.length; ${unique4} += 50) {
-    const ${unique4}where = ${unique2}.slice(${unique4}, ${unique4} + 50).map(${unique3}).join(" OR ");
-    await abap.statements.select(${target}, {select: "${head}WHERE " + ${unique4}where + " ${tail.trim()}"${extra}}, {appending: true});
-  }
-  ${dedup}
-  const ${unique4}max = ${upToCode};
-  if (${unique4}max > 0 && ${target}.getArrayLength() > ${unique4}max) {
-    if (${target} instanceof abap.types.HashedTable) {
-      for (const ${unique4}row of ${target}.array().slice(${unique4}max)) {
-        await abap.statements.deleteInternal(${target}, {fromValue: ${unique4}row});
-      }
-    } else {
-      while (${target}.getArrayLength() > ${unique4}max) {
-        ${target}.deleteIndex(${target}.getArrayLength() - 1);
-      }
-    }
-  }
-  abap.builtin.sy.get().dbcnt.set(${target}.getArrayLength());
+while (${target}.getArrayLength() > ${unique4}max) {
+${target}.deleteIndex(${target}.getArrayLength() - 1);
+}
+}
+}
+abap.builtin.sy.get().dbcnt.set(${target}.getArrayLength());
 }`;
             return new chunk_1.Chunk().append(code, node, traversal);
         }

package/build/src/statements/sort.d.ts

@@ -4,5 +4,7 @@ import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class SortTranspiler implements IStatementTranspiler {
     transpile(node: abaplint.Nodes.StatementNode, traversal: Traversal): Chunk;
+    private isDynamicName;
+    private dynamicName;
     private findNextText;
 }

package/build/src/statements/sort.js

@@ -40,7 +40,8 @@ const expressions_1 = require("../expressions");
 class SortTranspiler {
     transpile(node, traversal) {
         const concat = node.concatTokens().toUpperCase();
-        const components = node.findDirectExpressions(abaplint.Expressions.ComponentChain);
+        const components = node.getChildren().filter(c => c instanceof abaplint.Nodes.ExpressionNode
+            && (c.get() instanceof abaplint.Expressions.ComponentChain || this.isDynamicName(c, traversal)));
         const options = [];
         if (concat.includes(" BY ") === false) {
             const descending = node.findDirectTokenByText("DESCENDING") !== undefined;
@@ -52,12 +53,14 @@ class SortTranspiler {
             const by = [];
             for (const c of components) {
                 const next = this.findNextText(c, node);
-                const concat = expressions_1.ComponentChainTranspiler.concat(c, traversal);
+                const component = c.get() instanceof abaplint.Expressions.Dynamic
+                    ? this.dynamicName(c, traversal)
+                    : `"${expressions_1.ComponentChainTranspiler.concat(c, traversal)}"`;
                 if (next === "DESCENDING") {
-                    by.push(`{component: "${concat}", descending: true}`);
+                    by.push(`{component: ${component}, descending: true}`);
                 }
                 else {
-                    by.push(`{component: "${concat}"}`);
+                    by.push(`{component: ${component}}`);
                 }
             }
             options.push(`by: [${by.join(",")}]`);
@@ -65,6 +68,32 @@ class SortTranspiler {
         const target = traversal.traverse(node.findDirectExpression(abaplint.Expressions.Target)).getCode();
         return new chunk_1.Chunk().append("abap.statements.sort(" + target + ",{" + options.join(",") + "});", node, traversal);
     }
+    // "BY (name)" with the component name in a literal or a character-like field; a sort order table
+    // (abap_sortorder_tab) is not handled here
+    isDynamicName(c, traversal) {
+        if (!(c.get() instanceof abaplint.Expressions.Dynamic)) {
+            return false;
+        }
+        if (c.findFirstExpression(abaplint.Expressions.ConstantString)) {
+            return true;
+        }
+        const field = c.findFirstExpression(abaplint.Expressions.FieldChain);
+        if (field === undefined) {
+            return false;
+        }
+        const token = field.getFirstToken();
+        const type = traversal.findCurrentScopeByToken(token)?.findVariable(token.getStr())?.getType();
+        return !(type instanceof abaplint.BasicTypes.TableType);
+    }
+    dynamicName(c, traversal) {
+        const constant = c.findFirstExpression(abaplint.Expressions.ConstantString);
+        if (constant) {
+            const str = constant.getFirstToken().getStr();
+            return JSON.stringify(str.substring(1, str.length - 1).toLowerCase().trimEnd());
+        }
+        const field = c.findFirstExpression(abaplint.Expressions.FieldChain);
+        return new expressions_1.FieldChainTranspiler(true).transpile(field, traversal).getCode() + ".toLowerCase().trimEnd()";
+    }
     findNextText(c, parent) {
         const children = parent.getChildren();
         for (let i = 0; i < children.length; i++) {

package/build/src/structures/class_definition.js

@@ -52,17 +52,18 @@ class ClassDefinitionTranspiler {
         }
         else {
             // its an abstract class with only abstract methods
+            // not indented, Chunk.runIndentationLogic indents by brace depth
             return new chunk_1.Chunk(`
 class ${className?.toLowerCase()} {
-  static INTERNAL_TYPE = 'CLAS';
-  static IMPLEMENTED_INTERFACES = [];
-  static INTERNAL_NAME = 'ABSTRACT_CLASS_INTERNAL_NAME';
-  static ATTRIBUTES = {};
-  async constructor_() {
-    this.me = new abap.types.ABAPObject();
-    this.me.set(this);
-    return this;
-  }
+static INTERNAL_TYPE = 'CLAS';
+static IMPLEMENTED_INTERFACES = [];
+static INTERNAL_NAME = 'ABSTRACT_CLASS_INTERNAL_NAME';
+static ATTRIBUTES = {};
+async constructor_() {
+this.me = new abap.types.ABAPObject();
+this.me.set(this);
+return this;
+}
 }`);
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.13.96",
+  "version": "2.13.98",
   "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.64",
+    "@abaplint/core": "^2.120.66",
     "source-map": "^0.8.0"
   },
   "devDependencies": {