@abaplint/transpiler 2.13.39 → 2.13.41

package/build/src/chunk.d.ts

@@ -2,17 +2,42 @@ import * as sourceMap from "source-map";
 import * as abaplint from "@abaplint/core";
 export declare class Chunk {
     private raw;
+    private lineCount;
+    private lastLineLength;
     mappings: sourceMap.Mapping[];
     constructor(str?: string);
     join(chunks: Chunk[], str?: string): Chunk;
     appendChunk(append: Chunk): Chunk;
+    private originalPosition;
     append(input: string, pos: abaplint.Position | abaplint.INode | abaplint.Token, traversal: {
         getFilename(): string;
     }): Chunk;
+    /**
+     * Baseline fallback so statements whose transpiler emitted no mappings still
+     * resolve to their ABAP source. Adds a single mapping from the start of this
+     * chunk (generated line 1, column 0) to `pos`. No-op if the chunk is empty or
+     * already carries mappings, so it never overrides finer-grained mappings.
+     */
+    ensureStartMapping(pos: abaplint.Position | abaplint.INode | abaplint.Token, traversal: {
+        getFilename(): string;
+    }): Chunk;
     appendString(input: string): this;
     stripLastNewline(): void;
     getCode(): string;
     toString(): string;
     runIndentationLogic(ignoreSourceMap?: boolean): this;
-    getMap(generatedFilename: string): string;
+    /**
+     * @param generatedFilename name written to the "file" field of the map
+     * @param options.generatedLineOffset number of lines prepended to the generated
+     *   output after this chunk was built (e.g. a runtime import line); every mapping
+     *   is shifted down by this amount so the map stays aligned with the file on disk
+     * @param options.sourcePaths maps a mapping "source" (the bare abap filename) to
+     *   the path that should appear in the map, avoiding fragile post-hoc string edits
+     */
+    getMap(generatedFilename: string, options?: {
+        generatedLineOffset?: number;
+        sourcePaths?: {
+            [filename: string]: string;
+        };
+    }): string;
 }

package/build/src/chunk.js

@@ -48,9 +48,14 @@ abaplint:
 // Keeps track of source maps as generated code is added
 class Chunk {
     raw;
+    // tracked incrementally so appends never re-scan the whole buffer
+    lineCount;
+    lastLineLength;
     mappings = [];
     constructor(str) {
         this.raw = "";
+        this.lineCount = 1;
+        this.lastLineLength = 0;
         this.mappings = [];
         if (str) {
             this.appendString(str);
@@ -69,63 +74,85 @@ class Chunk {
         if (append.getCode() === "") {
             return this;
         }
-        const lines = this.raw.split("\n");
-        const lineCount = lines.length;
-        const lastLine = lines[lines.length - 1];
         for (const m of append.mappings) {
-            // original stays the same, but adjust the generated positions
-            const add = m;
-            if (add.generated.line === 1 && this.raw.endsWith("\n") === false) {
-                add.generated.column += lastLine.length;
-            }
-            else {
-                add.generated.line += lineCount - 1;
+            // deep copy so the appended chunk's mappings are never mutated,
+            // otherwise appending the same chunk twice double-shifts its positions
+            const add = {
+                source: m.source,
+                name: m.name,
+                generated: { line: m.generated.line, column: m.generated.column },
+                original: { line: m.original.line, column: m.original.column },
+            };
+            // original stays the same, but adjust the generated positions:
+            // the appended content begins at the end of the current buffer, so its
+            // first line continues the current last line, and every line moves down
+            if (add.generated.line === 1) {
+                add.generated.column += this.lastLineLength;
             }
+            add.generated.line += this.lineCount - 1;
             this.mappings.push(add);
         }
-        this.raw += append.getCode();
-        return this;
+        return this.appendString(append.getCode());
+    }
+    originalPosition(pos) {
+        if (pos instanceof abaplint.Position || pos instanceof abaplint.Token) {
+            return { line: pos.getRow(), column: pos.getCol() - 1 };
+        }
+        else {
+            return { line: pos.getFirstToken().getRow(), column: pos.getFirstToken().getCol() - 1 };
+        }
     }
     append(input, pos, traversal) {
         if (input === "") {
             return this;
         }
         if (pos && input !== "\n") {
-            const lines = this.raw.split("\n");
-            const lastLine = lines[lines.length - 1];
-            let originalLine = 0;
-            let originalColumn = 0;
-            if (pos instanceof abaplint.Position || pos instanceof abaplint.Token) {
-                originalLine = pos.getRow();
-                originalColumn = pos.getCol() - 1;
-            }
-            else {
-                originalLine = pos.getFirstToken().getRow();
-                originalColumn = pos.getFirstToken().getCol() - 1;
-            }
             this.mappings.push({
                 source: traversal.getFilename(),
                 generated: {
-                    line: lines.length,
-                    column: lastLine.length,
-                },
-                original: {
-                    line: originalLine,
-                    column: originalColumn,
+                    line: this.lineCount,
+                    column: this.lastLineLength,
                 },
+                original: this.originalPosition(pos),
             });
         }
-        this.raw += input;
+        return this.appendString(input);
+    }
+    /**
+     * Baseline fallback so statements whose transpiler emitted no mappings still
+     * resolve to their ABAP source. Adds a single mapping from the start of this
+     * chunk (generated line 1, column 0) to `pos`. No-op if the chunk is empty or
+     * already carries mappings, so it never overrides finer-grained mappings.
+     */
+    ensureStartMapping(pos, traversal) {
+        if (this.raw === "" || this.mappings.length > 0) {
+            return this;
+        }
+        this.mappings.push({
+            source: traversal.getFilename(),
+            generated: { line: 1, column: 0 },
+            original: this.originalPosition(pos),
+        });
         return this;
     }
     appendString(input) {
         this.raw += input;
+        const lastNewline = input.lastIndexOf("\n");
+        if (lastNewline < 0) {
+            this.lastLineLength += input.length;
+        }
+        else {
+            this.lineCount += input.split("\n").length - 1;
+            this.lastLineLength = input.length - lastNewline - 1;
+        }
         return this;
     }
     stripLastNewline() {
         // note: this will not change the source map
         if (this.raw.endsWith("\n")) {
             this.raw = this.raw.substring(0, this.raw.length - 1);
+            this.lineCount--;
+            this.lastLineLength = this.raw.length - this.raw.lastIndexOf("\n") - 1;
         }
     }
     getCode() {
@@ -145,16 +172,18 @@ class Chunk {
             if (l.startsWith("}")) {
                 i = i - 1;
             }
-            if (i > 0) {
-                output.push(" ".repeat(i * 2) + l);
+            // clamp so unbalanced braces never produce a negative indent/shift
+            const indent = i > 0 ? i * 2 : 0;
+            if (indent > 0) {
+                output.push(" ".repeat(indent) + l);
             }
             else {
                 output.push(l);
             }
-            // fix maps
+            // fix maps: shift columns by the indentation actually applied to this line
             for (const m of this.mappings) {
                 if (m.generated.line === line) {
-                    m.generated.column += i * 2;
+                    m.generated.column += indent;
                 }
             }
             if (l.endsWith(" {")) {
@@ -163,11 +192,28 @@ class Chunk {
             line++;
         }
         this.raw = output.join("\n");
+        // line structure is unchanged, but the last line may have been indented
+        this.lastLineLength = output[output.length - 1].length;
         return this;
     }
-    getMap(generatedFilename) {
+    /**
+     * @param generatedFilename name written to the "file" field of the map
+     * @param options.generatedLineOffset number of lines prepended to the generated
+     *   output after this chunk was built (e.g. a runtime import line); every mapping
+     *   is shifted down by this amount so the map stays aligned with the file on disk
+     * @param options.sourcePaths maps a mapping "source" (the bare abap filename) to
+     *   the path that should appear in the map, avoiding fragile post-hoc string edits
+     */
+    getMap(generatedFilename, options) {
+        const offset = options?.generatedLineOffset ?? 0;
+        const sourcePaths = options?.sourcePaths ?? {};
         const sourceMapGenerator = new sourceMap.SourceMapGenerator();
-        this.mappings.forEach(m => sourceMapGenerator.addMapping(m));
+        this.mappings.forEach(m => sourceMapGenerator.addMapping({
+            source: sourcePaths[m.source] ?? m.source,
+            name: m.name,
+            original: m.original,
+            generated: { line: m.generated.line + offset, column: m.generated.column },
+        }));
         const json = sourceMapGenerator.toJSON();
         json.file = generatedFilename;
         json.sourceRoot = "";

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

@@ -3,4 +3,7 @@ import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class ReduceBodyTranspiler {
     transpile(typ: Nodes.ExpressionNode, body: Nodes.ExpressionNode, traversal: Traversal): Chunk;
+    private transpileIndex;
+    private declareInit;
+    private transpileNext;
 }

package/build/src/expressions/reduce_body.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReduceBodyTranspiler = void 0;
 const core_1 = require("@abaplint/core");
+const traversal_1 = require("../traversal");
 const chunk_1 = require("../chunk");
 const transpile_types_1 = require("../transpile_types");
 const target_1 = require("./target");
@@ -21,10 +22,14 @@ class ReduceBodyTranspiler {
         else if (forExpressions.length > 1) {
             throw new Error("ReduceBodyTranspiler, multiple FOR not supported, " + body.concatTokens());
         }
-        else if (["THEN", "UNTIL", "WHILE", "FROM", "TO", "GROUPS"].some(token => forExpressions[0].findDirectTokenByText(token))) {
+        const loopExpression = forExpression.findDirectExpression(core_1.Expressions.InlineLoopDefinition);
+        if (loopExpression === undefined) {
+            // index based FOR, eg. "FOR i = 1 WHILE i <= 5"
+            return this.transpileIndex(body, forExpression, traversal);
+        }
+        else if (["THEN", "UNTIL", "WHILE", "FROM", "TO", "GROUPS"].some(token => forExpression.findDirectTokenByText(token))) {
             throw new Error("ValueBody FOR todo, " + body.concatTokens());
         }
-        const loopExpression = forExpression.findDirectExpression(core_1.Expressions.InlineLoopDefinition);
         const loopSource = traversal.traverse(loopExpression?.findDirectExpression(core_1.Expressions.Source)).getCode();
         const loopVariable = traversal.traverse(loopExpression?.findDirectExpression(core_1.Expressions.TargetField)
             || loopExpression?.findDirectExpression(core_1.Expressions.TargetFieldSymbol)).getCode();
@@ -42,6 +47,75 @@ class ReduceBodyTranspiler {
         const returnId = UniqueIdentifier.get();
         ret.appendString(`const ${returnId} = ${target};\n`);
         */
+        const returnField = this.declareInit(body, traversal, ret);
+        ret.appendString(`for await (const ${loopVariable} of abap.statements.loop(${loopSource}${loopWhere})) {\n`);
+        ret.appendString(this.transpileNext(body, traversal));
+        ret.appendString(`}\n`);
+        ret.appendString(`return ${returnField};\n`);
+        ret.appendString("})())");
+        return ret;
+    }
+    transpileIndex(body, forExpression, traversal) {
+        if (["FROM", "TO", "GROUPS"].some(token => forExpression.findDirectTokenByText(token))) {
+            throw new Error("ValueBody FOR todo, " + body.concatTokens());
+        }
+        const counter = forExpression.findDirectExpression(core_1.Expressions.InlineFieldDefinition);
+        if (counter === undefined) {
+            throw new Error("ValueBody FOR todo, " + body.concatTokens());
+        }
+        const cond = forExpression.findDirectExpression(core_1.Expressions.Cond);
+        if (cond === undefined) {
+            throw new Error("ValueBody FOR missing condition, " + body.concatTokens());
+        }
+        const hasUntil = forExpression.findDirectTokenByText("UNTIL") !== undefined;
+        const hasWhile = forExpression.findDirectTokenByText("WHILE") !== undefined;
+        if ((hasUntil ? 1 : 0) + (hasWhile ? 1 : 0) !== 1) {
+            throw new Error("ValueBody FOR todo, condition, " + body.concatTokens());
+        }
+        const fieldName = counter.findDirectExpression(core_1.Expressions.Field)?.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 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 = forExpression.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 condCode = traversal.traverse(cond).getCode();
+        const ret = new chunk_1.Chunk();
+        ret.appendString("(await (async () => {\n");
+        const returnField = this.declareInit(body, traversal, ret);
+        ret.appendString(transpile_types_1.TranspileTypes.declare(variable) + `\n`);
+        ret.appendString(`${counterName}.set(${start});\n`);
+        ret.appendString(`while (true) {\n`);
+        if (hasWhile) {
+            ret.appendString(`if (!(${condCode})) {\nbreak;\n}\n`);
+        }
+        ret.appendString(this.transpileNext(body, traversal));
+        ret.appendString(`${counterName}.set(${incrementExpression});\n`);
+        if (hasUntil) {
+            ret.appendString(`if (${condCode}) {\nbreak;\n}\n`);
+        }
+        ret.appendString(`}\n`);
+        ret.appendString(`return ${returnField};\n`);
+        ret.appendString("})())");
+        return ret;
+    }
+    declareInit(body, traversal, ret) {
         let returnField = "";
         for (const init of body.findDirectExpressions(core_1.Expressions.InlineFieldDefinition)) {
             const fieldName = init.findDirectExpression(core_1.Expressions.Field).concatTokens().toLowerCase();
@@ -53,18 +127,18 @@ class ReduceBodyTranspiler {
             }
             ret.appendString(transpile_types_1.TranspileTypes.declare(variable) + `\n`);
         }
-        ret.appendString(`for await (const ${loopVariable} of abap.statements.loop(${loopSource}${loopWhere})) {\n`);
+        return returnField;
+    }
+    transpileNext(body, traversal) {
+        let ret = "";
         for (const nextChild of body.findDirectExpression(core_1.Expressions.ReduceNext)?.getChildren() || []) {
             if (nextChild.get() instanceof core_1.Expressions.SimpleTarget && nextChild instanceof core_1.Nodes.ExpressionNode) {
-                ret.appendString(new target_1.TargetTranspiler().transpile(nextChild, traversal).getCode() + ".set(");
+                ret += new target_1.TargetTranspiler().transpile(nextChild, traversal).getCode() + ".set(";
             }
             else if (nextChild.get() instanceof core_1.Expressions.Source && nextChild instanceof core_1.Nodes.ExpressionNode) {
-                ret.appendString(traversal.traverse(nextChild).getCode() + ");\n");
+                ret += traversal.traverse(nextChild).getCode() + ");\n";
             }
         }
-        ret.appendString(`}\n`);
-        ret.appendString(`return ${returnField};\n`);
-        ret.appendString("})())");
         return ret;
     }
 }

package/build/src/expressions/switch_body.js

@@ -32,6 +32,9 @@ class SwitchBodyTranspiler {
                     else if (c.concatTokens() === "THEN") {
                         mode = "THEN";
                     }
+                    else if (c.concatTokens() === "ELSE") {
+                        mode = "";
+                    }
                 }
                 else if (mode === "WHEN" && c instanceof core_1.Nodes.ExpressionNode) {
                     currentWhenThen.whenOr.push(c);

package/build/src/expressions/value_body.js

@@ -24,6 +24,7 @@ class ValueBodyTranspiler {
         }
         let post = "";
         let extraFields = "";
+        let baseCode = undefined;
         const hasLines = body.findDirectExpression(core_1.Expressions.ValueBodyLine) !== undefined;
         const children = body.getChildren();
         for (let i = 0; i < children.length; i++) {
@@ -39,7 +40,8 @@ class ValueBodyTranspiler {
             }
             else if (child.get() instanceof core_1.Expressions.ValueBase && child instanceof core_1.Nodes.ExpressionNode) {
                 const source = traversal.traverse(child.findDirectExpression(core_1.Expressions.Source));
-                ret = new chunk_1.Chunk().appendString(source.getCode() + ".clone()");
+                baseCode = source.getCode() + ".clone()";
+                ret = new chunk_1.Chunk().appendString(baseCode);
             }
             else if (child.get() instanceof core_1.Expressions.ValueBodyLine && child instanceof core_1.Nodes.ExpressionNode) {
                 if (!(context instanceof core_1.BasicTypes.TableType)) {
@@ -66,7 +68,7 @@ class ValueBodyTranspiler {
                     }
                 }
                 i = idx - 1;
-                const result = this.buildForChain(forNodes, typ, traversal, body);
+                const result = this.buildForChain(forNodes, typ, traversal, body, baseCode);
                 ret = result.chunk;
                 post = result.post;
             }
@@ -77,6 +79,8 @@ class ValueBodyTranspiler {
                 const pre = `(await (async () => { try { return `;
                 ret = new chunk_1.Chunk().appendString(pre + ret.getCode());
                 post += `; } catch (error) { if (abap.isLineNotFound(error)) { return ${deflt}; } throw error; } })())`;
+                // the default value Source is part of this DEFAULT handling, stop processing further children
+                break;
             }
             else if (child instanceof core_1.Nodes.TokenNode && child.getFirstToken().getStr().toUpperCase() === "OPTIONAL") {
                 // note: this is last in the body, so its okay to prepend and postpend
@@ -90,8 +94,8 @@ class ValueBodyTranspiler {
         }
         return ret.appendString(post);
     }
-    buildForChain(forNodes, typ, traversal, body) {
-        const val = new type_name_or_infer_1.TypeNameOrInfer().transpile(typ, traversal).getCode();
+    buildForChain(forNodes, typ, traversal, body, baseCode) {
+        const val = baseCode ?? new type_name_or_infer_1.TypeNameOrInfer().transpile(typ, traversal).getCode();
         const chunk = new chunk_1.Chunk();
         const preLoopDecls = [];
         const descriptors = [];

package/build/src/handlers/handle_fugr.js

@@ -62,8 +62,11 @@ class HandleFUGR {
             const contents = new traversal_1.Traversal(spaghetti, file, obj, reg, this.options).traverse(rearranged);
             chunk.appendChunk(contents);
             chunk.stripLastNewline();
-            chunk.runIndentationLogic(this.options?.ignoreSourceMap);
         }
+        // indentation must run once over the accumulated chunk: running it per
+        // appended file re-indents the earlier files, drifting the brace counter
+        // and shifting their mapping columns multiple times
+        chunk.runIndentationLogic(this.options?.ignoreSourceMap);
         chunk.appendString("\n}");
         const output = {
             object: {

package/build/src/statements/clear.js

@@ -39,17 +39,14 @@ const chunk_1 = require("../chunk");
 class ClearTranspiler {
     transpile(node, traversal) {
         const target = traversal.traverse(node.findDirectExpression(abaplint.Expressions.Target));
+        // Reference implementation for the source-map convention:
+        // - keep the target's own expression-level mappings by appending its Chunk
+        //   (do NOT flatten with target.getCode(), that discards the mappings)
+        // - map the trailing generated syntax to the statement's last token, not
+        //   getEnd() which points one column past the statement
         const ret = new chunk_1.Chunk();
-        /*
         ret.appendChunk(target);
-        ret.append(".clear();", node.getLastToken().getEnd(), traversal);
-        */
-        ret.append(target.getCode() + ".clear();", node.getLastToken().getEnd(), traversal);
-        //    ret.append(target.getCode() + ".clear();", node, traversal);
-        /*
-            ret.append(target.getCode(), node.getFirstToken().getStart(), traversal);
-            ret.append(".clear();", node.getLastToken().getEnd(), traversal);
-            */
+        ret.append(".clear();", node.getLastToken(), traversal);
         return ret;
     }
 }

package/build/src/statements/concatenate.js

@@ -53,6 +53,9 @@ class ConcatenateTranspiler {
         if (concat.includes(" RESPECTING BLANKS")) {
             extra += ", respectingBlanks: true";
         }
+        if (concat.includes(" IN BYTE MODE")) {
+            extra += ", byteMode: true";
+        }
         const target = traversal.traverse(node.findDirectExpression(abaplint.Expressions.Target));
         return new chunk_1.Chunk()
             .append("abap.statements.concatenate({source: [", node, traversal)

package/build/src/statements/loop.js

@@ -65,8 +65,11 @@ class LoopTranspiler {
         const source = traversal.traverse(loopSource).getCode();
         this.unique = unique_identifier_1.UniqueIdentifier.get();
         let target = "";
+        // the abap expression the target-assignment line should map back to
+        let targetNode = undefined;
         const into = this.determineInto(node);
         if (into && this.skipInto !== true) {
+            targetNode = into;
             const concat = node.concatTokens().toUpperCase();
             const t = traversal.traverse(into).getCode();
             const scope = traversal.findCurrentScopeByToken(node.getFirstToken());
@@ -86,6 +89,7 @@ class LoopTranspiler {
         else if (this.skipInto !== true) {
             const assigning = node.findFirstExpression(abaplint.Expressions.FSTarget)?.findFirstExpression(abaplint.Expressions.FieldSymbol);
             if (assigning) {
+                targetNode = assigning;
                 target = traversal.traverse(assigning).getCode() + ".assign(" + this.unique + ");";
             }
         }
@@ -166,7 +170,15 @@ class LoopTranspiler {
         if (extra.length > 0) {
             concat = ",{" + extra.join(",") + "}";
         }
-        return new chunk_1.Chunk(`for await (const ${this.unique} of abap.statements.loop(${source}${concat})) {\n${target}`);
+        // map the loop head to the statement start and the target-assignment line
+        // (foo.set(unique)) back to the INTO/ASSIGNING target expression
+        const ret = new chunk_1.Chunk();
+        ret.append(`for await (const ${this.unique} of abap.statements.loop(${source}${concat})) {`, node, traversal);
+        ret.appendString("\n");
+        if (target !== "") {
+            ret.append(target, targetNode ?? node, traversal);
+        }
+        return ret;
     }
 }
 exports.LoopTranspiler = LoopTranspiler;

package/build/src/statements/return.js

@@ -37,7 +37,6 @@ exports.ReturnTranspiler = void 0;
 const abaplint = __importStar(require("@abaplint/core"));
 const traversal_1 = require("../traversal");
 const chunk_1 = require("../chunk");
-const unique_identifier_1 = require("../unique_identifier");
 class ReturnTranspiler {
     transpile(node, traversal) {
         const source = node.findDirectExpression(abaplint.Expressions.Source);
@@ -51,8 +50,9 @@ class ReturnTranspiler {
             }
         }
         let pre = "";
-        if (traversal.isInsideDoOrWhile(node)) {
-            pre = `abap.builtin.sy.get().index.set(${unique_identifier_1.UniqueIdentifier.getIndexBackup1()});\n`;
+        const syIndexBackup = traversal.findCurrentDoOrWhileIndexBackup(node);
+        if (syIndexBackup !== undefined) {
+            pre = `abap.builtin.sy.get().index.set(${syIndexBackup});\n`;
         }
         if (scope?.getIdentifier().stype === abaplint.ScopeType.Method
             && scope?.getIdentifier().sname.toLowerCase() === "constructor") {

package/build/src/structures/constants.js

@@ -47,9 +47,11 @@ class ConstantsTranspiler {
         if (name === undefined) {
             throw "ConstantsTranspilerName";
         }
-        let ret = new statements_1.DataTranspiler().transpile(begin, traversal).getCode() + "\n";
-        ret += ConstantsTranspiler.handleValues(name, node, traversal);
-        return new chunk_1.Chunk(ret);
+        const ret = new chunk_1.Chunk();
+        ret.appendChunk(new statements_1.DataTranspiler().transpile(begin, traversal).ensureStartMapping(begin, traversal));
+        ret.appendString("\n");
+        ret.appendString(ConstantsTranspiler.handleValues(name, node, traversal));
+        return ret;
     }
     static handleValues(prefix, node, traversal) {
         let ret = "";

package/build/src/structures/data.js

@@ -44,7 +44,7 @@ class DataTranspiler {
             return new chunk_1.Chunk("");
         }
         const topName = begin.findDirectExpression(abaplint.Expressions.DefinitionName)?.concatTokens().toLowerCase();
-        const chunk = new statements_1.DataTranspiler().transpile(begin, traversal);
+        const chunk = new statements_1.DataTranspiler().transpile(begin, traversal).ensureStartMapping(begin, traversal);
         for (const d of node.findDirectStatements(abaplint.Statements.Data)) {
             const subName = d.findFirstExpression(abaplint.Expressions.DefinitionName)?.concatTokens().toLowerCase();
             if (subName && topName) {

package/build/src/structures/do.js

@@ -44,7 +44,8 @@ class DoTranspiler {
         const syIndexBackup = unique_identifier_1.UniqueIdentifier.getIndexBackup();
         for (const c of node.getChildren()) {
             if (c instanceof abaplint.Nodes.StatementNode && c.get() instanceof abaplint.Statements.Do) {
-                ret.appendChunk(new statements_1.DoTranspiler(syIndexBackup).transpile(c, traversal));
+                traversal.registerDoOrWhileIndexBackup(c, syIndexBackup);
+                ret.appendChunk(new statements_1.DoTranspiler(syIndexBackup).transpile(c, traversal).ensureStartMapping(c, traversal));
                 ret.appendString("\n");
             }
             else if (c instanceof abaplint.Nodes.StatementNode && c.get() instanceof abaplint.Statements.EndDo) {

package/build/src/structures/function_module.js

@@ -41,7 +41,7 @@ const transpile_types_1 = require("../transpile_types");
 const unique_identifier_1 = require("../unique_identifier");
 class FunctionModuleTranspiler {
     transpile(node, traversal) {
-        let r = "";
+        const chunk = new chunk_1.Chunk();
         let name = "";
         for (const c of node.getChildren()) {
             if (c.get() instanceof abaplint.Statements.FunctionModule && c instanceof abaplint.Nodes.StatementNode) {
@@ -49,19 +49,19 @@ class FunctionModuleTranspiler {
                 if (name === undefined) {
                     name = "FunctionModuleTranspilerNameNotFound";
                 }
-                r += `async function ${traversal_1.Traversal.escapeNamespace(name)}(INPUT) {\n`;
-                r += this.findSignature(traversal, name, c);
+                chunk.append(`async function ${traversal_1.Traversal.escapeNamespace(name)}(INPUT) {\n`, c, traversal);
+                chunk.appendString(this.findSignature(traversal, name, c));
             }
             else if (c.get() instanceof abaplint.Statements.EndFunction) {
-                r += "}\n";
-                r += `abap.FunctionModules['${name.toUpperCase()}'] = ${traversal_1.Traversal.escapeNamespace(name)};\n`;
+                chunk.append("}\n", c, traversal);
+                chunk.appendString(`abap.FunctionModules['${name.toUpperCase()}'] = ${traversal_1.Traversal.escapeNamespace(name)};\n`);
             }
             else {
-                r += traversal.traverse(c).getCode();
+                chunk.appendChunk(traversal.traverse(c));
             }
         }
         unique_identifier_1.UniqueIdentifier.resetIndexBackup();
-        return new chunk_1.Chunk(r);
+        return chunk;
     }
     //////////////////////
     findSignature(traversal, name, node) {

package/build/src/structures/loop.js

@@ -94,6 +94,7 @@ class LoopTranspiler {
                     ret.appendString(`let ${tabix} = undefined;\n`);
                 }
                 const loop = new statements_1.LoopTranspiler();
+                // LoopStatementTranspiler maps its own head, so no ensureStartMapping needed here
                 ret.appendChunk(loop.transpile(c, traversal));
                 ret.appendString("\n");
                 if (hasAt === true) {

package/build/src/structures/select.js

@@ -60,7 +60,8 @@ class SelectTranspiler {
         const targetName = unique_identifier_1.UniqueIdentifier.get();
         const loopName = unique_identifier_1.UniqueIdentifier.get();
         ret.appendString(`let ${targetName} = new abap.types.Table(abap.DDIC["${from}"].type());\n`);
-        ret.appendChunk(new select_1.SelectTranspiler().transpile(selectStatement, traversal, targetName));
+        const selectHead = new select_1.SelectTranspiler().transpile(selectStatement, traversal, targetName);
+        ret.appendChunk(selectHead.ensureStartMapping(selectStatement, traversal));
         // todo: optimize, it should do real streaming?
         const packageSize = selectStatement.findFirstExpression(abaplint.Expressions.SQLPackageSize)
             ?.findFirstExpression(abaplint.Expressions.SQLSource);

package/build/src/structures/while.js

@@ -44,7 +44,8 @@ class WhileTranspiler {
         const syIndexBackup = unique_identifier_1.UniqueIdentifier.getIndexBackup();
         for (const c of node.getChildren()) {
             if (c instanceof abaplint.Nodes.StatementNode && c.get() instanceof abaplint.Statements.While) {
-                ret.appendChunk(new statements_1.WhileTranspiler(syIndexBackup).transpile(c, traversal));
+                traversal.registerDoOrWhileIndexBackup(c, syIndexBackup);
+                ret.appendChunk(new statements_1.WhileTranspiler(syIndexBackup).transpile(c, traversal).ensureStartMapping(c, traversal));
                 ret.appendString("\n");
             }
             else if (c instanceof abaplint.Nodes.StatementNode && c.get() instanceof abaplint.Statements.EndWhile) {

package/build/src/traversal.d.ts

@@ -6,6 +6,7 @@ export declare class Traversal {
     private readonly file;
     private readonly obj;
     private sqlInferredType;
+    private readonly doOrWhileIndexBackups;
     readonly reg: abaplint.IRegistry;
     readonly options: ITranspilerOptions | undefined;
     constructor(spaghetti: abaplint.ISpaghettiScope, file: abaplint.ABAPFile, obj: abaplint.ABAPObject, reg: abaplint.IRegistry, options?: ITranspilerOptions);
@@ -58,6 +59,8 @@ export declare class Traversal {
     determineType(node: abaplint.Nodes.ExpressionNode | abaplint.Nodes.StatementNode, scope: abaplint.ISpaghettiScopeNode | undefined): abaplint.AbstractType | undefined;
     isInsideLoop(node: abaplint.Nodes.StatementNode): boolean;
     isInsideDoOrWhile(node: abaplint.Nodes.StatementNode): boolean;
+    registerDoOrWhileIndexBackup(node: abaplint.Nodes.StatementNode, name: string): void;
+    findCurrentDoOrWhileIndexBackup(node: abaplint.Nodes.StatementNode): string | undefined;
     registerClassOrInterface(def: abaplint.IClassDefinition | abaplint.IInterfaceDefinition | undefined): string;
     setValues(identifier: abaplint.TypedIdentifier, name: string): string;
     static setValues(identifier: abaplint.TypedIdentifier, name: string): string;

package/build/src/traversal.js

@@ -47,6 +47,7 @@ class Traversal {
     file;
     obj;
     sqlInferredType;
+    doOrWhileIndexBackups = new Map();
     reg;
     options;
     constructor(spaghetti, file, obj, reg, options) {
@@ -779,12 +780,18 @@ this.INTERNAL_ID = abap.internalIdCounter++;\n`;
         return stack.length > 0;
     }
     isInsideDoOrWhile(node) {
+        return this.findCurrentDoOrWhileIndexBackup(node) !== undefined;
+    }
+    registerDoOrWhileIndexBackup(node, name) {
+        this.doOrWhileIndexBackups.set(node, name);
+    }
+    findCurrentDoOrWhileIndexBackup(node) {
         const stack = [];
         for (const statement of this.getFile().getStatements()) {
             const get = statement.get();
             if (get instanceof abaplint.Statements.While
                 || get instanceof abaplint.Statements.Do) {
-                stack.push(statement);
+                stack.push(this.doOrWhileIndexBackups.get(statement));
             }
             else if (get instanceof abaplint.Statements.EndWhile
                 || get instanceof abaplint.Statements.EndDo) {
@@ -794,7 +801,7 @@ this.INTERNAL_ID = abap.internalIdCounter++;\n`;
                 break;
             }
         }
-        return stack.length > 0;
+        return stack[stack.length - 1];
     }
     registerClassOrInterface(def) {
         if (def === undefined) {
@@ -907,6 +914,8 @@ this.INTERNAL_ID = abap.internalIdCounter++;\n`;
         if (list[search]) {
             const transpiler = new list[search]();
             const chunk = transpiler.transpile(node, this);
+            // baseline: statements that emitted no mappings still resolve to their source
+            chunk.ensureStartMapping(node, this);
             chunk.appendString("\n");
             return chunk;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.13.39",
+  "version": "2.13.41",
   "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.119.64",
+    "@abaplint/core": "^2.120.2",
     "source-map": "^0.7.6"
   },
   "devDependencies": {