@abaplint/core 2.120.74 → 2.120.75

package/build/src/rules/range_row_values.js

@@ -0,0 +1,200 @@
+"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.RangeRowValues = exports.RangeRowValuesConf = void 0;
+const Expressions = __importStar(require("../abap/2_statements/expressions"));
+const _reference_1 = require("../abap/5_syntax/_reference");
+const syntax_1 = require("../abap/5_syntax/syntax");
+const nodes_1 = require("../abap/nodes");
+const _typed_identifier_1 = require("../abap/types/_typed_identifier");
+const basic_1 = require("../abap/types/basic");
+const issue_1 = require("../issue");
+const _abap_object_1 = require("../objects/_abap_object");
+const _basic_rule_config_1 = require("./_basic_rule_config");
+const _irule_1 = require("./_irule");
+const RANGE_COMPONENTS = ["SIGN", "OPTION", "LOW", "HIGH"];
+const SIGNS = ["I", "E"];
+const OPTIONS = ["EQ", "NE", "BT", "NB", "CP", "NP", "GT", "GE", "LT", "LE"];
+class RangeRowValuesConf extends _basic_rule_config_1.BasicRuleConfig {
+}
+exports.RangeRowValuesConf = RangeRowValuesConf;
+class RangeRowValues {
+    constructor() {
+        this.conf = new RangeRowValuesConf();
+    }
+    getMetadata() {
+        return {
+            key: "range_row_values",
+            title: "Range row values",
+            shortDescription: `Checks the SIGN and OPTION of range rows built with VALUE`,
+            extendedInformation: `A row of a range table, ie. a structure with exactly the components SIGN, OPTION, LOW and HIGH,
+is a selection structure to the syntax check. For a VALUE row of one, the system warns when SIGN or OPTION
+is missing, and when a literal is not a permitted value: SIGN must be I or E, OPTION one of
+EQ NE BT NB CP NP GT GE LT LE, in upper case.
+
+Components given in the VALUE header count for the rows that follow, eg. VALUE #( sign = 'I' option = 'EQ' ( low = 1 ) ).
+Only literals are checked, a value from a variable, constant or expression is not.`,
+            tags: [_irule_1.RuleTag.Syntax],
+            badExample: `TYPES ty_range TYPE RANGE OF string.
+DATA(range) = VALUE ty_range( ( sign = 'I' option = 'eq' low = \`a\` )
+                              ( sign = 'I' low = \`b\` ) ).`,
+            goodExample: `TYPES ty_range TYPE RANGE OF string.
+DATA(range) = VALUE ty_range( ( sign = 'I' option = 'EQ' low = \`a\` )
+                              ( sign = 'I' option = 'EQ' low = \`b\` ) ).`,
+        };
+    }
+    getConfig() {
+        return this.conf;
+    }
+    setConfig(conf) {
+        this.conf = conf;
+    }
+    initialize(reg) {
+        this.reg = reg;
+        return this;
+    }
+    run(obj) {
+        var _a, _b, _c;
+        if (!(obj instanceof _abap_object_1.ABAPObject)) {
+            return [];
+        }
+        const syntax = new syntax_1.SyntaxLogic(this.reg, obj).run();
+        if (syntax.issues.length > 0) {
+            return [];
+        }
+        const issues = [];
+        for (const file of obj.getABAPFiles()) {
+            for (const source of ((_a = file.getStructure()) === null || _a === void 0 ? void 0 : _a.findAllExpressionsRecursive(Expressions.Source)) || []) {
+                if (source.getFirstToken().getStr().toUpperCase() !== "VALUE") {
+                    continue;
+                }
+                const typeToken = (_b = source.findDirectExpression(Expressions.TypeNameOrInfer)) === null || _b === void 0 ? void 0 : _b.getFirstToken();
+                const body = source.findDirectExpression(Expressions.ValueBody);
+                if (typeToken === undefined || body === undefined) {
+                    continue;
+                }
+                const scope = syntax.spaghetti.lookupPosition(typeToken.getStart(), file.getFilename());
+                const resolved = (_c = scope === null || scope === void 0 ? void 0 : scope.getData().references.find(r => r.referenceType === _reference_1.ReferenceType.InferredType
+                    && r.position.getStart().equals(typeToken.getStart()))) === null || _c === void 0 ? void 0 : _c.resolved;
+                if (!(resolved instanceof _typed_identifier_1.TypedIdentifier)) {
+                    continue;
+                }
+                const type = resolved.getType();
+                if (type instanceof basic_1.TableType && this.isRangeRow(type.getRowType())) {
+                    const header = new Map();
+                    for (const child of body.getChildren()) {
+                        if (!(child instanceof nodes_1.ExpressionNode)) {
+                            continue;
+                        }
+                        else if (child.get() instanceof Expressions.FieldAssignment) {
+                            this.addAssignment(header, child);
+                        }
+                        else if (child.get() instanceof Expressions.ValueBodyLine) {
+                            const assignments = child.findDirectExpressions(Expressions.FieldAssignment);
+                            if (assignments.length === 0) {
+                                continue;
+                            }
+                            const row = new Map(header);
+                            for (const a of assignments) {
+                                this.addAssignment(row, a);
+                            }
+                            issues.push(...this.checkRow(file, child, row));
+                        }
+                    }
+                }
+                else if (this.isRangeRow(type) && body.findDirectExpression(Expressions.ValueBase) === undefined) {
+                    const assignments = body.findDirectExpressions(Expressions.FieldAssignment);
+                    if (assignments.length === 0) {
+                        continue;
+                    }
+                    const row = new Map();
+                    for (const a of assignments) {
+                        this.addAssignment(row, a);
+                    }
+                    issues.push(...this.checkRow(file, body, row));
+                }
+            }
+        }
+        return issues;
+    }
+    ////////////////
+    isRangeRow(type) {
+        if (!(type instanceof basic_1.StructureType)) {
+            return false;
+        }
+        const names = type.getComponents().map(c => c.name.toUpperCase());
+        return names.length === RANGE_COMPONENTS.length && RANGE_COMPONENTS.every(c => names.includes(c));
+    }
+    addAssignment(row, assignment) {
+        var _a;
+        const name = (_a = assignment.findDirectExpression(Expressions.FieldSub)) === null || _a === void 0 ? void 0 : _a.concatTokens().toUpperCase();
+        const source = assignment.findDirectExpression(Expressions.Source);
+        if (name && source) {
+            row.set(name, source);
+        }
+    }
+    checkRow(file, node, row) {
+        const issues = [];
+        for (const [component, allowed] of [["SIGN", SIGNS], ["OPTION", OPTIONS]]) {
+            const source = row.get(component);
+            if (source === undefined) {
+                const message = `Specification ${component} is missing in the range row`;
+                issues.push(issue_1.Issue.atToken(file, node.getFirstToken(), message, this.getMetadata().key, this.conf.severity));
+                continue;
+            }
+            const value = this.literal(source);
+            if (value !== undefined && !allowed.includes(value)) {
+                const message = `"${value}" is not a permitted value for ${component}, expected ${allowed.join(" ")}`;
+                issues.push(issue_1.Issue.atToken(file, source.getFirstToken(), message, this.getMetadata().key, this.conf.severity));
+            }
+        }
+        return issues;
+    }
+    /** The content of a character literal, undefined for anything else */
+    literal(source) {
+        var _a, _b;
+        if (source.getChildren().length !== 1) {
+            return undefined;
+        }
+        const str = (_b = (_a = source.findDirectExpression(Expressions.Constant)) === null || _a === void 0 ? void 0 : _a.findDirectExpression(Expressions.ConstantString)) === null || _b === void 0 ? void 0 : _b.getFirstToken().getStr();
+        if (str === undefined) {
+            return undefined;
+        }
+        const quote = str.charAt(0);
+        return str.slice(1, -1).split(quote + quote).join(quote);
+    }
+}
+exports.RangeRowValues = RangeRowValues;
+//# sourceMappingURL=range_row_values.js.map

package/build/src/rules/selection_screen_naming.js

@@ -24,6 +24,7 @@ class SelectionScreenNaming extends _abap_rule_1.ABAPRule {
     constructor() {
         super(...arguments);
         this.conf = new SelectionScreenNamingConf();
+        this.regex = this.compile();
     }
     getMetadata() {
         return {
@@ -43,6 +44,15 @@ class SelectionScreenNaming extends _abap_rule_1.ABAPRule {
     }
     setConfig(conf) {
         this.conf = conf;
+        this.regex = this.compile();
+    }
+    compile() {
+        return {
+            parameter: new RegExp(this.conf.parameter, "i"),
+            selectOption: new RegExp(this.conf.selectOption, "i"),
+            screenElement: new RegExp(this.conf.screenElement, "i"),
+            ignorePatterns: name_validator_1.NameValidator.compileIgnorePatterns(this.conf),
+        };
     }
     runParsed(file) {
         const issues = [];
@@ -66,8 +76,8 @@ class SelectionScreenNaming extends _abap_rule_1.ABAPRule {
                 || (stat.get() instanceof statements_1.SelectOption && !selectOptionDisabled)
                 || (stat.get() instanceof statements_1.SelectionScreen && !screenElementDisabled)) {
                 const fieldNode = this.getFieldForStatementNode(stat);
-                const regex = new RegExp(this.getPatternForStatement(stat.get()), "i");
-                if (fieldNode && name_validator_1.NameValidator.violatesRule(fieldNode.getFirstToken().getStr(), regex, this.conf)) {
+                const regex = this.getRegexForStatement(stat.get());
+                if (fieldNode && name_validator_1.NameValidator.violatesRule(fieldNode.getFirstToken().getStr(), regex, this.conf, this.regex.ignorePatterns)) {
                     issues.push(issue_1.Issue.atToken(file, fieldNode.getFirstToken(), this.getDescription(this.getPatternForStatement(stat.get()), fieldNode.getFirstToken().getStr()), this.getMetadata().key, this.conf.severity));
                 }
             }
@@ -87,6 +97,15 @@ class SelectionScreenNaming extends _abap_rule_1.ABAPRule {
         }
         return pattern;
     }
+    getRegexForStatement(statement) {
+        if (statement instanceof statements_1.Parameter) {
+            return this.regex.parameter;
+        }
+        else if (statement instanceof statements_1.SelectOption) {
+            return this.regex.selectOption;
+        }
+        return this.regex.screenElement;
+    }
     getFieldForStatementNode(statNode) {
         if (statNode.get() instanceof statements_1.Parameter) {
             return statNode.findFirstExpression(expressions_1.FieldSub);

package/build/src/rules/sicf_consistency.js

@@ -57,8 +57,7 @@ class SICFConsistency {
                 if (this.conf.skipNames && this.conf.skipNames.some((a) => a.toUpperCase() === h.toUpperCase())) {
                     continue;
                 }
-                const pattern = new RegExp(this.reg.getConfig().getSyntaxSetttings().errorNamespace, "i");
-                if (pattern.test(h) === true) {
+                if (this.reg.inErrorNamespace(h) === true) {
                     const message = "Handler class " + h + " not found";
                     const issue = issue_1.Issue.atPosition(obj.getFiles()[0], new position_1.Position(1, 1), message, this.getMetadata().key, this.conf.severity);
                     issues.push(issue);

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