test(name-resolve): Add some unittests for NameResolver

Author: MarcellPerger1

test/common/common.py

@@ -14,7 +14,7 @@
 from parser.cst.cstgen import CstGen, LocatedCstError
 from parser.lexer import Tokenizer
 from parser.lexer.tokens import Token, OpToken
-from parser.typecheck.typecheck import Scope
+from parser.typecheck.typecheck import Scope, NameResolver, NameResolutionError
 from test.common.snapshottest import SnapshotTestCase
 from test.common.utils import TestCaseUtils
 from util.pformat import pformat
@@ -127,3 +127,13 @@ def assertFailsGracefullyAST(self, src: str):
         with self.assertRaises(LocatedAstError) as ctx:
             a.parse()
         return ctx.exception
+
+    # noinspection PyMethodMayBeStatic
+    def getNameResolver(self, src: str):
+        return NameResolver(AstGen(CstGen(Tokenizer(src))))
+
+    def assertNameResolveError(self, src: str):
+        nr = self.getNameResolver(src)
+        with self.assertRaises(NameResolutionError) as ctx:
+            nr.run()
+        return ctx.exception

test/test_typecheck/test_name_resolve.py

@@ -0,0 +1,55 @@
+from unittest.mock import Mock, patch
+
+from parser.common import StrRegion
+from parser.typecheck.typecheck import NameResolver
+from test.common import CommonTestCase
+
+
+class BoundMock(Mock):
+    # Not-so-black magic to allow setting the method on the class while ensuring
+    # that the wrapper receives the correct `self` value (builtin unittest is
+    # a bit broken in this regard, as it passes no self value at all)
+    def __init__(self, *args, wraps=None, **kwargs):
+        if wraps:
+            def wraps_2(*a, **k):  # I hope we don't have to pickle this anywhere...
+                if (inst := self.__dict__['_inst']) is not None:
+                    return wraps(inst, *a, **k)
+                else:
+                    return wraps(*a, **k)
+        else:
+            wraps_2 = None
+        super().__init__(*args, wraps=wraps_2, **kwargs)
+        self.__dict__['_inst'] = None
+
+    def __get__(self, instance, owner=None):
+        # This very naive method of finding out the proper instance works
+        # because __get__ will be called again every time this is accessed
+        if owner is not None:  # if accessed on instance
+            self.__dict__['_inst'] = instance
+        else:
+            self.__dict__['_inst'] = None
+        return self
+
+
+class TestNameResolve(CommonTestCase):
+    def test_top_scope_attr(self):
+        src = 'let a = 8, b = 5; a += b; def c(val param) {c(param, a, b);}'
+        orig = NameResolver._init  # Reliably called exactly once in slow path of .run()
+        m = BoundMock(spec_set=orig, wraps=orig)
+        with patch.object(NameResolver, '_init', new_callable=lambda: m):
+            nr = self.getNameResolver(src)
+            self.assertIsNone(nr.top_scope)
+            m.assert_not_called()
+            v = nr.run()
+            self.assertIs(v, nr.top_scope)
+            m.assert_called_once()
+            v2 = nr.run()
+            self.assertIs(v2, v)
+            m.assert_called_once()  # Still only once
+
+
+class TestNameResolveErrors(CommonTestCase):
+    def test_undefined_var(self):
+        err = self.assertNameResolveError('foo = 9;')
+        self.assertContains(err.msg, "Name 'foo' is not defined")
+        self.assertEqual(StrRegion(0, 3), err.region)