@abaplint/core 2.81.2 → 2.82.1

package/build/src/abap/5_syntax/_object_oriented.js

@@ -9,14 +9,6 @@ class ObjectOriented {
     constructor(scope) {
         this.scope = scope;
     }
-    // returns list of interfaces implemented
-    fromInterfaces(classDefinition, skip) {
-        const ignore = [];
-        for (const i of classDefinition.getImplementing()) {
-            ignore.push(...this.fromInterfaceByName(i.name, ignore.concat(skip || [])));
-        }
-        return ignore;
-    }
     fromInterfaceByName(name, ignore) {
         const idef = this.scope.findInterfaceDefinition(name);
         if (idef === undefined || ignore.includes(name.toUpperCase())) {
@@ -279,8 +271,12 @@ class ObjectOriented {
         }
         return csup;
     }
+    fromSuperClassesAndInterfaces(child) {
+        const implemented = this.fromSuperClasses(child);
+        this.fromInterfaces(child, implemented);
+    }
     // returns list of interfaces implemented
-    fromSuperClass(child) {
+    fromSuperClasses(child) {
         let sup = child.getSuperClass();
         const ignore = [];
         while (sup !== undefined) {
@@ -306,6 +302,14 @@ class ObjectOriented {
         }
         return ignore;
     }
+    // returns list of interfaces implemented
+    fromInterfaces(classDefinition, skip) {
+        const ignore = [];
+        for (const i of classDefinition.getImplementing()) {
+            ignore.push(...this.fromInterfaceByName(i.name, ignore.concat(skip || [])));
+        }
+        return ignore;
+    }
 }
 exports.ObjectOriented = ObjectOriented;
 //# sourceMappingURL=_object_oriented.js.map

package/build/src/abap/5_syntax/_reference.js

@@ -4,21 +4,21 @@ exports.ReferenceType = void 0;
 var ReferenceType;
 (function (ReferenceType) {
     /** for classes and interface references */
-    ReferenceType["ObjectOrientedReference"] = "ObjectOrientedReference";
-    ReferenceType["ObjectOrientedVoidReference"] = "ObjectOrientedVoidReference";
-    ReferenceType["ObjectOrientedUnknownReference"] = "ObjectOrientedUnknownReference";
-    ReferenceType["TableReference"] = "TableReference";
-    ReferenceType["TableVoidReference"] = "TableVoidReference";
-    ReferenceType["MethodReference"] = "MethodReference";
-    ReferenceType["BuiltinMethodReference"] = "BuiltinMethodReference";
-    ReferenceType["MethodImplementationReference"] = "MethodImplementationReference";
-    ReferenceType["TypeReference"] = "TypeReference";
-    ReferenceType["BuiltinTypeReference"] = "BuiltinTypeReference";
-    ReferenceType["VoidType"] = "VoidType";
-    ReferenceType["InferredType"] = "InferredType";
-    ReferenceType["FormReference"] = "FormReference";
-    //  FormVoidReference = "FormReference",
-    ReferenceType["DataReadReference"] = "DataReadReference";
-    ReferenceType["DataWriteReference"] = "DataWriteReference";
+    ReferenceType["ObjectOrientedReference"] = "Object";
+    ReferenceType["ObjectOrientedVoidReference"] = "Object (Void)";
+    ReferenceType["ObjectOrientedUnknownReference"] = "Object (Unknown)";
+    ReferenceType["TableReference"] = "Table";
+    ReferenceType["TableVoidReference"] = "Table (Void)";
+    ReferenceType["MethodReference"] = "Method";
+    ReferenceType["BuiltinMethodReference"] = "Builtin Method";
+    ReferenceType["MethodImplementationReference"] = "Method Implementation";
+    ReferenceType["TypeReference"] = "Type";
+    ReferenceType["BuiltinTypeReference"] = "Builtin Type";
+    ReferenceType["VoidType"] = "Type (Void)";
+    ReferenceType["InferredType"] = "Inferred Type";
+    ReferenceType["FormReference"] = "Form";
+    //  FormVoidReference = "Form (void)",
+    ReferenceType["DataReadReference"] = "Read From";
+    ReferenceType["DataWriteReference"] = "Write To";
 })(ReferenceType = exports.ReferenceType || (exports.ReferenceType = {}));
 //# sourceMappingURL=_reference.js.map

package/build/src/abap/5_syntax/statements/class_implementation.js

@@ -17,7 +17,6 @@ class ClassImplementation {
         if (classDefinition === undefined) {
             throw new Error("Class definition for \"" + className + "\" not found");
         }
-        const classAttributes = classDefinition.getAttributes();
         for (const t of classDefinition.getTypeDefinitions().getAll()) {
             scope.addType(t.type);
         }
@@ -27,13 +26,13 @@ class ClassImplementation {
         }
         scope.addIdentifier(new _typed_identifier_1.TypedIdentifier(new tokens_1.Identifier(new position_1.Position(1, 1), "me"), _builtin_1.BuiltIn.filename, new basic_1.ObjectReferenceType(classDefinition)));
         helper.addAliasedAttributes(classDefinition); // todo, this is not correct, take care of instance vs static
+        const classAttributes = classDefinition.getAttributes();
         scope.addList(classAttributes.getConstants());
         scope.addList(classAttributes.getStatic());
         for (const i of classAttributes.getInstance()) {
             scope.addExtraLikeType(i);
         }
-        const implemented = helper.fromSuperClass(classDefinition);
-        helper.fromInterfaces(classDefinition, implemented);
+        helper.fromSuperClassesAndInterfaces(classDefinition);
     }
 }
 exports.ClassImplementation = ClassImplementation;

package/build/src/abap/5_syntax/statements/method_implementation.js

@@ -13,12 +13,10 @@ class MethodImplementation {
         const methodName = methodToken === null || methodToken === void 0 ? void 0 : methodToken.getStr();
         const classDefinition = scope.findClassDefinition(className);
         if (classDefinition === undefined) {
-            //      scope.pop(node.getLastToken().getEnd());
             throw new Error("Class definition for \"" + className + "\" not found");
         }
         const { method: methodDefinition } = helper.searchMethodName(classDefinition, methodName);
         if (methodDefinition === undefined) {
-            //      scope.pop(node.getLastToken().getEnd());
             throw new Error("Method definition \"" + methodName + "\" not found");
         }
         if (methodDefinition.isStatic() === false) {

package/build/src/abap/nodes/expression_node.js

@@ -189,7 +189,7 @@ class ExpressionNode extends _abstract_node_1.AbstractNode {
         }
         return ret;
     }
-    findAllExpressionsMulti(type) {
+    findAllExpressionsMulti(type, recursive = false) {
         const ret = [];
         for (const child of this.getChildren()) {
             if (child instanceof token_node_1.TokenNode) {
@@ -201,7 +201,7 @@ class ExpressionNode extends _abstract_node_1.AbstractNode {
                     ret.push(child);
                 }
             }
-            if (before === ret.length) {
+            if (before === ret.length || recursive === true) {
                 ret.push(...child.findAllExpressionsMulti(type));
             }
         }

package/build/src/abap/nodes/statement_node.js

@@ -211,7 +211,7 @@ class StatementNode extends _abstract_node_1.AbstractNode {
                 }
             }
             if (before === ret.length || recursive === true) {
-                ret.push(...child.findAllExpressionsMulti(type));
+                ret.push(...child.findAllExpressionsMulti(type, recursive));
             }
         }
         return ret;

package/build/src/abap/types/class_definition.js

@@ -31,8 +31,7 @@ class ClassDefinition extends _identifier_1.Identifier {
         this.friends = this.findFriends(def, filename, scope);
         this.parse(filename, scope);
         const helper = new _object_oriented_1.ObjectOriented(scope);
-        const implemented = helper.fromSuperClass(this);
-        helper.fromInterfaces(this, implemented);
+        helper.fromSuperClassesAndInterfaces(this);
         this.attributes = new class_attributes_1.Attributes(this.node, this.filename, scope);
         this.types = this.attributes.getTypes();
         this.methodDefs = new method_definitions_1.MethodDefinitions(this.node, this.filename, scope);

package/build/src/edit_helper.js

@@ -114,10 +114,14 @@ class EditHelper {
                 continue;
             }
             else if (setPrevious === true) {
-                previousStatement = s;
+                if (scolon.getStart().equals(colon.getStart())) {
+                    previousStatement = s;
+                }
             }
             else if (setNext === true) {
-                nextStatement = s;
+                if (scolon.getStart().equals(colon.getStart())) {
+                    nextStatement = s;
+                }
                 break;
             }
         }

package/build/src/lsp/_lookup.js

@@ -28,36 +28,40 @@ class LSPLookup {
         const clas = bottomScope.findClassDefinition(cursor.token.getStr());
         if (clas && clas.getStart().equals(cursor.token.getStart())) {
             const found = _lsp_utils_1.LSPUtils.identiferToLocation(clas);
-            return { hover: "Class definition, " + cursor.token.getStr(),
+            return {
+                hover: "Class Definition, " + cursor.token.getStr(),
                 definition: found,
                 definitionId: clas,
                 implementation: undefined,
-                scope: bottomScope };
+                scope: bottomScope,
+            };
         }
         const intf = bottomScope.findInterfaceDefinition(cursor.token.getStr());
         if (intf && intf.getStart().equals(cursor.token.getStart())) {
             const found = _lsp_utils_1.LSPUtils.identiferToLocation(intf);
-            return { hover: "Interface definition, " + cursor.token.getStr(),
+            return {
+                hover: "Interface Definition, " + cursor.token.getStr(),
                 definition: found,
                 definitionId: intf,
                 implementation: undefined,
-                scope: bottomScope };
+                scope: bottomScope,
+            };
         }
         const type = bottomScope.findType(cursor.token.getStr());
         if (type !== undefined && type.getStart().equals(cursor.token.getStart())) {
             const found = _lsp_utils_1.LSPUtils.identiferToLocation(type);
-            const hover = "Type definition, " + cursor.token.getStr() + "\n\n" + this.dumpType(type);
+            const hover = "Type Definition, " + cursor.token.getStr() + "\n\n" + this.dumpType(type);
             return { hover, definition: found, definitionId: type, scope: bottomScope };
         }
         const method = this.findMethodDefinition(cursor, bottomScope);
         if (method !== undefined && method.getStart().equals(cursor.token.getStart())) {
             const found = _lsp_utils_1.LSPUtils.identiferToLocation(method);
-            const hover = "Method definition \"" + method.getName() + "\"";
+            const hover = "Method Definition \"" + method.getName() + "\"";
             return { hover, definition: found, definitionId: method, scope: bottomScope };
         }
         const variable = bottomScope.findVariable(cursor.token.getStr());
         if (variable !== undefined && variable.getStart().equals(cursor.token.getStart())) {
-            const hover = "Variable definition\n\n" + this.dumpType(variable);
+            const hover = "Variable Definition\n\n" + this.dumpType(variable);
             let location = undefined;
             if (variable.getMeta().includes("built-in" /* BuiltIn */) === false) {
                 location = _lsp_utils_1.LSPUtils.identiferToLocation(variable);
@@ -103,23 +107,23 @@ class LSPLookup {
             value = value + "\n\nMeta: " + variable.getMeta().join(", ");
         }
         if (variable.getType().containsVoid() === true) {
-            value = value + "\n\nContains void types";
+            value = value + "\n\nContains Void types";
         }
         if (variable.getType().getQualifiedName()) {
-            value = value + "\n\nQualified type name: ```" + variable.getType().getQualifiedName() + "```";
+            value = value + "\n\nQualified Type Name: ```" + variable.getType().getQualifiedName() + "```";
         }
         if (variable.getType().isGeneric() === true) {
-            value = value + "\n\nIs generic type";
+            value = value + "\n\nIs Generic Type";
         }
         return value;
     }
     static referenceHover(ref, scope, reg) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         let name = "";
         if (ref.resolved) {
             name = "```" + ref.resolved.getName() + "```";
         }
-        let ret = "Resolved Reference: " + ref.referenceType + " " + name;
+        let ret = `${ref.referenceType} ${name}`;
         if (ref.referenceType === _reference_1.ReferenceType.MethodReference && ((_a = ref.extra) === null || _a === void 0 ? void 0 : _a.ooName)) {
             let cdef = scope.findClassDefinition(ref.extra.ooName);
             if (cdef === undefined) {
@@ -136,45 +140,62 @@ class LSPLookup {
         else if (ref.resolved instanceof _typed_identifier_1.TypedIdentifier) {
             ret += "\n\n" + this.dumpType(ref.resolved);
         }
+        else if (ref.referenceType === _reference_1.ReferenceType.BuiltinMethodReference) {
+            const builtinDef = new _builtin_1.BuiltIn().searchBuiltin((_e = (_d = ref.resolved) === null || _d === void 0 ? void 0 : _d.getName()) === null || _e === void 0 ? void 0 : _e.toUpperCase());
+            if (builtinDef === undefined) {
+                return "Error: builtin method signature not found";
+            }
+            ret += "\n\n" + this.methodParameters(builtinDef);
+        }
+        if (ref.resolved) {
+            ret += "\n\n(Resolved)";
+        }
         if (ref.extra !== undefined && Object.keys(ref.extra).length > 0) {
             ret += "\n\nExtra: " + JSON.stringify(ref.extra);
         }
         return ret;
     }
-    static hoverMethod(method, def) {
-        if (def === undefined) {
+    static hoverMethod(method, classDef) {
+        if (classDef === undefined) {
             return "class not found";
         }
-        const mdef = def.getMethodDefinitions().getByName(method);
-        if (mdef === undefined) {
+        const methodDef = classDef.getMethodDefinitions().getByName(method);
+        if (methodDef === undefined) {
             return "method not found in definition";
         }
+        return this.methodParameters(methodDef);
+    }
+    static methodParameters(methodDef) {
         let ret = "";
-        if (mdef.getParameters().getImporting().length > 0) {
+        const parameters = methodDef.getParameters();
+        const importing = parameters.getImporting();
+        if (importing.length > 0) {
             ret += "IMPORTING\n";
-            for (const p of mdef.getParameters().getImporting()) {
+            for (const p of importing) {
                 ret += this.singleParameter(p);
             }
         }
-        if (mdef.getParameters().getExporting().length > 0) {
+        const exporting = parameters.getExporting();
+        if (exporting.length > 0) {
             ret += "EXPORTING\n";
-            for (const p of mdef.getParameters().getExporting()) {
+            for (const p of exporting) {
                 ret += this.singleParameter(p);
             }
         }
-        if (mdef.getParameters().getChanging().length > 0) {
+        const changing = parameters.getChanging();
+        if (changing.length > 0) {
             ret += "CHANGING\n";
-            for (const p of mdef.getParameters().getChanging()) {
+            for (const p of changing) {
                 ret += this.singleParameter(p);
             }
         }
-        const r = mdef.getParameters().getReturning();
+        const r = parameters.getReturning();
         if (r) {
             ret += "RETURNING\n" + this.singleParameter(r);
         }
-        if (mdef.getRaising().length > 0) {
+        if (methodDef.getRaising().length > 0) {
             ret += "RAISING\n";
-            for (const p of mdef.getRaising()) {
+            for (const p of methodDef.getRaising()) {
                 ret += "* " + p + "\n";
             }
         }

package/build/src/registry.js

@@ -68,7 +68,7 @@ class Registry {
     }
     static abaplintVersion() {
         // magic, see build script "version.sh"
-        return "2.81.2";
+        return "2.82.1";
     }
     getDDICReferences() {
         return this.references;

package/build/src/rules/index.js

@@ -124,6 +124,7 @@ __exportStar(require("./space_before_colon"), exports);
 __exportStar(require("./space_before_dot"), exports);
 __exportStar(require("./sql_escape_host_variables"), exports);
 __exportStar(require("./start_at_tab"), exports);
+__exportStar(require("./static_call_via_instance"), exports);
 __exportStar(require("./superclass_final"), exports);
 __exportStar(require("./sy_modification"), exports);
 __exportStar(require("./tabl_enhancement_category"), exports);

package/build/src/rules/parser_missing_space.js

@@ -50,7 +50,8 @@ This rule makes sure the spaces are consistently required across the language.`,
     }
     missingSpace(statement) {
         const found = statement.findAllExpressionsMulti([Expressions.CondSub, Expressions.SQLCond,
-            Expressions.ValueBody, Expressions.NewObject, Expressions.Cond, Expressions.ComponentCond, Expressions.MethodCallParam], true);
+            Expressions.ValueBody, Expressions.NewObject, Expressions.Cond,
+            Expressions.ComponentCond, Expressions.MethodCallParam], true);
         let pos = undefined;
         for (const f of found) {
             const type = f.get();

package/build/src/rules/static_call_via_instance.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticCallViaInstance = exports.StaticCallViaInstanceConf = void 0;
+/* eslint-disable max-len */
+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 syntax_1 = require("../abap/5_syntax/syntax");
+const _reference_1 = require("../abap/5_syntax/_reference");
+const types_1 = require("../abap/types");
+class StaticCallViaInstanceConf extends _basic_rule_config_1.BasicRuleConfig {
+}
+exports.StaticCallViaInstanceConf = StaticCallViaInstanceConf;
+class StaticCallViaInstance extends _abap_rule_1.ABAPRule {
+    constructor() {
+        super(...arguments);
+        this.conf = new StaticCallViaInstanceConf();
+    }
+    getMetadata() {
+        return {
+            key: "static_call_via_instance",
+            title: "Static call via instance variable",
+            shortDescription: `Static method call via instance variable`,
+            extendedInformation: `https://github.com/SAP/styleguides/blob/main/clean-abap/CleanABAP.md#dont-call-static-methods-through-instance-variables`,
+            tags: [_irule_1.RuleTag.Styleguide],
+        };
+    }
+    getConfig() {
+        return this.conf;
+    }
+    setConfig(conf) {
+        this.conf = conf;
+    }
+    runParsed(file, obj) {
+        const issues = [];
+        const staticMethodCalls = this.listMethodCalls(file.getFilename(), new syntax_1.SyntaxLogic(this.reg, obj).run().spaghetti.getTop());
+        const tokens = file.getTokens();
+        for (let i = 0; i < tokens.length - 1; i++) {
+            const token = tokens[i];
+            if (token.getStr() !== "->") {
+                continue;
+            }
+            const next = tokens[i + 1];
+            for (const s of staticMethodCalls) {
+                if (s.equals(next.getStart())) {
+                    const message = "Avoid calling static method via instance";
+                    issues.push(issue_1.Issue.atToken(file, token, message, this.getMetadata().key));
+                    break;
+                }
+            }
+        }
+        return issues;
+    }
+    listMethodCalls(filename, node) {
+        const ret = [];
+        for (const r of node.getData().references) {
+            if (r.referenceType !== _reference_1.ReferenceType.MethodReference || r.position.getFilename() !== filename) {
+                continue;
+            }
+            if (r.resolved instanceof types_1.MethodDefinition && r.resolved.isStatic() === true) {
+                ret.push(r.position.getStart());
+            }
+        }
+        for (const child of node.getChildren()) {
+            ret.push(...this.listMethodCalls(filename, child));
+        }
+        return ret;
+    }
+}
+exports.StaticCallViaInstance = StaticCallViaInstance;
+//# sourceMappingURL=static_call_via_instance.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abaplint/core",
-    "version": "2.81.2",
+    "version": "2.82.1",
     "description": "abaplint - Core API",
     "main": "build/src/index.js",
     "typings": "build/abaplint.d.ts",
@@ -48,9 +48,9 @@
         "@microsoft/api-extractor": "^7.18.19",
         "@types/chai": "^4.2.22",
         "@types/mocha": "^9.0.0",
-        "@types/node": "^16.11.9",
+        "@types/node": "^16.11.10",
         "chai": "^4.3.4",
-        "eslint": "^8.2.0",
+        "eslint": "^8.3.0",
         "mocha": "^9.1.3",
         "c8": "^7.10.0",
         "source-map-support": "^0.5.21",