@abaplint/core 2.120.75 → 2.120.77

package/build/abaplint.d.ts

@@ -624,6 +624,8 @@ export declare class BuiltIn {
     static searchBuiltin(name: string | undefined): IMethodDefinition | undefined;
     private static readonly unnamedArgument;
     static hasUnnamedArgument(name: string | undefined): boolean;
+    private static readonly argumentTypedReturn;
+    static returnsArgumentType(name: string | undefined): boolean;
     static isPredicate(name: string | undefined): boolean | undefined;
     getTypes(): TypedIdentifier[];
     get(extras: string[]): TypedIdentifier[];
@@ -7811,6 +7813,7 @@ export declare class SyntaxLogic {
     private readonly object;
     private readonly reg;
     private scope;
+    private loopTables;
     private helpers;
     constructor(reg: IRegistry, object: ABAPObject);
     run(): ISyntaxResult;

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

@@ -124,6 +124,12 @@ class BuiltIn {
         }
         return BuiltIn.unnamedArgument.has(name.toUpperCase());
     }
+    static returnsArgumentType(name) {
+        if (name === undefined) {
+            return false;
+        }
+        return BuiltIn.argumentTypedReturn.has(name.toUpperCase());
+    }
     static isPredicate(name) {
         if (name === undefined) {
             return undefined;
@@ -1231,4 +1237,6 @@ BuiltIn.unnamedArgument = new Set([
     "FRAC", "LINES", "LOG", "LOG10", "NUMOFCHAR", "SIGN", "SIN", "SINH", "SQRT", "STRLEN", "TAN", "TANH",
     "TRUNC", "XSTRLEN"
 ]);
+// numeric functions returning a value of the type of the argument
+BuiltIn.argumentTypedReturn = new Set(["ABS", "CEIL", "FLOOR", "FRAC", "SIGN", "TRUNC"]);
 //# sourceMappingURL=_builtin.js.map

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

@@ -0,0 +1,126 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoopTableChange = void 0;
+const Expressions = __importStar(require("../2_statements/expressions"));
+const Statements = __importStar(require("../2_statements/statements"));
+const nodes_1 = require("../nodes");
+const basic_1 = require("../types/basic");
+const _scope_type_1 = require("./_scope_type");
+const _syntax_input_1 = require("./_syntax_input");
+/** In a method, the body of the table an enclosing LOOP AT walks cannot be replaced or freed,
+ *  "you cannot access the entire table body in change mode in a loop. If this is known statically,
+ *  a syntax error occurs in classes", see the ABAP keyword documentation for LOOP AT itab.
+ *  Only tables named directly are handled, a field symbol or a reference is a runtime matter. */
+class LoopTableChange {
+    constructor() {
+        this.tables = [];
+    }
+    /** returns true if the LOOP structure was pushed, then pop() must be called after it */
+    push(node, scope) {
+        var _a, _b;
+        if (scope.getType() !== _scope_type_1.ScopeType.Method) {
+            return false;
+        }
+        const loop = node.findDirectStatement(Statements.Loop);
+        if (loop === undefined || loop.findDirectExpression(Expressions.LoopGroupBy) !== undefined) {
+            return false;
+        }
+        const chain = (_b = (_a = loop.findDirectExpression(Expressions.LoopSource)) === null || _a === void 0 ? void 0 : _a.findDirectExpression(Expressions.SimpleSource2)) === null || _b === void 0 ? void 0 : _b.findDirectExpression(Expressions.FieldChain);
+        const children = (chain === null || chain === void 0 ? void 0 : chain.getChildren()) || [];
+        if (children.length !== 1 && !(children.length === 2 && children[1].get() instanceof Expressions.TableBody)) {
+            return false;
+        }
+        const found = LoopTableChange.findTable(children[0], scope);
+        if (found === undefined) {
+            return false;
+        }
+        this.tables.push(found);
+        return true;
+    }
+    pop() {
+        this.tables.pop();
+    }
+    check(node, input) {
+        if (this.tables.length === 0 || input.scope.getType() !== _scope_type_1.ScopeType.Method) {
+            return;
+        }
+        // DELETE itab WHERE is not refused, abapGit does it in zcl_abapgit_syntax_xml->order_matches,
+        // SORT is left out, it is not certain that it is checked statically
+        const s = node.get();
+        if (!(s instanceof Statements.Clear)
+            && !(s instanceof Statements.Free)
+            && !(s instanceof Statements.Refresh)
+            && !(s instanceof Statements.Move)) {
+            return;
+        }
+        for (const target of node.findDirectExpressions(Expressions.Target)) {
+            const children = target.getChildren();
+            const body = children.length === 2 && children[1].get() instanceof Expressions.TableBody;
+            if (children.length !== 1 && body === false) {
+                continue;
+            }
+            else if (!(children[0].get() instanceof Expressions.TargetField)) {
+                continue;
+            }
+            const found = LoopTableChange.findTable(children[0], input.scope);
+            if (found === undefined || this.tables.includes(found) === false) {
+                continue;
+            }
+            else if (found.getType().isWithHeader() === true && body === false) {
+                // without [] the statement works on the header line
+                continue;
+            }
+            const message = `"${found.getName()}" cannot be changed as a whole inside a LOOP over it`;
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
+        }
+    }
+    static findTable(node, scope) {
+        var _a;
+        if (!(node instanceof nodes_1.ExpressionNode)
+            || node.getChildren().length !== 1
+            || !(((_a = node.getFirstChild()) === null || _a === void 0 ? void 0 : _a.get()) instanceof Expressions.Field)) {
+            return undefined;
+        }
+        const found = scope.findVariable(node.concatTokens());
+        if (found === undefined || !(found.getType() instanceof basic_1.TableType)) {
+            return undefined;
+        }
+        return found;
+    }
+}
+exports.LoopTableChange = LoopTableChange;
+//# sourceMappingURL=_loop_table_change.js.map

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

@@ -0,0 +1,83 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.substringType = substringType;
+exports.isFieldSymbolItself = isFieldSymbolItself;
+const Expressions = __importStar(require("../../2_statements/expressions"));
+const basic_1 = require("../../types/basic");
+const _syntax_input_1 = require("../_syntax_input");
+// The type of a substring with a static offset or length, used for reading and writing positions.
+// On a character or byte field of fixed length the substring must lie inside the field, else it is
+// a syntax error. Other types, a dynamic offset or length and "*" (undefined) are left alone, as is
+// length 0. The offset is applied first, so the length is compared to what remains after the offset.
+function substringType(context, offset, length, node, input) {
+    if (!(context instanceof basic_1.CharacterType) && !(context instanceof basic_1.HexType)) {
+        return context;
+    }
+    const fieldLength = context.getLength();
+    if (offset !== undefined && offset > 0) {
+        if (offset >= fieldLength) {
+            const message = `Offset ${offset} is outside the field of length ${fieldLength}`;
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
+        }
+        return context instanceof basic_1.CharacterType ? new basic_1.CharacterType(fieldLength - offset) : new basic_1.HexType(fieldLength - offset);
+    }
+    if (length !== undefined && length > 0) {
+        if (length > fieldLength) {
+            const message = `Length ${length} exceeds the remaining length ${fieldLength} of the field`;
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
+        }
+        return context instanceof basic_1.CharacterType ? new basic_1.CharacterType(length) : new basic_1.HexType(length);
+    }
+    return context;
+}
+// A field symbol typed "c" or "x" is generic, but its type is represented with length 1, so the
+// offset or length at "index" is not checked when it directly follows the field symbol
+function isFieldSymbolItself(children, index) {
+    var _a;
+    const first = (_a = children[0]) === null || _a === void 0 ? void 0 : _a.get();
+    if (!(first instanceof Expressions.SourceFieldSymbol) && !(first instanceof Expressions.TargetFieldSymbol)) {
+        return false;
+    }
+    for (let i = 1; i < index; i++) {
+        if (!(children[i].get() instanceof Expressions.FieldOffset)) {
+            return false;
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=_substring.js.map

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

@@ -46,6 +46,7 @@ const attribute_name_1 = require("./attribute_name");
 const table_expression_1 = require("./table_expression");
 const field_offset_1 = require("./field_offset");
 const field_length_1 = require("./field_length");
+const _substring_1 = require("./_substring");
 class AttributeChain {
     static runSyntax(inputContext, node, input, type) {
         if (inputContext instanceof void_type_1.VoidType) {
@@ -122,25 +123,11 @@ class AttributeChain {
             }
             else if (child instanceof nodes_1.ExpressionNode && child.get() instanceof Expressions.FieldOffset) {
                 const offset = field_offset_1.FieldOffset.runSyntax(child, input);
-                if (offset !== undefined) {
-                    if (contextType instanceof basic_1.CharacterType) {
-                        contextType = new basic_1.CharacterType(contextType.getLength() - offset);
-                    }
-                    else if (contextType instanceof basic_1.HexType) {
-                        contextType = new basic_1.HexType(contextType.getLength() - offset);
-                    }
-                }
+                contextType = (0, _substring_1.substringType)(contextType, offset, undefined, child, input);
             }
             else if (child instanceof nodes_1.ExpressionNode && child.get() instanceof Expressions.FieldLength) {
                 const length = field_length_1.FieldLength.runSyntax(child, input);
-                if (length !== undefined) {
-                    if (contextType instanceof basic_1.CharacterType) {
-                        contextType = new basic_1.CharacterType(length);
-                    }
-                    else if (contextType instanceof basic_1.HexType) {
-                        contextType = new basic_1.HexType(length);
-                    }
-                }
+                contextType = (0, _substring_1.substringType)(contextType, undefined, length, child, input);
             }
         }
         return contextType;

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

@@ -63,6 +63,11 @@ class Compare {
             input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), initialMessage));
             return;
         }
+        const predicateMessage = this.checkPredicateOperand(sources, input);
+        if (predicateMessage !== undefined) {
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), predicateMessage));
+            return;
+        }
         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"
@@ -103,6 +108,31 @@ class Compare {
         if ((chain === null || chain === void 0 ? void 0 : chain.length) === 4 && chain[0] instanceof nodes_1.TokenNode && (first === "XSDBOOL" || first === "BOOLC")) {
             return `Built-in function "${chain[0].getFirstToken().getStr()}" cannot be the operand of IS INITIAL`;
         }
+        const name = this.builtinCallName(node.findDirectExpression(Expressions.Source), input);
+        const returning = (_d = (_c = _builtin_1.BuiltIn.searchBuiltin(name)) === null || _c === void 0 ? void 0 : _c.getParameters().getReturning()) === null || _d === void 0 ? void 0 : _d.getType();
+        if (returning instanceof basic_1.StringType || returning instanceof basic_1.CharacterType) {
+            return `Built-in function "${name}" cannot be the operand of IS INITIAL`;
+        }
+        return undefined;
+    }
+    // a predicate function, contains( ) or line_exists( ), is a relational expression and not a value,
+    // it can stand alone as a condition or inside boolc( ) or xsdbool( ), but cannot be an operand of a comparison
+    static checkPredicateOperand(sources, input) {
+        if (input.scope.getOpenABAP()) {
+            return undefined;
+        }
+        for (const source of sources) {
+            const name = this.builtinCallName(source, input);
+            if (_builtin_1.BuiltIn.isPredicate(name) === true) {
+                return `Predicate function "${name}" cannot be the operand of a comparison`;
+            }
+        }
+        return undefined;
+    }
+    // the name of the built-in function when the source is exactly one call of it, not hidden by a method of the same name
+    static builtinCallName(source, input) {
+        var _a;
+        const chain = source === null || source === void 0 ? void 0 : source.getChildren();
         if ((chain === null || chain === void 0 ? void 0 : chain.length) !== 1 || !(chain[0] instanceof nodes_1.ExpressionNode) || !(chain[0].get() instanceof Expressions.MethodCallChain)) {
             return undefined;
         }
@@ -110,9 +140,8 @@ class Compare {
         if (calls.length !== 1 || !(calls[0] instanceof nodes_1.ExpressionNode) || !(calls[0].get() instanceof Expressions.MethodCall)) {
             return undefined;
         }
-        const name = (_c = calls[0].findDirectExpression(Expressions.MethodName)) === null || _c === void 0 ? void 0 : _c.concatTokens();
-        const builtin = _builtin_1.BuiltIn.searchBuiltin(name);
-        if (name === undefined || builtin === undefined) {
+        const name = (_a = calls[0].findDirectExpression(Expressions.MethodName)) === null || _a === void 0 ? void 0 : _a.concatTokens();
+        if (name === undefined || _builtin_1.BuiltIn.searchBuiltin(name) === undefined) {
             return undefined;
         }
         // a method of the same name hides the built-in function
@@ -120,11 +149,7 @@ class Compare {
         if (enclosing !== undefined && new _object_oriented_1.ObjectOriented(input.scope).searchMethodName(enclosing, name).method !== undefined) {
             return undefined;
         }
-        const returning = (_d = builtin.getParameters().getReturning()) === null || _d === void 0 ? void 0 : _d.getType();
-        if (returning instanceof basic_1.StringType || returning instanceof basic_1.CharacterType) {
-            return `Built-in function "${name}" cannot be the operand of IS INITIAL`;
-        }
-        return undefined;
+        return name;
     }
 }
 exports.Compare = Compare;

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

@@ -48,6 +48,7 @@ const expressions_1 = require("../../2_statements/expressions");
 const dereference_1 = require("./dereference");
 const source_field_symbol_1 = require("./source_field_symbol");
 const source_field_1 = require("./source_field");
+const _substring_1 = require("./_substring");
 const _syntax_input_1 = require("../_syntax_input");
 const version_1 = require("../../../version");
 class FieldChain {
@@ -160,24 +161,14 @@ class FieldChain {
             }
             else if (current.get() instanceof Expressions.FieldOffset && current instanceof nodes_1.ExpressionNode) {
                 const offset = field_offset_1.FieldOffset.runSyntax(current, input);
-                if (offset) {
-                    if (context instanceof basic_1.CharacterType) {
-                        context = new basic_1.CharacterType(context.getLength() - offset);
-                    }
-                    else if (context instanceof basic_1.HexType) {
-                        context = new basic_1.HexType(context.getLength() - offset);
-                    }
+                if (!(0, _substring_1.isFieldSymbolItself)(children, i)) {
+                    context = (0, _substring_1.substringType)(context, offset, undefined, current, input);
                 }
             }
             else if (current.get() instanceof Expressions.FieldLength && current instanceof nodes_1.ExpressionNode) {
                 const length = field_length_1.FieldLength.runSyntax(current, input);
-                if (length) {
-                    if (context instanceof basic_1.CharacterType) {
-                        context = new basic_1.CharacterType(length);
-                    }
-                    else if (context instanceof basic_1.HexType) {
-                        context = new basic_1.HexType(length);
-                    }
+                if (!(0, _substring_1.isFieldSymbolItself)(children, i)) {
+                    context = (0, _substring_1.substringType)(context, undefined, length, current, input);
                 }
             }
             prev = current.concatTokens();

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

@@ -141,7 +141,12 @@ class MethodCallChain {
                 }
                 const param = current.findDirectExpression(Expressions.MethodCallParam);
                 if (param && method) {
-                    method_call_param_1.MethodCallParam.runSyntax(param, input, method);
+                    const argumentType = method_call_param_1.MethodCallParam.runSyntax(param, input, method);
+                    if (method instanceof _builtin_1.BuiltInMethod
+                        && _builtin_1.BuiltIn.returnsArgumentType(methodName)
+                        && this.isNumeric(argumentType)) {
+                        context = argumentType;
+                    }
                 }
                 else if (param && context instanceof basic_1.VoidType) {
                     method_call_param_1.MethodCallParam.runSyntax(param, input, context);
@@ -158,6 +163,16 @@ class MethodCallChain {
         return context;
     }
     //////////////////////////////////////
+    static isNumeric(type) {
+        return type instanceof basic_1.IntegerType
+            || type instanceof basic_1.Integer8Type
+            || type instanceof basic_1.PackedType
+            || type instanceof basic_1.FloatType
+            || type instanceof basic_1.FloatingPointType
+            || type instanceof basic_1.DecFloatType
+            || type instanceof basic_1.DecFloat16Type
+            || type instanceof basic_1.DecFloat34Type;
+    }
     static findTop(first, input, targetType) {
         var _a;
         if (first.get() instanceof Expressions.ClassName) {

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

@@ -46,6 +46,7 @@ const constant_1 = require("./constant");
 const _check_offset_length_1 = require("./_check_offset_length");
 const _check_text_symbol_1 = require("./_check_text_symbol");
 class MethodCallParam {
+    /** returns the type of the unnamed argument, if any */
     static runSyntax(node, input, method) {
         if (!(node.get() instanceof Expressions.MethodCallParam)) {
             const message = "MethodCallParam, unexpected input";
@@ -125,6 +126,7 @@ class MethodCallParam {
                 input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
                 return;
             }
+            return sourceType;
         }
         else if (child instanceof nodes_1.ExpressionNode && child.get() instanceof Expressions.ParameterListS) {
             new method_parameters_1.MethodParameters().checkExporting(child, input, method);
@@ -137,6 +139,7 @@ class MethodCallParam {
             input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
             return;
         }
+        return undefined;
     }
 }
 exports.MethodCallParam = MethodCallParam;

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

@@ -74,7 +74,7 @@ const version_1 = require("../../../version");
 // TODO: refactor all these method parameters to objects, this is getting messy
 class Source {
     static runSyntax(node, input, targetType, writeReference = false, allowGenericDeference = false, readReference = true) {
-        var _a, _b, _c, _d;
+        var _a, _b;
         if (node === undefined) {
             return undefined;
         }
@@ -169,13 +169,7 @@ class Source {
                             this.traverseRemainingChildren(children, input);
                             return bodyType;
                         }
-                        const bodySource = (_b = node.findDirectExpression(Expressions.ConvBody)) === null || _b === void 0 ? void 0 : _b.findDirectExpression(Expressions.Source);
-                        const nestedType = (_c = bodySource === null || bodySource === void 0 ? void 0 : bodySource.findDirectExpression(Expressions.TypeNameOrInfer)) === null || _c === void 0 ? void 0 : _c.concatTokens();
-                        // CONV # passes its target type into a nested inferred constructor, so
-                        // showing both inferred types would produce duplicate inlay hints.
-                        if (!(inferred === "#" && nestedType === "#")) {
-                            this.addIfInferred(node, input, foundType);
-                        }
+                        this.addIfInferred(node, input, foundType);
                         this.traverseRemainingChildren(children, input);
                         return foundType;
                     }
@@ -233,7 +227,7 @@ class Source {
                     {
                         const foundType = this.determineType(node, input, targetType);
                         if ((foundType === null || foundType === void 0 ? void 0 : foundType.isGeneric()) === true
-                            && ((_d = node.findDirectExpression(Expressions.TypeNameOrInfer)) === null || _d === void 0 ? void 0 : _d.concatTokens()) === "#"
+                            && ((_b = node.findDirectExpression(Expressions.TypeNameOrInfer)) === null || _b === void 0 ? void 0 : _b.concatTokens()) === "#"
                             && !(0, version_1.releaseAtLeast)(input.scope.getRelease(), version_1.Release.v756)
                             && input.scope.getLanguageVersion() !== version_1.LanguageVersion.Cloud
                             && !input.scope.getOpenABAP()) {

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

@@ -47,6 +47,7 @@ const table_expression_1 = require("./table_expression");
 const expressions_1 = require("../../2_statements/expressions");
 const field_length_1 = require("./field_length");
 const cast_1 = require("./cast");
+const _substring_1 = require("./_substring");
 const _syntax_input_1 = require("../_syntax_input");
 const version_1 = require("../../../version");
 class Target {
@@ -154,6 +155,8 @@ class Target {
                 context = attribute_name_1.AttributeName.runSyntax(context, current, input, type);
             }
         }
+        // the substring is checked, but the type of the whole field is returned
+        let substring = context;
         const offset = node.findDirectExpression(Expressions.FieldOffset);
         if (offset) {
             if (context instanceof basic_1.XStringType || context instanceof basic_1.StringType) {
@@ -161,7 +164,10 @@ class Target {
                 input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
                 return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
             }
-            field_offset_1.FieldOffset.runSyntax(offset, input);
+            const value = field_offset_1.FieldOffset.runSyntax(offset, input);
+            if (!(0, _substring_1.isFieldSymbolItself)(children, children.indexOf(offset))) {
+                substring = (0, _substring_1.substringType)(substring, value, undefined, offset, input);
+            }
         }
         const length = node.findDirectExpression(Expressions.FieldLength);
         if (length) {
@@ -170,7 +176,13 @@ class Target {
                 input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
                 return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
             }
-            field_length_1.FieldLength.runSyntax(length, input);
+            const value = field_length_1.FieldLength.runSyntax(length, input);
+            if (!(0, _substring_1.isFieldSymbolItself)(children, children.indexOf(length))) {
+                substring = (0, _substring_1.substringType)(substring, undefined, value, length, input);
+            }
+        }
+        if (substring instanceof basic_1.VoidType && !(context instanceof basic_1.VoidType)) {
+            return substring;
         }
         return context;
     }

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

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReadTable = void 0;
 const Expressions = __importStar(require("../../2_statements/expressions"));
+const nodes_1 = require("../../nodes");
 const basic_1 = require("../../types/basic");
 const source_1 = require("../expressions/source");
 const inline_data_1 = require("../expressions/inline_data");
@@ -43,6 +44,9 @@ const fstarget_1 = require("../expressions/fstarget");
 const component_compare_simple_1 = require("../expressions/component_compare_simple");
 const _type_utils_1 = require("../_type_utils");
 const _syntax_input_1 = require("../_syntax_input");
+const _builtin_1 = require("../_builtin");
+const _object_oriented_1 = require("../_object_oriented");
+const version_1 = require("../../../version");
 class ReadTable {
     runSyntax(node, input) {
         const concat = node.concatTokens().toUpperCase();
@@ -69,6 +73,11 @@ class ReadTable {
         const components = node.findDirectExpression(Expressions.ComponentCompareSimple);
         if (components !== undefined) {
             component_compare_simple_1.ComponentCompareSimple.runSyntax(components, input, rowType);
+            const keyMessage = this.checkKeyOperands(components, input);
+            if (keyMessage !== undefined) {
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), keyMessage));
+                return;
+            }
         }
         const indexSource = node.findExpressionAfterToken("INDEX");
         if (indexSource) {
@@ -164,6 +173,36 @@ class ReadTable {
             }
         }
     }
+    // before 7.40 a WITH [TABLE] KEY operand is not an expression position, a built-in function from 7.02 on
+    // is read as a functional method call there, "method TO_UPPER is unknown" on a system, while
+    // functional methods and the older built-in functions like lines( ) are accepted
+    checkKeyOperands(node, input) {
+        var _a, _b;
+        if (input.scope.getOpenABAP() || (0, version_1.releaseAtLeast)(input.scope.getRelease(), version_1.Release.v740sp02)) {
+            return undefined;
+        }
+        for (const operand of node.findDirectExpressionsMulti([Expressions.Source, Expressions.SimpleSource4])) {
+            const chain = operand.getChildren();
+            if (chain.length !== 1 || !(chain[0] instanceof nodes_1.ExpressionNode) || !(chain[0].get() instanceof Expressions.MethodCallChain)) {
+                continue;
+            }
+            const calls = chain[0].getChildren();
+            if (calls.length !== 1 || !(calls[0] instanceof nodes_1.ExpressionNode) || !(calls[0].get() instanceof Expressions.MethodCall)) {
+                continue;
+            }
+            const name = (_a = calls[0].findDirectExpression(Expressions.MethodName)) === null || _a === void 0 ? void 0 : _a.concatTokens();
+            if (name === undefined || ((_b = _builtin_1.BuiltIn.methods[name.toUpperCase()]) === null || _b === void 0 ? void 0 : _b.release) === undefined) {
+                continue;
+            }
+            // a method of the same name hides the built-in function
+            const enclosing = input.scope.findClassDefinition(input.scope.getEnclosingClassName());
+            if (enclosing !== undefined && new _object_oriented_1.ObjectOriented(input.scope).searchMethodName(enclosing, name).method !== undefined) {
+                continue;
+            }
+            return `Built-in function "${name}" cannot be a READ TABLE key operand before 7.40`;
+        }
+        return undefined;
+    }
 }
 exports.ReadTable = ReadTable;
 //# sourceMappingURL=read_table.js.map

package/build/src/abap/5_syntax/structures/cleanup.js

@@ -0,0 +1,105 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cleanup = void 0;
+const Statements = __importStar(require("../../2_statements/statements"));
+const Structures = __importStar(require("../../3_structures/structures"));
+const nodes_1 = require("../../nodes");
+const _syntax_input_1 = require("../_syntax_input");
+const LOOPS = [
+    Structures.Loop,
+    Structures.LoopAtScreen,
+    Structures.LoopExtract,
+    Structures.Do,
+    Structures.While,
+    Structures.Select,
+    Structures.With,
+    Structures.Provide,
+];
+// a CLEANUP block cannot contain statements that statically leave it: RETURN, and EXIT, CONTINUE or CHECK
+// that do not belong to a loop inside the block, these end a loop outside the TRY or the processing block
+class Cleanup {
+    static runSyntax(node, input) {
+        if (input.scope.getOpenABAP()) {
+            return;
+        }
+        const body = node.findDirectStructure(Structures.Body);
+        if (body !== undefined) {
+            this.walk(body, false, input);
+        }
+    }
+    static walk(node, inLoop, input) {
+        for (const child of node.getChildren()) {
+            if (child instanceof nodes_1.StructureNode) {
+                const stru = child.get();
+                // a nested CLEANUP block is checked on its own, macro definitions and test injections do not run here
+                if (stru instanceof Structures.Cleanup
+                    || stru instanceof Structures.Define
+                    || stru instanceof Structures.TestInjection) {
+                    continue;
+                }
+                this.walk(child, inLoop || LOOPS.some(l => stru instanceof l), input);
+            }
+            else if (child instanceof nodes_1.StatementNode) {
+                const name = this.leavingStatement(child, inLoop);
+                if (name !== undefined) {
+                    const message = `${name} cannot leave a CLEANUP block`;
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, child.getFirstToken(), message));
+                }
+            }
+        }
+    }
+    static leavingStatement(node, inLoop) {
+        const s = node.get();
+        if (s instanceof Statements.Return) {
+            return "RETURN";
+        }
+        else if (inLoop === true) {
+            return undefined;
+        }
+        else if (s instanceof Statements.Exit && node.findDirectTokenByText("FROM") === undefined) {
+            return "EXIT";
+        }
+        else if (s instanceof Statements.Continue) {
+            return "CONTINUE";
+        }
+        else if (s instanceof Statements.Check) {
+            return "CHECK";
+        }
+        return undefined;
+    }
+}
+exports.Cleanup = Cleanup;
+//# sourceMappingURL=cleanup.js.map

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

@@ -50,6 +50,7 @@ const type_mesh_1 = require("./structures/type_mesh");
 const types_1 = require("./structures/types");
 const statics_1 = require("./structures/statics");
 const constants_1 = require("./structures/constants");
+const cleanup_1 = require("./structures/cleanup");
 const class_definition_1 = require("../types/class_definition");
 const interface_definition_1 = require("../types/interface_definition");
 const delete_memory_1 = require("./statements/delete_memory");
@@ -191,6 +192,7 @@ const _syntax_input_1 = require("./_syntax_input");
 const assert_error_1 = require("./assert_error");
 const field_group_1 = require("./statements/field_group");
 const stuff_1 = require("../../stuff");
+const _loop_table_change_1 = require("./_loop_table_change");
 // -----------------------------------
 const map = {};
 function addToMap(handler) {
@@ -352,6 +354,7 @@ class SyntaxLogic {
         };
         this.issues = [];
         this.deferred = [];
+        this.loopTables = new _loop_table_change_1.LoopTableChange();
         this.reg.getDDICReferences().clear(this.object);
         this.reg.getMSAGReferences().clear(this.object);
         if (this.object instanceof objects_1.Program && this.object.isInclude()) {
@@ -417,6 +420,9 @@ class SyntaxLogic {
         this.issues.push(issue);
     }
     traverse(node) {
+        const loop = node instanceof nodes_1.StructureNode
+            && node.get() instanceof Structures.Loop
+            && this.loopTables.push(node, this.scope);
         for (const child of node.getChildren()) {
             const isStructure = child instanceof nodes_1.StructureNode;
             const isStatement = child instanceof nodes_1.StatementNode;
@@ -449,6 +455,9 @@ class SyntaxLogic {
                 this.traverse(child);
             }
         }
+        if (loop === true) {
+            this.loopTables.pop();
+        }
     }
     /**
      * if this returns true, then the traversal should continue with next child
@@ -505,6 +514,9 @@ class SyntaxLogic {
             // todo: skipped for now
             return true;
         }
+        else if (stru instanceof Structures.Cleanup) {
+            cleanup_1.Cleanup.runSyntax(node, input);
+        }
         return false;
     }
     updateScopeStatement(node) {
@@ -534,6 +546,7 @@ class SyntaxLogic {
             this.scope.addIdentifier(new data_2.Data().runSyntax(node, input));
             return;
         }
+        this.loopTables.check(node, input);
         const name = s.constructor.name;
         if (map[name]) {
             map[name].runSyntax(node, input);

package/build/src/registry.js

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

package/build/src/rules/redundant_conversion.js

@@ -189,6 +189,9 @@ text = text.`,
             else if (child.get() instanceof Expressions.Constant) {
                 context = this.infer(context, constant_1.Constant.runSyntax(child));
             }
+            else if (child.get() instanceof Expressions.StringTemplate) {
+                context = basic_1.StringType.get();
+            }
             else if (child.get() instanceof Expressions.Source) {
                 context = this.infer(context, this.sourceType(child, scope));
             }

package/build/src/rules/use_message_class.js

@@ -40,7 +40,16 @@ const Expressions = __importStar(require("../abap/2_statements/expressions"));
 const Statements = __importStar(require("../abap/2_statements/statements"));
 const _basic_rule_config_1 = require("./_basic_rule_config");
 const _irule_1 = require("./_irule");
+const syntax_1 = require("../abap/5_syntax/syntax");
+const _typed_identifier_1 = require("../abap/types/_typed_identifier");
+const basic_1 = require("../abap/types/basic");
+const tokens_1 = require("../abap/1_lexer/tokens");
 class UseMessageClassConf extends _basic_rule_config_1.BasicRuleConfig {
+    constructor() {
+        super(...arguments);
+        /** Allow MESSAGE with an object reference, eg. an exception, like MESSAGE lx_error TYPE 'E' */
+        this.allowExceptions = true;
+    }
 }
 exports.UseMessageClassConf = UseMessageClassConf;
 class UseMessageClass extends _abap_rule_1.ABAPRule {
@@ -53,6 +62,9 @@ class UseMessageClass extends _abap_rule_1.ABAPRule {
             key: "use_message_class",
             title: "Use message class",
             shortDescription: `Define messages in SE91 instead of using inline text or variables`,
+            extendedInformation: `If allowExceptions is enabled, MESSAGE with an object reference is allowed, eg. MESSAGE lx_error TYPE 'E'.
+
+Void types are only allowed if the type name contains "CX_", as void class references cannot be distinguished from other void types.`,
             tags: [_irule_1.RuleTag.Styleguide, _irule_1.RuleTag.SingleFile],
             badExample: `MESSAGE 'Something went wrong' TYPE 'E'.`,
             goodExample: `MESSAGE e001(bc_msg).`,
@@ -64,13 +76,14 @@ class UseMessageClass extends _abap_rule_1.ABAPRule {
     setConfig(conf) {
         this.conf = conf;
     }
-    runParsed(file, _obj) {
+    runParsed(file, obj) {
         const structure = file.getStructure();
         if (structure === undefined) {
             return [];
         }
         const issues = [];
         const key = this.getMetadata().key;
+        let syntax = undefined;
         for (const statement of structure.findAllStatements(Statements.Message)) {
             // The parser populates MessageSource only for the class-based forms (e001(bc_msg) or ID/TYPE/NUMBER).
             // The text form (MESSAGE <source> TYPE <source>) uses MessageSourceSource directly with no MessageSource child.
@@ -78,10 +91,60 @@ class UseMessageClass extends _abap_rule_1.ABAPRule {
             if (statement.findDirectExpression(Expressions.MessageSource) !== undefined) {
                 continue;
             }
+            if (this.conf.allowExceptions === true) {
+                syntax !== null && syntax !== void 0 ? syntax : (syntax = new syntax_1.SyntaxLogic(this.reg, obj).run());
+                if (this.isObjectReference(statement, file, syntax)) {
+                    continue;
+                }
+            }
             issues.push(issue_1.Issue.atStatement(file, statement, "Use a message class (SE91) instead of inline text or variable", key, this.conf.severity));
         }
         return issues;
     }
+    isObjectReference(statement, file, syntax) {
+        var _a, _b;
+        const chain = (_b = (_a = statement.findDirectExpression(Expressions.MessageSourceSource)) === null || _a === void 0 ? void 0 : _a.findDirectExpression(Expressions.Source)) === null || _b === void 0 ? void 0 : _b.findDirectExpression(Expressions.FieldChain);
+        if (chain === undefined) {
+            return false;
+        }
+        let type = undefined;
+        for (const child of chain.getChildren()) {
+            const c = child.get();
+            if (c instanceof Expressions.ComponentName) {
+                type = type instanceof basic_1.StructureType ? type.getComponentByName(child.concatTokens()) : undefined;
+            }
+            else if (c instanceof Expressions.SourceField
+                || c instanceof Expressions.SourceFieldSymbol
+                || c instanceof Expressions.AttributeName) {
+                type = this.findType(child.getFirstToken().getStart(), file, syntax);
+            }
+            else if (c instanceof Expressions.ClassName
+                || c instanceof tokens_1.InstanceArrow
+                || c instanceof tokens_1.StaticArrow
+                || c instanceof tokens_1.Dash) {
+                continue;
+            }
+            else {
+                return false;
+            }
+            if (type === undefined) {
+                return false;
+            }
+        }
+        // void class references cannot be distinguished from other void types, guess based on the name
+        return type instanceof basic_1.ObjectReferenceType
+            || type instanceof basic_1.GenericObjectReferenceType
+            || (type instanceof basic_1.VoidType && /CX_/i.test(type.getVoided() || ""));
+    }
+    findType(start, file, syntax) {
+        const scope = syntax.spaghetti.lookupPosition(start, file.getFilename());
+        for (const r of (scope === null || scope === void 0 ? void 0 : scope.getData().references) || []) {
+            if (r.position.getStart().equals(start) && r.resolved instanceof _typed_identifier_1.TypedIdentifier) {
+                return r.resolved.getType();
+            }
+        }
+        return undefined;
+    }
 }
 exports.UseMessageClass = UseMessageClass;
 //# sourceMappingURL=use_message_class.js.map

package/package.json

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