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

jaclang/compiler/passes/main/tests/fixtures/mod_type_assign.jac

@@ -0,0 +1,7 @@
+import:jac blip;
+
+
+with entry{
+    kl = blip;
+    l1 = l2 = blip;
+}

jaclang/compiler/passes/main/tests/fixtures/pygame_mock/__init__.pyi

@@ -0,0 +1,3 @@
+from .display import *
+from .color import *
+from .constants import *

jaclang/compiler/passes/main/tests/test_import_pass.py

@@ -70,19 +70,19 @@ class ImportPassPassTests(TestCase):
         )
         assert isinstance(build.ir, ast.Module)
         p = {
-            "math": "jaclang/jaclang/vendor/mypy/typeshed/stdlib/math.pyi",
-            "pygame_mock": "pygame_mock/__init__.py",
-            "pygame_mock.color": "pygame_mock/color.py",
-            "pygame_mock.constants": "pygame_mock/constants.py",
-            "argparse": "jaclang/vendor/mypy/typeshed/stdlib/argparse.pyi",
-            "builtins": "jaclang/vendor/mypy/typeshed/stdlib/builtins.pyi",
-            "pygame_mock.display": "pygame_mock/display.py",
-            "os": "jaclang/vendor/mypy/typeshed/stdlib/os/__init__.pyi",
-            "genericpath": "jaclang/vendor/mypy/typeshed/stdlib/genericpath.pyi",
+            "math": r"jaclang/vendor/mypy/typeshed/stdlib/math.pyi$",
+            "pygame_mock": r"pygame_mock/__init__.pyi$",
+            "pygame_mock.color": r"pygame_mock/color.py$",
+            "pygame_mock.constants": r"pygame_mock/constants.py$",
+            "argparse": r"jaclang/vendor/mypy/typeshed/stdlib/argparse.pyi$",
+            "builtins": r"jaclang/vendor/mypy/typeshed/stdlib/builtins.pyi$",
+            "pygame_mock.display": r"pygame_mock/display.py$",
+            "os": r"jaclang/vendor/mypy/typeshed/stdlib/os/__init__.pyi$",
+            "genericpath": r"jaclang/vendor/mypy/typeshed/stdlib/genericpath.pyi$",
         }
         for i in p:
             self.assertIn(i, build.ir.py_raise_map)
-            self.assertIn(p[i], re.sub(r".*fixtures/", "", build.ir.py_raise_map[i]))
+            self.assertRegex(re.sub(r".*fixtures/", "", build.ir.py_raise_map[i]), p[i])
 
     def test_py_raised_mods(self) -> None:
         """Basic test for pass."""

jaclang/compiler/passes/main/tests/test_type_check_pass.py

@@ -59,6 +59,6 @@ class MypyTypeCheckPassTests(TestCase):
         self.assertIn("HasVar - species - Type: builtins.str", out)
         self.assertIn("myDog - Type: type_info.Dog", out)
         self.assertIn("Body - Type: type_info.Dog.Body", out)
-        self.assertEqual(out.count("Type: builtins.str"), 28)
+        self.assertEqual(out.count("Type: builtins.str"), 34)
         for i in lis:
             self.assertNotIn(i, out)

jaclang/compiler/passes/main/tests/test_typeinfo_pass.py

@@ -1,7 +1,29 @@
 """Test pass module."""
 
+from jaclang.compiler.compile import jac_file_to_pass
+from jaclang.compiler.passes.main.fuse_typeinfo_pass import FuseTypeInfoPass
+from jaclang.compiler.passes.main.schedules import py_code_gen_typed
 from jaclang.utils.test import TestCase
 
 
 class TestFuseTypeInfo(TestCase):
-    """Test pass module."""
+    """Test FuseTypeInfoPass module."""
+
+    def setUp(self) -> None:
+        """Set up test."""
+        return super().setUp()
+
+    def test_mod_type_assign(self) -> None:
+        """Test module type assignment."""
+        gen_ast = jac_file_to_pass(
+            self.fixture_abs_path("mod_type_assign.jac"),
+            FuseTypeInfoPass,
+            schedule=py_code_gen_typed,
+        ).ir.pp()
+        type_info_list = [
+            "kl - Type: types.ModuleType,  SymbolTable: blip",
+            "l1 - Type: types.ModuleType,  SymbolTable: blip",
+            "l2 - Type: types.ModuleType,  SymbolTable: blip",
+        ]
+        for type_info in type_info_list:
+            self.assertIn(type_info, str(gen_ast))

jaclang/compiler/passes/main/type_check_pass.py

@@ -51,10 +51,10 @@ class JacTypeCheckPass(Pass):
         options.ignore_missing_imports = True
         options.cache_dir = Con.JAC_MYPY_CACHE
         options.mypy_path = [
-            str(
-                pathlib.Path(os.path.dirname(__file__)).parent.parent.parent.parent
-                / "stubs"
-            )
+            # str( # TODO: Remove me, this was the wrong way to point to stubs
+            #     pathlib.Path(os.path.dirname(__file__)).parent.parent.parent.parent
+            #     / "stubs"
+            # )
         ]
         if top_module_path != "":
             options.mypy_path.append(top_module_path)

jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -126,11 +126,14 @@ class JacFormatPass(Pass):
         last_element = None
         for counter, i in enumerate(node.body):
             counter += 1
+            if last_element and (
+                i.loc.first_line - last_element.loc.last_line > 1
+                and not last_element.gen.jac.endswith("\n\n")
+            ):
+                self.emit_ln(node, "")
             if isinstance(i, ast.Import):
                 self.emit_ln(node, i.gen.jac)
             else:
-                if isinstance(last_element, ast.Import):
-                    self.emit_ln(node, "")
                 if last_element and (
                     isinstance(i, ast.Architype)
                     and isinstance(last_element, ast.Architype)
@@ -140,21 +143,6 @@ class JacFormatPass(Pass):
                     self.emit_ln(node, "")
                 self.emit_ln(node, i.gen.jac)
 
-                if counter <= len(node.body) - 1:
-                    if (
-                        isinstance(i, ast.Ability)
-                        and isinstance(node.body[counter], ast.Ability)
-                        and i.gen.jac.endswith(";")
-                        or (
-                            isinstance(i, ast.Architype)
-                            and len(node.body[counter].kid[-1].kid) == 2
-                            and len(node.body[counter - 1].kid[-1].kid) == 2
-                        )
-                        and node.gen.jac.endswith("\n")
-                    ):
-                        self.emit(node, "")
-                    else:
-                        self.emit_ln(node, "")
             last_element = i
 
     def exit_global_vars(self, node: ast.GlobalVars) -> None:
@@ -222,6 +210,20 @@ class JacFormatPass(Pass):
         """
         prev_token = None
         for stmt in node.kid:
+            line_emiited = False
+            if prev_token and stmt.loc.first_line - prev_token.loc.last_line > 1:
+                if (
+                    stmt.kid
+                    and isinstance(stmt.kid[-1], ast.SubNodeList)
+                    and not isinstance(stmt.kid[-1].kid[-1], ast.CommentToken)
+                ):
+                    self.emit(node, "")
+
+                else:
+                    line_emiited = True
+                    self.indent_level -= 1
+                    self.emit_ln(node, "")
+                    self.indent_level += 1
             if isinstance(node.parent, (ast.EnumDef, ast.Enum)) and stmt.gen.jac == ",":
                 self.indent_level -= 1
                 self.emit_ln(node, f"{stmt.gen.jac}")
@@ -266,9 +268,10 @@ class JacFormatPass(Pass):
                             self.indent_level += 1
                         else:
                             self.emit(node, f" {stmt.gen.jac}")
-                        self.indent_level -= 1
-                        self.emit_ln(node, "")
-                        self.indent_level += 1
+                        if not line_emiited:
+                            self.indent_level -= 1
+                            self.emit_ln(node, "")
+                            self.indent_level += 1
                     else:
                         if not node.gen.jac.endswith("\n"):
                             self.indent_level -= 1
@@ -279,12 +282,21 @@ class JacFormatPass(Pass):
                         if prev_token and isinstance(prev_token, ast.Ability):
                             self.emit(node, f"{stmt.gen.jac}")
                         else:
-                            self.emit(node, stmt.gen.jac)
-                            if not stmt.gen.jac.endswith("postinit;"):
+                            token_before = self.token_before(stmt)
+                            if (
+                                token_before is not None
+                                and isinstance(token_before, ast.Token)
+                                and token_before.name == Tok.LBRACE
+                                and stmt.loc.first_line - token_before.loc.last_line > 1
+                            ):
                                 self.indent_level -= 1
-                                self.emit_ln(stmt, "")
                                 self.emit_ln(node, "")
                                 self.indent_level += 1
+                            self.emit(node, stmt.gen.jac)
+                            self.indent_level -= 1
+                            self.emit_ln(stmt, "")
+                            self.emit_ln(node, "")
+                            self.indent_level += 1
                 elif stmt.gen.jac == ",":
                     self.emit(node, f"{stmt.value} ")
                 elif stmt.value == "=":
@@ -304,10 +316,29 @@ class JacFormatPass(Pass):
                 isinstance(prev_token, ast.Ability)
                 and isinstance(stmt, (ast.Ability, ast.AbilityDef))
             ):
-                if not isinstance(prev_token.kid[-1], ast.CommentToken):
-                    self.indent_level -= 1
-                    self.emit_ln(node, "")
-                    self.indent_level += 1
+                if (
+                    not isinstance(prev_token.kid[-1], ast.CommentToken)
+                    and not line_emiited
+                ):
+                    if (
+                        prev_token.kid
+                        and isinstance(prev_token.kid[-1], ast.SubNodeList)
+                        and isinstance(prev_token.kid[-1].kid[-1], ast.CommentToken)
+                    ):
+                        if (
+                            prev_token
+                            and stmt.loc.first_line - prev_token.kid[-1].kid[-1].line_no
+                            > 1
+                        ):
+                            self.indent_level -= 1
+                            self.emit_ln(node, "")
+                            self.indent_level += 1
+                        else:
+                            self.emit(node, "")
+                    else:
+                        self.indent_level -= 1
+                        self.emit_ln(node, "")
+                        self.indent_level += 1
                 self.emit(node, stmt.gen.jac)
             else:
                 if prev_token and prev_token.gen.jac.strip() == "{":
@@ -373,7 +404,9 @@ class JacFormatPass(Pass):
                     indented = True
                 for count, j in enumerate(i.kid):
                     if j.gen.jac == ",":
-                        if i.kid[count + 1].gen.jac.startswith("#"):
+                        if len(i.kid) > count + 1 and i.kid[
+                            count + 1
+                        ].gen.jac.startswith("#"):
                             self.indent_level -= 1
                             self.emit(node, f"{j.gen.jac} ")
                             self.indent_level += 1
@@ -907,8 +940,6 @@ class JacFormatPass(Pass):
         """Check if the length of the current generated code exceeds the max line length."""
         if max_line_length == 0:
             max_line_length = self.MAX_LINE_LENGTH
-        # print(content)
-        # print(len(content))
         return len(content) > max_line_length
 
     def exit_binary_expr(self, node: ast.BinaryExpr) -> None:
@@ -958,7 +989,6 @@ class JacFormatPass(Pass):
                 self.error(
                     f"Binary operator {node.op.value} not supported in bootstrap Jac"
                 )
-        # print(node.gen)
         if isinstance(
             node.kid[-1], (ast.Semi, ast.CommentToken)
         ) and not node.gen.jac.endswith("\n"):

jaclang/compiler/passes/tool/tests/fixtures/general_format_checks/line_spacing.jac

@@ -0,0 +1,57 @@
+import:py math;
+
+glob RAD = 5;
+
+glob DIA = 10;
+
+# this comment is for walker
+
+walker decorator_walk {
+    can hash(func: Any) {
+        can inner(a: Any) {
+            print(("#" * 20));
+            func(a);
+            print(("#" * 20));
+        }
+        return inner;
+    }
+
+    can exclaim(func: Any) {
+        can inner(b: Any) {
+            print(("!" * 20));
+            func(b);
+            print(("!" * 20));
+        }
+        return inner;
+    }
+
+    can tilde(func: Any) {
+        can inner(c: Any) {
+            print(("~" * 20));
+            func(c);
+            print(("~" * 20));
+        }
+        return inner;
+    }
+
+    can greeter(name: Any) {
+        print("Hello, " + name + "!");
+    }
+
+    # Entry point for the walker
+
+    can start with entry {
+
+        # Apply decorators to greeter
+        decorated_greeter = hash(exclaim(tilde(greeter)));
+
+        # Call the decorated greeter function
+        decorated_greeter("World");
+
+        # this is another comment
+    }
+}
+
+with entry {
+    root spawn decorator_walk();
+}

jaclang/compiler/semtable.py

@@ -19,13 +19,13 @@ class SemInfo:
         self,
         node: ast.AstNode,
         name: str,
-        type: Optional[str] = None,
+        type_str: Optional[str] = None,
         semstr: str = "",
     ) -> None:
         """Initialize the class."""
-        self.node = node
+        self.node_type = type(node)
         self.name = name
-        self.type = type
+        self.type = type_str
         self.semstr = semstr
 
     def __repr__(self) -> str:
@@ -40,7 +40,7 @@ class SemInfo:
         self_scope = str(scope) + f".{self.name}({self.type})"
         _, children = sem_registry.lookup(scope=SemScope.get_scope_from_str(self_scope))
         if filter and children and isinstance(children, list):
-            return [i for i in children if isinstance(i.node, filter)]
+            return [i for i in children if i.node_type == filter]
         return children if children and isinstance(children, list) else []
 
 

jaclang/compiler/symtable.py

@@ -54,6 +54,11 @@ class Symbol:
         out.reverse()
         return ".".join(out)
 
+    @property
+    def fetch_sym_tab(self) -> Optional[SymbolTable]:
+        """Get symbol table."""
+        return self.parent_tab.find_scope(self.sym_name)
+
     def add_defn(self, node: ast.NameAtom) -> None:
         """Add defn."""
         self.defn.append(node)

jaclang/langserve/engine.py

@@ -25,7 +25,6 @@ from jaclang.langserve.utils import (
     get_location_range,
     get_symbols_for_outline,
     parse_symbol_path,
-    resolve_completion_symbol_table,
 )
 from jaclang.vendor.pygls import uris
 from jaclang.vendor.pygls.server import LanguageServer
@@ -188,14 +187,73 @@ class JacLangServer(LanguageServer):
             if not node_selected
             else node_selected.sym_tab
         )
-        current_tab = self.modules[file_path].ir._sym_tab
         current_symbol_table = mod_tab
 
         if completion_trigger == ".":
             if current_symbol_path:
-                completion_items = resolve_completion_symbol_table(
-                    mod_tab, current_symbol_path, current_tab
-                )
+                temp_tab = mod_tab
+                for symbol in current_symbol_path:
+                    if symbol == "self":
+                        is_ability_def = (
+                            temp_tab.owner
+                            if isinstance(temp_tab.owner, ast.AbilityDef)
+                            else temp_tab.owner.find_parent_of_type(ast.AbilityDef)
+                        )
+                        if not is_ability_def:
+                            archi_owner = mod_tab.owner.find_parent_of_type(
+                                ast.Architype
+                            )
+                            temp_tab = (
+                                archi_owner._sym_tab
+                                if archi_owner and archi_owner._sym_tab
+                                else mod_tab
+                            )
+                            continue
+                        else:
+                            archi_owner = (
+                                (
+                                    is_ability_def.decl_link.find_parent_of_type(
+                                        ast.Architype
+                                    )
+                                )
+                                if is_ability_def.decl_link
+                                else None
+                            )
+                            temp_tab = (
+                                archi_owner.sym_tab
+                                if archi_owner and archi_owner.sym_tab
+                                else temp_tab
+                            )
+                            continue
+                    symb = temp_tab.lookup(symbol)
+                    if symb:
+                        fetc_tab = symb.fetch_sym_tab
+                        if fetc_tab:
+                            temp_tab = fetc_tab
+                        else:
+                            temp_tab = (
+                                symb.defn[0].type_sym_tab
+                                if symb.defn[0].type_sym_tab
+                                else temp_tab
+                            )
+                    else:
+                        break
+                completion_items = collect_all_symbols_in_scope(temp_tab, up_tree=False)
+                if (
+                    isinstance(temp_tab.owner, ast.Architype)
+                    and temp_tab.owner.base_classes
+                ):
+                    base = []
+                    for base_name in temp_tab.owner.base_classes.items:
+                        if isinstance(base_name, ast.Name) and base_name.sym:
+                            base.append(base_name.sym)
+                    for base_class_symbol in base:
+                        if base_class_symbol.fetch_sym_tab:
+                            completion_items += collect_all_symbols_in_scope(
+                                base_class_symbol.fetch_sym_tab,
+                                up_tree=False,
+                            )
+
             else:
                 completion_items = []
         else:
@@ -349,7 +407,10 @@ class JacLangServer(LanguageServer):
             elif node_selected.parent and isinstance(
                 node_selected.parent, ast.ModuleItem
             ):
-                path = node_selected.parent.from_mod_path.abs_path
+                path = (
+                    node_selected.parent.abs_path
+                    or 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
@@ -371,7 +432,7 @@ class JacLangServer(LanguageServer):
                             ),
                         ),
                     )
-            elif isinstance(node_selected, (ast.ElementStmt, ast.BuiltinType)):
+            elif isinstance(node_selected, ast.ElementStmt):
                 return None
             decl_node = (
                 node_selected.parent.body.target

jaclang/langserve/tests/test_server.py

@@ -218,9 +218,9 @@ class TestJacLangServer(TestCase):
         )
         lsp.deep_check(import_file)
         positions = [
-            (6, 39, "/pygame_mock/__init__.py:2:0-2:0"),
+            (6, 39, "/pygame_mock/__init__.pyi: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, 31, "/pygame_mock/__init__.pyi: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"),
@@ -282,7 +282,7 @@ class TestJacLangServer(TestCase):
             ),
             (
                 "<JacSemTokenType.FUNCTION: 12>, <JacSemTokenModifier.DECLARATION: 1>,",
-                6,
+                8,
             ),
             ("<JacSemTokenType.METHOD: 13>, <JacSemTokenModifier.DECLARATION: 1>", 6),
             ("<JacSemTokenType.ENUM: 3>, <JacSemTokenModifier.DECLARATION: 1>,", 4),

jaclang/langserve/utils.py

@@ -332,119 +332,6 @@ def parse_symbol_path(text: str, dot_position: int) -> list[str]:
     return all_words
 
 
-def resolve_symbol_path(sym_name: str, node_tab: SymbolTable) -> str:
-    """Resolve symbol path."""
-    visited = set()
-    current_tab: Optional[SymbolTable] = node_tab
-
-    while current_tab is not None and current_tab not in visited:
-        visited.add(current_tab)
-        for name, symbol in current_tab.tab.items():
-            if name not in dir(builtins) and name == sym_name:
-                path = symbol.defn[0]._sym_type
-                if symbol.sym_type == SymbolType.ENUM_ARCH:
-                    if isinstance(current_tab.owner, ast.Module):
-                        return current_tab.owner.name + "." + sym_name
-                    elif isinstance(current_tab.owner, ast.AstSymbolNode):
-                        return current_tab.owner.name_spec._sym_type + "." + sym_name
-                return path
-        current_tab = current_tab.parent if current_tab.parent != current_tab else None
-    return ""
-
-
-def find_symbol_table(path: str, current_tab: Optional[SymbolTable]) -> SymbolTable:
-    """Find symbol table."""
-    path = path.lstrip(".")
-    current_table = current_tab
-    if current_table:
-        for segment in path.split("."):
-            current_table = next(
-                (
-                    child_table
-                    for child_table in current_table.kid
-                    if child_table.name == segment
-                ),
-                current_table,
-            )
-    if current_table:
-        return current_table
-    raise ValueError(f"Symbol table not found for path {path}")
-
-
-def resolve_completion_symbol_table(
-    mod_tab: SymbolTable,
-    current_symbol_path: list[str],
-    current_tab: Optional[SymbolTable],
-) -> list[lspt.CompletionItem]:
-    """Resolve symbol table for completion items."""
-    current_symbol_table = mod_tab
-    for obj in current_symbol_path:
-        if obj == "self":
-            try:
-                try:
-                    is_abilitydef = (
-                        mod_tab.owner
-                        if isinstance(mod_tab.owner, ast.AbilityDef)
-                        else mod_tab.owner.parent_of_type(ast.AbilityDef)
-                    )
-                    archi_owner = (
-                        (is_abilitydef.decl_link.parent_of_type(ast.Architype))
-                        if is_abilitydef.decl_link
-                        else None
-                    )
-                    current_symbol_table = (
-                        archi_owner._sym_tab
-                        if archi_owner and archi_owner._sym_tab
-                        else mod_tab
-                    )
-                    continue
-
-                except ValueError:
-                    pass
-                archi_owner = mod_tab.owner.parent_of_type(ast.Architype)
-                current_symbol_table = (
-                    archi_owner._sym_tab
-                    if archi_owner and archi_owner._sym_tab
-                    else mod_tab
-                )
-            except ValueError:
-                pass
-        else:
-            path: str = resolve_symbol_path(obj, current_symbol_table)
-            if path:
-                current_symbol_table = find_symbol_table(path, current_tab)
-            else:
-                if (
-                    isinstance(current_symbol_table.owner, ast.Architype)
-                    and current_symbol_table.owner.base_classes
-                ):
-                    for base_name in current_symbol_table.owner.base_classes.items:
-                        if isinstance(base_name, ast.Name) and base_name.sym:
-                            path = base_name.sym.sym_dotted_name + "." + obj
-                            current_symbol_table = find_symbol_table(path, current_tab)
-    if (
-        isinstance(current_symbol_table.owner, ast.Architype)
-        and current_symbol_table.owner.base_classes
-    ):
-        base = []
-        for base_name in current_symbol_table.owner.base_classes.items:
-            if isinstance(base_name, ast.Name) and base_name.sym:
-                base.append(base_name.sym.sym_dotted_name)
-        for base_ in base:
-            completion_items = collect_all_symbols_in_scope(
-                find_symbol_table(base_, current_tab),
-                up_tree=False,
-            )
-    else:
-        completion_items = []
-    if isinstance(current_symbol_table.owner, (ast.Ability, ast.AbilityDef)):
-        return completion_items
-    completion_items.extend(
-        collect_all_symbols_in_scope(current_symbol_table, up_tree=False)
-    )
-    return completion_items
-
-
 def get_token_start(
     token_index: int | None, sem_tokens: list[int]
 ) -> tuple[int, int, int]:

jaclang/plugin/tests/test_jaseci.py

@@ -337,8 +337,8 @@ class TestJaseciPlugin(TestCase):
 
         # --------- NO UPDATE SHOULD HAPPEN -------- #
 
-        self.assertTrue(archs[0], "A(val=2)")
-        self.assertTrue(archs[1], "A(val=1)")
+        self.assertEqual(archs[0], "A(val=2)")
+        self.assertEqual(archs[1], "A(val=1)")
 
         self._output2buffer()
         cli.enter(
@@ -435,8 +435,8 @@ class TestJaseciPlugin(TestCase):
 
         # --------- UPDATE SHOULD HAPPEN -------- #
 
-        self.assertTrue(archs[0], "A(val=20)")
-        self.assertTrue(archs[1], "A(val=10)")
+        self.assertEqual(archs[0], "A(val=20)")
+        self.assertEqual(archs[1], "A(val=10)")
 
         self._output2buffer()
         cli.enter(
@@ -474,6 +474,25 @@ class TestJaseciPlugin(TestCase):
         )
         self.assertFalse(self.capturedOutput.getvalue().strip())
 
+        # --------- ROOTS RESET OWN NODE -------- #
+
+        cli.enter(
+            filename=self.fixture_abs_path("other_root_access.jac"),
+            entrypoint="update_node",
+            args=[1],
+            session=session,
+            root=self.roots[0],
+            node=self.nodes[0],
+        )
+        cli.enter(
+            filename=self.fixture_abs_path("other_root_access.jac"),
+            entrypoint="update_node",
+            args=[2],
+            session=session,
+            root=self.roots[1],
+            node=self.nodes[1],
+        )
+
     def test_other_root_access(self) -> None:
         """Test filtering on node, then visit."""
         global session