@abaplint/core 2.120.73 → 2.120.75

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/ddic.js

@@ -256,7 +256,7 @@ class DDIC {
     lookupDomain(name, dataElement, description) {
         const found = this.reg.getObject("DOMA", name);
         if (found) {
-            return { type: found.parseType(this.reg, dataElement, description), object: found };
+            return { type: found.parseDomainType(this.reg, dataElement, description), object: found };
         }
         else if (this.reg.inErrorNamespace(name)) {
             return { type: new Types.UnknownType(name + ", lookupDomain"), object: undefined };

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/objects/domain.js

@@ -81,7 +81,10 @@ class Domain extends _abstract_object_1.AbstractObject {
         this.parsedXML = undefined;
         super.setDirty();
     }
-    parseType(reg, dataElement, description) {
+    parseType(reg) {
+        return this.parseDomainType(reg);
+    }
+    parseDomainType(reg, dataElement, description) {
         // dont cache the DOMA parsed type, they are cached on DTEL level
         // also note that the type carries the name of the DTEL
         if (this.parsedXML === undefined) {

package/build/src/registry.js

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

package/build/src/rules/abapdoc_html_tag.js

@@ -0,0 +1,123 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbapdocHtmlTag = exports.AbapdocHtmlTagConf = void 0;
+const Statements = __importStar(require("../abap/2_statements/statements"));
+const issue_1 = require("../issue");
+const _abap_rule_1 = require("./_abap_rule");
+const _basic_rule_config_1 = require("./_basic_rule_config");
+const _irule_1 = require("./_irule");
+const _statement_1 = require("../abap/2_statements/statements/_statement");
+const position_1 = require("../position");
+class AbapdocHtmlTagConf extends _basic_rule_config_1.BasicRuleConfig {
+}
+exports.AbapdocHtmlTagConf = AbapdocHtmlTagConf;
+const ALLOWED = new Set(["p", "em", "strong", "ul", "ol", "li", "br", "h1", "h2", "h3"]);
+class AbapdocHtmlTag extends _abap_rule_1.ABAPRule {
+    constructor() {
+        super(...arguments);
+        this.conf = new AbapdocHtmlTagConf();
+    }
+    getMetadata() {
+        return {
+            key: "abapdoc_html_tag",
+            title: "Unsupported HTML tag in ABAP Doc",
+            shortDescription: `Reports tag-like tokens in ABAP Doc which are not ABAP Doc HTML tags.`,
+            extendedInformation: `ABAP Doc is parsed as HTML, a field symbol or a placeholder written as <name> is an
+unsupported and unclosed tag, the system warns and the rendered documentation drops the word.
+
+Supported tags are p, em, strong, ul, ol, li, br, h1, h2 and h3, also as closing tags and with attributes.
+
+Write &lt;name&gt; to show the angle brackets. A "<" which is not followed by a letter, like "a < b", is not reported.
+
+Only checks ABAP Doc inside class definitions and interfaces.`,
+            tags: [_irule_1.RuleTag.SingleFile],
+            badExample: `INTERFACE zif_foo PUBLIC.
+  "! Returns the <name> of the selected row
+  METHODS name RETURNING VALUE(result) TYPE string.
+ENDINTERFACE.`,
+            goodExample: `INTERFACE zif_foo PUBLIC.
+  "! Returns the &lt;name&gt; of the selected row
+  METHODS name RETURNING VALUE(result) TYPE string.
+ENDINTERFACE.`,
+        };
+    }
+    getConfig() {
+        return this.conf;
+    }
+    setConfig(conf) {
+        this.conf = conf;
+    }
+    runParsed(file) {
+        const issues = [];
+        let definition = false;
+        for (const statement of file.getStatements()) {
+            const type = statement.get();
+            if (type instanceof Statements.ClassDefinition || type instanceof Statements.Interface) {
+                definition = true;
+                continue;
+            }
+            else if (type instanceof Statements.EndClass || type instanceof Statements.EndInterface) {
+                definition = false;
+                continue;
+            }
+            else if (definition === false || !(type instanceof _statement_1.Comment)) {
+                continue;
+            }
+            const token = statement.getFirstToken();
+            const str = token.getStr();
+            if (str.startsWith(`"!`) === false) {
+                continue;
+            }
+            const regex = /<\/?([a-zA-Z][\w-]*)(\s[^<>]*)?\/?>/g;
+            let match;
+            while ((match = regex.exec(str)) !== null) {
+                const name = match[1];
+                if (ALLOWED.has(name.toLowerCase())) {
+                    continue;
+                }
+                const row = token.getStart().getRow();
+                const col = token.getStart().getCol() + match.index;
+                const start = new position_1.Position(row, col);
+                const end = new position_1.Position(row, col + match[0].length);
+                const message = `HTML tag <${name}> is not supported in ABAP Doc, write &lt;${name}&gt;`;
+                issues.push(issue_1.Issue.atRange(file, start, end, message, this.getMetadata().key, this.conf.severity));
+            }
+        }
+        return issues;
+    }
+}
+exports.AbapdocHtmlTag = AbapdocHtmlTag;
+//# sourceMappingURL=abapdoc_html_tag.js.map

package/build/src/rules/abapdoc_leading_at.js

@@ -0,0 +1,117 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbapdocLeadingAt = exports.AbapdocLeadingAtConf = void 0;
+const Statements = __importStar(require("../abap/2_statements/statements"));
+const issue_1 = require("../issue");
+const _abap_rule_1 = require("./_abap_rule");
+const _basic_rule_config_1 = require("./_basic_rule_config");
+const _irule_1 = require("./_irule");
+const _statement_1 = require("../abap/2_statements/statements/_statement");
+class AbapdocLeadingAtConf extends _basic_rule_config_1.BasicRuleConfig {
+}
+exports.AbapdocLeadingAtConf = AbapdocLeadingAtConf;
+class AbapdocLeadingAt extends _abap_rule_1.ABAPRule {
+    constructor() {
+        super(...arguments);
+        this.conf = new AbapdocLeadingAtConf();
+    }
+    getMetadata() {
+        return {
+            key: "abapdoc_leading_at",
+            title: "ABAP Doc line starting with @",
+            shortDescription: `Reports ABAP Doc lines starting with "@" which is not followed by a command.`,
+            extendedInformation: `In ABAP Doc, "@" at the start of a line introduces a command, the commands are
+@parameter, @raising and @exception. Any other text after a leading "@", like a CDS annotation,
+gives the syntax warning 'A command was expected after ABAP Doc symbol "@"'.
+
+An "@" in the middle of a line is plain text and not reported.
+
+Only checks ABAP Doc inside class definitions and interfaces.`,
+            tags: [_irule_1.RuleTag.SingleFile],
+            badExample: `CLASS zcl_foo DEFINITION PUBLIC.
+  PUBLIC SECTION.
+    "! the first of
+    "! @UI.presentationVariant sortOrder
+    DATA mv_sort_field TYPE string.
+ENDCLASS.`,
+            goodExample: `CLASS zcl_foo DEFINITION PUBLIC.
+  PUBLIC SECTION.
+    "! the first of @UI.presentationVariant
+    "! sortOrder
+    DATA mv_sort_field TYPE string.
+ENDCLASS.`,
+        };
+    }
+    getConfig() {
+        return this.conf;
+    }
+    setConfig(conf) {
+        this.conf = conf;
+    }
+    runParsed(file) {
+        const issues = [];
+        let definition = false;
+        for (const statement of file.getStatements()) {
+            const type = statement.get();
+            if (type instanceof Statements.ClassDefinition || type instanceof Statements.Interface) {
+                definition = true;
+                continue;
+            }
+            else if (type instanceof Statements.EndClass || type instanceof Statements.EndInterface) {
+                definition = false;
+                continue;
+            }
+            else if (definition === false || !(type instanceof _statement_1.Comment)) {
+                continue;
+            }
+            const token = statement.getFirstToken();
+            const str = token.getStr();
+            if (str.startsWith(`"!`) === false) {
+                continue;
+            }
+            const text = str.substring(2).trimStart();
+            if (text.startsWith("@") === false
+                || text.match(/^@(parameter|raising|exception)(\s|$)/i) !== null) {
+                continue;
+            }
+            const message = `A command was expected after ABAP Doc symbol "@", move the "@" away from the start of the line`;
+            issues.push(issue_1.Issue.atToken(file, token, message, this.getMetadata().key, this.conf.severity));
+        }
+        return issues;
+    }
+}
+exports.AbapdocLeadingAt = AbapdocLeadingAt;
+//# sourceMappingURL=abapdoc_leading_at.js.map

package/build/src/rules/abapdoc_parameter_names.js

@@ -0,0 +1,149 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbapdocParameterNames = exports.AbapdocParameterNamesConf = void 0;
+const Statements = __importStar(require("../abap/2_statements/statements"));
+const Expressions = __importStar(require("../abap/2_statements/expressions"));
+const issue_1 = require("../issue");
+const _abap_rule_1 = require("./_abap_rule");
+const _basic_rule_config_1 = require("./_basic_rule_config");
+const _irule_1 = require("./_irule");
+const _statement_1 = require("../abap/2_statements/statements/_statement");
+class AbapdocParameterNamesConf extends _basic_rule_config_1.BasicRuleConfig {
+}
+exports.AbapdocParameterNamesConf = AbapdocParameterNamesConf;
+class AbapdocParameterNames extends _abap_rule_1.ABAPRule {
+    constructor() {
+        super(...arguments);
+        this.conf = new AbapdocParameterNamesConf();
+    }
+    getMetadata() {
+        return {
+            key: "abapdoc_parameter_names",
+            title: "ABAP Doc parameter names",
+            shortDescription: `Checks that the parameters documented in ABAP Doc exist in the method definition.`,
+            extendedInformation: `Reports "! @parameter lines in the ABAP Doc block in front of a METHODS or CLASS-METHODS
+definition when the parameter is not a parameter of the method, typically after a parameter was renamed or removed.
+Also reports a parameter documented twice.
+
+Missing @parameter lines are not reported, documenting parameters is optional. @raising and @exception lines are not checked.
+
+Only the block directly in front of the method is checked, a blank line or a plain comment ends the block,
+see rule wrong_abapdoc_position for misplaced ABAP Doc.`,
+            tags: [_irule_1.RuleTag.SingleFile],
+            badExample: `CLASS zcl_foo DEFINITION PUBLIC.
+  PUBLIC SECTION.
+    "! @parameter iv_bar | Bar
+    METHODS foo IMPORTING iv_foo TYPE i.
+ENDCLASS.`,
+            goodExample: `CLASS zcl_foo DEFINITION PUBLIC.
+  PUBLIC SECTION.
+    "! @parameter iv_foo | Foo
+    METHODS foo IMPORTING iv_foo TYPE i.
+ENDCLASS.`,
+        };
+    }
+    getConfig() {
+        return this.conf;
+    }
+    setConfig(conf) {
+        this.conf = conf;
+    }
+    runParsed(file) {
+        var _a;
+        const issues = [];
+        const statements = file.getStatements();
+        for (let i = 0; i < statements.length; i++) {
+            const def = statements[i];
+            if (!(def.get() instanceof Statements.MethodDef)) {
+                continue;
+            }
+            const name = def.findDirectExpression(Expressions.MethodName);
+            if (name === undefined) {
+                continue;
+            }
+            const abapdoc = [];
+            let nextRow = undefined;
+            for (let j = i - 1; j >= 0 && statements[j].get() instanceof _statement_1.Comment; j--) {
+                const comment = statements[j];
+                const start = comment.getStart();
+                if (start.isAfter(name.getFirstToken().getStart())) {
+                    continue; // comment inside the statement, after the method name
+                }
+                nextRow = nextRow !== null && nextRow !== void 0 ? nextRow : (_a = def.getTokens().find(t => t.getStart().isAfter(start))) === null || _a === void 0 ? void 0 : _a.getStart().getRow();
+                if (this.isAbapdoc(comment, def) === false || start.getRow() + 1 !== nextRow) {
+                    break; // a blank line or a plain comment ends the block
+                }
+                abapdoc.unshift(comment);
+                nextRow = start.getRow();
+            }
+            if (abapdoc.length === 0) {
+                continue;
+            }
+            const parameters = def.findAllExpressions(Expressions.MethodParamName)
+                .map(p => p.getFirstToken().getStr().replace(/^!/, "").toUpperCase());
+            const documented = new Set();
+            for (const comment of abapdoc) {
+                const match = comment.getFirstToken().getStr().match(/^"!\s*@parameter\s+!?([^\s|]+)/i);
+                if (match === null) {
+                    continue;
+                }
+                const parameter = match[1].toUpperCase();
+                let message = undefined;
+                if (parameters.includes(parameter) === false) {
+                    message = `ABAP Doc parameter "${match[1]}" is not a parameter of method ${name.concatTokens()}`;
+                }
+                else if (documented.has(parameter) === true) {
+                    message = `ABAP Doc parameter "${match[1]}" documented more than once`;
+                }
+                documented.add(parameter);
+                if (message !== undefined) {
+                    issues.push(issue_1.Issue.atStatement(file, comment, message, this.getMetadata().key, this.conf.severity));
+                }
+            }
+        }
+        return issues;
+    }
+    /** ABAP Doc in front of the method name, after the colon of a chain */
+    isAbapdoc(comment, def) {
+        if (comment.getFirstToken().getStr().startsWith(`"!`) === false) {
+            return false;
+        }
+        const colon = def.getColon();
+        return colon === undefined || comment.getStart().isAfter(colon.getStart());
+    }
+}
+exports.AbapdocParameterNames = AbapdocParameterNames;
+//# sourceMappingURL=abapdoc_parameter_names.js.map

package/build/src/rules/cds_check_syntax.js

@@ -288,10 +288,10 @@ Missing objects are only reported when their names match the configured errorNam
         let searchable;
         for (const annotation of tree.findAllExpressionsRecursive(expressions_1.CDSAnnotation)) {
             const normalized = annotation.concatTokens().replace(/\s/g, "").toUpperCase().replace(/^@</, "@");
-            if (this.hasSearchAnnotation(normalized, "defaultSearchElement")) {
+            if (this.hasSearchAnnotation(normalized, /[.{,]DEFAULTSEARCHELEMENT:TRUE/)) {
                 return;
             }
-            else if (searchable === undefined && this.hasSearchAnnotation(normalized, "searchable")) {
+            else if (searchable === undefined && this.hasSearchAnnotation(normalized, /[.{,]SEARCHABLE:TRUE/)) {
                 searchable = annotation;
             }
         }
@@ -301,11 +301,11 @@ Missing objects are only reported when their names match the configured errorNam
             issues.push(issue_1.Issue.atToken(file, searchable.getFirstToken(), message, this.getMetadata().key, this.conf.severity));
         }
     }
-    hasSearchAnnotation(normalized, name) {
+    hasSearchAnnotation(normalized, annotation) {
         if (normalized.startsWith("@SEARCH") === false) {
             return false;
         }
-        return new RegExp("[.{,]" + name.toUpperCase() + ":TRUE").test(normalized);
+        return annotation.test(normalized);
     }
     checkReservedNames(tree, issues, file) {
         var _a, _b;

package/build/src/rules/change_if_to_case.js

@@ -55,6 +55,7 @@ class ChangeIfToCase extends _abap_rule_1.ABAPRule {
     constructor() {
         super(...arguments);
         this.conf = new ChangeIfToCaseConf();
+        this.skipNames = [];
     }
     getMetadata() {
         return {
@@ -81,6 +82,7 @@ ENDCASE.`,
     }
     setConfig(conf) {
         this.conf = conf;
+        this.skipNames = (this.conf.skipNames || []).map(skip => new RegExp(skip, "i"));
     }
     runParsed(file) {
         var _a;
@@ -158,8 +160,7 @@ ENDCASE.`,
         else {
             return false;
         }
-        for (const skip of this.getConfig().skipNames || []) {
-            const reg = new RegExp(skip, "i");
+        for (const reg of this.skipNames) {
             if (chain.match(reg)) {
                 return false;
             }