@abaplint/core 2.120.57 → 2.120.58

package/build/src/registry.js

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

package/build/src/rules/index.js

@@ -149,7 +149,9 @@ __exportStar(require("./prefer_insert_into_table"), exports);
 __exportStar(require("./prefer_is_not"), exports);
 __exportStar(require("./prefer_pragmas"), exports);
 __exportStar(require("./prefer_abap_bool"), exports);
+__exportStar(require("./prefer_abap_bool_values"), exports);
 __exportStar(require("./prefer_raise_exception_new"), exports);
+__exportStar(require("./prefer_string_template"), exports);
 __exportStar(require("./prefer_returning_to_exporting"), exports);
 __exportStar(require("./prefer_xsdbool"), exports);
 __exportStar(require("./preferred_compare_operator"), exports);

package/build/src/rules/prefer_abap_bool_values.js

@@ -0,0 +1,256 @@
+"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.PreferAbapBoolValues = exports.PreferAbapBoolValuesConf = void 0;
+const issue_1 = require("../issue");
+const _abap_rule_1 = require("./_abap_rule");
+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 _irule_1 = require("./_irule");
+const edit_helper_1 = require("../edit_helper");
+const nodes_1 = require("../abap/nodes");
+const ABAP_BOOL = "ABAP_BOOL";
+const ABAP_TRUE = "abap_true";
+const ABAP_FALSE = "abap_false";
+const VALID_VALUES = new Set(["ABAP_TRUE", "ABAP_FALSE", "ABAP_UNDEFINED"]);
+class PreferAbapBoolValuesConf extends _basic_rule_config_1.BasicRuleConfig {
+}
+exports.PreferAbapBoolValuesConf = PreferAbapBoolValuesConf;
+class PreferAbapBoolValues extends _abap_rule_1.ABAPRule {
+    constructor() {
+        super(...arguments);
+        this.conf = new PreferAbapBoolValuesConf();
+    }
+    getMetadata() {
+        return {
+            key: "prefer_abap_bool_values",
+            title: "Prefer abap_true and abap_false",
+            shortDescription: `Use abap_true and abap_false instead of 'X' and ' ' for abap_bool variables`,
+            // eslint-disable-next-line max-len
+            extendedInformation: `https://github.com/SAP/styleguides/blob/main/clean-abap/CleanABAP.md#use-abap_true-abap_false-and-abap_undefined-for-abap_bool-variables`,
+            tags: [_irule_1.RuleTag.Styleguide, _irule_1.RuleTag.SingleFile, _irule_1.RuleTag.Quickfix],
+            badExample: `DATA lv_flag TYPE abap_bool.\nlv_flag = 'X'.`,
+            goodExample: `DATA lv_flag TYPE abap_bool.\nlv_flag = abap_true.`,
+        };
+    }
+    getConfig() {
+        return this.conf;
+    }
+    setConfig(conf) {
+        this.conf = conf;
+    }
+    runParsed(file) {
+        const issues = [];
+        const structure = file.getStructure();
+        if (structure === undefined) {
+            return [];
+        }
+        const boolVars = this.collectBoolVars(file);
+        // Check Move statements: target = source
+        for (const stat of structure.findAllStatements(Statements.Move)) {
+            const target = stat.findFirstExpression(Expressions.Target);
+            const source = stat.findFirstExpression(Expressions.Source);
+            if (target === undefined || source === undefined) {
+                continue;
+            }
+            const targetName = target.concatTokens().toUpperCase();
+            if (!boolVars.has(targetName)) {
+                continue;
+            }
+            this.checkSourceNode(source, file, issues);
+        }
+        // Check comparisons: IF/ELSEIF conditions
+        const compareStatements = [
+            ...structure.findAllStatements(Statements.If),
+            ...structure.findAllStatements(Statements.ElseIf),
+        ];
+        for (const stat of compareStatements) {
+            const cond = stat.findFirstExpression(Expressions.Cond);
+            if (cond === undefined) {
+                continue;
+            }
+            for (const compare of cond.findAllExpressions(Expressions.Compare)) {
+                this.checkCompareBoolLiteral(compare, boolVars, file, issues);
+            }
+        }
+        return issues;
+    }
+    collectBoolVars(file) {
+        var _a;
+        const boolVars = new Set();
+        const structure = file.getStructure();
+        if (structure === undefined) {
+            return boolVars;
+        }
+        const statements = [
+            ...structure.findAllStatements(Statements.Data),
+            ...structure.findAllStatements(Statements.ClassData),
+            ...structure.findAllStatements(Statements.FieldSymbol),
+        ];
+        for (const stat of statements) {
+            const typeNameExpr = stat.findFirstExpression(Expressions.TypeName);
+            if (typeNameExpr === undefined) {
+                continue;
+            }
+            if (typeNameExpr.concatTokens().toUpperCase() !== ABAP_BOOL) {
+                continue;
+            }
+            const nameExpr = (_a = stat.findFirstExpression(Expressions.DefinitionName)) !== null && _a !== void 0 ? _a : stat.findFirstExpression(Expressions.FieldSymbol);
+            if (nameExpr === undefined) {
+                continue;
+            }
+            boolVars.add(nameExpr.concatTokens().toUpperCase());
+        }
+        return boolVars;
+    }
+    checkSourceNode(source, file, issues) {
+        const firstToken = source.getFirstToken().getStr().toUpperCase();
+        if (firstToken === "COND") {
+            const condBody = source.findDirectExpression(Expressions.CondBody);
+            if (condBody) {
+                this.checkCondBodyBranches(condBody, file, issues);
+            }
+            return;
+        }
+        if (firstToken === "SWITCH") {
+            const switchBody = source.findDirectExpression(Expressions.SwitchBody);
+            if (switchBody) {
+                this.checkSwitchBodyBranches(switchBody, file, issues);
+            }
+            return;
+        }
+        // Plain literal assignment
+        const issue = this.checkLiteralSource(source, file);
+        if (issue) {
+            issues.push(issue);
+        }
+    }
+    checkLiteralSource(source, file) {
+        const constantStr = source.findFirstExpression(Expressions.ConstantString);
+        if (constantStr === undefined) {
+            return undefined;
+        }
+        const token = constantStr.getFirstToken();
+        const val = token.getStr();
+        if (val === "'X'") {
+            const fix = edit_helper_1.EditHelper.replaceToken(file, token, ABAP_TRUE);
+            return issue_1.Issue.atToken(file, token, `Use ${ABAP_TRUE} instead of 'X'`, this.getMetadata().key, this.conf.severity, fix);
+        }
+        if (val === "' '") {
+            const fix = edit_helper_1.EditHelper.replaceToken(file, token, ABAP_FALSE);
+            return issue_1.Issue.atToken(file, token, `Use ${ABAP_FALSE} instead of ' '`, this.getMetadata().key, this.conf.severity, fix);
+        }
+        return undefined;
+    }
+    checkCondBodyBranches(condBody, file, issues) {
+        // CondBody: WHEN <cond> THEN <source> [WHEN <cond> THEN <source>]* [ELSE <source>]
+        // Walk children; Source nodes after THEN/ELSE are the result values
+        let afterThenOrElse = false;
+        for (const child of condBody.getChildren()) {
+            const tokenStr = child.getFirstToken().getStr().toUpperCase();
+            if (tokenStr === "THEN" || tokenStr === "ELSE") {
+                afterThenOrElse = true;
+                continue;
+            }
+            if (tokenStr === "WHEN") {
+                afterThenOrElse = false;
+                continue;
+            }
+            if (afterThenOrElse && child instanceof nodes_1.ExpressionNode && child.get() instanceof Expressions.Source) {
+                const issue = this.checkLiteralSource(child, file);
+                if (issue) {
+                    issues.push(issue);
+                }
+                afterThenOrElse = false;
+            }
+        }
+    }
+    checkSwitchBodyBranches(switchBody, file, issues) {
+        // SwitchBody: <source> WHEN <val> [OR <val>]* THEN <source> [ELSE <source>]
+        // First Source is the operand; Source after THEN/ELSE are result values
+        let firstSourceSeen = false;
+        let afterThenOrElse = false;
+        for (const child of switchBody.getChildren()) {
+            const tokenStr = child.getFirstToken().getStr().toUpperCase();
+            if (tokenStr === "THEN" || tokenStr === "ELSE") {
+                afterThenOrElse = true;
+                continue;
+            }
+            if (tokenStr === "WHEN" || tokenStr === "OR") {
+                afterThenOrElse = false;
+                continue;
+            }
+            if (child instanceof nodes_1.ExpressionNode && child.get() instanceof Expressions.Source) {
+                if (!firstSourceSeen) {
+                    firstSourceSeen = true;
+                    continue;
+                }
+                if (afterThenOrElse) {
+                    const issue = this.checkLiteralSource(child, file);
+                    if (issue) {
+                        issues.push(issue);
+                    }
+                    afterThenOrElse = false;
+                }
+            }
+        }
+    }
+    checkCompareBoolLiteral(compare, boolVars, file, issues) {
+        // Compare: Source CompareOperator Source  (or other forms)
+        const sources = compare.findDirectExpressions(Expressions.Source);
+        if (sources.length < 2) {
+            return;
+        }
+        const [left, right] = sources;
+        const leftStr = left.concatTokens().toUpperCase();
+        const rightStr = right.concatTokens().toUpperCase();
+        let literalSource;
+        if (boolVars.has(leftStr) && !VALID_VALUES.has(rightStr)) {
+            literalSource = right;
+        }
+        else if (boolVars.has(rightStr) && !VALID_VALUES.has(leftStr)) {
+            literalSource = left;
+        }
+        if (literalSource) {
+            const issue = this.checkLiteralSource(literalSource, file);
+            if (issue) {
+                issues.push(issue);
+            }
+        }
+    }
+}
+exports.PreferAbapBoolValues = PreferAbapBoolValues;
+//# sourceMappingURL=prefer_abap_bool_values.js.map

package/build/src/rules/prefer_string_template.js

@@ -0,0 +1,135 @@
+"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.PreferStringTemplate = exports.PreferStringTemplateConf = void 0;
+const issue_1 = require("../issue");
+const _abap_rule_1 = require("./_abap_rule");
+const Expressions = __importStar(require("../abap/2_statements/expressions"));
+const _basic_rule_config_1 = require("./_basic_rule_config");
+const _irule_1 = require("./_irule");
+const nodes_1 = require("../abap/nodes");
+const edit_helper_1 = require("../edit_helper");
+class PreferStringTemplateConf extends _basic_rule_config_1.BasicRuleConfig {
+}
+exports.PreferStringTemplateConf = PreferStringTemplateConf;
+class PreferStringTemplate extends _abap_rule_1.ABAPRule {
+    constructor() {
+        super(...arguments);
+        this.conf = new PreferStringTemplateConf();
+    }
+    getMetadata() {
+        return {
+            key: "prefer_string_template",
+            title: "Prefer string template over &&",
+            shortDescription: `Use string templates instead of && to assemble text`,
+            extendedInformation: `https://github.com/SAP/styleguides/blob/main/clean-abap/CleanABAP.md#use--to-assemble-text`,
+            tags: [_irule_1.RuleTag.Styleguide, _irule_1.RuleTag.SingleFile, _irule_1.RuleTag.Quickfix],
+            badExample: `DATA(msg) = \`Hello \` && name && \`!\`.`,
+            goodExample: `DATA(msg) = |Hello { name }!|.`,
+        };
+    }
+    getConfig() {
+        return this.conf;
+    }
+    setConfig(conf) {
+        this.conf = conf;
+    }
+    runParsed(file) {
+        const issues = [];
+        const structure = file.getStructure();
+        if (structure === undefined) {
+            return [];
+        }
+        const allSources = structure.findAllExpressions(Expressions.Source);
+        // collect all Source nodes that appear as the RHS (children[2]) of a && expression
+        const rhsChildren = new Set();
+        for (const source of allSources) {
+            const children = source.getChildren();
+            if (children.length === 3 && children[1].getFirstToken().getStr() === "&&") {
+                rhsChildren.add(children[2]);
+            }
+        }
+        for (const source of allSources) {
+            const children = source.getChildren();
+            if (children.length !== 3) {
+                continue;
+            }
+            if (children[1].getFirstToken().getStr() !== "&&") {
+                continue;
+            }
+            // only process top-level && roots (not nested RHS children)
+            if (rhsChildren.has(source)) {
+                continue;
+            }
+            const operands = this.flattenChain(source);
+            if (!operands.some(op => { const c = op.getFirstToken().getStr()[0]; return c === "'" || c === "`"; })) {
+                continue;
+            }
+            const template = this.buildTemplate(operands);
+            const start = source.getFirstToken().getStart();
+            const end = source.getLastToken().getEnd();
+            const fix = edit_helper_1.EditHelper.replaceRange(file, start, end, template);
+            const token = children[1].getFirstToken();
+            issues.push(issue_1.Issue.atToken(file, token, "Use string template instead of &&", this.getMetadata().key, this.conf.severity, fix));
+        }
+        return issues;
+    }
+    flattenChain(node) {
+        const children = node.getChildren();
+        if (children.length === 3 && children[1].getFirstToken().getStr() === "&&") {
+            return [...this.flattenChain(children[0]), ...this.flattenChain(children[2])];
+        }
+        if (children.length === 1 && children[0] instanceof nodes_1.ExpressionNode) {
+            return this.flattenChain(children[0]);
+        }
+        return [node];
+    }
+    buildTemplate(operands) {
+        let inner = "";
+        for (const op of operands) {
+            const raw = op.getFirstToken().getStr();
+            const firstChar = raw[0];
+            if (firstChar === "'" || firstChar === "`") {
+                inner += raw.slice(1, -1);
+            }
+            else {
+                inner += `{ ${op.concatTokens()} }`;
+            }
+        }
+        return `|${inner}|`;
+    }
+}
+exports.PreferStringTemplate = PreferStringTemplate;
+//# sourceMappingURL=prefer_string_template.js.map

package/package.json

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