@abaplint/core 2.113.126 → 2.113.128

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

@@ -16,11 +16,11 @@ const _reference_1 = require("../_reference");
 const _syntax_input_1 = require("../_syntax_input");
 const isSimple = /^\w+$/;
 class Select {
-    runSyntax(node, input, skipImplicitInto = false) {
+    static runSyntax(node, input, skipImplicitInto = false) {
         var _a;
         const token = node.getFirstToken();
         const from = node.findDirectExpression(Expressions.SQLFrom);
-        const dbSources = from ? new sql_from_1.SQLFrom().runSyntax(from, input) : [];
+        const dbSources = from ? sql_from_1.SQLFrom.runSyntax(from, input) : [];
         if (from === undefined) {
             const message = `Missing FROM`;
             input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
@@ -39,10 +39,10 @@ class Select {
         const fae = node.findDirectExpression(Expressions.SQLForAllEntries);
         if (fae) {
             input.scope.push(_scope_type_1.ScopeType.OpenSQL, "SELECT", token.getStart(), input.filename);
-            new sql_for_all_entries_1.SQLForAllEntries().runSyntax(fae, input);
+            sql_for_all_entries_1.SQLForAllEntries.runSyntax(fae, input);
         }
         for (const t of node.findAllExpressions(Expressions.Target)) {
-            new target_1.Target().runSyntax(t, input);
+            target_1.Target.runSyntax(t, input);
         }
         // check implicit into, the target field is implict equal to the table name
         if (skipImplicitInto === false
@@ -68,23 +68,23 @@ class Select {
         }
         // OFFSET
         for (const s of node.findDirectExpressions(Expressions.SQLSource)) {
-            new sql_source_1.SQLSource().runSyntax(s, input);
+            sql_source_1.SQLSource.runSyntax(s, input);
         }
         for (const up of node.findDirectExpressions(Expressions.SQLUpTo)) {
             for (const s of up.findDirectExpressions(Expressions.SQLSource)) {
-                new sql_source_1.SQLSource().runSyntax(s, input);
+                sql_source_1.SQLSource.runSyntax(s, input);
             }
         }
         for (const fae of node.findDirectExpressions(Expressions.SQLForAllEntries)) {
             for (const s of fae.findDirectExpressions(Expressions.SQLSource)) {
-                new sql_source_1.SQLSource().runSyntax(s, input);
+                sql_source_1.SQLSource.runSyntax(s, input);
             }
         }
         for (const s of node.findAllExpressions(Expressions.SQLCompare)) {
-            new sql_compare_1.SQLCompare().runSyntax(s, input, dbSources);
+            sql_compare_1.SQLCompare.runSyntax(s, input, dbSources);
         }
         for (const s of node.findDirectExpressions(Expressions.SQLOrderBy)) {
-            new sql_order_by_1.SQLOrderBy().runSyntax(s, input);
+            sql_order_by_1.SQLOrderBy.runSyntax(s, input);
         }
         if (this.isStrictMode(node)) {
             this.strictModeChecks(node, input);
@@ -94,7 +94,7 @@ class Select {
         }
     }
     // there are multiple rules, but gotta start somewhere
-    isStrictMode(node) {
+    static isStrictMode(node) {
         const into = node.findDirectExpressionsMulti([Expressions.SQLIntoList, Expressions.SQLIntoStructure, Expressions.SQLIntoTable])[0];
         const where = node.findDirectExpression(Expressions.SQLCond);
         // INTO is after WHERE
@@ -118,7 +118,7 @@ class Select {
         }
         return false;
     }
-    strictModeChecks(node, input) {
+    static strictModeChecks(node, input) {
         const sources = node.findAllExpressions(Expressions.SQLSource);
         for (const source of sources) {
             const first = source.getFirstChild();
@@ -135,19 +135,19 @@ class Select {
             input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
         }
     }
-    handleInto(node, input, fields, dbSources) {
+    static handleInto(node, input, fields, dbSources) {
         const intoTable = node.findDirectExpression(Expressions.SQLIntoTable);
         if (intoTable) {
             const inline = intoTable.findFirstExpression(Expressions.InlineData);
             if (inline) {
-                new inline_data_1.InlineData().runSyntax(inline, input, this.buildTableType(fields, dbSources, input.scope));
+                inline_data_1.InlineData.runSyntax(inline, input, this.buildTableType(fields, dbSources, input.scope));
             }
         }
         const intoStructure = node.findDirectExpression(Expressions.SQLIntoStructure);
         if (intoStructure) {
             for (const inline of intoStructure.findAllExpressions(Expressions.InlineData)) {
                 // todo, for now these are voided
-                new inline_data_1.InlineData().runSyntax(inline, input, new basic_1.VoidType("SELECT_todo"));
+                inline_data_1.InlineData.runSyntax(inline, input, basic_1.VoidType.get("SELECT_todo"));
             }
         }
         const intoList = node.findDirectExpression(Expressions.SQLIntoList);
@@ -169,7 +169,7 @@ class Select {
                         input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
                         return;
                     }
-                    let type = new basic_1.VoidType("SELECT_todo");
+                    let type = basic_1.VoidType.get("SELECT_todo");
                     if (isSimple.test(field.code)) {
                         for (const dbSource of dbSources) {
                             if (dbSource === undefined) {
@@ -185,12 +185,12 @@ class Select {
                             }
                         }
                     }
-                    new inline_data_1.InlineData().runSyntax(inline, input, type);
+                    inline_data_1.InlineData.runSyntax(inline, input, type);
                 }
             }
         }
     }
-    checkFields(fields, dbSources, input, node) {
+    static checkFields(fields, dbSources, input, node) {
         if (dbSources.length > 1) {
             return;
         }
@@ -219,17 +219,17 @@ class Select {
             }
         }
     }
-    buildTableType(fields, dbSources, scope) {
+    static buildTableType(fields, dbSources, scope) {
         if (dbSources.length !== 1) {
-            return new basic_1.VoidType("SELECT_todo");
+            return basic_1.VoidType.get("SELECT_todo");
         }
         if (dbSources[0] === undefined) {
             // then its a voided table
-            return new basic_1.VoidType("SELECT_todo");
+            return basic_1.VoidType.get("SELECT_todo");
         }
         const dbType = dbSources[0].parseType(scope.getRegistry());
         if (!(dbType instanceof basic_1.StructureType)) {
-            return new basic_1.VoidType("SELECT_todo");
+            return basic_1.VoidType.get("SELECT_todo");
         }
         if (fields.length === 1 && fields[0].code === "*") {
             return new basic_1.TableType(dbType, { withHeader: false, keyType: basic_1.TableKeyType.default }, undefined);
@@ -240,15 +240,15 @@ class Select {
             for (const field of fields) {
                 const type = dbType.getComponentByName(field.code);
                 if (type === undefined) {
-                    return new basic_1.VoidType("SELECT_todo");
+                    return basic_1.VoidType.get("SELECT_todo");
                 }
                 components.push({ name: field.code, type });
             }
             return new basic_1.TableType(new basic_1.StructureType(components), { withHeader: false, keyType: basic_1.TableKeyType.default }, undefined);
         }
-        return new basic_1.VoidType("SELECT_todo");
+        return basic_1.VoidType.get("SELECT_todo");
     }
-    findFields(node, input) {
+    static findFields(node, input) {
         var _a, _b;
         let expr = undefined;
         const ret = [];
@@ -257,7 +257,7 @@ class Select {
             expr = node.findFirstExpression(Expressions.SQLFieldListLoop);
         }
         if (((_a = expr === null || expr === void 0 ? void 0 : expr.getFirstChild()) === null || _a === void 0 ? void 0 : _a.get()) instanceof Expressions.Dynamic) {
-            new dynamic_1.Dynamic().runSyntax(expr.getFirstChild(), input);
+            dynamic_1.Dynamic.runSyntax(expr.getFirstChild(), input);
         }
         for (const field of (expr === null || expr === void 0 ? void 0 : expr.findDirectExpressionsMulti([Expressions.SQLField, Expressions.SQLFieldName])) || []) {
             let code = field.concatTokens().toUpperCase();

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

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

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

@@ -37,7 +37,7 @@ const assert_error_1 = require("../assert_error");
 * DATA(bar) = VALUE #( ... ).     give error, no type can be derived
 */
 class Source {
-    runSyntax(node, input, targetType, writeReference = false) {
+    static runSyntax(node, input, targetType, writeReference = false) {
         if (node === undefined) {
             return undefined;
         }
@@ -56,20 +56,20 @@ class Source {
                     {
                         const method = new _builtin_1.BuiltIn().searchBuiltin(tok);
                         input.scope.addReference(token, method, _reference_1.ReferenceType.BuiltinMethodReference, input.filename);
-                        new cond_1.Cond().runSyntax(node.findDirectExpression(Expressions.Cond), input);
+                        cond_1.Cond.runSyntax(node.findDirectExpression(Expressions.Cond), input);
                         return basic_1.StringType.get();
                     }
                 case "XSDBOOL":
                     {
                         const method = new _builtin_1.BuiltIn().searchBuiltin(tok);
                         input.scope.addReference(token, method, _reference_1.ReferenceType.BuiltinMethodReference, input.filename);
-                        new cond_1.Cond().runSyntax(node.findDirectExpression(Expressions.Cond), input);
+                        cond_1.Cond.runSyntax(node.findDirectExpression(Expressions.Cond), input);
                         return new basic_1.CharacterType(1, { qualifiedName: "ABAP_BOOL", ddicName: "ABAP_BOOL" });
                     }
                 case "REDUCE":
                     {
                         const foundType = this.determineType(node, input, targetType);
-                        const bodyType = new reduce_body_1.ReduceBody().runSyntax(node.findDirectExpression(Expressions.ReduceBody), input, foundType);
+                        const bodyType = reduce_body_1.ReduceBody.runSyntax(node.findDirectExpression(Expressions.ReduceBody), input, foundType);
                         if (foundType === undefined || foundType.isGeneric()) {
                             this.addIfInferred(node, input, bodyType);
                         }
@@ -81,7 +81,7 @@ class Source {
                 case "SWITCH":
                     {
                         const foundType = this.determineType(node, input, targetType);
-                        const bodyType = new switch_body_1.SwitchBody().runSyntax(node.findDirectExpression(Expressions.SwitchBody), input);
+                        const bodyType = switch_body_1.SwitchBody.runSyntax(node.findDirectExpression(Expressions.SwitchBody), input);
                         if (foundType === undefined || foundType.isGeneric()) {
                             this.addIfInferred(node, input, bodyType);
                         }
@@ -93,7 +93,7 @@ class Source {
                 case "COND":
                     {
                         const foundType = this.determineType(node, input, targetType);
-                        const bodyType = new cond_body_1.CondBody().runSyntax(node.findDirectExpression(Expressions.CondBody), input, foundType);
+                        const bodyType = cond_body_1.CondBody.runSyntax(node.findDirectExpression(Expressions.CondBody), input, foundType);
                         if (foundType === undefined || foundType.isGeneric()) {
                             this.addIfInferred(node, input, bodyType);
                         }
@@ -110,11 +110,11 @@ class Source {
                 case "CONV":
                     {
                         const foundType = this.determineType(node, input, targetType);
-                        const bodyType = new conv_body_1.ConvBody().runSyntax(node.findDirectExpression(Expressions.ConvBody), input);
+                        const bodyType = conv_body_1.ConvBody.runSyntax(node.findDirectExpression(Expressions.ConvBody), input);
                         if (new _type_utils_1.TypeUtils(input.scope).isAssignable(foundType, bodyType) === false) {
                             const message = `CONV: Types not compatible, ${foundType === null || foundType === void 0 ? void 0 : foundType.constructor.name}, ${bodyType === null || bodyType === void 0 ? void 0 : bodyType.constructor.name}`;
                             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);
                         }
                         this.addIfInferred(node, input, foundType);
                         return foundType;
@@ -122,7 +122,7 @@ class Source {
                 case "REF":
                     {
                         const foundType = this.determineType(node, input, targetType);
-                        const s = new Source().runSyntax(node.findDirectExpression(Expressions.Source), input);
+                        const s = Source.runSyntax(node.findDirectExpression(Expressions.Source), input);
                         if (foundType === undefined && s) {
                             return new basic_1.DataReference(s);
                         }
@@ -134,7 +134,7 @@ class Source {
                 case "FILTER":
                     {
                         const foundType = this.determineType(node, input, targetType);
-                        const bodyType = new filter_body_1.FilterBody().runSyntax(node.findDirectExpression(Expressions.FilterBody), input, foundType);
+                        const bodyType = filter_body_1.FilterBody.runSyntax(node.findDirectExpression(Expressions.FilterBody), input, foundType);
                         if (foundType === undefined || foundType.isGeneric()) {
                             this.addIfInferred(node, input, bodyType);
                         }
@@ -151,21 +151,21 @@ class Source {
                 case "CORRESPONDING":
                     {
                         const foundType = this.determineType(node, input, targetType);
-                        new corresponding_body_1.CorrespondingBody().runSyntax(node.findDirectExpression(Expressions.CorrespondingBody), input, foundType);
+                        corresponding_body_1.CorrespondingBody.runSyntax(node.findDirectExpression(Expressions.CorrespondingBody), input, foundType);
                         this.addIfInferred(node, input, foundType);
                         return foundType;
                     }
                 case "EXACT":
                     {
                         const foundType = this.determineType(node, input, targetType);
-                        new Source().runSyntax(node.findDirectExpression(Expressions.Source), input, foundType);
+                        Source.runSyntax(node.findDirectExpression(Expressions.Source), input, foundType);
                         this.addIfInferred(node, input, foundType);
                         return foundType;
                     }
                 case "VALUE":
                     {
                         const foundType = this.determineType(node, input, targetType);
-                        const bodyType = new value_body_1.ValueBody().runSyntax(node.findDirectExpression(Expressions.ValueBody), input, foundType);
+                        const bodyType = value_body_1.ValueBody.runSyntax(node.findDirectExpression(Expressions.ValueBody), input, foundType);
                         if (foundType === undefined || foundType.isGeneric()) {
                             this.addIfInferred(node, input, bodyType);
                         }
@@ -189,46 +189,49 @@ class Source {
         let hexExpected = false;
         let hexNext = false;
         while (children.length >= 0) {
-            if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.MethodCallChain) {
-                context = new method_call_chain_1.MethodCallChain().runSyntax(first, input, targetType);
-                if (context === undefined) {
-                    const message = "Method has no RETURNING value";
-                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
-                    return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
+            if (first instanceof nodes_1.ExpressionNode) {
+                const get = first.get();
+                if (get instanceof Expressions.MethodCallChain) {
+                    context = method_call_chain_1.MethodCallChain.runSyntax(first, input, targetType);
+                    if (context === undefined) {
+                        const message = "Method has no RETURNING value";
+                        input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                        return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
+                    }
                 }
-            }
-            else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.FieldChain) {
-                context = new field_chain_1.FieldChain().runSyntax(first, input, type);
-            }
-            else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.StringTemplate) {
-                context = new string_template_1.StringTemplate().runSyntax(first, input);
-            }
-            else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.Source) {
-                const found = new Source().runSyntax(first, input);
-                context = this.infer(context, found);
-            }
-            else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.Constant) {
-                const found = new constant_1.Constant().runSyntax(first);
-                context = this.infer(context, found);
-            }
-            else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.Dereference) {
-                context = new dereference_1.Dereference().runSyntax(first, context, input);
-            }
-            else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.ComponentChain) {
-                context = new component_chain_1.ComponentChain().runSyntax(context, first, input);
-            }
-            else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.ArithOperator) {
-                if (first.concatTokens() === "**") {
-                    context = new basic_1.FloatType();
+                else if (get instanceof Expressions.FieldChain) {
+                    context = field_chain_1.FieldChain.runSyntax(first, input, type);
                 }
-                const operator = first.concatTokens().toUpperCase();
-                if (operator === "BIT-OR" || operator === "BIT-AND" || operator === "BIT-XOR") {
-                    hexExpected = true;
-                    hexNext = true;
+                else if (get instanceof Expressions.StringTemplate) {
+                    context = string_template_1.StringTemplate.runSyntax(first, input);
+                }
+                else if (get instanceof Expressions.Source) {
+                    const found = Source.runSyntax(first, input);
+                    context = this.infer(context, found);
+                }
+                else if (get instanceof Expressions.Constant) {
+                    const found = constant_1.Constant.runSyntax(first);
+                    context = this.infer(context, found);
+                }
+                else if (get instanceof Expressions.Dereference) {
+                    context = dereference_1.Dereference.runSyntax(first, context, input);
+                }
+                else if (get instanceof Expressions.ComponentChain) {
+                    context = component_chain_1.ComponentChain.runSyntax(context, first, input);
+                }
+                else if (get instanceof Expressions.ArithOperator) {
+                    if (first.concatTokens() === "**") {
+                        context = new basic_1.FloatType();
+                    }
+                    const operator = first.concatTokens().toUpperCase();
+                    if (operator === "BIT-OR" || operator === "BIT-AND" || operator === "BIT-XOR") {
+                        hexExpected = true;
+                        hexNext = true;
+                    }
+                }
+                else if (get instanceof Expressions.AttributeChain) {
+                    context = attribute_chain_1.AttributeChain.runSyntax(context, first, input, type);
                 }
-            }
-            else if (first instanceof nodes_1.ExpressionNode && first.get() instanceof Expressions.AttributeChain) {
-                context = new attribute_chain_1.AttributeChain().runSyntax(context, first, input, type);
             }
             if (hexExpected === true) {
                 if (!(context instanceof basic_1.VoidType)
@@ -239,7 +242,7 @@ class Source {
                     && !(context instanceof unknown_type_1.UnknownType)) {
                     const message = "Operator only valid for XSTRING or HEX";
                     input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
-                    return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
+                    return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
                 }
                 if (hexNext === false) {
                     hexExpected = false;
@@ -257,13 +260,13 @@ class Source {
         return context;
     }
     ////////////////////////////////
-    traverseRemainingChildren(children, input) {
+    static traverseRemainingChildren(children, input) {
         const last = children[children.length - 1];
         if (last && last.get() instanceof Expressions.Source) {
-            new Source().runSyntax(last, input);
+            Source.runSyntax(last, input);
         }
     }
-    infer(context, found) {
+    static infer(context, found) {
         if (context instanceof basic_1.FloatType && found instanceof basic_1.IntegerType) {
             return context;
         }
@@ -271,9 +274,9 @@ class Source {
             return found;
         }
     }
-    addIfInferred(node, input, inferredType) {
+    static addIfInferred(node, input, inferredType) {
         const basic = new basic_types_1.BasicTypes(input);
-        const typeExpression = node.findFirstExpression(Expressions.TypeNameOrInfer);
+        const typeExpression = node.findDirectExpression(Expressions.TypeNameOrInfer);
         const typeToken = typeExpression === null || typeExpression === void 0 ? void 0 : typeExpression.getFirstToken();
         const typeName = typeToken === null || typeToken === void 0 ? void 0 : typeToken.getStr();
         if (typeName === "#" && inferredType && typeToken) {
@@ -295,9 +298,9 @@ class Source {
             }
         }
     }
-    determineType(node, input, targetType) {
+    static determineType(node, input, targetType) {
         const basic = new basic_types_1.BasicTypes(input);
-        const typeExpression = node.findFirstExpression(Expressions.TypeNameOrInfer);
+        const typeExpression = node.findDirectExpression(Expressions.TypeNameOrInfer);
         const typeToken = typeExpression === null || typeExpression === void 0 ? void 0 : typeExpression.getFirstToken();
         const typeName = typeToken === null || typeToken === void 0 ? void 0 : typeToken.getStr();
         if (typeExpression === undefined) {
@@ -311,7 +314,7 @@ class Source {
             if (found && found instanceof unknown_type_1.UnknownType) {
                 if (input.scope.getDDIC().inErrorNamespace(typeName) === false) {
                     input.scope.addReference(typeToken, undefined, _reference_1.ReferenceType.VoidType, input.filename);
-                    return new basic_1.VoidType(typeName);
+                    return basic_1.VoidType.get(typeName);
                 }
                 else {
                     const tid = new _typed_identifier_1.TypedIdentifier(typeToken, input.filename, found);
@@ -322,7 +325,7 @@ class Source {
             else if (found === undefined) {
                 const message = "Type \"" + typeName + "\" not found in scope, VALUE";
                 input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
-                return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
+                return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
             }
             return found;
         }

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

@@ -5,7 +5,7 @@ const basic_1 = require("../../types/basic");
 const _reference_1 = require("../_reference");
 const _syntax_input_1 = require("../_syntax_input");
 class SourceField {
-    runSyntax(node, input, type, error = true) {
+    static runSyntax(node, input, type, error = true) {
         const token = node.getFirstToken();
         const name = token.getStr();
         const found = input.scope.findVariable(name);
@@ -14,7 +14,7 @@ class SourceField {
             if (error === true) {
                 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 (type) {
             input.scope.addReference(token, found, type, input.filename);

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

@@ -5,13 +5,13 @@ const basic_1 = require("../../types/basic");
 const _reference_1 = require("../_reference");
 const _syntax_input_1 = require("../_syntax_input");
 class SourceFieldSymbol {
-    runSyntax(node, input) {
+    static runSyntax(node, input) {
         const token = node.getFirstToken();
         const found = input.scope.findVariable(token.getStr());
         if (found === undefined) {
             const message = "\"" + node.getFirstToken().getStr() + "\" not found, SourceFieldSymbol";
             input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
-            return new basic_1.VoidType(_syntax_input_1.CheckSyntaxKey);
+            return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
         }
         input.scope.addReference(token, found, _reference_1.ReferenceType.DataReadReference, input.filename);
         return found.getType();

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

@@ -9,16 +9,16 @@ const source_1 = require("./source");
 const sql_in_1 = require("./sql_in");
 const sql_source_1 = require("./sql_source");
 class SQLCompare {
-    runSyntax(node, input, tables) {
+    static runSyntax(node, input, tables) {
         var _a, _b;
         let sourceType;
         let token;
         if (((_a = node.getFirstChild()) === null || _a === void 0 ? void 0 : _a.get()) instanceof Expressions.Dynamic) {
-            new dynamic_1.Dynamic().runSyntax(node.getFirstChild(), input);
+            dynamic_1.Dynamic.runSyntax(node.getFirstChild(), input);
             return;
         }
         for (const s of node.findDirectExpressions(Expressions.SimpleSource3)) {
-            new source_1.Source().runSyntax(s, input);
+            source_1.Source.runSyntax(s, input);
         }
         for (const s of node.findDirectExpressions(Expressions.SQLSource)) {
             for (const child of s.getChildren()) {
@@ -27,11 +27,11 @@ class SQLCompare {
                     break;
                 }
             }
-            sourceType = new sql_source_1.SQLSource().runSyntax(s, input);
+            sourceType = sql_source_1.SQLSource.runSyntax(s, input);
         }
         const sqlin = node.findDirectExpression(Expressions.SQLIn);
         if (sqlin) {
-            new sql_in_1.SQLIn().runSyntax(sqlin, input);
+            sql_in_1.SQLIn.runSyntax(sqlin, input);
         }
         const fieldName = (_b = node.findDirectExpression(Expressions.SQLFieldName)) === null || _b === void 0 ? void 0 : _b.concatTokens();
         if (fieldName && sourceType && token) {
@@ -69,7 +69,7 @@ class SQLCompare {
             }
         }
     }
-    findType(fieldName, tables, scope) {
+    static findType(fieldName, tables, scope) {
         for (const t of tables) {
             const type = t === null || t === void 0 ? void 0 : t.parseType(scope.getRegistry());
             if (type instanceof basic_1.StructureType) {

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

@@ -6,13 +6,13 @@ const source_1 = require("./source");
 const basic_1 = require("../../types/basic");
 const _syntax_input_1 = require("../_syntax_input");
 class SQLForAllEntries {
-    runSyntax(node, input) {
+    static runSyntax(node, input) {
         let s = node.findFirstExpression(Expressions.Source);
         if (s === undefined) {
             s = node.findFirstExpression(Expressions.SimpleSource3);
         }
         if (s) {
-            const type = new source_1.Source().runSyntax(s, input);
+            const type = source_1.Source.runSyntax(s, input);
             if (type instanceof basic_1.VoidType) {
                 return;
             }

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

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

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

@@ -6,11 +6,11 @@ const basic_1 = require("../../types/basic");
 const _syntax_input_1 = require("../_syntax_input");
 const sql_source_1 = require("./sql_source");
 class SQLIn {
-    runSyntax(node, input) {
+    static runSyntax(node, input) {
         if (node.getChildren().length === 2) {
             const insource = node.findFirstExpression(Expressions.SQLSource);
             if (insource) {
-                const intype = new sql_source_1.SQLSource().runSyntax(insource, input);
+                const intype = sql_source_1.SQLSource.runSyntax(insource, input);
                 if (intype &&
                     !(intype instanceof basic_1.VoidType) &&
                     !(intype instanceof basic_1.UnknownType) &&
@@ -23,10 +23,10 @@ class SQLIn {
             return;
         }
         for (const s of node.findDirectExpressions(Expressions.SQLSource)) {
-            new sql_source_1.SQLSource().runSyntax(s, input);
+            sql_source_1.SQLSource.runSyntax(s, input);
         }
         for (const s of node.findDirectExpressions(Expressions.SQLSourceNoSpace)) {
-            new sql_source_1.SQLSource().runSyntax(s, input);
+            sql_source_1.SQLSource.runSyntax(s, input);
         }
     }
 }

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

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

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

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