@abaplint/cli 2.120.51 → 2.120.53

package/build/cli.js

@@ -53,6 +53,13 @@ const BUFS = new Set([
     CH_DOT, CH_COMMA, CH_COLON, 40 /* ( */, 41 /* ) */, 91 /* [ */,
     93 /* ] */, 43 /* + */, CH_AT
 ]);
+// characters that may follow the closing "'", "`" or "|" of a literal, anything else
+// is a syntax error, "There must be a space or equivalent character after ...",
+// note that "(" is allowed, ie. text elements like 'text'(001)
+const AFTER_LITERAL = new Set([
+    EOF, CH_SPACE, CH_TAB, CH_NL, CH_DOT, CH_COMMA, CH_COLON, CH_DQUOTE,
+    40 /* ( */, 41 /* ) */, 91 /* [ */, 93 /* ] */
+]);
 class Lexer {
     run(file, virtual) {
         this.virtual = virtual;
@@ -332,7 +339,11 @@ class Lexer {
                 && ahead !== CH_BACKTICK
                 && this.buffer.countIsEven(CH_BACKTICK)) {
                 // end of ping
-                this.add();
+                if (AFTER_LITERAL.has(ahead)) {
+                    this.add();
+                }
+                // else: no separator after the literal, keep the buffer so the following
+                // characters are glued onto the token, the parser will report the error
                 if (ahead === CH_DQUOTE) {
                     this.m = ModeComment;
                 }
@@ -345,7 +356,9 @@ class Lexer {
                 && (current === CH_PIPE || current === CH_LBRACE)
                 && (stream.prevChar() !== CH_BACKSLASH || (stream.prevPrevChar() === CH_BACKSLASH && stream.prevChar() === CH_BACKSLASH))) {
                 // end of template
-                this.add();
+                if (current === CH_LBRACE || AFTER_LITERAL.has(ahead)) {
+                    this.add();
+                }
                 this.m = ModeNormal;
             }
             else if (this.m === ModeTemplate
@@ -360,7 +373,9 @@ class Lexer {
                 && ahead !== CH_QUOTE
                 && this.buffer.countIsEven(CH_QUOTE)) {
                 // end of string
-                this.add();
+                if (AFTER_LITERAL.has(ahead)) {
+                    this.add();
+                }
                 if (ahead === CH_DQUOTE) {
                     this.m = ModeComment;
                 }
@@ -24650,12 +24665,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,
@@ -34725,6 +34743,7 @@ class Source {
                             return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
                         }
                         this.addIfInferred(node, input, foundType);
+                        this.traverseRemainingChildren(children, input);
                         return foundType;
                     }
                 case "REF":
@@ -34820,11 +34839,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));
@@ -34832,18 +34855,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);
@@ -34852,6 +34876,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();
                     }
@@ -34898,7 +34923,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;
         }
@@ -34912,6 +34943,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);
@@ -70563,7 +70644,7 @@ class Registry {
     }
     static abaplintVersion() {
         // magic, see build script "version.js"
-        return "2.120.51";
+        return "2.120.53";
     }
     getDDICReferences() {
         return this.ddicReferences;
@@ -84170,6 +84251,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/cli",
-    "version": "2.120.51",
+    "version": "2.120.53",
     "description": "abaplint - Command Line Interface",
     "funding": "https://github.com/sponsors/larshp",
     "bin": {
@@ -39,7 +39,7 @@
     },
     "homepage": "https://abaplint.org",
     "devDependencies": {
-        "@abaplint/core": "^2.120.51",
+        "@abaplint/core": "^2.120.53",
         "@types/chai": "^4.3.20",
         "@types/minimist": "^1.2.5",
         "@types/mocha": "^10.0.10",