@abaplint/core 2.111.1 → 2.112.0

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

@@ -8,17 +8,20 @@ const _object_oriented_1 = require("../_object_oriented");
 const data_reference_type_1 = require("../../types/basic/data_reference_type");
 const _reference_1 = require("../_reference");
 const basic_1 = require("../../types/basic");
+const _syntax_input_1 = require("../_syntax_input");
 class AttributeName {
-    runSyntax(context, node, scope, filename, type) {
+    runSyntax(context, node, input, type, error = true) {
         if (context instanceof void_type_1.VoidType) {
             return context;
         }
-        const helper = new _object_oriented_1.ObjectOriented(scope);
+        const helper = new _object_oriented_1.ObjectOriented(input.scope);
         let ret = undefined;
         if (context instanceof object_reference_type_1.ObjectReferenceType) {
-            const def = scope.findObjectDefinition(context.getIdentifierName());
+            const def = input.scope.findObjectDefinition(context.getIdentifierName());
             if (def === undefined) {
-                throw new Error("Definition for \"" + context.getIdentifierName() + "\" not found in scope(AttributeName)");
+                const message = "Definition for \"" + context.getIdentifierName() + "\" not found in scope(AttributeName)";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return new void_type_1.VoidType(_syntax_input_1.CheckSyntaxKey);
             }
             const token = node.getFirstToken();
             const name = token.getStr();
@@ -27,15 +30,19 @@ class AttributeName {
                 found = helper.searchConstantName(def, name);
             }
             if (found === undefined) {
-                throw new Error("Attribute or constant \"" + name + "\" not found in \"" + def.getName() + "\"");
+                const message = "Attribute or constant \"" + name + "\" not found in \"" + def.getName() + "\"";
+                if (error === true) {
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                }
+                return new void_type_1.VoidType(_syntax_input_1.CheckSyntaxKey);
             }
             if (type) {
-                scope.addReference(token, found, type, filename);
+                input.scope.addReference(token, found, type, input.filename);
             }
             if (found && name.includes("~")) {
-                const idef = scope.findInterfaceDefinition(name.split("~")[0]);
+                const idef = input.scope.findInterfaceDefinition(name.split("~")[0]);
                 if (idef) {
-                    scope.addReference(token, idef, _reference_1.ReferenceType.ObjectOrientedReference, filename);
+                    input.scope.addReference(token, idef, _reference_1.ReferenceType.ObjectOrientedReference, input.filename);
                 }
             }
             ret = found.getType();
@@ -47,15 +54,21 @@ class AttributeName {
                 return sub;
             }
             if (!(sub instanceof structure_type_1.StructureType)) {
-                throw new Error("Data reference not structured");
+                const message = "Data reference not structured";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return new void_type_1.VoidType(_syntax_input_1.CheckSyntaxKey);
             }
             ret = sub.getComponentByName(name);
             if (ret === undefined) {
-                throw new Error("Component \"" + name + "\" not found in data reference structure");
+                const message = "Component \"" + name + "\" not found in data reference structure";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return new void_type_1.VoidType(_syntax_input_1.CheckSyntaxKey);
             }
         }
         else {
-            throw new Error("Not an object reference, attribute name");
+            const message = "Not an object reference, attribute name";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return new void_type_1.VoidType(_syntax_input_1.CheckSyntaxKey);
         }
         return ret;
     }

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

@@ -7,39 +7,46 @@ const source_1 = require("./source");
 const _type_utils_1 = require("../_type_utils");
 const basic_types_1 = require("../basic_types");
 const _reference_1 = require("../_reference");
+const _syntax_input_1 = require("../_syntax_input");
 class Cast {
-    runSyntax(node, scope, targetType, filename) {
+    runSyntax(node, input, targetType) {
         const sourceNode = node.findDirectExpression(Expressions.Source);
         if (sourceNode === undefined) {
-            throw new Error("Cast, source node not found");
+            const message = "Cast, source node not found";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
         }
-        const sourceType = new source_1.Source().runSyntax(sourceNode, scope, filename);
+        const sourceType = new source_1.Source().runSyntax(sourceNode, input);
         let tt = undefined;
         const typeExpression = node.findDirectExpression(Expressions.TypeNameOrInfer);
         const typeName = typeExpression === null || typeExpression === void 0 ? void 0 : typeExpression.concatTokens();
         if (typeName === undefined) {
-            throw new Error("Cast, child TypeNameOrInfer not found");
+            const message = "Cast, child TypeNameOrInfer not found";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
         }
         else if (typeName === "#" && targetType) {
             tt = targetType;
         }
         else if (typeName === "#") {
-            throw new Error("Cast, todo, infer type");
+            const message = "Cast, todo, infer type";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
         }
         if (tt === undefined && typeExpression) {
-            const basic = new basic_types_1.BasicTypes(filename, scope);
+            const basic = new basic_types_1.BasicTypes(input);
             tt = basic.parseType(typeExpression);
             if (tt === undefined || tt instanceof basic_1.VoidType || tt instanceof basic_1.UnknownType) {
-                const found = scope.findObjectDefinition(typeName);
+                const found = input.scope.findObjectDefinition(typeName);
                 if (found) {
                     tt = new basic_1.ObjectReferenceType(found, { qualifiedName: typeName });
-                    scope.addReference(typeExpression.getFirstToken(), found, _reference_1.ReferenceType.ObjectOrientedReference, filename);
+                    input.scope.addReference(typeExpression.getFirstToken(), found, _reference_1.ReferenceType.ObjectOrientedReference, input.filename);
                 }
             }
             else {
                 tt = new basic_1.DataReference(tt, typeName);
             }
-            if (tt === undefined && scope.getDDIC().inErrorNamespace(typeName) === false) {
+            if (tt === undefined && input.scope.getDDIC().inErrorNamespace(typeName) === false) {
                 tt = new basic_1.VoidType(typeName);
             }
             else if (typeName.toUpperCase() === "OBJECT") {
@@ -47,12 +54,16 @@ class Cast {
             }
             else if (tt === undefined) {
                 // todo, this should be an UnknownType instead?
-                throw new Error("Type \"" + typeName + "\" not found in scope, Cast");
+                const message = "Type \"" + typeName + "\" not found in scope, Cast";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
             }
         }
-        new source_1.Source().addIfInferred(node, scope, filename, tt);
-        if (new _type_utils_1.TypeUtils(scope).isCastable(sourceType, tt) === false) {
-            throw new Error("Cast, incompatible types");
+        new source_1.Source().addIfInferred(node, input, tt);
+        if (new _type_utils_1.TypeUtils(input.scope).isCastable(sourceType, tt) === false) {
+            const message = "Cast, incompatible types";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
         }
         return tt;
     }

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

@@ -6,15 +6,15 @@ const source_1 = require("./source");
 const method_call_chain_1 = require("./method_call_chain");
 const source_field_symbol_1 = require("./source_field_symbol");
 class Compare {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         for (const t of node.findDirectExpressions(Expressions.Source)) {
-            new source_1.Source().runSyntax(t, scope, filename);
+            new source_1.Source().runSyntax(t, input);
         }
         for (const t of node.findDirectExpressions(Expressions.SourceFieldSymbol)) {
-            new source_field_symbol_1.SourceFieldSymbol().runSyntax(t, scope, filename);
+            new source_field_symbol_1.SourceFieldSymbol().runSyntax(t, input);
         }
         for (const t of node.findDirectExpressions(Expressions.MethodCallChain)) {
-            new method_call_chain_1.MethodCallChain().runSyntax(t, scope, filename);
+            new method_call_chain_1.MethodCallChain().runSyntax(t, input);
         }
     }
 }

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

@@ -8,8 +8,9 @@ const basic_1 = require("../../types/basic");
 const types_1 = require("../../types");
 const _reference_1 = require("../_reference");
 const _object_oriented_1 = require("../_object_oriented");
+const _syntax_input_1 = require("../_syntax_input");
 class ComponentChain {
-    runSyntax(context, node, scope, filename) {
+    runSyntax(context, node, input) {
         if (context === undefined) {
             return undefined;
         }
@@ -26,17 +27,23 @@ class ComponentChain {
                 const concat = child.concatTokens();
                 if (concat === "-") {
                     if (!(context instanceof structure_type_1.StructureType)) {
-                        throw new Error("ComponentChain, not a structure");
+                        const message = "ComponentChain, not a structure";
+                        input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                        return new void_type_1.VoidType(_syntax_input_1.CheckSyntaxKey);
                     }
                 }
                 else if (concat === "=>") {
                     if (!(context instanceof basic_1.ObjectReferenceType)) {
-                        throw new Error("ComponentChain, not a reference");
+                        const message = "ComponentChain, not a reference";
+                        input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                        return new void_type_1.VoidType(_syntax_input_1.CheckSyntaxKey);
                     }
                 }
                 else if (concat === "->") {
                     if (!(context instanceof basic_1.ObjectReferenceType) && !(context instanceof basic_1.DataReference)) {
-                        throw new Error("ComponentChain, not a reference");
+                        const message = "ComponentChain, not a reference";
+                        input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                        return new void_type_1.VoidType(_syntax_input_1.CheckSyntaxKey);
                     }
                 }
             }
@@ -51,31 +58,39 @@ class ComponentChain {
                 if (context instanceof structure_type_1.StructureType) {
                     context = context.getComponentByName(name);
                     if (context === undefined) {
-                        throw new Error("Component \"" + name + "\" not found in structure");
+                        const message = "Component \"" + name + "\" not found in structure";
+                        input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                        return new void_type_1.VoidType(_syntax_input_1.CheckSyntaxKey);
                     }
                 }
                 else if (context instanceof basic_1.ObjectReferenceType) {
                     const id = context.getIdentifier();
-                    const def = scope.findObjectDefinition(id.getName());
+                    const def = input.scope.findObjectDefinition(id.getName());
                     if (def === undefined) {
-                        throw new Error(id.getName() + " not found in scope");
+                        const message = id.getName() + " not found in scope";
+                        input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                        return new void_type_1.VoidType(_syntax_input_1.CheckSyntaxKey);
                     }
-                    const helper = new _object_oriented_1.ObjectOriented(scope);
+                    const helper = new _object_oriented_1.ObjectOriented(input.scope);
                     const found = helper.searchAttributeName(def, name);
                     context = found === null || found === void 0 ? void 0 : found.getType();
                     if (context === undefined) {
-                        throw new Error("Attribute \"" + name + "\" not found");
+                        const message = "Attribute \"" + name + "\" not found";
+                        input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                        return new void_type_1.VoidType(_syntax_input_1.CheckSyntaxKey);
                     }
                     else {
                         const extra = {
                             ooName: id.getName(),
                             ooType: id instanceof types_1.ClassDefinition ? "CLAS" : "INTF"
                         };
-                        scope.addReference(child.getFirstToken(), found, _reference_1.ReferenceType.DataWriteReference, filename, extra);
+                        input.scope.addReference(child.getFirstToken(), found, _reference_1.ReferenceType.DataWriteReference, input.filename, extra);
                     }
                 }
                 else {
-                    throw new Error("ComponentChain, not a structure, " + (context === null || context === void 0 ? void 0 : context.constructor.name));
+                    const message = "ComponentChain, not a structure, " + (context === null || context === void 0 ? void 0 : context.constructor.name);
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return new void_type_1.VoidType(_syntax_input_1.CheckSyntaxKey);
                 }
             }
         }

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

@@ -2,17 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ComponentCompare = void 0;
 const Expressions = require("../../2_statements/expressions");
+const _syntax_input_1 = require("../_syntax_input");
 const component_chain_1 = require("./component_chain");
 const source_1 = require("./source");
 class ComponentCompare {
-    runSyntax(node, scope, filename, type) {
+    runSyntax(node, input, type) {
         const chain = node.findDirectExpression(Expressions.ComponentChainSimple);
         if (chain === undefined) {
-            throw new Error("ComponentCompare, chain not found");
+            const message = "ComponentCompare, chain not found";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
-        new component_chain_1.ComponentChain().runSyntax(type, chain, scope, filename);
+        new component_chain_1.ComponentChain().runSyntax(type, chain, 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/expressions/component_compare_simple.js

@@ -3,28 +3,33 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ComponentCompareSimple = void 0;
 const Expressions = require("../../2_statements/expressions");
 const nodes_1 = require("../../nodes");
+const _syntax_input_1 = require("../_syntax_input");
 const _type_utils_1 = require("../_type_utils");
 const component_chain_1 = require("./component_chain");
 const source_1 = require("./source");
 class ComponentCompareSimple {
-    runSyntax(node, scope, filename, rowType) {
+    runSyntax(node, input, rowType) {
         let targetType = undefined;
         for (const c of node.getChildren()) {
             if (c instanceof nodes_1.ExpressionNode) {
                 if (c.get() instanceof Expressions.ComponentChainSimple) {
-                    targetType = new component_chain_1.ComponentChain().runSyntax(rowType, c, scope, filename);
+                    targetType = new component_chain_1.ComponentChain().runSyntax(rowType, c, input);
                 }
                 else if (c.get() instanceof Expressions.Dynamic) {
                     targetType = undefined;
                 }
                 else if (c.get() instanceof Expressions.Source) {
-                    const sourceType = new source_1.Source().runSyntax(c, scope, filename, targetType);
-                    if (targetType && new _type_utils_1.TypeUtils(scope).isAssignable(sourceType, targetType) === false) {
-                        throw new Error("ComponentCompareSimple, incompatible types");
+                    const sourceType = new source_1.Source().runSyntax(c, input, targetType);
+                    if (targetType && new _type_utils_1.TypeUtils(input.scope).isAssignable(sourceType, targetType) === false) {
+                        const message = "ComponentCompareSimple, incompatible types";
+                        input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                        return;
                     }
                 }
                 else {
-                    throw new Error("ComponentCompareSimple, unexpected node");
+                    const message = "ComponentCompareSimple, unexpected node";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return;
                 }
             }
         }

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

@@ -4,15 +4,15 @@ exports.ComponentCond = void 0;
 const Expressions = require("../../2_statements/expressions");
 const component_compare_1 = require("./component_compare");
 class ComponentCond {
-    runSyntax(node, scope, filename, type) {
+    runSyntax(node, input, type) {
         for (const t of node.findDirectExpressions(Expressions.ComponentCondSub)) {
             const c = t.findDirectExpression(Expressions.ComponentCond);
             if (c) {
-                new ComponentCond().runSyntax(c, scope, filename, type);
+                new ComponentCond().runSyntax(c, input, type);
             }
         }
         for (const t of node.findDirectExpressions(Expressions.ComponentCompare)) {
-            new component_compare_1.ComponentCompare().runSyntax(t, scope, filename, type);
+            new component_compare_1.ComponentCompare().runSyntax(t, input, type);
         }
     }
 }

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

@@ -2,16 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ComponentName = void 0;
 const Basic = require("../../types/basic");
+const _syntax_input_1 = require("../_syntax_input");
 class ComponentName {
-    runSyntax(context, node) {
+    runSyntax(context, node, input) {
         if (context instanceof Basic.VoidType) {
             return context;
         }
-        const name = node.getFirstToken().getStr();
+        const nameToken = node.getFirstToken();
+        const name = nameToken.getStr();
         if (context instanceof Basic.StructureType) {
             const ret = context.getComponentByName(name);
             if (ret === undefined) {
-                throw new Error("Component \"" + name + "\" not found in structure");
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, nameToken, "Component \"" + name + "\" not found in structure"));
+                return new Basic.VoidType(_syntax_input_1.CheckSyntaxKey);
             }
             return ret;
         }
@@ -26,12 +29,14 @@ class ComponentName {
             else if (rowType instanceof Basic.StructureType) {
                 const ret = rowType.getComponentByName(name);
                 if (ret === undefined) {
-                    throw new Error("Component \"" + name + "\" not found in structure");
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, nameToken, "Component \"" + name + "\" not found in structure"));
+                    return new Basic.VoidType(_syntax_input_1.CheckSyntaxKey);
                 }
                 return ret;
             }
         }
-        throw new Error("Not a structure, ComponentName, \"" + name + "\"");
+        input.issues.push((0, _syntax_input_1.syntaxIssue)(input, nameToken, "Not a structure, ComponentName, \"" + name + "\""));
+        return new Basic.VoidType(_syntax_input_1.CheckSyntaxKey);
     }
 }
 exports.ComponentName = ComponentName;

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

@@ -4,18 +4,15 @@ exports.Cond = void 0;
 const Expressions = require("../../2_statements/expressions");
 const compare_1 = require("./compare");
 class Cond {
-    runSyntax(node, scope, filename) {
-        if (node === undefined) {
-            throw new Error("Cond, expected node input");
-        }
+    runSyntax(node, input) {
         for (const t of node.findDirectExpressions(Expressions.CondSub)) {
             const c = t.findDirectExpression(Expressions.Cond);
             if (c) {
-                new Cond().runSyntax(c, scope, filename);
+                new Cond().runSyntax(c, input);
             }
         }
         for (const t of node.findDirectExpressions(Expressions.Compare)) {
-            new compare_1.Compare().runSyntax(t, scope, filename);
+            new compare_1.Compare().runSyntax(t, input);
         }
     }
 }

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

@@ -6,29 +6,29 @@ const source_1 = require("./source");
 const let_1 = require("./let");
 const cond_1 = require("./cond");
 class CondBody {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         if (node === undefined) {
             return undefined;
         }
         let scoped = false;
         const l = node.findDirectExpression(Expressions.Let);
         if (l) {
-            scoped = new let_1.Let().runSyntax(l, scope, filename);
+            scoped = new let_1.Let().runSyntax(l, input);
         }
         for (const s of node.findDirectExpressions(Expressions.Cond)) {
-            new cond_1.Cond().runSyntax(s, scope, filename);
+            new cond_1.Cond().runSyntax(s, input);
         }
         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);
             }
         }
         if (scoped === true) {
-            scope.pop(node.getLastToken().getEnd());
+            input.scope.pop(node.getLastToken().getEnd());
         }
         return type;
     }

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

@@ -4,23 +4,24 @@ exports.ConvBody = void 0;
 const Expressions = require("../../2_statements/expressions");
 const source_1 = require("./source");
 const let_1 = require("./let");
+const _syntax_input_1 = require("../_syntax_input");
+const basic_1 = require("../../types/basic");
 class ConvBody {
-    runSyntax(node, scope, filename) {
-        if (node === undefined) {
-            throw new Error("ConvBody, node undefined");
-        }
+    runSyntax(node, input) {
         let scoped = false;
         const l = node.findDirectExpression(Expressions.Let);
         if (l) {
-            scoped = new let_1.Let().runSyntax(l, scope, filename);
+            scoped = new let_1.Let().runSyntax(l, input);
         }
         const s = node.findDirectExpression(Expressions.Source);
         if (s === undefined) {
-            throw new Error("ConvBody, no source found");
+            const message = "ConvBody, no source found";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
         }
-        const sourceType = new source_1.Source().runSyntax(s, scope, filename);
+        const sourceType = new source_1.Source().runSyntax(s, input);
         if (scoped === true) {
-            scope.pop(node.getLastToken().getEnd());
+            input.scope.pop(node.getLastToken().getEnd());
         }
         return sourceType;
     }

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

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

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

@@ -7,25 +7,25 @@ const basic_1 = require("../../types/basic");
 const basic_types_1 = require("../basic_types");
 const type_table_1 = require("./type_table");
 class DataDefinition {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const tt = node.findFirstExpression(Expressions.TypeTable);
         if (tt) {
-            return new type_table_1.TypeTable().runSyntax(node, scope, filename);
+            return new type_table_1.TypeTable().runSyntax(node, input);
         }
         const valueNode = node.findFirstExpression(Expressions.Value);
         let value = undefined;
         if (valueNode) {
-            value = new basic_types_1.BasicTypes(filename, scope).findValue(node);
+            value = new basic_types_1.BasicTypes(input).findValue(node);
         }
         const name = node.findFirstExpression(Expressions.DefinitionName);
         const typeStructure = node.findFirstExpression(Expressions.TypeStructure);
         if (typeStructure && name) {
-            return new _typed_identifier_1.TypedIdentifier(name.getFirstToken(), filename, new basic_1.VoidType("DataDefinition, TypeStructure"));
+            return new _typed_identifier_1.TypedIdentifier(name.getFirstToken(), input.filename, new basic_1.VoidType("DataDefinition, TypeStructure"));
         }
-        const bfound = new basic_types_1.BasicTypes(filename, scope).simpleType(node);
+        const bfound = new basic_types_1.BasicTypes(input).simpleType(node);
         if (bfound) {
             if (value) {
-                return new _typed_identifier_1.TypedIdentifier(bfound.getToken(), filename, bfound.getType(), bfound.getMeta(), value);
+                return new _typed_identifier_1.TypedIdentifier(bfound.getToken(), input.filename, bfound.getType(), bfound.getMeta(), value);
             }
             else {
                 return bfound;
@@ -33,7 +33,7 @@ class DataDefinition {
         }
         if (name) {
             console.dir("undef");
-            return new _typed_identifier_1.TypedIdentifier(name.getFirstToken(), filename, new basic_1.UnknownType("DataDefinition, fallback"));
+            return new _typed_identifier_1.TypedIdentifier(name.getFirstToken(), input.filename, new basic_1.UnknownType("DataDefinition, fallback"));
         }
         return undefined;
     }

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

@@ -2,24 +2,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DatabaseTable = void 0;
 const _reference_1 = require("../_reference");
+const _syntax_input_1 = require("../_syntax_input");
 class DatabaseTable {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const token = node.getFirstToken();
         const name = token.getStr();
         if (name === "(") {
             // dynamic
             return undefined;
         }
-        const found = scope.getDDIC().lookupTableOrView2(name);
-        if (found === undefined && scope.getDDIC().inErrorNamespace(name) === true) {
-            throw new Error("Database table or view \"" + name + "\" not found");
+        const found = input.scope.getDDIC().lookupTableOrView2(name);
+        if (found === undefined && input.scope.getDDIC().inErrorNamespace(name) === true) {
+            const message = "Database table or view \"" + name + "\" not found";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
         }
         else if (found === undefined) {
-            scope.addReference(token, undefined, _reference_1.ReferenceType.TableVoidReference, filename);
+            input.scope.addReference(token, undefined, _reference_1.ReferenceType.TableVoidReference, input.filename);
         }
         else {
-            scope.addReference(token, found.getIdentifier(), _reference_1.ReferenceType.TableReference, filename);
-            scope.getDDICReferences().addUsing(scope.getParentObj(), { object: found, token: token, filename: filename });
+            input.scope.addReference(token, found.getIdentifier(), _reference_1.ReferenceType.TableReference, input.filename);
+            input.scope.getDDICReferences().addUsing(input.scope.getParentObj(), { object: found, token: token, filename: input.filename });
         }
         return found;
     }

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

@@ -6,10 +6,10 @@ const field_chain_1 = require("./field_chain");
 const _reference_1 = require("../_reference");
 const constant_1 = require("./constant");
 class Default {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const chain = node.findDirectExpression(Expressions.FieldChain);
         if (chain) {
-            return new field_chain_1.FieldChain().runSyntax(chain, scope, filename, _reference_1.ReferenceType.DataReadReference);
+            return new field_chain_1.FieldChain().runSyntax(chain, input, _reference_1.ReferenceType.DataReadReference);
         }
         const constant = node.findDirectExpression(Expressions.Constant);
         if (constant) {

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

@@ -2,8 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Dereference = void 0;
 const basic_1 = require("../../types/basic");
+const _syntax_input_1 = require("../_syntax_input");
 class Dereference {
-    runSyntax(type) {
+    runSyntax(node, type, input) {
         if (type instanceof basic_1.VoidType
             || type instanceof basic_1.AnyType
             || type instanceof basic_1.DataType
@@ -12,7 +13,9 @@ class Dereference {
             return type;
         }
         if (!(type instanceof basic_1.DataReference)) {
-            throw new Error("Not a data reference, cannot be dereferenced");
+            const message = "Not a data reference, cannot be dereferenced";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
         }
         return type.getType();
     }

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

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