@abaplint/core 2.113.217 → 2.113.219

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

@@ -448,7 +448,7 @@ class TypeUtils {
                     if (!(sourceRowType instanceof basic_1.StructureType)) {
                         return false;
                     }
-                    else if (!(this.structureContainsString(sourceRowType))
+                    else if (!this.structureContainsString(sourceRowType)
                         && this.structureContainsVoid(sourceRowType) === false) {
                         return false;
                     }
@@ -458,7 +458,7 @@ class TypeUtils {
                     if (!(targetRowType instanceof basic_1.StructureType)) {
                         return false;
                     }
-                    else if (!(this.structureContainsString(targetRowType))
+                    else if (!this.structureContainsString(targetRowType)
                         && this.structureContainsVoid(targetRowType) === false) {
                         return false;
                     }

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

@@ -11,7 +11,7 @@ class CorrespondingBody {
         }
         const base = (_a = node.findDirectExpression(Expressions.CorrespondingBodyBase)) === null || _a === void 0 ? void 0 : _a.findDirectExpression(Expressions.Source);
         if (base) {
-            source_1.Source.runSyntax(base, input);
+            source_1.Source.runSyntax(base, input, targetType);
         }
         let type = undefined;
         for (const s of node.findDirectExpressions(Expressions.Source)) {

package/build/src/registry.js

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

package/build/src/rules/downport.js

@@ -939,7 +939,6 @@ ${indentation}${uniqueName} = ${source.concatTokens()}.\n${indentation}`);
         const source = high.findExpressionAfterToken("MESSAGE");
         if ((source === null || source === void 0 ? void 0 : source.get()) instanceof Expressions.MessageSourceSource
             && ((_a = source.getFirstChild()) === null || _a === void 0 ? void 0 : _a.get()) instanceof Expressions.Source) {
-            ;
             const uniqueName = this.uniqueName(high.getFirstToken().getStart(), lowFile.getFilename(), highSyntax);
             const indentation = " ".repeat(high.getFirstToken().getStart().getCol() - 1);
             const firstToken = high.getFirstToken();

package/build/src/rules/fully_type_constants.js

@@ -45,7 +45,7 @@ class FullyTypeConstants extends _abap_rule_1.ABAPRule {
         for (const stat of file.getStatements()) {
             if ((stat.get() instanceof Statements.Constant
                 || (this.conf.checkData === true && stat.get() instanceof Statements.Data))
-                && (!this.isTyped(stat))) {
+                && !this.isTyped(stat)) {
                 const type = stat.get() instanceof Statements.Constant ? "constant definition" : "data definition";
                 let token = (_a = stat.findFirstExpression(expressions_1.NamespaceSimpleName)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
                 if (token === undefined) {
@@ -60,7 +60,7 @@ class FullyTypeConstants extends _abap_rule_1.ABAPRule {
         return issues;
     }
     isTyped(stat) {
-        return (stat.findFirstExpression(expressions_1.Type) || stat.findFirstExpression(expressions_1.TypeTable));
+        return stat.findFirstExpression(expressions_1.Type) || stat.findFirstExpression(expressions_1.TypeTable);
     }
 }
 exports.FullyTypeConstants = FullyTypeConstants;

package/build/src/rules/implement_methods.js

@@ -77,7 +77,15 @@ class ImplementMethods extends _abap_rule_1.ABAPRule {
                     const issue = issue_1.Issue.atIdentifier(found, "Do not implement abstract method \"" + md.name + "\"", this.getMetadata().key, this.conf.severity);
                     ret.push(issue);
                 }
-                continue;
+                if (def.isAbstract) {
+                    continue;
+                }
+                else {
+                    const message = "Abstract methods can only be defined in abstract classes.";
+                    const issue = issue_1.Issue.atIdentifier(def.identifier, message, this.getMetadata().key, this.conf.severity);
+                    ret.push(issue);
+                    break;
+                }
             }
             if (impl === undefined) {
                 const message = "Class implementation for \"" + def.name + "\" not found";
@@ -180,8 +188,16 @@ class ImplementMethods extends _abap_rule_1.ABAPRule {
                 return [idef];
             }
             for (const m of this.findInterfaceMethods(idef)) {
-                if (interfaceInfo.abstractMethods.includes(m.method.name.toUpperCase())) {
-                    continue;
+                if (this.isAbstract(m, interfaceInfo, def)) {
+                    if (def.isAbstract) {
+                        continue;
+                    }
+                    else {
+                        const message = "Abstract methods can only be defined in abstract classes.";
+                        const issue = issue_1.Issue.atIdentifier(def.identifier, message, this.getMetadata().key, this.conf.severity);
+                        ret.push(issue);
+                        break;
+                    }
                 }
                 if (this.isImplemented(m, def, impl) === false) {
                     const message = "Implement method \"" + m.method.name + "\" from interface \"" + m.objectName + "\"";
@@ -199,6 +215,23 @@ class ImplementMethods extends _abap_rule_1.ABAPRule {
         }
         return ret;
     }
+    isAbstract(m, interfaceInfo, def) {
+        if (interfaceInfo.abstractMethods.includes(m.method.name.toUpperCase())) {
+            return true;
+        }
+        if (!def.superClassName) {
+            return false;
+        }
+        // look up in superclass if method is abstract there
+        const superClass = this.findClass(def.superClassName);
+        const superInterface = superClass === null || superClass === void 0 ? void 0 : superClass.def.interfaces.find(iface => iface.name.toUpperCase() === m.objectName.toUpperCase());
+        if (superClass && superInterface) {
+            return this.isAbstract(m, superInterface, superClass.def);
+        }
+        else {
+            return false;
+        }
+    }
     isImplemented(m, def, impl) {
         if (impl === undefined) {
             return false;

package/build/src/rules/parser_702_chaining.js

@@ -7,6 +7,7 @@ const _abap_rule_1 = require("./_abap_rule");
 const _basic_rule_config_1 = require("./_basic_rule_config");
 const _irule_1 = require("./_irule");
 const version_1 = require("../version");
+const __1 = require("..");
 class Parser702ChainingConf extends _basic_rule_config_1.BasicRuleConfig {
 }
 exports.Parser702ChainingConf = Parser702ChainingConf;
@@ -18,7 +19,7 @@ class Parser702Chaining extends _abap_rule_1.ABAPRule {
     getMetadata() {
         return {
             key: "parser_702_chaining",
-            title: "Parser Error, bad chanining on 702",
+            title: "Parser Error, bad chaining on 702",
             shortDescription: `ABAP on 702 does not allow for method chaining with IMPORTING/EXPORTING/CHANGING keywords,
 this rule finds these and reports errors.
 Only active on target version 702 and below.`,
@@ -59,13 +60,47 @@ Only active on target version 702 and below.`,
                     || param.findDirectTokenByText("CHANGING")
                     || param.findDirectTokenByText("EXCEPTIONS")) {
                     const message = "This kind of method chaining not possible in 702";
-                    const issue = issue_1.Issue.atPosition(file, param.getFirstToken().getStart(), message, this.getMetadata().key, this.conf.severity);
-                    issues.push(issue);
+                    this.pushIssue(message, file, param, issues);
                 }
             }
         }
+        // after a value assignment (move statement whose source is a method call, or method parameter assignment),
+        // there can't be any EXPORTING/IMPORTING/CHANGING/EXCEPTIONS
+        for (const statement of file.getStatements()) {
+            if (!(statement.get() instanceof __1.Statements.Move)) {
+                continue;
+            }
+            const source = statement.findDirectExpression(Expressions.Source);
+            if (source === undefined) {
+                continue;
+            }
+            this.ensureSourceHasNoProceduralKeywords(source, file, issues);
+        }
+        for (const methodParameters of stru.findAllExpressions(Expressions.MethodParameters)) {
+            for (const params of methodParameters.findAllExpressions(Expressions.ParameterS)) {
+                const source = params.findDirectExpression(Expressions.Source);
+                if (source === undefined) {
+                    continue;
+                }
+                this.ensureSourceHasNoProceduralKeywords(source, file, issues);
+            }
+        }
         return issues;
     }
+    ensureSourceHasNoProceduralKeywords(source, file, issues) {
+        const forbiddenTokens = ["EXPORTING", "IMPORTING", "CHANGING", "EXCEPTIONS"];
+        for (const param of source.findAllExpressions(Expressions.MethodParameters)) {
+            const usedForbiddenToken = forbiddenTokens.find(text => param.findDirectTokenByText(text));
+            if (usedForbiddenToken) {
+                const message = `Unexpected word ${usedForbiddenToken} in functional method call`;
+                this.pushIssue(message, file, param, issues);
+            }
+        }
+    }
+    pushIssue(message, file, node, issues) {
+        const issue = issue_1.Issue.atPosition(file, node.getFirstToken().getStart(), message, this.getMetadata().key, this.conf.severity);
+        issues.push(issue);
+    }
 }
 exports.Parser702Chaining = Parser702Chaining;
 //# sourceMappingURL=parser_702_chaining.js.map

package/build/src/rules/unnecessary_return.js

@@ -61,9 +61,9 @@ ENDFORM.`,
         for (let i = 0; i < statements.length; i++) {
             const node = statements[i];
             const nodeType = node.get();
-            if ((nodeType instanceof Statements.MethodImplementation
+            if (nodeType instanceof Statements.MethodImplementation
                 || nodeType instanceof Statements.Form
-                || nodeType instanceof Statements.FunctionModule)) {
+                || nodeType instanceof Statements.FunctionModule) {
                 statementCounter = 0;
                 continue;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abaplint/core",
-    "version": "2.113.217",
+    "version": "2.113.219",
     "description": "abaplint - Core API",
     "main": "build/src/index.js",
     "typings": "build/abaplint.d.ts",
@@ -50,17 +50,17 @@
     },
     "homepage": "https://abaplint.org",
     "devDependencies": {
-        "@microsoft/api-extractor": "^7.52.13",
+        "@microsoft/api-extractor": "^7.52.15",
         "@types/chai": "^4.3.20",
         "@types/mocha": "^10.0.10",
-        "@types/node": "^24.5.2",
+        "@types/node": "^24.6.2",
         "chai": "^4.5.0",
         "eslint": "^9.36.0",
-        "mocha": "^11.7.2",
+        "mocha": "^11.7.4",
         "c8": "^10.1.3",
         "source-map-support": "^0.5.21",
         "ts-json-schema-generator": "^2.4.0",
-        "typescript": "^5.9.2"
+        "typescript": "^5.9.3"
     },
     "dependencies": {
         "fast-xml-parser": "^5.2.5",