@abaplint/core 2.120.46 → 2.120.48

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

@@ -94,6 +94,13 @@ class TypeUtils {
             || type instanceof basic_1.UnknownType
             || type instanceof basic_1.VoidType;
     }
+    isCharLikeForCompare(type) {
+        return type === undefined
+            || type instanceof basic_1.StringType
+            || type instanceof basic_1.CLikeType
+            || type instanceof basic_1.CSequenceType
+            || this.isCharLikeField(type);
+    }
     isCharLike(type) {
         if (type === undefined) {
             return false;

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

@@ -43,6 +43,7 @@ const basic_1 = require("../../types/basic");
 const _type_utils_1 = require("../_type_utils");
 class Compare {
     static runSyntax(node, input) {
+        var _a;
         const sourceTypes = [];
         const sources = node.findDirectExpressions(Expressions.Source);
         for (const t of sources) {
@@ -54,8 +55,16 @@ class Compare {
         for (const t of node.findDirectExpressions(Expressions.MethodCallChain)) {
             method_call_chain_1.MethodCallChain.runSyntax(t, input);
         }
-        if (node.findDirectExpression(Expressions.CompareOperator)
-            && new _type_utils_1.TypeUtils(input.scope).isCompareable(sourceTypes[0], sourceTypes[1], sources[0], sources[1]) === false
+        const typeUtils = new _type_utils_1.TypeUtils(input.scope);
+        const compareOperator = (_a = node.findDirectExpression(Expressions.CompareOperator)) === null || _a === void 0 ? void 0 : _a.concatTokens().toUpperCase();
+        if (compareOperator === "CS"
+            && sourceTypes.length === 2
+            && sourceTypes.some((type) => typeUtils.isCharLikeForCompare(type) === false)) {
+            const message = "CS operands must be character-like (data type C, N, D, T, or STRING)";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+        }
+        else if (node.findDirectExpression(Expressions.CompareOperator)
+            && typeUtils.isCompareable(sourceTypes[0], sourceTypes[1], sources[0], sources[1]) === false
             && sourceTypes.length === 2) {
             let message = "Incompatible types for comparison";
             if ((sourceTypes[0] instanceof basic_1.DateType

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

@@ -32,6 +32,17 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InlineData = void 0;
 const Expressions = __importStar(require("../../2_statements/expressions"));
@@ -64,7 +75,7 @@ class InlineData {
                 input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
                 type = basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
             }
-            const identifier = new _typed_identifier_1.TypedIdentifier(token, input.filename, type, ["inline" /* IdentifierMeta.InlineDefinition */]);
+            const identifier = new _typed_identifier_1.TypedIdentifier(token, input.filename, this.stripDerivedFromConstant(type), ["inline" /* IdentifierMeta.InlineDefinition */]);
             input.scope.addIdentifier(identifier);
             input.scope.addReference(token, identifier, _reference_1.ReferenceType.DataWriteReference, input.filename);
         }
@@ -75,6 +86,26 @@ class InlineData {
             input.scope.addReference(token, identifier, _reference_1.ReferenceType.DataWriteReference, input.filename);
         }
     }
+    // The inferred type is taken from the source expression, which might be a literal.
+    // The variable itself is not a constant, so the relaxations that apply to literals
+    // must not be inherited, eg. a "c" variable is not assignable to a "string" parameter
+    static stripDerivedFromConstant(type) {
+        const data = type.getAbstractTypeData();
+        if ((data === null || data === void 0 ? void 0 : data.derivedFromConstant) !== true) {
+            return type;
+        }
+        const { derivedFromConstant } = data, rest = __rest(data, ["derivedFromConstant"]);
+        if (type instanceof basic_1.CharacterType) {
+            return new basic_1.CharacterType(type.getLength(), rest);
+        }
+        else if (type instanceof basic_1.IntegerType) {
+            return basic_1.IntegerType.get(rest);
+        }
+        else if (type instanceof basic_1.StringType) {
+            return basic_1.StringType.get(rest);
+        }
+        return type;
+    }
 }
 exports.InlineData = InlineData;
 //# sourceMappingURL=inline_data.js.map

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

@@ -38,17 +38,35 @@ const Expressions = __importStar(require("../../2_statements/expressions"));
 const inline_data_1 = require("../expressions/inline_data");
 const basic_1 = require("../../types/basic");
 const target_1 = require("../expressions/target");
+const _syntax_input_1 = require("../_syntax_input");
 class GetTime {
     runSyntax(node, input) {
         const target = node.findDirectExpression(Expressions.Target);
+        const stamp = node.findDirectTokenByText("STAMP") !== undefined;
         const inline = target === null || target === void 0 ? void 0 : target.findDirectExpression(Expressions.InlineData);
         if (inline) {
             inline_data_1.InlineData.runSyntax(inline, input, new basic_1.PackedType(8, 0));
         }
         else if (target) {
-            target_1.Target.runSyntax(target, input);
+            const type = target_1.Target.runSyntax(target, input);
+            if (stamp === true && this.compatibleTimeStamp(type) === false) {
+                const message = "GET TIME STAMP FIELD, target type not compatible";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
+            }
         }
     }
+    // the target must be a timestamp, ie. packed(timestamp and timestampl) or utclong
+    compatibleTimeStamp(type) {
+        return type === undefined
+            || type instanceof basic_1.PackedType
+            || type instanceof basic_1.UTCLongType
+            || type instanceof basic_1.VoidType
+            || type instanceof basic_1.AnyType
+            || type instanceof basic_1.DataType
+            || type instanceof basic_1.UnknownType
+            || type.isGeneric();
+    }
 }
 exports.GetTime = GetTime;
 //# sourceMappingURL=get_time.js.map

package/build/src/registry.js

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

package/package.json

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