@abaplint/core 2.119.60 → 2.119.61

package/build/abaplint.d.ts

@@ -4405,6 +4405,10 @@ declare interface ISyntaxSettings {
      * @uniqueItems true
      */
     globalConstants?: string[];
+    /** List of names to void in ambigious statements (regex not possible)
+     * @uniqueItems true
+     */
+    ambigiousVoids?: string[];
     /** List of full named global macros (regex not possible)
      * @uniqueItems true
      */
@@ -6403,10 +6407,13 @@ declare class Result {
     private readonly tokens;
     private readonly tokenIndex;
     private nodes;
+    private nodeCount;
     constructor(tokens: readonly Token[], tokenIndex: number, nodes?: (ExpressionNode | TokenNode)[]);
+    private static fromChain;
     peek(): Token;
     peekAt(offset: number): Token | undefined;
     shift(node: ExpressionNode | TokenNode): Result;
+    wrapConsumed(consumedTokens: number, node: ExpressionNode): Result;
     popNode(): ExpressionNode | TokenNode | undefined;
     getNodes(): (ExpressionNode | TokenNode)[];
     setNodes(n: (ExpressionNode | TokenNode)[]): void;

package/build/src/abap/2_statements/combi.js

@@ -599,24 +599,14 @@ class Expression {
         for (const input of r) {
             const temp = this.runnable.run([input]);
             for (const t of temp) {
-                let consumed = input.remainingLength() - t.remainingLength();
+                const consumed = input.remainingLength() - t.remainingLength();
                 if (consumed > 0) {
-                    const originalLength = t.getNodes().length;
-                    const children = [];
-                    while (consumed > 0) {
-                        const sub = t.popNode();
-                        if (sub) {
-                            children.push(sub);
-                            consumed = consumed - sub.countTokens();
-                        }
-                    }
                     const re = new nodes_1.ExpressionNode(this);
-                    re.setChildren(children.reverse());
-                    const n = t.getNodes().slice(0, originalLength - consumed);
-                    n.push(re);
-                    t.setNodes(n);
+                    results.push(t.wrapConsumed(consumed, re));
+                }
+                else {
+                    results.push(t);
                 }
-                results.push(t);
             }
         }
         //    console.dir(results);

package/build/src/abap/2_statements/result.js

@@ -7,11 +7,17 @@ class Result {
         // nodes: matched tokens
         this.tokens = tokens;
         this.tokenIndex = tokenIndex;
-        this.nodes = nodes;
-        if (this.nodes === undefined) {
-            this.nodes = [];
+        this.nodeCount = 0;
+        if (nodes !== undefined) {
+            this.setNodes(nodes);
         }
     }
+    static fromChain(tokens, tokenIndex, nodes, nodeCount) {
+        const ret = new Result(tokens, tokenIndex);
+        ret.nodes = nodes;
+        ret.nodeCount = nodeCount;
+        return ret;
+    }
     peek() {
         return this.tokens[this.tokenIndex];
     }
@@ -19,18 +25,54 @@ class Result {
         return this.tokens[this.tokenIndex + offset];
     }
     shift(node) {
-        const cp = this.nodes.slice();
-        cp.push(node);
-        return new Result(this.tokens, this.tokenIndex + 1, cp);
+        return Result.fromChain(this.tokens, this.tokenIndex + 1, { node, previous: this.nodes }, this.nodeCount + 1);
+    }
+    wrapConsumed(consumedTokens, node) {
+        let current = this.nodes;
+        let currentCount = this.nodeCount;
+        const children = [];
+        while (consumedTokens > 0) {
+            if (current === undefined) {
+                break;
+            }
+            children.push(current.node);
+            consumedTokens = consumedTokens - current.node.countTokens();
+            current = current.previous;
+            currentCount--;
+        }
+        node.setChildren(children.reverse());
+        this.nodes = { node, previous: current };
+        this.nodeCount = currentCount + 1;
+        return this;
     }
     popNode() {
-        return this.nodes.pop();
+        if (this.nodes === undefined) {
+            return undefined;
+        }
+        const ret = this.nodes.node;
+        this.nodes = this.nodes.previous;
+        this.nodeCount--;
+        return ret;
     }
     getNodes() {
-        return this.nodes;
+        const ret = new Array(this.nodeCount);
+        let current = this.nodes;
+        for (let index = this.nodeCount - 1; index >= 0; index--) {
+            if (current === undefined) {
+                break;
+            }
+            ret[index] = current.node;
+            current = current.previous;
+        }
+        return ret;
     }
     setNodes(n) {
-        this.nodes = n;
+        this.nodes = undefined;
+        this.nodeCount = 0;
+        for (const node of n) {
+            this.nodes = { node, previous: this.nodes };
+            this.nodeCount++;
+        }
     }
     getTokens() {
         return this.tokens;

package/build/src/abap/5_syntax/statements/delete_internal.js

@@ -50,18 +50,25 @@ class DeleteInternal {
         let targetType = undefined;
         const target = node.findDirectExpression(Expressions.Target);
         if (target) {
+            const targetName = target.concatTokens();
             let tabl = undefined;
-            const localVariable = input.scope.findVariable(target.concatTokens());
+            const localVariable = input.scope.findVariable(targetName);
             if (localVariable === undefined && node.getChildren().length === 5 && node.getChildren()[2].concatTokens().toUpperCase() === "FROM") {
                 // it might be a database table
-                const found = (_a = input.scope.getDDIC()) === null || _a === void 0 ? void 0 : _a.lookupTableOrView(target.concatTokens());
+                const found = (_a = input.scope.getDDIC()) === null || _a === void 0 ? void 0 : _a.lookupTableOrView(targetName);
                 if ((found === null || found === void 0 ? void 0 : found.object) !== undefined) {
                     tabl = found;
                     input.scope.getDDICReferences().addUsing(input.scope.getParentObj(), { object: tabl.object });
                 }
             }
             if (tabl === undefined) {
-                targetType = target_1.Target.runSyntax(target, input);
+                const ambigiousVoids = input.scope.getRegistry().getConfig().getSyntaxSetttings().ambigiousVoids || [];
+                if (ambigiousVoids.some(name => name.toUpperCase() === targetName.toUpperCase())) {
+                    targetType = basic_1.VoidType.get(targetName);
+                }
+                else {
+                    targetType = target_1.Target.runSyntax(target, input);
+                }
                 if (node.findDirectTokenByText("TABLE") === undefined
                     && node.findDirectTokenByText("ADJACENT") === undefined
                     && (node.findDirectTokenByText("FROM") || node.findDirectTokenByText("INDEX"))

package/build/src/config.js

@@ -78,6 +78,7 @@ class Config {
                 languageVersion: langVer,
                 errorNamespace: "^(Z|Y|LCL\_|TY\_|LIF\_)",
                 globalConstants: [],
+                ambigiousVoids: [],
                 globalMacros: [],
             },
             rules: rules,
@@ -128,6 +129,12 @@ class Config {
             // remove duplicates,
             this.config.syntax.globalConstants = [...new Set(this.config.syntax.globalConstants)];
         }
+        if (this.config.syntax.ambigiousVoids === undefined) {
+            this.config.syntax.ambigiousVoids = [];
+        }
+        else {
+            this.config.syntax.ambigiousVoids = [...new Set(this.config.syntax.ambigiousVoids)];
+        }
         if (this.config.global.skipIncludesWithoutMain === undefined) {
             this.config.global.skipIncludesWithoutMain = false;
         }

package/build/src/registry.js

@@ -75,7 +75,7 @@ class Registry {
     }
     static abaplintVersion() {
         // magic, see build script "version.js"
-        return "2.119.60";
+        return "2.119.61";
     }
     getDDICReferences() {
         return this.ddicReferences;

package/build/src/rules/downport.js

@@ -342,6 +342,7 @@ Make sure to test the downported code, it might not always be completely correct
         const lowConfig = this.lowReg.getConfig().get();
         highConfig.syntax.errorNamespace = lowConfig.syntax.errorNamespace;
         highConfig.syntax.globalConstants = lowConfig.syntax.globalConstants;
+        highConfig.syntax.ambigiousVoids = lowConfig.syntax.ambigiousVoids;
         highConfig.syntax.globalMacros = lowConfig.syntax.globalMacros;
         this.highReg = new registry_1.Registry();
         for (const o of this.lowReg.getObjects()) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abaplint/core",
-    "version": "2.119.60",
+    "version": "2.119.61",
     "description": "abaplint - Core API",
     "main": "build/src/index.js",
     "typings": "build/abaplint.d.ts",