jaclang 0.7.16__py3-none-any.whl → 0.7.18__py3-none-any.whl

jaclang/compiler/passes/utils/mypy_ast_build.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import ast
 import os
+from typing import Callable, TYPE_CHECKING, TextIO
 
 from jaclang.compiler.absyntree import AstNode
 from jaclang.compiler.passes import Pass
@@ -21,13 +22,19 @@ from mypy.build import FileSystemCache
 from mypy.build import Graph
 from mypy.build import ModuleNotFound
 from mypy.build import PRI_INDIRECT
+from mypy.build import Plugin
+from mypy.build import SearchPaths
 from mypy.build import compute_search_paths
 from mypy.build import find_module_simple
+from mypy.build import find_module_with_reason
 from mypy.build import load_plugins
 from mypy.build import process_graph
 from mypy.options import Options
 from mypy.semanal_main import semantic_analysis_for_scc
 
+if TYPE_CHECKING:
+    from mypy.report import Reports  # Avoid unconditional slow import
+
 
 mypy_to_jac_node_map: dict[
     tuple[int, int | None, int | None, int | None], list[AstNode]
@@ -37,6 +44,43 @@ mypy_to_jac_node_map: dict[
 class BuildManager(myb.BuildManager):
     """Overrides to mypy build manager for direct AST pass through."""
 
+    def __init__(
+        self,
+        data_dir: str,
+        search_paths: SearchPaths,
+        ignore_prefix: str,
+        source_set: BuildSourceSet,
+        reports: Reports | None,
+        options: Options,
+        version_id: str,
+        plugin: Plugin,
+        plugins_snapshot: dict[str, str],
+        errors: Errors,
+        flush_errors: Callable[[str | None, list[str], bool], None],
+        fscache: FileSystemCache,
+        stdout: TextIO,
+        stderr: TextIO,
+    ) -> None:
+        """Override mypy BuildManager constructor to initialize jac related map."""
+        global mypy_to_jac_node_map
+        super().__init__(
+            data_dir,
+            search_paths,
+            ignore_prefix,
+            source_set,
+            reports,
+            options,
+            version_id,
+            plugin,
+            plugins_snapshot,
+            errors,
+            flush_errors,
+            fscache,
+            stdout,
+            stderr,
+        )
+        mypy_to_jac_node_map = {}
+
     def parse_file(
         self,
         id: str,
@@ -664,6 +708,7 @@ __all__ = [
     "BuildSource",
     "BuildSourceSet",
     "FileSystemCache",
+    "find_module_with_reason",
     "compute_search_paths",
     "load_graph",
     "load_plugins",

jaclang/compiler/symtable.py

@@ -137,7 +137,7 @@ class SymbolTable:
                 return k
         return None
 
-    def push_scope(self, name: str, key_node: ast.AstNode) -> SymbolTable:
+    def push_kid_scope(self, name: str, key_node: ast.AstNode) -> SymbolTable:
         """Push a new scope onto the symbol table."""
         self.kid.append(SymbolTable(name, key_node, self))
         return self.kid[-1]
@@ -205,16 +205,21 @@ class SymbolTable:
         for i in node_list:
             if cur_sym_tab is None:
                 break
-            cur_sym_tab = (
-                lookup.decl.sym_tab
-                if (
-                    lookup := self.use_lookup(
-                        i,
-                        sym_table=cur_sym_tab,
-                    )
-                )
-                else None
-            )
+            lookup = self.use_lookup(i, sym_table=cur_sym_tab)
+            if lookup:
+                cur_sym_tab = lookup.decl.sym_tab
+
+                # check if the symbol table name is not the same as symbol name
+                # then try to find a child scope with the same name
+                # This is used to get the scope in case of
+                #      import:py math;
+                #      b = math.floor(1.7);
+                if cur_sym_tab.name != i.sym_name:
+                    t = cur_sym_tab.find_scope(i.sym_name)
+                    if t:
+                        cur_sym_tab = t
+            else:
+                cur_sym_tab = None
 
     def update_py_ctx_for_def(self, node: ast.AstSymbolNode) -> None:
         """Update python context for definition."""

jaclang/compiler/tests/test_importer.py

@@ -5,29 +5,37 @@ import sys
 
 from jaclang import jac_import
 from jaclang.cli import cli
-from jaclang.plugin.feature import JacFeature as Jac
+from jaclang.runtimelib.machine import JacMachine, JacProgram
 from jaclang.utils.test import TestCase
 
 
 class TestLoader(TestCase):
     """Test Jac self.prse."""
 
-    def setUp(self) -> None:
-        """Set up test."""
-        return super().setUp()
-
     def test_import_basic_python(self) -> None:
         """Test basic self loading."""
-        Jac.context().init_memory(base_path=self.fixture_abs_path(__file__))
+        JacMachine(self.fixture_abs_path(__file__)).attach_program(
+            JacProgram(mod_bundle=None, bytecode=None)
+        )
         (h,) = jac_import("fixtures.hello_world", base_path=__file__)
         self.assertEqual(h.hello(), "Hello World!")  # type: ignore
+        JacMachine.detach()
 
     def test_modules_correct(self) -> None:
         """Test basic self loading."""
-        Jac.context().init_memory(base_path=self.fixture_abs_path(__file__))
+        JacMachine(self.fixture_abs_path(__file__)).attach_program(
+            JacProgram(mod_bundle=None, bytecode=None)
+        )
         jac_import("fixtures.hello_world", base_path=__file__)
-        self.assertIn("module 'fixtures.hello_world'", str(sys.modules))
-        self.assertIn("/tests/fixtures/hello_world.jac", str(sys.modules))
+        self.assertIn(
+            "module 'fixtures.hello_world'",
+            str(JacMachine.get().loaded_modules),
+        )
+        self.assertIn(
+            "/tests/fixtures/hello_world.jac",
+            str(JacMachine.get().loaded_modules),
+        )
+        JacMachine.detach()
 
     def test_jac_py_import(self) -> None:
         """Basic test for pass."""

jaclang/langserve/engine.py

@@ -16,13 +16,13 @@ from jaclang.compiler.passes.main.schedules import py_code_gen_typed
 from jaclang.compiler.passes.tool import FuseCommentsPass, JacFormatPass
 from jaclang.langserve.sem_manager import SemTokManager
 from jaclang.langserve.utils import (
+    add_unique_text_edit,
     collect_all_symbols_in_scope,
     create_range,
     find_deepest_symbol_node_at_pos,
     find_index,
     gen_diagnostics,
-    get_item_path,
-    get_mod_path,
+    get_location_range,
     get_symbols_for_outline,
     parse_symbol_path,
     resolve_completion_symbol_table,
@@ -127,6 +127,15 @@ class JacLangServer(LanguageServer):
                     build.warnings_had,
                 ),
             )
+            if annex_view:
+                self.publish_diagnostics(
+                    file_path,
+                    gen_diagnostics(
+                        file_path,
+                        build.errors_had,
+                        build.warnings_had,
+                    ),
+                )
             self.log_py(f"PROFILE: Deep check took {time.time() - start_time} seconds.")
             return len(build.errors_had) == 0
         except Exception as e:
@@ -325,8 +334,9 @@ class JacLangServer(LanguageServer):
                 and node_selected.parent
                 and isinstance(node_selected.parent, ast.ModulePath)
             ):
-                spec = get_mod_path(node_selected.parent, node_selected)
+                spec = node_selected.parent.abs_path
                 if spec:
+                    spec = spec[5:] if spec.startswith("File:") else spec
                     return lspt.Location(
                         uri=uris.from_fs_path(spec),
                         range=lspt.Range(
@@ -339,19 +349,28 @@ class JacLangServer(LanguageServer):
             elif node_selected.parent and isinstance(
                 node_selected.parent, ast.ModuleItem
             ):
-                path_range = get_item_path(node_selected.parent)
-                if path_range:
-                    path, loc_range = path_range
-                    if path and loc_range:
-                        return lspt.Location(
-                            uri=uris.from_fs_path(path),
-                            range=lspt.Range(
-                                start=lspt.Position(line=loc_range[0], character=0),
-                                end=lspt.Position(line=loc_range[1], character=5),
+                path = node_selected.parent.from_mod_path.abs_path
+                try:  # TODO: Get rid of this when 'from' import is fixed
+                    loc_range = tuple(
+                        loc - 1 if loc > 0 else loc
+                        for loc in get_location_range(node_selected.parent)
+                    )
+                except ValueError:
+                    loc_range = (0, 0, 0, 0)
+
+                if path and loc_range:
+                    path = path[5:] if path.startswith("File:") else path
+                    return lspt.Location(
+                        uri=uris.from_fs_path(path),
+                        range=lspt.Range(
+                            start=lspt.Position(
+                                line=loc_range[0], character=loc_range[1]
                             ),
-                        )
-                else:
-                    return None
+                            end=lspt.Position(
+                                line=loc_range[2], character=loc_range[3]
+                            ),
+                        ),
+                    )
             elif isinstance(node_selected, (ast.ElementStmt, ast.BuiltinType)):
                 return None
             decl_node = (
@@ -368,7 +387,7 @@ class JacLangServer(LanguageServer):
             decl_uri = uris.from_fs_path(decl_node.loc.mod_path)
             try:
                 decl_range = create_range(decl_node.loc)
-            except ValueError:  # 'print' name has decl in 0,0,0,0
+            except ValueError:
                 return None
             decl_location = lspt.Location(
                 uri=decl_uri,
@@ -404,6 +423,35 @@ class JacLangServer(LanguageServer):
             return list_of_references
         return []
 
+    def rename_symbol(
+        self, file_path: str, position: lspt.Position, new_name: str
+    ) -> Optional[lspt.WorkspaceEdit]:
+        """Rename a symbol in a file."""
+        if file_path not in self.modules:
+            return None
+        index1 = find_index(
+            self.modules[file_path].sem_manager.sem_tokens,
+            position.line,
+            position.character,
+        )
+        if index1 is None:
+            return None
+        node_selected = self.modules[file_path].sem_manager.static_sem_tokens[index1][3]
+        if node_selected and node_selected.sym:
+            changes: dict[str, list[lspt.TextEdit]] = {}
+            for node in [
+                *node_selected.sym.uses,
+                node_selected.sym.defn[0],
+            ]:
+                key = uris.from_fs_path(node.loc.mod_path)
+                new_edit = lspt.TextEdit(
+                    range=create_range(node.loc),
+                    new_text=new_name,
+                )
+                add_unique_text_edit(changes, key, new_edit)
+            return lspt.WorkspaceEdit(changes=changes)
+        return None
+
     def get_semantic_tokens(self, file_path: str) -> lspt.SemanticTokens:
         """Return semantic tokens for a file."""
         if file_path not in self.modules:

jaclang/langserve/server.py

@@ -17,8 +17,14 @@ server = JacLangServer()
 
 
 @server.feature(lspt.TEXT_DOCUMENT_DID_OPEN)
-@server.feature(lspt.TEXT_DOCUMENT_DID_SAVE)
 async def did_open(ls: JacLangServer, params: lspt.DidOpenTextDocumentParams) -> None:
+    """Check syntax on change."""
+    ls.deep_check(params.text_document.uri)
+    ls.lsp.send_request(lspt.WORKSPACE_SEMANTIC_TOKENS_REFRESH)
+
+
+@server.feature(lspt.TEXT_DOCUMENT_DID_SAVE)
+async def did_save(ls: JacLangServer, params: lspt.DidOpenTextDocumentParams) -> None:
     """Check syntax on change."""
     await ls.launch_deep_check(params.text_document.uri)
     ls.lsp.send_request(lspt.WORKSPACE_SEMANTIC_TOKENS_REFRESH)
@@ -132,6 +138,15 @@ def references(ls: JacLangServer, params: lspt.ReferenceParams) -> list[lspt.Loc
     return ls.get_references(params.text_document.uri, params.position)
 
 
+@server.feature(lspt.TEXT_DOCUMENT_RENAME)
+def rename(
+    ls: JacLangServer, params: lspt.RenameParams
+) -> Optional[lspt.WorkspaceEdit]:
+    """Rename symbol."""
+    ls.log_warning("Auto Rename is Experimental, Please use with caution.")
+    return ls.rename_symbol(params.text_document.uri, params.position, params.new_name)
+
+
 @server.feature(
     lspt.TEXT_DOCUMENT_SEMANTIC_TOKENS_FULL,
     lspt.SemanticTokensLegend(

jaclang/langserve/tests/fixtures/import_include_statements.jac

@@ -1,6 +1,6 @@
 import:py os;
-import:py from math, sqrt as square_root;
+import:py from math{ sqrt as square_root}
 import:py datetime as dt;
-import:jac from base_module_structure, add as add_numbers , subtract,x,Colorenum as clr;
+import:jac from base_module_structure{ add as add_numbers , subtract,x,Colorenum as clr}
 import:jac base_module_structure as base_module_structure;
-import:py from py_import,add1 as ss, sub1 as subtract1,apple,Orange1;
+import:py from py_import{add1 as ss, sub1 as subtract1,apple,Orange1}

jaclang/langserve/tests/fixtures/rename.jac

@@ -0,0 +1,30 @@
+can foo;
+
+
+
+:can:foo{
+    print("foo");
+}
+
+
+obj out{
+    has cnt :int;
+    can bar;
+    can baz;
+}
+
+
+:obj:out:can:bar{
+    print("bar");
+}
+
+:obj:out:can:baz{
+    print("baz");
+}
+
+with entry{
+    foo();
+    new = out();
+    new.cnt;
+    out(1).bar();
+}

jaclang/langserve/tests/test_server.py

@@ -187,11 +187,15 @@ class TestJacLangServer(TestCase):
         )
         lsp.deep_check(import_file)
         positions = [
-            (2, 24, "datetime.py:0:0-0:0"),
+            (0, 12, "tdlib/os/__init__.pyi:0:0-0:0"),
+            (1, 18, "stdlib/math.pyi:0:0-0:0"),
+            (2, 24, "datetime.pyi:0:0-0:0"),
             (3, 17, "base_module_structure.jac:0:0-0:0"),
-            (3, 87, "base_module_structure.jac:23:0-23:5"),
-            (5, 65, "py_import.py:12:0-20:5"),
-            (5, 35, "py_import.py:3:0-4:5"),
+            (3, 87, "base_module_structure.jac:23:5-23:14"),
+            (5, 65, "py_import.py:0:0-0:0"),
+            (5, 35, "py_import.py:0:0-0:0"),
+            # (5, 65, "py_import.py:12:0-20:5"),  # TODO : Should work after 'from' import files are raised
+            # (5, 35, "py_import.py:3:0-4:5"),
         ]
 
         for line, char, expected in positions:
@@ -201,6 +205,62 @@ class TestJacLangServer(TestCase):
                     str(lsp.get_definition(import_file, lspt.Position(line, char))),
                 )
 
+    def test_go_to_definition_foolme(self) -> None:
+        """Test that the go to definition is correct."""
+        lsp = JacLangServer()
+        workspace_path = self.fixture_abs_path("")
+        workspace = Workspace(workspace_path, lsp)
+        lsp.lsp._workspace = workspace
+        import_file = uris.from_fs_path(
+            self.fixture_abs_path(
+                "../../../../jaclang/compiler/passes/main/tests/fixtures/py_imp_test.jac"
+            )
+        )
+        lsp.deep_check(import_file)
+        positions = [
+            (6, 39, "/pygame_mock/__init__.py:2:0-2:0"),
+            (6, 45, "/pygame_mock/constants.py:3:0-4:1"),
+            (7, 31, "/pygame_mock/__init__.py:2:0-2:0"),
+            (7, 35, "/pygame_mock/constants.py:3:0-4:1"),
+            (20, 51, "/py_imp_test.jac:6:4-6:11"),
+            (20, 64, "/pygame_mock/constants.py:4:3-4:15"),
+            (21, 48, "/py_imp_test.jac:10:4-10:6"),
+            (21, 58, "/py_imp_test.jac:11:8-11:15"),
+            (21, 68, "/pygame_mock/constants.py:4:3-4:15"),
+            (23, 58, "/pygame_mock/constants.py:4:3-4:15"),
+        ]
+
+        for line, char, expected in positions:
+            with self.subTest(line=line, char=char):
+                self.assertIn(
+                    expected,
+                    str(lsp.get_definition(import_file, lspt.Position(line, char))),
+                )
+
+    def test_go_to_definition_index_expr(self) -> None:
+        """Test that the go to definition is correct."""
+        lsp = JacLangServer()
+        workspace_path = self.fixture_abs_path("")
+        workspace = Workspace(workspace_path, lsp)
+        lsp.lsp._workspace = workspace
+        import_file = uris.from_fs_path(
+            self.fixture_abs_path("../../../../jaclang/tests/fixtures/index_slice.jac")
+        )
+        lsp.deep_check(import_file)
+        positions = [
+            (23, 20, "index_slice.jac:2:8-2:13"),
+            (24, 24, "index_slice.jac:2:8-2:13"),
+            (27, 33, "index_slice.jac:2:8-2:13"),
+        ]
+
+        for line, char, expected in positions:
+            with self.subTest(line=line, char=char):
+                print(str(lsp.get_definition(import_file, lspt.Position(line, char))))
+                self.assertIn(
+                    expected,
+                    str(lsp.get_definition(import_file, lspt.Position(line, char))),
+                )
+
     def test_sem_tokens(self) -> None:
         """Test that the Semantic Tokens are generated correctly."""
         lsp = JacLangServer()
@@ -214,7 +274,7 @@ class TestJacLangServer(TestCase):
             ("<JacSemTokenType.VARIABLE: 8>, <JacSemTokenModifier.READONLY: 4>", 12),
             (
                 "<JacSemTokenType.PROPERTY: 9>, <JacSemTokenModifier.DEFINITION: 2>,",
-                19,
+                21,
             ),
             (
                 "<JacSemTokenType.PARAMETER: 7>, <JacSemTokenModifier.DECLARATION: 1>,",
@@ -232,7 +292,6 @@ class TestJacLangServer(TestCase):
                 3,
             ),
         ]
-        print(str(sem_list))
         for token_type, expected_count in expected_counts:
             self.assertEqual(str(sem_list).count(token_type), expected_count)
 
@@ -351,3 +410,162 @@ class TestJacLangServer(TestCase):
             references = str(lsp.get_references(circle_file, lspt.Position(line, char)))
             for expected in expected_refs:
                 self.assertIn(expected, references)
+
+    def test_py_type__definition(self) -> None:
+        """Test that the go to definition is correct for pythoon imports."""
+        lsp = JacLangServer()
+        workspace_path = self.fixture_abs_path("")
+        workspace = Workspace(workspace_path, lsp)
+        lsp.lsp._workspace = workspace
+        import_file = uris.from_fs_path(
+            self.fixture_abs_path(
+                "../../../../jaclang/compiler/passes/main/tests/fixtures/py_imp_test.jac"
+            )
+        )
+        lsp.deep_check(import_file)
+        positions = [
+            (19, 29, "pygame_mock/color.py:0:0-2:4"),
+            (3, 17, "/pygame_mock/__init__.py:0:0-0:0"),
+            (20, 45, "pygame_mock/color.py:0:0-2:4"),
+            (19, 77, "mock/constants.py:4:3-4:15"),
+            (26, 28, "mock/display.py:0:0-1:7"),
+            (24, 22, "/argparse.pyi:124:0-249:13"),
+            (19, 74, "pygame_mock/constants.py:4:3-4:15"),
+            (27, 17, "/stdlib/os/__init__.pyi:50:0-50:3"),
+        ]
+
+        for line, char, expected in positions:
+            with self.subTest(line=line, char=char):
+                self.assertIn(
+                    expected,
+                    str(lsp.get_definition(import_file, lspt.Position(line, char))),
+                )
+
+    def test_py_type__references(self) -> None:
+        """Test that the go to definition is correct for pythoon imports."""
+        lsp = JacLangServer()
+        workspace_path = self.fixture_abs_path("")
+        workspace = Workspace(workspace_path, lsp)
+        lsp.lsp._workspace = workspace
+
+        circle_file = uris.from_fs_path(
+            self.fixture_abs_path(
+                "../../../../jaclang/compiler/passes/main/tests/fixtures/py_imp_test.jac"
+            )
+        )
+        lsp.deep_check(circle_file)
+        test_cases = [
+            (
+                2,
+                21,
+                [
+                    ":6:21-6:32",
+                    ":7:11-7:22",
+                    ":11:25-11:36",
+                    ":12:15-12:26",
+                    ":18:33-18:44",
+                    "19:46-19:57",
+                    ":19:8-19:19",
+                    ":19:46-19:57",
+                    ":20:8-20:19",
+                    "21:8-21:19,",
+                    "23:8-23:19",
+                    ":26:4-26:15",
+                ],
+            ),
+            (
+                19,
+                63,
+                [
+                    "6:33-6:42",
+                    "7:23-7:32",
+                    "18:45-18:54",
+                    "19:58-19:67",
+                    "11:37-11:46",
+                    "12:27-12:36",
+                ],
+            ),
+            (
+                24,
+                53,
+                [
+                    "24:42-24:56",
+                    "24:16-24:30",
+                    "argparse.pyi:334:21-334:35",
+                    "argparse.pyi:163:29-163:43",
+                    "argparse.pyi:32:52-32:66",
+                ],
+            ),
+        ]
+        for line, char, expected_refs in test_cases:
+            references = str(lsp.get_references(circle_file, lspt.Position(line, char)))
+            for expected in expected_refs:
+                self.assertIn(expected, references)
+
+    def test_rename_symbol(self) -> None:
+        """Test that the rename is correct."""
+        lsp = JacLangServer()
+        workspace_path = self.fixture_abs_path("")
+        workspace = Workspace(workspace_path, lsp)
+        lsp.lsp._workspace = workspace
+
+        circle_file = uris.from_fs_path(self.fixture_abs_path("circle.jac"))
+        lsp.deep_check(circle_file)
+        test_cases = [
+            (
+                20,
+                14,
+                "ShapeKind",
+                "27:20-27:29,",
+                "36:19-36:28",
+                "75:26-75:35",
+                "20:5-20:14",
+            ),
+            (12, 34, "circleRadius", "12:21-12:27", "12:30-12:36", "11:19-11:25"),
+            (62, 14, "target_area", "65:43-65:56", "70:32-70:45", "62:5-62:18"),
+            (57, 33, "type_of_shape", "75:12-75:22", "27:8-27:18,", "57:23-57:33"),
+        ]
+        for tup in test_cases:
+            line, char, new_name, *expected_refs = tup
+            references = str(
+                lsp.rename_symbol(circle_file, lspt.Position(line, char), new_name)
+            )
+            for expected in expected_refs:
+                self.assertIn(expected, references)
+
+    def test_rename_uses(self) -> None:
+        """Test that the rename is correct."""
+        lsp = JacLangServer()
+        workspace_path = self.fixture_abs_path("")
+        workspace = Workspace(workspace_path, lsp)
+        lsp.lsp._workspace = workspace
+
+        circle_file = uris.from_fs_path(self.fixture_abs_path("rename.jac"))
+        lsp.deep_check(circle_file)
+        # fmt: off
+        test_cases = [
+            (0, 7, "func", "25:4-25:7", "0:4-0:7", "4:5-4:8",),
+            (4, 6, "func", "25:4-25:7", "0:4-0:7", "4:5-4:8",),
+            (25, 7, "func", "25:4-25:7", "0:4-0:7", "4:5-4:8",),
+            (10, 10, "canBar", "27:8-27:11", "10:8-10:11"),
+            (27, 9, "canBar", "27:8-27:11", "10:8-10:11"),
+            (9, 6, "canBar", "26:10-26:13", "28:4-28:7", "16:5-16:8", "9:4-9:7"),
+            (26, 11, "canBar", "26:10-26:13", "28:4-28:7", "16:5-16:8", "9:4-9:7"),
+            (16, 7, "canBar", "26:10-26:13", "28:4-28:7", "16:5-16:8", "9:4-9:7"),
+            (28, 6, "canBar", "26:10-26:13", "28:4-28:7", "16:5-16:8", "9:4-9:7"),
+            (11, 10, "canBar", "11:8-11:11", "16:13-16:16", "28:11-28:14"),
+            (16, 14, "canBar", "11:8-11:11", "16:13-16:16", "28:11-28:14"),
+            (28, 13, "canBar", "11:8-11:11", "16:13-16:16", "28:11-28:14"),
+            (12, 10, "canBaz", "12:8-12:11", "20:13-20:16"),
+            (20, 14, "canBaz", "12:8-12:11", "20:13-20:16"),
+            (26, 6, "count", "27:4-27:7", "26:4-26:7"),
+            (27, 5, "count", "27:4-27:7", "26:4-26:7"),
+        ]
+        # fmt: on
+        for tup in test_cases:
+            line, char, new_name, *expected_refs = tup
+            references = str(
+                lsp.rename_symbol(circle_file, lspt.Position(line, char), new_name)
+            )
+            for expected in expected_refs:
+                self.assertIn(expected, references)