@abaplint/core 2.120.1 → 2.120.3

package/build/abaplint.d.ts

@@ -3535,6 +3535,10 @@ export declare const enum IdentifierMeta {
     MethodExporting = "exporting",
     MethodChanging = "changing",
     MethodReturning = "returning",
+    FunctionModuleImporting = "function_module_importing",
+    FunctionModuleExporting = "function_module_exporting",
+    FunctionModuleChanging = "function_module_changing",
+    FunctionModuleTables = "function_module_tables",
     EventParameter = "event_parameter",
     FormParameter = "form_parameter",
     ReadOnly = "read_only",
@@ -3625,6 +3629,7 @@ declare interface IFunctionModuleParameter {
     type: string | undefined;
     optional: boolean;
     defaultValue: string | undefined;
+    passByValue: boolean;
 }
 
 declare interface IGlobalConfig {
@@ -4882,6 +4887,7 @@ declare class MethodParameters_2 implements IMethodParameters {
     private checkDuplicateNames;
     private workaroundRAP;
     private add;
+    private isPassByValue;
 }
 
 declare class MethodParamName extends Expression {

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

@@ -46,6 +46,7 @@ const basic_1 = require("../types/basic");
 const ddic_1 = require("../../ddic");
 const _object_oriented_1 = require("./_object_oriented");
 const _reference_1 = require("./_reference");
+const tokens_1 = require("../1_lexer/tokens");
 class Procedural {
     constructor(reg, scope) {
         this.scope = scope;
@@ -225,7 +226,8 @@ class Procedural {
                 continue;
             }
             else {
-                const type = new _typed_identifier_1.TypedIdentifier(nameToken, filename, found);
+                const token = new tokens_1.Identifier(nameToken.getStart(), param.name);
+                const type = new _typed_identifier_1.TypedIdentifier(token, filename, found, this.functionModuleParameterMeta(param));
                 if (ignoreIfAlreadyExists === true) {
                     const exists = this.scope.findVariable(param.name);
                     if (exists === undefined) {
@@ -239,6 +241,25 @@ class Procedural {
             }
         }
     }
+    functionModuleParameterMeta(param) {
+        const ret = [];
+        if (param.direction === types_1.FunctionModuleParameterDirection.importing) {
+            ret.push("function_module_importing" /* IdentifierMeta.FunctionModuleImporting */);
+        }
+        else if (param.direction === types_1.FunctionModuleParameterDirection.exporting) {
+            ret.push("function_module_exporting" /* IdentifierMeta.FunctionModuleExporting */);
+        }
+        else if (param.direction === types_1.FunctionModuleParameterDirection.changing) {
+            ret.push("function_module_changing" /* IdentifierMeta.FunctionModuleChanging */);
+        }
+        else if (param.direction === types_1.FunctionModuleParameterDirection.tables) {
+            ret.push("function_module_tables" /* IdentifierMeta.FunctionModuleTables */);
+        }
+        if (param.passByValue) {
+            ret.push("pass_by_value" /* IdentifierMeta.PassByValue */);
+        }
+        return ret;
+    }
 }
 exports.Procedural = Procedural;
 //# sourceMappingURL=_procedural.js.map

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

@@ -111,6 +111,7 @@ class Source {
                         else {
                             this.addIfInferred(node, input, foundType);
                         }
+                        this.traverseRemainingChildren(children, input);
                         return foundType ? foundType : bodyType;
                     }
                 case "SWITCH":

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

@@ -42,8 +42,10 @@ const inline_data_1 = require("../expressions/inline_data");
 const dynamic_1 = require("../expressions/dynamic");
 class CallTransformation {
     runSyntax(node, input) {
+        const resultParameters = node.findExpressionAfterToken("RESULT");
+        const resultSources = new Set((resultParameters === null || resultParameters === void 0 ? void 0 : resultParameters.findAllExpressions(Expressions.SimpleSource3)) || []);
         for (const s of node.findAllExpressions(Expressions.SimpleSource3)) {
-            source_1.Source.runSyntax(s, input);
+            source_1.Source.runSyntax(s, input, undefined, resultSources.has(s));
         }
         for (const d of node.findAllExpressions(Expressions.Dynamic)) {
             dynamic_1.Dynamic.runSyntax(d, input);

package/build/src/abap/types/function_module_definition.js

@@ -61,6 +61,7 @@ class FunctionModuleDefinition {
                     type: param.TYP || param.DBFIELD,
                     optional: param.OPTIONAL === "X",
                     defaultValue: param.DEFAULT,
+                    passByValue: param.REFERENCE !== "X",
                 });
             }
         }
@@ -75,6 +76,7 @@ class FunctionModuleDefinition {
                     type: param.TYP || param.DBFIELD,
                     optional: param.OPTIONAL === "X",
                     defaultValue: param.DEFAULT,
+                    passByValue: param.REFERENCE !== "X",
                 });
             }
         }
@@ -89,6 +91,7 @@ class FunctionModuleDefinition {
                     type: param.TYP || param.DBFIELD,
                     optional: true,
                     defaultValue: undefined,
+                    passByValue: param.REFERENCE !== "X",
                 });
             }
         }
@@ -104,6 +107,7 @@ class FunctionModuleDefinition {
                     type: param.DBSTRUCT || param.TYP,
                     optional: param.OPTIONAL === "X",
                     defaultValue: undefined,
+                    passByValue: false,
                 });
             }
         }

package/build/src/abap/types/method_parameters.js

@@ -267,14 +267,14 @@ class MethodParameters {
         }
     }
     add(target, source, input, meta, abstractMethod) {
-        var _a, _b;
+        var _a;
         for (const opt of source.findAllExpressions(Expressions.MethodParamOptional)) {
             const p = opt.findDirectExpression(Expressions.MethodParam);
             if (p === undefined) {
                 continue;
             }
             const extraMeta = [];
-            if (p.getFirstToken().getStr().toUpperCase() === "VALUE" && ((_a = p.getChildren()[1]) === null || _a === void 0 ? void 0 : _a.getFirstToken().getStr()) === "(") {
+            if (this.isPassByValue(p)) {
                 extraMeta.push("pass_by_value" /* IdentifierMeta.PassByValue */);
             }
             else if (meta.includes("importing" /* IdentifierMeta.MethodImporting */)) {
@@ -293,7 +293,7 @@ class MethodParameters {
             else if (opt.findFirstExpression(Expressions.Default)) {
                 const name = target[target.length - 1].getName().toUpperCase();
                 this.optional.push(name);
-                const val = (_b = opt.findFirstExpression(Expressions.Default)) === null || _b === void 0 ? void 0 : _b.getLastChild();
+                const val = (_a = opt.findFirstExpression(Expressions.Default)) === null || _a === void 0 ? void 0 : _a.getLastChild();
                 if (val && val instanceof nodes_1.ExpressionNode) {
                     this.defaults[name] = val;
                 }
@@ -304,9 +304,15 @@ class MethodParameters {
         }
         const params = source.findAllExpressions(Expressions.MethodParam);
         for (const param of params) {
-            target.push(method_param_1.MethodParam.runSyntax(param, input, meta));
+            const extraMeta = this.isPassByValue(param) ? ["pass_by_value" /* IdentifierMeta.PassByValue */] : [];
+            target.push(method_param_1.MethodParam.runSyntax(param, input, [...meta, ...extraMeta]));
         }
     }
+    isPassByValue(param) {
+        var _a;
+        return param.getFirstToken().getStr().toUpperCase() === "VALUE"
+            && ((_a = param.getChildren()[1]) === null || _a === void 0 ? void 0 : _a.getFirstToken().getStr()) === "(";
+    }
 }
 exports.MethodParameters = MethodParameters;
 //# sourceMappingURL=method_parameters.js.map

package/build/src/objects/_abap_object.js

@@ -56,10 +56,10 @@ class ABAPObject extends _abstract_object_1.AbstractObject {
         return undefined;
     }
     getMainABAPFile() {
-        // todo, uris, https://github.com/abaplint/abaplint/issues/673
         const search = this.getName().replace(/\//g, "#").toLowerCase() + "." + this.getType().toLowerCase() + ".abap";
+        const encodedSearch = search.replace(/#/g, "%23");
         for (const file of this.getABAPFiles()) {
-            if (file.getFilename().endsWith(search)) {
+            if (file.getFilename().endsWith(search) || file.getFilename().endsWith(encodedSearch)) {
                 return file;
             }
         }

package/build/src/registry.js

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

package/build/src/rules/clear_exporting_parameters.js

@@ -1,37 +1,4 @@
 "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.ClearExportingParameters = exports.ClearExportingParametersConf = void 0;
 const issue_1 = require("../issue");
@@ -40,12 +7,11 @@ const _irule_1 = require("./_irule");
 const syntax_1 = require("../abap/5_syntax/syntax");
 const _abap_object_1 = require("../objects/_abap_object");
 const _scope_type_1 = require("../abap/5_syntax/_scope_type");
+const _typed_identifier_1 = require("../abap/types/_typed_identifier");
 const objects_1 = require("../objects");
 const _reference_1 = require("../abap/5_syntax/_reference");
 const basic_1 = require("../abap/types/basic");
 const _statement_1 = require("../abap/2_statements/statements/_statement");
-const edit_helper_1 = require("../edit_helper");
-const Expressions = __importStar(require("../abap/2_statements/expressions"));
 class ClearExportingParametersConf extends _basic_rule_config_1.BasicRuleConfig {
     constructor() {
         super(...arguments);
@@ -78,7 +44,7 @@ Reading and writing the parameter in the same statement (e.g. "ev_result = ev_re
 as the source is evaluated before the parameter is assigned.
 Objects containing parser or syntax errors are not reported.
 
-Only class and interface method implementations are checked, function module parameters are currently not supported.`,
+Class and interface method implementations and function modules are checked.`,
             tags: [_irule_1.RuleTag.Styleguide],
             badExample: `CLASS lcl DEFINITION.
   PUBLIC SECTION.
@@ -134,19 +100,20 @@ ENDCLASS.`,
         return issues;
     }
     traverse(node, obj, issues) {
-        if (node.getIdentifier().stype === _scope_type_1.ScopeType.Method) {
-            this.checkMethod(node, obj, issues);
+        if (node.getIdentifier().stype === _scope_type_1.ScopeType.Method
+            || node.getIdentifier().stype === _scope_type_1.ScopeType.FunctionModule) {
+            this.checkProcedure(node, obj, issues);
         }
         for (const child of node.getChildren()) {
             this.traverse(child, obj, issues);
         }
     }
-    checkMethod(node, obj, issues) {
-        const parameters = this.findExportingByReference(node, obj);
+    checkProcedure(node, obj, issues) {
+        const references = this.collectReferences(node);
+        const parameters = this.findExportingByReference(node, references);
         if (parameters.length === 0) {
             return;
         }
-        const references = this.collectReferences(node);
         for (const parameter of parameters) {
             const issue = this.checkParameter(parameter, references, obj);
             if (issue !== undefined) {
@@ -154,52 +121,36 @@ ENDCLASS.`,
             }
         }
     }
-    findExportingByReference(node, obj) {
+    findExportingByReference(node, references) {
         var _a;
         const ret = [];
-        const vars = node.getData().vars;
-        for (const name in vars) {
-            const parameter = vars[name];
+        const candidates = new Set(Object.values(node.getData().vars));
+        for (const reference of references) {
+            if (reference.resolved instanceof _typed_identifier_1.TypedIdentifier) {
+                candidates.add(reference.resolved);
+            }
+        }
+        for (const parameter of candidates) {
             const meta = parameter.getMeta();
-            if (meta.includes("exporting" /* IdentifierMeta.MethodExporting */) === false
+            const exporting = meta.includes("exporting" /* IdentifierMeta.MethodExporting */)
+                || meta.includes("function_module_exporting" /* IdentifierMeta.FunctionModuleExporting */);
+            if (exporting === false
                 || meta.includes("pass_by_value" /* IdentifierMeta.PassByValue */) === true) {
                 continue;
             }
-            else if ((_a = this.conf.skipNames) === null || _a === void 0 ? void 0 : _a.some(s => s.toUpperCase() === name.toUpperCase())) {
+            else if ((_a = this.conf.skipNames) === null || _a === void 0 ? void 0 : _a.some(s => s.toUpperCase() === parameter.getName().toUpperCase())) {
                 continue;
             }
             const type = parameter.getType();
             if (type instanceof basic_1.VoidType || type instanceof basic_1.UnknownType) {
                 continue; // e.g. RAP magic parameters, or unresolved types
             }
-            else if (this.isPassByValue(parameter, obj) === true) {
-                continue; // VALUE(..) parameters are always initialized
-            }
             ret.push(parameter);
         }
         return ret;
     }
-    isPassByValue(parameter, obj) {
-        var _a;
-        // the PassByValue meta is not set for EXPORTING parameters, so determine it from the definition
-        const file = obj.getABAPFileByName(parameter.getFilename());
-        if (file === undefined) {
-            return false;
-        }
-        const statement = edit_helper_1.EditHelper.findStatement(parameter.getToken(), file);
-        if (statement === undefined) {
-            return false;
-        }
-        for (const param of statement.findAllExpressions(Expressions.MethodParam)) {
-            const nameToken = (_a = param.findFirstExpression(Expressions.MethodParamName)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
-            if (nameToken !== undefined && nameToken.getStart().equals(parameter.getStart())) {
-                return param.getFirstToken().getStr().toUpperCase() === "VALUE";
-            }
-        }
-        return false;
-    }
     collectReferences(node) {
-        // methods do not nest, so all descendant scopes (FOR, LET, ...) belong to this method
+        // procedures do not nest, so all descendant scopes (FOR, LET, ...) belong to this procedure
         const ret = [...node.getData().references];
         for (const child of node.getChildren()) {
             ret.push(...this.collectReferences(child));
@@ -210,7 +161,9 @@ ENDCLASS.`,
         let firstRead = undefined;
         let earliestWrite = undefined;
         for (const reference of references) {
-            if (reference.resolved === undefined || parameter.equals(reference.resolved) === false) {
+            if (reference.resolved === undefined
+                || parameter.equals(reference.resolved) === false
+                || parameter.getName().toUpperCase() !== reference.resolved.getName().toUpperCase()) {
                 continue;
             }
             const pos = reference.position.getStart();
@@ -220,8 +173,8 @@ ENDCLASS.`,
                 }
             }
             else if (reference.referenceType === _reference_1.ReferenceType.DataWriteReference) {
-                if (earliestWrite === undefined || pos.isBefore(earliestWrite)) {
-                    earliestWrite = pos;
+                if (earliestWrite === undefined || pos.isBefore(earliestWrite.position.getStart())) {
+                    earliestWrite = reference;
                 }
             }
         }
@@ -229,7 +182,7 @@ ENDCLASS.`,
             return undefined; // never read, no hazard
         }
         // the parameter is safe only if it is written in a statement strictly before the first read
-        const readStatement = this.statementStart(firstRead.position.getStart(), obj);
+        const readStatement = this.statementStart(firstRead, obj);
         const writeStatement = earliestWrite === undefined ? undefined : this.statementStart(earliestWrite, obj);
         if (writeStatement !== undefined && readStatement !== undefined && writeStatement.isBefore(readStatement)) {
             return undefined;
@@ -237,14 +190,14 @@ ENDCLASS.`,
         const message = `EXPORTING parameter "${parameter.getName().toLowerCase()}" read before it is cleared or assigned`;
         return issue_1.Issue.atIdentifier(firstRead.position, message, this.getMetadata().key, this.conf.severity);
     }
-    statementStart(pos, obj) {
-        for (const file of obj.getABAPFiles()) {
-            for (const statement of file.getStatements()) {
-                const start = statement.getStart();
-                const end = statement.getEnd();
-                if (pos.equals(start) || (pos.isAfter(start) && pos.isBefore(end))) {
-                    return start;
-                }
+    statementStart(reference, obj) {
+        const file = obj.getABAPFileByName(reference.position.getFilename());
+        for (const statement of (file === null || file === void 0 ? void 0 : file.getStatements()) || []) {
+            const pos = reference.position.getStart();
+            const start = statement.getStart();
+            const end = statement.getEnd();
+            if (pos.equals(start) || (pos.isAfter(start) && pos.isBefore(end))) {
+                return start;
             }
         }
         return undefined;

package/build/src/rules/slow_parameter_passing.js

@@ -69,7 +69,8 @@ ENDCLASS.`,
             }
             for (const v in vars) {
                 const id = vars[v];
-                if (id.getMeta().includes("pass_by_value" /* IdentifierMeta.PassByValue */) === false) {
+                if (id.getMeta().includes("importing" /* IdentifierMeta.MethodImporting */) === false
+                    || id.getMeta().includes("pass_by_value" /* IdentifierMeta.PassByValue */) === false) {
                     continue;
                 }
                 else if (this.reg.isFileDependency(id.getFilename()) === true) {

package/package.json

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