@abaplint/core 2.120.77 → 2.120.79

package/build/abaplint.d.ts

@@ -23,6 +23,7 @@ export declare abstract class ABAPObject extends AbstractObject {
     } | undefined;
     private textsTranslations;
     private rawXMLCache;
+    private parsing;
     syntaxResult: ISyntaxResult | undefined;
     abstract getSequencedFiles(): readonly ABAPFile[];
     abstract getDescription(): string | undefined;
@@ -7808,6 +7809,7 @@ declare type SyntaxInput = {
 
 export declare class SyntaxLogic {
     private currentFile;
+    private readonly includeStack;
     private issues;
     private deferred;
     private readonly object;

package/build/src/abap/2_statements/expand_macros.js

@@ -92,7 +92,7 @@ class ExpandMacros {
     listMacroNames() {
         return this.macros.listMacroNames();
     }
-    find(statements, file, clear = true) {
+    find(statements, file, clear = true, includePath = new Set()) {
         var _a, _b, _c;
         let nameToken = undefined;
         let start = undefined;
@@ -113,14 +113,16 @@ class ExpandMacros {
             else if (type instanceof Statements.Include) {
                 const includeName = (_b = statement.findDirectExpression(Expressions.IncludeName)) === null || _b === void 0 ? void 0 : _b.concatTokens();
                 // todo, this does not take function module includes into account
-                // todo, workaround for cyclic includes?
                 const prog = (_c = this.reg) === null || _c === void 0 ? void 0 : _c.getObject("PROG", includeName);
                 if (prog) {
                     prog.parse(this.release, this.globalMacros, this.reg, this.languageVersion);
                     const includeMainFile = prog.getMainABAPFile();
-                    if (includeMainFile) {
+                    // an include that is already on the current include path is not walked again
+                    if (includeMainFile && includePath.has(includeMainFile.getFilename()) === false) {
+                        includePath.add(includeMainFile.getFilename());
                         // slow, this copies everything,
-                        this.find([...includeMainFile.getStatements()], includeMainFile, false);
+                        this.find([...includeMainFile.getStatements()], includeMainFile, false, includePath);
+                        includePath.delete(includeMainFile.getFilename());
                     }
                 }
             }

package/build/src/abap/2_statements/statements/convert.js

@@ -16,11 +16,11 @@ class Convert {
         const dat = (0, combi_1.seq)("DATE", expressions_1.Source);
         const tim = (0, combi_1.seq)("TIME", expressions_1.Source);
         const stamp = (0, combi_1.seq)("INTO TIME STAMP", expressions_1.Target);
-        const intoutc = (0, combi_1.ver)(version_1.Release.v754, (0, combi_1.seq)("INTO UTCLONG", expressions_1.Target));
+        const intoutc = (0, combi_1.ver)(version_1.Release.v754, (0, combi_1.seq)("INTO UTCLONG", expressions_1.Target), { also: combi_1.AlsoIn.OpenABAP });
         const invert = (0, combi_1.seq)("INTO INVERTED-DATE", expressions_1.Target);
         const date = (0, combi_1.seq)((0, combi_1.per)(dat, tim), (0, combi_1.per)(daylightSource, stamp, zone, invert, intoutc));
         const inv = (0, combi_1.seq)("INVERTED-DATE", expressions_1.Source, "INTO DATE", expressions_1.Target);
-        const utclong = (0, combi_1.ver)(version_1.Release.v754, (0, combi_1.seq)("UTCLONG", expressions_1.Source, (0, combi_1.per)(zone, into, daylightSource)), { also: combi_1.AlsoIn.OpenABAP });
+        const utclong = (0, combi_1.ver)(version_1.Release.v754, (0, combi_1.seq)("UTCLONG", expressions_1.Source, (0, combi_1.per)(zone, into, daylightTarget)), { also: combi_1.AlsoIn.OpenABAP });
         return (0, combi_1.seq)("CONVERT", (0, combi_1.alt)(time, date, inv, utclong));
     }
 }

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

@@ -1194,9 +1194,9 @@ BuiltIn.methods = {
         },
         optional: {
             "days": basic_1.IntegerType.get(),
-            "hour": basic_1.IntegerType.get(),
-            "minutes": basic_1.IntegerType.get(),
-            "seconds": new basic_1.FloatType(),
+            "hours": basic_1.IntegerType.get(),
+            "minutes": new basic_1.Integer8Type(),
+            "seconds": new basic_1.DecFloat34Type(),
         },
         return: new basic_1.UTCLongType(),
         release: version_1.Release.v754,
@@ -1212,7 +1212,7 @@ BuiltIn.methods = {
             "high": new basic_1.UTCLongType(),
             "low": new basic_1.UTCLongType(),
         },
-        return: new basic_1.FloatType(),
+        return: new basic_1.DecFloat34Type(),
         release: version_1.Release.v754,
     },
     "XSDBOOL": {

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

@@ -52,7 +52,12 @@ class Procedural {
         this.scope = scope;
         this.reg = reg;
     }
-    addAllFormDefinitions(file, obj) {
+    addAllFormDefinitions(file, obj, visited = new Set()) {
+        // an include reached again through a cycle of INCLUDEs is not walked twice
+        if (visited.has(file.getFilename())) {
+            return;
+        }
+        visited.add(file.getFilename());
         const structure = file.getStructure();
         if (structure) {
             const input = {
@@ -73,12 +78,12 @@ class Procedural {
         for (const node of includes) {
             const found = this.findInclude(node, obj);
             if (found) {
-                this.addAllFormDefinitions(found, obj);
+                this.addAllFormDefinitions(found, obj, visited);
             }
         }
     }
     findInclude(node, obj) {
-        // assumption: no cyclic includes, includes not found are reported by rule "check_include"
+        // cyclic includes are cut by the callers, includes not found are reported by rule "check_include"
         // todo: how to make sure code is not duplicated here and in rule "check_include" / include graph?
         const expr = node.findFirstExpression(Expressions.IncludeName);
         if (expr === undefined) {

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

@@ -42,7 +42,11 @@ const _syntax_input_1 = require("../_syntax_input");
 // 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.
+// A substring of a date, time or numeric text field has type n; its bounds are not checked.
 function substringType(context, offset, length, node, input) {
+    if (context instanceof basic_1.DateType || context instanceof basic_1.TimeType || context instanceof basic_1.NumericType) {
+        return numericSubstringType(context, offset, length);
+    }
     if (!(context instanceof basic_1.CharacterType) && !(context instanceof basic_1.HexType)) {
         return context;
     }
@@ -65,6 +69,24 @@ function substringType(context, offset, length, node, input) {
     }
     return context;
 }
+function numericSubstringType(context, offset, length) {
+    const hasOffset = offset !== undefined && offset > 0;
+    const hasLength = length !== undefined && length > 0;
+    if (hasOffset === false && hasLength === false) {
+        return context;
+    }
+    let remaining = context instanceof basic_1.DateType ? 8 : context instanceof basic_1.TimeType ? 6 : context.getLength();
+    if (hasOffset) {
+        remaining = remaining - offset;
+    }
+    if (hasLength) {
+        remaining = Math.min(remaining, length);
+    }
+    if (remaining <= 0) {
+        return context;
+    }
+    return new basic_1.NumericType(remaining);
+}
 // 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) {

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

@@ -82,6 +82,16 @@ class Convert {
                 target_1.Target.runSyntax(stampTarget, input);
             }
         }
+        const utclongTarget = node.findExpressionAfterToken("UTCLONG");
+        if ((utclongTarget === null || utclongTarget === void 0 ? void 0 : utclongTarget.get()) instanceof Expressions.Target) {
+            const inline = utclongTarget === null || utclongTarget === void 0 ? void 0 : utclongTarget.findDirectExpression(Expressions.InlineData);
+            if (inline) {
+                inline_data_1.InlineData.runSyntax(inline, input, new basic_1.UTCLongType());
+            }
+            else {
+                target_1.Target.runSyntax(utclongTarget, input);
+            }
+        }
     }
 }
 exports.Convert = Convert;

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

@@ -337,6 +337,8 @@ if (Object.keys(map).length === 0) {
 // -----------------------------------
 class SyntaxLogic {
     constructor(reg, object) {
+        // files the traversal walked into through INCLUDEs, outermost first
+        this.includeStack = [];
         this.reg = reg;
         this.issues = [];
         this.deferred = [];
@@ -444,11 +446,20 @@ class SyntaxLogic {
             // walk into INCLUDEs
             if (isStatement && child.get() instanceof Statements.Include) {
                 const file = this.helpers.proc.findInclude(child, this.object);
-                if (file !== undefined && file.getStructure() !== undefined) {
+                // an INCLUDE that leads back to a file already being walked is not followed again
+                const cyclic = file !== undefined && (file.getFilename() === this.currentFile.getFilename()
+                    || this.includeStack.includes(file.getFilename()));
+                if (file !== undefined && file.getStructure() !== undefined && cyclic === false) {
                     const old = this.currentFile;
+                    this.includeStack.push(old.getFilename());
                     this.currentFile = file;
-                    this.traverse(file.getStructure());
-                    this.currentFile = old;
+                    try {
+                        this.traverse(file.getStructure());
+                    }
+                    finally {
+                        this.currentFile = old;
+                        this.includeStack.pop();
+                    }
                 }
             }
             if (isStructure || isStatement) {

package/build/src/abap/cross_include_macros.js

@@ -1,9 +1,44 @@
 "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.CrossIncludeMacros = void 0;
 const _abap_object_1 = require("../objects/_abap_object");
 const program_1 = require("../objects/program");
 const _statement_1 = require("./2_statements/statements/_statement");
+const statements_1 = require("./2_statements/statements");
+const Expressions = __importStar(require("./2_statements/expressions"));
 const expand_macros_1 = require("./2_statements/expand_macros");
 const include_graph_1 = require("../utils/include_graph");
 // Macros can be defined in one include and used in a sibling include, connected
@@ -16,6 +51,7 @@ class CrossIncludeMacros {
         this.reg = reg;
     }
     run() {
+        this.reparseCyclicPrograms();
         const candidates = this.findCandidates();
         if (candidates.length === 0) {
             return;
@@ -43,6 +79,45 @@ class CrossIncludeMacros {
         }
     }
     //////////////////////////////
+    // A program or include in an INCLUDE cycle can be parsed while the include defining its macros is still
+    // being parsed, depending on the order the files were added. Everything is parsed now, so parse it again.
+    reparseCyclicPrograms() {
+        const config = this.reg.getConfig();
+        for (const obj of this.reg.getObjects()) {
+            if (obj instanceof program_1.Program && this.hasUnknown(obj) && this.isInIncludeCycle(obj)) {
+                obj.setDirty();
+                obj.parse(config.getRelease(), config.getSyntaxSetttings().globalMacros, this.reg, config.getLanguageVersion());
+            }
+        }
+    }
+    hasUnknown(prog) {
+        return prog.getABAPFiles().some(f => f.getStatements().some(s => s.get() instanceof _statement_1.Unknown));
+    }
+    // the include graph does not link INCLUDEs of main programs, so follow the INCLUDEs from the program
+    isInIncludeCycle(prog) {
+        var _a;
+        const seen = new Set();
+        const stack = [prog];
+        while (stack.length > 0) {
+            for (const file of stack.pop().getABAPFiles()) {
+                for (const statement of file.getStatements()) {
+                    if (!(statement.get() instanceof statements_1.Include)) {
+                        continue;
+                    }
+                    const name = (_a = statement.findDirectExpression(Expressions.IncludeName)) === null || _a === void 0 ? void 0 : _a.concatTokens();
+                    const included = this.reg.getObject("PROG", name);
+                    if (included === prog) {
+                        return true;
+                    }
+                    else if (included instanceof program_1.Program && seen.has(included) === false) {
+                        seen.add(included);
+                        stack.push(included);
+                    }
+                }
+            }
+        }
+        return false;
+    }
     findCandidates() {
         const ret = [];
         for (const obj of this.reg.getObjects()) {

package/build/src/objects/_abap_object.js

@@ -11,6 +11,7 @@ class ABAPObject extends _abstract_object_1.AbstractObject {
     }
     constructor(name) {
         super(name);
+        this.parsing = false;
         this.parsed = [];
         this.texts = undefined;
         this.rawXMLCache = undefined;
@@ -19,11 +20,19 @@ class ABAPObject extends _abstract_object_1.AbstractObject {
         return !!x && x instanceof ABAPObject;
     }
     parse(release, globalMacros, reg, languageVersion = version_1.LanguageVersion.Normal) {
-        if (this.isDirty() === false) {
+        // an INCLUDE that leads back to this object while it is being parsed is not followed again
+        if (this.isDirty() === false || this.parsing === true) {
             return { updated: false, runtime: 0 };
         }
         const abapFiles = this.getFiles().filter(f => f.getFilename().endsWith(".abap"));
-        const result = new abap_parser_1.ABAPParser({ release, globalMacros, reg, languageVersion }).parse(abapFiles);
+        let result;
+        this.parsing = true;
+        try {
+            result = new abap_parser_1.ABAPParser({ release, globalMacros, reg, languageVersion }).parse(abapFiles);
+        }
+        finally {
+            this.parsing = false;
+        }
         this.parsed = result.output;
         this.old = result.issues;
         this.dirty = false;

package/build/src/registry.js

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

package/build/src/rules/index.js

@@ -105,6 +105,7 @@ __exportStar(require("./inline_data_old_versions"), exports);
 __exportStar(require("./inline_packed_computation"), exports);
 __exportStar(require("./intf_referencing_clas"), exports);
 __exportStar(require("./invalid_table_index"), exports);
+__exportStar(require("./is_assigned_in_loop"), exports);
 __exportStar(require("./keep_single_parameter_on_one_line"), exports);
 __exportStar(require("./keyword_case"), exports);
 __exportStar(require("./line_break_multiple_parameters"), exports);
@@ -170,6 +171,7 @@ __exportStar(require("./prefix_is_current_class"), exports);
 __exportStar(require("./range_row_values"), exports);
 __exportStar(require("./reduce_procedural_code"), exports);
 __exportStar(require("./reduce_string_templates"), exports);
+__exportStar(require("./redundant_cast"), exports);
 __exportStar(require("./redundant_conversion"), exports);
 __exportStar(require("./release_idoc"), exports);
 __exportStar(require("./remove_descriptions"), exports);

package/build/src/rules/is_assigned_in_loop.js

@@ -0,0 +1,242 @@
+"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.IsAssignedInLoop = exports.IsAssignedInLoopConf = void 0;
+const Statements = __importStar(require("../abap/2_statements/statements"));
+const Expressions = __importStar(require("../abap/2_statements/expressions"));
+const issue_1 = require("../issue");
+const _basic_rule_config_1 = require("./_basic_rule_config");
+const _abap_rule_1 = require("./_abap_rule");
+const _irule_1 = require("./_irule");
+const edit_helper_1 = require("../edit_helper");
+const severity_1 = require("../severity");
+class IsAssignedInLoopConf extends _basic_rule_config_1.BasicRuleConfig {
+    constructor() {
+        super(...arguments);
+        this.severity = severity_1.Severity.Warning;
+    }
+}
+exports.IsAssignedInLoopConf = IsAssignedInLoopConf;
+class IsAssignedInLoop extends _abap_rule_1.ABAPRule {
+    constructor() {
+        super(...arguments);
+        this.conf = new IsAssignedInLoopConf();
+    }
+    getMetadata() {
+        return {
+            key: "is_assigned_in_loop",
+            title: "IS ASSIGNED after READ TABLE or ASSIGN in a loop",
+            shortDescription: `Reports IS [NOT] ASSIGNED after a READ TABLE ... ASSIGNING or ASSIGN inside a loop, without UNASSIGN before it`,
+            extendedInformation: `A failed READ TABLE ... ASSIGNING or ASSIGN keeps the previous binding of the field symbol. Inside a
+loop, the field symbol still points to the row of an earlier iteration, so IS ASSIGNED is true
+although the statement failed, and the code goes on with the wrong row.
+
+Add UNASSIGN <fs> before the statement, inside the loop, or check sy-subrc after a READ TABLE.
+The quick fix inserts the UNASSIGN; it is not offered for a field symbol declared inline in
+the statement, or for a chained statement.
+
+Not reported: a check that also reads sy-subrc, an ASSIGN that cannot fail (a static source
+without dereference, table expression or dynamic part), and loops outside of the
+method, form or function module of the statement. See also subrc_after_assign.`,
+            tags: [_irule_1.RuleTag.SingleFile, _irule_1.RuleTag.Quickfix],
+            badExample: `LOOP AT lt_cells INTO ls_cell.
+  READ TABLE lt_styles ASSIGNING <style> WITH KEY id = ls_cell-style.
+  IF <style> IS ASSIGNED.
+    ls_cell-format = <style>-format.
+  ENDIF.
+ENDLOOP.`,
+            goodExample: `LOOP AT lt_cells INTO ls_cell.
+  UNASSIGN <style>.
+  READ TABLE lt_styles ASSIGNING <style> WITH KEY id = ls_cell-style.
+  IF <style> IS ASSIGNED.
+    ls_cell-format = <style>-format.
+  ENDIF.
+ENDLOOP.`,
+        };
+    }
+    getConfig() {
+        return this.conf;
+    }
+    setConfig(conf) {
+        this.conf = conf;
+    }
+    runParsed(file) {
+        const issues = [];
+        const statements = file.getStatements();
+        for (let i = 0; i < statements.length; i++) {
+            const statement = statements[i];
+            const name = this.boundByFailable(statement);
+            if (name === undefined) {
+                continue;
+            }
+            const fs = name.toUpperCase();
+            const loop = this.innermostLoop(i, statements);
+            if (loop === undefined || this.unassignedBefore(loop, i, statements, fs) === true) {
+                continue;
+            }
+            const check = this.nextCheck(i, statements, fs);
+            if (check === undefined) {
+                continue;
+            }
+            const read = statement.get() instanceof Statements.ReadTable;
+            const message = `${read ? "READ TABLE" : "ASSIGN"} in a loop keeps the previous binding of ${name} when it fails, `
+                + `UNASSIGN ${name} before it` + (read ? " or check sy-subrc" : "");
+            const fix = this.buildFix(file, statement, name);
+            issues.push(issue_1.Issue.atStatement(file, check, message, this.getMetadata().key, this.conf.severity, fix));
+        }
+        return issues;
+    }
+    ////////////////
+    /** the field symbol bound by a READ TABLE ... ASSIGNING or an ASSIGN that can fail */
+    boundByFailable(statement) {
+        var _a, _b, _c;
+        const s = statement.get();
+        if (s instanceof Statements.ReadTable) {
+            const target = (_a = statement.findDirectExpression(Expressions.ReadTableTarget)) === null || _a === void 0 ? void 0 : _a.findDirectExpression(Expressions.FSTarget);
+            return (_b = target === null || target === void 0 ? void 0 : target.findFirstExpression(Expressions.FieldSymbol)) === null || _b === void 0 ? void 0 : _b.concatTokens();
+        }
+        else if (s instanceof Statements.Assign) {
+            const source = statement.findDirectExpression(Expressions.AssignSource);
+            if (source === undefined) {
+                return undefined;
+            }
+            const first = source.getFirstToken().getStr().toUpperCase();
+            const failable = first === "COMPONENT"
+                || first === "TABLE"
+                || source.findFirstExpression(Expressions.Dynamic) !== undefined
+                || source.findFirstExpression(Expressions.Dereference) !== undefined
+                || source.findFirstExpression(Expressions.TableExpression) !== undefined
+                || statement.findDirectTokenByText("INCREMENT") !== undefined;
+            if (failable === false) {
+                return undefined;
+            }
+            const target = statement.findDirectExpression(Expressions.FSTarget);
+            return (_c = target === null || target === void 0 ? void 0 : target.findFirstExpression(Expressions.FieldSymbol)) === null || _c === void 0 ? void 0 : _c.concatTokens();
+        }
+        return undefined;
+    }
+    /** index of the innermost LOOP, DO, WHILE or SELECT loop around the statement, in the same block */
+    innermostLoop(index, statements) {
+        let depth = 0;
+        for (let i = index - 1; i >= 0 && this.startsBlock(statements[i]) === false; i--) {
+            if (this.endsLoop(statements[i])) {
+                depth++;
+            }
+            else if (this.startsLoop(statements[i])) {
+                if (depth === 0) {
+                    return i;
+                }
+                depth--;
+            }
+        }
+        return undefined;
+    }
+    unassignedBefore(loop, index, statements, fs) {
+        for (let i = loop + 1; i < index; i++) {
+            if (statements[i].get() instanceof Statements.Unassign && this.mentions(statements[i], fs)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** the first IS [NOT] ASSIGNED of the field symbol after the statement, before the end of the loop
+     * or another UNASSIGN or binding of it; a check that also reads sy-subrc is fine */
+    nextCheck(index, statements, fs) {
+        let depth = 0;
+        for (let i = index + 1; i < statements.length && this.startsBlock(statements[i]) === false; i++) {
+            const statement = statements[i];
+            if (this.startsLoop(statement)) {
+                depth++;
+            }
+            else if (this.endsLoop(statement)) {
+                if (depth === 0) {
+                    return undefined;
+                }
+                depth--;
+            }
+            const concat = statement.concatTokens().toUpperCase();
+            if (concat.includes(fs + " IS ASSIGNED") || concat.includes(fs + " IS NOT ASSIGNED")) {
+                return concat.includes("SY-SUBRC") ? undefined : statement;
+            }
+            if ((statement.get() instanceof Statements.Unassign && this.mentions(statement, fs))
+                || this.binds(statement, fs)) {
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    mentions(statement, fs) {
+        return statement.findAllExpressions(Expressions.FieldSymbol).some(e => e.concatTokens().toUpperCase() === fs);
+    }
+    binds(statement, fs) {
+        return statement.findAllExpressions(Expressions.FSTarget)
+            .some(t => { var _a; return ((_a = t.findFirstExpression(Expressions.FieldSymbol)) === null || _a === void 0 ? void 0 : _a.concatTokens().toUpperCase()) === fs; });
+    }
+    startsLoop(statement) {
+        const s = statement.get();
+        return s instanceof Statements.Loop
+            || s instanceof Statements.Do
+            || s instanceof Statements.While
+            || s instanceof Statements.SelectLoop;
+    }
+    endsLoop(statement) {
+        const s = statement.get();
+        return s instanceof Statements.EndLoop
+            || s instanceof Statements.EndDo
+            || s instanceof Statements.EndWhile
+            || s instanceof Statements.EndSelect;
+    }
+    startsBlock(statement) {
+        const s = statement.get();
+        return s instanceof Statements.MethodImplementation
+            || s instanceof Statements.Form
+            || s instanceof Statements.FunctionModule
+            || s instanceof Statements.Module
+            || s instanceof Statements.EndMethod
+            || s instanceof Statements.EndForm
+            || s instanceof Statements.EndFunction
+            || s instanceof Statements.EndModule;
+    }
+    /** UNASSIGN on a line of its own before the statement, with the same indentation */
+    buildFix(file, statement, name) {
+        if (statement.getColon() !== undefined || statement.findFirstExpression(Expressions.InlineFS) !== undefined) {
+            return undefined;
+        }
+        const start = statement.getStart();
+        return edit_helper_1.EditHelper.insertAt(file, start, `UNASSIGN ${name}.\n` + " ".repeat(start.getCol() - 1));
+    }
+}
+exports.IsAssignedInLoop = IsAssignedInLoop;
+//# sourceMappingURL=is_assigned_in_loop.js.map

package/build/src/rules/many_parentheses.js

@@ -144,7 +144,11 @@ ENDIF.
                 && lastChildren[1].getChildren().length === 1
                 && lastChildren[1].getFirstToken().getStr().startsWith("-") === false
                 && lastChildren[2].getFirstToken().getStr() === ")") {
-                const issue = issue_1.Issue.atToken(file, lastChildren[0].getFirstToken(), "Too many parentheses", this.getMetadata().key, this.conf.severity);
+                const fixText = lastChildren[1].concatTokens();
+                const start = lastChildren[0].getFirstToken().getStart();
+                const end = lastChildren[2].getLastToken().getEnd();
+                const fix = edit_helper_1.EditHelper.replaceRange(file, start, end, fixText);
+                const issue = issue_1.Issue.atToken(file, lastChildren[0].getFirstToken(), "Too many parentheses", this.getMetadata().key, this.conf.severity, fix);
                 issues.push(issue);
             }
         }

package/build/src/rules/max_one_method_parameter_per_line.js

@@ -40,6 +40,7 @@ const issue_1 = require("../issue");
 const _abap_rule_1 = require("./_abap_rule");
 const _basic_rule_config_1 = require("./_basic_rule_config");
 const _irule_1 = require("./_irule");
+const edit_helper_1 = require("../edit_helper");
 class MaxOneMethodParameterPerLineConf extends _basic_rule_config_1.BasicRuleConfig {
 }
 exports.MaxOneMethodParameterPerLineConf = MaxOneMethodParameterPerLineConf;
@@ -53,7 +54,7 @@ class MaxOneMethodParameterPerLine extends _abap_rule_1.ABAPRule {
             key: "max_one_method_parameter_per_line",
             title: "Max one method parameter definition per line",
             shortDescription: `Keep max one method parameter description per line`,
-            tags: [_irule_1.RuleTag.SingleFile, _irule_1.RuleTag.Whitespace],
+            tags: [_irule_1.RuleTag.SingleFile, _irule_1.RuleTag.Whitespace, _irule_1.RuleTag.Quickfix],
             badExample: `
 METHODS apps_scope_token
   IMPORTING
@@ -82,7 +83,8 @@ METHODS apps_scope_token
                     continue;
                 }
                 if (prev.getFirstToken().getStart().getRow() === p.getFirstToken().getStart().getRow()) {
-                    const issue = issue_1.Issue.atToken(file, prev.getFirstToken(), this.getMetadata().title, this.getMetadata().key, this.conf.severity);
+                    const fix = this.buildFix(file, statement, p);
+                    const issue = issue_1.Issue.atToken(file, prev.getFirstToken(), this.getMetadata().title, this.getMetadata().key, this.conf.severity, fix);
                     issues.push(issue);
                 }
                 prev = p;
@@ -90,6 +92,30 @@ METHODS apps_scope_token
         }
         return issues;
     }
+    /** moves the parameter, or its preceding section keyword, to a new line */
+    buildFix(file, statement, param) {
+        const tokens = statement.getTokens();
+        const index = tokens.indexOf(param.getFirstToken());
+        if (index < 1) {
+            return undefined;
+        }
+        let target = tokens[index];
+        let indent = statement.findFirstExpression(Expressions.MethodParam).getFirstToken().getStart().getCol();
+        const before = tokens[index - 1];
+        if (MaxOneMethodParameterPerLine.SECTIONS.includes(before.getStr().toUpperCase())) {
+            if (index < 2) {
+                return undefined;
+            }
+            target = before;
+            indent = tokens.find(t => MaxOneMethodParameterPerLine.SECTIONS.includes(t.getStr().toUpperCase())).getStart().getCol();
+        }
+        const previous = tokens[tokens.indexOf(target) - 1];
+        if (previous.getEnd().getRow() !== target.getStart().getRow()) {
+            return undefined;
+        }
+        return edit_helper_1.EditHelper.replaceRange(file, previous.getEnd(), target.getStart(), "\n" + " ".repeat(indent - 1));
+    }
 }
 exports.MaxOneMethodParameterPerLine = MaxOneMethodParameterPerLine;
+MaxOneMethodParameterPerLine.SECTIONS = ["IMPORTING", "EXPORTING", "CHANGING", "RETURNING"];
 //# sourceMappingURL=max_one_method_parameter_per_line.js.map

package/build/src/rules/newline_between_methods.js

@@ -40,6 +40,8 @@ const _abap_rule_1 = require("./_abap_rule");
 const sequential_blank_1 = require("./sequential_blank");
 const Statements = __importStar(require("../abap/2_statements/statements"));
 const _irule_1 = require("./_irule");
+const edit_helper_1 = require("../edit_helper");
+const position_1 = require("../position");
 var NewlineLogic;
 (function (NewlineLogic) {
     NewlineLogic["Exact"] = "exact";
@@ -69,7 +71,7 @@ class NewlineBetweenMethods extends _abap_rule_1.ABAPRule {
             key: "newline_between_methods",
             title: "New line between methods",
             shortDescription: `Checks for newlines between method implementations.`,
-            tags: [_irule_1.RuleTag.Whitespace, _irule_1.RuleTag.SingleFile],
+            tags: [_irule_1.RuleTag.Whitespace, _irule_1.RuleTag.Quickfix, _irule_1.RuleTag.SingleFile],
         };
     }
     getMessage() {
@@ -98,18 +100,35 @@ class NewlineBetweenMethods extends _abap_rule_1.ABAPRule {
                 continue;
             }
             let counter = 0;
-            while (sequential_blank_1.SequentialBlank.isBlankOrWhitespace(rows[nextRow]) && (counter <= this.conf.count + 1)) {
+            while (sequential_blank_1.SequentialBlank.isBlankOrWhitespace(rows[nextRow])) {
                 counter++;
                 nextRow++;
             }
             if ((counter !== this.conf.count && this.conf.logic === NewlineLogic.Exact)
                 || (counter >= this.conf.count && this.conf.logic === NewlineLogic.Less)
                 || counter === 0) {
-                issues.push(issue_1.Issue.atStatement(file, statement, this.getMessage(), this.getMetadata().key, this.conf.severity));
+                const fix = this.buildFix(file, rows, statement.getStart().getRow(), counter);
+                issues.push(issue_1.Issue.atStatement(file, statement, this.getMessage(), this.getMetadata().key, this.conf.severity, fix));
             }
         }
         return issues;
     }
+    buildFix(file, rows, row, blanks) {
+        let target = this.conf.count;
+        if (this.conf.logic === NewlineLogic.Less) {
+            target = blanks === 0 ? 1 : this.conf.count - 1;
+        }
+        if (blanks < target) {
+            const end = new position_1.Position(row, rows[row - 1].length + 1);
+            return edit_helper_1.EditHelper.insertAt(file, end, "\n".repeat(target - blanks));
+        }
+        else if (blanks > target) {
+            const start = new position_1.Position(row + target, rows[row + target - 1].length + 1);
+            const end = new position_1.Position(row + blanks, rows[row + blanks - 1].length + 1);
+            return edit_helper_1.EditHelper.deleteRange(file, start, end);
+        }
+        return undefined;
+    }
     isConfigurationValid() {
         if (this.conf.count < 1 || (this.conf.count === 1 && this.conf.logic === NewlineLogic.Less)) {
             return false;

package/build/src/rules/prefer_pragmas.js

@@ -39,7 +39,7 @@ class PreferPragmas extends _abap_rule_1.ABAPRule {
         return {
             key: "prefer_pragmas",
             title: "prefer pragmas over pseudo comments ",
-            shortDescription: `prefer pragmas over pseudo comments `,
+            shortDescription: `prefer pragmas over pseudo comments`,
             extendedInformation: `https://github.com/SAP/styleguides/blob/main/clean-abap/CleanABAP.md#prefer-pragmas-to-pseudo-comments`,
             tags: [_irule_1.RuleTag.SingleFile, _irule_1.RuleTag.Styleguide],
             badExample: `DATA foo1 TYPE i. "#EC NEEDED`,

package/build/src/rules/redundant_cast.js

@@ -0,0 +1,157 @@
+"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.RedundantCast = exports.RedundantCastConf = void 0;
+const Expressions = __importStar(require("../abap/2_statements/expressions"));
+const _reference_1 = require("../abap/5_syntax/_reference");
+const syntax_1 = require("../abap/5_syntax/syntax");
+const nodes_1 = require("../abap/nodes");
+const _typed_identifier_1 = require("../abap/types/_typed_identifier");
+const basic_1 = require("../abap/types/basic");
+const issue_1 = require("../issue");
+const _abap_object_1 = require("../objects/_abap_object");
+const _basic_rule_config_1 = require("./_basic_rule_config");
+const _irule_1 = require("./_irule");
+const edit_helper_1 = require("../edit_helper");
+const version_1 = require("../version");
+class RedundantCastConf extends _basic_rule_config_1.BasicRuleConfig {
+}
+exports.RedundantCastConf = RedundantCastConf;
+class RedundantCast {
+    constructor() {
+        this.conf = new RedundantCastConf();
+    }
+    getMetadata() {
+        return {
+            key: "redundant_cast",
+            title: "Redundant Cast",
+            shortDescription: `Find redundant CAST expressions`,
+            extendedInformation: `Reports CAST expressions whose operand is already a reference to the cast's target class or interface.`,
+            tags: [_irule_1.RuleTag.Quickfix],
+            badExample: `DATA ref TYPE REF TO lcl.
+DATA(copy) = CAST lcl( ref ).`,
+            goodExample: `DATA ref TYPE REF TO lcl.
+DATA(copy) = ref.`,
+        };
+    }
+    getConfig() {
+        return this.conf;
+    }
+    setConfig(conf) {
+        this.conf = conf;
+    }
+    initialize(reg) {
+        this.reg = reg;
+        return this;
+    }
+    run(obj) {
+        var _a;
+        if (!(0, version_1.releaseAtLeast)(this.reg.getConfig().getRelease(), version_1.Release.v740sp02)
+            && !this.reg.getConfig().isOpenABAP()) {
+            return [];
+        }
+        if (!(obj instanceof _abap_object_1.ABAPObject)) {
+            return [];
+        }
+        const syntax = new syntax_1.SyntaxLogic(this.reg, obj).run();
+        if (syntax.issues.length > 0) {
+            return [];
+        }
+        const issues = [];
+        for (const file of obj.getABAPFiles()) {
+            const structure = file.getStructure();
+            if (structure === undefined) {
+                continue;
+            }
+            for (const cast of structure.findAllExpressionsRecursive(Expressions.Cast)) {
+                const typeExpression = cast.findDirectExpression(Expressions.TypeNameOrInfer);
+                const source = cast.findDirectExpression(Expressions.Source);
+                if (typeExpression === undefined
+                    || source === undefined
+                    || cast.findDirectExpression(Expressions.Let) !== undefined) {
+                    continue;
+                }
+                const scope = syntax.spaghetti.lookupPosition(cast.getFirstToken().getStart(), file.getFilename());
+                if (scope === undefined) {
+                    continue;
+                }
+                const target = (_a = scope.getData().references.find(reference => reference.referenceType === _reference_1.ReferenceType.InferredType
+                    && reference.position.getStart().equals(typeExpression.getFirstToken().getStart()))) === null || _a === void 0 ? void 0 : _a.resolved;
+                if (!(target instanceof _typed_identifier_1.TypedIdentifier)) {
+                    continue;
+                }
+                const operandType = this.sourceType(source, scope);
+                if (operandType === undefined || this.sameType(target.getType(), operandType) === false) {
+                    continue;
+                }
+                const closingParen = cast.getDirectTokens().find(token => token.getStr() === ")" && token.getStart().isAfter(source.getLastToken().getStart()));
+                if (closingParen === undefined) {
+                    continue;
+                }
+                const fix = edit_helper_1.EditHelper.replaceRange(file, cast.getFirstToken().getStart(), closingParen.getEnd(), source.concatTokens());
+                issues.push(issue_1.Issue.atRange(file, cast.getFirstToken().getStart(), closingParen.getEnd(), "Redundant CAST expression", this.getMetadata().key, this.conf.severity, fix));
+            }
+        }
+        return issues;
+    }
+    /** The type of a plain variable or attribute, undefined for anything more complex */
+    sourceType(source, scope) {
+        var _a;
+        const children = source.getChildren();
+        if (children.length !== 1 || !(children[0].get() instanceof Expressions.FieldChain)) {
+            return undefined;
+        }
+        const fieldChain = children[0];
+        const last = fieldChain.getLastChild();
+        if (!(last instanceof nodes_1.ExpressionNode)
+            || !(last.get() instanceof Expressions.SourceField || last.get() instanceof Expressions.AttributeName)) {
+            return undefined;
+        }
+        const operand = (_a = scope.getData().references.find(reference => reference.referenceType === _reference_1.ReferenceType.DataReadReference
+            && reference.position.getStart().equals(last.getFirstToken().getStart()))) === null || _a === void 0 ? void 0 : _a.resolved;
+        if (!(operand instanceof _typed_identifier_1.TypedIdentifier)) {
+            return undefined;
+        }
+        return operand.getType();
+    }
+    sameType(first, second) {
+        if (!(first instanceof basic_1.ObjectReferenceType) || !(second instanceof basic_1.ObjectReferenceType)) {
+            return false;
+        }
+        return first.getIdentifierName().toUpperCase() === second.getIdentifierName().toUpperCase();
+    }
+}
+exports.RedundantCast = RedundantCast;
+//# sourceMappingURL=redundant_cast.js.map

package/build/src/rules/redundant_conversion.js

@@ -196,9 +196,9 @@ text = text.`,
                 context = this.infer(context, this.sourceType(child, scope));
             }
             else if (child.get() instanceof Expressions.ArithOperator) {
-                if (child.concatTokens() === "**") {
-                    context = new basic_1.FloatType();
-                }
+                // the CONV sets the calculation type of arithmetic expressions, only redundant
+                // if the assignment target has the same type, see arithmeticUsesSameTargetType
+                return undefined;
             }
             else {
                 return undefined;

package/build/src/utils/include_graph.js

@@ -9,7 +9,6 @@ const position_1 = require("../position");
 const issue_1 = require("../issue");
 const _abap_object_1 = require("../objects/_abap_object");
 const severity_1 = require("../severity");
-// todo, check for cycles/circular dependencies, method findTop
 // todo, add configurable error for multiple use includes
 const FMXXINCLUDE = /^(\/\w+\/)?L.+XX$/;
 function getABAPObjects(reg) {
@@ -45,11 +44,33 @@ class Graph {
         }
         this.edges[from.filename].push(toFilename);
     }
-    findTop(filename) {
+    // true if "to" is reachable from "from" via the edges, "from" itself counts
+    isReachable(from, to) {
+        const seen = new Set();
+        const stack = [from];
+        while (stack.length > 0) {
+            const current = stack.pop();
+            if (current === to) {
+                return true;
+            }
+            if (seen.has(current) === false) {
+                seen.add(current);
+                stack.push(...this.edges[current] || []);
+            }
+        }
+        return false;
+    }
+    findTop(filename, path = new Set()) {
         const ret = [];
+        path.add(filename);
         for (const to of this.edges[filename] || []) {
-            ret.push(...this.findTop(to));
+            // an INCLUDE cycle, the file is already on the current path
+            if (path.has(to)) {
+                continue;
+            }
+            ret.push(...this.findTop(to, path));
         }
+        path.delete(filename);
         if (ret.length === 0) {
             const found = this.findVertexByFilename(filename);
             if (found !== undefined) {
@@ -104,6 +125,7 @@ class IncludeGraph {
     ///////////////////////////////
     build() {
         this.addVertices();
+        const included = [];
         for (const o of getABAPObjects(this.reg)) {
             for (const f of o.getABAPFiles()) {
                 if (f.getFilename().includes(".prog.screen_") || f.getFilename().includes(".fugr.screen_")) {
@@ -134,11 +156,19 @@ class IncludeGraph {
                         }
                         else {
                             this.graph.addEdge(found, f.getFilename());
+                            included.push({ file: f, statement: s, vertex: found, name });
                         }
                     }
                 }
             }
         }
+        // cycles are not followed, but ABAP rejects them, so report them
+        for (const i of included) {
+            if (this.graph.isReachable(i.file.getFilename(), i.vertex.filename)) {
+                const issue = issue_1.Issue.atStatement(i.file, i.statement, "Cyclic INCLUDE, " + i.name, new check_include_1.CheckInclude().getMetadata().key, this.severity);
+                this.issues.push(issue);
+            }
+        }
     }
     addVertices() {
         for (const o of getABAPObjects(this.reg)) {

package/package.json

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