@abaplint/core 2.120.73 → 2.120.75

package/build/src/rules/sort_empty_key.js

@@ -0,0 +1,188 @@
+"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.SortEmptyKey = exports.SortEmptyKeyConf = void 0;
+const Expressions = __importStar(require("../abap/2_statements/expressions"));
+const Statements = __importStar(require("../abap/2_statements/statements"));
+const _basic_rule_config_1 = require("./_basic_rule_config");
+const issue_1 = require("../issue");
+const _irule_1 = require("./_irule");
+const syntax_1 = require("../abap/5_syntax/syntax");
+const _abap_object_1 = require("../objects/_abap_object");
+const basic_1 = require("../abap/types/basic");
+const _typed_identifier_1 = require("../abap/types/_typed_identifier");
+const tokens_1 = require("../abap/1_lexer/tokens");
+const edit_helper_1 = require("../edit_helper");
+class SortEmptyKeyConf extends _basic_rule_config_1.BasicRuleConfig {
+}
+exports.SortEmptyKeyConf = SortEmptyKeyConf;
+class SortEmptyKey {
+    constructor() {
+        this.conf = new SortEmptyKeyConf();
+    }
+    getMetadata() {
+        return {
+            key: "sort_empty_key",
+            title: "SORT or DELETE ADJACENT DUPLICATES on a table with an empty key",
+            shortDescription: `SORT without BY and DELETE ADJACENT DUPLICATES without COMPARING on a table with an empty primary key`,
+            extendedInformation: `Without BY or COMPARING, both statements use the primary key of the table. For a table
+declared WITH EMPTY KEY there is nothing to sort or compare by, SORT does nothing.
+
+The syntax check warns: "ITAB is a table with an empty primary key. Check the semantics of the statement."
+
+Sorted and hashed tables, tables with a default or explicit key, and tables of unknown or generic type are not reported.
+
+The quick fix adds BY table_line or COMPARING table_line, for tables with an elementary row type.`,
+            tags: [_irule_1.RuleTag.SingleFile, _irule_1.RuleTag.Quickfix],
+            badExample: `DATA result TYPE STANDARD TABLE OF string WITH EMPTY KEY.
+SORT result.
+DELETE ADJACENT DUPLICATES FROM result.`,
+            goodExample: `DATA result TYPE STANDARD TABLE OF string WITH EMPTY KEY.
+SORT result BY table_line.
+DELETE ADJACENT DUPLICATES FROM result COMPARING table_line.`,
+        };
+    }
+    getConfig() {
+        return this.conf;
+    }
+    initialize(reg) {
+        this.reg = reg;
+        return this;
+    }
+    setConfig(conf) {
+        this.conf = conf;
+    }
+    run(obj) {
+        if (!(obj instanceof _abap_object_1.ABAPObject) || obj.getType() === "INTF") {
+            return [];
+        }
+        const issues = [];
+        let spaghetti = undefined;
+        for (const file of obj.getABAPFiles()) {
+            for (const statement of file.getStatements()) {
+                let addition;
+                if (statement.get() instanceof Statements.Sort) {
+                    if (statement.findDirectTokenByText("BY") !== undefined) {
+                        continue;
+                    }
+                    addition = "BY";
+                }
+                else if (statement.get() instanceof Statements.DeleteInternal) {
+                    if (statement.findDirectTokenByText("ADJACENT") === undefined
+                        || statement.findDirectTokenByText("COMPARING") !== undefined
+                        || statement.findDirectTokenByText("USING") !== undefined) {
+                        continue;
+                    }
+                    addition = "COMPARING";
+                }
+                else {
+                    continue;
+                }
+                const target = statement.findDirectExpression(Expressions.Target);
+                if (target === undefined) {
+                    continue;
+                }
+                if (spaghetti === undefined) {
+                    spaghetti = new syntax_1.SyntaxLogic(this.reg, obj).run().spaghetti;
+                }
+                const type = this.findType(target, spaghetti, file);
+                if (!(type instanceof basic_1.TableType)
+                    || type.getOptions().keyType !== basic_1.TableKeyType.empty
+                    || type.isGeneric()
+                    || (type.getAccessType() !== undefined && type.getAccessType() !== basic_1.TableAccessType.standard)) {
+                    continue;
+                }
+                const verb = addition === "BY" ? "SORT without BY" : "DELETE ADJACENT DUPLICATES without COMPARING";
+                const message = `${verb} on "${target.concatTokens()}", a table with an empty primary key`;
+                const fix = this.buildFix(file, statement, type.getRowType(), addition);
+                issues.push(issue_1.Issue.atStatement(file, statement, message, this.getMetadata().key, this.conf.severity, fix));
+            }
+        }
+        return issues;
+    }
+    ////////////////
+    /** The type of a target built from names, components and attributes only, else undefined */
+    findType(target, spaghetti, file) {
+        var _a;
+        let type = undefined;
+        for (const child of target.getChildren()) {
+            const get = child.get();
+            if (get instanceof Expressions.TargetField
+                || get instanceof Expressions.TargetFieldSymbol
+                || get instanceof Expressions.AttributeName) {
+                type = (_a = this.findReference(child.getFirstToken().getStart(), spaghetti, file)) === null || _a === void 0 ? void 0 : _a.getType();
+            }
+            else if (get instanceof Expressions.ComponentName) {
+                type = type instanceof basic_1.StructureType ? type.getComponentByName(child.concatTokens()) : undefined;
+            }
+            else if (!(get instanceof tokens_1.Dash)
+                && !(get instanceof tokens_1.InstanceArrow)
+                && !(get instanceof tokens_1.StaticArrow)
+                && !(get instanceof Expressions.ClassName)) {
+                return undefined;
+            }
+            if (type === undefined && !(get instanceof Expressions.ClassName) && !(get instanceof tokens_1.StaticArrow)) {
+                return undefined;
+            }
+        }
+        return type;
+    }
+    findReference(start, spaghetti, file) {
+        const scope = spaghetti.lookupPosition(start, file.getFilename());
+        for (const r of (scope === null || scope === void 0 ? void 0 : scope.getData().references) || []) {
+            if (r.position.getStart().equals(start) && r.resolved instanceof _typed_identifier_1.TypedIdentifier) {
+                return r.resolved;
+            }
+        }
+        return undefined;
+    }
+    buildFix(file, statement, rowType, addition) {
+        if (rowType instanceof basic_1.StructureType
+            || rowType instanceof basic_1.TableType
+            || rowType instanceof basic_1.VoidType
+            || rowType instanceof basic_1.UnknownType
+            || rowType.isGeneric()) {
+            return undefined;
+        }
+        const tokens = statement.getTokens();
+        let last = tokens[tokens.length - 1];
+        if (last instanceof tokens_1.Punctuation) {
+            last = tokens[tokens.length - 2];
+        }
+        return edit_helper_1.EditHelper.insertAt(file, last.getEnd(), ` ${addition} table_line`);
+    }
+}
+exports.SortEmptyKey = SortEmptyKey;
+//# sourceMappingURL=sort_empty_key.js.map

package/build/src/rules/subrc_after_assign.js

@@ -0,0 +1,220 @@
+"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.SubrcAfterAssign = exports.SubrcAfterAssignConf = void 0;
+const Statements = __importStar(require("../abap/2_statements/statements"));
+const Expressions = __importStar(require("../abap/2_statements/expressions"));
+const issue_1 = require("../issue");
+const _basic_rule_config_1 = require("./_basic_rule_config");
+const _abap_rule_1 = require("./_abap_rule");
+const _irule_1 = require("./_irule");
+const _statement_1 = require("../abap/2_statements/statements/_statement");
+const edit_helper_1 = require("../edit_helper");
+const severity_1 = require("../severity");
+class SubrcAfterAssignConf extends _basic_rule_config_1.BasicRuleConfig {
+    constructor() {
+        super(...arguments);
+        this.severity = severity_1.Severity.Warning;
+    }
+}
+exports.SubrcAfterAssignConf = SubrcAfterAssignConf;
+class SubrcAfterAssign extends _abap_rule_1.ABAPRule {
+    constructor() {
+        super(...arguments);
+        this.conf = new SubrcAfterAssignConf();
+    }
+    getMetadata() {
+        return {
+            key: "subrc_after_assign",
+            title: "sy-subrc checked after ASSIGN",
+            shortDescription: `Reports a sy-subrc check directly after an ASSIGN, use IS [NOT] ASSIGNED instead`,
+            extendedInformation: `On a 7.40 SP7 system sy-subrc was still 4 after a successful ASSIGN, left over from an earlier
+READ TABLE, see https://github.com/abap2UI5/abap2UI5/issues/1937. Current releases set sy-subrc here.
+IS [NOT] ASSIGNED asks the field symbol directly and does not depend on the release.
+
+A failed ASSIGN keeps the previous binding of the field symbol. So inside a loop, or when the
+field symbol is bound earlier in the same method, IS ASSIGNED is true after a failed ASSIGN.
+There, add UNASSIGN <fs> before the ASSIGN. The quick fix is only offered when the field symbol
+is declared in the method, bound only by this ASSIGN, and the ASSIGN is not in a loop.
+
+ASSIGN COMPONENT ... OF STRUCTURE is not reported.`,
+            tags: [_irule_1.RuleTag.SingleFile, _irule_1.RuleTag.Quickfix],
+            badExample: `ASSIGN (lv_name) TO <attri>.
+IF sy-subrc = 0.
+  WRITE <attri>.
+ENDIF.`,
+            goodExample: `ASSIGN (lv_name) TO <attri>.
+IF <attri> IS ASSIGNED.
+  WRITE <attri>.
+ENDIF.`,
+        };
+    }
+    getConfig() {
+        return this.conf;
+    }
+    setConfig(conf) {
+        this.conf = conf;
+    }
+    runParsed(file) {
+        var _a, _b;
+        const issues = [];
+        const statements = file.getStatements();
+        for (let i = 0; i < statements.length; i++) {
+            const statement = statements[i];
+            if (!(statement.get() instanceof Statements.Assign)
+                || ((_a = statement.findDirectExpression(Expressions.AssignSource)) === null || _a === void 0 ? void 0 : _a.getFirstToken().getStr().toUpperCase()) === "COMPONENT") {
+                continue;
+            }
+            const target = statement.findDirectExpression(Expressions.FSTarget);
+            const fs = (_b = target === null || target === void 0 ? void 0 : target.findFirstExpression(Expressions.FieldSymbol)) === null || _b === void 0 ? void 0 : _b.concatTokens();
+            if (target === undefined || fs === undefined) {
+                continue;
+            }
+            const check = this.nextCheck(i, statements, fs.toUpperCase());
+            if (check === undefined) {
+                continue;
+            }
+            let message = `sy-subrc checked after ASSIGN, use ${fs} IS [NOT] ASSIGNED`;
+            let fix = undefined;
+            if (this.insideLoop(i, statements) === true) {
+                message += ` with UNASSIGN ${fs} before the ASSIGN, it is inside a loop`;
+            }
+            else if (this.boundEarlier(i, statements, fs.toUpperCase()) === true) {
+                message += ` with UNASSIGN ${fs} before the ASSIGN, ${fs} is bound earlier`;
+            }
+            else if (target.findDirectExpression(Expressions.InlineFS) === undefined
+                && this.declaredInBlock(i, statements, fs.toUpperCase()) === false) {
+                message += ` with UNASSIGN ${fs} before the ASSIGN, ${fs} is not declared in this method`;
+            }
+            else {
+                fix = this.buildFix(file, check, fs);
+            }
+            issues.push(issue_1.Issue.atStatement(file, check, message, this.getMetadata().key, this.conf.severity, fix));
+        }
+        return issues;
+    }
+    ////////////////
+    /** the next statement, skipping comments and ENDIF like check_subrc does, if it reads sy-subrc */
+    nextCheck(index, statements, fs) {
+        for (let i = index + 1; i < statements.length; i++) {
+            const statement = statements[i];
+            if (statement.get() instanceof _statement_1.Comment
+                || statement.get() instanceof Statements.EndIf
+                || statement.get() instanceof Statements.EndTestSeam) {
+                continue;
+            }
+            const concat = statement.concatTokens().toUpperCase();
+            if (concat.includes(fs + " IS ASSIGNED") || concat.includes(fs + " IS NOT ASSIGNED")) {
+                return undefined;
+            }
+            return concat.includes("SY-SUBRC") ? statement : undefined;
+        }
+        return undefined;
+    }
+    insideLoop(index, statements) {
+        let depth = 0;
+        for (let i = index - 1; i >= 0 && this.startsBlock(statements[i]) === false; i--) {
+            const s = statements[i].get();
+            if (s instanceof Statements.EndLoop || s instanceof Statements.EndDo || s instanceof Statements.EndWhile) {
+                depth++;
+            }
+            else if (s instanceof Statements.Loop || s instanceof Statements.Do || s instanceof Statements.While) {
+                if (depth === 0) {
+                    return true;
+                }
+                depth--;
+            }
+        }
+        return false;
+    }
+    /** any earlier statement in the block with the field symbol as target, eg. ASSIGN, LOOP or READ TABLE ASSIGNING */
+    boundEarlier(index, statements, fs) {
+        var _a;
+        for (let i = index - 1; i >= 0 && this.startsBlock(statements[i]) === false; i--) {
+            for (const target of statements[i].findAllExpressions(Expressions.FSTarget)) {
+                if (((_a = target.findFirstExpression(Expressions.FieldSymbol)) === null || _a === void 0 ? void 0 : _a.concatTokens().toUpperCase()) === fs) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    declaredInBlock(index, statements, fs) {
+        var _a;
+        for (let i = index - 1; i >= 0 && this.startsBlock(statements[i]) === false; i--) {
+            if (statements[i].get() instanceof Statements.FieldSymbol
+                && ((_a = statements[i].findDirectExpression(Expressions.FieldSymbol)) === null || _a === void 0 ? void 0 : _a.concatTokens().toUpperCase()) === fs) {
+                return true;
+            }
+        }
+        return false;
+    }
+    startsBlock(statement) {
+        const s = statement.get();
+        return s instanceof Statements.MethodImplementation
+            || s instanceof Statements.Form
+            || s instanceof Statements.FunctionModule
+            || s instanceof Statements.Module
+            || s instanceof Statements.EndMethod
+            || s instanceof Statements.EndForm
+            || s instanceof Statements.EndFunction
+            || s instanceof Statements.EndModule;
+    }
+    /** replaces "sy-subrc = 0" or "sy-subrc <> 0" in place, also inside a longer condition */
+    buildFix(file, statement, fs) {
+        const tokens = statement.getTokens();
+        for (let i = 0; i + 4 < tokens.length; i++) {
+            if (tokens[i].getStr().toUpperCase() !== "SY"
+                || tokens[i + 1].getStr() !== "-"
+                || tokens[i + 2].getStr().toUpperCase() !== "SUBRC") {
+                continue;
+            }
+            if (tokens[i + 4].getStr() !== "0") {
+                return undefined;
+            }
+            const op = tokens[i + 3].getStr().toUpperCase();
+            if (op === "=" || op === "EQ") {
+                return edit_helper_1.EditHelper.replaceRange(file, tokens[i].getStart(), tokens[i + 4].getEnd(), `${fs} IS ASSIGNED`);
+            }
+            else if (op === "<>" || op === "NE") {
+                return edit_helper_1.EditHelper.replaceRange(file, tokens[i].getStart(), tokens[i + 4].getEnd(), `${fs} IS NOT ASSIGNED`);
+            }
+            return undefined;
+        }
+        return undefined;
+    }
+}
+exports.SubrcAfterAssign = SubrcAfterAssign;
+//# sourceMappingURL=subrc_after_assign.js.map

package/build/src/rules/types_naming.js

@@ -53,6 +53,7 @@ class TypesNaming extends _abap_rule_1.ABAPRule {
     constructor() {
         super(...arguments);
         this.conf = new TypesNamingConf();
+        this.regex = new RegExp(this.conf.pattern, "i");
     }
     getMetadata() {
         return {
@@ -70,10 +71,10 @@ class TypesNaming extends _abap_rule_1.ABAPRule {
     }
     setConfig(conf) {
         this.conf = conf;
+        this.regex = new RegExp(this.conf.pattern, "i");
     }
     runParsed(file, obj) {
         const issues = [];
-        const testRegex = new RegExp(this.conf.pattern, "i");
         let nesting = 0;
         if (obj instanceof objects_1.TypePool) {
             return [];
@@ -102,7 +103,7 @@ class TypesNaming extends _abap_rule_1.ABAPRule {
                 continue;
             }
             const token = expr.getFirstToken();
-            if (testRegex.exec(token.getStr())) {
+            if (this.regex.exec(token.getStr())) {
                 continue;
             }
             else {

package/build/src/rules/wrong_abapdoc_position.js

@@ -40,6 +40,8 @@ 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 edit_helper_1 = require("../edit_helper");
+const position_1 = require("../position");
 class WrongAbapdocPositionConf extends _basic_rule_config_1.BasicRuleConfig {
 }
 exports.WrongAbapdocPositionConf = WrongAbapdocPositionConf;
@@ -59,10 +61,13 @@ elsewhere is silently ignored, leaving the declaration undocumented.
 The following positions are reported,
 * in front of a chained keyword, ie. before "CONSTANTS:" instead of after the colon,
 * in the middle of a statement, ie. between the parameters of a METHODS definition,
-* directly in front of ENDCLASS, ENDINTERFACE or a SECTION statement.
+* directly in front of ENDCLASS, ENDINTERFACE or a SECTION statement,
+* separated from its declaration by a blank line or a normal comment, the system reads both as the end of the block.
 
-Only checks ABAP Doc inside class definitions and interfaces.`,
-            tags: [_irule_1.RuleTag.SingleFile],
+Only checks ABAP Doc inside class definitions and interfaces, and directly in front of them.
+
+The quick fix for a blank line deletes the blank lines.`,
+            tags: [_irule_1.RuleTag.SingleFile, _irule_1.RuleTag.Quickfix],
             badExample: `CLASS zcl_foo DEFINITION PUBLIC.
   PUBLIC SECTION.
     "! Navigation modes
@@ -88,6 +93,7 @@ ENDCLASS.`,
         this.conf = conf;
     }
     runParsed(file) {
+        var _a;
         const issues = [];
         const statements = file.getStatements();
         let definition = false;
@@ -102,7 +108,7 @@ ENDCLASS.`,
                 definition = false;
                 continue;
             }
-            else if (definition === false || this.isAbapdoc(statement) === false) {
+            else if (this.isAbapdoc(statement) === false) {
                 continue;
             }
             else if (this.isAbapdoc(statements[i - 1]) === true
@@ -110,19 +116,57 @@ ENDCLASS.`,
                 continue; // only report the first row of each block
             }
             let next = undefined;
-            for (let j = i + 1; j < statements.length; j++) {
-                if (statements[j].get() instanceof _statement_1.Comment) {
-                    continue;
+            let j = i + 1;
+            for (; j < statements.length; j++) {
+                if (!(statements[j].get() instanceof _statement_1.Comment)) {
+                    next = statements[j];
+                    break;
                 }
-                next = statements[j];
-                break;
             }
             if (next === undefined) {
                 continue;
             }
-            const message = this.check(statement, next);
+            else if (definition === false
+                && !(next.get() instanceof Statements.ClassDefinition)
+                && !(next.get() instanceof Statements.Interface)) {
+                continue;
+            }
+            // comments inside "next" are listed in front of it, only look at the rows above it
+            const nextRow = this.startRow(next);
+            const trailing = ((_a = statements[i - 1]) === null || _a === void 0 ? void 0 : _a.getEnd().getRow()) === statement.getStart().getRow();
+            let last = statement;
+            let separator = undefined;
+            let fix = undefined;
+            for (const s of trailing ? [] : statements.slice(i + 1, j)) {
+                if (s.getStart().getRow() >= nextRow) {
+                    break;
+                }
+                else if (s.getStart().getRow() > last.getEnd().getRow() + 1) {
+                    separator = "a blank line";
+                    if (this.isAbapdoc(s) === true) {
+                        fix = edit_helper_1.EditHelper.deleteRange(file, new position_1.Position(last.getEnd().getRow() + 1, 1), new position_1.Position(s.getStart().getRow(), 1));
+                    }
+                    break;
+                }
+                else if (this.isAbapdoc(s) === false) {
+                    separator = "a comment";
+                    break;
+                }
+                last = s;
+            }
+            if (separator === undefined && trailing === false && nextRow > last.getEnd().getRow() + 1) {
+                separator = "a blank line";
+                fix = edit_helper_1.EditHelper.deleteRange(file, new position_1.Position(last.getEnd().getRow() + 1, 1), new position_1.Position(nextRow, 1));
+            }
+            let message = this.check(statement, next);
+            if (message !== undefined) {
+                fix = undefined;
+            }
+            else if (separator !== undefined) {
+                message = "ABAP Doc is separated from its declaration by " + separator;
+            }
             if (message !== undefined) {
-                issues.push(issue_1.Issue.atStatement(file, statement, message, this.getMetadata().key, this.conf.severity));
+                issues.push(issue_1.Issue.atStatement(file, statement, message, this.getMetadata().key, this.conf.severity, fix));
             }
         }
         return issues;
@@ -131,6 +175,9 @@ ENDCLASS.`,
         return (statement === null || statement === void 0 ? void 0 : statement.get()) instanceof _statement_1.Comment
             && statement.getFirstToken().getStr().startsWith(`"!`);
     }
+    startRow(statement) {
+        return Math.min(statement.getStart().getRow(), ...statement.getPragmas().map(p => p.getRow()));
+    }
     check(abapdoc, next) {
         const type = next.get();
         if (type instanceof Statements.EndClass

package/build/src/rules/xml_consistency.js

@@ -41,6 +41,10 @@ const _abap_object_1 = require("../objects/_abap_object");
 const _basic_rule_config_1 = require("./_basic_rule_config");
 const fast_xml_parser_1 = require("fast-xml-parser");
 const severity_1 = require("../severity");
+const ABAPGIT_ATTRIBUTES = [
+    ["version", /<abapGit\b[^>]*\bversion="([^"]+)"/],
+    ["serializer_version", /<abapGit\b[^>]*\bserializer_version="([^"]+)"/],
+];
 class XMLConsistencyConf extends _basic_rule_config_1.BasicRuleConfig {
     constructor() {
         super(...arguments);
@@ -96,8 +100,8 @@ class XMLConsistency {
                 issues.push(issue_1.Issue.atRow(file, 1, "XML parser error: " + res.err.msg, this.getMetadata().key, this.conf.severity));
             }
             else {
-                for (const attribute of ["version", "serializer_version"]) {
-                    const value = (_a = xml.match(new RegExp(`<abapGit\\b[^>]*\\b${attribute}="([^"]+)"`))) === null || _a === void 0 ? void 0 : _a[1];
+                for (const [attribute, regex] of ABAPGIT_ATTRIBUTES) {
+                    const value = (_a = xml.match(regex)) === null || _a === void 0 ? void 0 : _a[1];
                     if (value !== undefined && value.match(/^v\d\.\d\.\d$/) === null) {
                         issues.push(issue_1.Issue.atRow(file, 1, `Unexpected abapGit ${attribute} "${value}"`, this.getMetadata().key, this.conf.severity));
                     }

package/build/src/utils/name_validator.js

@@ -2,12 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NameValidator = void 0;
 class NameValidator {
-    static violatesRule(name, pattern, params) {
+    /** compile the configured ignorePatterns, case insensitive */
+    static compileIgnorePatterns(params) {
+        return (params.ignorePatterns || []).map(ignored => new RegExp(ignored, "i"));
+    }
+    static violatesRule(name, pattern, params, ignorePatterns) {
         if (params.ignoreNames && params.ignoreNames.indexOf(name.toUpperCase()) >= 0) {
             return false;
         }
-        for (const ignored of params.ignorePatterns || []) {
-            if (new RegExp(ignored, "i").test(name)) {
+        for (const ignored of ignorePatterns) {
+            if (ignored.test(name)) {
                 return false;
             }
         }

package/package.json

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