@abaplint/core 2.111.1 → 2.112.0

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

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

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

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

@@ -6,7 +6,7 @@ const _typed_identifier_1 = require("../../types/_typed_identifier");
 const unknown_type_1 = require("../../types/basic/unknown_type");
 const _scope_type_1 = require("../_scope_type");
 class Tables {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         var _a, _b;
         const nameToken = (_a = node.findFirstExpression(Expressions.Field)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
         if (nameToken === undefined) {
@@ -17,20 +17,20 @@ class Tables {
             name = name.substr(1);
         }
         // lookupTableOrView will also give Unknown and Void
-        const found = (_b = scope.getDDIC()) === null || _b === void 0 ? void 0 : _b.lookupTableOrView(name);
+        const found = (_b = input.scope.getDDIC()) === null || _b === void 0 ? void 0 : _b.lookupTableOrView(name);
         if (found) {
-            scope.getDDICReferences().addUsing(scope.getParentObj(), { object: found.object, filename: filename, token: nameToken });
-            if (scope.getType() === _scope_type_1.ScopeType.Form || scope.getType() === _scope_type_1.ScopeType.FunctionModule) {
+            input.scope.getDDICReferences().addUsing(input.scope.getParentObj(), { object: found.object, filename: input.filename, token: nameToken });
+            if (input.scope.getType() === _scope_type_1.ScopeType.Form || input.scope.getType() === _scope_type_1.ScopeType.FunctionModule) {
                 // hoist TABLES definitions to global scope
-                scope.addNamedIdentifierToParent(nameToken.getStr(), new _typed_identifier_1.TypedIdentifier(nameToken, filename, found.type));
+                input.scope.addNamedIdentifierToParent(nameToken.getStr(), new _typed_identifier_1.TypedIdentifier(nameToken, input.filename, found.type));
             }
             else {
-                scope.addIdentifier(new _typed_identifier_1.TypedIdentifier(nameToken, filename, found.type));
+                input.scope.addIdentifier(new _typed_identifier_1.TypedIdentifier(nameToken, input.filename, found.type));
             }
             return;
         }
         // this should never happen,
-        scope.addIdentifier(new _typed_identifier_1.TypedIdentifier(nameToken, filename, new unknown_type_1.UnknownType("Tables, fallback")));
+        input.scope.addIdentifier(new _typed_identifier_1.TypedIdentifier(nameToken, input.filename, new unknown_type_1.UnknownType("Tables, fallback")));
     }
 }
 exports.Tables = Tables;

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

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

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

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

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

@@ -6,30 +6,35 @@ const _typed_identifier_1 = require("../../types/_typed_identifier");
 const basic_1 = require("../../types/basic");
 const Expressions = require("../../2_statements/expressions");
 const type_table_1 = require("../expressions/type_table");
+const _syntax_input_1 = require("../_syntax_input");
 class Type {
-    runSyntax(node, scope, filename, qualifiedNamePrefix) {
+    runSyntax(node, input, qualifiedNamePrefix) {
         const tt = node.findFirstExpression(Expressions.TypeTable);
         if (tt) {
-            return new type_table_1.TypeTable().runSyntax(node, scope, filename, qualifiedNamePrefix);
+            return new type_table_1.TypeTable().runSyntax(node, input, qualifiedNamePrefix);
         }
-        const found = new basic_types_1.BasicTypes(filename, scope).simpleType(node, qualifiedNamePrefix);
+        const found = new basic_types_1.BasicTypes(input).simpleType(node, qualifiedNamePrefix);
         if (found) {
             if ((found === null || found === void 0 ? void 0 : found.getType().isGeneric()) === true
                 && (found === null || found === void 0 ? void 0 : found.getType().containsVoid()) === false) {
-                throw new Error("TYPES definition cannot be generic, " + found.getName());
+                const message = "TYPES definition cannot be generic, " + found.getName();
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return new _typed_identifier_1.TypedIdentifier(found.getToken(), input.filename, new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey));
             }
-            if (scope.isGlobalOO() && found.getType() instanceof basic_1.PackedType) {
+            if (input.scope.isGlobalOO() && found.getType() instanceof basic_1.PackedType) {
                 const concat = node.concatTokens().toUpperCase();
                 if ((concat.includes(" TYPE P ") || concat.includes(" TYPE P."))
                     && concat.includes(" DECIMALS ") === false) {
-                    throw new Error("Specify DECIMALS in OO context for packed");
+                    const message = "Specify DECIMALS in OO context for packed";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return new _typed_identifier_1.TypedIdentifier(found.getToken(), input.filename, new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey));
                 }
             }
             return found;
         }
         const fallback = node.findFirstExpression(Expressions.NamespaceSimpleName);
         if (fallback) {
-            return new _typed_identifier_1.TypedIdentifier(fallback.getFirstToken(), filename, new basic_1.UnknownType("Type, fallback"));
+            return new _typed_identifier_1.TypedIdentifier(fallback.getFirstToken(), input.filename, new basic_1.UnknownType("Type, fallback"));
         }
         return undefined;
     }

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

@@ -3,16 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Unassign = void 0;
 const Expressions = require("../../2_statements/expressions");
 const _reference_1 = require("../_reference");
+const _syntax_input_1 = require("../_syntax_input");
 class Unassign {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         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, Unassign`);
+                const message = `"${token.getStr()}" not found, Unassign`;
+                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/statements/unpack.js

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

@@ -10,36 +10,36 @@ const identifier_1 = require("../../1_lexer/tokens/identifier");
 const database_table_1 = require("../expressions/database_table");
 const dynamic_1 = require("../expressions/dynamic");
 class UpdateDatabase {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, 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);
         }
         const tableName = node.findDirectExpression(Expressions.DatabaseTable);
         const tokenName = tableName === null || tableName === void 0 ? void 0 : tableName.getFirstToken();
         if (tableName && tokenName) {
             // todo, this also finds structures, it should only find transparent tables
-            const found = scope.getDDIC().lookupTable(tokenName.getStr());
+            const found = input.scope.getDDIC().lookupTable(tokenName.getStr());
             if (found instanceof basic_1.StructureType) {
-                scope.push(_scope_type_1.ScopeType.OpenSQL, "UPDATE", tokenName.getStart(), filename);
+                input.scope.push(_scope_type_1.ScopeType.OpenSQL, "UPDATE", tokenName.getStart(), input.filename);
                 for (const field of found.getComponents()) {
                     const fieldToken = new identifier_1.Identifier(node.getFirstToken().getStart(), field.name);
-                    const id = new _typed_identifier_1.TypedIdentifier(fieldToken, filename, field.type);
-                    scope.addIdentifier(id);
+                    const id = new _typed_identifier_1.TypedIdentifier(fieldToken, input.filename, field.type);
+                    input.scope.addIdentifier(id);
                 }
             }
         }
         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);
         }
-        if (scope.getType() === _scope_type_1.ScopeType.OpenSQL) {
-            scope.pop(node.getLastToken().getEnd());
+        if (input.scope.getType() === _scope_type_1.ScopeType.OpenSQL) {
+            input.scope.pop(node.getLastToken().getEnd());
         }
     }
 }

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

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

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

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

@@ -5,8 +5,9 @@ const Expressions = require("../../2_statements/expressions");
 const basic_1 = require("../../types/basic");
 const inline_data_1 = require("../expressions/inline_data");
 const target_1 = require("../expressions/target");
+const _syntax_input_1 = require("../_syntax_input");
 class WhenType {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         var _a;
         const nameToken = (_a = node.findFirstExpression(Expressions.ClassName)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
         if (nameToken === undefined) {
@@ -14,12 +15,14 @@ class WhenType {
         }
         let type = undefined;
         const className = nameToken.getStr();
-        const found = scope.findObjectDefinition(className);
-        if (found === undefined && scope.getDDIC().inErrorNamespace(className) === false) {
+        const found = input.scope.findObjectDefinition(className);
+        if (found === undefined && input.scope.getDDIC().inErrorNamespace(className) === false) {
             type = new basic_1.VoidType(className);
         }
         else if (found === undefined) {
-            throw new Error("Class " + className + " not found");
+            const message = "Class " + className + " not found";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, nameToken, message));
+            return;
         }
         else {
             type = new basic_1.ObjectReferenceType(found);
@@ -27,10 +30,10 @@ class WhenType {
         const target = node === null || node === void 0 ? void 0 : node.findDirectExpression(Expressions.Target);
         const inline = target === null || target === void 0 ? void 0 : target.findDirectExpression(Expressions.InlineData);
         if (inline) {
-            new inline_data_1.InlineData().runSyntax(inline, scope, filename, type);
+            new inline_data_1.InlineData().runSyntax(inline, input, type);
         }
         else if (target) {
-            new target_1.Target().runSyntax(target, scope, filename);
+            new target_1.Target().runSyntax(target, input);
         }
     }
 }

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

@@ -6,15 +6,15 @@ const source_1 = require("../expressions/source");
 const cond_1 = require("../expressions/cond");
 const target_1 = require("../expressions/target");
 class While {
-    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);
         }
         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.Target)) {
-            new target_1.Target().runSyntax(s, scope, filename);
+            new target_1.Target().runSyntax(s, input);
         }
     }
 }

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

@@ -5,12 +5,12 @@ const Expressions = require("../../2_statements/expressions");
 const select_1 = require("../expressions/select");
 const select_loop_1 = require("../expressions/select_loop");
 class With {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         for (const s of node.findAllExpressions(Expressions.Select)) {
-            new select_1.Select().runSyntax(s, scope, filename);
+            new select_1.Select().runSyntax(s, input);
         }
         for (const s of node.findAllExpressions(Expressions.SelectLoop)) {
-            new select_loop_1.SelectLoop().runSyntax(s, scope, filename);
+            new select_loop_1.SelectLoop().runSyntax(s, input);
         }
     }
 }

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

@@ -5,12 +5,12 @@ const Expressions = require("../../2_statements/expressions");
 const select_1 = require("../expressions/select");
 const select_loop_1 = require("../expressions/select_loop");
 class WithLoop {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         for (const s of node.findAllExpressions(Expressions.Select)) {
-            new select_1.Select().runSyntax(s, scope, filename);
+            new select_1.Select().runSyntax(s, input);
         }
         for (const s of node.findAllExpressions(Expressions.SelectLoop)) {
-            new select_loop_1.SelectLoop().runSyntax(s, scope, filename);
+            new select_loop_1.SelectLoop().runSyntax(s, input);
         }
     }
 }

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

@@ -8,30 +8,34 @@ const dynamic_1 = require("../expressions/dynamic");
 const _type_utils_1 = require("../_type_utils");
 const field_chain_1 = require("../expressions/field_chain");
 const _reference_1 = require("../_reference");
+const _syntax_input_1 = require("../_syntax_input");
 class Write {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         // todo, more
+        var _a;
         let second = node.getChildren()[1];
         if (second.get() instanceof Expressions.WriteOffsetLength) {
             second = node.getChildren()[2];
         }
-        for (const s of node.findAllExpressions(Expressions.Source)) {
-            const type = new source_1.Source().runSyntax(s, scope, filename);
+        for (const s of node.findDirectExpressions(Expressions.Source)) {
+            const type = new source_1.Source().runSyntax(s, input);
             if (s === second
-                && new _type_utils_1.TypeUtils(scope).isCharLike(type) === false
-                && new _type_utils_1.TypeUtils(scope).isHexLike(type) === false) {
-                throw new Error("Source not character like");
+                && new _type_utils_1.TypeUtils(input.scope).isCharLike(type) === false
+                && new _type_utils_1.TypeUtils(input.scope).isHexLike(type) === false) {
+                const message = "Source not character like";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, s.getFirstToken(), message));
+                return;
             }
         }
-        for (const s of node.findAllExpressions(Expressions.SimpleFieldChain2)) {
-            new field_chain_1.FieldChain().runSyntax(s, scope, filename, _reference_1.ReferenceType.DataReadReference);
+        for (const s of ((_a = node.findDirectExpression(Expressions.WriteOffsetLength)) === null || _a === void 0 ? void 0 : _a.findDirectExpressions(Expressions.SimpleFieldChain2)) || []) {
+            new field_chain_1.FieldChain().runSyntax(s, input, _reference_1.ReferenceType.DataReadReference);
         }
         for (const s of node.findAllExpressions(Expressions.Dynamic)) {
-            new dynamic_1.Dynamic().runSyntax(s, scope, filename);
+            new dynamic_1.Dynamic().runSyntax(s, input);
         }
         const target = node.findDirectExpression(Expressions.Target);
         if (target) {
-            new target_1.Target().runSyntax(target, scope, filename);
+            new target_1.Target().runSyntax(target, input);
         }
     }
 }

package/build/src/abap/5_syntax/structures/class_data.js

@@ -8,14 +8,14 @@ const _typed_identifier_1 = require("../../types/_typed_identifier");
 const Basic = require("../../types/basic");
 const class_data_1 = require("../statements/class_data");
 class ClassData {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const name = node.findFirstExpression(Expressions.NamespaceSimpleName).getFirstToken();
         const values = {};
         const components = [];
         for (const c of node.getChildren()) {
             const ctyp = c.get();
             if (c instanceof nodes_1.StatementNode && ctyp instanceof Statements.ClassData) {
-                const found = new class_data_1.ClassData().runSyntax(c, scope, filename);
+                const found = new class_data_1.ClassData().runSyntax(c, input);
                 if (found) {
                     components.push({ name: found.getName(), type: found.getType() });
                     values[found.getName()] = found.getValue();
@@ -23,7 +23,7 @@ class ClassData {
             }
             // todo, nested structures and INCLUDES
         }
-        return new _typed_identifier_1.TypedIdentifier(name, filename, new Basic.StructureType(components), ["static" /* IdentifierMeta.Static */], values);
+        return new _typed_identifier_1.TypedIdentifier(name, input.filename, new Basic.StructureType(components), ["static" /* IdentifierMeta.Static */], values);
     }
 }
 exports.ClassData = ClassData;

package/build/src/abap/5_syntax/structures/constants.js

@@ -8,26 +8,27 @@ const nodes_1 = require("../../nodes");
 const _typed_identifier_1 = require("../../types/_typed_identifier");
 const Basic = require("../../types/basic");
 const constant_1 = require("../statements/constant");
+const assert_error_1 = require("../assert_error");
 class Constants {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         var _a;
         const name = (_a = node.findFirstExpression(Expressions.DefinitionName)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
         if (name === undefined) {
-            throw new Error("Constants, structure, unexpected node");
+            throw new assert_error_1.AssertError("Constants, structure, unexpected node");
         }
         const components = [];
         const values = {};
         for (const c of node.getChildren()) {
             const ctyp = c.get();
             if (c instanceof nodes_1.StatementNode && ctyp instanceof Statements.Constant) {
-                const found = new constant_1.Constant().runSyntax(c, scope, filename);
+                const found = new constant_1.Constant().runSyntax(c, input);
                 if (found) {
                     components.push({ name: found.getName(), type: found.getType() });
                     values[found.getName()] = found.getValue();
                 }
             }
             else if (c instanceof nodes_1.StructureNode && ctyp instanceof Structures.Constants) {
-                const { type: found, values: val } = new Constants().runSyntax(c, scope, filename);
+                const { type: found, values: val } = new Constants().runSyntax(c, input);
                 if (found) {
                     components.push({ name: found.getName(), type: found.getType() });
                     values[found.getName()] = val;
@@ -37,7 +38,7 @@ class Constants {
         if (components.length === 0) {
             return { type: undefined, values };
         }
-        const type = new _typed_identifier_1.TypedIdentifier(name, filename, new Basic.StructureType(components), ["read_only" /* IdentifierMeta.ReadOnly */, "static" /* IdentifierMeta.Static */]);
+        const type = new _typed_identifier_1.TypedIdentifier(name, input.filename, new Basic.StructureType(components), ["read_only" /* IdentifierMeta.ReadOnly */, "static" /* IdentifierMeta.Static */]);
         return { type, values };
     }
 }

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

@@ -9,8 +9,9 @@ const _typed_identifier_1 = require("../../types/_typed_identifier");
 const Basic = require("../../types/basic");
 const data_1 = require("../statements/data");
 const _reference_1 = require("../_reference");
+const _syntax_input_1 = require("../_syntax_input");
 class Data {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         var _a;
         const name = node.findFirstExpression(Expressions.DefinitionName).getFirstToken();
         let table = false;
@@ -19,7 +20,7 @@ class Data {
         for (const c of node.getChildren()) {
             const ctyp = c.get();
             if (c instanceof nodes_1.StatementNode && ctyp instanceof Statements.Data) {
-                const found = new data_1.Data().runSyntax(c, scope, filename);
+                const found = new data_1.Data().runSyntax(c, input);
                 if (found) {
                     components.push({ name: found.getName(), type: found.getType() });
                     if (found.getValue() !== undefined) {
@@ -28,7 +29,7 @@ class Data {
                 }
             }
             else if (c instanceof nodes_1.StructureNode && ctyp instanceof Structures.Data) {
-                const found = new Data().runSyntax(c, scope, filename);
+                const found = new Data().runSyntax(c, input);
                 if (found) {
                     components.push({ name: found.getName(), type: found.getType() });
                 }
@@ -42,13 +43,13 @@ class Data {
                 // INCLUDES
                 const typeToken = (_a = c.findFirstExpression(Expressions.TypeName)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
                 const typeName = typeToken === null || typeToken === void 0 ? void 0 : typeToken.getStr();
-                let foundId = scope.findType(typeName);
+                let foundId = input.scope.findType(typeName);
                 if (foundId === undefined) {
-                    foundId = scope.findVariable(typeName);
+                    foundId = input.scope.findVariable(typeName);
                 }
                 let found = foundId === null || foundId === void 0 ? void 0 : foundId.getType();
                 if (found === undefined) {
-                    const f = scope.getDDIC().lookupTableOrView(typeName).type;
+                    const f = input.scope.getDDIC().lookupTableOrView(typeName).type;
                     if (f instanceof _typed_identifier_1.TypedIdentifier) {
                         found = f.getType();
                     }
@@ -57,21 +58,24 @@ class Data {
                     }
                 }
                 else {
-                    scope.addReference(typeToken, foundId, _reference_1.ReferenceType.TypeReference, filename);
+                    input.scope.addReference(typeToken, foundId, _reference_1.ReferenceType.TypeReference, input.filename);
                 }
                 if (found instanceof Basic.VoidType) {
                     if (table === true) {
-                        return new _typed_identifier_1.TypedIdentifier(name, filename, new Basic.TableType(found, { withHeader: true, keyType: Basic.TableKeyType.default }));
+                        const ttyp = new Basic.TableType(found, { withHeader: true, keyType: Basic.TableKeyType.default });
+                        return new _typed_identifier_1.TypedIdentifier(name, input.filename, ttyp);
                     }
                     else {
-                        return new _typed_identifier_1.TypedIdentifier(name, filename, found);
+                        return new _typed_identifier_1.TypedIdentifier(name, input.filename, found);
                     }
                 }
                 if (found instanceof Basic.UnknownType) {
-                    return new _typed_identifier_1.TypedIdentifier(name, filename, new Basic.UnknownType("unknown type, " + typeName));
+                    return new _typed_identifier_1.TypedIdentifier(name, input.filename, new Basic.UnknownType("unknown type, " + typeName));
                 }
                 if (!(found instanceof Basic.StructureType)) {
-                    throw new Error("not structured, " + typeName);
+                    const message = "not structured, " + typeName;
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return new _typed_identifier_1.TypedIdentifier(name, input.filename, new Basic.VoidType(_syntax_input_1.CheckSyntaxKey));
                 }
                 for (const c of found.getComponents()) {
                     components.push(c);
@@ -79,11 +83,11 @@ class Data {
             }
         }
         if (table === true) {
-            return new _typed_identifier_1.TypedIdentifier(name, filename, new Basic.TableType(new Basic.StructureType(components), { withHeader: true, keyType: Basic.TableKeyType.default }));
+            return new _typed_identifier_1.TypedIdentifier(name, input.filename, new Basic.TableType(new Basic.StructureType(components), { withHeader: true, keyType: Basic.TableKeyType.default }));
         }
         else {
             const val = Object.keys(values).length > 0 ? values : undefined;
-            return new _typed_identifier_1.TypedIdentifier(name, filename, new Basic.StructureType(components), undefined, val);
+            return new _typed_identifier_1.TypedIdentifier(name, input.filename, new Basic.StructureType(components), undefined, val);
         }
     }
 }