@abaplint/core 2.111.1 → 2.112.1

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

@@ -7,7 +7,7 @@ const events_1 = require("../2_statements/statements/events");
 const expressions_1 = require("../2_statements/expressions");
 const method_param_1 = require("../5_syntax/expressions/method_param");
 class EventDefinition extends _identifier_1.Identifier {
-    constructor(node, _visibility, filename, scope) {
+    constructor(node, _visibility, input) {
         if (!(node.get() instanceof events_1.Events)) {
             throw new Error("MethodDefinition, expected MethodDef as part of input node");
         }
@@ -15,17 +15,17 @@ class EventDefinition extends _identifier_1.Identifier {
         if (found === undefined) {
             throw new Error("MethodDefinition, expected MethodDef as part of input node");
         }
-        super(found.getFirstToken(), filename);
+        super(found.getFirstToken(), input.filename);
         this.parameters = [];
-        this.parse(node, filename, scope);
+        this.parse(node, input);
     }
     getParameters() {
         return this.parameters;
     }
     ///////////////
-    parse(node, filename, scope) {
+    parse(node, input) {
         for (const e of node.findAllExpressions(expressions_1.MethodParam)) {
-            this.parameters.push(new method_param_1.MethodParam().runSyntax(e, scope, filename, []));
+            this.parameters.push(new method_param_1.MethodParam().runSyntax(e, input, []));
         }
     }
 }

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

@@ -10,18 +10,18 @@ const _typed_identifier_1 = require("./_typed_identifier");
 const form_param_1 = require("../5_syntax/expressions/form_param");
 const basic_1 = require("./basic");
 class FormDefinition extends _identifier_1.Identifier {
-    constructor(node, filename, scope) {
+    constructor(node, input) {
         const st = node instanceof nodes_1.StructureNode ? node.findFirstStatement(Statements.Form) : node;
         // FORMs can contain a dash in the name
         const formName = st.findFirstExpression(Expressions.FormName);
         const pos = formName.getFirstToken().getStart();
         const name = formName.concatTokens();
         const nameToken = new Tokens.Identifier(pos, name);
-        super(nameToken, filename);
+        super(nameToken, input.filename);
         this.node = st;
-        this.tableParameters = this.findTables(scope, filename);
-        this.usingParameters = this.findType(Expressions.FormUsing, scope);
-        this.changingParameters = this.findType(Expressions.FormChanging, scope);
+        this.tableParameters = this.findTables(input);
+        this.usingParameters = this.findType(Expressions.FormUsing, input);
+        this.changingParameters = this.findType(Expressions.FormChanging, input);
     }
     getTablesParameters() {
         return this.tableParameters;
@@ -33,7 +33,7 @@ class FormDefinition extends _identifier_1.Identifier {
         return this.changingParameters;
     }
     ///////////////
-    findTables(scope, filename) {
+    findTables(input) {
         const ret = [];
         const tables = this.node.findFirstExpression(Expressions.FormTables);
         if (tables === undefined) {
@@ -42,10 +42,10 @@ class FormDefinition extends _identifier_1.Identifier {
         for (const param of tables.findAllExpressions(Expressions.FormParam)) {
             if (param.getChildren().length === 1) {
                 // untyped TABLES parameter
-                ret.push(new _typed_identifier_1.TypedIdentifier(param.getFirstToken(), filename, new basic_1.VoidType("FORM:UNTYPED"), ["form_parameter" /* IdentifierMeta.FormParameter */]));
+                ret.push(new _typed_identifier_1.TypedIdentifier(param.getFirstToken(), input.filename, new basic_1.VoidType("FORM:UNTYPED"), ["form_parameter" /* IdentifierMeta.FormParameter */]));
             }
             else {
-                const p = new form_param_1.FormParam().runSyntax(param, scope, this.filename);
+                const p = new form_param_1.FormParam().runSyntax(param, input);
                 let type = p.getType();
                 const isStructure = param.findDirectTokenByText("STRUCTURE") !== undefined;
                 if (isStructure) {
@@ -57,22 +57,22 @@ class FormDefinition extends _identifier_1.Identifier {
                 else if (!(type instanceof basic_1.UnknownType) && !(type instanceof basic_1.VoidType)) {
                     type = new basic_1.UnknownType("FORM TABLES type must be table type");
                 }
-                ret.push(new _typed_identifier_1.TypedIdentifier(p.getToken(), filename, type, ["form_parameter" /* IdentifierMeta.FormParameter */]));
+                ret.push(new _typed_identifier_1.TypedIdentifier(p.getToken(), input.filename, type, ["form_parameter" /* IdentifierMeta.FormParameter */]));
             }
         }
         return ret;
     }
-    findType(type, scope) {
+    findType(type, input) {
         const found = this.node.findFirstExpression(type);
         if (found === undefined) {
             return [];
         }
-        return this.findParams(found, scope);
+        return this.findParams(found, input);
     }
-    findParams(node, scope) {
+    findParams(node, input) {
         const res = [];
         for (const param of node.findAllExpressions(Expressions.FormParam)) {
-            const p = new form_param_1.FormParam().runSyntax(param, scope, this.filename);
+            const p = new form_param_1.FormParam().runSyntax(param, input);
             res.push(p);
         }
         return res;

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

@@ -16,19 +16,19 @@ const class_constant_1 = require("./class_constant");
 const _typed_identifier_1 = require("./_typed_identifier");
 const tokens_1 = require("../1_lexer/tokens");
 class InterfaceDefinition extends _identifier_1.Identifier {
-    constructor(node, filename, scope) {
+    constructor(node, input) {
         if (!(node.get() instanceof Structures.Interface)) {
             throw new Error("InterfaceDefinition, unexpected node type");
         }
         const name = node.findFirstStatement(Statements.Interface).findFirstExpression(Expressions.InterfaceName).getFirstToken();
-        super(name, filename);
-        scope.addInterfaceDefinition(this);
+        super(name, input.filename);
+        input.scope.addInterfaceDefinition(this);
         this.events = [];
         this.implementing = [];
         this.globalValue = node.findFirstExpression(Expressions.ClassGlobal) !== undefined;
-        scope.push(_scope_type_1.ScopeType.Interface, name.getStr(), node.getFirstToken().getStart(), filename);
-        this.parse(scope, filename, node);
-        scope.pop(node.getLastToken().getEnd());
+        input.scope.push(_scope_type_1.ScopeType.Interface, name.getStr(), node.getFirstToken().getStart(), input.filename);
+        this.parse(input, node);
+        input.scope.pop(node.getLastToken().getEnd());
     }
     getSuperClass() {
         return undefined;
@@ -58,57 +58,58 @@ class InterfaceDefinition extends _identifier_1.Identifier {
         return this.methodDefinitions;
     }
     /////////////////
-    parse(scope, filename, node) {
+    parse(input, node) {
         var _a;
         // todo, proper sequencing, the statements should be processed line by line
-        this.attributes = new class_attributes_1.Attributes(node, this.filename, scope);
+        this.attributes = new class_attributes_1.Attributes(node, input);
         this.typeDefinitions = this.attributes.getTypes();
-        this.aliases = new aliases_1.Aliases(node, this.filename, scope);
+        this.aliases = new aliases_1.Aliases(node, this.filename, input.scope);
         // todo, cleanup aliases, vs "object_oriented.ts" vs "class_implementation.ts"
+        // this adds the aliased types to scope?
         for (const a of this.aliases.getAll()) {
             const [objName, fieldName] = a.getComponent().split("~");
-            const idef = scope.findInterfaceDefinition(objName);
+            const idef = input.scope.findInterfaceDefinition(objName);
             if (idef) {
                 const foundType = idef.getTypeDefinitions().getByName(fieldName);
                 if (foundType) {
-                    scope.addTypeNamed(a.getName(), foundType);
+                    input.scope.addTypeNamed(a.getName(), foundType);
                 }
                 else {
                     const foundField = idef.getAttributes().findByName(fieldName);
                     if (foundField && foundField instanceof class_constant_1.ClassConstant) {
                         const token = new tokens_1.Identifier(a.getStart(), a.getName());
-                        const id = new _typed_identifier_1.TypedIdentifier(token, filename, foundField.getType());
+                        const id = new _typed_identifier_1.TypedIdentifier(token, input.filename, foundField.getType());
                         const constant = new class_constant_1.ClassConstant(id, visibility_1.Visibility.Public, foundField.getValue());
-                        scope.addIdentifier(constant);
+                        input.scope.addIdentifier(constant);
                     }
                 }
             }
         }
-        this.methodDefinitions = new method_definitions_1.MethodDefinitions(node, this.filename, scope);
-        if (this.methodDefinitions.getByName("CONSTRUCTOR") !== undefined) {
-            throw new Error("Interfaces cannot have constructor methods");
-        }
         const events = node.findAllStatements(Statements.Events);
         for (const e of events) {
-            this.events.push(new event_definition_1.EventDefinition(e, visibility_1.Visibility.Public, this.filename, scope));
+            this.events.push(new event_definition_1.EventDefinition(e, visibility_1.Visibility.Public, input));
         }
         for (const i of node.findAllStatements(Statements.InterfaceDef)) {
             const token = (_a = i.findDirectExpression(Expressions.InterfaceName)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
             const name = token === null || token === void 0 ? void 0 : token.getStr();
             if (name) {
                 this.implementing.push({ name, partial: false });
-                const idef = scope.findInterfaceDefinition(name);
+                const idef = input.scope.findInterfaceDefinition(name);
                 if (idef) {
-                    scope.addReference(token, idef, _reference_1.ReferenceType.ObjectOrientedReference, this.filename, { ooName: name.toUpperCase(), ooType: "INTF" });
+                    input.scope.addReference(token, idef, _reference_1.ReferenceType.ObjectOrientedReference, this.filename, { ooName: name.toUpperCase(), ooType: "INTF" });
                 }
-                else if (scope.getDDIC().inErrorNamespace(name) === false) {
-                    scope.addReference(token, undefined, _reference_1.ReferenceType.ObjectOrientedVoidReference, this.filename);
+                else if (input.scope.getDDIC().inErrorNamespace(name) === false) {
+                    input.scope.addReference(token, undefined, _reference_1.ReferenceType.ObjectOrientedVoidReference, this.filename);
                 }
                 else {
                     throw new Error("Interface " + name + " unknown");
                 }
             }
         }
+        this.methodDefinitions = new method_definitions_1.MethodDefinitions(node, input);
+        if (this.methodDefinitions.getByName("CONSTRUCTOR") !== undefined) {
+            throw new Error("Interfaces cannot have constructor methods");
+        }
     }
 }
 exports.InterfaceDefinition = InterfaceDefinition;

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

@@ -8,7 +8,7 @@ const _identifier_1 = require("../4_file_information/_identifier");
 const _reference_1 = require("../5_syntax/_reference");
 class MethodDefinition extends _identifier_1.Identifier {
     // todo: final flag
-    constructor(node, visibility, filename, scope) {
+    constructor(node, visibility, input) {
         var _a, _b;
         if (!(node.get() instanceof statements_1.MethodDef)) {
             throw new Error("MethodDefinition, expected MethodDef as part of input node");
@@ -17,15 +17,15 @@ class MethodDefinition extends _identifier_1.Identifier {
         if (found === undefined) {
             throw new Error("MethodDefinition, expected MethodDef as part of input node");
         }
-        super(found.getFirstToken(), filename);
+        super(found.getFirstToken(), input.filename);
         this.redefinition = false;
         if (node.findDirectExpression(Expressions.Redefinition)) {
             this.redefinition = true;
             const name = found.getFirstToken().getStr();
             if (name.includes("~")) {
-                const idef = scope.findInterfaceDefinition(name.split("~")[0]);
+                const idef = input.scope.findInterfaceDefinition(name.split("~")[0]);
                 if (idef) {
-                    scope.addReference(found.getFirstToken(), idef, _reference_1.ReferenceType.ObjectOrientedReference, filename);
+                    input.scope.addReference(found.getFirstToken(), idef, _reference_1.ReferenceType.ObjectOrientedReference, input.filename);
                 }
             }
         }
@@ -47,15 +47,15 @@ class MethodDefinition extends _identifier_1.Identifier {
             const token = r.getFirstToken();
             const name = token.getStr();
             this.raising.push(name);
-            const clas = scope.findClassDefinition(name);
+            const clas = input.scope.findClassDefinition(name);
             if (clas) {
-                scope.addReference(token, clas, _reference_1.ReferenceType.ObjectOrientedReference, filename, { ooName: name.toUpperCase(), ooType: "CLAS" });
+                input.scope.addReference(token, clas, _reference_1.ReferenceType.ObjectOrientedReference, input.filename, { ooName: name.toUpperCase(), ooType: "CLAS" });
             }
-            else if (scope.getDDIC().inErrorNamespace(name) === false) {
-                scope.addReference(token, clas, _reference_1.ReferenceType.ObjectOrientedVoidReference, filename, { ooName: name.toUpperCase(), ooType: "CLAS" });
+            else if (input.scope.getDDIC().inErrorNamespace(name) === false) {
+                input.scope.addReference(token, clas, _reference_1.ReferenceType.ObjectOrientedVoidReference, input.filename, { ooName: name.toUpperCase(), ooType: "CLAS" });
             }
             else {
-                scope.addReference(token, clas, _reference_1.ReferenceType.ObjectOrientedUnknownReference, filename, { ooName: name.toUpperCase(), ooType: "CLAS" });
+                input.scope.addReference(token, clas, _reference_1.ReferenceType.ObjectOrientedUnknownReference, input.filename, { ooName: name.toUpperCase(), ooType: "CLAS" });
             }
         }
         this.exceptions = [];
@@ -65,7 +65,7 @@ class MethodDefinition extends _identifier_1.Identifier {
             this.exceptions.push(name);
         }
         this.visibility = visibility;
-        this.parameters = new method_parameters_1.MethodParameters(node, this.filename, scope, this.abstract);
+        this.parameters = new method_parameters_1.MethodParameters(node, input, this.abstract);
     }
     getVisibility() {
         return this.visibility;

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

@@ -6,11 +6,10 @@ const Structures = require("../3_structures/structures");
 const statements_1 = require("../2_statements/statements");
 const visibility_1 = require("../4_file_information/visibility");
 class MethodDefinitions {
-    constructor(node, filename, scope) {
+    constructor(node, input) {
         this.all = {};
         this.all = {};
-        this.filename = filename;
-        this.parse(node, scope);
+        this.parse(node, input);
     }
     *getAll() {
         for (const a in this.all) {
@@ -24,17 +23,17 @@ class MethodDefinitions {
         return this.all[name.toUpperCase()];
     }
     ///////////////////////
-    parseInterface(node, scope) {
+    parseInterface(node, input) {
         const defs = node.findAllStatements(statements_1.MethodDef);
         for (const def of defs) {
-            const m = new method_definition_1.MethodDefinition(def, visibility_1.Visibility.Public, this.filename, scope);
+            const m = new method_definition_1.MethodDefinition(def, visibility_1.Visibility.Public, input);
             this.all[m.getName().toUpperCase()] = m;
         }
     }
-    parse(node, scope) {
+    parse(node, input) {
         const idef = node.findDirectStructure(Structures.Interface);
         if (idef) {
-            return this.parseInterface(node, scope);
+            return this.parseInterface(node, input);
         }
         const cdef = node.findDirectStructure(Structures.ClassDefinition);
         if (!cdef) {
@@ -42,17 +41,17 @@ class MethodDefinitions {
         }
         const pri = cdef.findDirectStructure(Structures.PrivateSection);
         for (const def of (pri === null || pri === void 0 ? void 0 : pri.findAllStatements(statements_1.MethodDef)) || []) {
-            const m = new method_definition_1.MethodDefinition(def, visibility_1.Visibility.Private, this.filename, scope);
+            const m = new method_definition_1.MethodDefinition(def, visibility_1.Visibility.Private, input);
             this.all[m.getName().toUpperCase()] = m;
         }
         const pro = node.findDirectStructure(Structures.ProtectedSection);
         for (const def of (pro === null || pro === void 0 ? void 0 : pro.findAllStatements(statements_1.MethodDef)) || []) {
-            const m = new method_definition_1.MethodDefinition(def, visibility_1.Visibility.Protected, this.filename, scope);
+            const m = new method_definition_1.MethodDefinition(def, visibility_1.Visibility.Protected, input);
             this.all[m.getName().toUpperCase()] = m;
         }
         const pub = node.findDirectStructure(Structures.PublicSection);
         for (const def of (pub === null || pub === void 0 ? void 0 : pub.findAllStatements(statements_1.MethodDef)) || []) {
-            const m = new method_definition_1.MethodDefinition(def, visibility_1.Visibility.Public, this.filename, scope);
+            const m = new method_definition_1.MethodDefinition(def, visibility_1.Visibility.Public, input);
             this.all[m.getName().toUpperCase()] = m;
         }
     }

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

@@ -16,7 +16,7 @@ const _scope_type_1 = require("../5_syntax/_scope_type");
 // this.exceptions = [];
 // also consider RAISING vs EXCEPTIONS
 class MethodParameters {
-    constructor(node, filename, scope, abstractMethod) {
+    constructor(node, input, abstractMethod) {
         if (!(node.get() instanceof method_def_1.MethodDef)) {
             throw new Error("MethodDefinition, expected MethodDef as part of input node");
         }
@@ -28,12 +28,12 @@ class MethodParameters {
         this.returning = undefined;
         this.preferred = undefined;
         this.exceptions = [];
-        this.filename = filename;
+        this.filename = input.filename;
         // need the scope for LIKE typing inside method parameters
-        const parentName = scope.getName();
-        scope.push(_scope_type_1.ScopeType.MethodDefinition, "method definition", node.getStart(), filename);
-        this.parse(node, scope, filename, parentName, abstractMethod);
-        scope.pop(node.getEnd());
+        const parentName = input.scope.getName();
+        input.scope.push(_scope_type_1.ScopeType.MethodDefinition, "method definition", node.getStart(), input.filename);
+        this.parse(node, input, parentName, abstractMethod);
+        input.scope.pop(node.getEnd());
     }
     getFilename() {
         return this.filename;
@@ -108,22 +108,22 @@ class MethodParameters {
         return this.defaults[parameter.toUpperCase()];
     }
     ///////////////////
-    parse(node, scope, filename, parentName, abstractMethod) {
+    parse(node, input, parentName, abstractMethod) {
         var _a, _b;
         const handler = node.findFirstExpression(Expressions.EventHandler);
         if (handler) {
             const nameToken = (_a = node.findFirstExpression(Expressions.ClassName)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
             const ooName = nameToken === null || nameToken === void 0 ? void 0 : nameToken.getStr();
-            const def = scope.findObjectDefinition(ooName);
-            const doVoid = def ? false : !scope.getDDIC().inErrorNamespace(ooName);
+            const def = input.scope.findObjectDefinition(ooName);
+            const doVoid = def ? false : !input.scope.getDDIC().inErrorNamespace(ooName);
             if (def) {
-                scope.addReference(nameToken, def, _reference_1.ReferenceType.ObjectOrientedReference, filename);
+                input.scope.addReference(nameToken, def, _reference_1.ReferenceType.ObjectOrientedReference, input.filename);
             }
             else if (doVoid && ooName) {
-                scope.addReference(nameToken, undefined, _reference_1.ReferenceType.ObjectOrientedVoidReference, this.filename, { ooName: ooName.toUpperCase() });
+                input.scope.addReference(nameToken, undefined, _reference_1.ReferenceType.ObjectOrientedVoidReference, this.filename, { ooName: ooName.toUpperCase() });
             }
             const eventName = (_b = node.findFirstExpression(Expressions.EventName)) === null || _b === void 0 ? void 0 : _b.getFirstToken().getStr();
-            const event = new _object_oriented_1.ObjectOriented(scope).searchEvent(def, eventName);
+            const event = new _object_oriented_1.ObjectOriented(input.scope).searchEvent(def, eventName);
             for (const p of handler.findAllExpressions(Expressions.MethodParamName)) {
                 const token = p.getFirstToken();
                 const search = token.getStr().toUpperCase().replace("!", "");
@@ -148,7 +148,7 @@ class MethodParameters {
         }
         const importing = node.findFirstExpression(Expressions.MethodDefImporting);
         if (importing) {
-            this.add(this.importing, importing, scope, ["importing" /* IdentifierMeta.MethodImporting */], abstractMethod);
+            this.add(this.importing, importing, input, ["importing" /* IdentifierMeta.MethodImporting */], abstractMethod);
             if (importing.findDirectTokenByText("PREFERRED")) {
                 this.preferred = importing.getLastToken().getStr().toUpperCase();
                 if (this.preferred.startsWith("!")) {
@@ -158,19 +158,19 @@ class MethodParameters {
         }
         const exporting = node.findFirstExpression(Expressions.MethodDefExporting);
         if (exporting) {
-            this.add(this.exporting, exporting, scope, ["exporting" /* IdentifierMeta.MethodExporting */], abstractMethod);
+            this.add(this.exporting, exporting, input, ["exporting" /* IdentifierMeta.MethodExporting */], abstractMethod);
         }
         const changing = node.findFirstExpression(Expressions.MethodDefChanging);
         if (changing) {
-            this.add(this.changing, changing, scope, ["changing" /* IdentifierMeta.MethodChanging */], abstractMethod);
+            this.add(this.changing, changing, input, ["changing" /* IdentifierMeta.MethodChanging */], abstractMethod);
         }
         const returning = node.findFirstExpression(Expressions.MethodDefReturning);
         if (returning) {
-            this.returning = new method_def_returning_1.MethodDefReturning().runSyntax(returning, scope, this.filename, ["returning" /* IdentifierMeta.MethodReturning */]);
+            this.returning = new method_def_returning_1.MethodDefReturning().runSyntax(returning, input, ["returning" /* IdentifierMeta.MethodReturning */]);
         }
-        this.workaroundRAP(node, scope, filename, parentName);
+        this.workaroundRAP(node, input, parentName);
     }
-    workaroundRAP(node, _scope, filename, parentName) {
+    workaroundRAP(node, input, parentName) {
         const resultName = node.findExpressionAfterToken("RESULT");
         const isRap = node.findExpressionAfterToken("IMPORTING");
         if (isRap) {
@@ -178,7 +178,7 @@ class MethodParameters {
                 if (foo === resultName) {
                     continue;
                 }
-                this.importing.push(new _typed_identifier_1.TypedIdentifier(foo.getFirstToken(), filename, new basic_1.VoidType("RapMethodParameter"), ["importing" /* IdentifierMeta.MethodImporting */]));
+                this.importing.push(new _typed_identifier_1.TypedIdentifier(foo.getFirstToken(), input.filename, new basic_1.VoidType("RapMethodParameter"), ["importing" /* IdentifierMeta.MethodImporting */]));
             }
             const concat = node.concatTokens().toUpperCase();
             if (concat.includes(" FOR VALIDATE ")
@@ -186,30 +186,30 @@ class MethodParameters {
                 || concat.includes(" FOR FEATURES ")
                 || concat.includes(" FOR MODIFY ")) {
                 const token = isRap.getFirstToken();
-                this.exporting.push(new _typed_identifier_1.TypedIdentifier(new identifier_1.Identifier(token.getStart(), "failed"), filename, new basic_1.VoidType("RapMethodParameter"), ["exporting" /* IdentifierMeta.MethodExporting */]));
-                this.exporting.push(new _typed_identifier_1.TypedIdentifier(new identifier_1.Identifier(token.getStart(), "mapped"), filename, new basic_1.VoidType("RapMethodParameter"), ["exporting" /* IdentifierMeta.MethodExporting */]));
-                this.exporting.push(new _typed_identifier_1.TypedIdentifier(new identifier_1.Identifier(token.getStart(), "reported"), filename, new basic_1.VoidType("RapMethodParameter"), ["exporting" /* IdentifierMeta.MethodExporting */]));
+                this.exporting.push(new _typed_identifier_1.TypedIdentifier(new identifier_1.Identifier(token.getStart(), "failed"), input.filename, new basic_1.VoidType("RapMethodParameter"), ["exporting" /* IdentifierMeta.MethodExporting */]));
+                this.exporting.push(new _typed_identifier_1.TypedIdentifier(new identifier_1.Identifier(token.getStart(), "mapped"), input.filename, new basic_1.VoidType("RapMethodParameter"), ["exporting" /* IdentifierMeta.MethodExporting */]));
+                this.exporting.push(new _typed_identifier_1.TypedIdentifier(new identifier_1.Identifier(token.getStart(), "reported"), input.filename, new basic_1.VoidType("RapMethodParameter"), ["exporting" /* IdentifierMeta.MethodExporting */]));
             }
         }
         if (resultName) {
             const token = resultName.getFirstToken();
-            this.importing.push(new _typed_identifier_1.TypedIdentifier(token, filename, new basic_1.VoidType("RapMethodParameter"), ["exporting" /* IdentifierMeta.MethodExporting */]));
+            this.importing.push(new _typed_identifier_1.TypedIdentifier(token, input.filename, new basic_1.VoidType("RapMethodParameter"), ["exporting" /* IdentifierMeta.MethodExporting */]));
         }
         // its some kind of magic
         if (parentName.toUpperCase() === "CL_ABAP_BEHAVIOR_SAVER") {
-            const tempChanging = this.changing.map(c => new _typed_identifier_1.TypedIdentifier(c.getToken(), filename, new basic_1.VoidType("RapMethodParameter"), c.getMeta()));
+            const tempChanging = this.changing.map(c => new _typed_identifier_1.TypedIdentifier(c.getToken(), input.filename, new basic_1.VoidType("RapMethodParameter"), c.getMeta()));
             while (this.changing.length > 0) {
                 this.changing.shift();
             }
             this.changing.push(...tempChanging);
-            const tempImporting = this.importing.map(c => new _typed_identifier_1.TypedIdentifier(c.getToken(), filename, new basic_1.VoidType("RapMethodParameter"), c.getMeta()));
+            const tempImporting = this.importing.map(c => new _typed_identifier_1.TypedIdentifier(c.getToken(), input.filename, new basic_1.VoidType("RapMethodParameter"), c.getMeta()));
             while (this.importing.length > 0) {
                 this.importing.shift();
             }
             this.importing.push(...tempImporting);
         }
     }
-    add(target, source, scope, meta, abstractMethod) {
+    add(target, source, input, meta, abstractMethod) {
         var _a, _b;
         for (const opt of source.findAllExpressions(Expressions.MethodParamOptional)) {
             const p = opt.findDirectExpression(Expressions.MethodParam);
@@ -226,8 +226,8 @@ class MethodParameters {
             if (abstractMethod === true) {
                 extraMeta.push("abstract" /* IdentifierMeta.Abstract */);
             }
-            const id = new method_param_1.MethodParam().runSyntax(p, scope, this.filename, [...meta, ...extraMeta]);
-            scope.addIdentifier(id);
+            const id = new method_param_1.MethodParam().runSyntax(p, input, [...meta, ...extraMeta]);
+            input.scope.addIdentifier(id);
             target.push(id);
             if (opt.findDirectTokenByText("OPTIONAL")) {
                 const name = target[target.length - 1].getName().toUpperCase();
@@ -247,7 +247,7 @@ class MethodParameters {
         }
         const params = source.findAllExpressions(Expressions.MethodParam);
         for (const param of params) {
-            target.push(new method_param_1.MethodParam().runSyntax(param, scope, this.filename, meta));
+            target.push(new method_param_1.MethodParam().runSyntax(param, input, meta));
         }
     }
 }

package/build/src/issue.js

@@ -75,6 +75,18 @@ class Issue {
             defaultFix: fix,
         });
     }
+    static atTokenFilename(filename, token, message, key, severity, fix) {
+        severity = severity !== null && severity !== void 0 ? severity : severity_1.Severity.Error;
+        return new Issue({
+            filename: filename,
+            message,
+            key,
+            start: token.getStart(),
+            end: token.getEnd(),
+            severity,
+            defaultFix: fix,
+        });
+    }
     static atIdentifier(identifier, message, key, severity, fix) {
         severity = severity !== null && severity !== void 0 ? severity : severity_1.Severity.Error;
         return new Issue({

package/build/src/registry.js

@@ -67,7 +67,7 @@ class Registry {
     }
     static abaplintVersion() {
         // magic, see build script "version.sh"
-        return "2.111.1";
+        return "2.112.1";
     }
     getDDICReferences() {
         return this.ddicReferences;

package/build/src/rules/check_syntax.js

@@ -7,6 +7,7 @@ const _abap_object_1 = require("../objects/_abap_object");
 const issue_1 = require("../issue");
 const _irule_1 = require("./_irule");
 const severity_1 = require("../severity");
+const _syntax_input_1 = require("../abap/5_syntax/_syntax_input");
 class CheckSyntaxConf extends _basic_rule_config_1.BasicRuleConfig {
 }
 exports.CheckSyntaxConf = CheckSyntaxConf;
@@ -16,7 +17,7 @@ class CheckSyntax {
     }
     getMetadata() {
         return {
-            key: "check_syntax",
+            key: _syntax_input_1.CheckSyntaxKey,
             title: "Check syntax",
             shortDescription: `Enables syntax check and variable resolution`,
             tags: [_irule_1.RuleTag.Syntax],

package/build/src/rules/double_space.js

@@ -16,6 +16,8 @@ class DoubleSpaceConf extends _basic_rule_config_1.BasicRuleConfig {
         super(...arguments);
         /** Check for double space after keywords */
         this.keywords = true;
+        /** list of keywords to skip, case insensitive */
+        this.skipKeywords = ["CHANGING", "EXPORTING", "OTHERS"];
         /** Check for double space after start parenthesis */
         this.startParen = true;
         /** Check for double space before end parenthesis */
@@ -48,6 +50,9 @@ class DoubleSpace extends _abap_rule_1.ABAPRule {
     }
     setConfig(conf) {
         this.conf = conf;
+        if (this.conf.skipKeywords === undefined) {
+            this.conf.skipKeywords = new DoubleSpaceConf().skipKeywords;
+        }
     }
     runParsed(file) {
         let issues = [];
@@ -159,9 +164,7 @@ class DoubleSpace extends _abap_rule_1.ABAPRule {
             if (prev instanceof nodes_1.TokenNodeRegex
                 || upper === "("
                 || upper === ")"
-                || upper === "CHANGING"
-                || upper === "EXPORTING"
-                || upper === "OTHERS") {
+                || this.getConfig().skipKeywords.some(e => e.toUpperCase() === upper)) {
                 // not a keyword, continue
                 prev = n;
                 continue;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abaplint/core",
-    "version": "2.111.1",
+    "version": "2.112.1",
     "description": "abaplint - Core API",
     "main": "build/src/index.js",
     "typings": "build/abaplint.d.ts",
@@ -50,10 +50,10 @@
     },
     "homepage": "https://abaplint.org",
     "devDependencies": {
-        "@microsoft/api-extractor": "^7.47.1",
+        "@microsoft/api-extractor": "^7.47.2",
         "@types/chai": "^4.3.16",
         "@types/mocha": "^10.0.7",
-        "@types/node": "^20.14.10",
+        "@types/node": "^20.14.11",
         "chai": "^4.4.1",
         "eslint": "^8.57.0",
         "mocha": "^10.6.0",