@abaplint/core 2.111.0 → 2.112.0

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

@@ -5,15 +5,15 @@ const Expressions = require("../../2_statements/expressions");
 const inline_field_definition_1 = require("./inline_field_definition");
 const _scope_type_1 = require("../_scope_type");
 class Let {
-    runSyntax(node, scope, filename, skipScope = false) {
+    runSyntax(node, input, skipScope = false) {
         if (node === undefined) {
             return false;
         }
         if (skipScope !== true) {
-            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);
         }
         for (const f of node.findDirectExpressions(Expressions.InlineFieldDefinition)) {
-            new inline_field_definition_1.InlineFieldDefinition().runSyntax(f, scope, filename);
+            new inline_field_definition_1.InlineFieldDefinition().runSyntax(f, input);
         }
         return true;
     }

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

@@ -8,32 +8,22 @@ const inline_data_1 = require("./inline_data");
 const fstarget_1 = require("./fstarget");
 const target_1 = require("./target");
 class LoopGroupBy {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         for (const t of node.findAllExpressions(Expressions.Target)) {
             const inline = t.findDirectExpression(Expressions.InlineData);
             if (inline) {
-                new inline_data_1.InlineData().runSyntax(inline, scope, filename, new basic_1.VoidType("todoGroupBy"));
+                new inline_data_1.InlineData().runSyntax(inline, input, new basic_1.VoidType("todoGroupBy"));
             }
             else {
-                new target_1.Target().runSyntax(t, scope, filename);
+                new target_1.Target().runSyntax(t, input);
             }
         }
         for (const t of node.findAllExpressions(Expressions.FSTarget)) {
-            new fstarget_1.FSTarget().runSyntax(t, scope, filename, new basic_1.VoidType("todoGroupBy"));
+            new fstarget_1.FSTarget().runSyntax(t, input, new basic_1.VoidType("todoGroupBy"));
         }
-        /*
-        const components: IStructureComponent[] = [];
-        for (const c of node.findDirectExpressions(Expressions.LoopGroupByComponent)) {
-          components.push({name: c.getFirstToken().getStr(), type: new VoidType("todoGroupBy")});
-        }
-        if (components.length === 0) {
-          return;
-        }
-        */
-        //    const sourceType = new StructureType(components);
         for (const c of node.findDirectExpressions(Expressions.LoopGroupByComponent)) {
             for (const t of c.findDirectExpressions(Expressions.ComponentCompareSingle)) {
-                new component_compare_1.ComponentCompare().runSyntax(t, scope, filename);
+                new component_compare_1.ComponentCompare().runSyntax(t, input);
             }
         }
     }

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

@@ -4,10 +4,10 @@ exports.MessageSource = void 0;
 const Expressions = require("../../2_statements/expressions");
 const source_1 = require("./source");
 class MessageSource {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         var _a, _b, _c, _d, _e;
         for (const f of node.findDirectExpressions(Expressions.Source)) {
-            new source_1.Source().runSyntax(f, scope, filename);
+            new source_1.Source().runSyntax(f, input);
         }
         if (node.getFirstToken().getStr().toUpperCase() === "ID") {
             const id = (_a = node.findExpressionAfterToken("ID")) === null || _a === void 0 ? void 0 : _a.concatTokens();
@@ -20,7 +20,7 @@ class MessageSource {
             }
             if ((id === null || id === void 0 ? void 0 : id.startsWith("'")) && number) {
                 const messageClass = id.substring(1, id.length - 1).toUpperCase();
-                scope.getMSAGReferences().addUsing(filename, node.getFirstToken(), messageClass, number);
+                input.scope.getMSAGReferences().addUsing(input.filename, node.getFirstToken(), messageClass, number);
             }
         }
         else {
@@ -28,7 +28,7 @@ class MessageSource {
             const messageNumber = typeAndNumber === null || typeAndNumber === void 0 ? void 0 : typeAndNumber.substring(1);
             const messageClass = (_e = node.findDirectExpression(Expressions.MessageClass)) === null || _e === void 0 ? void 0 : _e.concatTokens().toUpperCase();
             if (messageNumber && messageClass) {
-                scope.getMSAGReferences().addUsing(filename, node.getFirstToken(), messageClass, messageNumber);
+                input.scope.getMSAGReferences().addUsing(input.filename, node.getFirstToken(), messageClass, messageNumber);
             }
         }
     }

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

@@ -6,18 +6,18 @@ const method_parameters_1 = require("./method_parameters");
 const source_1 = require("./source");
 const method_call_param_1 = require("./method_call_param");
 class MethodCallBody {
-    runSyntax(node, scope, filename, method) {
+    runSyntax(node, input, method) {
         const parameters = node.findDirectExpression(Expressions.MethodParameters);
         if (parameters) {
-            new method_parameters_1.MethodParameters().runSyntax(parameters, scope, method, filename);
+            new method_parameters_1.MethodParameters().runSyntax(parameters, input, method);
         }
         const param = node.findDirectExpression(Expressions.MethodCallParam);
         if (param) {
-            new method_call_param_1.MethodCallParam().runSyntax(param, scope, method, filename);
+            new method_call_param_1.MethodCallParam().runSyntax(param, input, method);
         }
         // for PARAMETER-TABLE and EXCEPTION-TABLE
         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/method_call_chain.js

@@ -14,16 +14,19 @@ const _reference_1 = require("../_reference");
 const component_name_1 = require("./component_name");
 const attribute_name_1 = require("./attribute_name");
 const class_definition_1 = require("../../types/class_definition");
+const _syntax_input_1 = require("../_syntax_input");
 class MethodCallChain {
-    runSyntax(node, scope, filename, targetType) {
+    runSyntax(node, input, targetType) {
         var _a, _b;
-        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("MethodCallChain, first child expected");
+            const message = "MethodCallChain, first child expected";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
         }
-        let context = this.findTop(first, scope, targetType, filename);
+        let context = this.findTop(first, input, targetType);
         if (first.get() instanceof Expressions.MethodCall) {
             children.unshift(first);
         }
@@ -38,37 +41,41 @@ class MethodCallChain {
                 const className = context instanceof basic_1.ObjectReferenceType ? context.getIdentifierName() : undefined;
                 const methodToken = (_a = current.findDirectExpression(Expressions.MethodName)) === null || _a === void 0 ? void 0 : _a.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 && current === first) {
                     method = new _builtin_1.BuiltIn().searchBuiltin(methodName === null || methodName === void 0 ? void 0 : methodName.toUpperCase());
                     if (method) {
-                        scope.addReference(methodToken, method, _reference_1.ReferenceType.BuiltinMethodReference, filename);
+                        input.scope.addReference(methodToken, method, _reference_1.ReferenceType.BuiltinMethodReference, input.filename);
                     }
                 }
                 else {
                     if (previous && previous.getFirstToken().getStr() === "=>" && (method === null || method === void 0 ? void 0 : method.isStatic()) === false) {
-                        throw new Error("Method \"" + methodName + "\" not static");
+                        const message = "Method \"" + methodName + "\" not static";
+                        input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                        return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
                     }
                     const extra = {
                         ooName: foundDef === null || foundDef === void 0 ? void 0 : foundDef.getName(),
                         ooType: foundDef instanceof class_definition_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);
                 }
                 if (methodName === null || methodName === void 0 ? void 0 : methodName.includes("~")) {
                     const name = methodName.split("~")[0];
-                    const idef = scope.findInterfaceDefinition(name);
+                    const idef = input.scope.findInterfaceDefinition(name);
                     if (idef) {
-                        scope.addReference(methodToken, idef, _reference_1.ReferenceType.ObjectOrientedReference, filename);
+                        input.scope.addReference(methodToken, idef, _reference_1.ReferenceType.ObjectOrientedReference, input.filename);
                     }
                 }
                 if (method === undefined && (methodName === null || methodName === void 0 ? void 0 : methodName.toUpperCase()) === "CONSTRUCTOR") {
                     context = undefined; // todo, this is a workaround, constructors always exists
                 }
                 else if (method === undefined && !(context instanceof basic_1.VoidType)) {
-                    throw new Error("Method \"" + methodName + "\" not found, methodCallChain");
+                    const message = "Method \"" + methodName + "\" not found, methodCallChain";
+                    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 ret = (_b = method.getParameters().getReturning()) === null || _b === void 0 ? void 0 : _b.getType();
@@ -76,51 +83,53 @@ class MethodCallChain {
                 }
                 const param = current.findDirectExpression(Expressions.MethodCallParam);
                 if (param && method) {
-                    new method_call_param_1.MethodCallParam().runSyntax(param, scope, method, filename);
+                    new method_call_param_1.MethodCallParam().runSyntax(param, input, method);
                 }
                 else if (param && context instanceof basic_1.VoidType) {
-                    new method_call_param_1.MethodCallParam().runSyntax(param, scope, context, filename);
+                    new method_call_param_1.MethodCallParam().runSyntax(param, input, context);
                 }
             }
             else if (current instanceof nodes_1.ExpressionNode && 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 instanceof nodes_1.ExpressionNode && current.get() instanceof Expressions.AttributeName) {
-                context = new attribute_name_1.AttributeName().runSyntax(context, current, scope, filename);
+                context = new attribute_name_1.AttributeName().runSyntax(context, current, input);
             }
             previous = current;
         }
         return context;
     }
     //////////////////////////////////////
-    findTop(first, scope, targetType, filename) {
+    findTop(first, input, targetType) {
         var _a;
         if (first.get() instanceof Expressions.ClassName) {
             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.FieldChain) {
-            return new field_chain_1.FieldChain().runSyntax(first, scope, filename, _reference_1.ReferenceType.DataReadReference);
+            return new field_chain_1.FieldChain().runSyntax(first, input, _reference_1.ReferenceType.DataReadReference);
         }
         else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.NewObject) {
-            return new new_object_1.NewObject().runSyntax(first, scope, targetType, filename);
+            return new new_object_1.NewObject().runSyntax(first, input, targetType);
         }
         else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.Cast) {
-            return new cast_1.Cast().runSyntax(first, scope, targetType, filename);
+            return new cast_1.Cast().runSyntax(first, input, targetType);
         }
         else {
-            const meType = (_a = scope.findVariable("me")) === null || _a === void 0 ? void 0 : _a.getType();
+            const meType = (_a = input.scope.findVariable("me")) === null || _a === void 0 ? void 0 : _a.getType();
             if (meType) {
                 return meType;
             }

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

@@ -8,21 +8,28 @@ const method_parameters_1 = require("./method_parameters");
 const tokens_1 = require("../../1_lexer/tokens");
 const source_1 = require("./source");
 const _type_utils_1 = require("../_type_utils");
+const _syntax_input_1 = require("../_syntax_input");
 class MethodCallParam {
-    runSyntax(node, scope, method, filename) {
+    runSyntax(node, input, method) {
         if (!(node.get() instanceof Expressions.MethodCallParam)) {
-            throw new Error("MethodCallParam, unexpected input");
+            const message = "MethodCallParam, unexpected input";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
         const children = node.getChildren();
         if (children.length < 2 || children.length > 3) {
-            throw new Error("MethodCallParam, unexpected child length");
+            const message = "MethodCallParam, unexpected child length";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
         const child = children[1];
         if (child.get() instanceof tokens_1.WParenRight || child.get() instanceof tokens_1.WParenRightW) {
             if (!(method instanceof basic_1.VoidType)) {
                 const required = method.getParameters().getRequiredParameters();
                 if (required.length > 0) {
-                    throw new Error("Parameter \"" + required[0].getName() + "\" must be supplied");
+                    const message = "Parameter \"" + required[0].getName() + "\" must be supplied";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return;
                 }
             }
         }
@@ -31,17 +38,23 @@ class MethodCallParam {
                 || child.get() instanceof Expressions.ConstantString)) {
             if (!(method instanceof basic_1.VoidType)) {
                 if (method.getParameters().getImporting().length === 0) {
-                    throw new Error("Method \"" + method.getName() + "\" has no importing parameters");
+                    const message = "Method \"" + method.getName() + "\" has no importing parameters";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return;
                 }
                 else if (method.getParameters().getRequiredParameters().length > 1) {
-                    throw new Error("Method \"" + method.getName() + "\" has more than one importing or changing parameter");
+                    const message = "Method \"" + method.getName() + "\" has more than one importing or changing parameter";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return;
                 }
             }
             let targetType = undefined;
             if (!(method instanceof basic_1.VoidType)) {
                 const name = method.getParameters().getDefaultImporting();
                 if (name === undefined) {
-                    throw new Error("No default importing parameter");
+                    const message = "No default importing parameter";
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return;
                 }
                 for (const i of method.getParameters().getImporting()) {
                     if (i.getName().toUpperCase() === name) {
@@ -55,27 +68,33 @@ class MethodCallParam {
             }
             let sourceType = basic_1.StringType.get();
             if (child.get() instanceof Expressions.Source) {
-                sourceType = new source_1.Source().runSyntax(child, scope, filename, targetType);
+                sourceType = new source_1.Source().runSyntax(child, input, targetType);
             }
             const calculated = child.findFirstExpression(Expressions.MethodCallChain) !== undefined
                 || child.findFirstExpression(Expressions.StringTemplate) !== undefined
                 || child.findFirstExpression(Expressions.ArithOperator) !== undefined;
             if (sourceType === undefined) {
-                throw new Error("No source type determined, method source");
+                const message = "No source type determined, method source";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
-            else if (new _type_utils_1.TypeUtils(scope).isAssignableStrict(sourceType, targetType, calculated) === false) {
-                throw new Error("Method parameter type not compatible");
+            else if (new _type_utils_1.TypeUtils(input.scope).isAssignableStrict(sourceType, targetType, calculated) === false) {
+                const message = "Method parameter type not compatible";
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
             }
         }
         else if (child instanceof nodes_1.ExpressionNode && child.get() instanceof Expressions.ParameterListS) {
-            new method_parameters_1.MethodParameters().checkExporting(child, scope, method, filename);
+            new method_parameters_1.MethodParameters().checkExporting(child, input, method);
         }
         else if (child.get() instanceof Expressions.MethodParameters) {
-            new method_parameters_1.MethodParameters().runSyntax(child, scope, method, filename);
+            new method_parameters_1.MethodParameters().runSyntax(child, input, method);
         }
         else {
             //      console.dir(child);
-            throw new Error("MethodCallParam, unexpected child");
+            const message = "MethodCallParam, unexpected child";
+            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+            return;
         }
     }
 }

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

@@ -5,25 +5,26 @@ const Expressions = require("../../2_statements/expressions");
 const _typed_identifier_1 = require("../../types/_typed_identifier");
 const basic_1 = require("../../types/basic");
 const basic_types_1 = require("../basic_types");
+const assert_error_1 = require("../assert_error");
 class MethodDefReturning {
-    runSyntax(node, scope, filename, meta) {
+    runSyntax(node, input, meta) {
         const name = node.findDirectExpression(Expressions.MethodParamName);
         if (name === undefined) {
-            throw new Error("method_parameter.ts, todo, handle pass by value and reference");
+            throw new assert_error_1.AssertError("method_parameter.ts, todo, handle pass by value and reference");
         }
         const type = node.findDirectExpression(Expressions.TypeParam);
         if (type === undefined) {
-            throw new Error("method_parameter.ts, unexpected structure");
+            throw new assert_error_1.AssertError("method_parameter.ts, unexpected structure");
         }
-        let found = new basic_types_1.BasicTypes(filename, scope).parseType(type);
+        let found = new basic_types_1.BasicTypes(input).parseType(type);
         if ((found === null || found === void 0 ? void 0 : found.isGeneric()) === true) {
             found = new basic_1.UnknownType("RETURNING parameter must be fully specified");
         }
         if (found) {
-            return new _typed_identifier_1.TypedIdentifier(name.getFirstToken(), filename, found, meta);
+            return new _typed_identifier_1.TypedIdentifier(name.getFirstToken(), input.filename, found, meta);
         }
         else {
-            return new _typed_identifier_1.TypedIdentifier(name.getFirstToken(), filename, new basic_1.UnknownType("method param, todo"), meta);
+            return new _typed_identifier_1.TypedIdentifier(name.getFirstToken(), input.filename, new basic_1.UnknownType("method param, todo"), meta);
         }
     }
 }

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

@@ -7,38 +7,39 @@ const basic_types_1 = require("../basic_types");
 const Expressions = require("../../2_statements/expressions");
 const default_1 = require("./default");
 const cgeneric_type_1 = require("../../types/basic/cgeneric_type");
+const assert_error_1 = require("../assert_error");
 class MethodParam {
-    runSyntax(node, scope, filename, meta) {
+    runSyntax(node, input, meta) {
         const name = node.findDirectExpression(Expressions.MethodParamName);
         if (name === undefined) {
-            throw new Error("MethodParam, todo, handle pass by value and reference");
+            throw new assert_error_1.AssertError("MethodParam, todo, handle pass by value and reference");
         }
         const type = node.findDirectExpression(Expressions.TypeParam);
         if (type === undefined) {
-            throw new Error("MethodParam, unexpected structure");
+            throw new assert_error_1.AssertError("MethodParam, unexpected structure");
         }
         const def = type.findDirectExpression(Expressions.Default);
         if (def) {
             try {
-                new default_1.Default().runSyntax(def, scope, filename);
+                new default_1.Default().runSyntax(def, input);
             }
             catch (e) {
-                return new _typed_identifier_1.TypedIdentifier(name.getFirstToken(), filename, new basic_1.UnknownType(e.toString()), meta);
+                return new _typed_identifier_1.TypedIdentifier(name.getFirstToken(), input.filename, new basic_1.UnknownType(e.toString()), meta);
             }
         }
         const concat = type.concatTokens().toUpperCase();
         if (concat === "TYPE C" || concat.startsWith("TYPE C ")) {
-            return new _typed_identifier_1.TypedIdentifier(name.getFirstToken(), filename, new cgeneric_type_1.CGenericType(), meta);
+            return new _typed_identifier_1.TypedIdentifier(name.getFirstToken(), input.filename, new cgeneric_type_1.CGenericType(), meta);
         }
         else if (concat === "TYPE X" || concat.startsWith("TYPE X ")) {
-            return new _typed_identifier_1.TypedIdentifier(name.getFirstToken(), filename, new basic_1.XGenericType(), meta);
+            return new _typed_identifier_1.TypedIdentifier(name.getFirstToken(), input.filename, new basic_1.XGenericType(), meta);
         }
-        const found = new basic_types_1.BasicTypes(filename, scope).parseType(type);
+        const found = new basic_types_1.BasicTypes(input).parseType(type);
         if (found) {
-            return new _typed_identifier_1.TypedIdentifier(name.getFirstToken(), filename, found, meta);
+            return new _typed_identifier_1.TypedIdentifier(name.getFirstToken(), input.filename, found, meta);
         }
         else {
-            return new _typed_identifier_1.TypedIdentifier(name.getFirstToken(), filename, new basic_1.UnknownType("method param, todo"), meta);
+            return new _typed_identifier_1.TypedIdentifier(name.getFirstToken(), input.filename, new basic_1.UnknownType("method param, todo"), meta);
         }
     }
 }