@abaplint/core 2.113.126 → 2.113.128

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

@@ -9,25 +9,25 @@ const fstarget_1 = require("./fstarget");
 const target_1 = require("./target");
 const source_1 = require("./source");
 class LoopGroupBy {
-    runSyntax(node, input) {
+    static 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, input, new basic_1.VoidType("todoGroupBy"));
+                inline_data_1.InlineData.runSyntax(inline, input, basic_1.VoidType.get("todoGroupBy"));
             }
             else {
-                new target_1.Target().runSyntax(t, input);
+                target_1.Target.runSyntax(t, input);
             }
         }
         for (const t of node.findAllExpressions(Expressions.FSTarget)) {
-            new fstarget_1.FSTarget().runSyntax(t, input, new basic_1.VoidType("todoGroupBy"));
+            fstarget_1.FSTarget.runSyntax(t, input, basic_1.VoidType.get("todoGroupBy"));
         }
         for (const t of node.findDirectExpressions(Expressions.Source)) {
-            new source_1.Source().runSyntax(t, input, new basic_1.VoidType("todoGroupBy"));
+            source_1.Source.runSyntax(t, input, basic_1.VoidType.get("todoGroupBy"));
         }
         for (const c of node.findDirectExpressions(Expressions.LoopGroupByComponent)) {
             for (const t of c.findDirectExpressions(Expressions.ComponentCompareSingle)) {
-                new component_compare_1.ComponentCompare().runSyntax(t, input);
+                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, input) {
+    static runSyntax(node, input) {
         var _a, _b, _c, _d, _e;
         for (const f of node.findDirectExpressions(Expressions.Source)) {
-            new source_1.Source().runSyntax(f, input);
+            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();

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, input, method) {
+    static runSyntax(node, input, method) {
         const parameters = node.findDirectExpression(Expressions.MethodParameters);
         if (parameters) {
             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, input, method);
+            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, input);
+            source_1.Source.runSyntax(s, input);
         }
     }
 }

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

@@ -15,26 +15,28 @@ const component_name_1 = require("./component_name");
 const attribute_name_1 = require("./attribute_name");
 const _syntax_input_1 = require("../_syntax_input");
 class MethodCallChain {
-    runSyntax(node, input, targetType) {
+    static runSyntax(node, input, targetType) {
         var _a, _b;
         const helper = new _object_oriented_1.ObjectOriented(input.scope);
-        const children = node.getChildren().slice();
-        const first = children.shift();
+        const children = node.getChildren();
+        const first = children[0];
         if (first === undefined) {
             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);
+            return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
         }
+        let currentIndex = 1;
         let context = this.findTop(first, input, targetType);
         if (first.get() instanceof Expressions.MethodCall) {
-            children.unshift(first);
+            currentIndex--;
         }
         let previous = undefined;
-        while (children.length > 0) {
-            const current = children.shift();
+        while (currentIndex <= children.length) {
+            const current = children[currentIndex];
             if (current === undefined) {
                 break;
             }
+            currentIndex++;
             if (current instanceof nodes_1.ExpressionNode && current.get() instanceof Expressions.MethodCall) {
                 // for built-in methods set className to undefined
                 const className = context instanceof basic_1.ObjectReferenceType ? context.getIdentifierName() : undefined;
@@ -53,7 +55,7 @@ class MethodCallChain {
                     if (previous && previous.getFirstToken().getStr() === "=>" && (method === null || method === void 0 ? void 0 : method.isStatic()) === false) {
                         const message = "Method \"" + methodName + "\" not static";
                         input.issues.push((0, _syntax_input_1.syntaxIssue)(input, methodToken, message));
-                        return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
+                        return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
                     }
                     const voidedName = context instanceof basic_1.VoidType ? context.getVoided() : undefined;
                     const extra = helper.methodReferenceExtras(foundDef, className || voidedName);
@@ -72,7 +74,7 @@ class MethodCallChain {
                 else if (method === undefined && !(context instanceof basic_1.VoidType)) {
                     const message = "Method \"" + methodName + "\" not found, methodCallChain";
                     input.issues.push((0, _syntax_input_1.syntaxIssue)(input, methodToken, message));
-                    return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
+                    return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
                 }
                 else if (method) {
                     const ret = (_b = method.getParameters().getReturning()) === null || _b === void 0 ? void 0 : _b.getType();
@@ -80,24 +82,24 @@ class MethodCallChain {
                 }
                 const param = current.findDirectExpression(Expressions.MethodCallParam);
                 if (param && method) {
-                    new method_call_param_1.MethodCallParam().runSyntax(param, input, method);
+                    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, input, context);
+                    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, input);
+                context = 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, input);
+                context = attribute_name_1.AttributeName.runSyntax(context, current, input);
             }
             previous = current;
         }
         return context;
     }
     //////////////////////////////////////
-    findTop(first, input, targetType) {
+    static findTop(first, input, targetType) {
         var _a;
         if (first.get() instanceof Expressions.ClassName) {
             const token = first.getFirstToken();
@@ -106,24 +108,24 @@ class MethodCallChain {
             if (classDefinition === undefined && input.scope.getDDIC().inErrorNamespace(className) === false) {
                 const extra = { ooName: className, ooType: "Void" };
                 input.scope.addReference(token, undefined, _reference_1.ReferenceType.ObjectOrientedVoidReference, input.filename, extra);
-                return new basic_1.VoidType(className);
+                return basic_1.VoidType.get(className);
             }
             else if (classDefinition === undefined) {
                 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);
+                return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
             }
             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, input, _reference_1.ReferenceType.DataReadReference);
+            return 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, input, targetType);
+            return 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, input, targetType);
+            return cast_1.Cast.runSyntax(first, input, targetType);
         }
         else {
             const meType = (_a = input.scope.findVariable("me")) === null || _a === void 0 ? void 0 : _a.getType();

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

@@ -10,7 +10,7 @@ const source_1 = require("./source");
 const _type_utils_1 = require("../_type_utils");
 const _syntax_input_1 = require("../_syntax_input");
 class MethodCallParam {
-    runSyntax(node, input, method) {
+    static runSyntax(node, input, method) {
         if (!(node.get() instanceof Expressions.MethodCallParam)) {
             const message = "MethodCallParam, unexpected input";
             input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
@@ -68,7 +68,7 @@ class MethodCallParam {
             }
             let sourceType = basic_1.StringType.get();
             if (child.get() instanceof Expressions.Source) {
-                sourceType = new source_1.Source().runSyntax(child, input, targetType);
+                sourceType = source_1.Source.runSyntax(child, input, targetType);
             }
             if (sourceType === undefined) {
                 const message = "No source type determined, method source";

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

@@ -7,7 +7,7 @@ const basic_1 = require("../../types/basic");
 const basic_types_1 = require("../basic_types");
 const assert_error_1 = require("../assert_error");
 class MethodDefReturning {
-    runSyntax(node, input, meta) {
+    static runSyntax(node, input, meta) {
         const name = node.findDirectExpression(Expressions.MethodParamName);
         if (name === undefined) {
             throw new assert_error_1.AssertError("method_parameter.ts, todo, handle pass by value and reference");

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

@@ -9,7 +9,7 @@ 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, input, meta) {
+    static runSyntax(node, input, meta) {
         const name = node.findDirectExpression(Expressions.MethodParamName);
         if (name === undefined) {
             throw new assert_error_1.AssertError("MethodParam, todo, handle pass by value and reference");
@@ -21,7 +21,7 @@ class MethodParam {
         const def = type.findDirectExpression(Expressions.Default);
         if (def) {
             try {
-                new default_1.Default().runSyntax(def, input);
+                default_1.Default.runSyntax(def, input);
             }
             catch (e) {
                 return new _typed_identifier_1.TypedIdentifier(name.getFirstToken(), input.filename, new basic_1.UnknownType(e.toString()), meta);
@@ -29,10 +29,10 @@ class MethodParam {
         }
         const concat = type.concatTokens().toUpperCase();
         if (concat === "TYPE C" || concat.startsWith("TYPE C ")) {
-            return new _typed_identifier_1.TypedIdentifier(name.getFirstToken(), input.filename, new cgeneric_type_1.CGenericType(), meta);
+            return new _typed_identifier_1.TypedIdentifier(name.getFirstToken(), input.filename, cgeneric_type_1.CGenericType.get(), meta);
         }
         else if (concat === "TYPE X" || concat.startsWith("TYPE X ")) {
-            return new _typed_identifier_1.TypedIdentifier(name.getFirstToken(), input.filename, new basic_1.XGenericType(), meta);
+            return new _typed_identifier_1.TypedIdentifier(name.getFirstToken(), input.filename, basic_1.XGenericType.get(), meta);
         }
         const found = new basic_types_1.BasicTypes(input).parseType(type);
         if (found) {

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

@@ -49,7 +49,7 @@ class MethodParameters {
                         const node = children.shift();
                         const exceptions = node.findFirstExpression(Expressions.ParameterException);
                         for (const s of (exceptions === null || exceptions === void 0 ? void 0 : exceptions.findAllExpressions(Expressions.SimpleFieldChain)) || []) {
-                            new field_chain_1.FieldChain().runSyntax(s, input, _reference_1.ReferenceType.DataReadReference);
+                            field_chain_1.FieldChain.runSyntax(s, input, _reference_1.ReferenceType.DataReadReference);
                         }
                     }
                     break;
@@ -76,10 +76,10 @@ class MethodParameters {
         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, input, type);
+            inline_data_1.InlineData.runSyntax(inline, input, type);
         }
         else if (target) {
-            const targetType = new target_1.Target().runSyntax(target, input);
+            const targetType = 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));
@@ -104,7 +104,7 @@ class MethodParameters {
             }
             const inline = item.target.findDirectExpression(Expressions.InlineData);
             if (inline) {
-                new inline_data_1.InlineData().runSyntax(inline, input, parameterType);
+                inline_data_1.InlineData.runSyntax(inline, input, parameterType);
             }
             else if (item.targetType === undefined) {
                 const message = "Could not determine target type";
@@ -210,7 +210,7 @@ class MethodParameters {
                     }
                 }
             }
-            let sourceType = new source_1.Source().runSyntax(source, input, targetType);
+            let sourceType = source_1.Source.runSyntax(source, input, targetType);
             if (sourceType === undefined) {
                 if (method instanceof basic_1.VoidType) {
                     sourceType = method;
@@ -218,7 +218,7 @@ class MethodParameters {
                 else {
                     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);
+                    sourceType = basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
                 }
             }
             ret.push({ name, source, sourceType });
@@ -246,7 +246,7 @@ class MethodParameters {
             if (target === undefined) {
                 throw new assert_error_1.AssertError("parameterListT, no target found");
             }
-            const targetType = new target_1.Target().runSyntax(target, input);
+            const targetType = target_1.Target.runSyntax(target, input);
             ret.push({ name, target, targetType });
         }
         return ret;

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

@@ -17,7 +17,7 @@ const version_1 = require("../../../version");
 const _syntax_input_1 = require("../_syntax_input");
 const assert_error_1 = require("../assert_error");
 class MethodSource {
-    runSyntax(node, input) {
+    static runSyntax(node, input) {
         var _a, _b, _c;
         const helper = new _object_oriented_1.ObjectOriented(input.scope);
         const children = node.getChildren().slice();
@@ -38,14 +38,14 @@ class MethodSource {
             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);
+                return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
             }
         }
         if (context instanceof basic_1.VoidType) {
             while (children.length > 0) {
                 const current = children.shift();
                 if (current instanceof nodes_1.ExpressionNode && current.get() instanceof Expressions.Dynamic) {
-                    new dynamic_1.Dynamic().runSyntax(current, input);
+                    dynamic_1.Dynamic.runSyntax(current, input);
                 }
             }
             return context;
@@ -59,12 +59,12 @@ class MethodSource {
                 if (context instanceof basic_1.UnknownType) {
                     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);
+                    return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
                 }
                 else if (!(context instanceof basic_1.StructureType)) {
                     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);
+                    return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
                 }
             }
             else if (current.get() instanceof tokens_1.InstanceArrow
@@ -74,7 +74,7 @@ class MethodSource {
             else if (current.get() instanceof Expressions.AttributeName
                 || current.get() instanceof Expressions.SourceField) {
                 if (context instanceof _abstract_type_1.AbstractType) {
-                    const attr = new attribute_name_1.AttributeName().runSyntax(context, current, input, _reference_1.ReferenceType.DataReadReference, false);
+                    const attr = 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;
@@ -89,12 +89,12 @@ class MethodSource {
                 // 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
+                    context = basic_1.VoidType.get("CONSTRUCTOR"); // todo, this is a workaround, constructors always exists
                 }
                 else if (method === undefined && !(context instanceof basic_1.VoidType)) {
                     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);
+                    return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
                 }
                 else if (method) {
                     const extra = helper.methodReferenceExtras(foundDef, className);
@@ -106,27 +106,27 @@ class MethodSource {
                 if (context instanceof basic_1.TableType && context.isWithHeader()) {
                     context = context.getRowType();
                 }
-                context = new component_name_1.ComponentName().runSyntax(context, current, input);
+                context = 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, input);
-                context = new basic_1.VoidType("Dynamic");
+                dynamic_1.Dynamic.runSyntax(current, input);
+                context = basic_1.VoidType.get("Dynamic");
             }
         }
         if (context instanceof _abstract_type_1.AbstractType && !(context instanceof basic_1.VoidType)) {
             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);
+            return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
         }
         else if (context === undefined) {
             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 basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
         }
         return context;
     }
     //////////////////////////////////////
-    findTop(first, input, children) {
+    static findTop(first, input, children) {
         if (first.get() instanceof Expressions.ClassName) {
             // todo, refactor this part to new expression handler,
             const token = first.getFirstToken();
@@ -135,25 +135,25 @@ class MethodSource {
             if (classDefinition === undefined && input.scope.getDDIC().inErrorNamespace(className) === false) {
                 const extra = { ooName: className, ooType: "Void" };
                 input.scope.addReference(token, undefined, _reference_1.ReferenceType.ObjectOrientedVoidReference, input.filename, extra);
-                return new basic_1.VoidType(className);
+                return basic_1.VoidType.get(className);
             }
             else if (classDefinition === undefined) {
                 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);
+                return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
             }
             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 && children.length > 0) {
-            return new source_field_1.SourceField().runSyntax(first, input, _reference_1.ReferenceType.DataReadReference);
+            return 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, input);
+            return 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, input);
-            return new basic_1.VoidType("Dynamic");
+            dynamic_1.Dynamic.runSyntax(first, input);
+            return basic_1.VoidType.get("Dynamic");
         }
         return undefined;
     }

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

@@ -12,7 +12,7 @@ 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, input, targetType) {
+    static runSyntax(node, input, targetType) {
         let ret = undefined;
         const typeExpr = node.findDirectExpression(Expressions.TypeNameOrInfer);
         const typeToken = typeExpr === null || typeExpr === void 0 ? void 0 : typeExpr.getFirstToken();
@@ -31,14 +31,14 @@ class NewObject {
                 if (intf) {
                     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);
+                    return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
                 }
             }
             ret = targetType;
             if ((clas === null || clas === void 0 ? void 0 : clas.isAbstract()) === true) {
                 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);
+                return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
             }
         }
         else if (typeName === "#" && targetType) {
@@ -57,7 +57,7 @@ class NewObject {
                 if ((clas === null || clas === void 0 ? void 0 : clas.isAbstract()) === true) {
                     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);
+                    return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
                 }
                 ret = objref;
             }
@@ -77,7 +77,7 @@ class NewObject {
             else {
                 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);
+                return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
             }
         }
         if (ret instanceof basic_1.ObjectReferenceType) {
@@ -85,17 +85,17 @@ class NewObject {
         }
         else {
             for (const s of node.findAllExpressions(Expressions.Source)) {
-                new source_1.Source().runSyntax(s, input, ret);
+                source_1.Source.runSyntax(s, input, ret);
             }
         }
         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 basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
         }
         return ret;
     }
-    parameters(node, obj, input) {
+    static parameters(node, obj, input) {
         const name = obj.getIdentifier().getName();
         const def = input.scope.findObjectDefinition(name);
         const helper = new _object_oriented_1.ObjectOriented(input.scope);
@@ -112,7 +112,7 @@ class NewObject {
                 input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
                 return;
             }
-            const sourceType = new source_1.Source().runSyntax(source, input, type);
+            const sourceType = 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));
@@ -134,7 +134,7 @@ class NewObject {
             return;
         }
     }
-    defaultImportingType(method) {
+    static defaultImportingType(method) {
         let targetType = undefined;
         if (method === undefined) {
             return undefined;

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, input) {
+    static runSyntax(node, input) {
         for (const f of node.findAllExpressionsMulti([Expressions.SimpleSource1, Expressions.Source])) {
-            new source_1.Source().runSyntax(f, input);
+            source_1.Source.runSyntax(f, input);
         }
     }
 }

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

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

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

@@ -5,15 +5,15 @@ const Expressions = require("../../2_statements/expressions");
 const source_1 = require("./source");
 const target_1 = require("./target");
 class ReduceNext {
-    runSyntax(node, input) {
+    static runSyntax(node, input) {
         if (node === undefined) {
             return;
         }
         for (const s of node.findDirectExpressions(Expressions.Source)) {
-            new source_1.Source().runSyntax(s, input);
+            source_1.Source.runSyntax(s, input);
         }
         for (const s of node.findDirectExpressions(Expressions.SimpleTarget)) {
-            new target_1.Target().runSyntax(s, input);
+            target_1.Target.runSyntax(s, input);
         }
     }
 }