@abaplint/core 2.120.74 → 2.120.75

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

package/build/src/rules/changing_sorted_line.js

@@ -0,0 +1,235 @@
+"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.ChangingSortedLine = exports.ChangingSortedLineConf = void 0;
+const Expressions = __importStar(require("../abap/2_statements/expressions"));
+const Statements = __importStar(require("../abap/2_statements/statements"));
+const Structures = __importStar(require("../abap/3_structures/structures"));
+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 nodes_1 = require("../abap/nodes");
+const _typed_identifier_1 = require("../abap/types/_typed_identifier");
+const tokens_1 = require("../abap/1_lexer/tokens");
+class ChangingSortedLineConf extends _basic_rule_config_1.BasicRuleConfig {
+}
+exports.ChangingSortedLineConf = ChangingSortedLineConf;
+class ChangingSortedLine {
+    constructor() {
+        this.conf = new ChangingSortedLineConf();
+    }
+    getMetadata() {
+        return {
+            key: "changing_sorted_line",
+            title: "Line of a sorted or hashed table passed to CHANGING",
+            shortDescription: `A field symbol on a whole line of a sorted or hashed table, passed to a CHANGING parameter of a method`,
+            extendedInformation: `The key fields of a sorted or hashed table line are write-protected, so the line as a whole is
+write-protected. Binding it to a CHANGING parameter activates, but the call fails at runtime with
+CX_SY_DYN_CALL_ILLEGAL_TYPE, "the actual parameter for ... is write-protected", even when the method does not
+change the key.
+
+Only field symbols assigned in the same method, form or function module are checked, via READ TABLE ... ASSIGNING,
+LOOP AT ... ASSIGNING, INSERT ... INTO TABLE ... ASSIGNING and ASSIGN itab[ ... ] TO.
+
+Fix: read the line into a work area, pass the work area and MODIFY TABLE ... FROM it afterwards,
+or pass only the non-key fields the method needs.`,
+            tags: [_irule_1.RuleTag.SingleFile],
+            badExample: `READ TABLE lt_sum WITH TABLE KEY app = lv_app ASSIGNING FIELD-SYMBOL(<sum>).
+add( CHANGING cs_sum = <sum> ).`,
+            goodExample: `READ TABLE lt_sum WITH TABLE KEY app = lv_app INTO DATA(ls_sum).
+add( CHANGING cs_sum = ls_sum ).
+MODIFY TABLE lt_sum FROM ls_sum.`,
+        };
+    }
+    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()) {
+            const stru = file.getStructure();
+            if (stru === undefined || stru.findFirstExpression(Expressions.MethodParameters) === undefined) {
+                continue;
+            }
+            if (spaghetti === undefined) {
+                spaghetti = new syntax_1.SyntaxLogic(this.reg, obj).run().spaghetti;
+            }
+            const blocks = [...stru.findAllStructures(Structures.Method),
+                ...stru.findAllStructures(Structures.Form),
+                ...stru.findAllStructures(Structures.FunctionModule)];
+            for (const block of blocks) {
+                // field symbol name -> name of the sorted or hashed table it points into
+                const lines = new Map();
+                for (const statement of block.findAllStatementNodes()) {
+                    for (const p of statement.findAllExpressions(Expressions.MethodParameters)) {
+                        this.checkChanging(p, lines, spaghetti, file, issues);
+                    }
+                    this.updateAssigned(statement, lines, spaghetti, file);
+                }
+            }
+        }
+        return issues;
+    }
+    ////////////////
+    checkChanging(params, lines, spaghetti, file, issues) {
+        var _a, _b;
+        let changing = false;
+        for (const child of params.getChildren()) {
+            const str = child.concatTokens().toUpperCase();
+            if (child instanceof nodes_1.ExpressionNode && changing === true && child.get() instanceof Expressions.ParameterListT) {
+                for (const p of child.findDirectExpressions(Expressions.ParameterT)) {
+                    const target = p.findDirectExpression(Expressions.Target);
+                    const fs = (target === null || target === void 0 ? void 0 : target.getChildren().length) === 1 ? target.findDirectExpression(Expressions.TargetFieldSymbol) : undefined;
+                    if (fs === undefined) {
+                        continue;
+                    }
+                    const table = lines.get(fs.concatTokens().toUpperCase());
+                    const type = (_a = this.findReference(fs.getFirstToken().getStart(), spaghetti, file)) === null || _a === void 0 ? void 0 : _a.getType();
+                    if (table === undefined || type === undefined || type.isGeneric()) {
+                        continue;
+                    }
+                    const name = (_b = p.findDirectExpression(Expressions.ParameterName)) === null || _b === void 0 ? void 0 : _b.concatTokens();
+                    const message = `Line of sorted or hashed table ${table} passed to CHANGING ${name} is write-protected, ` +
+                        `the call fails at runtime. Use a work area and MODIFY TABLE ... FROM, or pass only non-key fields`;
+                    issues.push(issue_1.Issue.atToken(file, fs.getFirstToken(), message, this.getMetadata().key, this.conf.severity));
+                }
+            }
+            changing = str === "CHANGING";
+        }
+    }
+    /** Tracks which field symbols the last assignment pointed to a whole line of a sorted or hashed table */
+    updateAssigned(statement, lines, spaghetti, file) {
+        var _a, _b, _c;
+        var _d;
+        const get = statement.get();
+        const fs = get instanceof Statements.Unassign
+            ? statement.findDirectExpression(Expressions.TargetFieldSymbol)
+            : (_a = statement.findFirstExpression(Expressions.FSTarget)) === null || _a === void 0 ? void 0 : _a.findFirstExpression(Expressions.TargetFieldSymbol);
+        if (fs === undefined) {
+            return;
+        }
+        const name = fs.concatTokens().toUpperCase();
+        let table = undefined;
+        let isTableExpression = false;
+        if (get instanceof Statements.ReadTable) {
+            table = (_d = statement.findDirectExpression(Expressions.SimpleSource2)) !== null && _d !== void 0 ? _d : statement.findDirectExpression(Expressions.Source);
+        }
+        else if (get instanceof Statements.Loop) {
+            table = (_b = statement.findDirectExpression(Expressions.LoopSource)) === null || _b === void 0 ? void 0 : _b.getFirstChild();
+        }
+        else if (get instanceof Statements.InsertInternal && statement.findDirectTokenByText("TABLE") !== undefined) {
+            table = statement.findDirectExpression(Expressions.Target);
+        }
+        else if (get instanceof Statements.Assign) {
+            table = (_c = statement.findDirectExpression(Expressions.AssignSource)) === null || _c === void 0 ? void 0 : _c.getFirstChild();
+            isTableExpression = true;
+        }
+        const tableType = table instanceof nodes_1.ExpressionNode ? this.findTableType(table, isTableExpression, spaghetti, file) : undefined;
+        if (table instanceof nodes_1.ExpressionNode && tableType instanceof basic_1.TableType
+            && (tableType.getAccessType() === basic_1.TableAccessType.sorted || tableType.getAccessType() === basic_1.TableAccessType.hashed)) {
+            lines.set(name, table.concatTokens().replace(/\[.*$/, "").trim());
+        }
+        else {
+            lines.delete(name);
+        }
+    }
+    /** The type of a table given by a plain field chain of names, components and attributes, else undefined.
+     *  With tableExpression, the chain must end with a table expression, and the type of the chain before it is returned */
+    findTableType(node, tableExpression, spaghetti, file) {
+        var _a, _b;
+        if (!(node.get() instanceof Expressions.Target)) {
+            const chain = node.getChildren().length === 1 ? node.findDirectExpression(Expressions.FieldChain) : undefined;
+            if (chain === undefined) {
+                return undefined;
+            }
+            node = chain;
+        }
+        const children = [...node.getChildren()];
+        if (tableExpression === true) {
+            if (!(((_a = children.pop()) === null || _a === void 0 ? void 0 : _a.get()) instanceof Expressions.TableExpression)) {
+                return undefined;
+            }
+        }
+        let type = undefined;
+        for (const child of children) {
+            const get = child.get();
+            if (get instanceof Expressions.SourceField
+                || get instanceof Expressions.SourceFieldSymbol
+                || get instanceof Expressions.TargetField
+                || get instanceof Expressions.TargetFieldSymbol
+                || get instanceof Expressions.AttributeName) {
+                type = (_b = this.findReference(child.getFirstToken().getStart(), spaghetti, file)) === null || _b === void 0 ? void 0 : _b.getType();
+            }
+            else if (get instanceof Expressions.ComponentName) {
+                type = type instanceof basic_1.StructureType ? type.getComponentByName(child.concatTokens()) : undefined;
+            }
+            else if (get instanceof Expressions.ClassName || get instanceof tokens_1.StaticArrow) {
+                continue;
+            }
+            else if (!(get instanceof tokens_1.Dash) && !(get instanceof tokens_1.InstanceArrow)) {
+                return undefined;
+            }
+            if (type === undefined) {
+                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;
+    }
+}
+exports.ChangingSortedLine = ChangingSortedLine;
+//# sourceMappingURL=changing_sorted_line.js.map

package/build/src/rules/class_attribute_names.js

@@ -30,6 +30,7 @@ class ClassAttributeNames extends _abap_rule_1.ABAPRule {
     constructor() {
         super(...arguments);
         this.conf = new ClassAttributeNamesConf();
+        this.regex = this.compile();
     }
     getMetadata() {
         return {
@@ -57,6 +58,15 @@ ENDCLASS.`,
     }
     setConfig(conf) {
         this.conf = conf;
+        this.regex = this.compile();
+    }
+    compile() {
+        return {
+            statics: new RegExp(this.conf.statics, "i"),
+            instance: new RegExp(this.conf.instance, "i"),
+            constants: new RegExp(this.conf.constants, "i"),
+            ignorePatterns: name_validator_1.NameValidator.compileIgnorePatterns(this.conf),
+        };
     }
     runParsed(file, obj) {
         if (this.conf.patternKind === undefined) {
@@ -89,13 +99,13 @@ ENDCLASS.`,
         for (const a of attr) {
             switch (a.level) {
                 case _abap_file_information_1.AttributeLevel.Instance:
-                    ret = ret.concat(this.checkName(a.identifier, this.conf.instance));
+                    ret = ret.concat(this.checkName(a.identifier, this.conf.instance, this.regex.instance));
                     break;
                 case _abap_file_information_1.AttributeLevel.Static:
-                    ret = ret.concat(this.checkName(a.identifier, this.conf.statics));
+                    ret = ret.concat(this.checkName(a.identifier, this.conf.statics, this.regex.statics));
                     break;
                 case _abap_file_information_1.AttributeLevel.Constant:
-                    ret = ret.concat(this.checkName(a.identifier, this.conf.constants));
+                    ret = ret.concat(this.checkName(a.identifier, this.conf.constants, this.regex.constants));
                     break;
                 default:
                     break;
@@ -103,11 +113,10 @@ ENDCLASS.`,
         }
         return ret;
     }
-    checkName(attr, expected) {
+    checkName(attr, expected, regex) {
         const ret = [];
-        const regex = new RegExp(expected, "i");
         const name = attr.getName();
-        if (name_validator_1.NameValidator.violatesRule(name, regex, this.conf)) {
+        if (name_validator_1.NameValidator.violatesRule(name, regex, this.conf, this.regex.ignorePatterns)) {
             const issue = issue_1.Issue.atIdentifier(attr, this.getDescription(name, expected), this.getMetadata().key, this.conf.severity);
             ret.push(issue);
         }

package/build/src/rules/delete_index_in_loop.js

@@ -0,0 +1,163 @@
+"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.DeleteIndexInLoop = exports.DeleteIndexInLoopConf = 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 token_node_1 = require("../abap/nodes/token_node");
+const _statement_1 = require("../abap/2_statements/statements/_statement");
+class DeleteIndexInLoopConf extends _basic_rule_config_1.BasicRuleConfig {
+}
+exports.DeleteIndexInLoopConf = DeleteIndexInLoopConf;
+class DeleteIndexInLoop extends _abap_rule_1.ABAPRule {
+    constructor() {
+        super(...arguments);
+        this.conf = new DeleteIndexInLoopConf();
+    }
+    getMetadata() {
+        return {
+            key: "delete_index_in_loop",
+            title: "DELETE INDEX sy-tabix inside a LOOP over the same table",
+            shortDescription: `Reports DELETE itab INDEX sy-tabix inside a LOOP AT the same table`,
+            extendedInformation: `sy-tabix is the index of the loop's current row only until another statement writes it.
+READ TABLE, APPEND, INSERT, COLLECT, a nested LOOP and any method called in the loop body
+all set sy-tabix. After that the DELETE removes a different row, and if sy-tabix is 0 it
+raises the runtime error TABLE_INVALID_INDEX.
+
+Use DELETE itab WHERE ..., or collect the rows to keep in a second table.
+
+Not reported: DELETE itab INDEX sy-tabix directly after READ TABLE itab, where sy-tabix
+is the index the READ just set.`,
+            tags: [_irule_1.RuleTag.SingleFile],
+            badExample: `LOOP AT tab INTO row.
+  IF row-flag = abap_true.
+    DELETE tab INDEX sy-tabix.
+  ENDIF.
+ENDLOOP.`,
+            goodExample: `DELETE tab WHERE flag = abap_true.`,
+        };
+    }
+    getConfig() {
+        return this.conf;
+    }
+    setConfig(conf) {
+        this.conf = conf;
+    }
+    runParsed(file) {
+        const issues = [];
+        const statements = file.getStatements();
+        for (let i = 0; i < statements.length; i++) {
+            const statement = statements[i];
+            if (!(statement.get() instanceof Statements.DeleteInternal) || this.byTabix(statement) === false) {
+                continue;
+            }
+            // DELETE TABLE and DELETE ADJACENT DUPLICATES have a keyword before the target
+            const target = statement.findDirectExpression(Expressions.Target);
+            if (target === undefined || statement.getChildren()[1] !== target) {
+                continue;
+            }
+            const table = target.concatTokens().toUpperCase();
+            if (this.previousReadsTable(i, statements, table) === true
+                || this.enclosingLoopTables(i, statements).includes(table) === false) {
+                continue;
+            }
+            const message = `DELETE ${target.concatTokens()} INDEX sy-tabix inside LOOP AT the same table,`
+                + ` sy-tabix might not be the loop's current row`;
+            issues.push(issue_1.Issue.atStatement(file, statement, message, this.getMetadata().key, this.conf.severity));
+        }
+        return issues;
+    }
+    ////////////////
+    byTabix(statement) {
+        const children = statement.getChildren();
+        for (let i = 0; i < children.length - 1; i++) {
+            const child = children[i];
+            if (child instanceof token_node_1.TokenNode && child.getFirstToken().getStr().toUpperCase() === "INDEX") {
+                return children[i + 1].concatTokens().toUpperCase() === "SY-TABIX";
+            }
+        }
+        return false;
+    }
+    previousReadsTable(index, statements, table) {
+        var _a;
+        for (let i = index - 1; i >= 0; i--) {
+            const statement = statements[i];
+            if (statement.get() instanceof _statement_1.Comment) {
+                continue;
+            }
+            if (!(statement.get() instanceof Statements.ReadTable)) {
+                return false;
+            }
+            const read = (_a = statement.findDirectExpression(Expressions.SimpleSource2)) !== null && _a !== void 0 ? _a : statement.findDirectExpression(Expressions.Source);
+            return (read === null || read === void 0 ? void 0 : read.concatTokens().toUpperCase()) === table;
+        }
+        return false;
+    }
+    enclosingLoopTables(index, statements) {
+        const tables = [];
+        let depth = 0;
+        for (let i = index - 1; i >= 0; i--) {
+            const statement = statements[i];
+            const s = statement.get();
+            if (s instanceof Statements.EndLoop) {
+                depth++;
+            }
+            else if (s instanceof Statements.Loop) {
+                if (depth === 0) {
+                    const source = statement.findDirectExpression(Expressions.LoopSource);
+                    if (source !== undefined) {
+                        tables.push(source.concatTokens().toUpperCase());
+                    }
+                }
+                else {
+                    depth--;
+                }
+            }
+            else if (s instanceof Statements.MethodImplementation
+                || s instanceof Statements.Form
+                || s instanceof Statements.FunctionModule
+                || s instanceof Statements.Module) {
+                break;
+            }
+        }
+        return tables;
+    }
+}
+exports.DeleteIndexInLoop = DeleteIndexInLoop;
+//# sourceMappingURL=delete_index_in_loop.js.map