@abaplint/core 2.111.1 → 2.112.1

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

@@ -9,20 +9,25 @@ const target_1 = require("../expressions/target");
 const fstarget_1 = require("../expressions/fstarget");
 const component_compare_simple_1 = require("../expressions/component_compare_simple");
 const _type_utils_1 = require("../_type_utils");
+const _syntax_input_1 = require("../_syntax_input");
 class ReadTable {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const concat = node.concatTokens().toUpperCase();
         const sources = node.findDirectExpressions(Expressions.Source);
         let firstSource = node.findDirectExpression(Expressions.SimpleSource2);
         if (firstSource === undefined) {
             firstSource = sources[0];
         }
-        const sourceType = firstSource ? new source_1.Source().runSyntax(firstSource, scope, filename) : undefined;
+        const sourceType = firstSource ? new source_1.Source().runSyntax(firstSource, input) : undefined;
         if (sourceType === undefined) {
-            throw new Error("No source type determined, read table");
+            const message = "No source type determined, read table";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
         else if (!(sourceType instanceof basic_1.TableType) && !(sourceType instanceof basic_1.VoidType)) {
-            throw new Error("Read table, not a table type");
+            const message = "Read table, not a table type";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
         let rowType = sourceType;
         if (rowType instanceof basic_1.TableType) {
@@ -30,20 +35,24 @@ class ReadTable {
         }
         const components = node.findDirectExpression(Expressions.ComponentCompareSimple);
         if (components !== undefined) {
-            new component_compare_simple_1.ComponentCompareSimple().runSyntax(components, scope, filename, rowType);
+            new component_compare_simple_1.ComponentCompareSimple().runSyntax(components, input, rowType);
         }
         const indexSource = node.findExpressionAfterToken("INDEX");
         if (indexSource) {
-            const indexType = new source_1.Source().runSyntax(indexSource, scope, filename);
-            if (new _type_utils_1.TypeUtils(scope).isAssignable(indexType, basic_1.IntegerType.get()) === false) {
-                throw new Error("READ TABLE, INDEX must be simple");
+            const indexType = new source_1.Source().runSyntax(indexSource, input);
+            if (new _type_utils_1.TypeUtils(input.scope).isAssignable(indexType, basic_1.IntegerType.get()) === false) {
+                const message = "READ TABLE, INDEX must be simple";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
         }
         const fromSource = node.findExpressionAfterToken("FROM");
         if (fromSource) {
-            const fromType = new source_1.Source().runSyntax(fromSource, scope, filename);
-            if (new _type_utils_1.TypeUtils(scope).isAssignable(fromType, rowType) === false) {
-                throw new Error("READ TABLE, FROM must be compatible");
+            const fromType = new source_1.Source().runSyntax(fromSource, input);
+            if (new _type_utils_1.TypeUtils(input.scope).isAssignable(fromType, rowType) === false) {
+                const message = "READ TABLE, FROM must be compatible";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, fromSource.getFirstToken(), message));
+                return;
             }
         }
         const afterKey = node.findExpressionAfterToken("KEY");
@@ -51,10 +60,12 @@ class ReadTable {
             if (s === firstSource || s === indexSource || s === fromSource) {
                 continue;
             }
-            const type = new source_1.Source().runSyntax(s, scope, filename);
+            const type = new source_1.Source().runSyntax(s, input);
             if (s === afterKey) {
                 if (type instanceof basic_1.StringType || type instanceof basic_1.TableType || type instanceof basic_1.ObjectReferenceType) {
-                    throw new Error("Key cannot be string or table or reference");
+                    const message = "Key cannot be string or table or reference";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, s.getFirstToken(), message));
+                    return;
                 }
             }
         }
@@ -67,22 +78,26 @@ class ReadTable {
             const fst = target.findDirectExpression(Expressions.FSTarget);
             const t = target.findFirstExpression(Expressions.Target);
             if (inline) {
-                new inline_data_1.InlineData().runSyntax(inline, scope, filename, rowType);
+                new inline_data_1.InlineData().runSyntax(inline, input, rowType);
             }
             else if (fst) {
-                new fstarget_1.FSTarget().runSyntax(fst, scope, filename, rowType);
+                new fstarget_1.FSTarget().runSyntax(fst, input, rowType);
             }
             else if (t) {
-                const targetType = new target_1.Target().runSyntax(t, scope, filename);
-                if (new _type_utils_1.TypeUtils(scope).isAssignable(rowType, targetType) === false) {
-                    throw new Error("Incompatible types");
+                const targetType = new target_1.Target().runSyntax(t, input);
+                if (new _type_utils_1.TypeUtils(input.scope).isAssignable(rowType, targetType) === false) {
+                    const message = "Incompatible types";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return;
                 }
             }
         }
         if (target === undefined && concat.includes(" TRANSPORTING NO FIELDS ") === false) {
             // if sourceType is void, assume its with header
             if (sourceType instanceof basic_1.TableType && sourceType.isWithHeader() === false) {
-                throw new Error("READ TABLE, define INTO or TRANSPORTING NO FIELDS");
+                const message = "READ TABLE, define INTO or TRANSPORTING NO FIELDS";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
         }
         const transporting = node.findDirectExpression(Expressions.TransportingFields);
@@ -91,7 +106,9 @@ class ReadTable {
             && !(rowType instanceof basic_1.UnknownType)
             && !(rowType instanceof basic_1.AnyType)) {
             if (!(rowType instanceof basic_1.StructureType)) {
-                throw new Error("READ TABLE, source not structured");
+                const message = "READ TABLE, source not structured";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
             for (const t of (transporting === null || transporting === void 0 ? void 0 : transporting.findDirectExpressions(Expressions.FieldSub)) || []) {
                 const field = t.concatTokens();
@@ -100,7 +117,9 @@ class ReadTable {
                     continue;
                 }
                 if (rowType.getComponentByName(field) === undefined) {
-                    throw new Error("READ TABLE, field " + field + " not found in source");
+                    const message = "READ TABLE, field " + field + " not found in source";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return;
                 }
             }
         }

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

@@ -5,12 +5,12 @@ const Expressions = require("../../2_statements/expressions");
 const source_1 = require("../expressions/source");
 const target_1 = require("../expressions/target");
 class ReadTextpool {
-    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.SimpleTarget)) {
-            new target_1.Target().runSyntax(t, scope, filename);
+            new target_1.Target().runSyntax(t, input);
         }
     }
 }

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

@@ -5,14 +5,14 @@ const Expressions = require("../../2_statements/expressions");
 const target_1 = require("../expressions/target");
 const source_1 = require("../expressions/source");
 class Receive {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         // todo, lots of work here, similar to call_function.ts
         // just recurse
         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 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/replace.js

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

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

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

@@ -4,12 +4,12 @@ exports.Select = void 0;
 const Expressions = require("../../2_statements/expressions");
 const select_1 = require("../expressions/select");
 class Select {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const selects = node.findDirectExpressions(Expressions.Select);
         for (let i = 0; i < selects.length; i++) {
             const last = i === selects.length - 1;
             const s = selects[i];
-            new select_1.Select().runSyntax(s, scope, filename, last === false);
+            new select_1.Select().runSyntax(s, input, last === false);
         }
     }
 }

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

@@ -4,10 +4,10 @@ exports.SelectLoop = void 0;
 const Expressions = require("../../2_statements/expressions");
 const select_loop_1 = require("../expressions/select_loop");
 class SelectLoop {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const s = node.findDirectExpression(Expressions.SelectLoop);
         if (s) {
-            new select_loop_1.SelectLoop().runSyntax(s, scope, filename);
+            new select_loop_1.SelectLoop().runSyntax(s, input);
         }
     }
 }

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

@@ -5,7 +5,7 @@ const Expressions = require("../../2_statements/expressions");
 const _typed_identifier_1 = require("../../types/_typed_identifier");
 const basic_1 = require("../../types/basic");
 class SelectionScreen {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const field = node.findFirstExpression(Expressions.InlineField);
         if (field === undefined) {
             return;
@@ -18,13 +18,13 @@ class SelectionScreen {
                 { name: "DYNNR", type: new basic_1.CharacterType(4) },
                 { name: "ACTIVETAB", type: new basic_1.CharacterType(132) },
             ]);
-            scope.addIdentifier(new _typed_identifier_1.TypedIdentifier(name, filename, type, ["selection_screen_tab" /* IdentifierMeta.SelectionScreenTab */]));
+            input.scope.addIdentifier(new _typed_identifier_1.TypedIdentifier(name, input.filename, type, ["selection_screen_tab" /* IdentifierMeta.SelectionScreenTab */]));
         }
         else if (concat.startsWith("SELECTION-SCREEN TAB")) {
-            scope.addIdentifier(new _typed_identifier_1.TypedIdentifier(name, filename, new basic_1.CharacterType(83), ["selection_screen_tab" /* IdentifierMeta.SelectionScreenTab */]));
+            input.scope.addIdentifier(new _typed_identifier_1.TypedIdentifier(name, input.filename, new basic_1.CharacterType(83), ["selection_screen_tab" /* IdentifierMeta.SelectionScreenTab */]));
         }
         else {
-            scope.addIdentifier(new _typed_identifier_1.TypedIdentifier(name, filename, new basic_1.CharacterType(83)));
+            input.scope.addIdentifier(new _typed_identifier_1.TypedIdentifier(name, input.filename, new basic_1.CharacterType(83)));
         }
     }
 }

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

@@ -6,18 +6,21 @@ const _typed_identifier_1 = require("../../types/_typed_identifier");
 const basic_1 = require("../../types/basic");
 const basic_types_1 = require("../basic_types");
 const dynamic_1 = require("../expressions/dynamic");
+const _syntax_input_1 = require("../_syntax_input");
 class SelectOption {
-    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("Select-option name too long, " + nameToken.getStr());
+            const message = "Select-option name too long, " + nameToken.getStr();
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, nameToken, message));
+            return;
         }
         for (const d of node.findDirectExpressions(Expressions.Dynamic)) {
-            new dynamic_1.Dynamic().runSyntax(d, scope, filename);
+            new dynamic_1.Dynamic().runSyntax(d, input);
         }
         const nameExpression = node.findFirstExpression(Expressions.FieldChain);
-        let found = new basic_types_1.BasicTypes(filename, scope).resolveLikeName(nameExpression);
+        let found = new basic_types_1.BasicTypes(input).resolveLikeName(nameExpression);
         if (found && nameToken) {
             if (found instanceof basic_1.StructureType) {
                 let length = 0;
@@ -39,11 +42,11 @@ class SelectOption {
                 { name: "LOW", type: found },
                 { name: "HIGH", type: found },
             ]);
-            scope.addIdentifier(new _typed_identifier_1.TypedIdentifier(nameToken, filename, new basic_1.TableType(stru, { withHeader: true, keyType: basic_1.TableKeyType.default })));
+            input.scope.addIdentifier(new _typed_identifier_1.TypedIdentifier(nameToken, input.filename, new basic_1.TableType(stru, { withHeader: true, keyType: basic_1.TableKeyType.default })));
             return;
         }
         if (nameToken) {
-            scope.addIdentifier(new _typed_identifier_1.TypedIdentifier(nameToken, filename, new basic_1.UnknownType("Select option, fallback")));
+            input.scope.addIdentifier(new _typed_identifier_1.TypedIdentifier(nameToken, input.filename, new basic_1.UnknownType("Select option, fallback")));
         }
     }
 }

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

@@ -5,15 +5,18 @@ const Expressions = require("../../2_statements/expressions");
 const source_1 = require("../expressions/source");
 const target_1 = require("../expressions/target");
 const _type_utils_1 = require("../_type_utils");
+const _syntax_input_1 = require("../_syntax_input");
 class SetBit {
-    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 typ = new target_1.Target().runSyntax(t, scope, filename);
-            if (typ && new _type_utils_1.TypeUtils(scope).isHexLike(typ) === false) {
-                throw new Error("Input must be byte-like");
+            const typ = new target_1.Target().runSyntax(t, input);
+            if (typ && new _type_utils_1.TypeUtils(input.scope).isHexLike(typ) === false) {
+                const message = "Input must be byte-like";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, t.getFirstToken(), message));
+                return;
             }
         }
     }

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

@@ -5,12 +5,12 @@ const Expressions = require("../../2_statements/expressions");
 const source_1 = require("../expressions/source");
 const method_source_1 = require("../expressions/method_source");
 class SetHandler {
-    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 s of node.findDirectExpressions(Expressions.MethodSource)) {
-            new method_source_1.MethodSource().runSyntax(s, scope, filename);
+            new method_source_1.MethodSource().runSyntax(s, input);
         }
     }
 }

package/build/src/abap/5_syntax/statements/set_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 SetLocale {
-    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/set_parameter.js

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

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

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

@@ -5,24 +5,31 @@ const Expressions = require("../../2_statements/expressions");
 const source_1 = require("../expressions/source");
 const target_1 = require("../expressions/target");
 const _type_utils_1 = require("../_type_utils");
+const _syntax_input_1 = require("../_syntax_input");
 class Shift {
-    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);
         }
         const target = node.findDirectExpression(Expressions.Target);
         if (target === undefined) {
-            throw new Error("Shift, Target not found");
+            const message = "Shift, Target not found";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
-        const targetType = new target_1.Target().runSyntax(target, scope, filename);
+        const targetType = new target_1.Target().runSyntax(target, input);
         if (node.concatTokens().toUpperCase().includes(" IN BYTE MODE")) {
-            if (new _type_utils_1.TypeUtils(scope).isHexLike(targetType) === false) {
-                throw new Error("Shift, Target not hex like");
+            if (new _type_utils_1.TypeUtils(input.scope).isHexLike(targetType) === false) {
+                const message = "Shift, Target not hex like";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
         }
         else {
-            if (new _type_utils_1.TypeUtils(scope).isCharLike(targetType) === false) {
-                throw new Error("Shift, Target not char like");
+            if (new _type_utils_1.TypeUtils(input.scope).isCharLike(targetType) === false) {
+                const message = "Shift, Target not char like";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
         }
     }

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

@@ -5,18 +5,21 @@ const Expressions = require("../../2_statements/expressions");
 const target_1 = require("../expressions/target");
 const dynamic_1 = require("../expressions/dynamic");
 const basic_1 = require("../../types/basic");
+const _syntax_input_1 = require("../_syntax_input");
 class Sort {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         var _a, _b;
         for (const s of node.findDirectExpressions(Expressions.Dynamic)) {
-            new dynamic_1.Dynamic().runSyntax(s, scope, filename);
+            new dynamic_1.Dynamic().runSyntax(s, input);
         }
         const tnode = node.findDirectExpression(Expressions.Target);
         if (tnode) {
-            const ttype = new target_1.Target().runSyntax(tnode, scope, filename);
+            const ttype = new target_1.Target().runSyntax(tnode, input);
             if (ttype instanceof basic_1.TableType) {
                 if (((_b = (_a = ttype.getOptions()) === null || _a === void 0 ? void 0 : _a.primaryKey) === null || _b === void 0 ? void 0 : _b.type) === basic_1.TableAccessType.sorted) {
-                    throw new Error(`Sorted table, already sorted`);
+                    const message = `Sorted table, already sorted`;
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, tnode.getFirstToken(), message));
+                    return;
                 }
                 const rowType = ttype.getRowType();
                 if (!(rowType instanceof basic_1.VoidType)
@@ -31,10 +34,14 @@ class Sort {
                             continue;
                         }
                         else if (!(rowType instanceof basic_1.StructureType)) {
-                            throw new Error("SORT, table row is not structured");
+                            const message = "SORT, table row is not structured";
+                            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, tnode.getFirstToken(), message));
+                            return;
                         }
                         else if (rowType.getComponentByName(cname) === undefined) {
-                            throw new Error(`Field ${cname} does not exist in table row structure`);
+                            const message = `Field ${cname} does not exist in table row structure`;
+                            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                            return;
                         }
                     }
                 }
@@ -43,7 +50,9 @@ class Sort {
                 && !(ttype instanceof basic_1.VoidType)
                 && !(ttype instanceof basic_1.UnknownType)
                 && !(ttype instanceof basic_1.AnyType)) {
-                throw new Error("SORT, must be a internal table");
+                const message = "SORT, must be a internal table";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, tnode.getFirstToken(), message));
+                return;
             }
         }
     }

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

@@ -7,34 +7,39 @@ const inline_data_1 = require("../expressions/inline_data");
 const source_1 = require("../expressions/source");
 const target_1 = require("../expressions/target");
 const _type_utils_1 = require("../_type_utils");
+const _syntax_input_1 = require("../_syntax_input");
 class Split {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const intoTable = node.findTokenSequencePosition("INTO", "TABLE") !== undefined;
         const type = intoTable ? new basic_1.TableType(basic_1.StringType.get(), { withHeader: false, keyType: basic_1.TableKeyType.default }) : basic_1.StringType.get();
         for (const target of node.findAllExpressions(Expressions.Target)) {
             const inline = target.findDirectExpression(Expressions.InlineData);
             if (inline) {
-                new inline_data_1.InlineData().runSyntax(inline, scope, filename, type);
+                new inline_data_1.InlineData().runSyntax(inline, input, type);
             }
             else {
-                let targetType = new target_1.Target().runSyntax(target, scope, filename);
+                let targetType = new target_1.Target().runSyntax(target, input);
                 if (intoTable) {
                     if (!(targetType instanceof basic_1.TableType)
                         && !(targetType instanceof basic_1.UnknownType)
                         && !(targetType instanceof basic_1.VoidType)) {
-                        throw new Error("Into must be table typed");
+                        const message = "Into must be table typed";
+                        input.issues.push((0, _syntax_input_1.syntaxIssue)(input, target.getFirstToken(), message));
+                        return;
                     }
                     if (targetType instanceof basic_1.TableType) {
                         targetType = targetType.getRowType();
                     }
                 }
-                if (new _type_utils_1.TypeUtils(scope).isCharLikeStrict(targetType) === false) {
-                    throw new Error("Incompatible, target not character like");
+                if (new _type_utils_1.TypeUtils(input.scope).isCharLikeStrict(targetType) === false) {
+                    const message = "Incompatible, target not character like";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return;
                 }
             }
         }
         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/static.js

@@ -7,21 +7,21 @@ const basic_types_1 = require("../basic_types");
 const basic_1 = require("../../types/basic");
 const type_table_1 = require("../expressions/type_table");
 class Static {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const tt = node.findFirstExpression(Expressions.TypeTable);
         if (tt) {
-            const ttfound = new type_table_1.TypeTable().runSyntax(node, scope, filename);
+            const ttfound = new type_table_1.TypeTable().runSyntax(node, input);
             if (ttfound) {
                 return ttfound;
             }
         }
-        const found = new basic_types_1.BasicTypes(filename, scope).simpleType(node);
+        const found = new basic_types_1.BasicTypes(input).simpleType(node);
         if (found) {
             return found;
         }
         const fallback = node.findFirstExpression(Expressions.NamespaceSimpleName);
         if (fallback) {
-            return new _typed_identifier_1.TypedIdentifier(fallback.getFirstToken(), filename, new basic_1.UnknownType("Static, fallback"));
+            return new _typed_identifier_1.TypedIdentifier(fallback.getFirstToken(), input.filename, new basic_1.UnknownType("Static, fallback"));
         }
         return undefined;
     }

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

@@ -6,15 +6,15 @@ const source_1 = require("../expressions/source");
 const target_1 = require("../expressions/target");
 const dynamic_1 = require("../expressions/dynamic");
 class Submit {
-    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);
         }
         for (const t of node.findDirectExpressions(Expressions.Dynamic)) {
-            new dynamic_1.Dynamic().runSyntax(t, scope, filename);
+            new dynamic_1.Dynamic().runSyntax(t, input);
         }
     }
 }

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

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