@abaplint/core 2.119.59 → 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/1_lexer/lexer.js

@@ -12,6 +12,37 @@ const ModeStr = 3;
 const ModeTemplate = 4;
 const ModeComment = 5;
 const ModePragma = 6;
+// character codes, used for integer comparisons in the hot loop
+const EOF = -1; // no character (start/end of file)
+const CH_TAB = 9; // "\t"
+const CH_NL = 10; // "\n"
+const CH_SPACE = 32; // " "
+const CH_DQUOTE = 34; // "\""
+const CH_HASH = 35; // "#"
+const CH_QUOTE = 39; // "'"
+const CH_STAR = 42; // "*"
+const CH_DASH = 45; // "-"
+const CH_COMMA = 44; // ","
+const CH_DOT = 46; // "."
+const CH_COLON = 58; // ":"
+const CH_EQUALS = 61; // "="
+const CH_GT = 62; // ">"
+const CH_AT = 64; // "@"
+const CH_BACKSLASH = 92; // "\\"
+const CH_BACKTICK = 96; // "`"
+const CH_LBRACE = 123; // "{"
+const CH_PIPE = 124; // "|"
+const CH_RBRACE = 125; // "}"
+// characters that terminate the current token
+const SPLITS = new Set([
+    CH_SPACE, CH_COLON, CH_DOT, CH_COMMA, CH_DASH, 43 /* + */, 40 /* ( */,
+    41 /* ) */, 91 /* [ */, 93 /* ] */, CH_BACKSLASH, CH_TAB, CH_NL
+]);
+// single characters that are emitted as their own token
+const BUFS = new Set([
+    CH_DOT, CH_COMMA, CH_COLON, 40 /* ( */, 41 /* ) */, 91 /* [ */,
+    93 /* ] */, 43 /* + */, CH_AT
+]);
 class Lexer {
     run(file, virtual) {
         this.virtual = virtual;
@@ -26,15 +57,17 @@ class Lexer {
             const col = this.stream.getCol();
             const row = this.stream.getRow();
             let whiteBefore = false;
-            if (this.stream.getOffset() - s.length >= 0) {
-                const prev = this.stream.getRaw().substr(this.stream.getOffset() - s.length, 1);
-                if (prev === " " || prev === "\n" || prev === "\t" || prev === ":") {
+            const beforeOffset = this.stream.getOffset() - s.length;
+            if (beforeOffset >= 0) {
+                const prev = this.stream.charCodeAt(beforeOffset);
+                if (prev === CH_SPACE || prev === CH_NL || prev === CH_TAB || prev === CH_COLON) {
                     whiteBefore = true;
                 }
             }
             let whiteAfter = false;
             const next = this.stream.nextChar();
-            if (next === " " || next === "\n" || next === "\t" || next === ":" || next === "," || next === "." || next === "" || next === "\"") {
+            if (next === CH_SPACE || next === CH_NL || next === CH_TAB || next === CH_COLON
+                || next === CH_COMMA || next === CH_DOT || next === EOF || next === CH_DQUOTE) {
                 whiteAfter = true;
             }
             let pos = new position_1.Position(row, col - s.length);
@@ -204,10 +237,10 @@ class Lexer {
                 }
             }
             if (tok === undefined && this.m === ModeNormal && s.charAt(0) === "\\") {
-                const adj = this.stream.nextChar() === "" ? 1 : 0;
+                const adj = this.stream.nextChar() === EOF ? 1 : 0;
                 const prevOffset = this.stream.getOffset() - s.length - adj;
-                const prevChar = prevOffset >= 0 ? this.stream.getRaw().substr(prevOffset, 1) : "";
-                const whiteBeforeBackslash = prevChar === " " || prevChar === "\n" || prevChar === "\t" || prevChar === ":";
+                const prevChar = this.stream.charCodeAt(prevOffset);
+                const whiteBeforeBackslash = prevChar === CH_SPACE || prevChar === CH_NL || prevChar === CH_TAB || prevChar === CH_COLON;
                 if (!whiteBeforeBackslash) {
                     tok = new tokens_1.AssociationName(pos, s);
                 }
@@ -220,100 +253,77 @@ class Lexer {
         this.buffer.clear();
     }
     process(raw) {
-        this.stream = new lexer_stream_1.LexerStream(raw.replace(/\r/g, ""));
-        this.buffer = new lexer_buffer_1.LexerBuffer();
-        const splits = {};
-        splits[" "] = true;
-        splits[":"] = true;
-        splits["."] = true;
-        splits[","] = true;
-        splits["-"] = true;
-        splits["+"] = true;
-        splits["("] = true;
-        splits[")"] = true;
-        splits["["] = true;
-        splits["]"] = true;
-        splits["\\"] = true;
-        splits["\t"] = true;
-        splits["\n"] = true;
-        const bufs = {};
-        bufs["."] = true;
-        bufs[","] = true;
-        bufs[":"] = true;
-        bufs["("] = true;
-        bufs[")"] = true;
-        bufs["["] = true;
-        bufs["]"] = true;
-        bufs["+"] = true;
-        bufs["@"] = true;
+        const stream = new lexer_stream_1.LexerStream(raw.replace(/\r/g, ""));
+        this.stream = stream;
+        this.buffer = new lexer_buffer_1.LexerBuffer(stream.getRaw());
         for (;;) {
-            const current = this.stream.currentChar();
-            const buf = this.buffer.add(current);
-            const ahead = this.stream.nextChar();
-            const aahead = this.stream.nextNextChar();
+            const current = stream.currentChar();
+            this.buffer.add(stream.getOffset());
+            const ahead = stream.nextChar();
+            const aahead = stream.nextNextChar();
             if (this.m === ModeNormal) {
-                if (splits[ahead]) {
+                if (SPLITS.has(ahead)) {
                     this.add();
                 }
-                else if (ahead === "'") {
+                else if (ahead === CH_QUOTE) {
                     // start string
                     this.add();
                     this.m = ModeStr;
                 }
-                else if (ahead === "|" || ahead === "}") {
+                else if (ahead === CH_PIPE || ahead === CH_RBRACE) {
                     // start template
                     this.add();
                     this.m = ModeTemplate;
                 }
-                else if (ahead === "`") {
+                else if (ahead === CH_BACKTICK) {
                     // start ping
                     this.add();
                     this.m = ModePing;
                 }
-                else if (aahead === "##") {
+                else if (ahead === CH_HASH && aahead === CH_HASH) {
                     // start pragma
                     this.add();
                     this.m = ModePragma;
                 }
-                else if (ahead === "\""
-                    || (ahead === "*" && current === "\n")) {
+                else if (ahead === CH_DQUOTE
+                    || (ahead === CH_STAR && current === CH_NL)) {
                     // start comment
                     this.add();
                     this.m = ModeComment;
                 }
-                else if (ahead === "@" && buf.trim().length === 0) {
+                else if (ahead === CH_AT && this.buffer.get().trim().length === 0) {
                     this.add();
                 }
-                else if (aahead === "->"
-                    || aahead === "=>") {
+                else if ((ahead === CH_DASH || ahead === CH_EQUALS) && aahead === CH_GT) {
                     this.add();
                 }
-                else if (current === ">"
-                    && ahead !== " "
-                    && (this.stream.prevChar() === "-" || this.stream.prevChar() === "=")) {
+                else if (current === CH_GT
+                    && ahead !== CH_SPACE
+                    && (stream.prevChar() === CH_DASH || stream.prevChar() === CH_EQUALS)) {
                     // arrows
                     this.add();
                 }
-                else if (buf.length === 1
-                    && (bufs[buf]
-                        || (buf === "-" && ahead !== ">"))) {
+                else if (this.buffer.length() === 1
+                    && (BUFS.has(current)
+                        || (current === CH_DASH && ahead !== CH_GT))) {
                     this.add();
                 }
             }
-            else if (this.m === ModePragma && (ahead === "," || ahead === ":" || ahead === "." || ahead === " " || ahead === "\n")) {
+            else if (this.m === ModePragma && (ahead === CH_COMMA || ahead === CH_COLON
+                || ahead === CH_DOT || ahead === CH_SPACE || ahead === CH_NL)) {
                 // end of pragma
                 this.add();
                 this.m = ModeNormal;
             }
             else if (this.m === ModePing
-                && buf.length > 1
-                && current === "`"
-                && aahead !== "``"
-                && ahead !== "`"
-                && this.buffer.countIsEven("`")) {
+                && this.buffer.length() > 1
+                && current === CH_BACKTICK
+                && !(ahead === CH_BACKTICK && aahead === CH_BACKTICK)
+                && ahead !== CH_BACKTICK
+                && this.buffer.countIsEven(CH_BACKTICK)) {
                 // end of ping
                 this.add();
-                if (ahead === `"`) {
+                if (ahead === CH_DQUOTE) {
                     this.m = ModeComment;
                 }
                 else {
@@ -321,41 +331,41 @@ class Lexer {
                 }
             }
             else if (this.m === ModeTemplate
-                && buf.length > 1
-                && (current === "|" || current === "{")
-                && (this.stream.prevChar() !== "\\" || this.stream.prevPrevChar() === "\\\\")) {
+                && this.buffer.length() > 1
+                && (current === CH_PIPE || current === CH_LBRACE)
+                && (stream.prevChar() !== CH_BACKSLASH || (stream.prevPrevChar() === CH_BACKSLASH && stream.prevChar() === CH_BACKSLASH))) {
                 // end of template
                 this.add();
                 this.m = ModeNormal;
             }
             else if (this.m === ModeTemplate
-                && ahead === "}"
-                && current !== "\\") {
+                && ahead === CH_RBRACE
+                && current !== CH_BACKSLASH) {
                 this.add();
             }
             else if (this.m === ModeStr
-                && current === "'"
-                && buf.length > 1
-                && aahead !== "''"
-                && ahead !== "'"
-                && this.buffer.countIsEven("'")) {
+                && current === CH_QUOTE
+                && this.buffer.length() > 1
+                && !(ahead === CH_QUOTE && aahead === CH_QUOTE)
+                && ahead !== CH_QUOTE
+                && this.buffer.countIsEven(CH_QUOTE)) {
                 // end of string
                 this.add();
-                if (ahead === "\"") {
+                if (ahead === CH_DQUOTE) {
                     this.m = ModeComment;
                 }
                 else {
                     this.m = ModeNormal;
                 }
             }
-            else if (ahead === "\n" && this.m !== ModeTemplate) {
+            else if (ahead === CH_NL && this.m !== ModeTemplate) {
                 this.add();
                 this.m = ModeNormal;
             }
-            else if (this.m === ModeTemplate && current === "\n") {
+            else if (this.m === ModeTemplate && current === CH_NL) {
                 this.add();
             }
-            if (!this.stream.advance()) {
+            if (!stream.advance()) {
                 break;
             }
         }

package/build/src/abap/1_lexer/lexer_buffer.js

@@ -1,24 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LexerBuffer = void 0;
+// The buffer holds a reference to the raw input and tracks the [start, end)
+// offset range of the current token, so the token string can be sliced out with
+// a single substring() instead of being concatenated one character at a time.
 class LexerBuffer {
-    constructor() {
-        this.buf = "";
+    constructor(raw) {
+        this.raw = raw;
+        this.start = 0;
+        this.end = 0;
+        this.empty = true;
     }
-    add(s) {
-        this.buf = this.buf + s;
-        return this.buf;
+    add(offset) {
+        if (this.empty === true) {
+            this.start = offset < 0 ? 0 : offset;
+            this.empty = false;
+        }
+        this.end = offset + 1;
     }
     get() {
-        return this.buf;
+        return this.raw.substring(this.start, this.end);
+    }
+    length() {
+        return this.end - this.start;
     }
     clear() {
-        this.buf = "";
+        this.start = 0;
+        this.end = 0;
+        this.empty = true;
     }
     countIsEven(char) {
         let count = 0;
-        for (let i = 0; i < this.buf.length; i += 1) {
-            if (this.buf.charAt(i) === char) {
+        for (let i = this.start; i < this.end; i += 1) {
+            if (this.raw.charCodeAt(i) === char) {
                 count += 1;
             }
         }

package/build/src/abap/1_lexer/lexer_stream.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LexerStream = void 0;
+const NL = 10; // "\n"
+const EOF = -1; // no character (start/end of file)
 class LexerStream {
     constructor(raw) {
         this.offset = -1;
@@ -9,7 +11,7 @@ class LexerStream {
         this.col = 0;
     }
     advance() {
-        if (this.currentChar() === "\n") {
+        if (this.currentChar() === NL) {
             this.col = 1;
             this.row = this.row + 1;
         }
@@ -27,38 +29,51 @@ class LexerStream {
     getRow() {
         return this.row;
     }
+    // the *Char() accessors return character codes (charCodeAt) rather than
+    // single character strings, to avoid allocating a string per input character
+    // in the lexer hot loop. EOF (-1) is returned when the offset is out of range.
     prevChar() {
-        if (this.offset - 1 < 0) {
-            return "";
+        const o = this.offset - 1;
+        if (o < 0) {
+            return EOF;
         }
-        return this.raw.substr(this.offset - 1, 1);
+        return this.raw.charCodeAt(o);
     }
     prevPrevChar() {
-        if (this.offset - 2 < 0) {
-            return "";
+        const o = this.offset - 2;
+        if (o < 0) {
+            return EOF;
         }
-        return this.raw.substr(this.offset - 2, 2);
+        return this.raw.charCodeAt(o);
     }
     currentChar() {
         if (this.offset < 0) {
-            return "\n"; // simulate newline at start of file to handle star(*) comments
+            return NL; // simulate newline at start of file to handle star(*) comments
         }
         else if (this.offset >= this.raw.length) {
-            return "";
+            return EOF;
         }
-        return this.raw.substr(this.offset, 1);
+        return this.raw.charCodeAt(this.offset);
     }
     nextChar() {
-        if (this.offset + 2 > this.raw.length) {
-            return "";
+        const o = this.offset + 1;
+        if (o >= this.raw.length) {
+            return EOF;
         }
-        return this.raw.substr(this.offset + 1, 1);
+        return this.raw.charCodeAt(o);
     }
     nextNextChar() {
-        if (this.offset + 3 > this.raw.length) {
-            return this.nextChar();
+        const o = this.offset + 2;
+        if (o >= this.raw.length) {
+            return EOF;
         }
-        return this.raw.substr(this.offset + 1, 2);
+        return this.raw.charCodeAt(o);
+    }
+    charCodeAt(o) {
+        if (o < 0 || o >= this.raw.length) {
+            return EOF;
+        }
+        return this.raw.charCodeAt(o);
     }
     getRaw() {
         return this.raw;

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

@@ -123,8 +123,9 @@ class Word {
     }
 }
 class Token {
-    constructor(s) {
-        this.name = s;
+    constructor(t) {
+        this.tokenType = t;
+        this.name = t.name;
     }
     listKeywords() {
         return [];
@@ -136,7 +137,7 @@ class Token {
         const result = [];
         for (const input of r) {
             if (input.remainingLength() !== 0
-                && input.peek().constructor.name === this.name) {
+                && input.peek().constructor === this.tokenType) {
                 result.push(input.shift(new nodes_1.TokenNode(input.peek())));
             }
         }
@@ -332,7 +333,12 @@ class Optional {
         for (const input of r) {
             result.push(input);
             const res = this.optional.run([input]);
-            result.push(...res);
+            if (res.length === 1) {
+                result.push(res[0]);
+            }
+            else {
+                result.push(...res);
+            }
         }
         return result;
     }
@@ -371,6 +377,9 @@ class Star {
                     // avoid stack overflow
                     result = result.concat(res);
                 }
+                else if (res.length === 1) {
+                    result.push(res[0]);
+                }
                 else {
                     result.push(...res);
                 }
@@ -522,6 +531,9 @@ class Sequence {
                     // avoid stack overflow
                     result = result.concat(temp);
                 }
+                else if (temp.length === 1) {
+                    result.push(temp[0]);
+                }
                 else {
                     result.push(...temp);
                 }
@@ -587,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);
@@ -746,7 +748,12 @@ class Alternative {
         const result = [];
         for (const sequ of this.list) {
             const temp = sequ.run(r);
-            result.push(...temp);
+            if (temp.length === 1) {
+                result.push(temp[0]);
+            }
+            else {
+                result.push(...temp);
+            }
         }
         return result;
     }
@@ -804,7 +811,12 @@ class AlternativePriority {
             //      console.log(seq.toStr());
             const temp = sequ.run(r);
             if (temp.length > 0) {
-                result.push(...temp);
+                if (temp.length === 1) {
+                    result.push(temp[0]);
+                }
+                else {
+                    result.push(...temp);
+                }
                 break;
             }
         }
@@ -920,7 +932,7 @@ function regex(r) {
     return new Regex(r);
 }
 function tok(t) {
-    return new Token(t.name);
+    return new Token(t);
 }
 const expressionSingletons = {};
 const stringSingletons = {};

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.59";
+        return "2.119.61";
     }
     getDDICReferences() {
         return this.ddicReferences;

package/build/src/rules/dangerous_statement.js

@@ -59,6 +59,7 @@ class DangerousStatementConf extends _basic_rule_config_1.BasicRuleConfig {
         this.insertTextpool = true;
         this.deleteDynpro = true;
         this.exportDynpro = true;
+        this.editorCallForReport = true;
         /** Finds instances of dynamic SQL: SELECT, UPDATE, DELETE, INSERT, MODIFY */
         this.dynamicSQL = true;
         /** Ignore dynamic SQL in IF_RAP_QUERY_PROVIDER~SELECT implementations */
@@ -143,6 +144,11 @@ dynamic SQL can potentially create SQL injection problems`,
             else if (this.conf.exportDynpro && statement instanceof Statements.ExportDynpro) {
                 message = "EXPORT DYNPRO";
             }
+            else if (this.conf.editorCallForReport
+                && statement instanceof Statements.EditorCall
+                && statementNode.findDirectTokenByText("REPORT")) {
+                message = "EDITOR-CALL FOR REPORT";
+            }
             if (message) {
                 issues.push(issue_1.Issue.atStatement(file, statementNode, this.getDescription(message), this.getMetadata().key, this.conf.severity));
             }

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.59",
+    "version": "2.119.61",
     "description": "abaplint - Core API",
     "main": "build/src/index.js",
     "typings": "build/abaplint.d.ts",