@abaplint/core 2.111.1 → 2.112.0

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

@@ -7,22 +7,25 @@ const target_1 = require("../expressions/target");
 const basic_1 = require("../../types/basic");
 const inline_data_1 = require("../expressions/inline_data");
 const _type_utils_1 = require("../_type_utils");
+const _syntax_input_1 = require("../_syntax_input");
 class GetBit {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         let lastType = undefined;
         for (const s of node.findDirectExpressions(Expressions.Source)) {
-            lastType = new source_1.Source().runSyntax(s, scope, filename);
+            lastType = new source_1.Source().runSyntax(s, input);
         }
-        if (lastType && new _type_utils_1.TypeUtils(scope).isHexLike(lastType) === false) {
-            throw new Error("Input must be byte-like");
+        if (lastType && new _type_utils_1.TypeUtils(input.scope).isHexLike(lastType) === false) {
+            const message = "Input must be byte-like";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
         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(t, scope, filename, basic_1.IntegerType.get());
+                new inline_data_1.InlineData().runSyntax(t, input, basic_1.IntegerType.get());
             }
             else {
-                new target_1.Target().runSyntax(t, scope, filename);
+                new target_1.Target().runSyntax(t, input);
             }
         }
     }

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

@@ -4,9 +4,9 @@ exports.GetCursor = void 0;
 const Expressions = require("../../2_statements/expressions");
 const target_1 = require("../expressions/target");
 class GetCursor {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         for (const t of node.findAllExpressions(Expressions.Target)) {
-            new target_1.Target().runSyntax(t, scope, filename);
+            new target_1.Target().runSyntax(t, input);
         }
     }
 }

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

@@ -5,12 +5,12 @@ const Expressions = require("../../2_statements/expressions");
 const target_1 = require("../expressions/target");
 const source_1 = require("../expressions/source");
 class GetLocale {
-    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/get_parameter.js

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

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

@@ -6,21 +6,24 @@ const source_1 = require("../expressions/source");
 const target_1 = require("../expressions/target");
 const inline_data_1 = require("../expressions/inline_data");
 const basic_1 = require("../../types/basic");
+const _syntax_input_1 = require("../_syntax_input");
 class GetReference {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const s = node.findDirectExpression(Expressions.Source);
-        const type = new source_1.Source().runSyntax(s, scope, filename);
+        const type = new source_1.Source().runSyntax(s, input);
         const target = node.findDirectExpression(Expressions.Target);
         const inline = target === null || target === void 0 ? void 0 : target.findDirectExpression(Expressions.InlineData);
         // todo: error if inline field symbol
         if (inline) {
             if (type instanceof basic_1.AnyType) {
-                throw new Error("GET REFERENCE generic and inline declaration not possible");
+                const message = "GET REFERENCE generic and inline declaration not possible";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
-            new inline_data_1.InlineData().runSyntax(inline, scope, filename, type ? new basic_1.DataReference(type) : undefined);
+            new inline_data_1.InlineData().runSyntax(inline, input, type ? new basic_1.DataReference(type) : undefined);
         }
         else if (target) {
-            new target_1.Target().runSyntax(target, scope, filename);
+            new target_1.Target().runSyntax(target, input);
         }
     }
 }

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

@@ -6,14 +6,14 @@ const inline_data_1 = require("../expressions/inline_data");
 const basic_1 = require("../../types/basic");
 const target_1 = require("../expressions/target");
 class GetRunTime {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const target = node.findDirectExpression(Expressions.Target);
         const inline = target === null || target === void 0 ? void 0 : target.findDirectExpression(Expressions.InlineData);
         if (inline) {
-            new inline_data_1.InlineData().runSyntax(inline, scope, filename, basic_1.IntegerType.get());
+            new inline_data_1.InlineData().runSyntax(inline, input, basic_1.IntegerType.get());
         }
         else if (target) {
-            new target_1.Target().runSyntax(target, scope, filename);
+            new target_1.Target().runSyntax(target, input);
         }
     }
 }

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

@@ -6,14 +6,14 @@ const inline_data_1 = require("../expressions/inline_data");
 const basic_1 = require("../../types/basic");
 const target_1 = require("../expressions/target");
 class GetTime {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const target = node.findDirectExpression(Expressions.Target);
         const inline = target === null || target === void 0 ? void 0 : target.findDirectExpression(Expressions.InlineData);
         if (inline) {
-            new inline_data_1.InlineData().runSyntax(inline, scope, filename, new basic_1.PackedType(8, 0));
+            new inline_data_1.InlineData().runSyntax(inline, input, new basic_1.PackedType(8, 0));
         }
         else if (target) {
-            new target_1.Target().runSyntax(target, scope, filename);
+            new target_1.Target().runSyntax(target, input);
         }
     }
 }

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

@@ -4,9 +4,9 @@ exports.If = void 0;
 const Expressions = require("../../2_statements/expressions");
 const cond_1 = require("../expressions/cond");
 class If {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         for (const s of node.findDirectExpressions(Expressions.Cond)) {
-            new cond_1.Cond().runSyntax(s, scope, filename);
+            new cond_1.Cond().runSyntax(s, input);
         }
     }
 }

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

@@ -5,19 +5,19 @@ const Expressions = require("../../2_statements/expressions");
 const source_1 = require("../expressions/source");
 const target_1 = require("../expressions/target");
 class Import {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         var _a;
         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);
         }
         const databaseName = node.findExpressionAfterToken("DATABASE");
         if (databaseName) {
-            const found = (_a = scope.getDDIC()) === null || _a === void 0 ? void 0 : _a.lookupTableOrView(databaseName.concatTokens());
+            const found = (_a = input.scope.getDDIC()) === null || _a === void 0 ? void 0 : _a.lookupTableOrView(databaseName.concatTokens());
             if (found) {
-                scope.getDDICReferences().addUsing(scope.getParentObj(), { object: found.object });
+                input.scope.getDDICReferences().addUsing(input.scope.getParentObj(), { object: found.object });
             }
         }
     }

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

@@ -5,12 +5,12 @@ const Expressions = require("../../2_statements/expressions");
 const source_1 = require("../expressions/source");
 const target_1 = require("../expressions/target");
 class ImportDynpro {
-    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/include_type.js

@@ -5,16 +5,18 @@ const Expressions = require("../../2_statements/expressions");
 const basic_1 = require("../../types/basic");
 const basic_types_1 = require("../basic_types");
 const _typed_identifier_1 = require("../../types/_typed_identifier");
+const _syntax_input_1 = require("../_syntax_input");
+const assert_error_1 = require("../assert_error");
 class IncludeType {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         var _a, _b;
         const components = [];
         const iname = node.findFirstExpression(Expressions.TypeName);
         if (iname === undefined) {
-            throw new Error("IncludeType, unexpected node structure");
+            throw new assert_error_1.AssertError("IncludeType, unexpected node structure");
         }
         const name = iname.getFirstToken().getStr();
-        let ityp = new basic_types_1.BasicTypes(filename, scope).parseType(iname);
+        let ityp = new basic_types_1.BasicTypes(input).parseType(iname);
         const as = (_a = node.findExpressionAfterToken("AS")) === null || _a === void 0 ? void 0 : _a.concatTokens();
         if (as && ityp instanceof basic_1.StructureType) {
             ityp = new basic_1.StructureType(ityp.getComponents().concat([{
@@ -50,11 +52,13 @@ class IncludeType {
         else if (ityp && ityp instanceof basic_1.VoidType) {
             return ityp;
         }
-        else if (scope.getDDIC().inErrorNamespace(name) === false) {
+        else if (input.scope.getDDIC().inErrorNamespace(name) === false) {
             return new basic_1.VoidType(name);
         }
         else {
-            throw new Error("IncludeType, type not found \"" + iname.concatTokens() + "\"");
+            const message = "IncludeType, type not found \"" + iname.concatTokens() + "\"";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
         }
         return components;
     }

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

@@ -6,19 +6,19 @@ const source_1 = require("../expressions/source");
 const dynamic_1 = require("../expressions/dynamic");
 const database_table_1 = require("../expressions/database_table");
 class InsertDatabase {
-    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);
         }
         for (const s of node.findAllExpressions(Expressions.SimpleSource3)) {
-            new source_1.Source().runSyntax(s, scope, filename);
+            new source_1.Source().runSyntax(s, 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) {
-            new database_table_1.DatabaseTable().runSyntax(dbtab, scope, filename);
+            new database_table_1.DatabaseTable().runSyntax(dbtab, input);
         }
     }
 }

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

@@ -5,15 +5,15 @@ const Expressions = require("../../2_statements/expressions");
 const source_1 = require("../expressions/source");
 const target_1 = require("../expressions/target");
 class InsertFieldGroup {
-    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);
         }
         for (const s of node.findAllExpressions(Expressions.SimpleSource1)) {
-            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/insert_internal.js

@@ -9,19 +9,22 @@ const fstarget_1 = require("../expressions/fstarget");
 const basic_1 = require("../../types/basic");
 const inline_data_1 = require("../expressions/inline_data");
 const _type_utils_1 = require("../_type_utils");
+const _syntax_input_1 = require("../_syntax_input");
 class InsertInternal {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         let targetType;
         const t = node.findDirectExpression(Expressions.Target);
         if (t) {
-            targetType = new target_1.Target().runSyntax(t, scope, filename);
+            targetType = new target_1.Target().runSyntax(t, input);
         }
         if (!(targetType instanceof basic_1.TableType)
             && !(targetType instanceof basic_1.VoidType)
             && !(targetType instanceof basic_1.AnyType)
             && !(targetType instanceof basic_1.UnknownType)
             && targetType !== undefined) {
-            throw new Error("INSERT target must be a table");
+            const message = "INSERT target must be a table";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
         else if (targetType instanceof basic_1.TableType
             && node.findDirectTokenByText("LINES") === undefined) {
@@ -31,48 +34,54 @@ class InsertInternal {
         if (source === undefined) {
             source = node.findDirectExpression(Expressions.Source);
         }
-        const sourceType = source ? new source_1.Source().runSyntax(source, scope, filename, targetType) : targetType;
+        const sourceType = source ? new source_1.Source().runSyntax(source, input, targetType) : targetType;
         if (targetType === undefined
             && !(sourceType instanceof basic_1.TableType)
             && !(sourceType instanceof basic_1.VoidType)
             && !(sourceType instanceof basic_1.AnyType)
             && !(sourceType instanceof basic_1.UnknownType)) {
-            throw new Error("INSERT target must be a table");
+            const message = "INSERT target must be a table";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
         const afterAssigning = node.findExpressionAfterToken("ASSIGNING");
         if ((afterAssigning === null || afterAssigning === void 0 ? void 0 : afterAssigning.get()) instanceof Expressions.FSTarget) {
             const inlinefs = afterAssigning === null || afterAssigning === void 0 ? void 0 : afterAssigning.findDirectExpression(Expressions.InlineFS);
             if (inlinefs) {
-                new inline_fs_1.InlineFS().runSyntax(inlinefs, scope, filename, sourceType);
+                new inline_fs_1.InlineFS().runSyntax(inlinefs, input, sourceType);
             }
             else {
-                new fstarget_1.FSTarget().runSyntax(afterAssigning, scope, filename, sourceType);
+                new fstarget_1.FSTarget().runSyntax(afterAssigning, input, sourceType);
             }
         }
         if (node.findDirectTokenByText("INITIAL") === undefined) {
-            if (new _type_utils_1.TypeUtils(scope).isAssignableStrict(sourceType, targetType) === false) {
-                throw new Error("Types not compatible");
+            if (new _type_utils_1.TypeUtils(input.scope).isAssignableStrict(sourceType, targetType) === false) {
+                const message = "Types not compatible";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
             else if (sourceType instanceof basic_1.CharacterType && targetType instanceof basic_1.StringType) {
                 // yea, well, INSERT doesnt convert the values automatically, like everything else?
-                throw new Error("Types not compatible");
+                const message = "Types not compatible";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
         }
         const afterInto = node.findExpressionAfterToken("INTO");
         if ((afterInto === null || afterInto === void 0 ? void 0 : afterInto.get()) instanceof Expressions.Target && sourceType) {
             const inline = afterInto.findDirectExpression(Expressions.InlineData);
             if (inline) {
-                new inline_data_1.InlineData().runSyntax(afterInto, scope, filename, new basic_1.DataReference(sourceType));
+                new inline_data_1.InlineData().runSyntax(afterInto, input, new basic_1.DataReference(sourceType));
             }
             else {
-                new target_1.Target().runSyntax(afterInto, scope, filename);
+                new target_1.Target().runSyntax(afterInto, input);
             }
         }
         for (const s of node.findDirectExpressions(Expressions.Source)) {
             if (s === source) {
                 continue;
             }
-            new source_1.Source().runSyntax(s, scope, filename, targetType);
+            new source_1.Source().runSyntax(s, input, targetType);
         }
     }
 }

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

@@ -4,9 +4,9 @@ exports.InsertReport = void 0;
 const Expressions = require("../../2_statements/expressions");
 const source_1 = require("../expressions/source");
 class InsertReport {
-    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);
         }
     }
 }

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

@@ -4,9 +4,9 @@ exports.InsertTextpool = void 0;
 const Expressions = require("../../2_statements/expressions");
 const source_1 = require("../expressions/source");
 class InsertTextpool {
-    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);
         }
     }
 }

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

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.InterfaceDeferred = void 0;
 const Expressions = require("../../2_statements/expressions");
 class InterfaceDeferred {
-    runSyntax(node, scope, _filename) {
+    runSyntax(node, input) {
         var _a;
         const name = (_a = node.findFirstExpression(Expressions.InterfaceName)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
-        scope.addDeferred(name, "INTF");
+        input.scope.addDeferred(name, "INTF");
     }
 }
 exports.InterfaceDeferred = InterfaceDeferred;

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

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

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

@@ -11,11 +11,12 @@ const fstarget_1 = require("../expressions/fstarget");
 const component_cond_1 = require("../expressions/component_cond");
 const dynamic_1 = require("../expressions/dynamic");
 const loop_group_by_1 = require("../expressions/loop_group_by");
+const _syntax_input_1 = require("../_syntax_input");
 class Loop {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const loopTarget = node.findDirectExpression(Expressions.LoopTarget);
         let target = loopTarget === null || loopTarget === void 0 ? void 0 : loopTarget.findDirectExpression(Expressions.Target);
-        const targetType = target ? new target_1.Target().runSyntax(target, scope, filename) : undefined;
+        const targetType = target ? new target_1.Target().runSyntax(target, input) : undefined;
         if (target === undefined) {
             target = node.findDirectExpression(Expressions.FSTarget);
         }
@@ -25,32 +26,42 @@ class Loop {
         if (firstSource === undefined) {
             firstSource = sources[0];
         }
-        let sourceType = firstSource ? new source_1.Source().runSyntax(firstSource, scope, filename, targetType, write) : undefined;
+        let sourceType = firstSource ? new source_1.Source().runSyntax(firstSource, input, targetType, write) : undefined;
         let rowType = undefined;
         const concat = node.concatTokens().toUpperCase();
         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;
         }
         else if (sourceType instanceof basic_1.UnknownType) {
-            throw new Error("Loop, not a table type, " + sourceType.getError());
+            const message = "Loop, not a table type, " + sourceType.getError();
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
         else if (sourceType instanceof basic_1.TableType
             && target === undefined
             && sourceType.isWithHeader() === false
             && node.getChildren().length === 4) {
-            throw new Error("Loop, no header line");
+            const message = "Loop, no header line";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
         else if (!(sourceType instanceof basic_1.TableType)
             && !(sourceType instanceof basic_1.AnyType)
             && !(sourceType instanceof basic_1.DataType)
             && !(sourceType instanceof basic_1.VoidType)
             && concat.startsWith("LOOP AT GROUP ") === false) {
-            throw new Error("Loop, not a table type");
+            const message = "Loop, not a table type";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
         else if (loopTarget === undefined
             && sourceType instanceof basic_1.TableType
             && sourceType.isWithHeader() === false) {
-            throw new Error("Loop, no header");
+            const message = "Loop, no header";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
         const targetConcat = loopTarget === null || loopTarget === void 0 ? void 0 : loopTarget.concatTokens().toUpperCase();
         if (sourceType instanceof basic_1.TableType) {
@@ -63,37 +74,39 @@ class Loop {
         if (targetConcat
             && targetConcat.startsWith("TRANSPORTING ")
             && node.findDirectTokenByText("WHERE") === undefined) {
-            throw new Error("Loop, TRANSPORTING NO FIELDS only with WHERE");
+            const message = "Loop, TRANSPORTING NO FIELDS only with WHERE";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
         const inline = target === null || target === void 0 ? void 0 : target.findDirectExpression(Expressions.InlineData);
         if (inline) {
-            new inline_data_1.InlineData().runSyntax(inline, scope, filename, sourceType);
+            new inline_data_1.InlineData().runSyntax(inline, input, sourceType);
         }
         for (const s of sources) {
             if (s === firstSource) {
                 continue;
             }
-            new source_1.Source().runSyntax(s, scope, filename);
+            new source_1.Source().runSyntax(s, input);
         }
         const inlinefs = target === null || target === void 0 ? void 0 : target.findDirectExpression(Expressions.InlineFS);
         if (inlinefs) {
-            new inline_fs_1.InlineFS().runSyntax(inlinefs, scope, filename, sourceType);
+            new inline_fs_1.InlineFS().runSyntax(inlinefs, input, sourceType);
         }
         else {
             const fstarget = loopTarget === null || loopTarget === void 0 ? void 0 : loopTarget.findDirectExpression(Expressions.FSTarget);
             if (fstarget) {
-                new fstarget_1.FSTarget().runSyntax(fstarget, scope, filename, sourceType);
+                new fstarget_1.FSTarget().runSyntax(fstarget, input, sourceType);
             }
         }
         for (const t of node.findDirectExpressions(Expressions.ComponentCond)) {
-            new component_cond_1.ComponentCond().runSyntax(t, scope, filename, rowType);
+            new component_cond_1.ComponentCond().runSyntax(t, input, rowType);
         }
         for (const t of node.findDirectExpressions(Expressions.Dynamic)) {
-            new dynamic_1.Dynamic().runSyntax(t, scope, filename);
+            new dynamic_1.Dynamic().runSyntax(t, input);
         }
         const group = node.findDirectExpression(Expressions.LoopGroupBy);
         if (group) {
-            new loop_group_by_1.LoopGroupBy().runSyntax(group, scope, filename);
+            new loop_group_by_1.LoopGroupBy().runSyntax(group, input);
         }
     }
 }

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

@@ -6,14 +6,14 @@ const target_1 = require("../expressions/target");
 const inline_data_1 = require("../expressions/inline_data");
 const basic_1 = require("../../types/basic");
 class LoopAtScreen {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const target = node.findDirectExpression(Expressions.Target);
         if (target) {
-            new target_1.Target().runSyntax(target, scope, filename);
+            new target_1.Target().runSyntax(target, input);
         }
         const inline = target === null || target === void 0 ? void 0 : target.findDirectExpression(Expressions.InlineData);
         if (inline) {
-            new inline_data_1.InlineData().runSyntax(inline, scope, filename, new basic_1.VoidType("SCREEN"));
+            new inline_data_1.InlineData().runSyntax(inline, input, new basic_1.VoidType("SCREEN"));
         }
     }
 }

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

@@ -8,23 +8,23 @@ const source_1 = require("../expressions/source");
 const target_1 = require("../expressions/target");
 const message_source_1 = require("../expressions/message_source");
 class Message {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const found = node.findExpressionAfterToken("INTO");
         const inline = found === null || found === void 0 ? void 0 : found.findDirectExpression(Expressions.InlineData);
         if (inline) {
-            new inline_data_1.InlineData().runSyntax(inline, scope, filename, basic_1.StringType.get());
+            new inline_data_1.InlineData().runSyntax(inline, input, basic_1.StringType.get());
         }
         else if (found) {
-            new target_1.Target().runSyntax(found, scope, filename);
+            new target_1.Target().runSyntax(found, 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.SimpleSource3)) {
-            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);
         }
     }
 }