@abaplint/core 2.106.9 → 2.107.0

package/build/abaplint.d.ts

@@ -6490,10 +6490,7 @@ declare class Table extends AbstractObject {
     private parsedData;
     getType(): string;
     getDescription(): string | undefined;
-    getAllowedNaming(): {
-        maxLength: number;
-        allowNamespace: boolean;
-    };
+    getAllowedNaming(): IAllowedNaming;
     setDirty(): void;
     listKeys(reg: IRegistry): string[];
     parseType(reg: IRegistry): AbstractType;

package/build/src/objects/table.js

@@ -35,12 +35,14 @@ class Table extends _abstract_object_1.AbstractObject {
     }
     getAllowedNaming() {
         let length = 30;
+        const regex = /^((\/[A-Z_\d]{3,8}\/)|[a-zA-Z0-9]{3})\w+$/;
         if (this.getTableCategory() === TableCategory.Transparent) {
             length = 16;
         }
         return {
             maxLength: length,
             allowNamespace: true,
+            customRegex: regex,
         };
     }
     setDirty() {

package/build/src/registry.js

@@ -65,7 +65,7 @@ class Registry {
     }
     static abaplintVersion() {
         // magic, see build script "version.sh"
-        return "2.106.9";
+        return "2.107.0";
     }
     getDDICReferences() {
         return this.ddicReferences;

package/build/src/rules/align_type_expressions.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlignTypeExpressions = exports.AlignTypeExpressionsConf = void 0;
+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 Structures = require("../abap/3_structures/structures");
+const Statements = require("../abap/2_statements/statements");
+const Expressions = require("../abap/2_statements/expressions");
+/*
+import {EditHelper, IEdit} from "../edit_helper";
+*/
+class AlignTypeExpressionsConf extends _basic_rule_config_1.BasicRuleConfig {
+}
+exports.AlignTypeExpressionsConf = AlignTypeExpressionsConf;
+class AlignTypeExpressions extends _abap_rule_1.ABAPRule {
+    constructor() {
+        super(...arguments);
+        this.conf = new AlignTypeExpressionsConf();
+    }
+    getMetadata() {
+        return {
+            key: "align_type_expressions",
+            title: "Align TYPE expressions",
+            shortDescription: `Align TYPE expressions in statements`,
+            extendedInformation: `
+Currently works for METHODS + BEGIN OF
+
+Also note that clean ABAP does not recommend aligning TYPE clauses:
+https://github.com/SAP/styleguides/blob/main/clean-abap/CleanABAP.md#dont-align-type-clauses`,
+            tags: [_irule_1.RuleTag.SingleFile, _irule_1.RuleTag.Whitespace],
+            badExample: `
+TYPES: BEGIN OF foo,
+         bar TYPE i,
+         foobar TYPE i,
+       END OF foo.
+
+INTERFACE lif.
+  METHODS bar
+    IMPORTING
+      foo TYPE i
+      foobar TYPE i.
+ENDINTERFACE.`,
+            goodExample: `
+TYPES: BEGIN OF foo,
+         bar    TYPE i,
+         foobar TYPE i,
+       END OF foo.
+
+INTERFACE lif.
+  METHODS bar
+    IMPORTING
+      foo    TYPE i
+      foobar TYPE i.
+ENDINTERFACE.`,
+        };
+    }
+    getConfig() {
+        return this.conf;
+    }
+    setConfig(conf) {
+        this.conf = conf;
+    }
+    runParsed(file) {
+        const issues = [];
+        const stru = file.getStructure();
+        if (stru === undefined) {
+            return issues; // parser error
+        }
+        issues.push(...this.checkTypes(stru, file));
+        issues.push(...this.checkMethods(stru, file));
+        return issues;
+    }
+    checkMethods(stru, file) {
+        const issues = [];
+        const methods = stru.findAllStatements(Statements.MethodDef);
+        for (const m of methods) {
+            const fields = [];
+            const params = m.findAllExpressions(Expressions.MethodParam);
+            let column = 0;
+            for (const p of params) {
+                const children = p.getChildren();
+                const name = children[children.length - 2];
+                fields.push({
+                    nameEnd: name.getLastToken().getEnd(),
+                    after: p.findFirstExpression(Expressions.TypeParam).getFirstToken().getStart()
+                });
+                column = Math.max(column, name.getFirstToken().getEnd().getCol() + 1);
+            }
+            const ret = m.findFirstExpression(Expressions.MethodDefReturning);
+            if (ret) {
+                const children = ret.getChildren();
+                const name = children[children.length - 2];
+                fields.push({
+                    nameEnd: name.getLastToken().getEnd(),
+                    after: ret.findFirstExpression(Expressions.TypeParam).getFirstToken().getStart()
+                });
+                column = Math.max(column, name.getLastToken().getEnd().getCol() + 1);
+            }
+            for (const f of fields) {
+                if (f.after.getCol() !== column) {
+                    //          const fix = this.buildFix(f.name, column);
+                    const message = `Align TYPE expressions to column ${column}`;
+                    const issue = issue_1.Issue.atPosition(file, f.after, message, this.getMetadata().key, this.conf.severity);
+                    issues.push(issue);
+                }
+            }
+        }
+        return issues;
+    }
+    checkTypes(stru, file) {
+        const issues = [];
+        const types = stru.findAllStructuresRecursive(Structures.Types);
+        for (const t of types) {
+            const fields = [];
+            let column = 0;
+            const st = t.findDirectStatements(Statements.Type);
+            for (const s of st) {
+                const name = s.getChildren()[1];
+                fields.push({
+                    nameEnd: name.getLastToken().getEnd(),
+                    after: s.getChildren()[2].getFirstToken().getStart()
+                });
+                column = Math.max(column, name.getFirstToken().getEnd().getCol() + 1);
+            }
+            for (const f of fields) {
+                if (f.after.getCol() !== column) {
+                    //          const fix = this.buildFix(f.name, column);
+                    const message = `Align TYPE expressions to column ${column}`;
+                    const issue = issue_1.Issue.atPosition(file, f.after, message, this.getMetadata().key, this.conf.severity);
+                    issues.push(issue);
+                }
+            }
+        }
+        return issues;
+    }
+}
+exports.AlignTypeExpressions = AlignTypeExpressions;
+//# sourceMappingURL=align_type_expressions.js.map

package/build/src/rules/index.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./7bit_ascii"), exports);
 __exportStar(require("./abapdoc"), exports);
 __exportStar(require("./align_parameters"), exports);
+__exportStar(require("./align_type_expressions"), exports);
 __exportStar(require("./allowed_object_naming"), exports);
 __exportStar(require("./allowed_object_types"), exports);
 __exportStar(require("./ambiguous_statement"), exports);

package/package.json

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