@abaplint/core 2.111.1 → 2.112.0

package/build/src/abap/5_syntax/structures/statics.js

@@ -8,9 +8,10 @@ const nodes_1 = require("../../nodes");
 const _typed_identifier_1 = require("../../types/_typed_identifier");
 const Basic = require("../../types/basic");
 const static_1 = require("../statements/static");
+const _syntax_input_1 = require("../_syntax_input");
 // todo, this is much like DATA, refactor?
 class Statics {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         var _a, _b;
         const name = node.findFirstExpression(Expressions.DefinitionName).getFirstToken();
         let table = false;
@@ -18,13 +19,13 @@ class Statics {
         for (const c of node.getChildren()) {
             const ctyp = c.get();
             if (c instanceof nodes_1.StatementNode && ctyp instanceof Statements.Static) {
-                const found = new static_1.Static().runSyntax(c, scope, filename);
+                const found = new static_1.Static().runSyntax(c, input);
                 if (found) {
                     components.push({ name: found.getName(), type: found.getType() });
                 }
             }
             else if (c instanceof nodes_1.StructureNode && ctyp instanceof Structures.Statics) {
-                const found = new Statics().runSyntax(c, scope, filename);
+                const found = new Statics().runSyntax(c, input);
                 if (found) {
                     components.push({ name: found.getName(), type: found.getType() });
                 }
@@ -37,9 +38,9 @@ class Statics {
             else if (c instanceof nodes_1.StatementNode && ctyp instanceof Statements.IncludeType) {
                 // INCLUDES
                 const typeName = (_a = c.findFirstExpression(Expressions.TypeName)) === null || _a === void 0 ? void 0 : _a.getFirstToken().getStr();
-                let found = (_b = scope.findType(typeName)) === null || _b === void 0 ? void 0 : _b.getType();
+                let found = (_b = input.scope.findType(typeName)) === null || _b === void 0 ? void 0 : _b.getType();
                 if (found === undefined) {
-                    const f = scope.getDDIC().lookupTableOrView(typeName).type;
+                    const f = input.scope.getDDIC().lookupTableOrView(typeName).type;
                     if (f instanceof _typed_identifier_1.TypedIdentifier) {
                         found = f.getType();
                     }
@@ -49,17 +50,20 @@ class Statics {
                 }
                 if (found instanceof Basic.VoidType) {
                     if (table === true) {
-                        return new _typed_identifier_1.TypedIdentifier(name, filename, new Basic.TableType(found, { withHeader: true, keyType: Basic.TableKeyType.default }));
+                        const ttyp = new Basic.TableType(found, { withHeader: true, keyType: Basic.TableKeyType.default });
+                        return new _typed_identifier_1.TypedIdentifier(name, input.filename, ttyp);
                     }
                     else {
-                        return new _typed_identifier_1.TypedIdentifier(name, filename, found);
+                        return new _typed_identifier_1.TypedIdentifier(name, input.filename, found);
                     }
                 }
                 if (found instanceof Basic.UnknownType) {
-                    return new _typed_identifier_1.TypedIdentifier(name, filename, new Basic.UnknownType("unknown type, " + typeName));
+                    return new _typed_identifier_1.TypedIdentifier(name, input.filename, new Basic.UnknownType("unknown type, " + typeName));
                 }
                 if (!(found instanceof Basic.StructureType)) {
-                    throw new Error("not structured, " + typeName);
+                    const message = "not structured, " + typeName;
+                    input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                    return new _typed_identifier_1.TypedIdentifier(name, input.filename, new Basic.VoidType(_syntax_input_1.CheckSyntaxKey));
                 }
                 for (const c of found.getComponents()) {
                     components.push(c);
@@ -67,10 +71,11 @@ class Statics {
             }
         }
         if (table === true) {
-            return new _typed_identifier_1.TypedIdentifier(name, filename, new Basic.TableType(new Basic.StructureType(components), { withHeader: true, keyType: Basic.TableKeyType.default }));
+            const ttyp = new Basic.TableType(new Basic.StructureType(components), { withHeader: true, keyType: Basic.TableKeyType.default });
+            return new _typed_identifier_1.TypedIdentifier(name, input.filename, ttyp);
         }
         else {
-            return new _typed_identifier_1.TypedIdentifier(name, filename, new Basic.StructureType(components));
+            return new _typed_identifier_1.TypedIdentifier(name, input.filename, new Basic.StructureType(components));
         }
     }
 }

package/build/src/abap/5_syntax/structures/type_enum.js

@@ -9,17 +9,18 @@ const _typed_identifier_1 = require("../../types/_typed_identifier");
 const _reference_1 = require("../_reference");
 const enum_type_1 = require("../../types/basic/enum_type");
 const _scope_type_1 = require("../_scope_type");
+const assert_error_1 = require("../assert_error");
 class TypeEnum {
-    runSyntax(node, scope, filename) {
+    runSyntax(node, input) {
         var _a;
         let values = [];
         const types = [];
         if (!(node.get() instanceof Structures.TypeEnum)) {
-            throw new Error("TypeEnum, unexpected type");
+            throw new assert_error_1.AssertError("TypeEnum, unexpected type");
         }
         const begin = node.findDirectStatement(Statements.TypeEnumBegin);
         if (begin === undefined) {
-            throw new Error("TypeEnum, unexpected type, begin");
+            throw new assert_error_1.AssertError("TypeEnum, unexpected type, begin");
         }
         for (const type of node.findDirectStatements(Statements.Type)) {
             const expr = type.findFirstExpression(Expressions.NamespaceSimpleName);
@@ -28,7 +29,7 @@ class TypeEnum {
             }
             const token = expr.getFirstToken();
             // integer is default if BASE TYPE is not specified
-            values.push(new _typed_identifier_1.TypedIdentifier(token, filename, basic_1.IntegerType.get()));
+            values.push(new _typed_identifier_1.TypedIdentifier(token, input.filename, basic_1.IntegerType.get()));
         }
         for (const type of node.findDirectStatements(Statements.TypeEnum)) {
             const expr = type.findFirstExpression(Expressions.NamespaceSimpleName);
@@ -37,25 +38,26 @@ class TypeEnum {
             }
             const token = expr.getFirstToken();
             // integer is default if BASE TYPE is not specified
-            values.push(new _typed_identifier_1.TypedIdentifier(token, filename, basic_1.IntegerType.get()));
+            values.push(new _typed_identifier_1.TypedIdentifier(token, input.filename, basic_1.IntegerType.get()));
         }
         const baseType = (_a = begin.findExpressionAfterToken("TYPE")) === null || _a === void 0 ? void 0 : _a.getFirstToken();
         const baseName = baseType === null || baseType === void 0 ? void 0 : baseType.getStr();
         if (baseType && baseName) {
-            const found = scope.findType(baseName);
+            const found = input.scope.findType(baseName);
             if (found) {
-                scope.addReference(baseType, found, _reference_1.ReferenceType.TypeReference, filename);
+                input.scope.addReference(baseType, found, _reference_1.ReferenceType.TypeReference, input.filename);
             }
         }
         const name = begin.findFirstExpression(Expressions.NamespaceSimpleName);
         if (name) {
             let qualifiedName = name.concatTokens();
-            if (scope.getType() === _scope_type_1.ScopeType.ClassDefinition
-                || scope.getType() === _scope_type_1.ScopeType.Interface) {
-                qualifiedName = scope.getName() + "=>" + qualifiedName;
+            if (input.scope.getType() === _scope_type_1.ScopeType.ClassDefinition
+                || input.scope.getType() === _scope_type_1.ScopeType.Interface) {
+                qualifiedName = input.scope.getName() + "=>" + qualifiedName;
             }
-            const id = new _typed_identifier_1.TypedIdentifier(name.getFirstToken(), filename, new enum_type_1.EnumType({ qualifiedName: qualifiedName }), ["enum" /* IdentifierMeta.Enum */]);
-            scope.addType(id);
+            const etype = new enum_type_1.EnumType({ qualifiedName: qualifiedName });
+            const id = new _typed_identifier_1.TypedIdentifier(name.getFirstToken(), input.filename, etype, ["enum" /* IdentifierMeta.Enum */]);
+            input.scope.addType(id);
             types.push(id);
         }
         const stru = begin.findExpressionAfterToken("STRUCTURE");
@@ -68,7 +70,7 @@ class TypeEnum {
                 });
             }
             values = [];
-            const id = new _typed_identifier_1.TypedIdentifier(stru.getFirstToken(), filename, new basic_1.StructureType(components), ["enum" /* IdentifierMeta.Enum */]);
+            const id = new _typed_identifier_1.TypedIdentifier(stru.getFirstToken(), input.filename, new basic_1.StructureType(components), ["enum" /* IdentifierMeta.Enum */]);
             values.push(id);
         }
         return { values, types };

package/build/src/abap/5_syntax/structures/types.js

@@ -12,7 +12,7 @@ const type_1 = require("../statements/type");
 const Basic = require("../../types/basic");
 const _scope_type_1 = require("../_scope_type");
 class Types {
-    runSyntax(node, scope, filename, qualifiedNamePrefix) {
+    runSyntax(node, input, qualifiedNamePrefix) {
         const name = node.findFirstExpression(Expressions.NamespaceSimpleName).getFirstToken();
         const components = [];
         let voidd = undefined;
@@ -23,13 +23,13 @@ class Types {
             const ctyp = c.get();
             if (c instanceof nodes_1.StatementNode) {
                 if (ctyp instanceof Statements.Type) {
-                    const found = new type_1.Type().runSyntax(c, scope, filename, qualifiedNamePrefix + name.getStr() + "-");
+                    const found = new type_1.Type().runSyntax(c, input, qualifiedNamePrefix + name.getStr() + "-");
                     if (found) {
                         components.push({ name: found.getName(), type: found.getType() });
                     }
                 }
                 else if (ctyp instanceof Statements.IncludeType) {
-                    const found = new include_type_1.IncludeType().runSyntax(c, scope, filename);
+                    const found = new include_type_1.IncludeType().runSyntax(c, input);
                     if (found instanceof basic_1.VoidType) {
                         voidd = found;
                     }
@@ -39,24 +39,24 @@ class Types {
                 }
             }
             else if (c instanceof nodes_1.StructureNode && ctyp instanceof Structures.Types) {
-                const found = new Types().runSyntax(c, scope, filename, qualifiedNamePrefix + name.getStr() + "-");
+                const found = new Types().runSyntax(c, input, qualifiedNamePrefix + name.getStr() + "-");
                 if (found) {
                     components.push({ name: found.getName(), type: found.getType() });
                 }
             }
         }
         if (voidd) {
-            return new _typed_identifier_1.TypedIdentifier(name, filename, voidd);
+            return new _typed_identifier_1.TypedIdentifier(name, input.filename, voidd);
         }
         else if (components.length === 0) { // todo, remove this check
             return undefined;
         }
         let qualifiedName = qualifiedNamePrefix + name.getStr();
-        if (scope.getType() === _scope_type_1.ScopeType.ClassDefinition
-            || scope.getType() === _scope_type_1.ScopeType.Interface) {
-            qualifiedName = scope.getName() + "=>" + qualifiedName;
+        if (input.scope.getType() === _scope_type_1.ScopeType.ClassDefinition
+            || input.scope.getType() === _scope_type_1.ScopeType.Interface) {
+            qualifiedName = input.scope.getName() + "=>" + qualifiedName;
         }
-        return new _typed_identifier_1.TypedIdentifier(name, filename, new Basic.StructureType(components, qualifiedName));
+        return new _typed_identifier_1.TypedIdentifier(name, input.filename, new Basic.StructureType(components, qualifiedName));
     }
 }
 exports.Types = Types;

package/build/src/abap/5_syntax/syntax.js

@@ -142,11 +142,13 @@ const insert_field_group_1 = require("./statements/insert_field_group");
 const read_entities_1 = require("./statements/read_entities");
 const modify_entities_1 = require("./statements/modify_entities");
 const commit_entities_1 = require("./statements/commit_entities");
+const _syntax_input_1 = require("./_syntax_input");
+const assert_error_1 = require("./assert_error");
 // -----------------------------------
 const map = {};
 function addToMap(handler) {
     if (map[handler.constructor.name] !== undefined) {
-        throw new Error("syntax.ts duplicate statement syntax handler");
+        throw new assert_error_1.AssertError("syntax.ts duplicate statement syntax handler");
     }
     map[handler.constructor.name] = handler;
 }
@@ -341,7 +343,7 @@ class SyntaxLogic {
         return this.scope;
     }
     newIssue(token, message) {
-        const issue = issue_1.Issue.atToken(this.currentFile, token, message, "check_syntax", severity_1.Severity.Error);
+        const issue = issue_1.Issue.atToken(this.currentFile, token, message, _syntax_input_1.CheckSyntaxKey, severity_1.Severity.Error);
         this.issues.push(issue);
     }
     traverse(node) {
@@ -378,36 +380,43 @@ class SyntaxLogic {
             }
         }
     }
-    // if this returns true, then the traversal should continue with next child
+    /**
+     * if this returns true, then the traversal should continue with next child
+     */
     updateScopeStructure(node) {
         const filename = this.currentFile.getFilename();
         const stru = node.get();
+        const input = {
+            scope: this.scope,
+            filename,
+            issues: this.issues,
+        };
         if (stru instanceof Structures.ClassDefinition) {
-            new class_definition_1.ClassDefinition(node, filename, this.scope);
+            new class_definition_1.ClassDefinition(node, input);
             return true;
         }
         else if (stru instanceof Structures.Interface) {
-            new interface_definition_1.InterfaceDefinition(node, filename, this.scope);
+            new interface_definition_1.InterfaceDefinition(node, input);
             return true;
         }
         else if (stru instanceof Structures.Types) {
-            this.scope.addType(new types_1.Types().runSyntax(node, this.scope, filename));
+            this.scope.addType(new types_1.Types().runSyntax(node, input));
             return true;
         }
         else if (stru instanceof Structures.Constants) {
-            this.scope.addIdentifier(new constants_1.Constants().runSyntax(node, this.scope, filename).type);
+            this.scope.addIdentifier(new constants_1.Constants().runSyntax(node, input).type);
             return true;
         }
         else if (stru instanceof Structures.Data) {
-            this.scope.addIdentifier(new data_1.Data().runSyntax(node, this.scope, filename));
+            this.scope.addIdentifier(new data_1.Data().runSyntax(node, input));
             return true;
         }
         else if (stru instanceof Structures.Statics) {
-            this.scope.addIdentifier(new statics_1.Statics().runSyntax(node, this.scope, filename));
+            this.scope.addIdentifier(new statics_1.Statics().runSyntax(node, input));
             return true;
         }
         else if (stru instanceof Structures.TypeEnum) {
-            const values = new type_enum_1.TypeEnum().runSyntax(node, this.scope, filename).values;
+            const values = new type_enum_1.TypeEnum().runSyntax(node, input).values;
             this.scope.addList(values);
             return true;
         }
@@ -416,26 +425,31 @@ class SyntaxLogic {
     updateScopeStatement(node) {
         const filename = this.currentFile.getFilename();
         const s = node.get();
+        const input = {
+            scope: this.scope,
+            filename,
+            issues: this.issues,
+        };
         // todo, refactor
         if (s instanceof Statements.Type) {
-            this.scope.addType(new type_1.Type().runSyntax(node, this.scope, filename));
+            this.scope.addType(new type_1.Type().runSyntax(node, input));
             return;
         }
         else if (s instanceof Statements.Constant) {
-            this.scope.addIdentifier(new constant_1.Constant().runSyntax(node, this.scope, filename));
+            this.scope.addIdentifier(new constant_1.Constant().runSyntax(node, input));
             return;
         }
         else if (s instanceof Statements.Static) {
-            this.scope.addIdentifier(new static_1.Static().runSyntax(node, this.scope, filename));
+            this.scope.addIdentifier(new static_1.Static().runSyntax(node, input));
             return;
         }
         else if (s instanceof Statements.Data) {
-            this.scope.addIdentifier(new data_2.Data().runSyntax(node, this.scope, filename));
+            this.scope.addIdentifier(new data_2.Data().runSyntax(node, input));
             return;
         }
         const name = s.constructor.name;
         if (map[name]) {
-            map[name].runSyntax(node, this.scope, filename);
+            map[name].runSyntax(node, input);
             return;
         }
         if (s instanceof Statements.FunctionModule) {
@@ -448,7 +462,9 @@ class SyntaxLogic {
             this.scope.pop(node.getLastToken().getEnd());
         }
         else if (s instanceof Statements.EndMethod) {
-            this.scope.pop(node.getLastToken().getEnd());
+            if (this.scope.getType() === _scope_type_1.ScopeType.Method) {
+                this.scope.pop(node.getLastToken().getEnd());
+            }
             if (this.scope.getType() === _scope_type_1.ScopeType.MethodInstance) {
                 this.scope.pop(node.getLastToken().getEnd());
             }

package/build/src/abap/types/class_attributes.js

@@ -18,13 +18,13 @@ const type_definitions_1 = require("./type_definitions");
 const types_1 = require("../5_syntax/structures/types");
 const type_1 = require("../5_syntax/statements/type");
 class Attributes {
-    constructor(node, filename, scope) {
+    constructor(node, input) {
         this.static = [];
         this.instance = [];
         this.constants = [];
-        this.filename = filename;
+        this.filename = input.filename;
         this.tlist = [];
-        this.parse(node, scope);
+        this.parse(node, input);
         this.types = new type_definitions_1.TypeDefinitions(this.tlist);
     }
     getTypes() {
@@ -93,22 +93,22 @@ class Attributes {
         return undefined;
     }
     /////////////////////////////
-    parse(node, scope) {
+    parse(node, input) {
         const cdef = node.findDirectStructure(Structures.ClassDefinition);
         if (cdef) {
-            this.parseSection(cdef.findDirectStructure(Structures.PublicSection), visibility_1.Visibility.Public, scope);
-            this.parseSection(cdef.findDirectStructure(Structures.ProtectedSection), visibility_1.Visibility.Protected, scope);
-            this.parseSection(cdef.findDirectStructure(Structures.PrivateSection), visibility_1.Visibility.Private, scope);
+            this.parseSection(cdef.findDirectStructure(Structures.PublicSection), visibility_1.Visibility.Public, input);
+            this.parseSection(cdef.findDirectStructure(Structures.ProtectedSection), visibility_1.Visibility.Protected, input);
+            this.parseSection(cdef.findDirectStructure(Structures.PrivateSection), visibility_1.Visibility.Private, input);
             return;
         }
         const idef = node.findDirectStructure(Structures.Interface);
         if (idef) {
-            this.parseSection(idef.findDirectStructure(Structures.SectionContents), visibility_1.Visibility.Public, scope);
+            this.parseSection(idef.findDirectStructure(Structures.SectionContents), visibility_1.Visibility.Public, input);
             return;
         }
         throw new Error("MethodDefinition, expected ClassDefinition or InterfaceDefinition");
     }
-    parseSection(node, visibility, scope) {
+    parseSection(node, visibility, input) {
         if (node === undefined) {
             return;
         }
@@ -116,36 +116,36 @@ class Attributes {
             const ctyp = c.get();
             if (c instanceof nodes_1.StructureNode) {
                 if (ctyp instanceof Structures.Data) {
-                    const found = new data_2.Data().runSyntax(c, scope, this.filename);
+                    const found = new data_2.Data().runSyntax(c, input);
                     if (found !== undefined) {
                         const attr = new class_attribute_1.ClassAttribute(found, visibility, found.getMeta(), found.getValue());
                         this.instance.push(attr);
-                        scope.addIdentifier(attr);
+                        input.scope.addIdentifier(attr);
                     }
                 }
                 else if (ctyp instanceof Structures.ClassData) {
-                    const found = new class_data_2.ClassData().runSyntax(c, scope, this.filename);
+                    const found = new class_data_2.ClassData().runSyntax(c, input);
                     if (found !== undefined) {
                         const attr = new class_attribute_1.ClassAttribute(found, visibility, found.getMeta(), found.getValue());
                         this.static.push(attr);
-                        scope.addIdentifier(attr);
+                        input.scope.addIdentifier(attr);
                     }
                 }
                 else if (ctyp instanceof Structures.Constants) {
-                    const { type: found, values } = new constants_1.Constants().runSyntax(c, scope, this.filename);
+                    const { type: found, values } = new constants_1.Constants().runSyntax(c, input);
                     if (found !== undefined) {
                         const attr = new class_constant_1.ClassConstant(found, visibility, values);
                         this.constants.push(attr);
-                        scope.addIdentifier(attr);
+                        input.scope.addIdentifier(attr);
                     }
                 }
                 else if (ctyp instanceof Structures.TypeEnum) {
-                    const { values, types } = new type_enum_1.TypeEnum().runSyntax(c, scope, this.filename);
+                    const { values, types } = new type_enum_1.TypeEnum().runSyntax(c, input);
                     for (const v of values) {
                         // for now add ENUM values as constants
                         const attr = new class_constant_1.ClassConstant(v, visibility, "novalueClassAttributeEnum");
                         this.constants.push(attr);
-                        scope.addIdentifier(attr);
+                        input.scope.addIdentifier(attr);
                     }
                     for (const t of types) {
                         this.tlist.push({ type: t, visibility });
@@ -153,50 +153,50 @@ class Attributes {
                     }
                 }
                 else if (ctyp instanceof Structures.Types) {
-                    const res = new types_1.Types().runSyntax(c, scope, this.filename);
+                    const res = new types_1.Types().runSyntax(c, input);
                     if (res) {
-                        scope.addType(res);
+                        input.scope.addType(res);
                         this.tlist.push({ type: res, visibility });
                     }
                 }
                 else {
                     // begin recursion
-                    this.parseSection(c, visibility, scope);
+                    this.parseSection(c, visibility, input);
                 }
             }
             else if (c instanceof nodes_1.StatementNode) {
                 if (ctyp instanceof Statements.Data) {
-                    this.instance.push(this.parseAttribute(c, visibility, scope));
+                    this.instance.push(this.parseAttribute(c, visibility, input));
                 }
                 else if (ctyp instanceof Statements.ClassData) {
-                    this.static.push(this.parseAttribute(c, visibility, scope));
+                    this.static.push(this.parseAttribute(c, visibility, input));
                 }
                 else if (ctyp instanceof Statements.Constant) {
-                    const found = new constant_1.Constant().runSyntax(c, scope, this.filename);
+                    const found = new constant_1.Constant().runSyntax(c, input);
                     if (found) {
                         const attr = new class_constant_1.ClassConstant(found, visibility, found.getValue());
                         this.constants.push(attr);
-                        scope.addIdentifier(attr);
+                        input.scope.addIdentifier(attr);
                     }
                 }
                 else if (ctyp instanceof Statements.Type) {
-                    const res = new type_1.Type().runSyntax(c, scope, this.filename);
+                    const res = new type_1.Type().runSyntax(c, input);
                     if (res) {
-                        scope.addType(res);
+                        input.scope.addType(res);
                         this.tlist.push({ type: res, visibility });
                     }
                 }
             }
         }
     }
-    parseAttribute(node, visibility, scope) {
+    parseAttribute(node, visibility, input) {
         let found = undefined;
         const s = node.get();
         if (s instanceof Statements.Data) {
-            found = new data_1.Data().runSyntax(node, scope, this.filename);
+            found = new data_1.Data().runSyntax(node, input);
         }
         else if (s instanceof Statements.ClassData) {
-            found = new class_data_1.ClassData().runSyntax(node, scope, this.filename);
+            found = new class_data_1.ClassData().runSyntax(node, input);
         }
         else {
             throw new Error("ClassAttribute, unexpected node, 1, " + this.filename);
@@ -204,7 +204,7 @@ class Attributes {
         if (found === undefined) {
             throw new Error("ClassAttribute, unexpected node, " + this.filename);
         }
-        scope.addIdentifier(found);
+        input.scope.addIdentifier(found);
         return new class_attribute_1.ClassAttribute(found, visibility, found.getMeta(), found.getValue());
     }
 }

package/build/src/abap/types/class_definition.js

@@ -15,39 +15,39 @@ const visibility_1 = require("../4_file_information/visibility");
 const _object_oriented_1 = require("../5_syntax/_object_oriented");
 const _reference_1 = require("../5_syntax/_reference");
 class ClassDefinition extends _identifier_1.Identifier {
-    constructor(node, filename, scope) {
+    constructor(node, input) {
         if (!(node.get() instanceof Structures.ClassDefinition)) {
             throw new Error("ClassDefinition, unexpected node type");
         }
         const def = node.findFirstStatement(Statements.ClassDefinition);
         const name = def.findDirectExpression(Expressions.ClassName).getFirstToken();
-        super(name, filename);
-        scope.addClassDefinition(this);
+        super(name, input.filename);
+        input.scope.addClassDefinition(this);
         this.events = [];
         this.implementing = [];
         this.globalValue = def.findFirstExpression(Expressions.ClassGlobal) !== undefined;
         this.finalValue = def.findFirstExpression(Expressions.ClassFinal) !== undefined;
-        scope.push(_scope_type_1.ScopeType.ClassDefinition, name.getStr(), name.getStart(), filename);
-        this.superClass = this.findSuper(def, filename, scope);
-        this.friends = this.findFriends(def, filename, scope);
-        this.parse(filename, scope, node);
-        const helper = new _object_oriented_1.ObjectOriented(scope);
+        input.scope.push(_scope_type_1.ScopeType.ClassDefinition, name.getStr(), name.getStart(), input.filename);
+        this.superClass = this.findSuper(def, input);
+        this.friends = this.findFriends(def, input);
+        this.parse(input, node);
+        const helper = new _object_oriented_1.ObjectOriented(input.scope);
         helper.fromSuperClassesAndInterfaces(this);
         helper.addAliasedTypes(this.aliases);
-        this.attributes = new class_attributes_1.Attributes(node, this.filename, scope);
+        this.attributes = new class_attributes_1.Attributes(node, input);
         this.types = this.attributes.getTypes();
         const events = node.findAllStatements(Statements.Events);
         for (const e of events) {
-            this.events.push(new event_definition_1.EventDefinition(e, visibility_1.Visibility.Public, this.filename, scope)); // todo, all these are not Public
+            this.events.push(new event_definition_1.EventDefinition(e, visibility_1.Visibility.Public, input)); // todo, all these are not Public
         }
-        this.methodDefs = new method_definitions_1.MethodDefinitions(node, this.filename, scope);
-        scope.pop(node.getLastToken().getEnd());
+        this.methodDefs = new method_definitions_1.MethodDefinitions(node, input);
+        input.scope.pop(node.getLastToken().getEnd());
         const concat = def.concatTokens().toUpperCase();
         this.testing = concat.includes(" FOR TESTING");
         this.sharedMemory = concat.includes(" SHARED MEMORY ENABLED");
         this.abstract = (def === null || def === void 0 ? void 0 : def.findDirectTokenByText("ABSTRACT")) !== undefined;
         // perform checks after everything has been initialized
-        this.checkMethodsFromSuperClasses(scope);
+        this.checkMethodsFromSuperClasses(input.scope);
     }
     getFriends() {
         return this.friends;
@@ -93,10 +93,10 @@ class ClassDefinition extends _identifier_1.Identifier {
       }
     */
     ///////////////////
-    findSuper(def, filename, scope) {
+    findSuper(def, input) {
         var _a;
         const token = (_a = def === null || def === void 0 ? void 0 : def.findDirectExpression(expressions_1.SuperClassName)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
-        this.addReference(token, filename, scope);
+        this.addReference(token, input);
         const name = token === null || token === void 0 ? void 0 : token.getStr();
         return name;
     }
@@ -127,30 +127,30 @@ class ClassDefinition extends _identifier_1.Identifier {
             }
         }
     }
-    findFriends(def, filename, scope) {
+    findFriends(def, input) {
         var _a;
         const result = [];
         for (const n of ((_a = def === null || def === void 0 ? void 0 : def.findDirectExpression(Expressions.ClassFriends)) === null || _a === void 0 ? void 0 : _a.findDirectExpressions(Expressions.ClassName)) || []) {
             const token = n.getFirstToken();
-            this.addReference(token, filename, scope);
+            this.addReference(token, input);
             const name = token.getStr();
             result.push(name);
         }
         return result;
     }
-    addReference(token, filename, scope) {
+    addReference(token, input) {
         const name = token === null || token === void 0 ? void 0 : token.getStr();
         if (name) {
-            const s = scope.findClassDefinition(name);
+            const s = input.scope.findClassDefinition(name);
             if (s) {
-                scope.addReference(token, s, _reference_1.ReferenceType.ObjectOrientedReference, filename, { ooName: name.toUpperCase(), ooType: "CLAS" });
+                input.scope.addReference(token, s, _reference_1.ReferenceType.ObjectOrientedReference, input.filename, { ooName: name.toUpperCase(), ooType: "CLAS" });
             }
-            else if (scope.getDDIC().inErrorNamespace(name) === false) {
-                scope.addReference(token, undefined, _reference_1.ReferenceType.ObjectOrientedVoidReference, filename);
+            else if (input.scope.getDDIC().inErrorNamespace(name) === false) {
+                input.scope.addReference(token, undefined, _reference_1.ReferenceType.ObjectOrientedVoidReference, input.filename);
             }
         }
     }
-    parse(filename, scope, inputNode) {
+    parse(input, inputNode) {
         var _a;
         for (const node of inputNode.findAllStatements(Statements.InterfaceDef)) {
             const partial = node.findDirectTokenByText("PARTIALLY") !== undefined;
@@ -160,18 +160,18 @@ class ClassDefinition extends _identifier_1.Identifier {
             }
             const name = token.getStr().toUpperCase();
             this.implementing.push({ name, partial });
-            const intf = scope.findInterfaceDefinition(name);
+            const intf = input.scope.findInterfaceDefinition(name);
             if (intf) {
-                scope.addReference(token, intf, _reference_1.ReferenceType.ObjectOrientedReference, filename, { ooName: name.toUpperCase(), ooType: "INTF" });
+                input.scope.addReference(token, intf, _reference_1.ReferenceType.ObjectOrientedReference, input.filename, { ooName: name.toUpperCase(), ooType: "INTF" });
             }
-            else if (scope.getDDIC().inErrorNamespace(name) === false) {
-                scope.addReference(token, undefined, _reference_1.ReferenceType.ObjectOrientedVoidReference, filename, { ooName: name.toUpperCase(), ooType: "INTF" });
+            else if (input.scope.getDDIC().inErrorNamespace(name) === false) {
+                input.scope.addReference(token, undefined, _reference_1.ReferenceType.ObjectOrientedVoidReference, input.filename, { ooName: name.toUpperCase(), ooType: "INTF" });
             }
             else {
-                scope.addReference(token, undefined, _reference_1.ReferenceType.ObjectOrientedUnknownReference, filename, { ooName: name.toUpperCase(), ooType: "INTF" });
+                input.scope.addReference(token, undefined, _reference_1.ReferenceType.ObjectOrientedUnknownReference, input.filename, { ooName: name.toUpperCase(), ooType: "INTF" });
             }
         }
-        this.aliases = new aliases_1.Aliases(inputNode, this.filename, scope);
+        this.aliases = new aliases_1.Aliases(inputNode, this.filename, input.scope);
     }
 }
 exports.ClassDefinition = ClassDefinition;