@abaplint/core 2.120.45 → 2.120.46

package/build/src/registry.js

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

package/build/src/rules/allowed_object_naming.js

@@ -17,7 +17,7 @@ class AllowedObjectNaming {
             key: "allowed_object_naming",
             title: "Allowed object naming",
             shortDescription: `Enforces basic name length and namespace restrictions, see note SAP 104010`,
-            tags: [_irule_1.RuleTag.Naming, _irule_1.RuleTag.SingleFile],
+            tags: [_irule_1.RuleTag.Naming, _irule_1.RuleTag.SingleFile, _irule_1.RuleTag.Syntax],
         };
     }
     initialize(_reg) {

package/build/src/rules/downport.js

@@ -409,6 +409,10 @@ Make sure to test the downported code, it might not always be completely correct
         if (found) {
             return found;
         }
+        found = this.outlineTableExpressionKeyBuiltin(low, high, lowFile, highSyntax);
+        if (found) {
+            return found;
+        }
         found = this.assignWithTable(low, high, lowFile);
         if (found) {
             return found;
@@ -1106,6 +1110,69 @@ ${indentation}`);
         }
         return condition;
     }
+    /** A built-in function is only recognized as one in an operand position that admits an
+     * expression, and "WITH KEY comp = ..." does not become such a position until v740. The
+     * table expression rewrites carry the key operand over verbatim, so
+     * "tab[ comp = to_upper( x ) ]" downports to a READ TABLE that a 702 or 731 compiler can
+     * only read as a functional method call - "method TO_UPPER is unknown", reported as a
+     * SYNTAX_ERROR of the whole class pool. Hoist the call into a variable first, an
+     * assignment IS an expression position at 702.
+     *
+     * Built-ins that predate 702 (lines, strlen, numofchar, ...) carry no release in
+     * BuiltIn.methods; they are accepted in the operand as they are and stay untouched. So do
+     * functional method calls, which are exactly the reading that makes the built-in fail, and
+     * the INDEX operand of "tab[ 1 ]", which is not a key operand. */
+    outlineTableExpressionKeyBuiltin(low, high, lowFile, highSyntax) {
+        if (!(low.get() instanceof _statement_1.Unknown)) {
+            return undefined;
+        }
+        for (const tableExpression of high.findAllExpressionsRecursive(Expressions.TableExpression)) {
+            let afterComponent = false;
+            for (const child of tableExpression.getChildren()) {
+                if (child.get() instanceof Expressions.ComponentChainSimple) {
+                    afterComponent = true;
+                    continue;
+                }
+                else if (afterComponent === false
+                    || !(child.get() instanceof Expressions.Source)
+                    || !(child instanceof nodes_1.ExpressionNode)) {
+                    continue;
+                }
+                const type = this.builtinReturnType(child, lowFile, highSyntax);
+                if (type === undefined) {
+                    continue;
+                }
+                const uniqueName = this.uniqueName(high.getFirstToken().getStart(), lowFile.getFilename(), highSyntax);
+                const indentation = " ".repeat(high.getFirstToken().getStart().getCol() - 1);
+                const code = `DATA ${uniqueName} TYPE ${type}.\n` +
+                    indentation + `${uniqueName} = ${child.concatTokens()}.\n` +
+                    indentation;
+                const fix1 = edit_helper_1.EditHelper.insertAt(lowFile, high.getFirstToken().getStart(), code);
+                const fix2 = edit_helper_1.EditHelper.replaceRange(lowFile, child.getFirstToken().getStart(), child.getLastToken().getEnd(), uniqueName);
+                const fix = edit_helper_1.EditHelper.merge(fix2, fix1);
+                return issue_1.Issue.atToken(lowFile, child.getFirstToken(), "Outline built-in function in table expression key", this.getMetadata().key, this.conf.severity, fix);
+            }
+        }
+        return undefined;
+    }
+    /** the ABAP type returned by the built-in function this Source starts with, or undefined
+     * if it does not start with one, or with one that predates 702 */
+    builtinReturnType(source, lowFile, highSyntax) {
+        var _a, _b, _c;
+        const spag = highSyntax.spaghetti.lookupPosition(source.getFirstToken().getStart(), lowFile.getFilename());
+        for (const r of (spag === null || spag === void 0 ? void 0 : spag.getData().references) || []) {
+            if (r.referenceType !== _reference_1.ReferenceType.BuiltinMethodReference
+                || r.position.getStart().equals(source.getFirstToken().getStart()) === false) {
+                continue;
+            }
+            const name = r.position.getName().toUpperCase();
+            if (((_a = _builtin_1.BuiltIn.methods[name]) === null || _a === void 0 ? void 0 : _a.release) === undefined) {
+                return undefined;
+            }
+            return (_c = (_b = _builtin_1.BuiltIn.searchBuiltin(name)) === null || _b === void 0 ? void 0 : _b.getParameters().getReturning()) === null || _c === void 0 ? void 0 : _c.getType().toABAP();
+        }
+        return undefined;
+    }
     outlineCatchSimple(node, lowFile) {
         // outlines "CATCH cx_bcs INTO DATA(lx_bcs_excep).", note that this does not need to look at types
         var _a, _b;
@@ -2716,9 +2783,13 @@ ${indentation}    output = ${uniqueName}.\n`;
                 continue;
             }
             const uniqueName = this.uniqueName(i.getFirstToken().getStart(), lowFile.getFilename(), highSyntax);
-            const type = this.findType(i, lowFile, highSyntax);
             const indent = " ".repeat(high.getFirstToken().getStart().getCol() - 1);
-            const abap = `DATA ${uniqueName} TYPE ${type}.\n` +
+            // the CONV type might just be a component of the row type, so prefer the row type
+            const rowOf = this.findRowTypeOf(high, i);
+            const declaration = rowOf === undefined
+                ? `DATA ${uniqueName} TYPE ${this.findType(i, lowFile, highSyntax)}.`
+                : `DATA ${uniqueName} LIKE LINE OF ${rowOf}.`;
+            const abap = declaration + "\n" +
                 indent + `${uniqueName} = ${body}.\n` +
                 indent;
             const fix1 = edit_helper_1.EditHelper.insertAt(lowFile, high.getFirstToken().getStart(), abap);
@@ -2728,6 +2799,19 @@ ${indentation}    output = ${uniqueName}.\n`;
         }
         return undefined;
     }
+    /** if the source expression is the complete source of an INSERT or APPEND statement, then the
+     * outlined variable must be typed via the row type of the table, returns the table name */
+    findRowTypeOf(high, source) {
+        var _a;
+        if (!(high.get() instanceof Statements.InsertInternal)
+            && !(high.get() instanceof Statements.Append)) {
+            return undefined;
+        }
+        else if (high.getChildren()[1] !== source) {
+            return undefined;
+        }
+        return (_a = high.findDirectExpression(Expressions.Target)) === null || _a === void 0 ? void 0 : _a.concatTokens();
+    }
     // "CAST" to "?="
     outlineCast(low, high, lowFile, highSyntax) {
         var _a;

package/package.json

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