Implement UnboundLocalError

src/interpreted/nodes.py

@@ -25,6 +25,7 @@ class Constant(Expression):
 @dataclass
 class Name(Expression):
     value: str
+    ctx: Literal["load", "store"]  # Added context
 
 
 @dataclass
@@ -47,12 +48,14 @@ class Dict(Expression):
 class Attribute(Expression):
     value: Expression
     attr: str
+    ctx: Literal["load", "store"]  
 
 
 @dataclass
 class Subscript(Expression):
     value: Expression
     key: Expression
+    ctx: Literal["load", "store"]  
 
 
 @dataclass
@@ -73,6 +76,7 @@ class Call(Expression):
 @dataclass
 class Name(Expression):
     id: str
+    ctx: Literal["load", "store"]  
 
 
 @dataclass

src/interpreted/parser.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
+from _ast import FunctionDef
 
 import ast
 import sys
 from keyword import iskeyword
+from typing import Any
 
 from interpreted.nodes import (
     Assign,
@@ -716,7 +718,51 @@ def parse_literal(self) -> Expression:
 
         raise ParseError(f"Unexpected token {self.peek().string!r}", self.index)
 
-
+class ScopeConsistencyChecker(ast.NodeVisitor):
+    def __init__(self):
+        self.inconsistent_nodes = []
+        self.loaded_names = set()
+
+    def check_consistency(self, node, variable_name):
+        if isinstance(node.ctx, nodes.Store):
+            if variable_name in self.loaded_names:
+                self.inconsistent_nodes.append(node)
+
+        else:
+            self.loaded_names.add(variable_name)
+
+    def visit_Name(self, node):
+        self.check_consistency(node, node.id)
+    def visit_Name(self, node):
+        self.check_consistency(node, node._attributes)
+
+class UnboundLocalErrorChecker(ast.NodeVisitor):
+
+    def __init__(self):
+        self.incosistent_nodes = []
+
+    def visit_scope(self, node):
+        checker = ScopeConsistencyChecker()
+        checker.visit(node)
+        self.incosistent_nodes.update(checker.inconsistent_nodes)   
+
+    def visit_FunctionDef(self, node):
+        self.visit(node)
+
+    def visit_AsyncFunctionDef(self, node):
+        self.visit(node)
+
+    def visit_classDef(self, node):
+        self.visit(node)
+
+# main driver code for UnboundLocalEerror checker    
+checker = UnboundLocalErrorChecker()
+checker.visit(Module)
+if checker.incosistent_nodes:
+    first_incon = checker.incosistent_nodes[0]
+    raise ParseError(first_incon.line, first_incon.column)
+
+
 def assert_expressions_are_targets(expressions: list[Expression], index) -> None:
     for target in expressions:
         if not isinstance(target, (Name, Subscript)):