@abaplint/core 2.120.73 → 2.120.75

package/build/abaplint.d.ts

@@ -1723,6 +1723,8 @@ declare class DataControl extends AbstractObject {
 declare class DataDefinition extends AbstractObject {
     private parserError;
     private parsedData;
+    private typeCache;
+    private typeCacheData;
     getType(): string;
     getAllowedNaming(): {
         maxLength: number;
@@ -2036,7 +2038,8 @@ declare class Domain extends AbstractObject {
     };
     getIdentifier(): Identifier | undefined;
     setDirty(): void;
-    parseType(reg: IRegistry, dataElement?: string, description?: string): AbstractType;
+    parseType(reg: IRegistry): AbstractType;
+    parseDomainType(reg: IRegistry, dataElement?: string, description?: string): AbstractType;
     parse(): {
         updated: boolean;
         runtime: number;
@@ -4770,6 +4773,7 @@ declare class MethodDefinition extends Identifier implements IMethodDefinition {
     private readonly exceptions;
     private readonly className;
     constructor(node: StatementNode, visibility: Visibility, input: SyntaxInput);
+    private checkRaisingParameter;
     getVisibility(): Visibility;
     getClassName(): string;
     isRedefinition(): boolean;
@@ -4860,6 +4864,7 @@ declare class MethodParameters_2 implements IMethodParameters {
     private checkNameLengths;
     private workaroundRAP;
     private add;
+    private checkKeywordNames;
     private isPassByValue;
 }
 

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

@@ -58,6 +58,9 @@ const Tokens = __importStar(require("../1_lexer/tokens"));
 const nodes_1 = require("../nodes");
 const version_1 = require("../../version");
 const result_1 = require("./result");
+// shared result for "nothing matched", frozen so accidental mutation throws instead of leaking between calls.
+// Returned arrays are never mutated by callers, which allows returning shared/input arrays as is
+const EMPTY = Object.freeze([]);
 class Regex {
     constructor(r) {
         this.regexp = r;
@@ -69,17 +72,23 @@ class Regex {
         return [];
     }
     run(r) {
-        const result = [];
+        let result = undefined;
         for (const input of r) {
             if (input.remainingLength() === 0) {
                 continue;
             }
             const token = input.peek();
             if (this.regexp.test(token.getStr()) === true) {
-                result.push(input.shift(new nodes_1.TokenNodeRegex(token)));
+                const shifted = input.shift(new nodes_1.TokenNodeRegex(token));
+                if (result === undefined) {
+                    result = [shifted];
+                }
+                else {
+                    result.push(shifted);
+                }
             }
         }
-        return result;
+        return result !== null && result !== void 0 ? result : EMPTY;
     }
     railroad() {
         return "Railroad.Terminal(\"" + this.regexp.source.replace(/\\/g, "\\\\").replace(/"/g, "\\\"") + "\")";
@@ -102,15 +111,20 @@ class Word {
         return [];
     }
     run(r) {
-        const result = [];
+        let result = undefined;
         for (const input of r) {
             if (input.remainingLength() !== 0
                 && input.peek().getUpperStr() === this.s) {
-                //        console.log("match, " + this.s + result.length);
-                result.push(input.shift(new nodes_1.TokenNode(input.peek())));
+                const shifted = input.shift(new nodes_1.TokenNode(input.peek()));
+                if (result === undefined) {
+                    result = [shifted];
+                }
+                else {
+                    result.push(shifted);
+                }
             }
         }
-        return result;
+        return result !== null && result !== void 0 ? result : EMPTY;
     }
     railroad() {
         return "Railroad.Terminal('\"" + this.s + "\"')";
@@ -134,14 +148,20 @@ class Token {
         return [];
     }
     run(r) {
-        const result = [];
+        let result = undefined;
         for (const input of r) {
             if (input.remainingLength() !== 0
                 && input.peek().constructor === this.tokenType) {
-                result.push(input.shift(new nodes_1.TokenNode(input.peek())));
+                const shifted = input.shift(new nodes_1.TokenNode(input.peek()));
+                if (result === undefined) {
+                    result = [shifted];
+                }
+                else {
+                    result.push(shifted);
+                }
             }
         }
-        return result;
+        return result !== null && result !== void 0 ? result : EMPTY;
     }
     railroad() {
         let text = this.name;
@@ -179,9 +199,9 @@ class Vers {
             if (this.also === AlsoIn.OpenABAP) {
                 return this.runnable.run(r);
             }
-            return (0, version_1.releaseAtLeast)(version_1.Release.v702, this.release) ? this.runnable.run(r) : [];
+            return (0, version_1.releaseAtLeast)(version_1.Release.v702, this.release) ? this.runnable.run(r) : EMPTY;
         }
-        return (0, version_1.releaseAtLeast)(Combi.getRelease(), this.release) ? this.runnable.run(r) : [];
+        return (0, version_1.releaseAtLeast)(Combi.getRelease(), this.release) ? this.runnable.run(r) : EMPTY;
     }
     getUsing() {
         return this.runnable.getUsing();
@@ -229,7 +249,7 @@ class LangVers {
             return this.runnable.run(r);
         }
         else {
-            return [];
+            return EMPTY;
         }
     }
     railroad() {
@@ -262,7 +282,7 @@ class LangVersNot {
             return this.runnable.run(r);
         }
         else {
-            return [];
+            return EMPTY;
         }
     }
     railroad() {
@@ -290,6 +310,22 @@ class OptionalPriority {
         return this.optional.getUsing();
     }
     run(r) {
+        if (r.length === 1) {
+            // single input, pass and return the input array without wrapping
+            const res = this.optional.run(r);
+            if (res.length > 1) {
+                return res;
+            }
+            else if (res.length === 0) {
+                return r;
+            }
+            else if (res[0].remainingLength() < r[0].remainingLength()) {
+                return res;
+            }
+            else {
+                return r;
+            }
+        }
         const result = [];
         for (const input of r) {
             const res = this.optional.run([input]);
@@ -329,6 +365,11 @@ class Optional {
         return this.optional.getUsing();
     }
     run(r) {
+        if (r.length === 1) {
+            // single input, pass and return the input array without wrapping
+            const res = this.optional.run(r);
+            return res.length === 0 ? r : r.concat(res);
+        }
         const result = [];
         for (const input of r) {
             result.push(input);
@@ -366,14 +407,16 @@ class Star {
         let result = r;
         try {
             let res = r;
-            let input = [];
             for (;;) {
-                input = res;
-                res = this.sta.run(input);
+                res = this.sta.run(res);
                 if (res.length === 0) {
                     break;
                 }
-                if (res.length > 1000) {
+                if (result === r) {
+                    // copy on first match, the input array must not be mutated
+                    result = r.concat(res);
+                }
+                else if (res.length > 1000) {
                     // avoid stack overflow
                     result = result.concat(res);
                 }
@@ -515,6 +558,17 @@ class Sequence {
         return this.list.reduce((a, c) => { return a.concat(c.getUsing()); }, []);
     }
     run(r) {
+        if (r.length === 1) {
+            // single input, pass it down without wrapping and return the last result as is
+            let temp = r;
+            for (const sequence of this.list) {
+                temp = sequence.run(temp);
+                if (temp.length === 0) {
+                    return EMPTY;
+                }
+            }
+            return temp;
+        }
         let result = [];
         for (const input of r) {
             let temp = [input];
@@ -592,12 +646,33 @@ class Expression {
         this.runnable = undefined;
     }
     run(r) {
-        const results = [];
         if (this.runnable === undefined) {
             this.runnable = this.getRunnable();
         }
+        if (r.length === 1) {
+            // single input, pass it down without wrapping
+            const input = r[0];
+            const temp = this.runnable.run(r);
+            if (temp.length === 0) {
+                return EMPTY;
+            }
+            const results = new Array(temp.length);
+            for (let i = 0; i < temp.length; i++) {
+                const t = temp[i];
+                const consumed = input.remainingLength() - t.remainingLength();
+                results[i] = consumed > 0 ? t.wrapConsumed(consumed, new nodes_1.ExpressionNode(this)) : t;
+            }
+            return results;
+        }
+        let results = undefined;
         for (const input of r) {
             const temp = this.runnable.run([input]);
+            if (temp.length === 0) {
+                continue;
+            }
+            else if (results === undefined) {
+                results = [];
+            }
             for (const t of temp) {
                 const consumed = input.remainingLength() - t.remainingLength();
                 if (consumed > 0) {
@@ -609,8 +684,7 @@ class Expression {
                 }
             }
         }
-        //    console.dir(results);
-        return results;
+        return results !== null && results !== void 0 ? results : EMPTY;
     }
     listKeywords() {
         // do not recurse, all Expressions are evaluated only on first level
@@ -651,12 +725,16 @@ class Permutation {
         return this.list.reduce((a, c) => { return a.concat(c.getUsing()); }, []);
     }
     run(r) {
-        const result = [];
-        const copy = this.list.slice();
+        let result = undefined;
+        let copy = undefined;
         for (let index = 0; index < this.list.length; index++) {
             const temp = this.list[index].run(r);
             if (temp.length !== 0) {
                 // match
+                if (result === undefined || copy === undefined) {
+                    result = [];
+                    copy = this.list.slice();
+                }
                 result.push(...temp);
                 const left = copy;
                 left.splice(index, 1);
@@ -668,7 +746,7 @@ class Permutation {
                 }
             }
         }
-        return result;
+        return result !== null && result !== void 0 ? result : EMPTY;
     }
     railroad() {
         const children = this.list.map((e) => { return e.railroad(); });
@@ -745,17 +823,31 @@ class Alternative {
         return this.list.reduce((a, c) => { return a.concat(c.getUsing()); }, []);
     }
     run(r) {
-        const result = [];
+        var _a;
+        // only allocate a new array when more than one alternative matches
+        let single = undefined;
+        let result = undefined;
         for (const sequ of this.list) {
             const temp = sequ.run(r);
-            if (temp.length === 1) {
-                result.push(temp[0]);
+            if (temp.length === 0) {
+                continue;
+            }
+            else if (result !== undefined) {
+                if (temp.length === 1) {
+                    result.push(temp[0]);
+                }
+                else {
+                    result.push(...temp);
+                }
+            }
+            else if (single !== undefined) {
+                result = single.concat(temp);
             }
             else {
-                result.push(...temp);
+                single = temp;
             }
         }
-        return result;
+        return (_a = result !== null && result !== void 0 ? result : single) !== null && _a !== void 0 ? _a : EMPTY;
     }
     railroad() {
         const children = this.list.map((e) => { return e.railroad(); });
@@ -806,21 +898,13 @@ class AlternativePriority {
         return this.list.reduce((a, c) => { return a.concat(c.getUsing()); }, []);
     }
     run(r) {
-        const result = [];
         for (const sequ of this.list) {
-            //      console.log(seq.toStr());
             const temp = sequ.run(r);
             if (temp.length > 0) {
-                if (temp.length === 1) {
-                    result.push(temp[0]);
-                }
-                else {
-                    result.push(...temp);
-                }
-                break;
+                return temp;
             }
         }
-        return result;
+        return EMPTY;
     }
     railroad() {
         const children = this.list.map((e) => { return e.railroad(); });
@@ -1026,18 +1110,21 @@ class StopBefore2 {
     getUsing() { return []; }
     run(r) {
         var _a;
-        const result = [];
-        for (const input of r) {
+        // only copy when something is filtered out
+        let result = undefined;
+        for (let i = 0; i < r.length; i++) {
+            const input = r[i];
             const next = input.peek();
-            if (next === undefined) {
-                continue;
-            }
-            if (next.getUpperStr() === this.t1 && ((_a = input.peekAt(1)) === null || _a === void 0 ? void 0 : _a.getUpperStr()) === this.t2) {
+            if (next === undefined
+                || (next.getUpperStr() === this.t1 && ((_a = input.peekAt(1)) === null || _a === void 0 ? void 0 : _a.getUpperStr()) === this.t2)) {
+                if (result === undefined) {
+                    result = r.slice(0, i);
+                }
                 continue;
             }
-            result.push(input);
+            result === null || result === void 0 ? void 0 : result.push(input);
         }
-        return result;
+        return result !== null && result !== void 0 ? result : r;
     }
     railroad() { return "Railroad.Terminal('stopBefore(" + this.t1 + " " + this.t2 + ")')"; }
     toStr() { return "stopBefore(" + this.t1 + "," + this.t2 + ")"; }
@@ -1052,15 +1139,20 @@ class StopBefore1 {
     getUsing() { return []; }
     run(r) {
         var _a;
-        const result = [];
-        for (const input of r) {
+        // only copy when something is filtered out
+        let result = undefined;
+        for (let i = 0; i < r.length; i++) {
+            const input = r[i];
             const next = (_a = input.peek()) === null || _a === void 0 ? void 0 : _a.getUpperStr();
             if (next !== undefined && this.words.includes(next)) {
+                if (result === undefined) {
+                    result = r.slice(0, i);
+                }
                 continue;
             }
-            result.push(input);
+            result === null || result === void 0 ? void 0 : result.push(input);
         }
-        return result;
+        return result !== null && result !== void 0 ? result : r;
     }
     railroad() { return "Railroad.Terminal('stopBefore(" + this.words.join("|") + ")')"; }
     toStr() { return "stopBefore(" + this.words.join(",") + ")"; }

package/build/src/abap/2_statements/expressions/method_param_optional.js

@@ -5,7 +5,9 @@ const combi_1 = require("../combi");
 const _1 = require(".");
 class MethodParamOptional extends combi_1.Expression {
     getRunnable() {
-        return (0, combi_1.seq)(_1.MethodParam, (0, combi_1.optPrio)("OPTIONAL"));
+        // not optPrio, a parameter named "optional" can follow one with a DEFAULT value:
+        // "a TYPE i DEFAULT 5 optional TYPE i"
+        return (0, combi_1.seq)(_1.MethodParam, (0, combi_1.opt)("OPTIONAL"));
     }
 }
 exports.MethodParamOptional = MethodParamOptional;

package/build/src/abap/5_syntax/basic_types.js

@@ -42,6 +42,7 @@ const Types = __importStar(require("../types/basic"));
 const _scope_type_1 = require("./_scope_type");
 const _object_oriented_1 = require("./_object_oriented");
 const class_constant_1 = require("../types/class_constant");
+const class_attribute_1 = require("../types/class_attribute");
 const identifier_1 = require("../1_lexer/tokens/identifier");
 const _reference_1 = require("./_reference");
 const basic_1 = require("../types/basic");
@@ -892,15 +893,18 @@ class BasicTypes {
         const firstName = firstToken.getStr();
         if (firstNode.get() instanceof Expressions.Field) {
             const found = this.input.scope.findVariable(firstName);
-            const val = found === null || found === void 0 ? void 0 : found.getValue();
-            if (typeof val === "string") {
-                this.input.scope.addReference(firstToken, found, _reference_1.ReferenceType.DataReadReference, this.input.filename);
-                return val;
+            if (found === undefined) {
+                const message = `"${firstName}" not found, findTop`;
+                this.input.issues.push((0, _syntax_input_1.syntaxIssue)(this.input, firstToken, message));
+                return undefined;
             }
-            else if ((found === null || found === void 0 ? void 0 : found.getType()) instanceof basic_1.StructureType) {
-                this.input.scope.addReference(firstToken, found, _reference_1.ReferenceType.DataReadReference, this.input.filename);
+            this.input.scope.addReference(firstToken, found, _reference_1.ReferenceType.DataReadReference, this.input.filename);
+            if (this.isConstant(found) === false) {
+                const message = `VALUE, ${expr.concatTokens().toLowerCase()} is not a constant`;
+                this.input.issues.push((0, _syntax_input_1.syntaxIssue)(this.input, firstToken, message));
+                return undefined;
             }
-            return undefined;
+            return this.constantValue(expr, found.getValue());
         }
         else if (firstNode.get() instanceof Expressions.ClassName
             && firstName.toLowerCase() === this.input.scope.getName().toLowerCase()
@@ -909,12 +913,18 @@ class BasicTypes {
             const children = expr.getChildren();
             const token = (_a = children[2]) === null || _a === void 0 ? void 0 : _a.getFirstToken();
             const found = this.input.scope.findVariable(token.getStr());
-            const val = found === null || found === void 0 ? void 0 : found.getValue();
-            if (typeof val === "string") {
-                this.input.scope.addReference(firstToken, found, _reference_1.ReferenceType.DataReadReference, this.input.filename);
-                return val;
+            if (found === undefined) {
+                const message = `"${token.getStr()}" not found, findTop`;
+                this.input.issues.push((0, _syntax_input_1.syntaxIssue)(this.input, token, message));
+                return undefined;
             }
-            return undefined;
+            this.input.scope.addReference(firstToken, found, _reference_1.ReferenceType.DataReadReference, this.input.filename);
+            if (this.isConstant(found) === false) {
+                const message = `VALUE, ${expr.concatTokens().toLowerCase()} is not a constant`;
+                this.input.issues.push((0, _syntax_input_1.syntaxIssue)(this.input, token, message));
+                return undefined;
+            }
+            return this.constantValue(expr, found.getValue());
         }
         else if (firstNode.get() instanceof Expressions.ClassName) {
             const obj = this.input.scope.findObjectDefinition(firstName);
@@ -937,24 +947,58 @@ class BasicTypes {
             if (c instanceof class_constant_1.ClassConstant) {
                 this.input.scope.addReference(firstToken, obj, _reference_1.ReferenceType.ObjectOrientedReference, this.input.filename, { ooName: obj.getName() });
                 this.input.scope.addReference(token, c, _reference_1.ReferenceType.DataReadReference, this.input.filename);
-                const val = c.getValue();
-                if (typeof val === "string") {
-                    return val;
-                }
-                else if (typeof val === "object" && children[4]) {
-                    const name = children[4].getFirstToken().getStr();
-                    if (val[name] !== undefined) {
-                        return val[name];
-                    }
-                }
+                return this.constantValue(expr, c.getValue());
+            }
+            const helper = new _object_oriented_1.ObjectOriented(this.input.scope);
+            const attribute = helper.searchAttributeName(obj, attr);
+            if (attribute) {
+                this.input.scope.addReference(firstToken, obj, _reference_1.ReferenceType.ObjectOrientedReference, this.input.filename, { ooName: obj.getName() });
+                this.input.scope.addReference(token, attribute, _reference_1.ReferenceType.DataReadReference, this.input.filename);
+                const message = `VALUE, ${expr.concatTokens().toLowerCase()} is not a constant`;
+                this.input.issues.push((0, _syntax_input_1.syntaxIssue)(this.input, token, message));
                 return undefined;
             }
-            throw new Error("resolveConstantValue, constant not found " + attr);
+            const message = `Attribute or constant "${attr}" not found in "${obj.getName()}"`;
+            this.input.issues.push((0, _syntax_input_1.syntaxIssue)(this.input, token, message));
+            return undefined;
         }
         else {
             throw new Error("resolveConstantValue, unexpected structure");
         }
     }
+    isConstant(identifier) {
+        if (identifier instanceof class_attribute_1.ClassAttribute) {
+            return false;
+        }
+        const meta = identifier.getMeta();
+        if (meta.includes("read_only" /* IdentifierMeta.ReadOnly */) === false) {
+            return false;
+        }
+        if (meta.includes("static" /* IdentifierMeta.Static */)) {
+            return true;
+        }
+        // Built-in constants and built-in system fields share ReadOnly/BuiltIn metadata.
+        // Only the constants have a value; system fields such as SY-INDEX do not.
+        return meta.includes("built-in" /* IdentifierMeta.BuiltIn */) && identifier.getValue() !== undefined;
+    }
+    constantValue(expr, value) {
+        if (typeof value === "string") {
+            return value;
+        }
+        else if (typeof value === "object" && value !== null) {
+            let current = value;
+            for (const child of expr.getChildren().slice(1)) {
+                if (child instanceof nodes_1.ExpressionNode && child.get() instanceof Expressions.ComponentName) {
+                    if (typeof current !== "object" || current === null) {
+                        return undefined;
+                    }
+                    current = current[child.getFirstToken().getStr()];
+                }
+            }
+            return typeof current === "string" ? current : undefined;
+        }
+        return undefined;
+    }
     resolveTypeRef(chain) {
         var _a;
         if (chain === undefined) {

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

@@ -50,6 +50,12 @@ class Append {
         if (target) {
             targetType = target_1.Target.runSyntax(target, input);
         }
+        // a hashed table has no index, APPEND adds at the end
+        if (targetType instanceof basic_1.TableType && targetType.getAccessType() === basic_1.TableAccessType.hashed) {
+            const message = "Implicit or explicit index operation on hashed table is not possible";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
+        }
         const fsTarget = node.findExpressionAfterToken("ASSIGNING");
         if (fsTarget && fsTarget.get() instanceof Expressions.FSTarget) {
             if (!(targetType instanceof basic_1.TableType) && !(targetType instanceof basic_1.VoidType) && !(targetType instanceof basic_1.UnknownType)) {

package/build/src/abap/types/method_definition.js

@@ -39,6 +39,7 @@ const Expressions = __importStar(require("../2_statements/expressions"));
 const method_parameters_1 = require("./method_parameters");
 const _identifier_1 = require("../4_file_information/_identifier");
 const _reference_1 = require("../5_syntax/_reference");
+const _syntax_input_1 = require("../5_syntax/_syntax_input");
 class MethodDefinition extends _identifier_1.Identifier {
     // todo: final flag
     constructor(node, visibility, input) {
@@ -80,6 +81,7 @@ class MethodDefinition extends _identifier_1.Identifier {
             this.static = true;
         }
         this.raising = [];
+        this.checkRaisingParameter(node, input);
         for (const r of ((_c = node.findDirectExpression(Expressions.MethodDefRaising)) === null || _c === void 0 ? void 0 : _c.findAllExpressions(Expressions.ClassName)) || []) {
             const token = r.getFirstToken();
             const name = token.getStr();
@@ -104,6 +106,26 @@ class MethodDefinition extends _identifier_1.Identifier {
         this.visibility = visibility;
         this.parameters = new method_parameters_1.MethodParameters(node, input, this.abstract);
     }
+    // A system reads a parameter named RAISING as the RAISING addition, measured on 758:
+    // "IMPORTING a TYPE i raising TYPE i" fails with 'Type "TYPE" is unknown'
+    checkRaisingParameter(node, input) {
+        const raising = node.findDirectExpression(Expressions.MethodDefRaising);
+        const first = raising === null || raising === void 0 ? void 0 : raising.getChildren()[1];
+        if (raising === undefined
+            || first === undefined
+            || !(first.get() instanceof Expressions.ClassName)
+            || ["TYPE", "LIKE"].includes(first.getFirstToken().getStr().toUpperCase()) === false) {
+            return;
+        }
+        if (node.findDirectExpression(Expressions.MethodDefImporting) === undefined
+            && node.findDirectExpression(Expressions.MethodDefExporting) === undefined
+            && node.findDirectExpression(Expressions.MethodDefChanging) === undefined) {
+            return;
+        }
+        const token = raising.getFirstToken();
+        const message = "Parameter \"" + token.getStr() + "\" is read as the RAISING addition, rename it or escape it as !" + token.getStr();
+        input.issues.push((0, _syntax_input_1.syntaxIssue)(input, token, message));
+    }
     getVisibility() {
         return this.visibility;
     }