@abaplint/core 2.120.70 → 2.120.72

package/build/src/rules/downport.js

@@ -531,7 +531,7 @@ Make sure to test the downported code, it might not always be completely correct
         if (found) {
             return found;
         }
-        found = this.outlineGetReferenceSimple(high, lowFile);
+        found = this.outlineGetReferenceSimple(high, lowFile, highSyntax);
         if (found) {
             return found;
         }
@@ -1206,7 +1206,17 @@ ${indentation}CATCH ${className} INTO ${targetName}.`;
         const fix = edit_helper_1.EditHelper.replaceRange(lowFile, node.getStart(), node.getEnd(), code);
         return issue_1.Issue.atToken(lowFile, node.getFirstToken(), "Outline DATA", this.getMetadata().key, this.conf.severity, fix);
     }
-    outlineGetReferenceSimple(node, lowFile) {
+    /** the type of a reference to the source: LIKE REF TO it, or REF TO data when its type is generic,
+     *  as LIKE REF TO a generically typed field symbol or parameter does not activate */
+    refTypeOf(sourceName, node, lowFile, highSyntax) {
+        var _a;
+        const spag = highSyntax.spaghetti.lookupPosition(node.getFirstToken().getStart(), lowFile.getFilename());
+        if (((_a = spag === null || spag === void 0 ? void 0 : spag.findVariable(sourceName)) === null || _a === void 0 ? void 0 : _a.getType().isGeneric()) === true) {
+            return "TYPE REF TO data";
+        }
+        return "LIKE REF TO " + sourceName;
+    }
+    outlineGetReferenceSimple(node, lowFile, highSyntax) {
         var _a, _b, _c;
         if (!(node.get() instanceof Statements.GetReference)) {
             return undefined;
@@ -1223,7 +1233,8 @@ ${indentation}CATCH ${className} INTO ${targetName}.`;
         const indentation = " ".repeat(node.getFirstToken().getStart().getCol() - 1);
         const firstToken = target.getFirstToken();
         const lastToken = target.getLastToken();
-        const fix1 = edit_helper_1.EditHelper.insertAt(lowFile, node.getStart(), `DATA ${targetName} LIKE REF TO ${source.concatTokens()}.\n${indentation}`);
+        const refType = this.refTypeOf(source.concatTokens(), node, lowFile, highSyntax);
+        const fix1 = edit_helper_1.EditHelper.insertAt(lowFile, node.getStart(), `DATA ${targetName} ${refType}.\n${indentation}`);
         const fix2 = edit_helper_1.EditHelper.replaceRange(lowFile, firstToken.getStart(), lastToken.getEnd(), targetName);
         const fix = edit_helper_1.EditHelper.merge(fix2, fix1);
         return issue_1.Issue.atToken(lowFile, node.getFirstToken(), "Outline DATA", this.getMetadata().key, this.conf.severity, fix);
@@ -1240,7 +1251,7 @@ ${indentation}CATCH ${className} INTO ${targetName}.`;
         if (!(((_a = target === null || target === void 0 ? void 0 : target.getFirstChild()) === null || _a === void 0 ? void 0 : _a.get()) instanceof Expressions.InlineData)) {
             return undefined;
         }
-        let type = "";
+        let type;
         const source = node.findFirstExpression(Expressions.Source);
         if (source === undefined) {
             return undefined;
@@ -1330,8 +1341,8 @@ ${indentation}CATCH ${className} INTO ${targetName}.`;
         if (!(node.get() instanceof Statements.Raise)) {
             return undefined;
         }
-        let id = undefined;
-        let number = undefined;
+        let id;
+        let number;
         let startToken = node.findDirectTokenByText("ID");
         if (startToken) {
             const sources = node.findDirectExpressions(Expressions.Source);
@@ -1489,7 +1500,7 @@ ${indentation}${uniqueName2}->if_t100_message~t100key = ${uniqueName1}.\n`;
             || sourceRef.getChildren().length !== 1) {
             return undefined;
         }
-        let code = "";
+        let code;
         if (sourceRef.findFirstExpression(Expressions.TableExpression)) {
             const uniqueName = this.uniqueName(high.getFirstToken().getStart(), lowFile.getFilename(), highSyntax);
             code = `ASSIGN ${sourceRef.concatTokens()} TO FIELD-SYMBOL(<${uniqueName}>).
@@ -1681,7 +1692,7 @@ LOOP AT ${groupTargetName}tab ${groupTarget}.`;
             || !(tableExpression instanceof nodes_1.ExpressionNode)) {
             return undefined;
         }
-        let condition = "";
+        let condition;
         if (tableExpression.getChildren().length === 3) {
             const index = tableExpression.findDirectExpression(Expressions.Source);
             if (index === undefined) {
@@ -1865,7 +1876,7 @@ ${indentation}${uniqueName}`;
             return undefined;
         }
         const op = secondChild.getFirstToken();
-        let operator = "";
+        let operator;
         switch (op.getStr()) {
             case "+":
                 operator = " + ";
@@ -1907,7 +1918,7 @@ ${indentation}${uniqueName}`;
                 || (formatting === null || formatting === void 0 ? void 0 : formatting.startsWith("ALPHA = ")) === false) {
                 continue;
             }
-            let functionName = "";
+            let functionName;
             switch (formatting) {
                 case "ALPHA = IN":
                     functionName = "CONVERSION_EXIT_ALPHA_INPUT";
@@ -2203,13 +2214,12 @@ ${indentation}    output = ${uniqueName}.\n`;
             const uniqueName = this.uniqueName(firstToken.getStart(), lowFile.getFilename(), highSyntax);
             const indentation = " ".repeat(high.getFirstToken().getStart().getCol() - 1);
             let body = "";
-            let name = "";
             const switchBody = i.findDirectExpression(Expressions.SwitchBody);
             if (switchBody === undefined) {
                 continue;
             }
             for (const l of ((_c = switchBody === null || switchBody === void 0 ? void 0 : switchBody.findDirectExpression(Expressions.Let)) === null || _c === void 0 ? void 0 : _c.findDirectExpressions(Expressions.InlineFieldDefinition)) || []) {
-                name = l.getFirstToken().getStr();
+                const name = l.getFirstToken().getStr();
                 body += indentation + `DATA(${name}) = ${(_d = switchBody.findFirstExpression(Expressions.Source)) === null || _d === void 0 ? void 0 : _d.concatTokens()}.\n`;
             }
             body += `DATA ${uniqueName} ${type}.\n`;
@@ -2267,7 +2277,6 @@ ${indentation}    output = ${uniqueName}.\n`;
             const uniqueName = this.uniqueName(firstToken.getStart(), lowFile.getFilename(), highSyntax);
             const indentation = " ".repeat(high.getFirstToken().getStart().getCol() - 1);
             let body = "";
-            let name = "";
             const reduceBody = i.findDirectExpression(Expressions.ReduceBody);
             if (reduceBody === undefined) {
                 continue;
@@ -2278,7 +2287,7 @@ ${indentation}    output = ${uniqueName}.\n`;
             }
             let firstName = "";
             for (const init of reduceBody.findDirectExpressions(Expressions.InlineFieldDefinition)) {
-                name = init.getFirstToken().getStr();
+                const name = init.getFirstToken().getStr();
                 if (firstName === "") {
                     firstName = name;
                 }
@@ -2510,7 +2519,7 @@ ${indentation}    output = ${uniqueName}.\n`;
                         after += c.concatTokens();
                     }
                 }
-                let condition = "";
+                let condition;
                 if ((tableExpression === null || tableExpression === void 0 ? void 0 : tableExpression.getChildren().length) === 3) {
                     condition = "INDEX " + ((_d = tableExpression === null || tableExpression === void 0 ? void 0 : tableExpression.findDirectExpression(Expressions.Source)) === null || _d === void 0 ? void 0 : _d.concatTokens());
                 }
@@ -2661,7 +2670,7 @@ ${indentation}    output = ${uniqueName}.\n`;
                 continue;
             }
             const name = nameToken.getStr();
-            let type = "";
+            let type;
             if (high.concatTokens().toUpperCase().startsWith("APPEND INITIAL LINE TO ")) {
                 type = "LIKE LINE OF " + ((_b = high.findFirstExpression(Expressions.Target)) === null || _b === void 0 ? void 0 : _b.concatTokens());
             }
@@ -3027,7 +3036,7 @@ ${indentation}    output = ${uniqueName}.\n`;
         }
         return undefined;
     }
-    getReference(node, lowFile, _highSyntax) {
+    getReference(node, lowFile, highSyntax) {
         var _a, _b, _c;
         if (!(node.get() instanceof Statements.GetReference)) {
             return undefined;
@@ -3041,7 +3050,7 @@ ${indentation}    output = ${uniqueName}.\n`;
         if (targetName === undefined || sourceName === undefined) {
             return undefined;
         }
-        const code = `DATA ${targetName} LIKE REF TO ${sourceName}.\n`;
+        const code = `DATA ${targetName} ${this.refTypeOf(sourceName, node, lowFile, highSyntax)}.\n`;
         const fix1 = edit_helper_1.EditHelper.insertAt(lowFile, node.getFirstToken().getStart(), code);
         const fix2 = edit_helper_1.EditHelper.replaceRange(lowFile, inline.getFirstToken().getStart(), inline.getLastToken().getEnd(), targetName);
         const fix = edit_helper_1.EditHelper.merge(fix2, fix1);
@@ -3118,18 +3127,30 @@ ${indentation}    output = ${uniqueName}.\n`;
                 const uniqueName = this.uniqueName(node.getFirstToken().getStart(), lowFile.getFilename(), highSyntax);
                 const indentation = " ".repeat(node.getFirstToken().getStart().getCol() - 1);
                 const sy = func === "LINE_EXISTS" ? "sy-subrc" : "sy-tabix";
-                const code = `DATA ${uniqueName} LIKE sy-subrc.\n` +
-                    indentation + `READ TABLE ${tableName} ${condition}TRANSPORTING NO FIELDS.\n` +
-                    indentation + uniqueName + ` = ${sy}.\n` +
-                    indentation;
                 let insertAt = node.getFirstToken().getStart();
                 if (node.get() instanceof statements_1.ElseIf) {
-                    // assumption: no side effects in IF conditions
+                    // assumption: no side effects in IF conditions, except the READ itself, see below
                     insertAt = this.findStartOfIf(node, highFile);
                     if (insertAt === undefined) {
                         continue;
                     }
                 }
+                // the READ sets sy-subrc and sy-tabix, which the built-in function does not,
+                // keep the values for the code that reads them after the inserted READ
+                const keep = [];
+                const reads = this.readSyFields(insertAt, highFile);
+                for (const field of ["sy-subrc", "sy-tabix"]) {
+                    if (reads.has(field)) {
+                        keep.push({ field, name: this.uniqueName(node.getFirstToken().getStart(), lowFile.getFilename(), highSyntax) });
+                    }
+                }
+                const code = `DATA ${uniqueName} LIKE sy-subrc.\n` +
+                    keep.map(k => indentation + `DATA ${k.name} LIKE ${k.field}.\n`).join("") +
+                    keep.map(k => indentation + `${k.name} = ${k.field}.\n`).join("") +
+                    indentation + `READ TABLE ${tableName} ${condition}TRANSPORTING NO FIELDS.\n` +
+                    indentation + uniqueName + ` = ${sy}.\n` +
+                    keep.map(k => indentation + `${k.field} = ${k.name}.\n`).join("") +
+                    indentation;
                 const fix1 = edit_helper_1.EditHelper.insertAt(lowFile, insertAt, code);
                 const start = expression.getFirstToken().getStart();
                 const end = expression.getLastToken().getEnd();
@@ -3140,6 +3161,46 @@ ${indentation}    output = ${uniqueName}.\n`;
         }
         return undefined;
     }
+    /** sy-subrc and sy-tabix, when read from the position on, in the procedure around it or the file outside of one;
+     *  inside a loop from the start of the outermost loop, as the next pass reads what this one left */
+    readSyFields(position, highFile) {
+        const structure = highFile.getStructure();
+        const contains = (s) => !position.isBefore(s.getFirstToken().getStart())
+            && !position.isAfter(s.getLastToken().getStart());
+        let scope = undefined;
+        for (const s of [Structures.Method, Structures.Form, Structures.FunctionModule]) {
+            for (const p of (structure === null || structure === void 0 ? void 0 : structure.findAllStructuresRecursive(s)) || []) {
+                if (contains(p)) {
+                    scope = p;
+                }
+            }
+        }
+        scope = scope || structure;
+        let from = position;
+        for (const s of [Structures.Loop, Structures.Do, Structures.While, Structures.Select]) {
+            for (const l of (scope === null || scope === void 0 ? void 0 : scope.findAllStructuresRecursive(s)) || []) {
+                if (contains(l) && l.getFirstToken().getStart().isBefore(from)) {
+                    from = l.getFirstToken().getStart();
+                }
+            }
+        }
+        const ret = new Set();
+        for (const s of (scope === null || scope === void 0 ? void 0 : scope.findAllStatementNodes()) || []) {
+            if (s.getLastToken().getStart().isBefore(from)) {
+                continue;
+            }
+            const tokens = s.getTokens();
+            for (let i = 0; i < tokens.length - 2; i++) {
+                if (tokens[i].getStr().toUpperCase() === "SY" && tokens[i + 1].getStr() === "-") {
+                    const field = "sy-" + tokens[i + 2].getStr().toLowerCase();
+                    if (field === "sy-subrc" || field === "sy-tabix") {
+                        ret.add(field);
+                    }
+                }
+            }
+        }
+        return ret;
+    }
     findStartOfIf(node, highFile) {
         const structure = highFile.getStructure();
         for (const c of (structure === null || structure === void 0 ? void 0 : structure.findAllStructuresRecursive(Structures.If)) || []) {
@@ -3152,6 +3213,7 @@ ${indentation}    output = ${uniqueName}.\n`;
         return undefined;
     }
     newToCreateObject(low, high, lowFile, highSyntax) {
+        var _a;
         if (!(low.get() instanceof _statement_1.Unknown)) {
             return undefined;
         }
@@ -3167,7 +3229,7 @@ ${indentation}    output = ${uniqueName}.\n`;
                 && found
                 && source.concatTokens() === found.concatTokens()
                 && target.findDirectExpression(Expressions.InlineData) === undefined) {
-                const abap = this.newParameters(found, target.concatTokens(), highSyntax, lowFile);
+                const abap = (_a = this.newDataReference(high, target, found, lowFile, highSyntax)) !== null && _a !== void 0 ? _a : this.newParameters(found, target.concatTokens(), highSyntax, lowFile);
                 if (abap !== undefined) {
                     fix = edit_helper_1.EditHelper.replaceRange(lowFile, high.getFirstToken().getStart(), high.getLastToken().getEnd(), abap);
                 }
@@ -3206,6 +3268,42 @@ ${indentation}    output = ${uniqueName}.\n`;
             return undefined;
         }
     }
+    /** NEW into a data reference creates data, CREATE OBJECT cannot: "target = NEW #|type( [value] )"
+     *  with a variable typed REF TO a data type becomes CREATE DATA plus the assignment of the value */
+    newDataReference(high, target, found, lowFile, highSyntax) {
+        var _a, _b, _c;
+        if (target.getChildren().length !== 1 || !(((_a = target.getFirstChild()) === null || _a === void 0 ? void 0 : _a.get()) instanceof Expressions.TargetField)) {
+            return undefined;
+        }
+        const children = found.getChildren();
+        const value = found.findDirectExpression(Expressions.Source);
+        // NEW, the type, "(", optionally one value, ")"
+        if (children.length !== 4 + (value ? 1 : 0)) {
+            return undefined;
+        }
+        const name = target.concatTokens();
+        const spag = highSyntax.spaghetti.lookupPosition(high.getFirstToken().getStart(), lowFile.getFilename());
+        const type = (_b = spag === null || spag === void 0 ? void 0 : spag.findVariable(name)) === null || _b === void 0 ? void 0 : _b.getType();
+        if (!(type instanceof basic_1.DataReference)) {
+            return undefined;
+        }
+        const typeName = (_c = found.findDirectExpression(Expressions.TypeNameOrInfer)) === null || _c === void 0 ? void 0 : _c.concatTokens();
+        const indentation = " ".repeat(high.getFirstToken().getStart().getCol() - 1);
+        let abap = `CREATE DATA ${name}` + (typeName === "#" ? "" : ` TYPE ${typeName}`) + ".";
+        if (value === undefined) {
+            return abap;
+        }
+        else if (type.getType().isGeneric() === false) {
+            return abap + `\n${indentation}${name}->* = ${value.concatTokens()}.`;
+        }
+        // a generic reference cannot be dereferenced as a target below v756
+        const fs = this.uniqueName(high.getFirstToken().getStart(), lowFile.getFilename(), highSyntax, true);
+        abap = `FIELD-SYMBOLS ${fs} TYPE any.\n` +
+            indentation + abap + "\n" +
+            indentation + `ASSIGN ${name}->* TO ${fs}.\n` +
+            indentation + `${fs} = ${value.concatTokens()}.`;
+        return abap;
+    }
     newParameters(found, name, highSyntax, lowFile) {
         var _a, _b, _c;
         const typeToken = (_a = found.findDirectExpression(Expressions.TypeNameOrInfer)) === null || _a === void 0 ? void 0 : _a.getFirstToken();

package/build/src/rules/empty_structure.js

@@ -63,6 +63,8 @@ class EmptyStructureConf extends _basic_rule_config_1.BasicRuleConfig {
         this.try = true;
         /** Checks for empty WHEN blocks */
         this.when = true;
+        /** Checks for empty CATCH blocks, unless the CATCH has pragma ##NO_HANDLER or pseudo comment "#EC NO_HANDLER */
+        this.catch = false;
         // todo, other category containing ELSE
     }
 }
@@ -175,6 +177,21 @@ result = xsdbool( sy-subrc = 0 ).`,
                 }
             }
         }
+        if (this.getConfig().catch === true) {
+            for (const c of stru.findAllStructuresRecursive(Structures.Catch)) {
+                // a comment in the block does not count, the extended check (SLIN) reports it too
+                if (c.findDirectStructure(Structures.Body) !== undefined) {
+                    continue;
+                }
+                const catchStatement = c.getFirstStatement();
+                if (catchStatement === undefined || this.isNoHandler(catchStatement, statements)) {
+                    continue;
+                }
+                const token = c.getFirstToken();
+                const issue = issue_1.Issue.atToken(file, token, this.getDescription(c.get().constructor.name), this.getMetadata().key, this.conf.severity);
+                issues.push(issue);
+            }
+        }
         if (this.getConfig().when === true) {
             const tries = stru.findAllStructuresRecursive(Structures.When);
             for (const t of tries) {
@@ -188,6 +205,15 @@ result = xsdbool( sy-subrc = 0 ).`,
         }
         return issues;
     }
+    isNoHandler(catchStatement, statements) {
+        if (catchStatement.getPragmas().some(p => p.getStr().toUpperCase() === "##NO_HANDLER")) {
+            return true;
+        }
+        const next = statements[statements.indexOf(catchStatement) + 1];
+        return (next === null || next === void 0 ? void 0 : next.get()) instanceof _statement_1.Comment
+            && next.getStart().getRow() === catchStatement.getEnd().getRow()
+            && next.concatTokens().toUpperCase().replace(/\s/g, "").includes("\"#ECNO_HANDLER");
+    }
 }
 exports.EmptyStructure = EmptyStructure;
 //# sourceMappingURL=empty_structure.js.map

package/build/src/rules/functional_writing.js

@@ -138,7 +138,7 @@ cl_abap_typedescr=>describe_by_name(
         const methodSource = statNode.findDirectExpression(Expressions.MethodSource);
         let methodSourceStr = methodSource === null || methodSource === void 0 ? void 0 : methodSource.concatTokens();
         const methodBody = statNode.findDirectExpression(Expressions.MethodCallBody);
-        let methodBodyStr = "";
+        let methodBodyStr;
         if (methodBody) {
             const methodCallParam = methodBody.findDirectExpression(Expressions.MethodCallParam);
             if (methodCallParam && methodCallParam.getFirstToken().getStr() === "(") {

package/build/src/rules/keyword_case.js

@@ -215,7 +215,7 @@ class KeywordCase extends _abap_rule_1.ABAPRule {
         const firstToken = tokens[0].token;
         const lastToken = tokens[tokens.length - 1].token;
         const firstTokenValue = firstToken.getStr();
-        let description = "";
+        let description;
         if (first.keyword === true) {
             description = `Keyword should be ${this.conf.style} case: "${firstTokenValue}"`;
         }

package/build/src/rules/local_class_naming.js

@@ -58,7 +58,7 @@ ENDCLASS.`,
                 continue;
             }
             const className = classDef.name;
-            let expected = "";
+            let expected;
             if (classDef.isForTesting) {
                 expected = this.conf.test;
             }

package/build/src/rules/many_parentheses.js

@@ -86,7 +86,7 @@ ENDIF.
             issues.push(...this.analyzeCondition(file, cond));
         }
         for (const sub of structure.findAllExpressionsMulti([Expressions.CondSub, Expressions.ComponentCondSub])) {
-            let cond = [];
+            let cond;
             if (sub.get() instanceof Expressions.CondSub) {
                 cond = sub.findDirectExpressions(Expressions.Cond);
             }

package/build/src/rules/obsolete_statement.js

@@ -486,13 +486,9 @@ ENDIF.`,
         }
         else if (statement instanceof Statements.ClassDefinitionLoad ||
             statement instanceof Statements.InterfaceLoad) {
-            let token = undefined;
-            if (statement instanceof Statements.ClassDefinitionLoad) {
-                token = statementNode.getChildren()[3].getFirstToken();
-            }
-            else {
-                token = statementNode.getChildren()[2].getFirstToken();
-            }
+            const token = statement instanceof Statements.ClassDefinitionLoad
+                ? statementNode.getChildren()[3].getFirstToken()
+                : statementNode.getChildren()[2].getFirstToken();
             let startPosition = token.getStart();
             startPosition = new position_1.Position(startPosition.getRow(), startPosition.getCol() - 1);
             return edit_helper_1.EditHelper.deleteRange(file, startPosition, token.getEnd());

package/build/src/rules/parser_missing_space.js

@@ -36,7 +36,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParserMissingSpace = exports.ParserMissingSpaceConf = void 0;
 const Expressions = __importStar(require("../abap/2_statements/expressions"));
 const issue_1 = require("../issue");
-const position_1 = require("../position");
 const _abap_rule_1 = require("./_abap_rule");
 const nodes_1 = require("../abap/nodes");
 const _basic_rule_config_1 = require("./_basic_rule_config");
@@ -69,7 +68,7 @@ This rule makes sure the spaces are consistently required across the language.`,
     }
     runParsed(file) {
         const issues = [];
-        let start = new position_1.Position(0, 0);
+        let start;
         for (const statement of file.getStatements()) {
             const missing = this.missingSpace(statement);
             if (missing) {

package/build/src/rules/prefer_raise_exception_new.js

@@ -93,14 +93,8 @@ From 752 and up`,
     }
     getFix(file, statement, withExporting) {
         const children = statement.getChildren();
-        let contentFix = undefined;
-        if (withExporting) {
-            const fixText = "( " + children[5].concatTokens() + " ).";
-            contentFix = edit_helper_1.EditHelper.replaceRange(file, children[3].getLastToken().getEnd(), statement.getEnd(), fixText);
-        }
-        else {
-            contentFix = edit_helper_1.EditHelper.replaceRange(file, children[3].getLastToken().getEnd(), statement.getEnd(), "( ).");
-        }
+        const fixText = withExporting ? "( " + children[5].concatTokens() + " )." : "( ).";
+        const contentFix = edit_helper_1.EditHelper.replaceRange(file, children[3].getLastToken().getEnd(), statement.getEnd(), fixText);
         const replaceType = edit_helper_1.EditHelper.replaceToken(file, children[2].getFirstToken(), "NEW");
         return edit_helper_1.EditHelper.merge(contentFix, replaceType);
     }

package/build/src/rules/redundant_conversion.js

@@ -60,7 +60,8 @@ class RedundantConversion {
             key: "redundant_conversion",
             title: "Redundant Conversion",
             shortDescription: `Find redundant CONV expressions`,
-            extendedInformation: `Reports CONV expressions whose operand already has the conversion's target type.`,
+            extendedInformation: `Reports CONV expressions whose operand already has the conversion's target type,
+including the result of a built-in function with a fixed result type, like to_upper( ) or strlen( ).`,
             tags: [_irule_1.RuleTag.Quickfix],
             badExample: `DATA text TYPE string.
 text = CONV string( text ).`,
@@ -97,7 +98,8 @@ text = text.`,
             if (structure === undefined) {
                 continue;
             }
-            for (const source of structure.findAllExpressions(Expressions.Source)) {
+            // recursive, a CONV can be the argument of a built-in function, which is itself a Source
+            for (const source of structure.findAllExpressionsRecursive(Expressions.Source)) {
                 if (source.getFirstToken().getStr().toUpperCase() !== "CONV") {
                     continue;
                 }
@@ -156,6 +158,15 @@ text = text.`,
     }
     sourceType(source, scope) {
         let context;
+        // boolc( <condition> ) is not a MethodCallChain, xsdbool( ) has the same shape but is not reported
+        const first = source.getFirstToken();
+        if (first.getStr().toUpperCase() === "BOOLC"
+            && source.findDirectExpression(Expressions.Cond) !== undefined
+            && source.getChildren().length === 4
+            && scope.getData().references.some(reference => reference.referenceType === _reference_1.ReferenceType.BuiltinMethodReference
+                && reference.position.getStart().equals(first.getStart()))) {
+            return basic_1.StringType.get();
+        }
         for (const child of source.getChildren()) {
             if (!(child instanceof nodes_1.ExpressionNode)) {
                 continue;
@@ -166,6 +177,15 @@ text = text.`,
                     return undefined;
                 }
             }
+            else if (child.get() instanceof Expressions.MethodCallChain) {
+                if (source.getChildren().length !== 1) {
+                    return undefined;
+                }
+                context = this.builtinResultType(child, scope);
+                if (context === undefined) {
+                    return undefined;
+                }
+            }
             else if (child.get() instanceof Expressions.Constant) {
                 context = this.infer(context, constant_1.Constant.runSyntax(child));
             }
@@ -186,6 +206,32 @@ text = text.`,
         }
         return context;
     }
+    /** The result type of a call to a built-in function whose result type does not depend on its arguments,
+     *  undefined for anything else, e.g. abs( ) or xsdbool( ), or a method of the same name */
+    builtinResultType(chain, scope) {
+        var _a;
+        const children = chain.getChildren();
+        if (children.length !== 1 || !(children[0].get() instanceof Expressions.MethodCall)) {
+            return undefined;
+        }
+        const name = (_a = children[0].findDirectExpression(Expressions.MethodName)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
+        if (name === undefined) {
+            return undefined;
+        }
+        const isBuiltin = scope.getData().references.some(reference => reference.referenceType === _reference_1.ReferenceType.BuiltinMethodReference
+            && reference.position.getStart().equals(name.getStart()));
+        if (isBuiltin === false) {
+            return undefined;
+        }
+        const upper = name.getStr().toUpperCase();
+        if (RedundantConversion.stringResult.has(upper)) {
+            return basic_1.StringType.get();
+        }
+        else if (RedundantConversion.integerResult.has(upper)) {
+            return basic_1.IntegerType.get();
+        }
+        return undefined;
+    }
     fieldChainType(fieldChain, scope) {
         var _a;
         const operand = (_a = scope.getData().references.find(reference => reference.referenceType === _reference_1.ReferenceType.DataReadReference
@@ -250,4 +296,15 @@ text = text.`,
     }
 }
 exports.RedundantConversion = RedundantConversion;
+// built-in functions that always return a string, whatever their arguments
+RedundantConversion.stringResult = new Set([
+    "BOOLC", "CONCAT_LINES_OF", "CONDENSE", "ESCAPE", "FROM_MIXED", "INSERT", "REPEAT", "REPLACE",
+    "REVERSE", "SEGMENT", "SHIFT_LEFT", "SHIFT_RIGHT", "SUBSTRING", "SUBSTRING_AFTER", "SUBSTRING_BEFORE",
+    "SUBSTRING_FROM", "SUBSTRING_TO", "TO_LOWER", "TO_MIXED", "TO_UPPER", "TRANSLATE"
+]);
+// built-in functions that always return an i
+RedundantConversion.integerResult = new Set([
+    "CHARLEN", "COUNT", "COUNT_ANY_NOT_OF", "COUNT_ANY_OF", "DBMAXLEN", "DISTANCE", "FIND", "FIND_ANY_NOT_OF",
+    "FIND_ANY_OF", "FIND_END", "LINES", "NUMOFCHAR", "STRLEN", "XSTRLEN"
+]);
 //# sourceMappingURL=redundant_conversion.js.map

package/build/src/rules/xml_consistency.js

@@ -67,6 +67,7 @@ class XMLConsistency {
 * Naming for CLAS and INTF objects
 * QUAN fields in TABL objects have reference table and field values
 * Transparent TABL objects have delivery class and size category set
+* TABL fields with a built-in type carry the INTTYPE abapGit serializes for it, for the confirmed pairs
 * Lock parameter names in ENQU objects are max 16 characters
 * Texts and translations do not exceed maximum allowed length.`,
             tags: [_irule_1.RuleTag.Naming, _irule_1.RuleTag.Syntax],
@@ -326,15 +327,29 @@ class XMLConsistency {
     }
     runTable(obj, file) {
         var _a, _b, _c, _d;
-        var _e;
+        var _e, _f;
         const issues = [];
         for (const field of (_e = obj.getFields()) !== null && _e !== void 0 ? _e : []) {
             if (field.DATATYPE === "QUAN" && (!((_a = field.REFTABLE) === null || _a === void 0 ? void 0 : _a.trim()) || !((_b = field.REFFIELD) === null || _b === void 0 ? void 0 : _b.trim()))) {
                 const message = `QUAN field ${field.FIELDNAME} must have REFTABLE and REFFIELD set`;
                 issues.push(issue_1.Issue.atRow(file, 1, message, this.getMetadata().key, this.conf.severity));
             }
+            const expected = field.DATATYPE ? XMLConsistency.intTypes[field.DATATYPE] : undefined;
+            if (expected !== undefined && field.INTTYPE !== undefined && field.INTTYPE !== expected) {
+                const message = `Field ${field.FIELDNAME}: INTTYPE "${field.INTTYPE}" does not match DATATYPE ${field.DATATYPE}, ` +
+                    `abapGit serializes "${expected}"`;
+                issues.push(issue_1.Issue.atRow(file, 1, message, this.getMetadata().key, this.conf.severity));
+            }
         }
         if (obj.getTableCategory() === Objects.TableCategory.Transparent) {
+            // Confirmed reserved database field names, see issue #4331, DAY and HOUR reported by activation.
+            // TRESE also contains names such as TEXT and LENGTH which are allowed here.
+            const reservedFieldNames = ["ZONE", "HANDLER", "SECTION", "PARAMETER", "DAY", "HOUR"];
+            for (const field of (_f = obj.getFields()) !== null && _f !== void 0 ? _f : []) {
+                if (reservedFieldNames.includes(field.FIELDNAME.toUpperCase())) {
+                    issues.push(issue_1.Issue.atRow(file, 1, `Table field name "${field.FIELDNAME}" is reserved`, this.getMetadata().key, this.conf.severity));
+                }
+            }
             if (!((_c = obj.getDeliveryClass()) === null || _c === void 0 ? void 0 : _c.trim())) {
                 const message = `Transparent table must have delivery class(CONTFLAG in DD02V) set`;
                 issues.push(issue_1.Issue.atRow(file, 1, message, this.getMetadata().key, this.conf.transparentTableSeverity));
@@ -348,4 +363,13 @@ class XMLConsistency {
     }
 }
 exports.XMLConsistency = XMLConsistency;
+// INTTYPE that abapGit serializes for a built-in DATATYPE, confirmed by exported tables;
+// a different value activates, but shows as a diff on every pull
+XMLConsistency.intTypes = {
+    "CHAR": "C", "CLNT": "C", "CUKY": "C", "LANG": "C",
+    "DATS": "D", "TIMS": "T",
+    "INT4": "X", "RAW": "X",
+    "DEC": "P", "CURR": "P",
+    "STRG": "g", "SSTR": "g", "RSTR": "y",
+};
 //# sourceMappingURL=xml_consistency.js.map

package/build/src/utils/form_length_stats.js

@@ -76,7 +76,7 @@ class FormLengthStats {
         return res;
     }
     static findName(stat) {
-        let name = "";
+        let name;
         const nameExpr = stat.findFirstExpression(expressions_1.FormName);
         if (nameExpr) {
             name = nameExpr.getFirstToken().getStr();

package/build/src/utils/method_length_stats.js

@@ -82,7 +82,7 @@ class MethodLengthStats {
         return res;
     }
     static findName(stat) {
-        let name = "";
+        let name;
         const nameExpr = stat.findFirstExpression(expressions_1.MethodName);
         if (nameExpr) {
             name = nameExpr.getFirstToken().getStr();

package/package.json

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