@abaplint/core 2.119.65 → 2.119.67

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

@@ -323,7 +323,8 @@ class TypeUtils {
             console.dir(target);
             console.dir(calculated);
         */
-        if (calculated && source instanceof basic_1.StringType && target instanceof basic_1.XStringType) {
+        if (calculated && source instanceof basic_1.StringType
+            && (target instanceof basic_1.XStringType || target instanceof basic_1.XSequenceType)) {
             return false;
         }
         if (calculated) {

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

@@ -43,6 +43,7 @@ const source_1 = require("./source");
 const _type_utils_1 = require("../_type_utils");
 const _syntax_input_1 = require("../_syntax_input");
 const constant_1 = require("./constant");
+const _builtin_1 = require("../_builtin");
 class MethodCallParam {
     static runSyntax(node, input, method) {
         if (!(node.get() instanceof Expressions.MethodCallParam)) {
@@ -103,6 +104,19 @@ class MethodCallParam {
             let sourceType = undefined;
             if (child.get() instanceof Expressions.Source) {
                 sourceType = source_1.Source.runSyntax(child, input, targetType);
+                const chain = child.findDirectExpression(Expressions.FieldChain);
+                const isCalculated = child.findDirectExpression(Expressions.Source) !== undefined;
+                const hasOffsetOrLength = chain !== undefined
+                    && isCalculated === false
+                    && (chain.findDirectExpression(Expressions.FieldOffset) !== undefined
+                        || chain.findDirectExpression(Expressions.FieldLength) !== undefined);
+                if (hasOffsetOrLength
+                    && !(method instanceof _builtin_1.BuiltInMethod)
+                    && (sourceType instanceof basic_1.StringType || sourceType instanceof basic_1.XStringType)) {
+                    const message = `Offsets or lengths cannot be specified for fields of type "STRING" or "XSTRING" in the current statement`;
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, child.getFirstToken(), message));
+                    return;
+                }
             }
             else if (child.get() instanceof Expressions.ConstantString) {
                 sourceType = constant_1.Constant.runSyntax(child);

package/build/src/abap/5_syntax/statements/concatenate.js

@@ -45,6 +45,11 @@ class Concatenate {
     runSyntax(node, input) {
         const byteMode = node.findDirectTokenByText("BYTE") !== undefined;
         const linesMode = node.findDirectTokenByText("LINES") !== undefined;
+        if (node.findFirstExpression(Expressions.TableExpression) !== undefined) {
+            const message = "CONCATENATE with table expression not possible";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
+        }
         const target = node.findFirstExpression(Expressions.Target);
         const inline = target === null || target === void 0 ? void 0 : target.findDirectExpression(Expressions.InlineData);
         if (inline) {

package/build/src/registry.js

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

package/build/src/rules/downport.js

@@ -331,6 +331,18 @@ Make sure to test the downported code, it might not always be completely correct
                     }
                 }
             }
+            // INTO after WHERE parses as a valid SELECT in the low version, but is only allowed in
+            // strict SQL syntax, so move it also when the statement is no longer Unknown
+            if (ret.length === 0) {
+                for (let i = 0; i < lowStatements.length; i++) {
+                    const low = lowStatements[i];
+                    const high = highStatements[i];
+                    const issue = this.downportSQLMoveInto(low, high, lowFile, highSyntax);
+                    if (issue) {
+                        ret.push(issue);
+                    }
+                }
+            }
         }
         return ret;
     }
@@ -574,10 +586,14 @@ Make sure to test the downported code, it might not always be completely correct
         return undefined;
     }
     //////////////////////////////////////////
-    /** move INTO from after WHERE to after FROM */
+    /** move INTO from after WHERE to after FROM,
+     * note that INTO after WHERE is only valid in strict SQL syntax, so it must be moved when
+     * downporting; this can happen both while the statement is still Unknown(from the main loop)
+     * and after the @ and FIELDS have been removed, leaving a SELECT that parses in the low version */
     downportSQLMoveInto(low, high, lowFile, _highSyntax) {
         var _a;
-        if (!(low.get() instanceof _statement_1.Unknown)) {
+        if (!(high.get() instanceof Statements.Select)
+            && !(high.get() instanceof Statements.SelectLoop)) {
             return undefined;
         }
         // note: SQLCond is also used in JOIN(FROM) conditions
@@ -585,6 +601,7 @@ Make sure to test the downported code, it might not always be completely correct
         if (where === undefined) {
             return undefined;
         }
+        // the FIELDS list sits between FROM and WHERE, wait for it to be removed first
         if (high.findFirstExpression(Expressions.SQLFields) !== undefined) {
             return undefined;
         }

package/package.json

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