@abaplint/core 2.111.1 → 2.112.1

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

@@ -10,86 +10,103 @@ const basic_1 = require("../../types/basic");
 const types_1 = require("../../types");
 const _object_oriented_1 = require("../_object_oriented");
 const _type_utils_1 = require("../_type_utils");
+const _syntax_input_1 = require("../_syntax_input");
 class CreateObject {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         let cdef = undefined;
         // CREATE OBJECT, TYPE
         const type = node.findExpressionAfterToken("TYPE");
         if (type && type.get() instanceof Expressions.ClassName) {
             const token = type.getFirstToken();
             const name = token.getStr();
-            cdef = scope.findClassDefinition(name);
+            cdef = input.scope.findClassDefinition(name);
             if (cdef) {
-                scope.addReference(token, cdef, _reference_1.ReferenceType.ObjectOrientedReference, filename);
+                input.scope.addReference(token, cdef, _reference_1.ReferenceType.ObjectOrientedReference, input.filename);
                 if (cdef.isAbstract() === true) {
-                    throw new Error(cdef.getName() + " is abstract, cannot be instantiated");
+                    const message = cdef.getName() + " is abstract, cannot be instantiated";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return;
                 }
             }
-            else if (scope.getDDIC().inErrorNamespace(name) === false) {
-                scope.addReference(token, undefined, _reference_1.ReferenceType.ObjectOrientedVoidReference, filename, { ooName: name, ooType: "CLAS" });
+            else if (input.scope.getDDIC().inErrorNamespace(name) === false) {
+                input.scope.addReference(token, undefined, _reference_1.ReferenceType.ObjectOrientedVoidReference, input.filename, { ooName: name, ooType: "CLAS" });
             }
             else {
-                throw new Error("TYPE \"" + name + "\" not found");
+                const message = "TYPE \"" + name + "\" not found";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
         }
         // 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);
         }
         let first = true;
         for (const t of node.findAllExpressions(Expressions.Target)) {
-            const found = new target_1.Target().runSyntax(t, scope, filename);
+            const found = new target_1.Target().runSyntax(t, input);
             if (first === true) {
                 first = false;
                 if (found instanceof basic_1.VoidType) {
                     continue;
                 }
                 else if (found instanceof basic_1.UnknownType) {
-                    throw new Error("Target type unknown, " + t.concatTokens());
+                    const message = "Target type unknown, " + t.concatTokens();
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return;
                 }
                 else if (!(found instanceof basic_1.ObjectReferenceType)
                     && !(found instanceof basic_1.AnyType)
                     && !(found instanceof basic_1.DataType)
                     && !(found instanceof basic_1.GenericObjectReferenceType)) {
-                    throw new Error("Target must be an object reference, " + t.concatTokens());
+                    const message = "Target must be an object reference, " + t.concatTokens();
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return;
                 }
                 else if (found instanceof basic_1.GenericObjectReferenceType && type === undefined) {
-                    throw new Error("Generic type, cannot be instantiated");
+                    const message = "Generic type, cannot be instantiated";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return;
                 }
                 else if (found instanceof basic_1.ObjectReferenceType) {
                     const id = found.getIdentifier();
                     if (id instanceof types_1.InterfaceDefinition && type === undefined) {
-                        throw new Error("Interface reference, cannot be instantiated");
+                        const message = "Interface reference, cannot be instantiated";
+                        input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                        return;
                     }
                     else if (found instanceof basic_1.ObjectReferenceType
                         && type === undefined
-                        && scope.findInterfaceDefinition(found.getQualifiedName())) {
-                        throw new Error("Interface reference, cannot be instantiated");
+                        && input.scope.findInterfaceDefinition(found.getQualifiedName())) {
+                        const message = "Interface reference, cannot be instantiated";
+                        input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                        return;
                     }
                     else if (id instanceof types_1.ClassDefinition && cdef === undefined) {
                         cdef = id;
                     }
                     if (type === undefined && id instanceof types_1.ClassDefinition && id.isAbstract() === true) {
-                        throw new Error(id.getName() + " is abstract, cannot be instantiated");
+                        const message = id.getName() + " is abstract, cannot be instantiated";
+                        input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                        return;
                     }
                 }
             }
         }
         for (const t of node.findDirectExpressions(Expressions.Dynamic)) {
-            new dynamic_1.Dynamic().runSyntax(t, scope, filename);
+            new dynamic_1.Dynamic().runSyntax(t, input);
         }
-        this.validateParameters(cdef, node, scope, filename);
+        this.validateParameters(cdef, node, input);
     }
-    validateParameters(cdef, node, scope, filename) {
+    validateParameters(cdef, node, input) {
         var _a, _b, _c, _d;
         if (cdef === undefined) {
             const sources = (_a = node.findDirectExpression(Expressions.ParameterListS)) === null || _a === void 0 ? void 0 : _a.findAllExpressions(Expressions.Source);
             for (const s of sources || []) {
-                new source_1.Source().runSyntax(s, scope, filename);
+                new source_1.Source().runSyntax(s, input);
             }
             return;
         }
-        const methodDef = new _object_oriented_1.ObjectOriented(scope).searchMethodName(cdef, "CONSTRUCTOR");
+        const methodDef = new _object_oriented_1.ObjectOriented(input.scope).searchMethodName(cdef, "CONSTRUCTOR");
         const methodParameters = (_b = methodDef.method) === null || _b === void 0 ? void 0 : _b.getParameters();
         const allImporting = (methodParameters === null || methodParameters === void 0 ? void 0 : methodParameters.getImporting()) || [];
         const requiredImporting = new Set(methodParameters === null || methodParameters === void 0 ? void 0 : methodParameters.getRequiredParameters().map(i => i.getName().toUpperCase()));
@@ -99,21 +116,27 @@ class CreateObject {
                 continue;
             }
             const source = p.findDirectExpression(Expressions.Source);
-            const sourceType = new source_1.Source().runSyntax(source, scope, filename);
+            const sourceType = new source_1.Source().runSyntax(source, input);
             const calculated = (source === null || source === void 0 ? void 0 : source.findFirstExpression(Expressions.MethodCallChain)) !== undefined
                 || (source === null || source === void 0 ? void 0 : source.findFirstExpression(Expressions.StringTemplate)) !== undefined
                 || (source === null || source === void 0 ? void 0 : source.findFirstExpression(Expressions.ArithOperator)) !== undefined;
             const found = allImporting === null || allImporting === void 0 ? void 0 : allImporting.find(p => p.getName().toUpperCase() === name);
             if (found === undefined) {
-                throw new Error(`constructor parameter "${name}" does not exist`);
+                const message = `constructor parameter "${name}" does not exist`;
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
-            else if (new _type_utils_1.TypeUtils(scope).isAssignableStrict(sourceType, found.getType(), calculated) === false) {
-                throw new Error(`constructor parameter "${name}" type not compatible`);
+            else if (new _type_utils_1.TypeUtils(input.scope).isAssignableStrict(sourceType, found.getType(), calculated) === false) {
+                const message = `constructor parameter "${name}" type not compatible`;
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
             requiredImporting.delete(name);
         }
         for (const r of requiredImporting.values()) {
-            throw new Error(`constructor parameter "${r}" must be supplied`);
+            const message = `constructor parameter "${r}" must be supplied`;
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
     }
 }

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

@@ -5,20 +5,24 @@ const Expressions = require("../../2_statements/expressions");
 const _typed_identifier_1 = require("../../types/_typed_identifier");
 const data_definition_1 = require("../expressions/data_definition");
 const unknown_type_1 = require("../../types/basic/unknown_type");
+const _syntax_input_1 = require("../_syntax_input");
+const basic_1 = require("../../types/basic");
 class Data {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const name = node.findFirstExpression(Expressions.DefinitionName);
         const dd = node.findFirstExpression(Expressions.DataDefinition);
         if (dd) {
-            const id = new data_definition_1.DataDefinition().runSyntax(dd, scope, filename);
+            const id = new data_definition_1.DataDefinition().runSyntax(dd, input);
             if ((id === null || id === void 0 ? void 0 : id.getType().isGeneric()) === true
                 && (id === null || id === void 0 ? void 0 : id.getType().containsVoid()) === false) {
-                throw new Error("DATA definition cannot be generic, " + (name === null || name === void 0 ? void 0 : name.concatTokens()));
+                const message = "DATA definition cannot be generic, " + (name === null || name === void 0 ? void 0 : name.concatTokens());
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return new _typed_identifier_1.TypedIdentifier(id.getToken(), input.filename, new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey));
             }
             return id;
         }
         if (name) {
-            return new _typed_identifier_1.TypedIdentifier(name.getFirstToken(), filename, new unknown_type_1.UnknownType("data, fallback"));
+            return new _typed_identifier_1.TypedIdentifier(name.getFirstToken(), input.filename, new unknown_type_1.UnknownType("data, fallback"));
         }
         return undefined;
     }

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

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

@@ -8,10 +8,10 @@ const component_compare_1 = require("../expressions/component_compare");
 const component_cond_1 = require("../expressions/component_cond");
 const basic_1 = require("../../types/basic");
 class DeleteInternal {
-    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);
         }
         let targetType = undefined;
         const target = node.findDirectExpression(Expressions.Target);
@@ -19,23 +19,23 @@ class DeleteInternal {
             let tabl = undefined;
             if (node.getChildren().length === 5 && node.getChildren()[2].concatTokens().toUpperCase() === "FROM") {
                 // it might be a database table
-                tabl = (_a = scope.getDDIC()) === null || _a === void 0 ? void 0 : _a.lookupTableOrView(target.concatTokens());
+                tabl = (_a = input.scope.getDDIC()) === null || _a === void 0 ? void 0 : _a.lookupTableOrView(target.concatTokens());
                 if (tabl) {
-                    scope.getDDICReferences().addUsing(scope.getParentObj(), { object: tabl.object });
+                    input.scope.getDDICReferences().addUsing(input.scope.getParentObj(), { object: tabl.object });
                 }
             }
             if (tabl === undefined) {
-                targetType = new target_1.Target().runSyntax(target, scope, filename);
+                targetType = new target_1.Target().runSyntax(target, input);
                 if (targetType instanceof basic_1.TableType) {
                     targetType = targetType.getRowType();
                 }
             }
         }
         for (const t of node.findDirectExpressions(Expressions.ComponentCompare)) {
-            new component_compare_1.ComponentCompare().runSyntax(t, scope, filename, targetType);
+            new component_compare_1.ComponentCompare().runSyntax(t, input, targetType);
         }
         for (const t of node.findDirectExpressions(Expressions.ComponentCond)) {
-            new component_cond_1.ComponentCond().runSyntax(t, scope, filename, targetType);
+            new component_cond_1.ComponentCond().runSyntax(t, input, targetType);
         }
     }
 }

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

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

@@ -9,51 +9,51 @@ const source_1 = require("../expressions/source");
 const field_chain_1 = require("../expressions/field_chain");
 const _reference_1 = require("../_reference");
 class Describe {
-    runSyntax(node, scope, filename) {
-        for (const s of node.findAllExpressions(Expressions.Source)) {
-            new source_1.Source().runSyntax(s, scope, filename);
+    runSyntax(node, input) {
+        for (const s of node.findDirectExpressions(Expressions.Source)) {
+            new source_1.Source().runSyntax(s, input);
         }
-        for (const s of node.findAllExpressions(Expressions.FieldChain)) {
-            new field_chain_1.FieldChain().runSyntax(s, scope, filename, _reference_1.ReferenceType.DataReadReference);
+        for (const s of node.findDirectExpressions(Expressions.FieldChain)) {
+            new field_chain_1.FieldChain().runSyntax(s, input, _reference_1.ReferenceType.DataReadReference);
         }
         const linesTarget = node.findExpressionAfterToken("LINES");
         if ((linesTarget === null || linesTarget === void 0 ? void 0 : linesTarget.get()) instanceof Expressions.Target) {
             const inline = linesTarget === null || linesTarget === void 0 ? void 0 : linesTarget.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 {
-                new target_1.Target().runSyntax(linesTarget, scope, filename);
+                new target_1.Target().runSyntax(linesTarget, input);
             }
         }
         const typeTarget = node.findExpressionAfterToken("TYPE");
         if ((typeTarget === null || typeTarget === void 0 ? void 0 : typeTarget.get()) instanceof Expressions.Target) {
             const inline = typeTarget === null || typeTarget === void 0 ? void 0 : typeTarget.findDirectExpression(Expressions.InlineData);
             if (inline) {
-                new inline_data_1.InlineData().runSyntax(inline, scope, filename, new basic_1.CharacterType(1));
+                new inline_data_1.InlineData().runSyntax(inline, input, new basic_1.CharacterType(1));
             }
             else {
-                new target_1.Target().runSyntax(typeTarget, scope, filename);
+                new target_1.Target().runSyntax(typeTarget, input);
             }
         }
         const lengthTarget = node.findExpressionAfterToken("LENGTH");
         if ((lengthTarget === null || lengthTarget === void 0 ? void 0 : lengthTarget.get()) instanceof Expressions.Target) {
             const inline = lengthTarget === null || lengthTarget === void 0 ? void 0 : lengthTarget.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 {
-                new target_1.Target().runSyntax(lengthTarget, scope, filename);
+                new target_1.Target().runSyntax(lengthTarget, input);
             }
         }
         const componentsTarget = node.findExpressionAfterToken("COMPONENTS");
         if ((componentsTarget === null || componentsTarget === void 0 ? void 0 : componentsTarget.get()) instanceof Expressions.Target) {
             const inline = componentsTarget === null || componentsTarget === void 0 ? void 0 : componentsTarget.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 {
-                new target_1.Target().runSyntax(componentsTarget, scope, filename);
+                new target_1.Target().runSyntax(componentsTarget, input);
             }
         }
     }

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

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

@@ -6,18 +6,21 @@ const source_1 = require("../expressions/source");
 const target_1 = require("../expressions/target");
 const _type_utils_1 = require("../_type_utils");
 const basic_1 = require("../../types/basic");
+const _syntax_input_1 = require("../_syntax_input");
 class Do {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const afterDo = node.findExpressionAfterToken("DO");
         for (const s of node.findDirectExpressions(Expressions.Source)) {
-            const type = new source_1.Source().runSyntax(s, scope, filename);
+            const type = new source_1.Source().runSyntax(s, input);
             if (s === afterDo
-                && new _type_utils_1.TypeUtils(scope).isAssignable(type, basic_1.IntegerType.get()) === false) {
-                throw new Error("DO TIMES must be numeric");
+                && new _type_utils_1.TypeUtils(input.scope).isAssignable(type, basic_1.IntegerType.get()) === false) {
+                const message = "DO TIMES must be numeric";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
         }
         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/editor_call.js

@@ -4,12 +4,12 @@ exports.EditorCall = void 0;
 const Expressions = require("../../2_statements/expressions");
 const source_1 = require("../expressions/source");
 class EditorCall {
-    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.SimpleSource3)) {
-            new source_1.Source().runSyntax(t, scope, filename);
+            new source_1.Source().runSyntax(t, input);
         }
     }
 }

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

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

@@ -5,19 +5,19 @@ const Expressions = require("../../2_statements/expressions");
 const source_1 = require("../expressions/source");
 const target_1 = require("../expressions/target");
 class Export {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         var _a;
         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.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/fieldsymbol.js

@@ -6,16 +6,16 @@ const _typed_identifier_1 = require("../../types/_typed_identifier");
 const basic_types_1 = require("../basic_types");
 const unknown_type_1 = require("../../types/basic/unknown_type");
 class FieldSymbol {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         var _a;
         const fsname = (_a = node.findFirstExpression(Expressions.FieldSymbol)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
-        const bfound = new basic_types_1.BasicTypes(filename, scope).parseType(node);
+        const bfound = new basic_types_1.BasicTypes(input).parseType(node);
         if (bfound && fsname) {
-            scope.addIdentifier(new _typed_identifier_1.TypedIdentifier(fsname, filename, bfound));
+            input.scope.addIdentifier(new _typed_identifier_1.TypedIdentifier(fsname, input.filename, bfound));
             return;
         }
         if (fsname) {
-            scope.addIdentifier(new _typed_identifier_1.TypedIdentifier(fsname, filename, new unknown_type_1.UnknownType("Fieldsymbol, fallback")));
+            input.scope.addIdentifier(new _typed_identifier_1.TypedIdentifier(fsname, input.filename, new unknown_type_1.UnknownType("Fieldsymbol, fallback")));
         }
     }
 }

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

@@ -7,9 +7,9 @@ const basic_1 = require("../../types/basic");
 const source_1 = require("../expressions/source");
 const target_1 = require("../expressions/target");
 class Find {
-    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 rfound = node.findExpressionAfterToken("RESULTS");
         if (rfound && rfound.get() instanceof Expressions.Target) {
@@ -24,29 +24,29 @@ class Find {
                 { name: "SUBMATCHES", type: new basic_1.TableType(sub, { withHeader: false, keyType: basic_1.TableKeyType.default }) },
             ], "MATCH_RESULT", "MATCH_RESULT");
             if (node.concatTokens().toUpperCase().startsWith("FIND FIRST")) {
-                this.inline(rfound, scope, filename, type);
+                this.inline(rfound, input, type);
             }
             else {
-                this.inline(rfound, scope, filename, new basic_1.TableType(type, { withHeader: false, keyType: basic_1.TableKeyType.default }, "MATCH_RESULT_TAB"));
+                this.inline(rfound, input, new basic_1.TableType(type, { withHeader: false, keyType: basic_1.TableKeyType.default }, "MATCH_RESULT_TAB"));
             }
         }
         const ofound = node.findExpressionsAfterToken("OFFSET");
         for (const o of ofound) {
             if (o.get() instanceof Expressions.Target) {
-                this.inline(o, scope, filename, basic_1.IntegerType.get());
+                this.inline(o, input, basic_1.IntegerType.get());
             }
         }
         const lfound = node.findExpressionAfterToken("LINE");
         if (lfound && lfound.get() instanceof Expressions.Target) {
-            this.inline(lfound, scope, filename, basic_1.IntegerType.get());
+            this.inline(lfound, input, basic_1.IntegerType.get());
         }
         const cfound = node.findExpressionAfterToken("COUNT");
         if (cfound && cfound.get() instanceof Expressions.Target) {
-            this.inline(cfound, scope, filename, basic_1.IntegerType.get());
+            this.inline(cfound, input, basic_1.IntegerType.get());
         }
         const lnfound = node.findExpressionAfterToken("LENGTH");
         if (lnfound && lnfound.get() instanceof Expressions.Target) {
-            this.inline(lnfound, scope, filename, basic_1.IntegerType.get());
+            this.inline(lnfound, input, basic_1.IntegerType.get());
         }
         if (node.findDirectTokenByText("SUBMATCHES")) {
             for (const t of node.findDirectExpressions(Expressions.Target)) {
@@ -58,22 +58,22 @@ class Find {
                 }
                 const inline = t === null || t === void 0 ? void 0 : t.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 {
-                    new target_1.Target().runSyntax(t, scope, filename);
+                    new target_1.Target().runSyntax(t, input);
                 }
             }
         }
     }
     /////////////////////
-    inline(node, scope, filename, type) {
+    inline(node, input, type) {
         const inline = node.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 {
-            new target_1.Target().runSyntax(node, scope, filename);
+            new target_1.Target().runSyntax(node, input);
         }
     }
 }

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

@@ -4,18 +4,21 @@ exports.Form = void 0;
 const form_definition_1 = require("../../types/form_definition");
 const _scope_type_1 = require("../_scope_type");
 const expressions_1 = require("../../2_statements/expressions");
+const _syntax_input_1 = require("../_syntax_input");
 class Form {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         var _a;
         const name = (_a = node.findDirectExpression(expressions_1.FormName)) === null || _a === void 0 ? void 0 : _a.concatTokens();
         if (name === undefined) {
-            throw new Error("Form, could not find name");
+            const message = "Form, could not find name";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
-        scope.push(_scope_type_1.ScopeType.Form, name, node.getFirstToken().getStart(), filename);
-        const form = new form_definition_1.FormDefinition(node, filename, scope);
-        scope.addList(form.getUsingParameters());
-        scope.addList(form.getChangingParameters());
-        scope.addList(form.getTablesParameters());
+        input.scope.push(_scope_type_1.ScopeType.Form, name, node.getFirstToken().getStart(), input.filename);
+        const form = new form_definition_1.FormDefinition(node, input);
+        input.scope.addList(form.getUsingParameters());
+        input.scope.addList(form.getChangingParameters());
+        input.scope.addList(form.getTablesParameters());
     }
 }
 exports.Form = Form;

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

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

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