From a9e0e8b3762122f097abe623cf84d9a95967616d Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Wed, 11 Jun 2025 19:14:04 +0100
Subject: [PATCH 1/8] refactor(name-resolve): Add class registry for
 FilteredWalker

---
 parser/typecheck/typecheck.py | 117 ++++++++++++++++++++++++++++++++--
 1 file changed, 111 insertions(+), 6 deletions(-)

diff --git a/parser/typecheck/typecheck.py b/parser/typecheck/typecheck.py
index e30fd22..0b79636 100644
--- a/parser/typecheck/typecheck.py
+++ b/parser/typecheck/typecheck.py
@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import functools
 from dataclasses import dataclass, field
 from typing import Callable, TypeVar
 
@@ -13,13 +14,22 @@
 WT = TypeVar('WT', bound=WalkableT)
 VT = TypeVar('VT')
 
+SpecificCbT = Callable[[WT], bool | None]
+SpecificCbsDict = dict[type[WT] | type, list[Callable[[WT], bool | None]]]
+BothCbT = Callable[[WT, WalkerCallType], bool | None]
+BothCbsDict = dict[type[WT] | type, list[Callable[[WT, WalkerCallType], bool | None]]]
 
-class FilteredWalker:
-    def __init__(self):
-        self.enter_cbs: dict[type[WT] | type, list[Callable[[WT], bool | None]]] = {}
-        self.exit_cbs: dict[type[WT] | type, list[Callable[[WT], bool | None]]] = {}
-        self.both_cbs: dict[type[WT] | type, list[
-            Callable[[WT, WalkerCallType], bool | None]]] = {}
+
+class _WalkerRegistry:
+    def __init__(self, enter_cbs: SpecificCbsDict = (),
+                 exit_cbs: SpecificCbsDict = (),
+                 both_sbc: BothCbsDict = ()):
+        self.enter_cbs: SpecificCbsDict = dict(enter_cbs)  # Copy them,
+        self.exit_cbs: SpecificCbsDict = dict(exit_cbs)    # also converts default () -> {}
+        self.both_cbs: BothCbsDict = dict(both_sbc)
+
+    def copy(self):
+        return _WalkerRegistry(self.enter_cbs, self.exit_cbs, self.both_cbs)
 
     def register_both(self, t: type[WT], fn: Callable[[WT, WalkerCallType], bool | None]):
         self.both_cbs.setdefault(t, []).append(fn)
@@ -33,6 +43,74 @@ def register_exit(self, t: type[WT], fn: Callable[[WT], bool | None]):
         self.exit_cbs.setdefault(t, []).append(fn)
         return self
 
+    def __call__(self, *args, **kwargs):
+        return self
+
+    def on_enter(self, *tps: type[WT] | type):
+        """Decorator version of register_enter."""
+        def decor(fn: SpecificCbT):
+            for t in tps:
+                self.register_enter(t, fn)
+            return fn
+        return decor
+
+    def on_exit(self, *tps: type[WT] | type):
+        """Decorator version of register_exit."""
+        def decor(fn: SpecificCbT):
+            for t in tps:
+                self.register_exit(t, fn)
+            return fn
+        return decor
+
+    def on_both(self, *tps: type[WT] | type):
+        """Decorator version of register_both."""
+        def decor(fn: BothCbT):
+            for t in tps:
+                self.register_both(t, fn)
+            return fn
+        return decor
+
+
+# TODO: This does not belong in this module!
+class FilteredWalker(_WalkerRegistry):
+    def __init__(self):
+        cls_reg = self.class_registry()
+        super().__init__(cls_reg.enter_cbs, cls_reg.exit_cbs, cls_reg.both_cbs)
+
+    @classmethod
+    def class_registry(cls) -> _WalkerRegistry:
+        return _WalkerRegistry()
+
+    @classmethod
+    def create_cls_registry(cls, fn=None):
+        """Create a class-level registry that can be added to using decorators.
+
+        This can be used in two ways (at the top of your class)::
+
+            # MUST be this name
+            class_registry = FilteredWalker.create_cls_registry()
+
+        or::
+
+            @classmethod
+            @FilteredWalker.create_cls_registry
+            def class_registry(cls):  # MUST be this name
+                pass
+
+        and when registering methods::
+
+            @class_registry.on_enter(AstDefine)
+            def enter_define(self, ...):
+                ...
+
+        The restrictions on name are because we have no other way of detecting
+         it (without metaclass dark magic) as we can't refer to the class while
+         its namespace is being evaluated
+        """
+        if fn is not None and (parent := fn(cls)) is not None:
+            return _WalkerRegistry.copy(parent)
+        return _WalkerRegistry()
+
     def __call__(self, o: WalkableT, call_type: WalkerCallType):
         result = None
         # Call more specific ones first
@@ -226,3 +304,30 @@ def enter_fn_decl(fn: AstDefine):
 
     def err(self, msg: str, region: StrRegion):
         return NameResolutionError(msg, region, self.src)
+
+
+class Typechecker:
+    def __init__(self, name_resolver: NameResolver):
+        self.resolver = name_resolver
+        self.src = self.resolver.src
+        self.is_ok: bool | None = None
+
+    def _init(self):
+        self.resolver.run()
+        self.ast = self.resolver.ast
+        self.top_scope = self.resolver.top_scope
+
+    def run(self):
+        if self.is_ok is None:
+            return self.is_ok
+        self._typecheck()
+        self.is_ok = True
+        return self.is_ok
+
+    def _typecheck(self):
+        walker = FilteredWalker()
+
+        self.ast.walk(walker)
+        ...
+
+

From a8e45fd726ac83351be1ffc80a56c1611aa3804f Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Thu, 12 Jun 2025 19:32:47 +0100
Subject: [PATCH 2/8] refactor(name-resolve): Move FilteredWalker to
 ast_node.py

---
 .../project_inspections.xml                   |   1 +
 parser/astgen/ast_node.py                     | 123 +++++++++++++++++-
 parser/typecheck/typecheck.py                 | 122 +----------------
 3 files changed, 123 insertions(+), 123 deletions(-)

diff --git a/.idea/inspectionProfiles/project_inspections.xml b/.idea/inspectionProfiles/project_inspections.xml
index 56fcd9f..47654a1 100644
--- a/.idea/inspectionProfiles/project_inspections.xml
+++ b/.idea/inspectionProfiles/project_inspections.xml
@@ -14,6 +14,7 @@
         </value>
       </option>
     </inspection_tool>
+    <inspection_tool class="PyInconsistentReturnsInspection" enabled="true" level="INFORMATION" enabled_by_default="true" editorAttributes="INFORMATION_ATTRIBUTES" />
     <inspection_tool class="PyPep8Inspection" enabled="true" level="WEAK WARNING" enabled_by_default="true">
       <option name="ignoredErrors">
         <list>
diff --git a/parser/astgen/ast_node.py b/parser/astgen/ast_node.py
index 56750fc..5994210 100644
--- a/parser/astgen/ast_node.py
+++ b/parser/astgen/ast_node.py
@@ -2,8 +2,9 @@
 
 from dataclasses import dataclass
 from enum import Enum
-from typing import Callable, TypeAlias, Iterable
+from typing import Callable, TypeAlias, Iterable, TypeVar
 
+from util import flatten_force
 from ..common import HasRegion, StrRegion
 
 __all__ = [
@@ -11,7 +12,8 @@
     "AstRepeat", "AstIf", "AstWhile", "AstAssign", "AstAugAssign", "AstDefine",
     "AstNumber", "AstString", "AstAnyName", "AstIdent", "AstAttrName",
     "AstListLiteral", "AstAttribute", "AstItem", "AstCall", "AstOp", "AstBinOp",
-    "AstUnaryOp", 'walk_ast', 'WalkableT', 'WalkerFnT', 'WalkerCallType'
+    "AstUnaryOp", 'walk_ast', 'WalkableT', 'WalkerFnT', 'WalkerCallType',
+    "FilteredWalker"
 ]
 
 
@@ -48,7 +50,6 @@ def _walk_obj_members(cls, o: WalkableT, fn: WalkerFnT):
         if o is None:
             return
         if isinstance(o, AstNode):
-            # noinspection PyProtectedMember
             return o._walk_members(fn)
         try:
             it = iter(o)
@@ -75,6 +76,122 @@ def walk_multiple_objects(cls, fn: WalkerFnT, objs: Iterable[WalkableT]):
 walk_ast = AstNode.walk_obj
 
 
+# region <FilteredWalker>
+WT = TypeVar('WT', bound=WalkableT)
+VT = TypeVar('VT')
+SpecificCbT = Callable[[WT], bool | None]
+SpecificCbsDict = dict[type[WT] | type, list[Callable[[WT], bool | None]]]
+BothCbT = Callable[[WT, WalkerCallType], bool | None]
+BothCbsDict = dict[type[WT] | type, list[Callable[[WT, WalkerCallType], bool | None]]]
+
+
+class WalkerFilterRegistry:
+    def __init__(self, enter_cbs: SpecificCbsDict = (),
+                 exit_cbs: SpecificCbsDict = (),
+                 both_sbc: BothCbsDict = ()):
+        self.enter_cbs: SpecificCbsDict = dict(enter_cbs)  # Copy them,
+        self.exit_cbs: SpecificCbsDict = dict(exit_cbs)    # also converts default () -> {}
+        self.both_cbs: BothCbsDict = dict(both_sbc)
+
+    def copy(self):
+        return WalkerFilterRegistry(self.enter_cbs, self.exit_cbs, self.both_cbs)
+
+    def register_both(self, t: type[WT], fn: Callable[[WT, WalkerCallType], bool | None]):
+        self.both_cbs.setdefault(t, []).append(fn)
+        return self
+
+    def register_enter(self, t: type[WT], fn: Callable[[WT], bool | None]):
+        self.enter_cbs.setdefault(t, []).append(fn)
+        return self
+
+    def register_exit(self, t: type[WT], fn: Callable[[WT], bool | None]):
+        self.exit_cbs.setdefault(t, []).append(fn)
+        return self
+
+    def __call__(self, *args, **kwargs):
+        return self
+
+    def on_enter(self, *tps: type[WT] | type):
+        """Decorator version of register_enter."""
+        def decor(fn: SpecificCbT):
+            for t in tps:
+                self.register_enter(t, fn)
+            return fn
+        return decor
+
+    def on_exit(self, *tps: type[WT] | type):
+        """Decorator version of register_exit."""
+        def decor(fn: SpecificCbT):
+            for t in tps:
+                self.register_exit(t, fn)
+            return fn
+        return decor
+
+    def on_both(self, *tps: type[WT] | type):
+        """Decorator version of register_both."""
+        def decor(fn: BothCbT):
+            for t in tps:
+                self.register_both(t, fn)
+            return fn
+        return decor
+
+
+class FilteredWalker(WalkerFilterRegistry):
+    def __init__(self):
+        cls_reg = self.class_registry()
+        super().__init__(cls_reg.enter_cbs, cls_reg.exit_cbs, cls_reg.both_cbs)
+
+    @classmethod
+    def class_registry(cls) -> WalkerFilterRegistry:
+        return WalkerFilterRegistry()
+
+    @classmethod
+    def create_cls_registry(cls, fn=None):
+        """Create a class-level registry that can be added to using decorators.
+
+        This can be used in two ways (at the top of your class)::
+
+            # MUST be this name
+            class_registry = FilteredWalker.create_cls_registry()
+
+        or::
+
+            @classmethod
+            @FilteredWalker.create_cls_registry
+            def class_registry(cls):  # MUST be this name
+                pass
+
+        and when registering methods::
+
+            @class_registry.on_enter(AstDefine)
+            def enter_define(self, ...):
+                ...
+
+        The restrictions on name are because we have no other way of detecting
+         it (without metaclass dark magic) as we can't refer to the class while
+         its namespace is being evaluated
+        """
+        if fn is not None and (parent := fn(cls)) is not None:
+            return WalkerFilterRegistry.copy(parent)
+        return WalkerFilterRegistry()
+
+    def __call__(self, o: WalkableT, call_type: WalkerCallType):
+        result = None
+        # Call more specific ones first
+        specific_cbs = self.enter_cbs if call_type == WalkerCallType.PRE else self.exit_cbs
+        for fn in self._get_funcs(specific_cbs, type(o)):
+            result = fn(o) or result
+        for fn in self._get_funcs(self.both_cbs, type(o)):
+            result = fn(o, call_type) or result
+        return result
+
+    @classmethod
+    def _get_funcs(cls, mapping: dict[type[WT] | type, list[VT]], tp: type[WT]) -> list[VT]:
+        """Also looks at superclasses/MRO"""
+        return flatten_force(mapping.get(sub, []) for sub in tp.mro())
+# endregion
+
+
 @dataclass
 class AstProgramNode(AstNode):
     name = 'program'
diff --git a/parser/typecheck/typecheck.py b/parser/typecheck/typecheck.py
index 0b79636..1e29523 100644
--- a/parser/typecheck/typecheck.py
+++ b/parser/typecheck/typecheck.py
@@ -1,130 +1,12 @@
 from __future__ import annotations
 
-import functools
 from dataclasses import dataclass, field
-from typing import Callable, TypeVar
 
 from parser.astgen.ast_node import (
-    AstNode, walk_ast, WalkableT, WalkerCallType, AstIdent, AstDeclNode,
-    AstDefine, VarDeclType, VarDeclScope)
+    AstNode, walk_ast, AstIdent, AstDeclNode, AstDefine, VarDeclType,
+    VarDeclScope, FilteredWalker)
 from parser.astgen.astgen import AstGen
 from parser.common import BaseLocatedError, StrRegion
-from util import flatten_force
-
-WT = TypeVar('WT', bound=WalkableT)
-VT = TypeVar('VT')
-
-SpecificCbT = Callable[[WT], bool | None]
-SpecificCbsDict = dict[type[WT] | type, list[Callable[[WT], bool | None]]]
-BothCbT = Callable[[WT, WalkerCallType], bool | None]
-BothCbsDict = dict[type[WT] | type, list[Callable[[WT, WalkerCallType], bool | None]]]
-
-
-class _WalkerRegistry:
-    def __init__(self, enter_cbs: SpecificCbsDict = (),
-                 exit_cbs: SpecificCbsDict = (),
-                 both_sbc: BothCbsDict = ()):
-        self.enter_cbs: SpecificCbsDict = dict(enter_cbs)  # Copy them,
-        self.exit_cbs: SpecificCbsDict = dict(exit_cbs)    # also converts default () -> {}
-        self.both_cbs: BothCbsDict = dict(both_sbc)
-
-    def copy(self):
-        return _WalkerRegistry(self.enter_cbs, self.exit_cbs, self.both_cbs)
-
-    def register_both(self, t: type[WT], fn: Callable[[WT, WalkerCallType], bool | None]):
-        self.both_cbs.setdefault(t, []).append(fn)
-        return self
-
-    def register_enter(self, t: type[WT], fn: Callable[[WT], bool | None]):
-        self.enter_cbs.setdefault(t, []).append(fn)
-        return self
-
-    def register_exit(self, t: type[WT], fn: Callable[[WT], bool | None]):
-        self.exit_cbs.setdefault(t, []).append(fn)
-        return self
-
-    def __call__(self, *args, **kwargs):
-        return self
-
-    def on_enter(self, *tps: type[WT] | type):
-        """Decorator version of register_enter."""
-        def decor(fn: SpecificCbT):
-            for t in tps:
-                self.register_enter(t, fn)
-            return fn
-        return decor
-
-    def on_exit(self, *tps: type[WT] | type):
-        """Decorator version of register_exit."""
-        def decor(fn: SpecificCbT):
-            for t in tps:
-                self.register_exit(t, fn)
-            return fn
-        return decor
-
-    def on_both(self, *tps: type[WT] | type):
-        """Decorator version of register_both."""
-        def decor(fn: BothCbT):
-            for t in tps:
-                self.register_both(t, fn)
-            return fn
-        return decor
-
-
-# TODO: This does not belong in this module!
-class FilteredWalker(_WalkerRegistry):
-    def __init__(self):
-        cls_reg = self.class_registry()
-        super().__init__(cls_reg.enter_cbs, cls_reg.exit_cbs, cls_reg.both_cbs)
-
-    @classmethod
-    def class_registry(cls) -> _WalkerRegistry:
-        return _WalkerRegistry()
-
-    @classmethod
-    def create_cls_registry(cls, fn=None):
-        """Create a class-level registry that can be added to using decorators.
-
-        This can be used in two ways (at the top of your class)::
-
-            # MUST be this name
-            class_registry = FilteredWalker.create_cls_registry()
-
-        or::
-
-            @classmethod
-            @FilteredWalker.create_cls_registry
-            def class_registry(cls):  # MUST be this name
-                pass
-
-        and when registering methods::
-
-            @class_registry.on_enter(AstDefine)
-            def enter_define(self, ...):
-                ...
-
-        The restrictions on name are because we have no other way of detecting
-         it (without metaclass dark magic) as we can't refer to the class while
-         its namespace is being evaluated
-        """
-        if fn is not None and (parent := fn(cls)) is not None:
-            return _WalkerRegistry.copy(parent)
-        return _WalkerRegistry()
-
-    def __call__(self, o: WalkableT, call_type: WalkerCallType):
-        result = None
-        # Call more specific ones first
-        specific_cbs = self.enter_cbs if call_type == WalkerCallType.PRE else self.exit_cbs
-        for fn in self._get_funcs(specific_cbs, type(o)):
-            result = fn(o) or result
-        for fn in self._get_funcs(self.both_cbs, type(o)):
-            result = fn(o, call_type) or result
-        return result
-
-    @classmethod
-    def _get_funcs(cls, mapping: dict[type[WT] | type, list[VT]], tp: type[WT]) -> list[VT]:
-        """Also looks at superclasses/MRO"""
-        return flatten_force(mapping.get(sub, []) for sub in tp.mro())
 
 
 @dataclass

From d763ff307f703a844b224bbf4182f06eb14018c1 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Thu, 12 Jun 2025 19:42:32 +0100
Subject: [PATCH 3/8] refactor: Convert absolute to relative imports

---
 parser/astgen/errors.py       | 2 +-
 parser/lexer/errors.py        | 2 +-
 parser/typecheck/typecheck.py | 6 +++---
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/parser/astgen/errors.py b/parser/astgen/errors.py
index bfa6e77..7735496 100644
--- a/parser/astgen/errors.py
+++ b/parser/astgen/errors.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from parser.common import BaseParseError, BaseLocatedError
+from ..common import BaseParseError, BaseLocatedError
 
 
 class AstParseError(BaseParseError):
diff --git a/parser/lexer/errors.py b/parser/lexer/errors.py
index 0734e7c..17e72cc 100644
--- a/parser/lexer/errors.py
+++ b/parser/lexer/errors.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from parser.common import BaseParseError, BaseLocatedError
+from ..common import BaseParseError, BaseLocatedError
 
 
 class TokenizerError(BaseParseError):
diff --git a/parser/typecheck/typecheck.py b/parser/typecheck/typecheck.py
index 1e29523..aea9731 100644
--- a/parser/typecheck/typecheck.py
+++ b/parser/typecheck/typecheck.py
@@ -2,11 +2,11 @@
 
 from dataclasses import dataclass, field
 
-from parser.astgen.ast_node import (
+from ..astgen.ast_node import (
     AstNode, walk_ast, AstIdent, AstDeclNode, AstDefine, VarDeclType,
     VarDeclScope, FilteredWalker)
-from parser.astgen.astgen import AstGen
-from parser.common import BaseLocatedError, StrRegion
+from ..astgen.astgen import AstGen
+from ..common import BaseLocatedError, StrRegion
 
 
 @dataclass

From 69c9d274b202ae15ff45c3e0dfd75d5644a2f049 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Fri, 13 Jun 2025 18:26:40 +0100
Subject: [PATCH 4/8] test(name-resolve): Add non-snapshot test

---
 test/test_typecheck/test_name_resolve.py | 27 +++++++++++++++++++++++-
 1 file changed, 26 insertions(+), 1 deletion(-)

diff --git a/test/test_typecheck/test_name_resolve.py b/test/test_typecheck/test_name_resolve.py
index 2137642..15fbb54 100644
--- a/test/test_typecheck/test_name_resolve.py
+++ b/test/test_typecheck/test_name_resolve.py
@@ -1,7 +1,9 @@
 from unittest.mock import Mock, patch
 
 from parser.common import StrRegion
-from parser.typecheck.typecheck import NameResolver
+from parser.typecheck.typecheck import (
+    NameResolver, Scope, NameInfo, BoolType, ValType, VoidType,
+    FuncInfo, ParamInfo)
 from test.common import CommonTestCase
 
 
@@ -48,6 +50,29 @@ def test_top_scope_attr(self):
             self.assertIs(v2, nr.top_scope)
             m.assert_called_once()  # Still only once
 
+    def test_params(self):
+        src = ('def f1(bool b0, val v0, string s0, number n0) {let L0=s0..v0;};'
+               'def f2() {}')
+        sc = Scope()
+        f1_scope = Scope()
+        f1_scope.declared = {
+            'b0': NameInfo(f1_scope, 'b0', BoolType(), is_param=True),
+            'v0': (v0 := NameInfo(f1_scope, 'v0', ValType(), is_param=True)),
+            's0': (s0 := NameInfo(f1_scope, 's0', ValType(), is_param=True)),
+            'n0': NameInfo(f1_scope, 'n0', ValType(), is_param=True),
+        }
+        f1_scope.used = {'v0': v0, 's0': s0}
+        sc.declared = {
+            'f1': FuncInfo.from_param_info(sc, 'f1', [
+                ParamInfo('b0', BoolType()),
+                ParamInfo('v0', ValType()),
+                ParamInfo('s0', ValType()),  # val == string  ==  number for now
+                ParamInfo('n0', ValType()),
+            ], VoidType(), f1_scope),
+            'f2': FuncInfo.from_param_info(sc, 'f2', [], VoidType(), Scope())
+        }
+        self.assertEqual(self.getNameResolver(src).run(), sc)
+
 
 class TestNameResolveErrors(CommonTestCase):
     def test_undefined_var(self):

From 477246e396654c665ff9f81f6c9cc22dc13e3e3c Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Fri, 13 Jun 2025 23:30:50 +0100
Subject: [PATCH 5/8] fix(name-resolve): Fix Scope.__eq__ giving recursion
 errors

---
 parser/typecheck/typecheck.py |  4 ++++
 util/recursive_eq.py          | 26 ++++++++++++++++++++++++++
 2 files changed, 30 insertions(+)
 create mode 100644 util/recursive_eq.py

diff --git a/parser/typecheck/typecheck.py b/parser/typecheck/typecheck.py
index aea9731..d8c609c 100644
--- a/parser/typecheck/typecheck.py
+++ b/parser/typecheck/typecheck.py
@@ -2,6 +2,7 @@
 
 from dataclasses import dataclass, field
 
+from util.recursive_eq import recursive_eq
 from ..astgen.ast_node import (
     AstNode, walk_ast, AstIdent, AstDeclNode, AstDefine, VarDeclType,
     VarDeclScope, FilteredWalker)
@@ -84,6 +85,9 @@ class Scope:
     (so type codegen/type-checker knows what each AstIdent refers to)"""
 
 
+Scope.__eq__ = recursive_eq(Scope.__eq__)
+
+
 class NameResolutionError(BaseLocatedError):
     pass
 
diff --git a/util/recursive_eq.py b/util/recursive_eq.py
new file mode 100644
index 0000000..2f86c02
--- /dev/null
+++ b/util/recursive_eq.py
@@ -0,0 +1,26 @@
+"""Safe recursive equality comparison."""
+import functools
+
+
+def recursive_eq(fn):
+    """Must be used as decorator, like reprlib.recursive_repr.
+    Works by hypothesising that 2 ids are equal. Then, it tries to compare
+    them. If it encounters one of them again, it checks that the corresponding
+    value is the hypothesised value. If so, they're equal. If not, they're
+    unequal."""
+    hypotheses: dict[int, int] = {}  # int <-> int (should be undirected)
+
+    @functools.wraps(fn)
+    def eq(a, b):
+        if (bid_exp := hypotheses.get(id(a))) is not None:
+            return bid_exp == id(b)
+        if (aid_exp := hypotheses.get(id(b))) is not None:
+            return aid_exp == id(a)
+        hypotheses[id(a)] = id(b)
+        hypotheses[id(b)] = id(a)
+        try:
+            return fn(a, b)  # Will call this function again
+        finally:
+            del hypotheses[id(a)]
+            del hypotheses[id(b)]
+    return eq

From e1d39ba157997762a60f1ed72cb065eae3458fbf Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Fri, 13 Jun 2025 23:34:00 +0100
Subject: [PATCH 6/8] test(name-resolve): Add missing local to expected result
 (test for #66, fixes #67)

---
 test/test_typecheck/test_name_resolve.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/test/test_typecheck/test_name_resolve.py b/test/test_typecheck/test_name_resolve.py
index 15fbb54..980e7a0 100644
--- a/test/test_typecheck/test_name_resolve.py
+++ b/test/test_typecheck/test_name_resolve.py
@@ -60,18 +60,19 @@ def test_params(self):
             'v0': (v0 := NameInfo(f1_scope, 'v0', ValType(), is_param=True)),
             's0': (s0 := NameInfo(f1_scope, 's0', ValType(), is_param=True)),
             'n0': NameInfo(f1_scope, 'n0', ValType(), is_param=True),
+            'L0': NameInfo(f1_scope, 'L0', ValType())
         }
         f1_scope.used = {'v0': v0, 's0': s0}
         sc.declared = {
             'f1': FuncInfo.from_param_info(sc, 'f1', [
                 ParamInfo('b0', BoolType()),
                 ParamInfo('v0', ValType()),
-                ParamInfo('s0', ValType()),  # val == string  ==  number for now
+                ParamInfo('s0', ValType()),  # val == string == number for now
                 ParamInfo('n0', ValType()),
             ], VoidType(), f1_scope),
             'f2': FuncInfo.from_param_info(sc, 'f2', [], VoidType(), Scope())
         }
-        self.assertEqual(self.getNameResolver(src).run(), sc)
+        self.assertEqual(sc, self.getNameResolver(src).run())
 
 
 class TestNameResolveErrors(CommonTestCase):

From 1c39ed2ad655d2904dd21203047d7cd38e727aea Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Fri, 13 Jun 2025 23:38:21 +0100
Subject: [PATCH 7/8] fix(name-resolve): Fix parameter type handling, fixes #66

---
 parser/typecheck/typecheck.py | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/parser/typecheck/typecheck.py b/parser/typecheck/typecheck.py
index d8c609c..e989aa1 100644
--- a/parser/typecheck/typecheck.py
+++ b/parser/typecheck/typecheck.py
@@ -155,14 +155,15 @@ def enter_fn_decl(fn: AstDefine):
                 raise self.err("Function already declared", fn.ident.region)
             subscope = Scope()
             params: list[ParamInfo] = []
-            for tp, param in fn.params:
-                if tp.id not in PARAM_TYPES:
-                    raise self.err("Unknown parameter type", tp.region)
-                if param.id in subscope.declared:
-                    raise self.err("There is already a parameter of this name", param.region)
-                tp = BoolType() if param.id == 'bool' else ValType()
-                subscope.declared[param.id] = NameInfo(subscope, param.id, tp, is_param=True)
-                params.append(ParamInfo(param.id, tp))
+            for tp_node, name_node in fn.params:
+                if tp_node.id not in PARAM_TYPES:
+                    raise self.err("Unknown parameter type", tp_node.region)
+                if (name := name_node.id) in subscope.declared:
+                    raise self.err("There is already a parameter of this name",
+                                   name_node.region)
+                tp = BoolType() if tp_node.id == 'bool' else ValType()
+                subscope.declared[name] = NameInfo(subscope, name, tp, is_param=True)
+                params.append(ParamInfo(name, tp))
             curr_scope.declared[ident] = info = FuncInfo.from_param_info(
                 curr_scope, ident, params,
                 ret_type=VoidType(), subscope=subscope)

From 7f0e52c6404fefcc828bb61c9518eabff06d33ae Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Fri, 13 Jun 2025 23:43:38 +0100
Subject: [PATCH 8/8] refactor(util): Add recursive_eq to exports from __init__

---
 util/__init__.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/util/__init__.py b/util/__init__.py
index 4780766..2faf3ce 100644
--- a/util/__init__.py
+++ b/util/__init__.py
@@ -3,6 +3,7 @@
 from os import PathLike
 from typing import TypeVar, Any, overload, Iterable
 
+from .recursive_eq import recursive_eq
 from .simple_process_pool import *
 from .timeouts import *