@abaplint/core 2.120.78 → 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.78";
+        return "2.120.79";
     }
     getDDICReferences() {
         return this.ddicReferences;

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/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_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.78",
+    "version": "2.120.79",
     "description": "abaplint - Core API",
     "main": "build/src/index.js",
     "typings": "build/abaplint.d.ts",