@abaplint/core 2.120.77 → 2.120.78

package/build/src/registry.js

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

package/build/src/rules/index.js

@@ -105,6 +105,7 @@ __exportStar(require("./inline_data_old_versions"), exports);
 __exportStar(require("./inline_packed_computation"), exports);
 __exportStar(require("./intf_referencing_clas"), exports);
 __exportStar(require("./invalid_table_index"), exports);
+__exportStar(require("./is_assigned_in_loop"), exports);
 __exportStar(require("./keep_single_parameter_on_one_line"), exports);
 __exportStar(require("./keyword_case"), exports);
 __exportStar(require("./line_break_multiple_parameters"), exports);
@@ -170,6 +171,7 @@ __exportStar(require("./prefix_is_current_class"), exports);
 __exportStar(require("./range_row_values"), exports);
 __exportStar(require("./reduce_procedural_code"), exports);
 __exportStar(require("./reduce_string_templates"), exports);
+__exportStar(require("./redundant_cast"), exports);
 __exportStar(require("./redundant_conversion"), exports);
 __exportStar(require("./release_idoc"), exports);
 __exportStar(require("./remove_descriptions"), exports);

package/build/src/rules/is_assigned_in_loop.js

@@ -0,0 +1,242 @@
+"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.IsAssignedInLoop = exports.IsAssignedInLoopConf = 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 edit_helper_1 = require("../edit_helper");
+const severity_1 = require("../severity");
+class IsAssignedInLoopConf extends _basic_rule_config_1.BasicRuleConfig {
+    constructor() {
+        super(...arguments);
+        this.severity = severity_1.Severity.Warning;
+    }
+}
+exports.IsAssignedInLoopConf = IsAssignedInLoopConf;
+class IsAssignedInLoop extends _abap_rule_1.ABAPRule {
+    constructor() {
+        super(...arguments);
+        this.conf = new IsAssignedInLoopConf();
+    }
+    getMetadata() {
+        return {
+            key: "is_assigned_in_loop",
+            title: "IS ASSIGNED after READ TABLE or ASSIGN in a loop",
+            shortDescription: `Reports IS [NOT] ASSIGNED after a READ TABLE ... ASSIGNING or ASSIGN inside a loop, without UNASSIGN before it`,
+            extendedInformation: `A failed READ TABLE ... ASSIGNING or ASSIGN keeps the previous binding of the field symbol. Inside a
+loop, the field symbol still points to the row of an earlier iteration, so IS ASSIGNED is true
+although the statement failed, and the code goes on with the wrong row.
+
+Add UNASSIGN <fs> before the statement, inside the loop, or check sy-subrc after a READ TABLE.
+The quick fix inserts the UNASSIGN; it is not offered for a field symbol declared inline in
+the statement, or for a chained statement.
+
+Not reported: a check that also reads sy-subrc, an ASSIGN that cannot fail (a static source
+without dereference, table expression or dynamic part), and loops outside of the
+method, form or function module of the statement. See also subrc_after_assign.`,
+            tags: [_irule_1.RuleTag.SingleFile, _irule_1.RuleTag.Quickfix],
+            badExample: `LOOP AT lt_cells INTO ls_cell.
+  READ TABLE lt_styles ASSIGNING <style> WITH KEY id = ls_cell-style.
+  IF <style> IS ASSIGNED.
+    ls_cell-format = <style>-format.
+  ENDIF.
+ENDLOOP.`,
+            goodExample: `LOOP AT lt_cells INTO ls_cell.
+  UNASSIGN <style>.
+  READ TABLE lt_styles ASSIGNING <style> WITH KEY id = ls_cell-style.
+  IF <style> IS ASSIGNED.
+    ls_cell-format = <style>-format.
+  ENDIF.
+ENDLOOP.`,
+        };
+    }
+    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];
+            const name = this.boundByFailable(statement);
+            if (name === undefined) {
+                continue;
+            }
+            const fs = name.toUpperCase();
+            const loop = this.innermostLoop(i, statements);
+            if (loop === undefined || this.unassignedBefore(loop, i, statements, fs) === true) {
+                continue;
+            }
+            const check = this.nextCheck(i, statements, fs);
+            if (check === undefined) {
+                continue;
+            }
+            const read = statement.get() instanceof Statements.ReadTable;
+            const message = `${read ? "READ TABLE" : "ASSIGN"} in a loop keeps the previous binding of ${name} when it fails, `
+                + `UNASSIGN ${name} before it` + (read ? " or check sy-subrc" : "");
+            const fix = this.buildFix(file, statement, name);
+            issues.push(issue_1.Issue.atStatement(file, check, message, this.getMetadata().key, this.conf.severity, fix));
+        }
+        return issues;
+    }
+    ////////////////
+    /** the field symbol bound by a READ TABLE ... ASSIGNING or an ASSIGN that can fail */
+    boundByFailable(statement) {
+        var _a, _b, _c;
+        const s = statement.get();
+        if (s instanceof Statements.ReadTable) {
+            const target = (_a = statement.findDirectExpression(Expressions.ReadTableTarget)) === null || _a === void 0 ? void 0 : _a.findDirectExpression(Expressions.FSTarget);
+            return (_b = target === null || target === void 0 ? void 0 : target.findFirstExpression(Expressions.FieldSymbol)) === null || _b === void 0 ? void 0 : _b.concatTokens();
+        }
+        else if (s instanceof Statements.Assign) {
+            const source = statement.findDirectExpression(Expressions.AssignSource);
+            if (source === undefined) {
+                return undefined;
+            }
+            const first = source.getFirstToken().getStr().toUpperCase();
+            const failable = first === "COMPONENT"
+                || first === "TABLE"
+                || source.findFirstExpression(Expressions.Dynamic) !== undefined
+                || source.findFirstExpression(Expressions.Dereference) !== undefined
+                || source.findFirstExpression(Expressions.TableExpression) !== undefined
+                || statement.findDirectTokenByText("INCREMENT") !== undefined;
+            if (failable === false) {
+                return undefined;
+            }
+            const target = statement.findDirectExpression(Expressions.FSTarget);
+            return (_c = target === null || target === void 0 ? void 0 : target.findFirstExpression(Expressions.FieldSymbol)) === null || _c === void 0 ? void 0 : _c.concatTokens();
+        }
+        return undefined;
+    }
+    /** index of the innermost LOOP, DO, WHILE or SELECT loop around the statement, in the same block */
+    innermostLoop(index, statements) {
+        let depth = 0;
+        for (let i = index - 1; i >= 0 && this.startsBlock(statements[i]) === false; i--) {
+            if (this.endsLoop(statements[i])) {
+                depth++;
+            }
+            else if (this.startsLoop(statements[i])) {
+                if (depth === 0) {
+                    return i;
+                }
+                depth--;
+            }
+        }
+        return undefined;
+    }
+    unassignedBefore(loop, index, statements, fs) {
+        for (let i = loop + 1; i < index; i++) {
+            if (statements[i].get() instanceof Statements.Unassign && this.mentions(statements[i], fs)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** the first IS [NOT] ASSIGNED of the field symbol after the statement, before the end of the loop
+     * or another UNASSIGN or binding of it; a check that also reads sy-subrc is fine */
+    nextCheck(index, statements, fs) {
+        let depth = 0;
+        for (let i = index + 1; i < statements.length && this.startsBlock(statements[i]) === false; i++) {
+            const statement = statements[i];
+            if (this.startsLoop(statement)) {
+                depth++;
+            }
+            else if (this.endsLoop(statement)) {
+                if (depth === 0) {
+                    return undefined;
+                }
+                depth--;
+            }
+            const concat = statement.concatTokens().toUpperCase();
+            if (concat.includes(fs + " IS ASSIGNED") || concat.includes(fs + " IS NOT ASSIGNED")) {
+                return concat.includes("SY-SUBRC") ? undefined : statement;
+            }
+            if ((statement.get() instanceof Statements.Unassign && this.mentions(statement, fs))
+                || this.binds(statement, fs)) {
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    mentions(statement, fs) {
+        return statement.findAllExpressions(Expressions.FieldSymbol).some(e => e.concatTokens().toUpperCase() === fs);
+    }
+    binds(statement, fs) {
+        return statement.findAllExpressions(Expressions.FSTarget)
+            .some(t => { var _a; return ((_a = t.findFirstExpression(Expressions.FieldSymbol)) === null || _a === void 0 ? void 0 : _a.concatTokens().toUpperCase()) === fs; });
+    }
+    startsLoop(statement) {
+        const s = statement.get();
+        return s instanceof Statements.Loop
+            || s instanceof Statements.Do
+            || s instanceof Statements.While
+            || s instanceof Statements.SelectLoop;
+    }
+    endsLoop(statement) {
+        const s = statement.get();
+        return s instanceof Statements.EndLoop
+            || s instanceof Statements.EndDo
+            || s instanceof Statements.EndWhile
+            || s instanceof Statements.EndSelect;
+    }
+    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;
+    }
+    /** UNASSIGN on a line of its own before the statement, with the same indentation */
+    buildFix(file, statement, name) {
+        if (statement.getColon() !== undefined || statement.findFirstExpression(Expressions.InlineFS) !== undefined) {
+            return undefined;
+        }
+        const start = statement.getStart();
+        return edit_helper_1.EditHelper.insertAt(file, start, `UNASSIGN ${name}.\n` + " ".repeat(start.getCol() - 1));
+    }
+}
+exports.IsAssignedInLoop = IsAssignedInLoop;
+//# sourceMappingURL=is_assigned_in_loop.js.map

package/build/src/rules/many_parentheses.js

@@ -144,7 +144,11 @@ ENDIF.
                 && lastChildren[1].getChildren().length === 1
                 && lastChildren[1].getFirstToken().getStr().startsWith("-") === false
                 && lastChildren[2].getFirstToken().getStr() === ")") {
-                const issue = issue_1.Issue.atToken(file, lastChildren[0].getFirstToken(), "Too many parentheses", this.getMetadata().key, this.conf.severity);
+                const fixText = lastChildren[1].concatTokens();
+                const start = lastChildren[0].getFirstToken().getStart();
+                const end = lastChildren[2].getLastToken().getEnd();
+                const fix = edit_helper_1.EditHelper.replaceRange(file, start, end, fixText);
+                const issue = issue_1.Issue.atToken(file, lastChildren[0].getFirstToken(), "Too many parentheses", this.getMetadata().key, this.conf.severity, fix);
                 issues.push(issue);
             }
         }

package/build/src/rules/newline_between_methods.js

@@ -40,6 +40,8 @@ const _abap_rule_1 = require("./_abap_rule");
 const sequential_blank_1 = require("./sequential_blank");
 const Statements = __importStar(require("../abap/2_statements/statements"));
 const _irule_1 = require("./_irule");
+const edit_helper_1 = require("../edit_helper");
+const position_1 = require("../position");
 var NewlineLogic;
 (function (NewlineLogic) {
     NewlineLogic["Exact"] = "exact";
@@ -69,7 +71,7 @@ class NewlineBetweenMethods extends _abap_rule_1.ABAPRule {
             key: "newline_between_methods",
             title: "New line between methods",
             shortDescription: `Checks for newlines between method implementations.`,
-            tags: [_irule_1.RuleTag.Whitespace, _irule_1.RuleTag.SingleFile],
+            tags: [_irule_1.RuleTag.Whitespace, _irule_1.RuleTag.Quickfix, _irule_1.RuleTag.SingleFile],
         };
     }
     getMessage() {
@@ -98,18 +100,35 @@ class NewlineBetweenMethods extends _abap_rule_1.ABAPRule {
                 continue;
             }
             let counter = 0;
-            while (sequential_blank_1.SequentialBlank.isBlankOrWhitespace(rows[nextRow]) && (counter <= this.conf.count + 1)) {
+            while (sequential_blank_1.SequentialBlank.isBlankOrWhitespace(rows[nextRow])) {
                 counter++;
                 nextRow++;
             }
             if ((counter !== this.conf.count && this.conf.logic === NewlineLogic.Exact)
                 || (counter >= this.conf.count && this.conf.logic === NewlineLogic.Less)
                 || counter === 0) {
-                issues.push(issue_1.Issue.atStatement(file, statement, this.getMessage(), this.getMetadata().key, this.conf.severity));
+                const fix = this.buildFix(file, rows, statement.getStart().getRow(), counter);
+                issues.push(issue_1.Issue.atStatement(file, statement, this.getMessage(), this.getMetadata().key, this.conf.severity, fix));
             }
         }
         return issues;
     }
+    buildFix(file, rows, row, blanks) {
+        let target = this.conf.count;
+        if (this.conf.logic === NewlineLogic.Less) {
+            target = blanks === 0 ? 1 : this.conf.count - 1;
+        }
+        if (blanks < target) {
+            const end = new position_1.Position(row, rows[row - 1].length + 1);
+            return edit_helper_1.EditHelper.insertAt(file, end, "\n".repeat(target - blanks));
+        }
+        else if (blanks > target) {
+            const start = new position_1.Position(row + target, rows[row + target - 1].length + 1);
+            const end = new position_1.Position(row + blanks, rows[row + blanks - 1].length + 1);
+            return edit_helper_1.EditHelper.deleteRange(file, start, end);
+        }
+        return undefined;
+    }
     isConfigurationValid() {
         if (this.conf.count < 1 || (this.conf.count === 1 && this.conf.logic === NewlineLogic.Less)) {
             return false;

package/build/src/rules/redundant_cast.js

@@ -0,0 +1,157 @@
+"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.RedundantCast = exports.RedundantCastConf = 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 edit_helper_1 = require("../edit_helper");
+const version_1 = require("../version");
+class RedundantCastConf extends _basic_rule_config_1.BasicRuleConfig {
+}
+exports.RedundantCastConf = RedundantCastConf;
+class RedundantCast {
+    constructor() {
+        this.conf = new RedundantCastConf();
+    }
+    getMetadata() {
+        return {
+            key: "redundant_cast",
+            title: "Redundant Cast",
+            shortDescription: `Find redundant CAST expressions`,
+            extendedInformation: `Reports CAST expressions whose operand is already a reference to the cast's target class or interface.`,
+            tags: [_irule_1.RuleTag.Quickfix],
+            badExample: `DATA ref TYPE REF TO lcl.
+DATA(copy) = CAST lcl( ref ).`,
+            goodExample: `DATA ref TYPE REF TO lcl.
+DATA(copy) = ref.`,
+        };
+    }
+    getConfig() {
+        return this.conf;
+    }
+    setConfig(conf) {
+        this.conf = conf;
+    }
+    initialize(reg) {
+        this.reg = reg;
+        return this;
+    }
+    run(obj) {
+        var _a;
+        if (!(0, version_1.releaseAtLeast)(this.reg.getConfig().getRelease(), version_1.Release.v740sp02)
+            && !this.reg.getConfig().isOpenABAP()) {
+            return [];
+        }
+        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()) {
+            const structure = file.getStructure();
+            if (structure === undefined) {
+                continue;
+            }
+            for (const cast of structure.findAllExpressionsRecursive(Expressions.Cast)) {
+                const typeExpression = cast.findDirectExpression(Expressions.TypeNameOrInfer);
+                const source = cast.findDirectExpression(Expressions.Source);
+                if (typeExpression === undefined
+                    || source === undefined
+                    || cast.findDirectExpression(Expressions.Let) !== undefined) {
+                    continue;
+                }
+                const scope = syntax.spaghetti.lookupPosition(cast.getFirstToken().getStart(), file.getFilename());
+                if (scope === undefined) {
+                    continue;
+                }
+                const target = (_a = scope.getData().references.find(reference => reference.referenceType === _reference_1.ReferenceType.InferredType
+                    && reference.position.getStart().equals(typeExpression.getFirstToken().getStart()))) === null || _a === void 0 ? void 0 : _a.resolved;
+                if (!(target instanceof _typed_identifier_1.TypedIdentifier)) {
+                    continue;
+                }
+                const operandType = this.sourceType(source, scope);
+                if (operandType === undefined || this.sameType(target.getType(), operandType) === false) {
+                    continue;
+                }
+                const closingParen = cast.getDirectTokens().find(token => token.getStr() === ")" && token.getStart().isAfter(source.getLastToken().getStart()));
+                if (closingParen === undefined) {
+                    continue;
+                }
+                const fix = edit_helper_1.EditHelper.replaceRange(file, cast.getFirstToken().getStart(), closingParen.getEnd(), source.concatTokens());
+                issues.push(issue_1.Issue.atRange(file, cast.getFirstToken().getStart(), closingParen.getEnd(), "Redundant CAST expression", this.getMetadata().key, this.conf.severity, fix));
+            }
+        }
+        return issues;
+    }
+    /** The type of a plain variable or attribute, undefined for anything more complex */
+    sourceType(source, scope) {
+        var _a;
+        const children = source.getChildren();
+        if (children.length !== 1 || !(children[0].get() instanceof Expressions.FieldChain)) {
+            return undefined;
+        }
+        const fieldChain = children[0];
+        const last = fieldChain.getLastChild();
+        if (!(last instanceof nodes_1.ExpressionNode)
+            || !(last.get() instanceof Expressions.SourceField || last.get() instanceof Expressions.AttributeName)) {
+            return undefined;
+        }
+        const operand = (_a = scope.getData().references.find(reference => reference.referenceType === _reference_1.ReferenceType.DataReadReference
+            && reference.position.getStart().equals(last.getFirstToken().getStart()))) === null || _a === void 0 ? void 0 : _a.resolved;
+        if (!(operand instanceof _typed_identifier_1.TypedIdentifier)) {
+            return undefined;
+        }
+        return operand.getType();
+    }
+    sameType(first, second) {
+        if (!(first instanceof basic_1.ObjectReferenceType) || !(second instanceof basic_1.ObjectReferenceType)) {
+            return false;
+        }
+        return first.getIdentifierName().toUpperCase() === second.getIdentifierName().toUpperCase();
+    }
+}
+exports.RedundantCast = RedundantCast;
+//# sourceMappingURL=redundant_cast.js.map

package/package.json

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