@abaplint/core 2.80.10 → 2.81.3

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

@@ -54,6 +54,25 @@ class CurrentScope {
         }
         this.current.getData().types[upper] = type;
     }
+    addExtraLikeType(type) {
+        if (type === undefined) {
+            return;
+        }
+        this.addExtraLikeTypeNamed(type.getName(), type);
+    }
+    addExtraLikeTypeNamed(name, type) {
+        if (type === undefined) {
+            return;
+        }
+        if (this.current === undefined) {
+            return;
+        }
+        const upper = name.toUpperCase();
+        if (this.current.getData().extraLikeTypes[upper] !== undefined) {
+            throw new Error(`Type name "${name}" already defined`);
+        }
+        this.current.getData().extraLikeTypes[upper] = type;
+    }
     addClassDefinition(c) {
         var _a;
         (_a = this.current) === null || _a === void 0 ? void 0 : _a.getData().cdefs.push(c);
@@ -231,6 +250,13 @@ class CurrentScope {
         }
         return (_a = this.current) === null || _a === void 0 ? void 0 : _a.findType(name);
     }
+    findExtraLikeType(name) {
+        var _a;
+        if (name === undefined) {
+            return undefined;
+        }
+        return (_a = this.current) === null || _a === void 0 ? void 0 : _a.findExtraLikeType(name);
+    }
     findVariable(name) {
         var _a;
         if (name === undefined) {

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/_scope_type.js

@@ -14,6 +14,7 @@ var ScopeType;
     ScopeType["Form"] = "form";
     ScopeType["FunctionModule"] = "function";
     ScopeType["Method"] = "method";
+    ScopeType["MethodInstance"] = "method_instance";
     ScopeType["For"] = "for";
     ScopeType["OpenSQL"] = "open_sql";
 })(ScopeType = exports.ScopeType || (exports.ScopeType = {}));

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

@@ -79,8 +79,12 @@ class BasicTypes {
         }
         else {
             const name = children.shift().getFirstToken().getStr();
-            const found = this.scope.findVariable(name);
+            let found = this.scope.findVariable(name);
             type = found === null || found === void 0 ? void 0 : found.getType();
+            if (found === undefined) {
+                found = this.scope.findExtraLikeType(name);
+                type = found === null || found === void 0 ? void 0 : found.getType();
+            }
             if (found) {
                 this.scope.addReference(chain === null || chain === void 0 ? void 0 : chain.getFirstToken(), found, _reference_1.ReferenceType.TypeReference, this.filename);
             }

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

@@ -12,6 +12,7 @@ class ScopeData {
             idefs: [],
             forms: [],
             types: {},
+            extraLikeTypes: {},
             deferred: [],
             references: [],
         };
@@ -126,6 +127,18 @@ class SpaghettiScopeNode extends ScopeData {
         }
         return undefined;
     }
+    findExtraLikeType(name) {
+        let search = this;
+        const upper = name.toUpperCase();
+        while (search !== undefined) {
+            const data = search.getData();
+            if (data.extraLikeTypes[upper]) {
+                return data.extraLikeTypes[upper];
+            }
+            search = search.getParent();
+        }
+        return undefined;
+    }
     findVariable(name) {
         let search = this;
         const upper = name.toUpperCase();

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,11 +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.getInstance()); // todo, this is not correct, take care of instance vs static
-        scope.addList(classAttributes.getStatic()); // todo, this is not correct, take care of instance vs static
-        const implemented = helper.fromSuperClass(classDefinition);
-        helper.fromInterfaces(classDefinition, implemented);
+        scope.addList(classAttributes.getStatic());
+        for (const i of classAttributes.getInstance()) {
+            scope.addExtraLikeType(i);
+        }
+        helper.fromSuperClassesAndInterfaces(classDefinition);
     }
 }
 exports.ClassImplementation = ClassImplementation;

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

@@ -11,17 +11,19 @@ class MethodImplementation {
         const className = scope.getName();
         const methodToken = node.findFirstExpression(Expressions.MethodName).getFirstToken();
         const methodName = methodToken === null || methodToken === void 0 ? void 0 : methodToken.getStr();
-        scope.push(_scope_type_1.ScopeType.Method, methodName, node.getFirstToken().getStart(), filename);
         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) {
+            scope.push(_scope_type_1.ScopeType.MethodInstance, methodName, node.getFirstToken().getStart(), filename);
+            scope.addList(classDefinition.getAttributes().getInstance());
+        }
+        scope.push(_scope_type_1.ScopeType.Method, methodName, node.getFirstToken().getStart(), filename);
         scope.addReference(methodToken, methodDefinition, _reference_1.ReferenceType.MethodImplementationReference, filename);
         scope.addList(methodDefinition.getParameters().getAll());
         for (const i of helper.findInterfaces(classDefinition)) {

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

@@ -11,6 +11,7 @@ const component_compare_simple_1 = require("../expressions/component_compare_sim
 const _type_utils_1 = require("../_type_utils");
 class ReadTable {
     runSyntax(node, scope, filename) {
+        const concat = node.concatTokens().toUpperCase();
         const sources = node.findDirectExpressions(Expressions.Source);
         let firstSource = node.findDirectExpression(Expressions.SimpleSource2);
         if (firstSource === undefined) {
@@ -53,6 +54,9 @@ class ReadTable {
         }
         const target = node.findDirectExpression(Expressions.ReadTableTarget);
         if (target) {
+            if (concat.includes(" REFERENCE INTO ")) {
+                rowType = new basic_1.DataReference(rowType);
+            }
             const inline = target.findFirstExpression(Expressions.InlineData);
             if (inline) {
                 new inline_data_1.InlineData().runSyntax(inline, scope, filename, rowType);
@@ -76,7 +80,6 @@ class ReadTable {
                 return;
             }
         }
-        const concat = node.concatTokens().toUpperCase();
         if (target === undefined && concat.includes(" TRANSPORTING NO FIELDS ") === false) {
             // if sourceType is void, assume its with header
             if (sourceType instanceof basic_1.TableType && sourceType.isWithHeader() === false) {

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

@@ -412,11 +412,16 @@ class SyntaxLogic {
         }
         else if (s instanceof Statements.EndForm
             || s instanceof Statements.EndFunction
-            || s instanceof Statements.EndMethod
             || s instanceof Statements.EndClass
             || s instanceof Statements.EndInterface) {
             this.scope.pop(node.getLastToken().getEnd());
         }
+        else if (s instanceof Statements.EndMethod) {
+            this.scope.pop(node.getLastToken().getEnd());
+            if (this.scope.getType() === _scope_type_1.ScopeType.MethodInstance) {
+                this.scope.pop(node.getLastToken().getEnd());
+            }
+        }
     }
 }
 exports.SyntaxLogic = SyntaxLogic;

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

@@ -97,11 +97,12 @@ class EditHelper {
         if (scolon === undefined) {
             return EditHelper.deleteRange(file, statement.getFirstToken().getStart(), statement.getLastToken().getEnd());
         }
-        // find statements part of chain
-        let chainCount = 0;
         let setPrevious = true;
+        let setNext = true;
         /** previous statement in the chain */
         let previousStatement = undefined;
+        /** next statement in the chain */
+        let nextStatement = undefined;
         for (const s of file.getStatements()) {
             const colon = s.getColon();
             if (colon === undefined) {
@@ -109,16 +110,22 @@ class EditHelper {
             }
             else if (s === statement) {
                 setPrevious = false;
+                setNext = true;
                 continue;
             }
-            else if (colon.getStart().equals(scolon.getStart())) {
-                chainCount = chainCount + 1;
+            else if (setPrevious === true) {
+                if (scolon.getStart().equals(colon.getStart())) {
+                    previousStatement = s;
+                }
             }
-            if (setPrevious === true) {
-                previousStatement = s;
+            else if (setNext === true) {
+                if (scolon.getStart().equals(colon.getStart())) {
+                    nextStatement = s;
+                }
+                break;
             }
         }
-        if (chainCount === 0) {
+        if (previousStatement === undefined && nextStatement === undefined) {
             // the statement to be deleted is the only one in the chain
             return EditHelper.deleteRange(file, statement.getFirstToken().getStart(), statement.getLastToken().getEnd());
         }
@@ -130,14 +137,30 @@ class EditHelper {
                 break;
             }
         }
+        const colon = statement.getColon();
         if (statement.getLastToken().getStr() === "." && previousStatement) {
+            // last statement in chain
             const edit1 = EditHelper.replaceToken(file, previousStatement.getLastToken(), ".");
-            const edit2 = EditHelper.deleteRange(file, startDelete, statement.getLastToken().getEnd());
+            const edit2 = EditHelper.deleteRange(file, previousStatement.getLastToken().getEnd(), statement.getLastToken().getEnd());
             return EditHelper.merge(edit1, edit2);
         }
+        else if (previousStatement === undefined && colon && nextStatement) {
+            // first statement in chain
+            return EditHelper.deleteRange(file, this.firstAfterColon(statement), this.firstAfterColon(nextStatement));
+        }
         else {
-            return EditHelper.deleteRange(file, startDelete, statement.getLastToken().getEnd());
+            // middle statement
+            return EditHelper.deleteRange(file, startDelete, this.firstAfterColon(nextStatement));
+        }
+    }
+    static firstAfterColon(statement) {
+        const colon = statement.getColon().getStart();
+        for (const t of statement.getTokens()) {
+            if (t.getStart().isAfter(colon)) {
+                return t.getStart();
+            }
         }
+        throw new Error("firstAfterColon, emtpy statement?");
     }
     static deleteToken(file, token) {
         const filename = file.getFilename();

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.80.10";
+        return "2.81.3";
     }
     getDDICReferences() {
         return this.references;

package/build/src/rules/index.js

@@ -92,6 +92,7 @@ __exportStar(require("./msag_consistency"), exports);
 __exportStar(require("./names_no_dash"), exports);
 __exportStar(require("./nesting"), exports);
 __exportStar(require("./newline_between_methods"), exports);
+__exportStar(require("./no_chained_assignment"), exports);
 __exportStar(require("./no_public_attributes"), exports);
 __exportStar(require("./no_yoda_conditions"), exports);
 __exportStar(require("./object_naming"), exports);
@@ -131,6 +132,7 @@ __exportStar(require("./type_form_parameters"), exports);
 __exportStar(require("./types_naming"), exports);
 __exportStar(require("./uncaught_exception"), exports);
 __exportStar(require("./unknown_types"), exports);
+__exportStar(require("./unnecessary_chaining"), exports);
 __exportStar(require("./unreachable_code"), exports);
 __exportStar(require("./unsecure_fae"), exports);
 __exportStar(require("./unused_ddic"), exports);

package/build/src/rules/no_chained_assignment.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoChainedAssignment = exports.NoChainedAssignmentConf = void 0;
+const Expressions = require("../abap/2_statements/expressions");
+const Statements = require("../abap/2_statements/statements");
+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");
+class NoChainedAssignmentConf extends _basic_rule_config_1.BasicRuleConfig {
+}
+exports.NoChainedAssignmentConf = NoChainedAssignmentConf;
+class NoChainedAssignment extends _abap_rule_1.ABAPRule {
+    constructor() {
+        super(...arguments);
+        this.conf = new NoChainedAssignmentConf();
+    }
+    getMetadata() {
+        return {
+            key: "no_chained_assignment",
+            title: "No chained assignment",
+            shortDescription: `Find chained assingments and reports issues`,
+            extendedInformation: `https://github.com/SAP/styleguides/blob/main/clean-abap/CleanABAP.md#dont-chain-assignments`,
+            tags: [_irule_1.RuleTag.SingleFile, _irule_1.RuleTag.Styleguide],
+            badExample: `var1 = var2 = var3.`,
+            goodExample: `var2 = var3.
+var1 = var2.`,
+        };
+    }
+    getConfig() {
+        return this.conf;
+    }
+    setConfig(conf) {
+        this.conf = conf;
+    }
+    runParsed(file) {
+        const issues = [];
+        for (const s of file.getStatements()) {
+            if (!(s.get() instanceof Statements.Move)) {
+                continue;
+            }
+            if (s.findDirectExpressions(Expressions.Target).length >= 2) {
+                const message = "No chained assignment";
+                const issue = issue_1.Issue.atStatement(file, s, message, this.getMetadata().key);
+                issues.push(issue);
+            }
+        }
+        return issues;
+    }
+}
+exports.NoChainedAssignment = NoChainedAssignment;
+//# sourceMappingURL=no_chained_assignment.js.map

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/prefer_inline.js

@@ -74,7 +74,7 @@ DATA(percentage) = CONV decfloat34( comment_number / abs_statement_number ) * 10
     }
     ///////////////////////////
     analyzeScope(node, obj) {
-        var _a;
+        var _a, _b;
         const ret = [];
         const vars = node.getData().vars;
         for (const name in vars) {
@@ -113,7 +113,8 @@ DATA(percentage) = CONV decfloat34( comment_number / abs_statement_number ) * 10
                 || statementType instanceof Statements.Catch
                 || statementType instanceof Statements.ReadTable
                 || statementType instanceof Statements.Loop)
-                || ((_a = writeStatement === null || writeStatement === void 0 ? void 0 : writeStatement.concatTokens()) === null || _a === void 0 ? void 0 : _a.includes("?="))) {
+                || ((_a = writeStatement === null || writeStatement === void 0 ? void 0 : writeStatement.concatTokens()) === null || _a === void 0 ? void 0 : _a.includes("?="))
+                || ((_b = writeStatement === null || writeStatement === void 0 ? void 0 : writeStatement.concatTokens()) === null || _b === void 0 ? void 0 : _b.includes(" #("))) {
                 continue;
             }
             const statement = edit_helper_1.EditHelper.findStatement(identifier.getToken(), file);