feat: distinction between class and instance variables (#130)

Closes #129 

### Summary of Changes

The `get_scope` function now has two additional fields:
`instance_variables` and `class_variables`. Each contains the
corresponding variables for a class node.

---------

Co-authored-by: megalinter-bot <[email protected]>

Author: lukarade

src/library_analyzer/processing/api/__init__.py

@@ -26,11 +26,7 @@
     package_files,
     package_root,
 )
-from ._resolve_references import (
-    MemberAccess,
-    ScopeNode,
-    get_scope,
-)
+from ._resolve_references import ClassScopeNode, MemberAccess, ScopeNode, get_scope
 
 __all__ = [
     "DefinitelyImpure",
@@ -58,4 +54,5 @@
     "ScopeNode",
     "MemberAccess",
     "get_scope",
+    "ClassScopeNode",
 ]

src/library_analyzer/processing/api/_resolve_references.py

@@ -31,8 +31,22 @@ class ScopeNode:
     """
 
     node: astroid.Module | astroid.FunctionDef | astroid.ClassDef | astroid.AssignName | astroid.AssignAttr | astroid.Attribute | astroid.Call | astroid.Import | astroid.ImportFrom | MemberAccess
-    children: list[ScopeNode] | None = None
-    parent: ScopeNode | None = None
+    children: list[ScopeNode | ClassScopeNode]
+    parent: ScopeNode | ClassScopeNode | None = None
+
+
+@dataclass
+class ClassScopeNode(ScopeNode):
+    """Represents a ScopeNode that defines the scope of a class.
+
+    Attributes
+    ----------
+        class_variables     is a list of AssignName nodes that define class variables
+        instance_variables  is a list of AssignAttr nodes that define instance variables
+    """
+
+    class_variables: list[astroid.AssignName] = field(default_factory=list)
+    instance_variables: list[astroid.AssignAttr] = field(default_factory=list)
 
 
 @dataclass
@@ -49,8 +63,26 @@ class ScopeFinder:
         children:               All found children nodes are stored in children until their scope is determined.
     """
 
-    current_node_stack: list[ScopeNode] = field(default_factory=list)
-    children: list[ScopeNode] = field(default_factory=list)
+    current_node_stack: list[ScopeNode | ClassScopeNode] = field(default_factory=list)
+    children: list[ScopeNode | ClassScopeNode] = field(default_factory=list)
+
+    def get_node_by_name(self, name: str) -> ScopeNode | ClassScopeNode | None:
+        """
+        Get a ScopeNode by its name.
+
+        Parameters
+        ----------
+            name    is the name of the node that should be found.
+
+        Returns
+        -------
+            The ScopeNode with the given name, or None if no node with the given name was found.
+        """
+        for node in self.current_node_stack:
+            if node.node.name == name:
+                return node
+        return None
+        # TODO: this is inefficient, instead use a dict to store the nodes
 
     def detect_scope(self, node: astroid.NodeNG) -> None:
         """
@@ -60,8 +92,8 @@ def detect_scope(self, node: astroid.NodeNG) -> None:
         The scope of a node is defined by the parent node in the scope tree.
         """
         current_scope = node
-        outer_scope_children: list[ScopeNode] = []
-        inner_scope_children: list[ScopeNode] = []
+        outer_scope_children: list[ScopeNode | ClassScopeNode] = []
+        inner_scope_children: list[ScopeNode | ClassScopeNode] = []
         for child in self.children:
             if (
                 child.parent is not None and child.parent.node != current_scope
@@ -75,6 +107,24 @@ def detect_scope(self, node: astroid.NodeNG) -> None:
         self.children.append(self.current_node_stack[-1])  # add the current node to the children
         self.current_node_stack.pop()  # remove the current node from the stack
 
+    def analyze_constructor(self, node: astroid.FunctionDef) -> None:
+        """Analyze the constructor of a class.
+
+        The constructor of a class is a special function that is called when an instance of the class is created.
+        This function only is called when the name of the FunctionDef node is `__init__`.
+        """
+        # add instance variables to the instance_variables list of the class
+        for child in node.body:
+            class_node = self.get_node_by_name(node.parent.name)
+
+            if isinstance(class_node, ClassScopeNode):
+                if isinstance(child, astroid.Assign):
+                    class_node.instance_variables.append(child.targets[0])
+                elif isinstance(child, astroid.AnnAssign):
+                    class_node.instance_variables.append(child.target)
+                else:
+                    raise TypeError(f"Unexpected node type {type(child)}")
+
     def enter_module(self, node: astroid.Module) -> None:
         """
         Enter a module node.
@@ -83,25 +133,32 @@ def enter_module(self, node: astroid.Module) -> None:
         The module node is also the first node that is visited, so the current_node_stack is empty before entering the module node.
         """
         self.current_node_stack.append(
-            ScopeNode(node=node, children=None, parent=None),
+            ScopeNode(node=node, children=[], parent=None),
         )
 
     def leave_module(self, node: astroid.Module) -> None:
         self.detect_scope(node)
 
     def enter_classdef(self, node: astroid.ClassDef) -> None:
         self.current_node_stack.append(
-            ScopeNode(node=node, children=None, parent=self.current_node_stack[-1]),
+            ClassScopeNode(
+                node=node,
+                children=[],
+                parent=self.current_node_stack[-1],
+                instance_variables=[],
+                class_variables=[],
+            ),
         )
 
     def leave_classdef(self, node: astroid.ClassDef) -> None:
         self.detect_scope(node)
 
     def enter_functiondef(self, node: astroid.FunctionDef) -> None:
         self.current_node_stack.append(
-            ScopeNode(node=node, children=None, parent=self.current_node_stack[-1]),
+            ScopeNode(node=node, children=[], parent=self.current_node_stack[-1]),
         )
-        # TODO: Special treatment for __init__ function
+        if node.name == "__init__":
+            self.analyze_constructor(node)
 
     def leave_functiondef(self, node: astroid.FunctionDef) -> None:
         self.detect_scope(node)
@@ -120,26 +177,42 @@ def enter_assignname(self, node: astroid.AssignName) -> None:
             | astroid.AnnAssign,
         ):
             parent = self.current_node_stack[-1]
-            scope_node = ScopeNode(node=node, children=None, parent=parent)
+            scope_node = ScopeNode(node=node, children=[], parent=parent)
             self.children.append(scope_node)
 
-    def enter_assignattr(self, node: astroid.Attribute) -> None:
+        # add class variables to the class_variables list of the class
+        if isinstance(node.parent.parent, astroid.ClassDef):
+            class_node = self.get_node_by_name(node.parent.parent.name)
+            if isinstance(class_node, ClassScopeNode):
+                class_node.class_variables.append(node)
+
+    def enter_assignattr(self, node: astroid.AssignAttr) -> None:
         parent = self.current_node_stack[-1]
-        scope_node = ScopeNode(node=node, children=None, parent=parent)
+        scope_node = ScopeNode(node=node, children=[], parent=parent)
         self.children.append(scope_node)
 
     def enter_import(self, node: astroid.Import) -> None:
         parent = self.current_node_stack[-1]
-        scope_node = ScopeNode(node=node, children=None, parent=parent)
+        scope_node = ScopeNode(node=node, children=[], parent=parent)
         self.children.append(scope_node)
 
     def enter_importfrom(self, node: astroid.ImportFrom) -> None:
         parent = self.current_node_stack[-1]
-        scope_node = ScopeNode(node=node, children=None, parent=parent)
+        scope_node = ScopeNode(node=node, children=[], parent=parent)
         self.children.append(scope_node)
 
 
-def get_scope(code: str) -> list[ScopeNode]:
+def get_scope(code: str) -> list[ScopeNode | ClassScopeNode]:
+    """Get the scope of the given code.
+
+    In order to get the scope of the given code, the code is parsed into an AST and then walked by an ASTWalker.
+    The ASTWalker detects the scope of each node and builds a scope tree by using an instance of ScopeFinder.
+
+    Returns
+    -------
+        scopes:     list of ScopeNode instances that represent the scope tree of the given code.
+        variables:  list of class variables and list of instance variables for all classes in the given code.
+    """
     scope_handler = ScopeFinder()
     walker = ASTWalker(scope_handler)
     module = astroid.parse(code)