@abaplint/core 2.106.8 → 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/abap/5_syntax/expressions/select.js

@@ -11,6 +11,7 @@ const _scope_type_1 = require("../_scope_type");
 const sql_source_1 = require("./sql_source");
 const sql_compare_1 = require("./sql_compare");
 const sql_order_by_1 = require("./sql_order_by");
+const dynamic_1 = require("./dynamic");
 const isSimple = /^\w+$/;
 class Select {
     runSyntax(node, scope, filename, skipImplicitInto = false) {
@@ -21,7 +22,7 @@ class Select {
         if (from === undefined) {
             throw new Error(`Missing FROM`);
         }
-        const fields = this.findFields(node);
+        const fields = this.findFields(node, scope, filename);
         if (fields.length === 0
             && node.findDirectExpression(Expressions.SQLFieldListLoop) === undefined) {
             throw new Error(`fields missing`);
@@ -179,17 +180,20 @@ class Select {
         }
         return new basic_1.VoidType("SELECT_todo");
     }
-    findFields(node) {
-        var _a;
+    findFields(node, scope, filename) {
+        var _a, _b;
         let expr = undefined;
         const ret = [];
         expr = node.findFirstExpression(Expressions.SQLFieldList);
         if (expr === undefined) {
             expr = node.findDirectExpression(Expressions.SQLFieldListLoop);
         }
+        if (((_a = expr === null || expr === void 0 ? void 0 : expr.getFirstChild()) === null || _a === void 0 ? void 0 : _a.get()) instanceof Expressions.Dynamic) {
+            new dynamic_1.Dynamic().runSyntax(expr.getFirstChild(), scope, filename);
+        }
         for (const field of (expr === null || expr === void 0 ? void 0 : expr.findDirectExpressionsMulti([Expressions.SQLField, Expressions.SQLFieldName])) || []) {
             let code = field.concatTokens().toUpperCase();
-            const as = ((_a = field.findDirectExpression(Expressions.SQLAsName)) === null || _a === void 0 ? void 0 : _a.concatTokens()) || "";
+            const as = ((_b = field.findDirectExpression(Expressions.SQLAsName)) === null || _b === void 0 ? void 0 : _b.concatTokens()) || "";
             if (as !== "") {
                 code = code.replace(" AS " + as, "");
             }

package/build/src/abap/5_syntax/expressions/sql_compare.js

@@ -4,13 +4,18 @@ exports.SQLCompare = void 0;
 const Expressions = require("../../2_statements/expressions");
 const nodes_1 = require("../../nodes");
 const basic_1 = require("../../types/basic");
+const dynamic_1 = require("./dynamic");
 const source_1 = require("./source");
 const sql_source_1 = require("./sql_source");
 class SQLCompare {
     runSyntax(node, scope, filename, tables) {
-        var _a;
+        var _a, _b;
         let sourceType;
         let token;
+        if (((_a = node.getFirstChild()) === null || _a === void 0 ? void 0 : _a.get()) instanceof Expressions.Dynamic) {
+            new dynamic_1.Dynamic().runSyntax(node.getFirstChild(), scope, filename);
+            return;
+        }
         for (const s of node.findAllExpressions(Expressions.SimpleSource3)) {
             new source_1.Source().runSyntax(s, scope, filename);
         }
@@ -36,7 +41,7 @@ class SQLCompare {
                 }
             }
         }
-        const fieldName = (_a = node.findDirectExpression(Expressions.SQLFieldName)) === null || _a === void 0 ? void 0 : _a.concatTokens();
+        const fieldName = (_b = node.findDirectExpression(Expressions.SQLFieldName)) === null || _b === void 0 ? void 0 : _b.concatTokens();
         if (fieldName && sourceType && token) {
             // check compatibility for rule sql_value_conversion
             const targetType = this.findType(fieldName, tables, scope);

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.8";
+        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/build/src/rules/no_prefixes.js

@@ -22,6 +22,7 @@ class NoPrefixesConf extends _basic_rule_config_1.BasicRuleConfig {
         this.types = "^TY_";
         /** importing, exporting, returning and changing parameters, case insensitive regex */
         this.methodParameters = "^[ICER].?_";
+        this.allowIsPrefixBoolean = true;
         // todo, public localClass: string = "";
         // todo, public localInterface: string = "";
         // todo, public functionModuleParameters: string = "";
@@ -166,12 +167,18 @@ https://github.com/SAP/styleguides/blob/main/clean-abap/sub-sections/AvoidEncodi
         return ret;
     }
     checkMethodParameters(topNode, regex, file) {
+        var _a, _b;
         const ret = [];
         for (const method of topNode.findAllStatements(Statements.MethodDef)) {
-            for (const def of method.findAllExpressions(Expressions.MethodParamName)) {
-                const name = def.concatTokens();
-                if (name !== "" && name.match(regex)) {
-                    const issue = issue_1.Issue.atToken(file, def.getFirstToken(), MESSAGE, this.getMetadata().key, this.conf.severity);
+            for (const param of method.findAllExpressionsMulti([Expressions.MethodDefReturning, Expressions.MethodParam])) {
+                const nameToken = param === null || param === void 0 ? void 0 : param.findFirstExpression(Expressions.MethodParamName);
+                const type = (_b = (_a = param === null || param === void 0 ? void 0 : param.findFirstExpression(Expressions.TypeParam)) === null || _a === void 0 ? void 0 : _a.concatTokens()) === null || _b === void 0 ? void 0 : _b.toUpperCase();
+                if (this.getConfig().allowIsPrefixBoolean === true && (type === null || type === void 0 ? void 0 : type.endsWith("TYPE ABAP_BOOL"))) {
+                    continue;
+                }
+                const name = nameToken === null || nameToken === void 0 ? void 0 : nameToken.concatTokens();
+                if (nameToken && name && name !== "" && name.match(regex)) {
+                    const issue = issue_1.Issue.atToken(file, nameToken.getFirstToken(), MESSAGE, this.getMetadata().key, this.conf.severity);
                     ret.push(issue);
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abaplint/core",
-    "version": "2.106.8",
+    "version": "2.107.0",
     "description": "abaplint - Core API",
     "main": "build/src/index.js",
     "typings": "build/abaplint.d.ts",
@@ -59,7 +59,7 @@
         "mocha": "^10.4.0",
         "c8": "^9.1.0",
         "source-map-support": "^0.5.21",
-        "ts-json-schema-generator": "^2.0.1",
+        "ts-json-schema-generator": "=2.0.1",
         "typescript": "^5.4.5"
     },
     "dependencies": {