@abaplint/core 2.120.52 → 2.120.53

package/build/abaplint.d.ts

@@ -3955,6 +3955,12 @@ declare interface InfoMethodDefinition {
     isForTesting: boolean;
     isAbstract: boolean;
     isFinal: boolean;
+    /** "DEFAULT IGNORE", 7.40 SP08: an implementing class need not implement this method,
+     * and a call of it on an unimplemented method does nothing */
+    isDefaultIgnore: boolean;
+    /** "DEFAULT FAIL", 7.40 SP08: an implementing class need not implement this method,
+     * and a call of it raises CX_SY_DYN_CALL_ILLEGAL_METHOD */
+    isDefaultFail: boolean;
     visibility: Visibility;
     parameters: InfoMethodParameter[];
     exceptions: string[];

package/build/src/abap/4_file_information/abap_file_information_parser.js

@@ -326,12 +326,15 @@ class ABAPFileInformationParser {
                 continue;
             }
             const parameters = this.parseMethodParameters(def);
+            const concatenated = def.concatTokens().toUpperCase();
             methods.push({
                 name: methodName.getStr(),
                 identifier: new _identifier_1.Identifier(methodName, this.filename),
                 isRedefinition: def.findDirectExpression(Expressions.Redefinition) !== undefined,
-                isForTesting: def.concatTokens().toUpperCase().includes(" FOR TESTING"),
-                isFinal: def.concatTokens().toUpperCase().includes(" FINAL"),
+                isForTesting: concatenated.includes(" FOR TESTING"),
+                isFinal: concatenated.includes(" FINAL"),
+                isDefaultIgnore: concatenated.includes(" DEFAULT IGNORE"),
+                isDefaultFail: concatenated.includes(" DEFAULT FAIL"),
                 isAbstract: def.findDirectExpression(Expressions.Abstract) !== undefined,
                 isEventHandler: def.findDirectExpression(Expressions.EventHandler) !== undefined,
                 visibility,

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

@@ -259,11 +259,15 @@ class Source {
         }
         let hexExpected = false;
         let hexNext = false;
+        // an arithmetic operator has been seen, so the operands that follow
+        // determine a calculation type rather than simply replacing the context
+        let arithmetic = false;
         while (children.length >= 0) {
             if (first instanceof nodes_1.ExpressionNode) {
                 const get = first.get();
                 if (get instanceof Expressions.MethodCallChain) {
-                    context = method_call_chain_1.MethodCallChain.runSyntax(first, input, targetType);
+                    const found = method_call_chain_1.MethodCallChain.runSyntax(first, input, targetType);
+                    context = arithmetic === true ? this.infer(context, found, true) : found;
                     if (context === undefined) {
                         const message = "Method has no RETURNING value";
                         input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
@@ -271,18 +275,19 @@ class Source {
                     }
                 }
                 else if (get instanceof Expressions.FieldChain) {
-                    context = field_chain_1.FieldChain.runSyntax(first, input, type, allowGenericDeference);
+                    const found = field_chain_1.FieldChain.runSyntax(first, input, type, allowGenericDeference);
+                    context = arithmetic === true ? this.infer(context, found, true) : found;
                 }
                 else if (get instanceof Expressions.StringTemplate) {
                     context = string_template_1.StringTemplate.runSyntax(first, input);
                 }
                 else if (get instanceof Expressions.Source) {
                     const found = Source.runSyntax(first, input);
-                    context = this.infer(context, found);
+                    context = this.infer(context, found, arithmetic);
                 }
                 else if (get instanceof Expressions.Constant) {
                     const found = constant_1.Constant.runSyntax(first);
-                    context = this.infer(context, found);
+                    context = this.infer(context, found, arithmetic);
                 }
                 else if (get instanceof Expressions.Dereference) {
                     context = dereference_1.Dereference.runSyntax(first, context, input);
@@ -291,6 +296,7 @@ class Source {
                     context = component_chain_1.ComponentChain.runSyntax(context, first, input);
                 }
                 else if (get instanceof Expressions.ArithOperator) {
+                    arithmetic = true;
                     if (first.concatTokens() === "**") {
                         context = new basic_1.FloatType();
                     }
@@ -337,7 +343,13 @@ class Source {
             Source.runSyntax(last, input);
         }
     }
-    static infer(context, found) {
+    static infer(context, found, arithmetic = false) {
+        if (arithmetic === true) {
+            const calculation = this.calculationType(context, found);
+            if (calculation !== undefined) {
+                return calculation;
+            }
+        }
         if (context instanceof basic_1.FloatType && found instanceof basic_1.IntegerType) {
             return context;
         }
@@ -351,6 +363,56 @@ class Source {
             return found;
         }
     }
+    /** The calculation type of an arithmetic expression is the most general of the
+     * operand types. An operand of type c, n, d, t or string is converted into it and
+     * never becomes the result: "lv_f * '0.25'" is a float, not a character field of
+     * length four. Returns undefined when neither operand is numeric, leaving the
+     * decision to the caller. */
+    static calculationType(left, right) {
+        if (left === undefined || right === undefined) {
+            return undefined;
+        }
+        else if (left instanceof basic_1.VoidType || left instanceof unknown_type_1.UnknownType) {
+            // not knowing an operand means not knowing the result
+            return left;
+        }
+        else if (right instanceof basic_1.VoidType || right instanceof unknown_type_1.UnknownType) {
+            return right;
+        }
+        const leftRank = this.numericRank(left);
+        const rightRank = this.numericRank(right);
+        if (leftRank === undefined && rightRank === undefined) {
+            return undefined;
+        }
+        else if (rightRank === undefined) {
+            return left;
+        }
+        else if (leftRank === undefined) {
+            return right;
+        }
+        return leftRank >= rightRank ? left : right;
+    }
+    static numericRank(type) {
+        if (type instanceof basic_1.DecFloat34Type) {
+            return 6;
+        }
+        else if (type instanceof basic_1.DecFloat16Type) {
+            return 5;
+        }
+        else if (type instanceof basic_1.FloatType) {
+            return 4;
+        }
+        else if (type instanceof basic_1.PackedType) {
+            return 3;
+        }
+        else if (type instanceof basic_1.Integer8Type) {
+            return 2;
+        }
+        else if (type instanceof basic_1.IntegerType) {
+            return 1;
+        }
+        return undefined;
+    }
     static addIfInferred(node, input, inferredType) {
         const basic = new basic_types_1.BasicTypes(input);
         const typeExpression = node.findDirectExpression(Expressions.TypeNameOrInfer);

package/build/src/registry.js

@@ -75,7 +75,7 @@ class Registry {
     }
     static abaplintVersion() {
         // magic, see build script "version.js"
-        return "2.120.52";
+        return "2.120.53";
     }
     getDDICReferences() {
         return this.ddicReferences;

package/build/src/rules/implement_methods.js

@@ -221,6 +221,11 @@ class ImplementMethods extends _abap_rule_1.ABAPRule {
                 return [idef];
             }
             for (const m of this.findInterfaceMethods(idef)) {
+                if (m.method.isDefaultIgnore === true || m.method.isDefaultFail === true) {
+                    // the interface says an implementation is optional, so asking for one
+                    // reports an error where ABAP reports none
+                    continue;
+                }
                 if (this.isAbstract(m, interfaceInfo, def)) {
                     if (def.isAbstract) {
                         continue;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abaplint/core",
-    "version": "2.120.52",
+    "version": "2.120.53",
     "description": "abaplint - Core API",
     "main": "build/src/index.js",
     "typings": "build/abaplint.d.ts",