@abaplint/core 2.111.1 → 2.112.0

package/build/src/abap/5_syntax/expressions/field_assignment.js

@@ -3,16 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FieldAssignment = void 0;
 const Expressions = require("../../2_statements/expressions");
 const basic_1 = require("../../types/basic");
+const _syntax_input_1 = require("../_syntax_input");
 const source_1 = require("./source");
 class FieldAssignment {
-    runSyntax(node, scope, filename, targetType) {
+    runSyntax(node, input, targetType) {
         const fieldSub = node.findDirectExpression(Expressions.FieldSub);
         if (fieldSub === undefined) {
-            throw new Error("FieldAssignment, FieldSub node not found");
+            const message = "FieldAssignment, FieldSub node not found";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
         const s = node.findDirectExpression(Expressions.Source);
         if (s === undefined) {
-            throw new Error("FieldAssignment, Source node not found");
+            const message = "FieldAssignment, Source node not found";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
         let type = undefined;
         if (targetType instanceof basic_1.StructureType) {
@@ -22,7 +27,9 @@ class FieldAssignment {
                 if (text !== "-" && context instanceof basic_1.StructureType) {
                     context = context.getComponentByName(text);
                     if (context === undefined && targetType.containsVoid() === false) {
-                        throw new Error(`field ${text} does not exist in structure`);
+                        const message = `field ${text} does not exist in structure`;
+                        input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                        return;
                     }
                 }
             }
@@ -31,7 +38,7 @@ class FieldAssignment {
         else if (targetType instanceof basic_1.VoidType) {
             type = targetType;
         }
-        new source_1.Source().runSyntax(s, scope, filename, type);
+        new source_1.Source().runSyntax(s, input, type);
     }
 }
 exports.FieldAssignment = FieldAssignment;

package/build/src/abap/5_syntax/expressions/field_chain.js

@@ -15,8 +15,9 @@ const expressions_1 = require("../../2_statements/expressions");
 const dereference_1 = require("./dereference");
 const source_field_symbol_1 = require("./source_field_symbol");
 const source_field_1 = require("./source_field");
+const _syntax_input_1 = require("../_syntax_input");
 class FieldChain {
-    runSyntax(node, scope, filename, refType) {
+    runSyntax(node, input, refType) {
         var _a, _b, _c;
         if (((_a = node.getFirstChild()) === null || _a === void 0 ? void 0 : _a.get()) instanceof Expressions.SourceField
             && node.findDirectExpression(Expressions.ComponentName)) {
@@ -24,10 +25,10 @@ class FieldChain {
             const concat = node.concatTokens();
             const offset = ((_b = node.findDirectExpression(Expressions.FieldOffset)) === null || _b === void 0 ? void 0 : _b.concatTokens()) || "";
             const length = ((_c = node.findDirectExpression(Expressions.FieldLength)) === null || _c === void 0 ? void 0 : _c.concatTokens()) || "";
-            const found = scope.findVariable(concat.replace(offset, "").replace(length, ""));
+            const found = input.scope.findVariable(concat.replace(offset, "").replace(length, ""));
             if (found) {
                 if (refType) {
-                    scope.addReference(node.getFirstToken(), found, refType, filename);
+                    input.scope.addReference(node.getFirstToken(), found, refType, input.filename);
                 }
                 // this is not completely correct, but will work, dashes in names is a mess anyhow
                 return found.getType();
@@ -35,18 +36,22 @@ class FieldChain {
         }
         let context = undefined;
         const children = node.getChildren();
-        context = this.findTop(children[0], scope, filename, refType);
+        context = this.findTop(children[0], input, refType);
         for (let i = 1; i < children.length; i++) {
             const current = children[i];
             if (current === undefined) {
                 break;
             }
             if (current.get() instanceof tokens_1.DashW) {
-                throw new Error("Ending with dash");
+                const message = "Ending with dash";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, current.getFirstToken(), message));
+                return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
             }
             else if (current.get() instanceof tokens_1.Dash) {
                 if (context instanceof basic_1.UnknownType) {
-                    throw new Error("Not a structure, type unknown, FieldChain");
+                    const message = "Not a structure, type unknown, FieldChain";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, current.getFirstToken(), message));
+                    return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
                 }
                 else if (!(context instanceof basic_1.StructureType)
                     && !(context instanceof basic_1.TableType && context.isWithHeader())
@@ -56,7 +61,7 @@ class FieldChain {
                         for (let j = 0; j < i; j++) {
                             contextName += children[j].concatTokens();
                         }
-                        if (scope.isAllowHeaderUse(contextName)) {
+                        if (input.scope.isAllowHeaderUse(contextName)) {
                             // FOR ALL ENTRIES workaround
                             context = context.getRowType();
                             if (!(context instanceof basic_1.StructureType) && !(context instanceof basic_1.VoidType)) {
@@ -64,11 +69,15 @@ class FieldChain {
                             }
                         }
                         else {
-                            throw new Error("Table without header, cannot access fields, " + contextName);
+                            const message = "Table without header, cannot access fields, " + contextName;
+                            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, current.getFirstToken(), message));
+                            return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
                         }
                     }
                     else {
-                        throw new Error("Not a structure, FieldChain");
+                        const message = "Not a structure, FieldChain";
+                        input.issues.push((0, _syntax_input_1.syntaxIssue)(input, current.getFirstToken(), message));
+                        return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
                     }
                 }
             }
@@ -76,33 +85,37 @@ class FieldChain {
                 if (!(context instanceof basic_1.ObjectReferenceType)
                     && !(context instanceof basic_1.DataReference)
                     && !(context instanceof basic_1.VoidType)) {
-                    throw new Error("Not an object reference, field chain");
+                    const message = "Not an object reference, field chain";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, current.getFirstToken(), message));
+                    return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
                 }
             }
             else if (current.get() instanceof expressions_1.Dereference) {
-                context = new dereference_1.Dereference().runSyntax(context);
+                context = new dereference_1.Dereference().runSyntax(current, context, input);
             }
             else if (current.get() instanceof Expressions.ComponentName) {
                 if (context instanceof basic_1.TableType && context.isWithHeader()) {
                     context = context.getRowType();
                 }
-                context = new component_name_1.ComponentName().runSyntax(context, current);
+                context = new component_name_1.ComponentName().runSyntax(context, current, input);
             }
             else if (current instanceof nodes_1.ExpressionNode
                 && current.get() instanceof Expressions.TableExpression) {
                 if (!(context instanceof basic_1.TableType) && !(context instanceof basic_1.VoidType)) {
-                    throw new Error("Table expression, expected table");
+                    const message = "Table expression, expected table";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, current.getFirstToken(), message));
+                    return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
                 }
-                new table_expression_1.TableExpression().runSyntax(current, scope, filename);
+                new table_expression_1.TableExpression().runSyntax(current, input);
                 if (!(context instanceof basic_1.VoidType)) {
                     context = context.getRowType();
                 }
             }
             else if (current.get() instanceof Expressions.AttributeName) {
-                context = new attribute_name_1.AttributeName().runSyntax(context, current, scope, filename, refType);
+                context = new attribute_name_1.AttributeName().runSyntax(context, current, input, refType);
             }
             else if (current.get() instanceof Expressions.FieldOffset && current instanceof nodes_1.ExpressionNode) {
-                const offset = new field_offset_1.FieldOffset().runSyntax(current, scope, filename);
+                const offset = new field_offset_1.FieldOffset().runSyntax(current, input);
                 if (offset) {
                     if (context instanceof basic_1.CharacterType) {
                         context = new basic_1.CharacterType(context.getLength() - offset);
@@ -113,7 +126,7 @@ class FieldChain {
                 }
             }
             else if (current.get() instanceof Expressions.FieldLength && current instanceof nodes_1.ExpressionNode) {
-                const length = new field_length_1.FieldLength().runSyntax(current, scope, filename);
+                const length = new field_length_1.FieldLength().runSyntax(current, input);
                 if (length) {
                     if (context instanceof basic_1.CharacterType) {
                         context = new basic_1.CharacterType(length);
@@ -127,17 +140,17 @@ class FieldChain {
         return context;
     }
     ////////////////
-    findTop(node, scope, filename, type) {
+    findTop(node, input, type) {
         if (node === undefined) {
             return undefined;
         }
         if (node instanceof nodes_1.ExpressionNode
             && node.get() instanceof Expressions.SourceFieldSymbol) {
-            return new source_field_symbol_1.SourceFieldSymbol().runSyntax(node, scope, filename);
+            return new source_field_symbol_1.SourceFieldSymbol().runSyntax(node, input);
         }
         else if (node instanceof nodes_1.ExpressionNode
             && node.get() instanceof Expressions.SourceField) {
-            return new source_field_1.SourceField().runSyntax(node, scope, filename, type);
+            return new source_field_1.SourceField().runSyntax(node, input, type);
         }
         else if (node.get() instanceof Expressions.ClassName) {
             const classTok = node.getFirstToken();
@@ -145,17 +158,19 @@ class FieldChain {
             if (classNam.toUpperCase() === "OBJECT") {
                 return new basic_1.GenericObjectReferenceType();
             }
-            const found = scope.existsObject(classNam);
+            const found = input.scope.existsObject(classNam);
             if (found === null || found === void 0 ? void 0 : found.id) {
-                scope.addReference(classTok, found.id, _reference_1.ReferenceType.ObjectOrientedReference, filename);
+                input.scope.addReference(classTok, found.id, _reference_1.ReferenceType.ObjectOrientedReference, input.filename);
                 return new basic_1.ObjectReferenceType(found.id);
             }
-            else if (scope.getDDIC().inErrorNamespace(classNam) === false) {
-                scope.addReference(classTok, undefined, _reference_1.ReferenceType.ObjectOrientedVoidReference, filename, { ooName: classNam.toUpperCase() });
+            else if (input.scope.getDDIC().inErrorNamespace(classNam) === false) {
+                input.scope.addReference(classTok, undefined, _reference_1.ReferenceType.ObjectOrientedVoidReference, input.filename, { ooName: classNam.toUpperCase() });
                 return new basic_1.VoidType(classNam);
             }
             else {
-                throw new Error("Unknown class " + classNam);
+                const message = "Unknown class " + classNam;
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
             }
         }
         return undefined;

package/build/src/abap/5_syntax/expressions/field_length.js

@@ -5,10 +5,10 @@ const Expressions = require("../../2_statements/expressions");
 const _reference_1 = require("../_reference");
 const field_chain_1 = require("./field_chain");
 class FieldLength {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const field = node.findDirectExpression(Expressions.SimpleFieldChain2);
         if (field) {
-            new field_chain_1.FieldChain().runSyntax(field, scope, filename, _reference_1.ReferenceType.DataReadReference);
+            new field_chain_1.FieldChain().runSyntax(field, input, _reference_1.ReferenceType.DataReadReference);
             return undefined;
         }
         else {

package/build/src/abap/5_syntax/expressions/field_offset.js

@@ -5,10 +5,10 @@ const Expressions = require("../../2_statements/expressions");
 const _reference_1 = require("../_reference");
 const field_chain_1 = require("./field_chain");
 class FieldOffset {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const field = node.findDirectExpression(Expressions.SimpleFieldChain2);
         if (field) {
-            new field_chain_1.FieldChain().runSyntax(field, scope, filename, _reference_1.ReferenceType.DataReadReference);
+            new field_chain_1.FieldChain().runSyntax(field, input, _reference_1.ReferenceType.DataReadReference);
             return undefined;
         }
         else {

package/build/src/abap/5_syntax/expressions/filter_body.js

@@ -4,17 +4,17 @@ exports.FilterBody = void 0;
 const Expressions = require("../../2_statements/expressions");
 const source_1 = require("./source");
 class FilterBody {
-    runSyntax(node, scope, filename, targetType) {
+    runSyntax(node, input, targetType) {
         if (node === undefined) {
             return targetType;
         }
         let type = undefined;
         for (const s of node.findDirectExpressions(Expressions.Source)) {
             if (type === undefined) {
-                type = new source_1.Source().runSyntax(s, scope, filename);
+                type = new source_1.Source().runSyntax(s, input);
             }
             else {
-                new source_1.Source().runSyntax(s, scope, filename);
+                new source_1.Source().runSyntax(s, input);
             }
         }
         return type ? type : targetType;

package/build/src/abap/5_syntax/expressions/for.js

@@ -13,7 +13,7 @@ const _typed_identifier_1 = require("../../types/_typed_identifier");
 const _reference_1 = require("../_reference");
 const let_1 = require("./let");
 class For {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         var _a;
         let scoped = false;
         const inlineLoop = node.findDirectExpressions(Expressions.InlineLoopDefinition);
@@ -26,32 +26,32 @@ class For {
             || groupsToken !== undefined;
         if (addScope) {
             // this scope is popped in parent expressions
-            scope.push(_scope_type_1.ScopeType.For, "FOR", node.getFirstToken().getStart(), filename);
+            input.scope.push(_scope_type_1.ScopeType.For, "FOR", node.getFirstToken().getStart(), input.filename);
             scoped = true;
         }
         for (const s of inlineLoop) {
-            new inline_loop_definition_1.InlineLoopDefinition().runSyntax(s, scope, filename);
+            new inline_loop_definition_1.InlineLoopDefinition().runSyntax(s, input);
         }
         for (const f of inlineField) {
-            new inline_field_definition_1.InlineFieldDefinition().runSyntax(f, scope, filename);
+            new inline_field_definition_1.InlineFieldDefinition().runSyntax(f, input);
         }
         if (groupsToken !== undefined) {
             const type = new basic_1.VoidType("todoGroupBy");
-            const identifier = new _typed_identifier_1.TypedIdentifier(groupsToken, filename, type, ["inline" /* IdentifierMeta.InlineDefinition */]);
-            scope.addIdentifier(identifier);
-            scope.addReference(groupsToken, identifier, _reference_1.ReferenceType.DataWriteReference, filename);
+            const identifier = new _typed_identifier_1.TypedIdentifier(groupsToken, input.filename, type, ["inline" /* IdentifierMeta.InlineDefinition */]);
+            input.scope.addIdentifier(identifier);
+            input.scope.addReference(groupsToken, identifier, _reference_1.ReferenceType.DataWriteReference, input.filename);
         }
         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.ComponentCond)) {
-            new component_cond_1.ComponentCond().runSyntax(s, scope, filename);
+            new component_cond_1.ComponentCond().runSyntax(s, input);
         }
         for (const s of node.findDirectExpressions(Expressions.Cond)) {
-            new cond_1.Cond().runSyntax(s, scope, filename);
+            new cond_1.Cond().runSyntax(s, input);
         }
         if (lett) {
-            new let_1.Let().runSyntax(lett, scope, filename, true);
+            new let_1.Let().runSyntax(lett, input, true);
         }
         return scoped;
     }

package/build/src/abap/5_syntax/expressions/form_param.js

@@ -5,8 +5,9 @@ const _typed_identifier_1 = require("../../types/_typed_identifier");
 const basic_1 = require("../../types/basic");
 const expressions_1 = require("../../2_statements/expressions");
 const basic_types_1 = require("../basic_types");
+const assert_error_1 = require("../assert_error");
 class FormParam {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         var _a, _b, _c;
         const nameToken = (_a = node.findFirstExpression(expressions_1.FormParamName)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
         if (node.findDirectTokenByText("STRUCTURE") && nameToken) {
@@ -14,28 +15,28 @@ class FormParam {
             const typeName = (_b = node.findDirectExpression(expressions_1.SimpleFieldChain)) === null || _b === void 0 ? void 0 : _b.getFirstToken().getStr();
             let type = undefined;
             if (typeName) {
-                type = (_c = scope.findType(typeName)) === null || _c === void 0 ? void 0 : _c.getType();
+                type = (_c = input.scope.findType(typeName)) === null || _c === void 0 ? void 0 : _c.getType();
                 if (type === undefined) {
-                    type = scope.getDDIC().lookupTableOrView(typeName).type;
+                    type = input.scope.getDDIC().lookupTableOrView(typeName).type;
                 }
             }
             else {
                 type = new basic_1.UnknownType("todo, FORM STRUCTURES typing");
             }
-            return new _typed_identifier_1.TypedIdentifier(nameToken, filename, type, ["form_parameter" /* IdentifierMeta.FormParameter */]);
+            return new _typed_identifier_1.TypedIdentifier(nameToken, input.filename, type, ["form_parameter" /* IdentifierMeta.FormParameter */]);
         }
         if (node.getChildren().length === 1 && nameToken) {
             // untyped FORM parameter
-            return new _typed_identifier_1.TypedIdentifier(nameToken, filename, new basic_1.AnyType(), ["form_parameter" /* IdentifierMeta.FormParameter */]);
+            return new _typed_identifier_1.TypedIdentifier(nameToken, input.filename, new basic_1.AnyType(), ["form_parameter" /* IdentifierMeta.FormParameter */]);
         }
-        const bfound = new basic_types_1.BasicTypes(filename, scope).parseType(node);
+        const bfound = new basic_types_1.BasicTypes(input).parseType(node);
         if (nameToken && bfound) {
-            return new _typed_identifier_1.TypedIdentifier(nameToken, filename, bfound, ["form_parameter" /* IdentifierMeta.FormParameter */]);
+            return new _typed_identifier_1.TypedIdentifier(nameToken, input.filename, bfound, ["form_parameter" /* IdentifierMeta.FormParameter */]);
         }
         if (nameToken) {
-            return new _typed_identifier_1.TypedIdentifier(nameToken, filename, new basic_1.UnknownType("FormParam, todo"), ["form_parameter" /* IdentifierMeta.FormParameter */]);
+            return new _typed_identifier_1.TypedIdentifier(nameToken, input.filename, new basic_1.UnknownType("FormParam, todo"), ["form_parameter" /* IdentifierMeta.FormParameter */]);
         }
-        throw new Error("FormParam, unexpected node");
+        throw new assert_error_1.AssertError("FormParam, unexpected node");
     }
 }
 exports.FormParam = FormParam;

package/build/src/abap/5_syntax/expressions/fstarget.js

@@ -4,20 +4,23 @@ exports.FSTarget = void 0;
 const Expressions = require("../../2_statements/expressions");
 const inline_fs_1 = require("./inline_fs");
 const _reference_1 = require("../_reference");
+const _syntax_input_1 = require("../_syntax_input");
 class FSTarget {
-    runSyntax(node, scope, filename, type) {
+    runSyntax(node, input, type) {
         const inlinefs = node === null || node === void 0 ? void 0 : node.findDirectExpression(Expressions.InlineFS);
         if (inlinefs) {
-            new inline_fs_1.InlineFS().runSyntax(inlinefs, scope, filename, type);
+            new inline_fs_1.InlineFS().runSyntax(inlinefs, input, type);
         }
         const target = node === null || node === void 0 ? void 0 : node.findDirectExpression(Expressions.TargetFieldSymbol);
         if (target) {
             const token = target.getFirstToken();
-            const found = scope.findVariable(token.getStr());
+            const found = input.scope.findVariable(token.getStr());
             if (found === undefined) {
-                throw new Error(`"${token.getStr()}" not found, FSTarget`);
+                const message = `"${token.getStr()}" not found, FSTarget`;
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
-            scope.addReference(token, found, _reference_1.ReferenceType.DataWriteReference, filename);
+            input.scope.addReference(token, found, _reference_1.ReferenceType.DataWriteReference, input.filename);
         }
     }
 }

package/build/src/abap/5_syntax/expressions/inline_data.js

@@ -5,8 +5,9 @@ const Expressions = require("../../2_statements/expressions");
 const _typed_identifier_1 = require("../../types/_typed_identifier");
 const basic_1 = require("../../types/basic");
 const _reference_1 = require("../_reference");
+const _syntax_input_1 = require("../_syntax_input");
 class InlineData {
-    runSyntax(node, scope, filename, type) {
+    runSyntax(node, input, type) {
         var _a;
         const token = (_a = node.findFirstExpression(Expressions.TargetField)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
         if (token && type) {
@@ -14,17 +15,19 @@ class InlineData {
                 type = basic_1.StringType.get();
             }
             else if (type instanceof basic_1.CGenericType) {
-                throw new Error("InlineData, generic type C cannot be used for inferred type");
+                const message = "InlineData, generic type C cannot be used for inferred type";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
-            const identifier = new _typed_identifier_1.TypedIdentifier(token, filename, type, ["inline" /* IdentifierMeta.InlineDefinition */]);
-            scope.addIdentifier(identifier);
-            scope.addReference(token, identifier, _reference_1.ReferenceType.DataWriteReference, filename);
+            const identifier = new _typed_identifier_1.TypedIdentifier(token, input.filename, type, ["inline" /* IdentifierMeta.InlineDefinition */]);
+            input.scope.addIdentifier(identifier);
+            input.scope.addReference(token, identifier, _reference_1.ReferenceType.DataWriteReference, input.filename);
         }
         else if (token) {
             const message = "InlineData, could not determine type for \"" + token.getStr() + "\"";
-            const identifier = new _typed_identifier_1.TypedIdentifier(token, filename, new basic_1.UnknownType(message), ["inline" /* IdentifierMeta.InlineDefinition */]);
-            scope.addIdentifier(identifier);
-            scope.addReference(token, identifier, _reference_1.ReferenceType.DataWriteReference, filename);
+            const identifier = new _typed_identifier_1.TypedIdentifier(token, input.filename, new basic_1.UnknownType(message), ["inline" /* IdentifierMeta.InlineDefinition */]);
+            input.scope.addIdentifier(identifier);
+            input.scope.addReference(token, identifier, _reference_1.ReferenceType.DataWriteReference, input.filename);
         }
     }
 }

package/build/src/abap/5_syntax/expressions/inline_field_definition.js

@@ -7,8 +7,10 @@ const Expressions = require("../../2_statements/expressions");
 const basic_types_1 = require("../basic_types");
 const unknown_type_1 = require("../../types/basic/unknown_type");
 const _reference_1 = require("../_reference");
+const _syntax_input_1 = require("../_syntax_input");
+const basic_1 = require("../../types/basic");
 class InlineFieldDefinition {
-    runSyntax(node, scope, filename, targetType) {
+    runSyntax(node, input, targetType) {
         var _a;
         let type = undefined;
         const field = (_a = node.findDirectExpression(Expressions.Field)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
@@ -17,11 +19,11 @@ class InlineFieldDefinition {
         }
         const source = node.findDirectExpression(Expressions.Source);
         if (source) {
-            type = new source_1.Source().runSyntax(source, scope, filename);
+            type = new source_1.Source().runSyntax(source, input);
         }
         const typeName = node.findDirectExpression(Expressions.TypeName);
         if (typeName) {
-            type = new basic_types_1.BasicTypes(filename, scope).parseType(typeName);
+            type = new basic_types_1.BasicTypes(input).parseType(typeName);
         }
         if (targetType !== undefined) {
             type = targetType;
@@ -30,12 +32,14 @@ class InlineFieldDefinition {
             type = new unknown_type_1.UnknownType("InlineFieldDefinition, fallback");
         }
         const name = field.getStr();
-        if (scope.findVariable(name) !== undefined) {
-            throw new Error(`Variable ${name} already defined`);
+        if (input.scope.findVariable(name) !== undefined) {
+            const message = `Variable ${name} already defined`;
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
         }
-        const identifier = new _typed_identifier_1.TypedIdentifier(field, filename, type, ["inline" /* IdentifierMeta.InlineDefinition */]);
-        scope.addReference(field, identifier, _reference_1.ReferenceType.DataWriteReference, filename);
-        scope.addIdentifier(identifier);
+        const identifier = new _typed_identifier_1.TypedIdentifier(field, input.filename, type, ["inline" /* IdentifierMeta.InlineDefinition */]);
+        input.scope.addReference(field, identifier, _reference_1.ReferenceType.DataWriteReference, input.filename);
+        input.scope.addIdentifier(identifier);
         return type;
     }
 }

package/build/src/abap/5_syntax/expressions/inline_fs.js

@@ -6,19 +6,19 @@ const _typed_identifier_1 = require("../../types/_typed_identifier");
 const basic_1 = require("../../types/basic");
 const _reference_1 = require("../_reference");
 class InlineFS {
-    runSyntax(node, scope, filename, type) {
+    runSyntax(node, input, type) {
         var _a;
         const token = (_a = node.findFirstExpression(Expressions.TargetFieldSymbol)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
         if (token && type) {
-            const identifier = new _typed_identifier_1.TypedIdentifier(token, filename, type, ["inline" /* IdentifierMeta.InlineDefinition */]);
-            scope.addIdentifier(identifier);
-            scope.addReference(token, identifier, _reference_1.ReferenceType.DataWriteReference, filename);
+            const identifier = new _typed_identifier_1.TypedIdentifier(token, input.filename, type, ["inline" /* IdentifierMeta.InlineDefinition */]);
+            input.scope.addIdentifier(identifier);
+            input.scope.addReference(token, identifier, _reference_1.ReferenceType.DataWriteReference, input.filename);
         }
         else if (token) {
             const message = "InlineFS, could not determine type for \"" + token.getStr() + "\"";
-            const identifier = new _typed_identifier_1.TypedIdentifier(token, filename, new basic_1.UnknownType(message), ["inline" /* IdentifierMeta.InlineDefinition */]);
-            scope.addIdentifier(identifier);
-            scope.addReference(token, identifier, _reference_1.ReferenceType.DataWriteReference, filename);
+            const identifier = new _typed_identifier_1.TypedIdentifier(token, input.filename, new basic_1.UnknownType(message), ["inline" /* IdentifierMeta.InlineDefinition */]);
+            input.scope.addIdentifier(identifier);
+            input.scope.addReference(token, identifier, _reference_1.ReferenceType.DataWriteReference, input.filename);
         }
     }
 }

package/build/src/abap/5_syntax/expressions/inline_loop_definition.js

@@ -6,8 +6,9 @@ const source_1 = require("./source");
 const basic_1 = require("../../types/basic");
 const _typed_identifier_1 = require("../../types/_typed_identifier");
 const _reference_1 = require("../_reference");
+const _syntax_input_1 = require("../_syntax_input");
 class InlineLoopDefinition {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         if (node === undefined) {
             return;
         }
@@ -17,7 +18,7 @@ class InlineLoopDefinition {
         }
         const source = node.findDirectExpression(Expressions.Source);
         if (source && target) {
-            const sourceType = new source_1.Source().runSyntax(source, scope, filename);
+            const sourceType = new source_1.Source().runSyntax(source, input);
             let rowType = undefined;
             if (sourceType instanceof basic_1.TableType) {
                 rowType = sourceType.getRowType();
@@ -26,7 +27,9 @@ class InlineLoopDefinition {
                 rowType = sourceType;
             }
             else if (sourceType instanceof basic_1.UnknownType) {
-                throw new Error("Unknown type, " + sourceType.getError());
+                const message = "Unknown type, " + sourceType.getError();
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
             if (rowType === undefined
                 && node.concatTokens().toUpperCase().includes(" IN GROUP ")
@@ -34,18 +37,20 @@ class InlineLoopDefinition {
                 rowType = sourceType;
             }
             else if (rowType === undefined) {
-                throw new Error("InlineLoopDefinition, not a table type");
+                const message = "InlineLoopDefinition, not a table type";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
-            const identifier = new _typed_identifier_1.TypedIdentifier(target.getFirstToken(), filename, rowType, ["inline" /* IdentifierMeta.InlineDefinition */]);
-            scope.addReference(target.getFirstToken(), identifier, _reference_1.ReferenceType.DataWriteReference, filename);
-            scope.addReference(target.getFirstToken(), identifier, _reference_1.ReferenceType.DataReadReference, filename);
-            scope.addIdentifier(identifier);
+            const identifier = new _typed_identifier_1.TypedIdentifier(target.getFirstToken(), input.filename, rowType, ["inline" /* IdentifierMeta.InlineDefinition */]);
+            input.scope.addReference(target.getFirstToken(), identifier, _reference_1.ReferenceType.DataWriteReference, input.filename);
+            input.scope.addReference(target.getFirstToken(), identifier, _reference_1.ReferenceType.DataReadReference, input.filename);
+            input.scope.addIdentifier(identifier);
         }
         const index = node.findExpressionAfterToken("INTO");
         if (index && index.get() instanceof Expressions.TargetField) {
-            const identifier = new _typed_identifier_1.TypedIdentifier(index.getFirstToken(), filename, basic_1.IntegerType.get(), ["inline" /* IdentifierMeta.InlineDefinition */]);
-            scope.addReference(index.getFirstToken(), identifier, _reference_1.ReferenceType.DataWriteReference, filename);
-            scope.addIdentifier(identifier);
+            const identifier = new _typed_identifier_1.TypedIdentifier(index.getFirstToken(), input.filename, basic_1.IntegerType.get(), ["inline" /* IdentifierMeta.InlineDefinition */]);
+            input.scope.addReference(index.getFirstToken(), identifier, _reference_1.ReferenceType.DataWriteReference, input.filename);
+            input.scope.addIdentifier(identifier);
         }
     }
 }

package/build/src/abap/5_syntax/expressions/let.js

@@ -5,15 +5,15 @@ const Expressions = require("../../2_statements/expressions");
 const inline_field_definition_1 = require("./inline_field_definition");
 const _scope_type_1 = require("../_scope_type");
 class Let {
-    runSyntax(node, scope, filename, skipScope = false) {
+    runSyntax(node, input, skipScope = false) {
         if (node === undefined) {
             return false;
         }
         if (skipScope !== true) {
-            scope.push(_scope_type_1.ScopeType.Let, "LET", node.getFirstToken().getStart(), filename);
+            input.scope.push(_scope_type_1.ScopeType.Let, "LET", node.getFirstToken().getStart(), input.filename);
         }
         for (const f of node.findDirectExpressions(Expressions.InlineFieldDefinition)) {
-            new inline_field_definition_1.InlineFieldDefinition().runSyntax(f, scope, filename);
+            new inline_field_definition_1.InlineFieldDefinition().runSyntax(f, input);
         }
         return true;
     }

package/build/src/abap/5_syntax/expressions/loop_group_by.js

@@ -8,32 +8,22 @@ const inline_data_1 = require("./inline_data");
 const fstarget_1 = require("./fstarget");
 const target_1 = require("./target");
 class LoopGroupBy {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         for (const t of node.findAllExpressions(Expressions.Target)) {
             const inline = t.findDirectExpression(Expressions.InlineData);
             if (inline) {
-                new inline_data_1.InlineData().runSyntax(inline, scope, filename, new basic_1.VoidType("todoGroupBy"));
+                new inline_data_1.InlineData().runSyntax(inline, input, new basic_1.VoidType("todoGroupBy"));
             }
             else {
-                new target_1.Target().runSyntax(t, scope, filename);
+                new target_1.Target().runSyntax(t, input);
             }
         }
         for (const t of node.findAllExpressions(Expressions.FSTarget)) {
-            new fstarget_1.FSTarget().runSyntax(t, scope, filename, new basic_1.VoidType("todoGroupBy"));
+            new fstarget_1.FSTarget().runSyntax(t, input, new basic_1.VoidType("todoGroupBy"));
         }
-        /*
-        const components: IStructureComponent[] = [];
-        for (const c of node.findDirectExpressions(Expressions.LoopGroupByComponent)) {
-          components.push({name: c.getFirstToken().getStr(), type: new VoidType("todoGroupBy")});
-        }
-        if (components.length === 0) {
-          return;
-        }
-        */
-        //    const sourceType = new StructureType(components);
         for (const c of node.findDirectExpressions(Expressions.LoopGroupByComponent)) {
             for (const t of c.findDirectExpressions(Expressions.ComponentCompareSingle)) {
-                new component_compare_1.ComponentCompare().runSyntax(t, scope, filename);
+                new component_compare_1.ComponentCompare().runSyntax(t, input);
             }
         }
     }