@abaplint/transpiler 2.13.64 → 2.13.66

package/build/src/chunk.d.ts

@@ -1,5 +1,9 @@
 import * as sourceMap from "source-map";
 import * as abaplint from "@abaplint/core";
+type SourceMapTraversal = {
+    getFilename(): string;
+    isSourceMapEnabled?(): boolean;
+};
 export declare class Chunk {
     private raw;
     private lineCount;
@@ -9,18 +13,14 @@ export declare class Chunk {
     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;
+    append(input: string, pos: abaplint.Position | abaplint.INode | abaplint.Token, traversal: SourceMapTraversal): 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;
+    ensureStartMapping(pos: abaplint.Position | abaplint.INode | abaplint.Token, traversal: SourceMapTraversal): Chunk;
     appendString(input: string): this;
     stripLastNewline(): void;
     getCode(): string;
@@ -41,3 +41,4 @@ export declare class Chunk {
         };
     }): string;
 }
+export {};

package/build/src/chunk.js

@@ -106,7 +106,7 @@ class Chunk {
         if (input === "") {
             return this;
         }
-        if (pos && input !== "\n") {
+        if (pos && input !== "\n" && traversal.isSourceMapEnabled?.() !== false) {
             this.mappings.push({
                 source: traversal.getFilename(),
                 generated: {
@@ -125,7 +125,7 @@ class Chunk {
      * already carries mappings, so it never overrides finer-grained mappings.
      */
     ensureStartMapping(pos, traversal) {
-        if (this.raw === "" || this.mappings.length > 0) {
+        if (this.raw === "" || this.mappings.length > 0 || traversal.isSourceMapEnabled?.() === false) {
             return this;
         }
         this.mappings.push({
@@ -168,29 +168,32 @@ class Chunk {
         if (ignoreSourceMap === true) {
             this.mappings = [];
         }
+        const indentationByLine = this.mappings.length > 0 ? [] : undefined;
         for (const l of this.raw.split("\n")) {
             if (l.startsWith("}")) {
                 i = i - 1;
             }
             // clamp so unbalanced braces never produce a negative indent/shift
             const indent = i > 0 ? i * 2 : 0;
+            if (indentationByLine !== undefined) {
+                indentationByLine[line] = indent;
+            }
             if (indent > 0) {
                 output.push(" ".repeat(indent) + l);
             }
             else {
                 output.push(l);
             }
-            // 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 += indent;
-                }
-            }
             if (l.endsWith(" {")) {
                 i = i + 1;
             }
             line++;
         }
+        // Shift every mapping once. The previous line-major implementation
+        // inspected every mapping for every generated line (O(lines * mappings)).
+        for (const m of this.mappings) {
+            m.generated.column += indentationByLine?.[m.generated.line] || 0;
+        }
         this.raw = output.join("\n");
         // line structure is unchanged, but the last line may have been indented
         this.lastLineLength = output[output.length - 1].length;

package/build/src/db/index.js

@@ -83,39 +83,49 @@ class DatabaseSetup {
         // note: avoid hitting maximum statement size by splitting into multiple statements
         const insert = [];
         const populateTables = new populate_tables_1.PopulateTables(this.reg);
+        const add = (statement) => {
+            if (statement.length > 0) {
+                insert.push(statement);
+            }
+        };
+        const addAll = (statements) => {
+            for (const statement of statements) {
+                add(statement);
+            }
+        };
         // INSERT data
         for (const obj of this.reg.getObjects()) {
             if (options?.populateTables?.tadir !== false) {
-                insert.push(populateTables.insertTADIR(obj));
+                add(populateTables.insertTADIR(obj));
             }
             if (obj instanceof abaplint.Objects.MessageClass) {
-                insert.push(...populateTables.insertT100(obj));
+                addAll(populateTables.insertT100(obj));
             }
             else if (options?.populateTables?.wwwparams !== false
                 && obj instanceof abaplint.Objects.WebMIME) {
-                insert.push(...populateTables.insertWWWPARAMS(obj));
+                addAll(populateTables.insertWWWPARAMS(obj));
             }
             else if (obj instanceof abaplint.Objects.Class
                 || obj instanceof abaplint.Objects.Interface
                 || obj instanceof abaplint.Objects.Program) {
                 if (options?.populateTables?.reposrc !== false) {
-                    insert.push(populateTables.insertREPOSRC(obj));
+                    add(populateTables.insertREPOSRC(obj));
                 }
                 if ((obj instanceof abaplint.Objects.Class || obj instanceof abaplint.Objects.Interface)
                     && options?.populateTables?.seosubco !== false) {
-                    insert.push(...populateTables.insertSEOSUBCO(obj));
+                    addAll(populateTables.insertSEOSUBCO(obj));
                 }
                 if ((obj instanceof abaplint.Objects.Class || obj instanceof abaplint.Objects.Interface)
                     && options?.populateTables?.seosubcodf !== false) {
-                    insert.push(...populateTables.insertSEOSUBCODF(obj));
+                    addAll(populateTables.insertSEOSUBCODF(obj));
                 }
                 if ((obj instanceof abaplint.Objects.Class || obj instanceof abaplint.Objects.Interface)
                     && options?.populateTables?.seosubcotx !== false) {
-                    insert.push(...populateTables.insertSEOSUBCOTX(obj));
+                    addAll(populateTables.insertSEOSUBCOTX(obj));
                 }
             }
         }
-        insert.push(populateTables.insertT000());
+        add(populateTables.insertT000());
         return insert;
     }
 }

package/build/src/index.js

@@ -72,11 +72,13 @@ class Transpiler {
     // workaround for web/webpack
     async runRaw(files) {
         const memory = files.map(f => new abaplint.MemoryFile(f.filename, f.contents));
-        const reg = new abaplint.Registry().addFiles(memory).parse();
-        return new Transpiler().run(reg);
+        const reg = new abaplint.Registry().addFiles(memory);
+        return this.run(reg);
     }
     async run(reg, progress) {
-        reg.parse();
+        // Validation installs the transpiler configuration and findIssues() parses
+        // dirty registries. Parsing before that would be wasted because setConfig()
+        // marks every registry object dirty again.
         this.validate(reg);
         const dbSetup = new db_1.DatabaseSetup(reg).run(this.options);
         this.plugin?.amendDatabaseSetup?.(dbSetup, reg, this.options || {});

package/build/src/statements/assign.js

@@ -97,7 +97,14 @@ class AssignTranspiler {
         }
         else {
             let dynamicName = "";
-            for (const c of assignSource?.getChildren() || []) {
+            const first = assignSource?.getFirstChild();
+            // dynamicSource below already contains the first source expression.
+            // Keep only the dynamic suffix in dynamicName, otherwise structure
+            // components in that expression are resolved a second time at runtime.
+            const dynamicNameChildren = first?.get() instanceof abaplint.Expressions.Source
+                ? assignSource?.getChildren().slice(1)
+                : assignSource?.getChildren();
+            for (const c of dynamicNameChildren || []) {
                 if (c instanceof abaplint.Nodes.ExpressionNode
                     && c.get() instanceof abaplint.Expressions.Dynamic
                     && c.findFirstExpression(abaplint.Expressions.ConstantString)) {
@@ -118,7 +125,10 @@ class AssignTranspiler {
                     continue;
                 }
                 else if (c.concatTokens() === "=>" || c.concatTokens() === "->") {
-                    dynamicName += " + '" + c.concatTokens() + "'";
+                    if (dynamicName !== "") {
+                        dynamicName += " + ";
+                    }
+                    dynamicName += "'" + c.concatTokens() + "'";
                 }
                 else {
                     if (dynamicName !== "") {
@@ -129,7 +139,6 @@ class AssignTranspiler {
             }
             options.push(`dynamicName: ` + dynamicName);
             // dynamicSource is the first part of the dynamic part
-            const first = assignSource?.getFirstChild();
             if (first?.get() instanceof abaplint.Expressions.Dynamic && first instanceof abaplint.Nodes.ExpressionNode) {
                 const firstFirst = first.getChildren()[1];
                 if (firstFirst?.get() instanceof abaplint.Expressions.Constant) {

package/build/src/statements/open_cursor.js

@@ -37,6 +37,7 @@ exports.OpenCursorTranspiler = void 0;
 const abaplint = __importStar(require("@abaplint/core"));
 const chunk_1 = require("../chunk");
 const insert_database_1 = require("./insert_database");
+const expressions_1 = require("../expressions");
 class OpenCursorTranspiler {
     transpile(node, traversal) {
         const target = traversal.traverse(node.findDirectExpression(abaplint.Expressions.SQLTarget)).getCode();
@@ -46,11 +47,21 @@ class OpenCursorTranspiler {
         select += traversal.traverse(selectExpression?.findDirectExpression(abaplint.Expressions.SQLFrom)).getCode();
         const cond = selectExpression?.findDirectExpression(abaplint.Expressions.SQLCond);
         if (cond) {
-            select += "WHERE " + traversal.traverse(node).getCode();
+            select += "WHERE " + new expressions_1.SQLCondTranspiler().transpile(cond, traversal).getCode() + " ";
+        }
+        const upTo = selectExpression?.findDirectExpression(abaplint.Expressions.SQLUpTo);
+        if (upTo) {
+            const source = upTo.findFirstExpression(abaplint.Expressions.SimpleSource3);
+            if (source) {
+                select += `UP TO " + ${new expressions_1.SourceTranspiler(true).transpile(source, traversal).getCode()} + " ROWS `;
+            }
+            else {
+                select += upTo.concatTokens() + " ";
+            }
         }
         const orderBy = selectExpression?.findDirectExpression(abaplint.Expressions.SQLOrderBy);
         if (orderBy) {
-            select += "ORDER BY " + traversal.traverse(node).getCode();
+            select += "ORDER BY " + new expressions_1.SQLOrderByTranspiler().transpile(orderBy, traversal).getCode();
         }
         const options = [];
         const connection = node.findDirectExpression(abaplint.Expressions.DatabaseConnection);

package/build/src/traversal.d.ts

@@ -7,9 +7,14 @@ export declare class Traversal {
     private readonly obj;
     private sqlInferredType;
     private readonly doOrWhileIndexBackups;
+    private readonly statementsInsideLoop;
+    private readonly enclosingDoOrWhile;
     readonly reg: abaplint.IRegistry;
     readonly options: ITranspilerOptions | undefined;
     constructor(spaghetti: abaplint.ISpaghettiScope, file: abaplint.ABAPFile, obj: abaplint.ABAPObject, reg: abaplint.IRegistry, options?: ITranspilerOptions);
+    /** Build file-level control-flow context once instead of rescanning all
+     * preceding statements for every DATA, CHECK, EXIT, and RETURN. */
+    private buildStatementContext;
     static escapeNamespace(name: string | undefined): string | undefined;
     /** the self reference "me", it is a FieldChain in eg. MethodCallChain and a SourceField in eg. MethodSource */
     static isMe(node: abaplint.Nodes.ExpressionNode | abaplint.Nodes.TokenNode | abaplint.Nodes.StructureNode): boolean;
@@ -19,6 +24,7 @@ export declare class Traversal {
     getFilename(): string;
     getFile(): abaplint.ABAPFile;
     getSpaghetti(): abaplint.ISpaghettiScope;
+    isSourceMapEnabled(): boolean;
     /** finds a statement in the _current_ file given a position */
     findStatementInFile(pos: abaplint.Position): abaplint.Nodes.StatementNode | undefined;
     private scopeCache;

package/build/src/traversal.js

@@ -48,6 +48,8 @@ class Traversal {
     obj;
     sqlInferredType;
     doOrWhileIndexBackups = new Map();
+    statementsInsideLoop = new WeakSet();
+    enclosingDoOrWhile = new WeakMap();
     reg;
     options;
     constructor(spaghetti, file, obj, reg, options) {
@@ -56,6 +58,43 @@ class Traversal {
         this.obj = obj;
         this.reg = reg;
         this.options = options;
+        this.buildStatementContext();
+    }
+    /** Build file-level control-flow context once instead of rescanning all
+     * preceding statements for every DATA, CHECK, EXIT, and RETURN. */
+    buildStatementContext() {
+        const loopStack = [];
+        const doOrWhileStack = [];
+        for (const statement of this.file.getStatements()) {
+            const get = statement.get();
+            if (get instanceof abaplint.Statements.Loop
+                || get instanceof abaplint.Statements.While
+                || get instanceof abaplint.Statements.SelectLoop
+                || get instanceof abaplint.Statements.Do) {
+                loopStack.push(statement);
+            }
+            else if (get instanceof abaplint.Statements.EndLoop
+                || get instanceof abaplint.Statements.EndWhile
+                || get instanceof abaplint.Statements.EndSelect
+                || get instanceof abaplint.Statements.EndDo) {
+                loopStack.pop();
+            }
+            if (loopStack.length > 0) {
+                this.statementsInsideLoop.add(statement);
+            }
+            if (get instanceof abaplint.Statements.While
+                || get instanceof abaplint.Statements.Do) {
+                doOrWhileStack.push(statement);
+            }
+            else if (get instanceof abaplint.Statements.EndWhile
+                || get instanceof abaplint.Statements.EndDo) {
+                doOrWhileStack.pop();
+            }
+            const enclosing = doOrWhileStack[doOrWhileStack.length - 1];
+            if (enclosing !== undefined) {
+                this.enclosingDoOrWhile.set(statement, enclosing);
+            }
+        }
     }
     static escapeNamespace(name) {
         return name?.replace(/\//g, "$");
@@ -102,6 +141,9 @@ class Traversal {
     getSpaghetti() {
         return this.spaghetti;
     }
+    isSourceMapEnabled() {
+        return this.options?.ignoreSourceMap !== true;
+    }
     /** finds a statement in the _current_ file given a position */
     findStatementInFile(pos) {
         for (const s of this.file.getStatements()) {
@@ -564,9 +606,16 @@ class Traversal {
         return ret;
     }
     buildFriendsAccess(def, hasSuperClass) {
-        let ret = "this.FRIENDS_ACCESS_INSTANCE = {\n";
+        let ret = "";
         if (hasSuperClass === true) {
-            ret += `"SUPER": sup.FRIENDS_ACCESS_INSTANCE,\n`;
+            // A subclass instance can be held through a superclass reference. In
+            // that case friend access must still find private members declared by
+            // the superclass.
+            ret += "this.FRIENDS_ACCESS_INSTANCE = Object.create(sup.FRIENDS_ACCESS_INSTANCE || null);\n";
+            ret += `this.FRIENDS_ACCESS_INSTANCE["SUPER"] = sup.FRIENDS_ACCESS_INSTANCE;\n`;
+        }
+        else {
+            ret += "this.FRIENDS_ACCESS_INSTANCE = {\n";
         }
         for (const method of def.getMethodDefinitions()?.getAll() || []) {
             const name = method.getName().toLowerCase();
@@ -579,9 +628,16 @@ class Traversal {
             }
             const methodName = privateHash + Traversal.escapeNamespace(name.replace("~", "$"));
             // NOTE: currently all are needed in the unit test setup
-            ret += `"${name.replace("~", "$")}": this.${methodName}.bind(this),\n`;
+            if (hasSuperClass === true) {
+                ret += `this.FRIENDS_ACCESS_INSTANCE["${name.replace("~", "$")}"] = this.${methodName}.bind(this);\n`;
+            }
+            else {
+                ret += `"${name.replace("~", "$")}": this.${methodName}.bind(this),\n`;
+            }
+        }
+        if (hasSuperClass === false) {
+            ret += "};\n";
         }
-        ret += "};\n";
         return ret;
     }
     buildConstructorContents(scope, def) {
@@ -820,26 +876,7 @@ this.INTERNAL_ID = abap.internalIdCounter++;\n`;
         return context;
     }
     isInsideLoop(node) {
-        const stack = [];
-        for (const statement of this.getFile().getStatements()) {
-            const get = statement.get();
-            if (get instanceof abaplint.Statements.Loop
-                || get instanceof abaplint.Statements.While
-                || get instanceof abaplint.Statements.SelectLoop
-                || get instanceof abaplint.Statements.Do) {
-                stack.push(statement);
-            }
-            else if (get instanceof abaplint.Statements.EndLoop
-                || get instanceof abaplint.Statements.EndWhile
-                || get instanceof abaplint.Statements.EndSelect
-                || get instanceof abaplint.Statements.EndDo) {
-                stack.pop();
-            }
-            if (statement === node) {
-                break;
-            }
-        }
-        return stack.length > 0;
+        return this.statementsInsideLoop.has(node);
     }
     isInsideDoOrWhile(node) {
         return this.findCurrentDoOrWhileIndexBackup(node) !== undefined;
@@ -848,22 +885,8 @@ this.INTERNAL_ID = abap.internalIdCounter++;\n`;
         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(this.doOrWhileIndexBackups.get(statement));
-            }
-            else if (get instanceof abaplint.Statements.EndWhile
-                || get instanceof abaplint.Statements.EndDo) {
-                stack.pop();
-            }
-            if (statement === node) {
-                break;
-            }
-        }
-        return stack[stack.length - 1];
+        const enclosing = this.enclosingDoOrWhile.get(node);
+        return enclosing === undefined ? undefined : this.doOrWhileIndexBackups.get(enclosing);
     }
     registerClassOrInterface(def) {
         if (def === undefined) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.13.64",
+  "version": "2.13.66",
   "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.37",
+    "@abaplint/core": "^2.120.42",
     "source-map": "^0.7.6"
   },
   "devDependencies": {