@abaplint/core 2.111.1 → 2.112.0

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

@@ -8,14 +8,16 @@ const inline_data_1 = require("./inline_data");
 const target_1 = require("./target");
 const source_1 = require("./source");
 const _type_utils_1 = require("../_type_utils");
+const _syntax_input_1 = require("../_syntax_input");
+const assert_error_1 = require("../assert_error");
 class MethodParameters {
     constructor() {
         this.requiredParameters = undefined;
     }
-    runSyntax(node, scope, method, filename) {
+    runSyntax(node, input, method) {
         var _a;
         if (!(node.get() instanceof Expressions.MethodParameters)) {
-            throw new Error("MethodParameters, unexpected input");
+            throw new assert_error_1.AssertError("MethodParameters, unexpected input");
         }
         const children = node.getChildren().slice();
         if (method instanceof basic_1.VoidType) {
@@ -28,50 +30,56 @@ class MethodParameters {
             const name = (_a = children.shift()) === null || _a === void 0 ? void 0 : _a.getFirstToken().getStr().toUpperCase();
             switch (name) {
                 case "EXPORTING":
-                    this.checkExporting(children.shift(), scope, method, filename, false);
+                    this.checkExporting(children.shift(), input, method, false);
                     break;
                 case "IMPORTING":
-                    this.checkImporting(children.shift(), scope, method, filename);
+                    this.checkImporting(children.shift(), input, method);
                     break;
                 case "CHANGING":
-                    this.checkChanging(children.shift(), scope, method, filename);
+                    this.checkChanging(children.shift(), input, method);
                     break;
                 case "RECEIVING":
-                    this.checkReceiving(children.shift(), scope, method, filename);
+                    this.checkReceiving(children.shift(), input, method);
                     break;
                 case "EXCEPTIONS":
                     children.shift(); // todo, old style exceptions
                     break;
                 default:
-                    throw new Error("MethodParameters, unexpected token, " + name);
+                    throw new assert_error_1.AssertError("MethodParameters, unexpected token, " + name);
             }
         }
-        this.reportErrors();
+        this.reportErrors(node, input);
     }
     ///////////////////////
-    checkReceiving(node, scope, method, filename) {
+    checkReceiving(node, input, method) {
         var _a;
         const type = method instanceof basic_1.VoidType ? method : (_a = method.getParameters().getReturning()) === null || _a === void 0 ? void 0 : _a.getType();
         if (type === undefined) {
-            throw new Error("Method does not have a returning parameter");
+            const message = "Method does not have a returning parameter";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
         else if (!(node instanceof nodes_1.ExpressionNode)) {
-            throw new Error("checkReceiving, not an expression node");
+            const message = "checkReceiving, not an expression node";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
         const target = node.findDirectExpression(Expressions.Target);
         const inline = target === null || target === void 0 ? void 0 : target.findDirectExpression(Expressions.InlineData);
         if (inline) {
-            new inline_data_1.InlineData().runSyntax(inline, scope, filename, type);
+            new inline_data_1.InlineData().runSyntax(inline, input, type);
         }
         else if (target) {
-            const targetType = new target_1.Target().runSyntax(target, scope, filename);
-            if (targetType && new _type_utils_1.TypeUtils(scope).isAssignable(type, targetType) === false) {
-                throw new Error("Method returning value not type compatible");
+            const targetType = new target_1.Target().runSyntax(target, input);
+            if (targetType && new _type_utils_1.TypeUtils(input.scope).isAssignable(type, targetType) === false) {
+                const message = "Method returning value not type compatible";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
         }
     }
-    checkImporting(node, scope, method, filename) {
-        for (const item of this.parameterListT(node, scope, filename)) {
+    checkImporting(node, input, method) {
+        for (const item of this.parameterListT(node, input)) {
             let parameterType = undefined;
             if (method instanceof basic_1.VoidType) {
                 parameterType = method;
@@ -79,27 +87,35 @@ class MethodParameters {
             else {
                 const parameter = method.getParameters().getExporting().find(p => p.getName().toUpperCase() === item.name);
                 if (parameter === undefined) {
-                    throw new Error("Method exporting parameter \"" + item.name + "\" does not exist");
+                    const message = "Method exporting parameter \"" + item.name + "\" does not exist";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return;
                 }
                 parameterType = parameter.getType();
             }
             const inline = item.target.findDirectExpression(Expressions.InlineData);
             if (inline) {
-                new inline_data_1.InlineData().runSyntax(inline, scope, filename, parameterType);
+                new inline_data_1.InlineData().runSyntax(inline, input, parameterType);
             }
             else if (item.targetType === undefined) {
-                throw new Error("Could not determine target type");
+                const message = "Could not determine target type";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
-            else if (item.targetType && new _type_utils_1.TypeUtils(scope).isAssignable(parameterType, item.targetType) === false) {
-                throw new Error("Method parameter type not compatible, " + item.name);
+            else if (item.targetType && new _type_utils_1.TypeUtils(input.scope).isAssignable(parameterType, item.targetType) === false) {
+                const message = "Method parameter type not compatible, " + item.name;
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
         }
     }
-    checkChanging(node, scope, method, filename) {
+    checkChanging(node, input, method) {
         var _a;
-        for (const item of this.parameterListT(node, scope, filename)) {
+        for (const item of this.parameterListT(node, input)) {
             if (item.target.findFirstExpression(Expressions.InlineData) !== undefined) {
-                throw new Error("CHANGING cannot be inlined");
+                const message = "CHANGING cannot be inlined";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
             let parameterType = undefined;
             if (method instanceof basic_1.VoidType) {
@@ -108,18 +124,22 @@ class MethodParameters {
             else {
                 const parameter = method.getParameters().getChanging().find(p => p.getName().toUpperCase() === item.name);
                 if (parameter === undefined) {
-                    throw new Error("Method changing parameter \"" + item.name + "\" does not exist");
+                    const message = "Method changing parameter \"" + item.name + "\" does not exist";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return;
                 }
                 parameterType = parameter.getType();
             }
-            if (item.targetType && new _type_utils_1.TypeUtils(scope).isAssignable(parameterType, item.targetType) === false) {
-                throw new Error("Method parameter type not compatible, " + item.name);
+            if (item.targetType && new _type_utils_1.TypeUtils(input.scope).isAssignable(parameterType, item.targetType) === false) {
+                const message = "Method parameter type not compatible, " + item.name;
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
             (_a = this.requiredParameters) === null || _a === void 0 ? void 0 : _a.delete(item.name);
         }
     }
-    checkExporting(node, scope, method, filename, errors = true) {
-        const items = this.parameterListS(node, scope, filename, method);
+    checkExporting(node, input, method, errors = true) {
+        const items = this.parameterListS(node, input, method);
         if (method instanceof basic_1.VoidType) {
             return;
         }
@@ -133,43 +153,48 @@ class MethodParameters {
                 || item.source.findFirstExpression(Expressions.StringTemplate) !== undefined
                 || item.source.findFirstExpression(Expressions.ArithOperator) !== undefined;
             if (parameter === undefined) {
-                throw new Error("Method importing parameter \"" + item.name + "\" does not exist");
+                const message = "Method importing parameter \"" + item.name + "\" does not exist";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
-            else if (new _type_utils_1.TypeUtils(scope).isAssignableStrict(item.sourceType, parameter.getType(), calculated) === false) {
-                throw new Error("Method parameter type not compatible, " + item.name);
+            else if (new _type_utils_1.TypeUtils(input.scope).isAssignableStrict(item.sourceType, parameter.getType(), calculated) === false) {
+                const message = "Method parameter type not compatible, " + item.name;
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
             this.requiredParameters.delete(item.name);
         }
         if (errors === true) {
-            this.reportErrors();
+            this.reportErrors(node, input);
         }
     }
-    reportErrors() {
+    reportErrors(node, input) {
         var _a;
         for (const r of ((_a = this.requiredParameters) === null || _a === void 0 ? void 0 : _a.values()) || []) {
-            throw new Error(`method parameter "${r}" must be supplied`);
+            const message = `method parameter "${r}" must be supplied`;
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
         }
     }
-    parameterListS(node, scope, filename, method) {
+    parameterListS(node, input, method) {
         var _a;
         if (node === undefined) {
             return [];
         }
         else if (!(node.get() instanceof Expressions.ParameterListS)) {
-            throw new Error("parameterListS, unexpected node");
+            throw new assert_error_1.AssertError("parameterListS, unexpected node");
         }
         const ret = [];
         for (const c of node.getChildren()) {
             if (!(c.get() instanceof Expressions.ParameterS) || !(c instanceof nodes_1.ExpressionNode)) {
-                throw new Error("parameterListS, unexpected node, child");
+                throw new assert_error_1.AssertError("parameterListS, unexpected node, child");
             }
             const name = (_a = c.findDirectExpression(Expressions.ParameterName)) === null || _a === void 0 ? void 0 : _a.getFirstToken().getStr().toUpperCase();
             if (name === undefined) {
-                throw new Error("parameterListS, no name determined");
+                throw new assert_error_1.AssertError("parameterListS, no name determined");
             }
             const source = c.findDirectExpression(Expressions.Source);
             if (source === undefined) {
-                throw new Error("parameterListS, no source found");
+                throw new assert_error_1.AssertError("parameterListS, no source found");
             }
             let targetType = undefined;
             if (!(method instanceof basic_1.VoidType)) {
@@ -179,41 +204,43 @@ class MethodParameters {
                     }
                 }
             }
-            let sourceType = new source_1.Source().runSyntax(source, scope, filename, targetType);
+            let sourceType = new source_1.Source().runSyntax(source, input, targetType);
             if (sourceType === undefined) {
                 if (method instanceof basic_1.VoidType) {
                     sourceType = method;
                 }
                 else {
-                    throw new Error("No source type determined for parameter " + name + " input");
+                    const message = "No source type determined for parameter " + name + " input";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    sourceType = new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
                 }
             }
             ret.push({ name, source, sourceType });
         }
         return ret;
     }
-    parameterListT(node, scope, filename) {
+    parameterListT(node, input) {
         var _a;
         if (node === undefined) {
             return [];
         }
         else if (!(node.get() instanceof Expressions.ParameterListT)) {
-            throw new Error("parameterListT, unexpected node");
+            throw new assert_error_1.AssertError("parameterListT, unexpected node");
         }
         const ret = [];
         for (const c of node.getChildren()) {
             if (!(c.get() instanceof Expressions.ParameterT) || !(c instanceof nodes_1.ExpressionNode)) {
-                throw new Error("parameterListT, unexpected node, child");
+                throw new assert_error_1.AssertError("parameterListT, unexpected node, child");
             }
             const name = (_a = c.findDirectExpression(Expressions.ParameterName)) === null || _a === void 0 ? void 0 : _a.getFirstToken().getStr().toUpperCase();
             if (name === undefined) {
-                throw new Error("parameterListT, no name determined");
+                throw new assert_error_1.AssertError("parameterListT, no name determined");
             }
             const target = c.findDirectExpression(Expressions.Target);
             if (target === undefined) {
-                throw new Error("parameterListT, no target found");
+                throw new assert_error_1.AssertError("parameterListT, no target found");
             }
-            const targetType = new target_1.Target().runSyntax(target, scope, filename);
+            const targetType = new target_1.Target().runSyntax(target, input);
             ret.push({ name, target, targetType });
         }
         return ret;

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

@@ -15,27 +15,31 @@ const attribute_name_1 = require("./attribute_name");
 const component_name_1 = require("./component_name");
 const types_1 = require("../../types");
 const version_1 = require("../../../version");
+const _syntax_input_1 = require("../_syntax_input");
+const assert_error_1 = require("../assert_error");
 class MethodSource {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         var _a, _b, _c;
-        const helper = new _object_oriented_1.ObjectOriented(scope);
+        const helper = new _object_oriented_1.ObjectOriented(input.scope);
         const children = node.getChildren().slice();
         const first = children.shift();
         if (first === undefined) {
-            throw new Error("MethodSource, first child expected");
+            throw new assert_error_1.AssertError("MethodSource, first child expected");
         }
-        let context = this.findTop(first, scope, filename);
+        let context = this.findTop(first, input, children);
         if (context === undefined) {
-            context = (_a = scope.findVariable("me")) === null || _a === void 0 ? void 0 : _a.getType();
+            context = (_a = input.scope.findVariable("me")) === null || _a === void 0 ? void 0 : _a.getType();
             children.unshift(first);
         }
-        if (scope.getVersion() === version_1.Version.Cloud
+        if (input.scope.getVersion() === version_1.Version.Cloud
             && first.get() instanceof Expressions.Dynamic
             && first instanceof nodes_1.ExpressionNode
             && ((_b = children[0]) === null || _b === void 0 ? void 0 : _b.concatTokens()) === "=>") {
             const name = (_c = first.findDirectExpression(Expressions.Constant)) === null || _c === void 0 ? void 0 : _c.concatTokens().replace(/'/g, "").replace(/`/g, "");
-            if (name !== undefined && scope.findClassDefinition(name) === undefined) {
-                throw new Error(`Class "${name}" not found/released`);
+            if (name !== undefined && input.scope.findClassDefinition(name) === undefined) {
+                const message = `Class "${name}" not found/released`;
+                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) {
@@ -49,10 +53,14 @@ class MethodSource {
             }
             if (current.get() instanceof tokens_1.Dash) {
                 if (context instanceof basic_1.UnknownType) {
-                    throw new Error("Not a structure, type unknown, MethodSource");
+                    const message = "Not a structure, type unknown, MethodSource";
+                    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)) {
-                    throw new Error("Not a structure, MethodSource");
+                    const message = "Not a structure, MethodSource";
+                    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
@@ -61,35 +69,35 @@ class MethodSource {
             }
             else if (current.get() instanceof Expressions.AttributeName
                 || current.get() instanceof Expressions.SourceField) {
-                try {
-                    if (context instanceof _abstract_type_1.AbstractType) {
-                        const attr = new attribute_name_1.AttributeName().runSyntax(context, current, scope, filename, _reference_1.ReferenceType.DataReadReference);
+                if (context instanceof _abstract_type_1.AbstractType) {
+                    const attr = new attribute_name_1.AttributeName().runSyntax(context, current, input, _reference_1.ReferenceType.DataReadReference, false);
+                    const isSyntaxError = attr instanceof basic_1.VoidType && attr.getVoided() === _syntax_input_1.CheckSyntaxKey;
+                    if (isSyntaxError === false) {
                         context = attr;
                         continue;
                     }
                 }
-                catch (_d) {
-                    // ignore
-                }
                 // try looking for method name
                 const className = context instanceof basic_1.ObjectReferenceType ? context.getIdentifierName() : undefined;
                 const methodToken = current.getFirstToken();
                 const methodName = methodToken === null || methodToken === void 0 ? void 0 : methodToken.getStr();
-                const def = scope.findObjectDefinition(className);
+                const def = input.scope.findObjectDefinition(className);
                 // eslint-disable-next-line prefer-const
                 let { method, def: foundDef } = helper.searchMethodName(def, methodName);
                 if (method === undefined && (methodName === null || methodName === void 0 ? void 0 : methodName.toUpperCase()) === "CONSTRUCTOR") {
                     context = new basic_1.VoidType("CONSTRUCTOR"); // todo, this is a workaround, constructors always exists
                 }
                 else if (method === undefined && !(context instanceof basic_1.VoidType)) {
-                    throw new Error("Method or attribute \"" + methodName + "\" not found, MethodSource");
+                    const message = "Method or attribute \"" + methodName + "\" not found, MethodSource";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
                 }
                 else if (method) {
                     const extra = {
                         ooName: foundDef === null || foundDef === void 0 ? void 0 : foundDef.getName(),
                         ooType: foundDef instanceof types_1.ClassDefinition ? "CLAS" : "INTF"
                     };
-                    scope.addReference(methodToken, method, _reference_1.ReferenceType.MethodReference, filename, extra);
+                    input.scope.addReference(methodToken, method, _reference_1.ReferenceType.MethodReference, input.filename, extra);
                     context = method;
                 }
             }
@@ -97,52 +105,53 @@ class MethodSource {
                 if (context instanceof basic_1.TableType && context.isWithHeader()) {
                     context = context.getRowType();
                 }
-                context = new component_name_1.ComponentName().runSyntax(context, current);
+                context = new component_name_1.ComponentName().runSyntax(context, current, input);
             }
             else if (current instanceof nodes_1.ExpressionNode && current.get() instanceof Expressions.Dynamic) {
-                new dynamic_1.Dynamic().runSyntax(current, scope, filename);
+                new dynamic_1.Dynamic().runSyntax(current, input);
                 context = new basic_1.VoidType("Dynamic");
             }
         }
         if (context instanceof _abstract_type_1.AbstractType && !(context instanceof basic_1.VoidType)) {
-            throw new Error("Not a method, MethodSource");
+            const message = "Not a method, MethodSource";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
         }
         else if (context === undefined) {
-            throw new Error("Not found, MethodSource");
+            const message = "Not found, MethodSource";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
         }
         return context;
     }
     //////////////////////////////////////
-    findTop(first, scope, filename) {
+    findTop(first, input, children) {
         if (first.get() instanceof Expressions.ClassName) {
             // todo, refactor this part to new expression handler,
             const token = first.getFirstToken();
             const className = token.getStr();
-            const classDefinition = scope.findObjectDefinition(className);
-            if (classDefinition === undefined && scope.getDDIC().inErrorNamespace(className) === false) {
+            const classDefinition = input.scope.findObjectDefinition(className);
+            if (classDefinition === undefined && input.scope.getDDIC().inErrorNamespace(className) === false) {
                 const extra = { ooName: className, ooType: "Void" };
-                scope.addReference(token, undefined, _reference_1.ReferenceType.ObjectOrientedVoidReference, filename, extra);
+                input.scope.addReference(token, undefined, _reference_1.ReferenceType.ObjectOrientedVoidReference, input.filename, extra);
                 return new basic_1.VoidType(className);
             }
             else if (classDefinition === undefined) {
-                throw new Error("Class " + className + " not found");
+                const message = "Class " + className + " not found";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, first.getFirstToken(), message));
+                return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
             }
-            scope.addReference(first.getFirstToken(), classDefinition, _reference_1.ReferenceType.ObjectOrientedReference, filename);
+            input.scope.addReference(first.getFirstToken(), classDefinition, _reference_1.ReferenceType.ObjectOrientedReference, input.filename);
             return new basic_1.ObjectReferenceType(classDefinition);
         }
-        else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.SourceField) {
-            try {
-                return new source_field_1.SourceField().runSyntax(first, scope, filename, _reference_1.ReferenceType.DataReadReference);
-            }
-            catch (_a) {
-                return undefined;
-            }
+        else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.SourceField && children.length > 0) {
+            return new source_field_1.SourceField().runSyntax(first, input, _reference_1.ReferenceType.DataReadReference);
         }
         else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.SourceFieldSymbol) {
-            return new source_field_symbol_1.SourceFieldSymbol().runSyntax(first, scope, filename);
+            return new source_field_symbol_1.SourceFieldSymbol().runSyntax(first, input);
         }
         else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.Dynamic) {
-            new dynamic_1.Dynamic().runSyntax(first, scope, filename);
+            new dynamic_1.Dynamic().runSyntax(first, input);
             return new basic_1.VoidType("Dynamic");
         }
         return undefined;

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

@@ -9,51 +9,59 @@ const _object_oriented_1 = require("../_object_oriented");
 const method_parameters_1 = require("./method_parameters");
 const basic_types_1 = require("../basic_types");
 const _type_utils_1 = require("../_type_utils");
+const _syntax_input_1 = require("../_syntax_input");
+const assert_error_1 = require("../assert_error");
 class NewObject {
-    runSyntax(node, scope, targetType, filename) {
+    runSyntax(node, input, targetType) {
         let ret = undefined;
         const typeExpr = node.findDirectExpression(Expressions.TypeNameOrInfer);
         const typeToken = typeExpr === null || typeExpr === void 0 ? void 0 : typeExpr.getFirstToken();
         const typeName = typeExpr === null || typeExpr === void 0 ? void 0 : typeExpr.concatTokens();
         if (typeName === undefined) {
-            throw new Error("NewObject, child TypeNameOrInfer not found");
+            throw new assert_error_1.AssertError("NewObject, child TypeNameOrInfer not found");
         }
         else if (typeName === "#" && targetType && targetType instanceof basic_1.ObjectReferenceType) {
-            const clas = scope.findClassDefinition(targetType.getIdentifierName());
+            const clas = input.scope.findClassDefinition(targetType.getIdentifierName());
             if (clas) {
-                scope.addReference(typeToken, clas, _reference_1.ReferenceType.InferredType, filename);
+                input.scope.addReference(typeToken, clas, _reference_1.ReferenceType.InferredType, input.filename);
             }
             else {
-                const intf = scope.findInterfaceDefinition(targetType.getIdentifierName());
+                const intf = input.scope.findInterfaceDefinition(targetType.getIdentifierName());
                 if (intf) {
-                    throw new Error(intf.getName() + " is an interface, cannot be instantiated");
+                    const message = intf.getName() + " is an interface, cannot be instantiated";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
                 }
             }
             ret = targetType;
             if ((clas === null || clas === void 0 ? void 0 : clas.isAbstract()) === true) {
-                throw new Error(clas.getName() + " is abstract, cannot be instantiated");
+                const message = clas.getName() + " is abstract, cannot be instantiated";
+                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) {
             ret = targetType;
         }
         else if (typeName === "#") {
-            throw new Error("NewObject, todo, infer type");
+            throw new assert_error_1.AssertError("NewObject, todo, infer type");
         }
         if (ret === undefined) {
-            const objDefinition = scope.findObjectDefinition(typeName);
+            const objDefinition = input.scope.findObjectDefinition(typeName);
             if (objDefinition) {
-                scope.addReference(typeToken, objDefinition, _reference_1.ReferenceType.ObjectOrientedReference, filename);
+                input.scope.addReference(typeToken, objDefinition, _reference_1.ReferenceType.ObjectOrientedReference, input.filename);
                 const objref = new basic_1.ObjectReferenceType(objDefinition);
-                const clas = scope.findClassDefinition(objref.getIdentifierName());
+                const clas = input.scope.findClassDefinition(objref.getIdentifierName());
                 if ((clas === null || clas === void 0 ? void 0 : clas.isAbstract()) === true) {
-                    throw new Error(clas.getName() + " is abstract, cannot be instantiated");
+                    const message = clas.getName() + " is abstract, cannot be instantiated";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
                 }
                 ret = objref;
             }
         }
         if (ret === undefined) {
-            const basic = new basic_types_1.BasicTypes(filename, scope);
+            const basic = new basic_types_1.BasicTypes(input);
             const type = basic.resolveTypeName(typeExpr);
             if (type instanceof basic_1.UnknownType) {
                 ret = type;
@@ -65,26 +73,30 @@ class NewObject {
                 ret = type;
             }
             else {
-                throw new Error("Type \"" + typeName + "\" not found in scope, NewObject");
+                const message = "Type \"" + typeName + "\" not found in scope, NewObject";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
             }
         }
         if (ret instanceof basic_1.ObjectReferenceType) {
-            this.parameters(node, ret, scope, filename);
+            this.parameters(node, ret, input);
         }
         else {
             for (const s of node.findAllExpressions(Expressions.Source)) {
-                new source_1.Source().runSyntax(s, scope, filename, ret);
+                new source_1.Source().runSyntax(s, input, ret);
             }
         }
-        if (ret instanceof basic_1.UnknownType && scope.getDDIC().inErrorNamespace(typeName) === true) {
-            throw new Error("Class or type \"" + typeName + "\" not found");
+        if (ret instanceof basic_1.UnknownType && input.scope.getDDIC().inErrorNamespace(typeName) === true) {
+            const message = "Class or type \"" + typeName + "\" not found";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
         }
         return ret;
     }
-    parameters(node, obj, scope, filename) {
+    parameters(node, obj, input) {
         const name = obj.getIdentifier().getName();
-        const def = scope.findObjectDefinition(name);
-        const helper = new _object_oriented_1.ObjectOriented(scope);
+        const def = input.scope.findObjectDefinition(name);
+        const helper = new _object_oriented_1.ObjectOriented(input.scope);
         // eslint-disable-next-line prefer-const
         let { method } = helper.searchMethodName(def, "CONSTRUCTOR");
         const requiredParameters = (method === null || method === void 0 ? void 0 : method.getParameters().getRequiredParameters()) || [];
@@ -94,22 +106,30 @@ class NewObject {
             // single unnamed parameter
             const type = this.defaultImportingType(method);
             if (type === undefined) {
-                throw new Error("NewObject, no default importing parameter found for constructor, " + name);
+                const message = "NewObject, no default importing parameter found for constructor, " + name;
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
-            const sourceType = new source_1.Source().runSyntax(source, scope, filename, type);
-            if (new _type_utils_1.TypeUtils(scope).isAssignableStrict(sourceType, type) === false) {
-                throw new Error(`NEW parameter type not compatible`);
+            const sourceType = new source_1.Source().runSyntax(source, input, type);
+            if (new _type_utils_1.TypeUtils(input.scope).isAssignableStrict(sourceType, type) === false) {
+                const message = `NEW parameter type not compatible`;
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
         }
         else if (parameters) {
             // parameters with names
             if (method === undefined) {
-                throw new Error("NewObject, no parameters for constructor found, " + name);
+                const message = "NewObject, no parameters for constructor found, " + name;
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
-            new method_parameters_1.MethodParameters().checkExporting(parameters, scope, method, filename);
+            new method_parameters_1.MethodParameters().checkExporting(parameters, input, method);
         }
         else if (requiredParameters.length > 0) {
-            throw new Error(`constructor parameter "${requiredParameters[0].getName()}" must be supplied, ` + name);
+            const message = `constructor parameter "${requiredParameters[0].getName()}" must be supplied, ` + name;
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
     }
     defaultImportingType(method) {

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

@@ -4,9 +4,9 @@ exports.RaiseWith = void 0;
 const Expressions = require("../../2_statements/expressions");
 const source_1 = require("./source");
 class RaiseWith {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         for (const f of node.findDirectExpressions(Expressions.SimpleSource1)) {
-            new source_1.Source().runSyntax(f, scope, filename);
+            new source_1.Source().runSyntax(f, input);
         }
     }
 }