@abaplint/core 2.120.72 → 2.120.74

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;
@@ -4770,6 +4772,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 +4863,7 @@ declare class MethodParameters_2 implements IMethodParameters {
     private checkNameLengths;
     private workaroundRAP;
     private add;
+    private checkKeywordNames;
     private isPassByValue;
 }
 

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/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;
     }

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

@@ -47,6 +47,12 @@ const _reference_1 = require("../5_syntax/_reference");
 const identifier_1 = require("../1_lexer/tokens/identifier");
 const _scope_type_1 = require("../5_syntax/_scope_type");
 const _syntax_input_1 = require("../5_syntax/_syntax_input");
+// the keywords that can follow a parameter in each section, a plain parameter name is read as them
+const KEYWORDS_AFTER = {
+    "IMPORTING": ["PREFERRED", "EXPORTING", "CHANGING", "RETURNING", "RAISING", "EXCEPTIONS"],
+    "EXPORTING": ["CHANGING", "RETURNING", "RAISING", "EXCEPTIONS"],
+    "CHANGING": ["RETURNING", "RAISING", "EXCEPTIONS"],
+};
 // todo:
 // this.exceptions = [];
 // also consider RAISING vs EXCEPTIONS
@@ -291,6 +297,7 @@ class MethodParameters {
     }
     add(target, source, input, meta, abstractMethod) {
         var _a;
+        this.checkKeywordNames(source, input);
         for (const opt of source.findAllExpressions(Expressions.MethodParamOptional)) {
             const p = opt.findDirectExpression(Expressions.MethodParam);
             if (p === undefined) {
@@ -331,6 +338,56 @@ class MethodParameters {
             target.push(method_param_1.MethodParam.runSyntax(param, input, [...meta, ...extraMeta]));
         }
     }
+    // A system reads a plain parameter name as a keyword wherever that keyword can stand, measured on 758:
+    // "val TYPE clike default TYPE i" makes default the DEFAULT addition of val, and then fails
+    // with "Unable to interpret ..." on what follows. "!default" and "VALUE(default)" are names
+    checkKeywordNames(section, input) {
+        var _a;
+        const following = KEYWORDS_AFTER[section.getFirstToken().getStr().toUpperCase()];
+        if (following === undefined) {
+            return;
+        }
+        // undefined: no parameter before in this section, true: the one before has OPTIONAL or DEFAULT
+        let previousHasAddition = undefined;
+        for (const child of section.getChildren()) {
+            if (!(child instanceof nodes_1.ExpressionNode)) {
+                continue;
+            }
+            let param = undefined;
+            let optional = false;
+            if (child.get() instanceof Expressions.MethodParamOptional) {
+                param = child.findDirectExpression(Expressions.MethodParam);
+                optional = child.findDirectTokenByText("OPTIONAL") !== undefined;
+            }
+            else if (child.get() instanceof Expressions.MethodParam) {
+                param = child;
+            }
+            else if (child.get() instanceof Expressions.MethodParamName) {
+                // "TYPE ANY STRUCTURE", not measured, so never reported after it
+                previousHasAddition = true;
+                continue;
+            }
+            if (param === undefined) {
+                continue;
+            }
+            const first = param.getFirstToken();
+            const name = first.getStr().toUpperCase();
+            if (((_a = param.getChildren()[0]) === null || _a === void 0 ? void 0 : _a.get()) instanceof Expressions.MethodParamName) {
+                let readAs = undefined;
+                if (following.includes(name)) {
+                    readAs = "the " + (name === "PREFERRED" ? "PREFERRED PARAMETER" : name) + " addition";
+                }
+                else if ((name === "DEFAULT" || name === "OPTIONAL") && previousHasAddition === false) {
+                    readAs = "the " + name + " addition of the parameter before it";
+                }
+                if (readAs !== undefined) {
+                    const message = "Parameter \"" + first.getStr() + "\" is read as " + readAs + ", rename it or escape it as !" + first.getStr();
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, first, message));
+                }
+            }
+            previousHasAddition = optional || param.findFirstExpression(Expressions.Default) !== undefined;
+        }
+    }
     isPassByValue(param) {
         var _a;
         // "!" is the identifier escape, generated code has eg. "IMPORTING !VALUE(iv_foo)"

package/build/src/objects/data_definition.js

@@ -11,6 +11,8 @@ class DataDefinition extends _abstract_object_1.AbstractObject {
         super(...arguments);
         this.parserError = undefined;
         this.parsedData = undefined;
+        this.typeCache = undefined;
+        this.typeCacheData = undefined;
     }
     getType() {
         return "DDLS";
@@ -38,7 +40,11 @@ class DataDefinition extends _abstract_object_1.AbstractObject {
     }
     parseType(reg) {
         this.parse();
-        return new cds_determine_types_1.CDSDetermineTypes().parseType(reg, this.parsedData, this.getName());
+        if (this.typeCache === undefined || this.typeCacheData !== this.parsedData) {
+            this.typeCacheData = this.parsedData;
+            this.typeCache = new cds_determine_types_1.CDSDetermineTypes().parseType(reg, this.parsedData, this.getName());
+        }
+        return this.typeCache;
     }
     getParsedData() {
         return this.parsedData;
@@ -50,6 +56,8 @@ class DataDefinition extends _abstract_object_1.AbstractObject {
     }
     setDirty() {
         this.parsedData = undefined;
+        this.typeCache = undefined;
+        this.typeCacheData = undefined;
         this.parserError = undefined;
         super.setDirty();
     }

package/build/src/registry.js

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

package/build/src/rules/generic_regex.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenericRegex = exports.GenericRegexConf = void 0;
+const issue_1 = require("../issue");
+const _basic_rule_config_1 = require("./_basic_rule_config");
+const _irule_1 = require("./_irule");
+class GenericRegexConf extends _basic_rule_config_1.BasicRuleConfig {
+    constructor() {
+        super(...arguments);
+        /** List of forbidden regular expressions, case insensitive, checked against each line of every file.
+         * Patterns use JavaScript regex syntax without enclosing slashes or flags.
+         * @uniqueItems true
+         */
+        this.regexes = [];
+    }
+}
+exports.GenericRegexConf = GenericRegexConf;
+class GenericRegex {
+    constructor() {
+        this.conf = new GenericRegexConf();
+        this.regexes = [];
+    }
+    getMetadata() {
+        return {
+            key: "generic_regex",
+            title: "Generic regex",
+            shortDescription: "Report an issue for each match of a configured regular expression.",
+            extendedInformation: `Checks each line of every object file, including comments, strings, and XML.
+Patterns use JavaScript regular expression syntax without enclosing slashes or flags.
+Matching is case insensitive and does not span multiple lines. Each non-overlapping match is reported.
+Use the standard exclude configuration to skip files.
+
+Example configuration: \`{"generic_regex": {"regexes": ["TODO", "BREAK-POINT"]}}\``,
+            tags: [_irule_1.RuleTag.SingleFile],
+        };
+    }
+    getConfig() {
+        return this.conf;
+    }
+    setConfig(conf) {
+        var _a;
+        this.conf = Object.assign(new GenericRegexConf(), conf);
+        this.conf.regexes = (_a = this.conf.regexes) !== null && _a !== void 0 ? _a : [];
+    }
+    initialize(_reg) {
+        this.regexes = this.conf.regexes.map(pattern => {
+            try {
+                return new RegExp(pattern, "gi");
+            }
+            catch (_a) {
+                throw new Error(`generic_regex: Invalid regular expression "${pattern}"`);
+            }
+        });
+        return this;
+    }
+    run(obj) {
+        const issues = [];
+        if (this.regexes.length === 0) {
+            return issues;
+        }
+        for (const file of obj.getFiles()) {
+            const rows = file.getRawRows();
+            for (let row = 0; row < rows.length; row++) {
+                const text = rows[row].replace(/\r$/, "");
+                for (const regex of this.regexes) {
+                    regex.lastIndex = 0;
+                    for (;;) {
+                        const match = regex.exec(text);
+                        if (match === null) {
+                            break;
+                        }
+                        const startCol = match.index + 1;
+                        const message = `Text matches forbidden regular expression "${regex.source}"`;
+                        issues.push(issue_1.Issue.atRowRange(file, row + 1, startCol, startCol + match[0].length, message, this.getMetadata().key, this.conf.severity));
+                        if (match[0].length === 0) {
+                            regex.lastIndex++;
+                        }
+                    }
+                }
+            }
+        }
+        return issues;
+    }
+}
+exports.GenericRegex = GenericRegex;
+//# sourceMappingURL=generic_regex.js.map

package/build/src/rules/index.js

@@ -82,6 +82,7 @@ __exportStar(require("./fully_type_constants"), exports);
 __exportStar(require("./fully_type_itabs"), exports);
 __exportStar(require("./function_module_recommendations"), exports);
 __exportStar(require("./functional_writing"), exports);
+__exportStar(require("./generic_regex"), exports);
 __exportStar(require("./global_class"), exports);
 __exportStar(require("./identical_conditions"), exports);
 __exportStar(require("./identical_contents"), exports);

package/build/src/rules/no_exclamation_escape.js

@@ -7,6 +7,31 @@ const _basic_rule_config_1 = require("./_basic_rule_config");
 const _irule_1 = require("./_irule");
 const edit_helper_1 = require("../edit_helper");
 const tokens_1 = require("../abap/1_lexer/tokens");
+const artifacts_1 = require("../abap/artifacts");
+const combi_1 = require("../abap/2_statements/combi");
+let keywords = undefined;
+/** every word of the statement and expression grammar, upper case */
+function getKeywords() {
+    if (keywords === undefined) {
+        const list = [];
+        for (const stat of artifacts_1.ArtifactsABAP.getStatements()) {
+            list.push(...combi_1.Combi.listKeywords(stat.getMatcher()));
+        }
+        for (const expr of artifacts_1.ArtifactsABAP.getExpressions()) {
+            list.push(...combi_1.Combi.listKeywords(new expr().getRunnable()));
+        }
+        keywords = new Set();
+        for (const words of list) {
+            // a WordSequence lists eg. "PREFERRED PARAMETER" or "IS-INITIAL" as one entry
+            for (const word of words.replace(/-/g, " ").split(" ")) {
+                if (word !== "") {
+                    keywords.add(word.toUpperCase());
+                }
+            }
+        }
+    }
+    return keywords;
+}
 class NoExclamationEscapeConf extends _basic_rule_config_1.BasicRuleConfig {
 }
 exports.NoExclamationEscapeConf = NoExclamationEscapeConf;
@@ -20,8 +45,10 @@ class NoExclamationEscape extends _abap_rule_1.ABAPRule {
             key: "no_exclamation_escape",
             title: "No exclamation escape",
             shortDescription: `Detects and removes exclamation marks (!) used to escape identifiers`,
-            // eslint-disable-next-line max-len
-            extendedInformation: `Exclamation marks are not needed when the identifier is not a reserved keyword, or could be avoided by renaming.`,
+            extendedInformation: `Exclamation marks are not needed when the identifier is not a keyword, or could be avoided by renaming.
+
+An identifier named like an ABAP keyword is allowed to be escaped, eg. a method parameter "!default",
+which the system otherwise reads as the DEFAULT addition of the parameter before it.`,
             tags: [_irule_1.RuleTag.SingleFile, _irule_1.RuleTag.Quickfix],
             badExample: "methods CONVERT changing !CO_sdf type ref to ZCL_sdf optional.",
             goodExample: "methods CONVERT changing CO_sdf type ref to ZCL_sdf optional.",
@@ -40,6 +67,9 @@ class NoExclamationEscape extends _abap_rule_1.ABAPRule {
                 const str = token.getStr();
                 if (str.startsWith("!")) {
                     const replacement = str.substring(1);
+                    if (getKeywords().has(replacement.toUpperCase())) {
+                        continue;
+                    }
                     const fix = edit_helper_1.EditHelper.replaceToken(file, token, replacement);
                     issues.push(issue_1.Issue.atToken(file, token, "Do not use exclamation mark to escape identifiers", this.getMetadata().key, this.conf.severity, fix));
                 }

package/package.json

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