@abaplint/core 2.111.1 → 2.112.1

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

@@ -10,49 +10,49 @@ const reduce_next_1 = require("./reduce_next");
 const let_1 = require("./let");
 const _scope_type_1 = require("../_scope_type");
 class ReduceBody {
-    runSyntax(node, scope, filename, targetType) {
+    runSyntax(node, input, targetType) {
         if (node === undefined) {
             return;
         }
         let scoped = false;
         const letNode = node.findDirectExpression(Expressions.Let);
         if (letNode) {
-            scoped = new let_1.Let().runSyntax(letNode, scope, filename);
+            scoped = new let_1.Let().runSyntax(letNode, input);
         }
         let first = undefined;
         for (const i of node.findDirectExpressions(Expressions.InlineFieldDefinition)) {
             if (scoped === false) {
-                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);
                 scoped = true;
             }
             let foundType = targetType;
             const source = i.findDirectExpression(Expressions.Source);
             if (source) {
-                foundType = new source_1.Source().runSyntax(source, scope, filename, targetType);
+                foundType = new source_1.Source().runSyntax(source, input, targetType);
             }
-            const found = new inline_field_definition_1.InlineFieldDefinition().runSyntax(i, scope, filename, foundType);
+            const found = new inline_field_definition_1.InlineFieldDefinition().runSyntax(i, input, foundType);
             if (found && first === undefined) {
                 first = found;
             }
         }
         let forScopes = 0;
         for (const forNode of node.findDirectExpressions(Expressions.For) || []) {
-            const scoped = new for_1.For().runSyntax(forNode, scope, filename);
+            const scoped = new for_1.For().runSyntax(forNode, input);
             if (scoped === true) {
                 forScopes++;
             }
         }
         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.ReduceNext)) {
-            new reduce_next_1.ReduceNext().runSyntax(s, scope, filename);
+            new reduce_next_1.ReduceNext().runSyntax(s, input);
         }
         if (scoped === true) {
-            scope.pop(node.getLastToken().getEnd());
+            input.scope.pop(node.getLastToken().getEnd());
         }
         for (let i = 0; i < forScopes; i++) {
-            scope.pop(node.getLastToken().getEnd());
+            input.scope.pop(node.getLastToken().getEnd());
         }
         if (first) {
             return first;

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

@@ -5,15 +5,15 @@ const Expressions = require("../../2_statements/expressions");
 const source_1 = require("./source");
 const target_1 = require("./target");
 class ReduceNext {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         if (node === undefined) {
             return;
         }
         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.SimpleTarget)) {
-            new target_1.Target().runSyntax(s, scope, filename);
+            new target_1.Target().runSyntax(s, input);
         }
     }
 }

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

@@ -13,30 +13,35 @@ const sql_compare_1 = require("./sql_compare");
 const sql_order_by_1 = require("./sql_order_by");
 const dynamic_1 = require("./dynamic");
 const _reference_1 = require("../_reference");
+const _syntax_input_1 = require("../_syntax_input");
 const isSimple = /^\w+$/;
 class Select {
-    runSyntax(node, scope, filename, skipImplicitInto = false) {
+    runSyntax(node, input, skipImplicitInto = false) {
         var _a;
         const token = node.getFirstToken();
         const from = node.findDirectExpression(Expressions.SQLFrom);
-        const dbSources = from ? new sql_from_1.SQLFrom().runSyntax(from, scope, filename) : [];
+        const dbSources = from ? new sql_from_1.SQLFrom().runSyntax(from, input) : [];
         if (from === undefined) {
-            throw new Error(`Missing FROM`);
+            const message = `Missing FROM`;
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
-        const fields = this.findFields(node, scope, filename);
+        const fields = this.findFields(node, input);
         if (fields.length === 0
             && node.findDirectExpression(Expressions.SQLFieldListLoop) === undefined) {
-            throw new Error(`fields missing`);
+            const message = `fields missing`;
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
-        this.checkFields(fields, dbSources, scope);
-        this.handleInto(node, scope, filename, fields, dbSources);
+        this.checkFields(fields, dbSources, input, node);
+        this.handleInto(node, input, fields, dbSources);
         const fae = node.findDirectExpression(Expressions.SQLForAllEntries);
         if (fae) {
-            scope.push(_scope_type_1.ScopeType.OpenSQL, "SELECT", token.getStart(), filename);
-            new sql_for_all_entries_1.SQLForAllEntries().runSyntax(fae, scope, filename);
+            input.scope.push(_scope_type_1.ScopeType.OpenSQL, "SELECT", token.getStart(), input.filename);
+            new sql_for_all_entries_1.SQLForAllEntries().runSyntax(fae, input);
         }
         for (const t of node.findAllExpressions(Expressions.Target)) {
-            new target_1.Target().runSyntax(t, scope, filename);
+            new target_1.Target().runSyntax(t, input);
         }
         // check implicit into, the target field is implict equal to the table name
         if (skipImplicitInto === false
@@ -48,53 +53,55 @@ class Select {
             if (fields === undefined || c.test(fields) === false) {
                 const nameToken = from === null || from === void 0 ? void 0 : from.findDirectExpression(Expressions.SQLFromSource);
                 if (nameToken) {
-                    const found = scope.findVariable(nameToken.concatTokens());
+                    const found = input.scope.findVariable(nameToken.concatTokens());
                     if (found) {
-                        scope.addReference(nameToken.getFirstToken(), found, _reference_1.ReferenceType.DataWriteReference, filename);
+                        input.scope.addReference(nameToken.getFirstToken(), found, _reference_1.ReferenceType.DataWriteReference, input.filename);
                     }
                     else {
-                        throw new Error(`Target variable ${nameToken.concatTokens()} not found in scope`);
+                        const message = `Target variable ${nameToken.concatTokens()} not found in scope`;
+                        input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                        return;
                     }
                 }
             }
         }
         // OFFSET
         for (const s of node.findDirectExpressions(Expressions.SQLSource)) {
-            new sql_source_1.SQLSource().runSyntax(s, scope, filename);
+            new sql_source_1.SQLSource().runSyntax(s, input);
         }
         for (const up of node.findDirectExpressions(Expressions.SQLUpTo)) {
             for (const s of up.findDirectExpressions(Expressions.SQLSource)) {
-                new sql_source_1.SQLSource().runSyntax(s, scope, filename);
+                new sql_source_1.SQLSource().runSyntax(s, input);
             }
         }
         for (const fae of node.findDirectExpressions(Expressions.SQLForAllEntries)) {
             for (const s of fae.findDirectExpressions(Expressions.SQLSource)) {
-                new sql_source_1.SQLSource().runSyntax(s, scope, filename);
+                new sql_source_1.SQLSource().runSyntax(s, input);
             }
         }
         for (const s of node.findAllExpressions(Expressions.SQLCompare)) {
-            new sql_compare_1.SQLCompare().runSyntax(s, scope, filename, dbSources);
+            new sql_compare_1.SQLCompare().runSyntax(s, input, dbSources);
         }
         for (const s of node.findDirectExpressions(Expressions.SQLOrderBy)) {
-            new sql_order_by_1.SQLOrderBy().runSyntax(s, scope, filename);
+            new sql_order_by_1.SQLOrderBy().runSyntax(s, 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());
         }
     }
-    handleInto(node, scope, filename, fields, dbSources) {
+    handleInto(node, input, fields, dbSources) {
         const intoTable = node.findDirectExpression(Expressions.SQLIntoTable);
         if (intoTable) {
             const inline = intoTable.findFirstExpression(Expressions.InlineData);
             if (inline) {
-                new inline_data_1.InlineData().runSyntax(inline, scope, filename, this.buildTableType(fields, dbSources, scope));
+                new inline_data_1.InlineData().runSyntax(inline, input, this.buildTableType(fields, dbSources, input.scope));
             }
         }
         const intoStructure = node.findDirectExpression(Expressions.SQLIntoStructure);
         if (intoStructure) {
             for (const inline of intoStructure.findAllExpressions(Expressions.InlineData)) {
                 // todo, for now these are voided
-                new inline_data_1.InlineData().runSyntax(inline, scope, filename, new basic_1.VoidType("SELECT_todo"));
+                new inline_data_1.InlineData().runSyntax(inline, input, new basic_1.VoidType("SELECT_todo"));
             }
         }
         const intoList = node.findDirectExpression(Expressions.SQLIntoList);
@@ -102,7 +109,9 @@ class Select {
             const isDynamic = fields.length === 1 && fields[0].expression.findDirectExpression(Expressions.Dynamic) !== undefined;
             const targets = intoList.findDirectExpressions(Expressions.SQLTarget);
             if (targets.length !== fields.length && isDynamic !== true) {
-                throw new Error(`number of fields selected vs list does not match`);
+                const message = `number of fields selected vs list does not match`;
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
             for (let i = 0; i < targets.length; i++) {
                 const target = targets[i];
@@ -110,7 +119,9 @@ class Select {
                 const inline = target.findFirstExpression(Expressions.InlineData);
                 if (inline) {
                     if (isDynamic) {
-                        throw new Error(`dynamic field list, inlining not possible`);
+                        const message = `dynamic field list, inlining not possible`;
+                        input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                        return;
                     }
                     let type = new basic_1.VoidType("SELECT_todo");
                     if (isSimple.test(field.code)) {
@@ -118,7 +129,7 @@ class Select {
                             if (dbSource === undefined) {
                                 continue;
                             }
-                            const dbType = dbSource.parseType(scope.getRegistry());
+                            const dbType = dbSource.parseType(input.scope.getRegistry());
                             if (dbType instanceof basic_1.StructureType) {
                                 const found = dbType.getComponentByName(field.code);
                                 if (found) {
@@ -128,12 +139,12 @@ class Select {
                             }
                         }
                     }
-                    new inline_data_1.InlineData().runSyntax(inline, scope, filename, type);
+                    new inline_data_1.InlineData().runSyntax(inline, input, type);
                 }
             }
         }
     }
-    checkFields(fields, dbSources, scope) {
+    checkFields(fields, dbSources, input, node) {
         if (dbSources.length > 1) {
             return;
         }
@@ -142,19 +153,23 @@ class Select {
             // then its voided
             return;
         }
-        const type = first.parseType(scope.getRegistry());
+        const type = first.parseType(input.scope.getRegistry());
         if (type instanceof basic_1.VoidType || type instanceof basic_1.UnknownType) {
             return;
         }
         if (!(type instanceof basic_1.StructureType)) {
-            throw new Error("checkFields, expected structure, " + type.constructor.name);
+            const message = "checkFields, expected structure, " + type.constructor.name;
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
         for (const field of fields) {
             if (field.code === "*") {
                 continue;
             }
             if (isSimple.test(field.code) && type.getComponentByName(field.code) === undefined) {
-                throw new Error(`checkFields, field ${field.code} not found`);
+                const message = `checkFields, field ${field.code} not found`;
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
         }
     }
@@ -187,7 +202,7 @@ class Select {
         }
         return new basic_1.VoidType("SELECT_todo");
     }
-    findFields(node, scope, filename) {
+    findFields(node, input) {
         var _a, _b;
         let expr = undefined;
         const ret = [];
@@ -196,7 +211,7 @@ class Select {
             expr = node.findDirectExpression(Expressions.SQLFieldListLoop);
         }
         if (((_a = expr === null || expr === void 0 ? void 0 : expr.getFirstChild()) === null || _a === void 0 ? void 0 : _a.get()) instanceof Expressions.Dynamic) {
-            new dynamic_1.Dynamic().runSyntax(expr.getFirstChild(), scope, filename);
+            new dynamic_1.Dynamic().runSyntax(expr.getFirstChild(), input);
         }
         for (const field of (expr === null || expr === void 0 ? void 0 : expr.findDirectExpressionsMulti([Expressions.SQLField, Expressions.SQLFieldName])) || []) {
             let code = field.concatTokens().toUpperCase();

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

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SelectLoop = void 0;
 const select_1 = require("./select");
 class SelectLoop {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         // try using the other Select, they should look very much the same
-        new select_1.Select().runSyntax(node, scope, filename);
+        new select_1.Select().runSyntax(node, input);
     }
 }
 exports.SelectLoop = SelectLoop;

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

@@ -25,6 +25,8 @@ const attribute_chain_1 = require("./attribute_chain");
 const dereference_1 = require("./dereference");
 const _typed_identifier_1 = require("../../types/_typed_identifier");
 const _type_utils_1 = require("../_type_utils");
+const _syntax_input_1 = require("../_syntax_input");
+const assert_error_1 = require("../assert_error");
 /*
 * Type interference, valid scenarios:
 * typed = VALUE #( ... ).         right hand side must follow left hand type
@@ -35,7 +37,7 @@ const _type_utils_1 = require("../_type_utils");
 * DATA(bar) = VALUE #( ... ).     give error, no type can be derived
 */
 class Source {
-    runSyntax(node, scope, filename, targetType, writeReference = false) {
+    runSyntax(node, input, targetType, writeReference = false) {
         if (node === undefined) {
             return undefined;
         }
@@ -53,72 +55,74 @@ class Source {
                 case "BOOLC":
                     {
                         const method = new _builtin_1.BuiltIn().searchBuiltin(tok);
-                        scope.addReference(token, method, _reference_1.ReferenceType.BuiltinMethodReference, filename);
-                        new cond_1.Cond().runSyntax(node.findDirectExpression(Expressions.Cond), scope, filename);
+                        input.scope.addReference(token, method, _reference_1.ReferenceType.BuiltinMethodReference, input.filename);
+                        new cond_1.Cond().runSyntax(node.findDirectExpression(Expressions.Cond), input);
                         return basic_1.StringType.get();
                     }
                 case "XSDBOOL":
                     {
                         const method = new _builtin_1.BuiltIn().searchBuiltin(tok);
-                        scope.addReference(token, method, _reference_1.ReferenceType.BuiltinMethodReference, filename);
-                        new cond_1.Cond().runSyntax(node.findDirectExpression(Expressions.Cond), scope, filename);
+                        input.scope.addReference(token, method, _reference_1.ReferenceType.BuiltinMethodReference, input.filename);
+                        new cond_1.Cond().runSyntax(node.findDirectExpression(Expressions.Cond), input);
                         return new basic_1.CharacterType(1, { qualifiedName: "ABAP_BOOL", ddicName: "ABAP_BOOL" });
                     }
                 case "REDUCE":
                     {
-                        const foundType = this.determineType(node, scope, filename, targetType);
-                        const bodyType = new reduce_body_1.ReduceBody().runSyntax(node.findDirectExpression(Expressions.ReduceBody), scope, filename, foundType);
+                        const foundType = this.determineType(node, input, targetType);
+                        const bodyType = new reduce_body_1.ReduceBody().runSyntax(node.findDirectExpression(Expressions.ReduceBody), input, foundType);
                         if (foundType === undefined || foundType.isGeneric()) {
-                            this.addIfInferred(node, scope, filename, bodyType);
+                            this.addIfInferred(node, input, bodyType);
                         }
                         else {
-                            this.addIfInferred(node, scope, filename, foundType);
+                            this.addIfInferred(node, input, foundType);
                         }
                         return foundType ? foundType : bodyType;
                     }
                 case "SWITCH":
                     {
-                        const foundType = this.determineType(node, scope, filename, targetType);
-                        const bodyType = new switch_body_1.SwitchBody().runSyntax(node.findDirectExpression(Expressions.SwitchBody), scope, filename);
+                        const foundType = this.determineType(node, input, targetType);
+                        const bodyType = new switch_body_1.SwitchBody().runSyntax(node.findDirectExpression(Expressions.SwitchBody), input);
                         if (foundType === undefined || foundType.isGeneric()) {
-                            this.addIfInferred(node, scope, filename, bodyType);
+                            this.addIfInferred(node, input, bodyType);
                         }
                         else {
-                            this.addIfInferred(node, scope, filename, foundType);
+                            this.addIfInferred(node, input, foundType);
                         }
                         return foundType ? foundType : bodyType;
                     }
                 case "COND":
                     {
-                        const foundType = this.determineType(node, scope, filename, targetType);
-                        const bodyType = new cond_body_1.CondBody().runSyntax(node.findDirectExpression(Expressions.CondBody), scope, filename);
+                        const foundType = this.determineType(node, input, targetType);
+                        const bodyType = new cond_body_1.CondBody().runSyntax(node.findDirectExpression(Expressions.CondBody), input);
                         if (foundType === undefined || foundType.isGeneric()) {
-                            this.addIfInferred(node, scope, filename, bodyType);
+                            this.addIfInferred(node, input, bodyType);
                         }
                         else {
-                            this.addIfInferred(node, scope, filename, foundType);
+                            this.addIfInferred(node, input, foundType);
                         }
                         children.shift();
                         children.shift();
                         children.shift();
                         children.shift();
-                        this.traverseRemainingChildren(children, scope, filename);
+                        this.traverseRemainingChildren(children, input);
                         return foundType ? foundType : bodyType;
                     }
                 case "CONV":
                     {
-                        const foundType = this.determineType(node, scope, filename, targetType);
-                        const bodyType = new conv_body_1.ConvBody().runSyntax(node.findDirectExpression(Expressions.ConvBody), scope, filename);
-                        if (new _type_utils_1.TypeUtils(scope).isAssignable(foundType, bodyType) === false) {
-                            throw new Error("CONV: Types not compatible");
+                        const foundType = this.determineType(node, input, targetType);
+                        const bodyType = new conv_body_1.ConvBody().runSyntax(node.findDirectExpression(Expressions.ConvBody), input);
+                        if (new _type_utils_1.TypeUtils(input.scope).isAssignable(foundType, bodyType) === false) {
+                            const message = "CONV: Types not compatible";
+                            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                            return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
                         }
-                        this.addIfInferred(node, scope, filename, foundType);
+                        this.addIfInferred(node, input, foundType);
                         return foundType;
                     }
                 case "REF":
                     {
-                        const foundType = this.determineType(node, scope, filename, targetType);
-                        const s = new Source().runSyntax(node.findDirectExpression(Expressions.Source), scope, filename);
+                        const foundType = this.determineType(node, input, targetType);
+                        const s = new Source().runSyntax(node.findDirectExpression(Expressions.Source), input);
                         if (foundType === undefined && s) {
                             return new basic_1.DataReference(s);
                         }
@@ -128,13 +132,13 @@ class Source {
                     }
                 case "FILTER":
                     {
-                        const foundType = this.determineType(node, scope, filename, targetType);
-                        const bodyType = new filter_body_1.FilterBody().runSyntax(node.findDirectExpression(Expressions.FilterBody), scope, filename, foundType);
+                        const foundType = this.determineType(node, input, targetType);
+                        const bodyType = new filter_body_1.FilterBody().runSyntax(node.findDirectExpression(Expressions.FilterBody), input, foundType);
                         if (foundType === undefined || foundType.isGeneric()) {
-                            this.addIfInferred(node, scope, filename, bodyType);
+                            this.addIfInferred(node, input, bodyType);
                         }
                         else {
-                            this.addIfInferred(node, scope, filename, foundType);
+                            this.addIfInferred(node, input, foundType);
                         }
                         if (foundType && !(foundType instanceof unknown_type_1.UnknownType)) {
                             return foundType;
@@ -145,22 +149,22 @@ class Source {
                     }
                 case "CORRESPONDING":
                     {
-                        const foundType = this.determineType(node, scope, filename, targetType);
-                        new corresponding_body_1.CorrespondingBody().runSyntax(node.findDirectExpression(Expressions.CorrespondingBody), scope, filename, foundType);
-                        this.addIfInferred(node, scope, filename, foundType);
+                        const foundType = this.determineType(node, input, targetType);
+                        new corresponding_body_1.CorrespondingBody().runSyntax(node.findDirectExpression(Expressions.CorrespondingBody), input, foundType);
+                        this.addIfInferred(node, input, foundType);
                         return foundType;
                     }
                 case "EXACT":
-                    return this.determineType(node, scope, filename, targetType);
+                    return this.determineType(node, input, targetType);
                 case "VALUE":
                     {
-                        const foundType = this.determineType(node, scope, filename, targetType);
-                        const bodyType = new value_body_1.ValueBody().runSyntax(node.findDirectExpression(Expressions.ValueBody), scope, filename, foundType);
+                        const foundType = this.determineType(node, input, targetType);
+                        const bodyType = new value_body_1.ValueBody().runSyntax(node.findDirectExpression(Expressions.ValueBody), input, foundType);
                         if (foundType === undefined || foundType.isGeneric()) {
-                            this.addIfInferred(node, scope, filename, bodyType);
+                            this.addIfInferred(node, input, bodyType);
                         }
                         else {
-                            this.addIfInferred(node, scope, filename, foundType);
+                            this.addIfInferred(node, input, foundType);
                         }
                         return foundType ? foundType : bodyType;
                     }
@@ -180,19 +184,21 @@ class Source {
         let hexNext = false;
         while (children.length >= 0) {
             if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.MethodCallChain) {
-                context = new method_call_chain_1.MethodCallChain().runSyntax(first, scope, filename, targetType);
+                context = new method_call_chain_1.MethodCallChain().runSyntax(first, input, targetType);
                 if (context === undefined) {
-                    throw new Error("Method has no RETURNING value");
+                    const message = "Method has no RETURNING value";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
                 }
             }
             else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.FieldChain) {
-                context = new field_chain_1.FieldChain().runSyntax(first, scope, filename, type);
+                context = new field_chain_1.FieldChain().runSyntax(first, input, type);
             }
             else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.StringTemplate) {
-                context = new string_template_1.StringTemplate().runSyntax(first, scope, filename);
+                context = new string_template_1.StringTemplate().runSyntax(first, input);
             }
             else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.Source) {
-                const found = new Source().runSyntax(first, scope, filename);
+                const found = new Source().runSyntax(first, input);
                 context = this.infer(context, found);
             }
             else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.Constant) {
@@ -200,10 +206,10 @@ class Source {
                 context = this.infer(context, found);
             }
             else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.Dereference) {
-                context = new dereference_1.Dereference().runSyntax(context);
+                context = new dereference_1.Dereference().runSyntax(first, context, input);
             }
             else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.ComponentChain) {
-                context = new component_chain_1.ComponentChain().runSyntax(context, first, scope, filename);
+                context = new component_chain_1.ComponentChain().runSyntax(context, first, input);
             }
             else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.ArithOperator) {
                 if (first.concatTokens() === "**") {
@@ -216,7 +222,7 @@ class Source {
                 }
             }
             else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.AttributeChain) {
-                context = new attribute_chain_1.AttributeChain().runSyntax(context, first, scope, filename, type);
+                context = new attribute_chain_1.AttributeChain().runSyntax(context, first, input, type);
             }
             if (hexExpected === true) {
                 if (!(context instanceof basic_1.VoidType)
@@ -225,7 +231,9 @@ class Source {
                     && !(context instanceof basic_1.XGenericType)
                     && !(context instanceof basic_1.XSequenceType)
                     && !(context instanceof unknown_type_1.UnknownType)) {
-                    throw new Error("Operator only valid for XSTRING or HEX");
+                    const message = "Operator only valid for XSTRING or HEX";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
                 }
                 if (hexNext === false) {
                     hexExpected = false;
@@ -243,10 +251,10 @@ class Source {
         return context;
     }
     ////////////////////////////////
-    traverseRemainingChildren(children, scope, filename) {
+    traverseRemainingChildren(children, input) {
         const last = children[children.length - 1];
         if (last && last.get() instanceof Expressions.Source) {
-            new Source().runSyntax(last, scope, filename);
+            new Source().runSyntax(last, input);
         }
     }
     infer(context, found) {
@@ -257,37 +265,37 @@ class Source {
             return found;
         }
     }
-    addIfInferred(node, scope, filename, inferredType) {
-        const basic = new basic_types_1.BasicTypes(filename, scope);
+    addIfInferred(node, input, inferredType) {
+        const basic = new basic_types_1.BasicTypes(input);
         const typeExpression = node.findFirstExpression(Expressions.TypeNameOrInfer);
         const typeToken = typeExpression === null || typeExpression === void 0 ? void 0 : typeExpression.getFirstToken();
         const typeName = typeToken === null || typeToken === void 0 ? void 0 : typeToken.getStr();
         if (typeName === "#" && inferredType && typeToken) {
             const found = basic.lookupQualifiedName(inferredType.getQualifiedName());
             if (found) {
-                scope.addReference(typeToken, found, _reference_1.ReferenceType.InferredType, filename);
+                input.scope.addReference(typeToken, found, _reference_1.ReferenceType.InferredType, input.filename);
             }
             else if (inferredType instanceof basic_1.ObjectReferenceType) {
-                const def = scope.findObjectDefinition(inferredType.getQualifiedName());
+                const def = input.scope.findObjectDefinition(inferredType.getQualifiedName());
                 if (def) {
-                    const tid = new _typed_identifier_1.TypedIdentifier(typeToken, filename, inferredType);
-                    scope.addReference(typeToken, tid, _reference_1.ReferenceType.InferredType, filename);
+                    const tid = new _typed_identifier_1.TypedIdentifier(typeToken, input.filename, inferredType);
+                    input.scope.addReference(typeToken, tid, _reference_1.ReferenceType.InferredType, input.filename);
                 }
             }
             else if (inferredType instanceof basic_1.CharacterType) {
                 // character is bit special it does not have a qualified name eg "TYPE c LENGTH 6"
-                const tid = new _typed_identifier_1.TypedIdentifier(typeToken, filename, inferredType);
-                scope.addReference(typeToken, tid, _reference_1.ReferenceType.InferredType, filename);
+                const tid = new _typed_identifier_1.TypedIdentifier(typeToken, input.filename, inferredType);
+                input.scope.addReference(typeToken, tid, _reference_1.ReferenceType.InferredType, input.filename);
             }
         }
     }
-    determineType(node, scope, filename, targetType) {
-        const basic = new basic_types_1.BasicTypes(filename, scope);
+    determineType(node, input, targetType) {
+        const basic = new basic_types_1.BasicTypes(input);
         const typeExpression = node.findFirstExpression(Expressions.TypeNameOrInfer);
         const typeToken = typeExpression === null || typeExpression === void 0 ? void 0 : typeExpression.getFirstToken();
         const typeName = typeToken === null || typeToken === void 0 ? void 0 : typeToken.getStr();
         if (typeExpression === undefined) {
-            throw new Error("determineType, child TypeNameOrInfer not found");
+            throw new assert_error_1.AssertError("determineType, child TypeNameOrInfer not found");
         }
         else if (typeName === "#" && targetType) {
             return targetType;
@@ -295,18 +303,20 @@ class Source {
         if (typeName !== "#" && typeToken) {
             const found = basic.parseType(typeExpression);
             if (found && found instanceof unknown_type_1.UnknownType) {
-                if (scope.getDDIC().inErrorNamespace(typeName) === false) {
-                    scope.addReference(typeToken, undefined, _reference_1.ReferenceType.VoidType, filename);
+                if (input.scope.getDDIC().inErrorNamespace(typeName) === false) {
+                    input.scope.addReference(typeToken, undefined, _reference_1.ReferenceType.VoidType, input.filename);
                     return new basic_1.VoidType(typeName);
                 }
                 else {
-                    const tid = new _typed_identifier_1.TypedIdentifier(typeToken, filename, found);
-                    scope.addReference(typeToken, tid, _reference_1.ReferenceType.TypeReference, filename);
+                    const tid = new _typed_identifier_1.TypedIdentifier(typeToken, input.filename, found);
+                    input.scope.addReference(typeToken, tid, _reference_1.ReferenceType.TypeReference, input.filename);
                     return found;
                 }
             }
             else if (found === undefined) {
-                throw new Error("Type \"" + typeName + "\" not found in scope, VALUE");
+                const message = "Type \"" + typeName + "\" not found in scope, VALUE";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
             }
             return found;
         }