@abaplint/transpiler 2.13.95 → 2.13.97

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/db/schema_generation/pg_database_schema.js

@@ -95,6 +95,9 @@ class PGDatabaseSchema {
         else if (type instanceof abaplint.BasicTypes.IntegerType) {
             return `INT`;
         }
+        else if (type instanceof abaplint.BasicTypes.Integer8Type) {
+            return `BIGINT`;
+        }
         else if (type instanceof abaplint.BasicTypes.FloatType
             || type instanceof abaplint.BasicTypes.FloatingPointType) {
             return `REAL`;

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

@@ -94,6 +94,9 @@ class SnowflakeDatabaseSchema {
         else if (type instanceof abaplint.BasicTypes.IntegerType) {
             return `INT`;
         }
+        else if (type instanceof abaplint.BasicTypes.Integer8Type) {
+            return `NUMBER(19)`;
+        }
         else if (type instanceof abaplint.BasicTypes.FloatType
             || type instanceof abaplint.BasicTypes.FloatingPointType) {
             return `REAL`;

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

@@ -96,6 +96,9 @@ class SQLiteDatabaseSchema {
         else if (type instanceof abaplint.BasicTypes.IntegerType) {
             return `INT`;
         }
+        else if (type instanceof abaplint.BasicTypes.Integer8Type) {
+            return `INTEGER`;
+        }
         else if (type instanceof abaplint.BasicTypes.FloatType
             || type instanceof abaplint.BasicTypes.FloatingPointType) {
             return `REAL`;

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/sql_cond.d.ts

@@ -11,6 +11,7 @@ export declare class SQLCondTranspiler implements IExpressionTranspiler {
     private findSubselect;
     private sqlSubselect;
     private sqlSource;
+    private sqlHost;
     private basicConditionNew;
     private sourceWithComponents;
     private sqlOperator;

package/build/src/expressions/sql_cond.js

@@ -151,6 +151,11 @@ class SQLCondTranspiler {
             ret += fieldName + " IS NULL";
             return ret;
         }
+        const aggregation = c.findDirectExpression(abaplint.Expressions.SQLAggregation);
+        if (aggregation && operator && source) {
+            return aggregation.concatTokens() + " " + this.sqlOperator(operator.concatTokens()) + " "
+                + this.sqlSource(source, traversal, filename, table, true);
+        }
         if (fieldName === undefined || operator === undefined || source === undefined) {
             throw new Error("SQL Condition, transpiler todo2, " + c.concatTokens());
         }
@@ -212,17 +217,18 @@ class SQLCondTranspiler {
         }
         return ret + ")";
     }
-    sqlSource(source, traversal, filename, table) {
+    sqlSource(source, traversal, filename, table, numericHost = false) {
         let ret = "";
         const simple = source.findDirectExpression(abaplint.Expressions.SimpleSource3);
         const hostExpression = source.findDirectExpression(abaplint.Expressions.Source);
         const alias = source.findDirectExpression(abaplint.Expressions.SQLAliasField);
         if (source.getFirstToken().getStr() === "@" && hostExpression) {
             const code = new source_1.SourceTranspiler(true).transpile(hostExpression, traversal).getCode();
-            ret += "'\" + " + code + " + \"'";
+            ret += this.sqlHost(code, numericHost);
         }
         else if (simple && simple.findDirectExpression(abaplint.Expressions.Constant) === undefined) {
-            ret += "'\" + " + new simple_source3_1.SimpleSource3Transpiler(true).transpile(simple, traversal).getCode() + " + \"'";
+            const code = new simple_source3_1.SimpleSource3Transpiler(true).transpile(simple, traversal).getCode();
+            ret += this.sqlHost(code, numericHost);
         }
         else if (alias) {
             // SQLAliasField might be a SQL reference or value from ABAP interface
@@ -257,6 +263,12 @@ class SQLCondTranspiler {
         }
         return ret;
     }
+    sqlHost(code, numericHost) {
+        if (numericHost) {
+            return `" + ((value) => typeof value === "number" || typeof value === "bigint" ? value : "'" + value + "'")(${code}) + "`;
+        }
+        return "'\" + " + code + " + \"'";
+    }
     basicConditionNew(node, traversal, filename, table) {
         const sourceWithComponents = this.sourceWithComponents(node, traversal);
         if (sourceWithComponents) {

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/_dataset.d.ts

@@ -0,0 +1,17 @@
+import * as abaplint from "@abaplint/core";
+import { Traversal } from "../traversal";
+/** the Sources and Targets of a DATASET statement, each found by the
+ *  keywords right in front of it: "MESSAGE" in "FOR INPUT IN BINARY MODE
+ *  MESSAGE m", "LENGTH" only when not "MAXIMUM LENGTH" or "ACTUAL LENGTH" */
+export declare class DatasetOperands {
+    private readonly operands;
+    private readonly words;
+    constructor(node: abaplint.Nodes.StatementNode, traversal: Traversal);
+    /** whether the statement has these keywords in a row: its own tokens only,
+     *  never the text of an operand, so a variable lv_type or a literal
+     *  'no end of line' is not an addition */
+    has(words: string): boolean;
+    /** the dataset name, or the source of TRANSFER: the first operand */
+    first(): string;
+    after(words: string, notAfter?: string[]): string | undefined;
+}

package/build/src/statements/_dataset.js

@@ -0,0 +1,82 @@
+"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.DatasetOperands = void 0;
+const abaplint = __importStar(require("@abaplint/core"));
+/** the Sources and Targets of a DATASET statement, each found by the
+ *  keywords right in front of it: "MESSAGE" in "FOR INPUT IN BINARY MODE
+ *  MESSAGE m", "LENGTH" only when not "MAXIMUM LENGTH" or "ACTUAL LENGTH" */
+class DatasetOperands {
+    operands = [];
+    words = [];
+    constructor(node, traversal) {
+        let keywords = [];
+        for (const c of node.getChildren()) {
+            if (c instanceof abaplint.Nodes.TokenNode) {
+                keywords.push(c.getFirstToken().getStr().toUpperCase());
+                this.words.push(c.getFirstToken().getStr().toUpperCase());
+            }
+            else if (c instanceof abaplint.Nodes.ExpressionNode) {
+                this.operands.push({ keywords, code: traversal.traverse(c).getCode() });
+                keywords = [];
+            }
+        }
+    }
+    /** whether the statement has these keywords in a row: its own tokens only,
+     *  never the text of an operand, so a variable lv_type or a literal
+     *  'no end of line' is not an addition */
+    has(words) {
+        // abaplint splits UTF-8, NON-UNICODE and BYTE-ORDER into three tokens
+        const joined = this.words.join(" ").replace(/ - /g, "-");
+        return (" " + joined + " ").includes(" " + words + " ");
+    }
+    /** the dataset name, or the source of TRANSFER: the first operand */
+    first() {
+        return this.operands[0].code;
+    }
+    after(words, notAfter = []) {
+        const want = words.split(" ");
+        for (const o of this.operands.slice(1)) {
+            const tail = o.keywords.slice(-want.length);
+            const before = o.keywords[o.keywords.length - want.length - 1];
+            if (tail.join(" ") === words && (before === undefined || notAfter.includes(before) === false)) {
+                return o.code;
+            }
+        }
+        return undefined;
+    }
+}
+exports.DatasetOperands = DatasetOperands;
+//# sourceMappingURL=_dataset.js.map

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

@@ -0,0 +1,18 @@
+import * as abaplint from "@abaplint/core";
+import { Traversal } from "../traversal";
+/** PARAMETERS and SELECT-OPTIONS declare program variables that exist, with their
+ * DEFAULT values, before INITIALIZATION runs. Without LOWER CASE a character-like
+ * default is upper-cased (measured on a 7.5x system: 'abcdef' into a parameter of
+ * length 4 is "ABCD", a string parameter and the LOW of a select-option likewise) */
+export declare class SelectionDefault {
+    static variable(node: abaplint.Nodes.StatementNode, traversal: Traversal): {
+        name: string;
+        type: abaplint.AbstractType;
+    } | undefined;
+    /** the expression after a keyword of the statement, eg. DEFAULT; only a keyword
+     * token counts, an operand named like the keyword does not */
+    static after(node: abaplint.Nodes.StatementNode, keyword: string): abaplint.Nodes.ExpressionNode | undefined;
+    /** sets the target to a DEFAULT operand, a Constant or a FieldChain, and upper-cases
+     * it when the target is character-like and the statement has no LOWER CASE */
+    static set(node: abaplint.Nodes.StatementNode, target: string, targetType: abaplint.AbstractType, operand: abaplint.Nodes.ExpressionNode, traversal: Traversal): string;
+}

package/build/src/statements/_selection.js

@@ -0,0 +1,82 @@
+"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.SelectionDefault = void 0;
+const abaplint = __importStar(require("@abaplint/core"));
+const traversal_1 = require("../traversal");
+/** PARAMETERS and SELECT-OPTIONS declare program variables that exist, with their
+ * DEFAULT values, before INITIALIZATION runs. Without LOWER CASE a character-like
+ * default is upper-cased (measured on a 7.5x system: 'abcdef' into a parameter of
+ * length 4 is "ABCD", a string parameter and the LOW of a select-option likewise) */
+class SelectionDefault {
+    static variable(node, traversal) {
+        const token = node.findDirectExpression(abaplint.Expressions.FieldSub)?.getFirstToken();
+        if (token === undefined) {
+            return undefined;
+        }
+        const found = traversal.findCurrentScopeByToken(token)?.findVariable(token.getStr());
+        if (found === undefined) {
+            return undefined;
+        }
+        return {
+            name: traversal_1.Traversal.prefixVariable(traversal_1.Traversal.escapeNamespace(found.getName().toLowerCase())),
+            type: found.getType(),
+        };
+    }
+    /** the expression after a keyword of the statement, eg. DEFAULT; only a keyword
+     * token counts, an operand named like the keyword does not */
+    static after(node, keyword) {
+        const children = node.getChildren();
+        for (let i = 0; i < children.length - 1; i++) {
+            if (children[i] instanceof abaplint.Nodes.TokenNode && children[i].concatTokens().toUpperCase() === keyword) {
+                return children[i + 1];
+            }
+        }
+        return undefined;
+    }
+    /** sets the target to a DEFAULT operand, a Constant or a FieldChain, and upper-cases
+     * it when the target is character-like and the statement has no LOWER CASE */
+    static set(node, target, targetType, operand, traversal) {
+        let code = "\n" + target + ".set(" + traversal.traverse(operand).getCode() + ");";
+        const characterLike = targetType instanceof abaplint.BasicTypes.CharacterType
+            || targetType instanceof abaplint.BasicTypes.StringType;
+        if (node.findDirectTokenByText("LOWER") === undefined && characterLike === true) {
+            code += "\n" + target + ".set(abap.builtin.to_upper({val: " + target + "}));";
+        }
+        return code;
+    }
+}
+exports.SelectionDefault = SelectionDefault;
+//# sourceMappingURL=_selection.js.map

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/close_dataset.d.ts

@@ -3,5 +3,5 @@ import { IStatementTranspiler } from "./_statement_transpiler";
 import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class CloseDatasetTranspiler implements IStatementTranspiler {
-    transpile(_node: abaplint.Nodes.StatementNode, _traversal: Traversal): Chunk;
+    transpile(node: abaplint.Nodes.StatementNode, traversal: Traversal): Chunk;
 }