@abaplint/core 2.81.0 → 2.81.4

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

package/build/src/rules/no_chained_assignment.js

@@ -8,10 +8,6 @@ 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 {
-    constructor() {
-        super(...arguments);
-        this.onlyConstants = false;
-    }
 }
 exports.NoChainedAssignmentConf = NoChainedAssignmentConf;
 class NoChainedAssignment extends _abap_rule_1.ABAPRule {
@@ -28,7 +24,7 @@ class NoChainedAssignment extends _abap_rule_1.ABAPRule {
             tags: [_irule_1.RuleTag.SingleFile, _irule_1.RuleTag.Styleguide],
             badExample: `var1 = var2 = var3.`,
             goodExample: `var2 = var3.
-var1 = var3.`,
+var1 = var2.`,
         };
     }
     getConfig() {

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

@@ -6,10 +6,6 @@ const _abap_rule_1 = require("./_abap_rule");
 const _basic_rule_config_1 = require("./_basic_rule_config");
 const _irule_1 = require("./_irule");
 class UnnecessaryChainingConf extends _basic_rule_config_1.BasicRuleConfig {
-    constructor() {
-        super(...arguments);
-        this.onlyConstants = false;
-    }
 }
 exports.UnnecessaryChainingConf = UnnecessaryChainingConf;
 class UnnecessaryChaining extends _abap_rule_1.ABAPRule {

package/build/src/rules/unreachable_code.js

@@ -67,6 +67,10 @@ class UnreachableCode extends _abap_rule_1.ABAPRule {
             return true;
         }
         else if (s instanceof Statements.Leave && n.findFirstExpression(Expressions.AndReturn) === undefined) {
+            const concat = n.concatTokens();
+            if (concat.includes(" TO LIST-PROCESSING")) {
+                return false;
+            }
             return true;
         }
         else if (s instanceof Statements.Return

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abaplint/core",
-    "version": "2.81.0",
+    "version": "2.81.4",
     "description": "abaplint - Core API",
     "main": "build/src/index.js",
     "typings": "build/abaplint.d.ts",
@@ -48,14 +48,14 @@
         "@microsoft/api-extractor": "^7.18.19",
         "@types/chai": "^4.2.22",
         "@types/mocha": "^9.0.0",
-        "@types/node": "^16.11.7",
+        "@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.20",
+        "source-map-support": "^0.5.21",
         "ts-json-schema-generator": "^0.97.0",
-        "typescript": "^4.4.4"
+        "typescript": "^4.5.2"
     },
     "dependencies": {
         "fast-xml-parser": "^3.21.1",