@abaplint/core 2.111.1 → 2.112.1

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

@@ -5,37 +5,42 @@ const Expressions = require("../../2_statements/expressions");
 const _object_oriented_1 = require("../_object_oriented");
 const _scope_type_1 = require("../_scope_type");
 const _reference_1 = require("../_reference");
+const _syntax_input_1 = require("../_syntax_input");
 class MethodImplementation {
-    runSyntax(node, scope, filename) {
-        const helper = new _object_oriented_1.ObjectOriented(scope);
-        const className = scope.getName();
+    runSyntax(node, input) {
+        const helper = new _object_oriented_1.ObjectOriented(input.scope);
+        const className = input.scope.getName();
         const methodToken = node.findFirstExpression(Expressions.MethodName).getFirstToken();
         const methodName = methodToken === null || methodToken === void 0 ? void 0 : methodToken.getStr();
-        const classDefinition = scope.findClassDefinition(className);
+        const classDefinition = input.scope.findClassDefinition(className);
         if (classDefinition === undefined) {
-            throw new Error("Class definition for \"" + className + "\" not found");
+            const message = "Class definition for \"" + className + "\" not found";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
         const { method: methodDefinition } = helper.searchMethodName(classDefinition, methodName);
         if (methodDefinition === undefined) {
-            throw new Error("Method definition \"" + methodName + "\" not found");
+            const message = "Method definition \"" + methodName + "\" not found";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
         const start = node.getFirstToken().getStart();
         if (methodDefinition.isStatic() === false) {
-            scope.push(_scope_type_1.ScopeType.MethodInstance, methodName, start, filename);
-            scope.addList(classDefinition.getAttributes().getInstance());
+            input.scope.push(_scope_type_1.ScopeType.MethodInstance, methodName, start, input.filename);
+            input.scope.addList(classDefinition.getAttributes().getInstance());
         }
-        scope.push(_scope_type_1.ScopeType.Method, methodName, start, filename);
-        scope.addReference(methodToken, methodDefinition, _reference_1.ReferenceType.MethodImplementationReference, filename);
-        scope.addList(methodDefinition.getParameters().getAll());
+        input.scope.push(_scope_type_1.ScopeType.Method, methodName, start, input.filename);
+        input.scope.addReference(methodToken, methodDefinition, _reference_1.ReferenceType.MethodImplementationReference, input.filename);
+        input.scope.addList(methodDefinition.getParameters().getAll());
         for (const i of helper.findInterfaces(classDefinition)) {
             if (methodName.toUpperCase().startsWith(i.name.toUpperCase() + "~") === false) {
                 continue;
             }
-            const idef = scope.findInterfaceDefinition(i.name);
+            const idef = input.scope.findInterfaceDefinition(i.name);
             if (idef === undefined) {
                 continue;
             }
-            scope.addReference(methodToken, idef, _reference_1.ReferenceType.ObjectOrientedReference, filename);
+            input.scope.addReference(methodToken, idef, _reference_1.ReferenceType.ObjectOrientedReference, input.filename);
         }
     }
 }

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

@@ -7,30 +7,30 @@ const database_table_1 = require("../expressions/database_table");
 const source_1 = require("../expressions/source");
 const _reference_1 = require("../_reference");
 class ModifyDatabase {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         for (const d of node.findAllExpressions(Expressions.Dynamic)) {
-            new dynamic_1.Dynamic().runSyntax(d, scope, filename);
+            new dynamic_1.Dynamic().runSyntax(d, input);
         }
         const dbtab = node.findFirstExpression(Expressions.DatabaseTable);
         if (dbtab !== undefined) {
             if (node.getChildren().length === 5) {
-                const found = scope.findVariable(dbtab.concatTokens());
+                const found = input.scope.findVariable(dbtab.concatTokens());
                 if (found) {
-                    scope.addReference(dbtab.getFirstToken(), found, _reference_1.ReferenceType.DataWriteReference, filename);
+                    input.scope.addReference(dbtab.getFirstToken(), found, _reference_1.ReferenceType.DataWriteReference, input.filename);
                 }
                 else {
-                    new database_table_1.DatabaseTable().runSyntax(dbtab, scope, filename);
+                    new database_table_1.DatabaseTable().runSyntax(dbtab, input);
                 }
             }
             else {
-                new database_table_1.DatabaseTable().runSyntax(dbtab, scope, filename);
+                new database_table_1.DatabaseTable().runSyntax(dbtab, input);
             }
         }
         for (const s of node.findAllExpressions(Expressions.Source)) {
-            new source_1.Source().runSyntax(s, scope, filename);
+            new source_1.Source().runSyntax(s, input);
         }
         for (const s of node.findAllExpressions(Expressions.SimpleSource3)) {
-            new source_1.Source().runSyntax(s, scope, filename);
+            new source_1.Source().runSyntax(s, input);
         }
     }
 }

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

@@ -7,17 +7,17 @@ const target_1 = require("../expressions/target");
 const inline_data_1 = require("../expressions/inline_data");
 const basic_1 = require("../../types/basic");
 class ModifyEntities {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         for (const s of node.findDirectExpressions(Expressions.Source)) {
-            new source_1.Source().runSyntax(s, scope, filename);
+            new source_1.Source().runSyntax(s, input);
         }
         for (const t of node.findDirectExpressions(Expressions.Target)) {
             const inline = t === null || t === void 0 ? void 0 : t.findDirectExpression(Expressions.InlineData);
             if (inline) {
-                new inline_data_1.InlineData().runSyntax(inline, scope, filename, new basic_1.VoidType("ModifyEntities"));
+                new inline_data_1.InlineData().runSyntax(inline, input, new basic_1.VoidType("ModifyEntities"));
             }
             else {
-                new target_1.Target().runSyntax(t, scope, filename);
+                new target_1.Target().runSyntax(t, input);
             }
         }
     }

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

@@ -7,17 +7,18 @@ const target_1 = require("../expressions/target");
 const fstarget_1 = require("../expressions/fstarget");
 const component_cond_1 = require("../expressions/component_cond");
 const basic_1 = require("../../types/basic");
+const _syntax_input_1 = require("../_syntax_input");
 class ModifyInternal {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         for (const s of node.findDirectExpressions(Expressions.Source)) {
-            new source_1.Source().runSyntax(s, scope, filename);
+            new source_1.Source().runSyntax(s, input);
         }
         // there is only one
         const target = node.findFirstExpression(Expressions.Target);
         const targetExpression = target;
         if (targetExpression) {
             // it might be a dynamic target
-            const targetType = new target_1.Target().runSyntax(targetExpression, scope, filename);
+            const targetType = new target_1.Target().runSyntax(targetExpression, input);
             if (targetType instanceof basic_1.VoidType
                 || targetType instanceof basic_1.AnyType
                 || targetType instanceof basic_1.UnknownType) {
@@ -28,25 +29,31 @@ class ModifyInternal {
                     && node.findDirectTokenByText("INDEX")
                     && targetType.isWithHeader() === false) {
                     // MODIFY TABLE INDEX
-                    throw new Error("Table does not have header line");
+                    const message = "Table does not have header line";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return;
                 }
             }
             else if (targetType instanceof basic_1.StructureType) {
                 // it might originate from a TABLES statement
                 if (target.concatTokens().toUpperCase() !== targetType.getDDICName()) {
-                    throw new Error("Not an internal table");
+                    const message = "Not an internal table";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return;
                 }
             }
             else {
-                throw new Error("Not an internal table");
+                const message = "Not an internal table";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
         }
         const fstarget = node.findDirectExpression(Expressions.FSTarget);
         if (fstarget) {
-            new fstarget_1.FSTarget().runSyntax(fstarget, scope, filename, undefined);
+            new fstarget_1.FSTarget().runSyntax(fstarget, input, undefined);
         }
         for (const t of node.findDirectExpressions(Expressions.ComponentCond)) {
-            new component_cond_1.ComponentCond().runSyntax(t, scope, filename);
+            new component_cond_1.ComponentCond().runSyntax(t, input);
         }
     }
 }

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

@@ -4,9 +4,9 @@ exports.ModifyScreen = void 0;
 const Expressions = require("../../2_statements/expressions");
 const source_1 = require("../expressions/source");
 class ModifyScreen {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         for (const s of node.findAllExpressions(Expressions.Source)) {
-            new source_1.Source().runSyntax(s, scope, filename);
+            new source_1.Source().runSyntax(s, input);
         }
     }
 }

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

@@ -6,37 +6,44 @@ const source_1 = require("../expressions/source");
 const target_1 = require("../expressions/target");
 const inline_data_1 = require("../expressions/inline_data");
 const _type_utils_1 = require("../_type_utils");
+const _syntax_input_1 = require("../_syntax_input");
 class Move {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const targets = node.findDirectExpressions(Expressions.Target);
         const firstTarget = targets[0];
         const inline = firstTarget === null || firstTarget === void 0 ? void 0 : firstTarget.findDirectExpression(Expressions.InlineData);
         let targetType = undefined;
         if (inline === undefined) {
-            targetType = firstTarget ? new target_1.Target().runSyntax(firstTarget, scope, filename) : undefined;
+            targetType = firstTarget ? new target_1.Target().runSyntax(firstTarget, input) : undefined;
             for (const t of targets) {
                 if (t === firstTarget) {
                     continue;
                 }
-                new target_1.Target().runSyntax(t, scope, filename);
+                new target_1.Target().runSyntax(t, input);
             }
         }
         const source = node.findDirectExpression(Expressions.Source);
-        const sourceType = source ? new source_1.Source().runSyntax(source, scope, filename, targetType) : undefined;
+        const sourceType = source ? new source_1.Source().runSyntax(source, input, targetType) : undefined;
         if (sourceType === undefined) {
-            throw new Error("No source type determined");
+            const message = "No source type determined";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
         if (inline) {
-            new inline_data_1.InlineData().runSyntax(inline, scope, filename, sourceType);
+            new inline_data_1.InlineData().runSyntax(inline, input, sourceType);
             targetType = sourceType;
         }
         if (node.findDirectTokenByText("?=")) {
-            if (new _type_utils_1.TypeUtils(scope).isCastable(sourceType, targetType) === false) {
-                throw new Error("Incompatible types");
+            if (new _type_utils_1.TypeUtils(input.scope).isCastable(sourceType, targetType) === false) {
+                const message = "Incompatible types";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
         }
-        else if (new _type_utils_1.TypeUtils(scope).isAssignable(sourceType, targetType) === false) {
-            throw new Error("Incompatible types");
+        else if (new _type_utils_1.TypeUtils(input.scope).isAssignable(sourceType, targetType) === false) {
+            const message = "Incompatible types";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
     }
 }

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

@@ -6,21 +6,28 @@ const source_1 = require("../expressions/source");
 const target_1 = require("../expressions/target");
 const version_1 = require("../../../version");
 const basic_1 = require("../../types/basic");
+const _syntax_input_1 = require("../_syntax_input");
 class MoveCorresponding {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const s = node.findDirectExpression(Expressions.Source);
         const t = node.findDirectExpression(Expressions.SimpleTarget);
         if (s === undefined || t === undefined) {
-            throw new Error("MoveCorresponding, source or target not found");
+            const message = "MoveCorresponding, source or target not found";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
-        const sourceType = new source_1.Source().runSyntax(s, scope, filename);
-        const targetType = new target_1.Target().runSyntax(t, scope, filename);
-        if (scope.getVersion() < version_1.Version.v740sp05 && scope.getVersion() !== version_1.Version.Cloud) {
+        const sourceType = new source_1.Source().runSyntax(s, input);
+        const targetType = new target_1.Target().runSyntax(t, input);
+        if (input.scope.getVersion() < version_1.Version.v740sp05 && input.scope.getVersion() !== version_1.Version.Cloud) {
             if (sourceType instanceof basic_1.TableType && sourceType.isWithHeader() === false) {
-                throw new Error("MOVE-CORRESPONDING with tables possible from v740sp05");
+                const message = "MOVE-CORRESPONDING with tables possible from v740sp05";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
             else if (targetType instanceof basic_1.TableType && targetType.isWithHeader() === false) {
-                throw new Error("MOVE-CORRESPONDING with tables possible from v740sp05");
+                const message = "MOVE-CORRESPONDING with tables possible from v740sp05";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
         }
     }

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

@@ -5,12 +5,12 @@ const Expressions = require("../../2_statements/expressions");
 const source_1 = require("../expressions/source");
 const target_1 = require("../expressions/target");
 class Multiply {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         for (const s of node.findDirectExpressions(Expressions.Source)) {
-            new source_1.Source().runSyntax(s, scope, filename);
+            new source_1.Source().runSyntax(s, input);
         }
         for (const t of node.findDirectExpressions(Expressions.Target)) {
-            new target_1.Target().runSyntax(t, scope, filename);
+            new target_1.Target().runSyntax(t, input);
         }
     }
 }

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

@@ -5,12 +5,12 @@ const Expressions = require("../../2_statements/expressions");
 const source_1 = require("../expressions/source");
 const target_1 = require("../expressions/target");
 class OpenDataset {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         for (const s of node.findDirectExpressions(Expressions.Source)) {
-            new source_1.Source().runSyntax(s, scope, filename);
+            new source_1.Source().runSyntax(s, input);
         }
         for (const t of node.findDirectExpressions(Expressions.Target)) {
-            new target_1.Target().runSyntax(t, scope, filename);
+            new target_1.Target().runSyntax(t, input);
         }
     }
 }

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

@@ -5,12 +5,12 @@ const Expressions = require("../../2_statements/expressions");
 const source_1 = require("../expressions/source");
 const target_1 = require("../expressions/target");
 class Pack {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         for (const s of node.findDirectExpressions(Expressions.Source)) {
-            new source_1.Source().runSyntax(s, scope, filename);
+            new source_1.Source().runSyntax(s, input);
         }
         for (const t of node.findDirectExpressions(Expressions.Target)) {
-            new target_1.Target().runSyntax(t, scope, filename);
+            new target_1.Target().runSyntax(t, input);
         }
     }
 }

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

@@ -5,23 +5,28 @@ const Expressions = require("../../2_statements/expressions");
 const _typed_identifier_1 = require("../../types/_typed_identifier");
 const basic_1 = require("../../types/basic");
 const basic_types_1 = require("../basic_types");
+const _syntax_input_1 = require("../_syntax_input");
 class Parameter {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         var _a;
         const nameToken = (_a = node.findFirstExpression(Expressions.FieldSub)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
         if (nameToken && nameToken.getStr().length > 8) {
-            throw new Error("Parameter name too long, " + nameToken.getStr());
+            const message = "Parameter name too long, " + nameToken.getStr();
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
         if (node.findDirectTokenByText("RADIOBUTTON") && node.findDirectTokenByText("LENGTH")) {
-            throw new Error("RADIOBUTTON and LENGTH not possible together");
+            const message = "RADIOBUTTON and LENGTH not possible together";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
-        const bfound = new basic_types_1.BasicTypes(filename, scope).parseType(node);
+        const bfound = new basic_types_1.BasicTypes(input).parseType(node);
         if (nameToken && bfound) {
-            scope.addIdentifier(new _typed_identifier_1.TypedIdentifier(nameToken, filename, bfound));
+            input.scope.addIdentifier(new _typed_identifier_1.TypedIdentifier(nameToken, input.filename, bfound));
             return;
         }
         if (nameToken) {
-            scope.addIdentifier(new _typed_identifier_1.TypedIdentifier(nameToken, filename, new basic_1.UnknownType("Parameter, fallback")));
+            input.scope.addIdentifier(new _typed_identifier_1.TypedIdentifier(nameToken, input.filename, new basic_1.UnknownType("Parameter, fallback")));
         }
     }
 }

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

@@ -6,26 +6,28 @@ const Statements = require("../../2_statements/statements");
 const _reference_1 = require("../_reference");
 const source_1 = require("../expressions/source");
 const target_1 = require("../expressions/target");
+const _syntax_input_1 = require("../_syntax_input");
+const assert_error_1 = require("../assert_error");
 class Perform {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         if (!(node.get() instanceof Statements.Perform)) {
-            throw new Error("checkPerform unexpected node type");
+            throw new assert_error_1.AssertError("checkPerform unexpected node type");
         }
         ////////////////////////////
         // check parameters are defined
         for (const c of node.findDirectExpressions(Expressions.PerformChanging)) {
             for (const s of c.findDirectExpressions(Expressions.Target)) {
-                new target_1.Target().runSyntax(s, scope, filename);
+                new target_1.Target().runSyntax(s, input);
             }
         }
         for (const t of node.findDirectExpressions(Expressions.PerformTables)) {
             for (const s of t.findDirectExpressions(Expressions.Source)) {
-                new source_1.Source().runSyntax(s, scope, filename);
+                new source_1.Source().runSyntax(s, input);
             }
         }
         for (const u of node.findDirectExpressions(Expressions.PerformUsing)) {
             for (const s of u.findDirectExpressions(Expressions.Source)) {
-                new source_1.Source().runSyntax(s, scope, filename);
+                new source_1.Source().runSyntax(s, input);
             }
         }
         ////////////////////////////
@@ -41,11 +43,13 @@ class Perform {
             return; // it might be a dynamic call
         }
         const name = expr.concatTokens();
-        const found = scope.findFormDefinition(name);
+        const found = input.scope.findFormDefinition(name);
         if (found === undefined) {
-            throw new Error("FORM definition \"" + name + "\" not found");
+            const message = "FORM definition \"" + name + "\" not found";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, expr.getFirstToken(), message));
+            return;
         }
-        scope.addReference(expr.getFirstToken(), found, _reference_1.ReferenceType.FormReference, filename);
+        input.scope.addReference(expr.getFirstToken(), found, _reference_1.ReferenceType.FormReference, input.filename);
         // todo, also check parameters match
     }
 }

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

@@ -10,28 +10,31 @@ const message_source_1 = require("../expressions/message_source");
 const raise_with_1 = require("../expressions/raise_with");
 const _object_oriented_1 = require("../_object_oriented");
 const method_parameters_1 = require("../expressions/method_parameters");
+const _syntax_input_1 = require("../_syntax_input");
 class Raise {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         // todo
         var _a, _b, _c, _d, _e, _f;
-        const helper = new _object_oriented_1.ObjectOriented(scope);
+        const helper = new _object_oriented_1.ObjectOriented(input.scope);
         let method;
         const classTok = (_a = node.findDirectExpression(Expressions.ClassName)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
         const className = classTok === null || classTok === void 0 ? void 0 : classTok.getStr();
-        if (className) {
-            const found = scope.existsObject(className);
+        if (classTok && className) {
+            const found = input.scope.existsObject(className);
             if (found === null || found === void 0 ? void 0 : found.id) {
-                scope.addReference(classTok, found.id, _reference_1.ReferenceType.ObjectOrientedReference, filename);
-                const def = scope.findObjectDefinition(className);
+                input.scope.addReference(classTok, found.id, _reference_1.ReferenceType.ObjectOrientedReference, input.filename);
+                const def = input.scope.findObjectDefinition(className);
                 method = (_b = helper.searchMethodName(def, "CONSTRUCTOR")) === null || _b === void 0 ? void 0 : _b.method;
             }
-            else if (scope.getDDIC().inErrorNamespace(className) === false) {
+            else if (input.scope.getDDIC().inErrorNamespace(className) === false) {
                 const extra = { ooName: className, ooType: "Void" };
-                scope.addReference(classTok, undefined, _reference_1.ReferenceType.ObjectOrientedVoidReference, filename, extra);
+                input.scope.addReference(classTok, undefined, _reference_1.ReferenceType.ObjectOrientedVoidReference, input.filename, extra);
                 method = new basic_1.VoidType(className);
             }
             else {
-                throw new Error("RAISE, unknown class " + className);
+                const message = "RAISE, unknown class " + className;
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, classTok, message));
+                return;
             }
             if (method === undefined) {
                 method = new basic_1.VoidType(className);
@@ -39,16 +42,18 @@ class Raise {
         }
         const c = node.findExpressionAfterToken("EXCEPTION");
         if (c instanceof nodes_1.ExpressionNode && (c.get() instanceof Expressions.SimpleSource2 || c.get() instanceof Expressions.Source)) {
-            const type = new source_1.Source().runSyntax(c, scope, filename);
+            const type = new source_1.Source().runSyntax(c, input);
             if (type instanceof basic_1.VoidType) {
                 method = type;
             }
             else if (type instanceof basic_1.ObjectReferenceType) {
-                const def = scope.findObjectDefinition(type.getIdentifierName());
+                const def = input.scope.findObjectDefinition(type.getIdentifierName());
                 method = (_c = helper.searchMethodName(def, "CONSTRUCTOR")) === null || _c === void 0 ? void 0 : _c.method;
             }
             else if (type !== undefined) {
-                throw new Error("RAISE EXCEPTION, must be object reference, got " + type.constructor.name);
+                const message = "RAISE EXCEPTION, must be object reference, got " + type.constructor.name;
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, c.getFirstToken(), message));
+                return;
             }
         }
         if (method === undefined) {
@@ -57,19 +62,19 @@ class Raise {
         // check parameters vs constructor
         const param = node.findDirectExpression(Expressions.ParameterListS);
         if (param) {
-            new method_parameters_1.MethodParameters().checkExporting(param, scope, method, filename, true);
+            new method_parameters_1.MethodParameters().checkExporting(param, input, method, true);
         }
         for (const s of node.findDirectExpressions(Expressions.RaiseWith)) {
-            new raise_with_1.RaiseWith().runSyntax(s, scope, filename);
+            new raise_with_1.RaiseWith().runSyntax(s, input);
         }
         for (const s of node.findDirectExpressions(Expressions.Source)) {
-            new source_1.Source().runSyntax(s, scope, filename);
+            new source_1.Source().runSyntax(s, input);
         }
         for (const s of node.findDirectExpressions(Expressions.SimpleSource2)) {
-            new source_1.Source().runSyntax(s, scope, filename);
+            new source_1.Source().runSyntax(s, input);
         }
         for (const s of node.findDirectExpressions(Expressions.MessageSource)) {
-            new message_source_1.MessageSource().runSyntax(s, scope, filename);
+            new message_source_1.MessageSource().runSyntax(s, input);
         }
         const id = (_d = node.findExpressionAfterToken("ID")) === null || _d === void 0 ? void 0 : _d.concatTokens();
         let number = (_e = node.findDirectExpression(Expressions.MessageNumber)) === null || _e === void 0 ? void 0 : _e.concatTokens();
@@ -81,7 +86,7 @@ class Raise {
         }
         if ((id === null || id === void 0 ? void 0 : id.startsWith("'")) && number) {
             const messageClass = id.substring(1, id.length - 1).toUpperCase();
-            scope.getMSAGReferences().addUsing(filename, node.getFirstToken(), messageClass, number);
+            input.scope.getMSAGReferences().addUsing(input.filename, node.getFirstToken(), messageClass, number);
         }
     }
 }

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

@@ -5,18 +5,18 @@ const Expressions = require("../../2_statements/expressions");
 const source_1 = require("../expressions/source");
 const _reference_1 = require("../_reference");
 class RaiseEvent {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         // todo: only possible in classes
         const f = node.findDirectExpression(Expressions.EventName);
         if (f === null || f === void 0 ? void 0 : f.concatTokens().includes("~")) {
             const name = f.concatTokens().split("~")[0];
-            const idef = scope.findInterfaceDefinition(name);
+            const idef = input.scope.findInterfaceDefinition(name);
             if (idef) {
-                scope.addReference(f.getFirstToken(), idef, _reference_1.ReferenceType.ObjectOrientedReference, filename);
+                input.scope.addReference(f.getFirstToken(), idef, _reference_1.ReferenceType.ObjectOrientedReference, input.filename);
             }
         }
         for (const s of node.findAllExpressions(Expressions.Source)) {
-            new source_1.Source().runSyntax(s, scope, filename);
+            new source_1.Source().runSyntax(s, input);
         }
     }
 }

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

@@ -5,15 +5,16 @@ const Expressions = require("../../2_statements/expressions");
 const _typed_identifier_1 = require("../../types/_typed_identifier");
 const basic_1 = require("../../types/basic");
 const basic_types_1 = require("../basic_types");
+const assert_error_1 = require("../assert_error");
 class Ranges {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         var _a;
         const nameToken = (_a = node.findFirstExpression(Expressions.SimpleName)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
         const typeExpression = node.findFirstExpression(Expressions.FieldSub);
         if (typeExpression === undefined) {
-            throw new Error("Ranges, unexpected node");
+            throw new assert_error_1.AssertError("Ranges, unexpected node");
         }
-        const found = new basic_types_1.BasicTypes(filename, scope).parseType(typeExpression);
+        const found = new basic_types_1.BasicTypes(input).parseType(typeExpression);
         if (found && nameToken) {
             const structure = new basic_1.StructureType([
                 { name: "sign", type: new basic_1.CharacterType(1) },
@@ -22,8 +23,8 @@ class Ranges {
                 { name: "high", type: found },
             ]);
             const type = new basic_1.TableType(structure, { withHeader: true, keyType: basic_1.TableKeyType.default });
-            const id = new _typed_identifier_1.TypedIdentifier(nameToken, filename, type);
-            scope.addIdentifier(id);
+            const id = new _typed_identifier_1.TypedIdentifier(nameToken, input.filename, type);
+            input.scope.addIdentifier(id);
         }
     }
 }

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

@@ -7,17 +7,17 @@ const target_1 = require("../expressions/target");
 const inline_data_1 = require("../expressions/inline_data");
 const basic_1 = require("../../types/basic");
 class ReadEntities {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         for (const s of node.findDirectExpressions(Expressions.Source)) {
-            new source_1.Source().runSyntax(s, scope, filename);
+            new source_1.Source().runSyntax(s, input);
         }
         for (const t of node.findDirectExpressions(Expressions.Target)) {
             const inline = t === null || t === void 0 ? void 0 : t.findDirectExpression(Expressions.InlineData);
             if (inline) {
-                new inline_data_1.InlineData().runSyntax(inline, scope, filename, new basic_1.VoidType("ReadEntities"));
+                new inline_data_1.InlineData().runSyntax(inline, input, new basic_1.VoidType("ReadEntities"));
             }
             else {
-                new target_1.Target().runSyntax(t, scope, filename);
+                new target_1.Target().runSyntax(t, input);
             }
         }
     }

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

@@ -5,12 +5,12 @@ const Expressions = require("../../2_statements/expressions");
 const target_1 = require("../expressions/target");
 const source_1 = require("../expressions/source");
 class ReadReport {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         for (const s of node.findDirectExpressions(Expressions.Source)) {
-            new source_1.Source().runSyntax(s, scope, filename);
+            new source_1.Source().runSyntax(s, input);
         }
         for (const t of node.findDirectExpressions(Expressions.Target)) {
-            new target_1.Target().runSyntax(t, scope, filename);
+            new target_1.Target().runSyntax(t, input);
         }
     }
 }