@abaplint/core 2.111.1 → 2.112.0

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

@@ -1,22 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SourceField = void 0;
+const basic_1 = require("../../types/basic");
 const _reference_1 = require("../_reference");
+const _syntax_input_1 = require("../_syntax_input");
 class SourceField {
-    runSyntax(node, scope, filename, type) {
+    runSyntax(node, input, type, error = true) {
         const token = node.getFirstToken();
         const name = token.getStr();
-        const found = scope.findVariable(name);
+        const found = input.scope.findVariable(name);
         if (found === undefined) {
-            throw new Error("\"" + name + "\" not found, findTop");
+            const message = "\"" + name + "\" not found, findTop";
+            if (error === true) {
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            }
+            return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
         }
         if (type) {
-            scope.addReference(token, found, type, filename);
+            input.scope.addReference(token, found, type, input.filename);
         }
         if (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);
             }
         }
         return found.getType();

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

@@ -1,15 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SourceFieldSymbol = void 0;
+const basic_1 = require("../../types/basic");
 const _reference_1 = require("../_reference");
+const _syntax_input_1 = require("../_syntax_input");
 class SourceFieldSymbol {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const token = node.getFirstToken();
-        const found = scope.findVariable(token.getStr());
+        const found = input.scope.findVariable(token.getStr());
         if (found === undefined) {
-            throw new Error("\"" + node.getFirstToken().getStr() + "\" not found, SourceFieldSymbol");
+            const message = "\"" + node.getFirstToken().getStr() + "\" not found, SourceFieldSymbol";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
         }
-        scope.addReference(token, found, _reference_1.ReferenceType.DataReadReference, filename);
+        input.scope.addReference(token, found, _reference_1.ReferenceType.DataReadReference, input.filename);
         return found.getType();
     }
 }

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

@@ -6,45 +6,37 @@ const nodes_1 = require("../../nodes");
 const basic_1 = require("../../types/basic");
 const dynamic_1 = require("./dynamic");
 const source_1 = require("./source");
+const sql_in_1 = require("./sql_in");
 const sql_source_1 = require("./sql_source");
 class SQLCompare {
-    runSyntax(node, scope, filename, tables) {
+    runSyntax(node, input, tables) {
         var _a, _b;
         let sourceType;
         let token;
         if (((_a = node.getFirstChild()) === null || _a === void 0 ? void 0 : _a.get()) instanceof Expressions.Dynamic) {
-            new dynamic_1.Dynamic().runSyntax(node.getFirstChild(), scope, filename);
+            new dynamic_1.Dynamic().runSyntax(node.getFirstChild(), input);
             return;
         }
-        for (const s of node.findAllExpressions(Expressions.SimpleSource3)) {
-            new source_1.Source().runSyntax(s, scope, filename);
+        for (const s of node.findDirectExpressions(Expressions.SimpleSource3)) {
+            new source_1.Source().runSyntax(s, input);
         }
-        for (const s of node.findAllExpressions(Expressions.SQLSource)) {
+        for (const s of node.findDirectExpressions(Expressions.SQLSource)) {
             for (const child of s.getChildren()) {
                 if (child instanceof nodes_1.ExpressionNode) {
                     token = child.getFirstToken();
                     break;
                 }
             }
-            sourceType = new sql_source_1.SQLSource().runSyntax(s, scope, filename);
+            sourceType = new sql_source_1.SQLSource().runSyntax(s, input);
         }
         const sqlin = node.findDirectExpression(Expressions.SQLIn);
-        if (sqlin && sqlin.getChildren().length === 2) {
-            const insource = node.findFirstExpression(Expressions.SQLSource);
-            if (insource) {
-                const intype = new sql_source_1.SQLSource().runSyntax(insource, scope, filename);
-                if (intype &&
-                    !(intype instanceof basic_1.VoidType) &&
-                    !(intype instanceof basic_1.UnknownType) &&
-                    !(intype instanceof basic_1.TableType)) {
-                    throw new Error("IN, not a table");
-                }
-            }
+        if (sqlin) {
+            new sql_in_1.SQLIn().runSyntax(sqlin, input);
         }
         const fieldName = (_b = node.findDirectExpression(Expressions.SQLFieldName)) === null || _b === void 0 ? void 0 : _b.concatTokens();
         if (fieldName && sourceType && token) {
             // check compatibility for rule sql_value_conversion
-            const targetType = this.findType(fieldName, tables, scope);
+            const targetType = this.findType(fieldName, tables, input.scope);
             let message = "";
             if (sourceType instanceof basic_1.IntegerType
                 && targetType instanceof basic_1.CharacterType) {
@@ -73,7 +65,7 @@ class SQLCompare {
                 message = "Source field longer than database field, NUMC -> NUMC";
             }
             if (message !== "") {
-                scope.addSQLConversion(fieldName, message, token);
+                input.scope.addSQLConversion(fieldName, message, token);
             }
         }
     }

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

@@ -4,22 +4,25 @@ exports.SQLForAllEntries = void 0;
 const Expressions = require("../../2_statements/expressions");
 const source_1 = require("./source");
 const basic_1 = require("../../types/basic");
+const _syntax_input_1 = require("../_syntax_input");
 class SQLForAllEntries {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         let s = node.findFirstExpression(Expressions.Source);
         if (s === undefined) {
             s = node.findFirstExpression(Expressions.SimpleSource3);
         }
         if (s) {
-            const type = new source_1.Source().runSyntax(s, scope, filename);
+            const type = new source_1.Source().runSyntax(s, input);
             if (type instanceof basic_1.VoidType) {
                 return;
             }
             if (!(type instanceof basic_1.TableType)) {
-                throw new Error("FAE parameter must be table type");
+                const message = "FAE parameter must be table type";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
             const name = s.concatTokens().replace("[]", "");
-            scope.setAllowHeaderUse(name);
+            input.scope.setAllowHeaderUse(name);
         }
     }
 }

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

@@ -5,16 +5,16 @@ const Expressions = require("../../2_statements/expressions");
 const dynamic_1 = require("./dynamic");
 const database_table_1 = require("./database_table");
 class SQLFrom {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const ret = [];
         const fromList = node.findAllExpressions(Expressions.SQLFromSource);
         for (const from of fromList) {
             for (const d of from.findAllExpressions(Expressions.Dynamic)) {
-                new dynamic_1.Dynamic().runSyntax(d, scope, filename);
+                new dynamic_1.Dynamic().runSyntax(d, input);
             }
             const dbtab = from.findFirstExpression(Expressions.DatabaseTable);
             if (dbtab !== undefined) {
-                ret.push(new database_table_1.DatabaseTable().runSyntax(dbtab, scope, filename));
+                ret.push(new database_table_1.DatabaseTable().runSyntax(dbtab, input));
             }
         }
         return ret;

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLIn = void 0;
+const Expressions = require("../../2_statements/expressions");
+const basic_1 = require("../../types/basic");
+const _syntax_input_1 = require("../_syntax_input");
+const sql_source_1 = require("./sql_source");
+class SQLIn {
+    runSyntax(node, input) {
+        if (node.getChildren().length === 2) {
+            const insource = node.findFirstExpression(Expressions.SQLSource);
+            if (insource) {
+                const intype = new sql_source_1.SQLSource().runSyntax(insource, input);
+                if (intype &&
+                    !(intype instanceof basic_1.VoidType) &&
+                    !(intype instanceof basic_1.UnknownType) &&
+                    !(intype instanceof basic_1.TableType)) {
+                    const message = "IN, not a table";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return;
+                }
+            }
+            return;
+        }
+        for (const s of node.findDirectExpressions(Expressions.SQLSource)) {
+            new sql_source_1.SQLSource().runSyntax(s, input);
+        }
+        for (const s of node.findDirectExpressions(Expressions.SQLSourceNoSpace)) {
+            new sql_source_1.SQLSource().runSyntax(s, input);
+        }
+    }
+}
+exports.SQLIn = SQLIn;
+//# sourceMappingURL=sql_in.js.map

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

@@ -4,10 +4,10 @@ exports.SQLOrderBy = void 0;
 const Expressions = require("../../2_statements/expressions");
 const dynamic_1 = require("./dynamic");
 class SQLOrderBy {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const dyn = node.findDirectExpression(Expressions.Dynamic);
         if (dyn) {
-            new dynamic_1.Dynamic().runSyntax(dyn, scope, filename);
+            new dynamic_1.Dynamic().runSyntax(dyn, input);
         }
     }
 }

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

@@ -4,12 +4,12 @@ exports.SQLSource = void 0;
 const Expressions = require("../../2_statements/expressions");
 const source_1 = require("./source");
 class SQLSource {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         for (const s of node.findAllExpressions(Expressions.Source)) {
-            return new source_1.Source().runSyntax(s, scope, filename);
+            return new source_1.Source().runSyntax(s, input);
         }
         for (const s of node.findAllExpressions(Expressions.SimpleSource3)) {
-            return new source_1.Source().runSyntax(s, scope, filename);
+            return new source_1.Source().runSyntax(s, input);
         }
         return undefined;
     }

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

@@ -5,26 +5,32 @@ const basic_1 = require("../../types/basic");
 const Expressions = require("../../2_statements/expressions");
 const source_1 = require("./source");
 const _type_utils_1 = require("../_type_utils");
+const _syntax_input_1 = require("../_syntax_input");
 class StringTemplate {
-    runSyntax(node, scope, filename) {
-        const typeUtils = new _type_utils_1.TypeUtils(scope);
+    runSyntax(node, input) {
+        const typeUtils = new _type_utils_1.TypeUtils(input.scope);
         const ret = basic_1.StringType.get();
         for (const templateSource of node.findAllExpressions(Expressions.StringTemplateSource)) {
             const s = templateSource.findDirectExpression(Expressions.Source);
-            const type = new source_1.Source().runSyntax(s, scope, filename, ret);
+            const type = new source_1.Source().runSyntax(s, input, ret);
             if (type === undefined) {
-                throw new Error("No target type determined");
+                const message = "No target type determined";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
             }
             else if ((typeUtils.isCharLike(type) === false && typeUtils.isHexLike(type) === false)
                 || type instanceof basic_1.StructureType) {
-                throw new Error("String template, not character like, " + type.constructor.name);
+                const message = "String template, not character like, " + type.constructor.name;
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
             }
             const format = templateSource.findDirectExpression(Expressions.StringTemplateFormatting);
             const formatConcat = format === null || format === void 0 ? void 0 : format.concatTokens();
             for (const formatSource of (format === null || format === void 0 ? void 0 : format.findAllExpressions(Expressions.Source)) || []) {
-                new source_1.Source().runSyntax(formatSource, scope, filename);
+                new source_1.Source().runSyntax(formatSource, input);
             }
-            if ((formatConcat === null || formatConcat === void 0 ? void 0 : formatConcat.includes("ALPHA = "))
+            if (format
+                && (formatConcat === null || formatConcat === void 0 ? void 0 : formatConcat.includes("ALPHA = "))
                 && !(type instanceof basic_1.UnknownType)
                 && !(type instanceof basic_1.VoidType)
                 && !(type instanceof basic_1.StringType)
@@ -33,7 +39,9 @@ class StringTemplate {
                 && !(type instanceof basic_1.NumericGenericType)
                 && !(type instanceof basic_1.NumericType)
                 && !(type instanceof basic_1.AnyType)) {
-                throw new Error("Cannot apply ALPHA to this type");
+                const message = "Cannot apply ALPHA to this type";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, format.getFirstToken(), message));
+                return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
             }
         }
         return ret;

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

@@ -3,21 +3,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SwitchBody = void 0;
 const Expressions = require("../../2_statements/expressions");
 const source_1 = require("./source");
+const _syntax_input_1 = require("../_syntax_input");
+const basic_1 = require("../../types/basic");
 class SwitchBody {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         if (node === undefined) {
             return;
         }
         const thenSource = node.findExpressionAfterToken("THEN");
         if (!((thenSource === null || thenSource === void 0 ? void 0 : thenSource.get()) instanceof Expressions.Source)) {
-            throw new Error("SwitchBody, unexpected");
+            const message = "SwitchBody, unexpected";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
         }
-        const type = new source_1.Source().runSyntax(thenSource, scope, filename);
+        const type = new source_1.Source().runSyntax(thenSource, input);
         for (const s of node.findDirectExpressions(Expressions.Source)) {
             if (s === thenSource) {
                 continue;
             }
-            new source_1.Source().runSyntax(s, scope, filename);
+            new source_1.Source().runSyntax(s, input);
         }
         return type;
     }

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

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

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

@@ -14,14 +14,15 @@ const table_expression_1 = require("./table_expression");
 const expressions_1 = require("../../2_statements/expressions");
 const field_length_1 = require("./field_length");
 const cast_1 = require("./cast");
+const _syntax_input_1 = require("../_syntax_input");
 class Target {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         const concat = node.concatTokens();
         if (concat.includes("-")) {
             // workaround for names with dashes
-            const found = scope.findVariable(concat);
+            const found = input.scope.findVariable(concat);
             if (found) {
-                scope.addReference(node.getFirstToken(), found, _reference_1.ReferenceType.DataWriteReference, filename);
+                input.scope.addReference(node.getFirstToken(), found, _reference_1.ReferenceType.DataWriteReference, input.filename);
                 return found.getType();
             }
         }
@@ -30,9 +31,11 @@ class Target {
         if (first === undefined || !(first instanceof nodes_1.ExpressionNode)) {
             return undefined;
         }
-        let context = this.findTop(first, scope, filename);
+        let context = this.findTop(first, input);
         if (context === undefined) {
-            throw new Error(`"${first.getFirstToken().getStr()}" not found, Target`);
+            const message = `"${first.getFirstToken().getStr()}" not found, Target`;
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
         }
         while (children.length > 0) {
             const current = children.shift();
@@ -41,39 +44,49 @@ class Target {
             }
             if (current.get() instanceof tokens_1.Dash) {
                 if (context instanceof unknown_type_1.UnknownType) {
-                    throw new Error("Not a structure, type unknown, target");
+                    const message = "Not a structure, type unknown, target";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
                 }
                 else if (!(context instanceof basic_1.StructureType)
                     && !(context instanceof basic_1.TableType && context.isWithHeader() && context.getRowType() instanceof basic_1.StructureType)
                     && !(context instanceof basic_1.TableType && context.isWithHeader() && context.getRowType() instanceof basic_1.VoidType)
                     && !(context instanceof basic_1.VoidType)) {
-                    throw new Error("Not a structure, target");
+                    const message = "Not a structure, target";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
                 }
             }
             else if (current.get() instanceof tokens_1.InstanceArrow) {
                 if (!(context instanceof basic_1.ObjectReferenceType)
                     && !(context instanceof basic_1.DataReference)
                     && !(context instanceof basic_1.VoidType)) {
-                    throw new Error("Not an object reference, target");
+                    const message = "Not an object reference, target";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
                 }
             }
             else if (current.get() instanceof expressions_1.Dereference) {
                 if (!(context instanceof basic_1.DataReference) && !(context instanceof basic_1.VoidType)) {
-                    throw new Error("Not an object reference, target");
+                    const message = "Not an object reference, target";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
                 }
                 if (!(context instanceof basic_1.VoidType)) {
                     context = context.getType();
                 }
             }
             else if (current.get() instanceof Expressions.ComponentName) {
-                context = new component_name_1.ComponentName().runSyntax(context, current);
+                context = new component_name_1.ComponentName().runSyntax(context, current, input);
             }
             else if (current.get() instanceof Expressions.TableBody) {
                 if (!(context instanceof basic_1.TableType)
                     && !(context instanceof basic_1.VoidType)
                     && !(context instanceof unknown_type_1.UnknownType)
                     && !(context instanceof unknown_type_1.UnknownType)) {
-                    throw new Error("Not a internal table, \"[]\"");
+                    const message = "Not a internal table, \"[]\"";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
                 }
                 if (context instanceof basic_1.TableType && context.isWithHeader()) {
                     context = new basic_1.TableType(context.getRowType(), Object.assign(Object.assign({}, context.getOptions()), { withHeader: false }));
@@ -82,36 +95,42 @@ class Target {
             else if (current instanceof nodes_1.ExpressionNode
                 && current.get() instanceof Expressions.TableExpression) {
                 if (!(context instanceof basic_1.TableType) && !(context instanceof basic_1.VoidType)) {
-                    throw new Error("Table expression, expected table");
+                    const message = "Table expression, expected table";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
                 }
-                new table_expression_1.TableExpression().runSyntax(current, scope, filename);
+                new table_expression_1.TableExpression().runSyntax(current, input);
                 if (!(context instanceof basic_1.VoidType)) {
                     context = context.getRowType();
                 }
             }
             else if (current.get() instanceof Expressions.AttributeName) {
                 const type = children.length === 0 ? _reference_1.ReferenceType.DataWriteReference : _reference_1.ReferenceType.DataReadReference;
-                context = new attribute_name_1.AttributeName().runSyntax(context, current, scope, filename, type);
+                context = new attribute_name_1.AttributeName().runSyntax(context, current, input, type);
             }
         }
         const offset = node.findDirectExpression(Expressions.FieldOffset);
         if (offset) {
             if (context instanceof basic_1.XStringType || context instanceof basic_1.StringType) {
-                throw new Error("xstring/string offset/length in writer position not possible");
+                const message = "xstring/string offset/length in writer position not possible";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
             }
-            new field_offset_1.FieldOffset().runSyntax(offset, scope, filename);
+            new field_offset_1.FieldOffset().runSyntax(offset, input);
         }
         const length = node.findDirectExpression(Expressions.FieldLength);
         if (length) {
             if (context instanceof basic_1.XStringType || context instanceof basic_1.StringType) {
-                throw new Error("xstring/string offset/length in writer position not possible");
+                const message = "xstring/string offset/length in writer position not possible";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
             }
-            new field_length_1.FieldLength().runSyntax(length, scope, filename);
+            new field_length_1.FieldLength().runSyntax(length, input);
         }
         return context;
     }
     /////////////////////////////////
-    findTop(node, scope, filename) {
+    findTop(node, input) {
         if (node === undefined) {
             return undefined;
         }
@@ -119,26 +138,26 @@ class Target {
         const name = token.getStr();
         if (node.get() instanceof Expressions.TargetField
             || node.get() instanceof Expressions.TargetFieldSymbol) {
-            const found = scope.findVariable(name);
+            const found = input.scope.findVariable(name);
             if (found) {
-                scope.addReference(token, found, _reference_1.ReferenceType.DataWriteReference, filename);
+                input.scope.addReference(token, found, _reference_1.ReferenceType.DataWriteReference, input.filename);
             }
             if (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);
                 }
             }
             return found === null || found === void 0 ? void 0 : found.getType();
         }
         else if (node.get() instanceof Expressions.ClassName) {
-            const found = scope.findObjectDefinition(name);
+            const found = input.scope.findObjectDefinition(name);
             if (found) {
-                scope.addReference(token, found, _reference_1.ReferenceType.ObjectOrientedReference, filename);
+                input.scope.addReference(token, found, _reference_1.ReferenceType.ObjectOrientedReference, input.filename);
                 return new basic_1.ObjectReferenceType(found);
             }
-            else if (scope.getDDIC().inErrorNamespace(name) === false) {
-                scope.addReference(token, undefined, _reference_1.ReferenceType.ObjectOrientedVoidReference, filename, { ooName: name, ooType: "CLAS" });
+            else if (input.scope.getDDIC().inErrorNamespace(name) === false) {
+                input.scope.addReference(token, undefined, _reference_1.ReferenceType.ObjectOrientedVoidReference, input.filename, { ooName: name, ooType: "CLAS" });
                 return new basic_1.VoidType(name);
             }
             else {
@@ -146,9 +165,11 @@ class Target {
             }
         }
         else if (node.get() instanceof Expressions.Cast && node instanceof nodes_1.ExpressionNode) {
-            const ret = new cast_1.Cast().runSyntax(node, scope, undefined, filename);
+            const ret = new cast_1.Cast().runSyntax(node, input, undefined);
             if (ret instanceof unknown_type_1.UnknownType) {
-                throw new Error("CAST, uknown type");
+                const message = "CAST, uknown type";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
             }
             return ret;
         }

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

@@ -8,7 +8,7 @@ const basic_1 = require("../../types/basic");
 const _scope_type_1 = require("../_scope_type");
 const type_table_key_1 = require("./type_table_key");
 class TypeTable {
-    runSyntax(node, scope, filename, qualifiedNamePrefix) {
+    runSyntax(node, input, qualifiedNamePrefix) {
         // todo, input is currently the statement, but should be the expression?
         let nameExpr = node.findFirstExpression(Expressions.DefinitionName);
         if (nameExpr === undefined) {
@@ -21,14 +21,14 @@ class TypeTable {
         let qualifiedName = qualifiedNamePrefix || "";
         if (node.getFirstToken().getStr().toUpperCase() === "TYPES") {
             qualifiedName = qualifiedName + name.getStr();
-            if (scope.getType() === _scope_type_1.ScopeType.ClassDefinition
-                || scope.getType() === _scope_type_1.ScopeType.Interface) {
-                qualifiedName = scope.getName() + "=>" + qualifiedName;
+            if (input.scope.getType() === _scope_type_1.ScopeType.ClassDefinition
+                || input.scope.getType() === _scope_type_1.ScopeType.Interface) {
+                qualifiedName = input.scope.getName() + "=>" + qualifiedName;
             }
         }
-        let type = new basic_types_1.BasicTypes(filename, scope).parseTable(node, qualifiedName);
+        let type = new basic_types_1.BasicTypes(input).parseTable(node, qualifiedName);
         if (type === undefined) {
-            return new _typed_identifier_1.TypedIdentifier(name, filename, new basic_1.UnknownType("TableType, fallback"));
+            return new _typed_identifier_1.TypedIdentifier(name, input.filename, new basic_1.UnknownType("TableType, fallback"));
         }
         for (const tt of node.findAllExpressions(Expressions.TypeTableKey)) {
             const error = new type_table_key_1.TypeTableKey().runSyntax(tt, type);
@@ -36,7 +36,7 @@ class TypeTable {
                 type = error;
             }
         }
-        return new _typed_identifier_1.TypedIdentifier(name, filename, type);
+        return new _typed_identifier_1.TypedIdentifier(name, input.filename, type);
     }
 }
 exports.TypeTable = TypeTable;