jaclang 0.7.33__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/compiler/passes/main/py_collect_dep_pass.py

@@ -1,78 +0,0 @@
-"""Collect Python dependencies based on reference sourced from Jac.
-
-This pass will use mypy to calculate the python package/module dependencies
-that are only relevant to actual references source from Jac code.
-"""
-
-from __future__ import annotations
-
-
-import os
-
-import jaclang.compiler.absyntree as ast
-from jaclang.compiler.passes import Pass
-from jaclang.settings import settings
-
-import mypy.nodes as MypyNodes  # noqa N812
-
-
-class PyCollectDepsPass(Pass):
-    """Python and bytecode file self.__debug_printing pass."""
-
-    def __debug_print(self, msg: str) -> None:
-        if settings.collect_py_dep_debug:
-            self.log_info("CollectPythonDependencies::" + msg)
-
-    def enter_node(self, node: ast.AstNode) -> None:
-        """Collect python dependencies from all Jac Nodes."""
-        assert isinstance(self.ir, ast.Module)
-
-        if not isinstance(node, ast.AstSymbolNode):
-            return
-
-        # Adding the path of the file related to the py import
-        path: str = ""
-        if isinstance(node, ast.ModulePath):
-            if node.path:
-                path = ".".join([i.value for i in node.path])
-            node.abs_path = self.ir.py_info.py_mod_dep_map.get(path)
-            if node.abs_path and os.path.isfile(node.abs_path.replace(".pyi", ".py")):
-                node.abs_path = node.abs_path.replace(".pyi", ".py")
-
-        elif isinstance(node, ast.ModuleItem):
-            imp = node.parent_of_type(ast.Import)
-            mod_path_node = imp.get_all_sub_nodes(ast.ModulePath)[0]
-            if mod_path_node.path:
-                path = ".".join([i.value for i in mod_path_node.path])
-            path += f".{node.name.value}"
-            node.abs_path = self.ir.py_info.py_mod_dep_map.get(path)
-            if node.abs_path and os.path.isfile(node.abs_path.replace(".pyi", ".py")):
-                node.abs_path = node.abs_path.replace(".pyi", ".py")
-
-        if len(node.gen.mypy_ast) == 0:
-            return
-
-        mypy_node = node.gen.mypy_ast[0]
-
-        if isinstance(mypy_node, MypyNodes.RefExpr) and mypy_node.node:
-            node_full_name = mypy_node.node.fullname
-            if "." in node_full_name:
-                mod_name = node_full_name[: node_full_name.rindex(".")]
-            else:
-                mod_name = node_full_name
-
-            if mod_name not in self.ir.py_info.py_mod_dep_map:
-                self.__debug_print(
-                    f"Can't find a python file associated with {type(node)}::{node.loc}"
-                )
-                return
-
-            mode_path = self.ir.py_info.py_mod_dep_map[mod_name]
-            if mode_path.endswith(".jac"):
-                return
-
-            self.ir.py_info.py_raise_map[mod_name] = mode_path
-        else:
-            self.__debug_print(
-                f"Collect python dependencies is not supported in {type(node)}::{node.loc}"
-            )

jaclang/compiler/passes/main/pyout_pass.py

@@ -1,86 +0,0 @@
-"""Connect Decls and Defs in AST.
-
-This pass creates and manages compilation of Python code from the AST. This pass
-also creates bytecode files from the Python code, and manages the caching of
-relevant files.
-"""
-
-import os
-
-
-import jaclang.compiler.absyntree as ast
-from jaclang.compiler.constant import Constants as Con
-from jaclang.compiler.passes import Pass
-
-
-class PyOutPass(Pass):
-    """Python and bytecode file printing pass."""
-
-    def before_pass(self) -> None:
-        """Before pass."""
-        return super().before_pass()
-
-    def enter_module(self, node: ast.Module) -> None:
-        """Sub objects.
-
-        name: str,
-        doc: Token,
-        body: Optional['Elements'],
-        mod_path: str,
-        is_imported: bool,
-        sym_tab: Optional[SymbolTable],
-        """
-        if not (os.path.exists(node.loc.mod_path) and node.gen.py_ast):
-            self.error(
-                f"Unable to find module {node.loc.mod_path} or no code present.", node
-            )
-            return
-        mods = [node] + [
-            i for i in self.get_all_sub_nodes(node, ast.Module) if not i.stub_only
-        ]
-        for mod in mods:
-            mod_path, out_path_py, out_path_pyc = self.get_output_targets(mod)
-            if os.path.exists(out_path_pyc) and os.path.getmtime(
-                out_path_pyc
-            ) > os.path.getmtime(mod_path):
-                continue
-            try:
-                self.gen_python(mod, out_path=out_path_py)
-                self.dump_bytecode(mod, mod_path=mod_path, out_path=out_path_pyc)
-            except Exception as e:
-                self.warning(f"Error in generating Python code: {e}", node)
-        self.terminate()
-
-    def gen_python(self, node: ast.Module, out_path: str) -> None:
-        """Generate Python."""
-        with open(out_path, "w") as f:
-            f.write(node.gen.py)
-
-    def dump_bytecode(self, node: ast.Module, mod_path: str, out_path: str) -> None:
-        """Generate Python."""
-        if node.gen.py_bytecode:
-            with open(out_path, "wb") as f:
-                f.write(node.gen.py_bytecode)
-        else:
-            self.error(
-                f"Soemthing went wrong with {node.loc.mod_path} compilation.", node
-            )
-
-    def get_output_targets(self, node: ast.Module) -> tuple[str, str, str]:
-        """Get output targets."""
-        base_path, file_name = os.path.split(node.loc.mod_path)
-        gen_path = os.path.join(base_path, Con.JAC_GEN_DIR)
-        mod_dir, file_name = os.path.split(node.loc.mod_path)
-        mod_dir = mod_dir.replace(base_path, "").lstrip(os.sep)
-        base_name, _ = os.path.splitext(file_name)
-        out_dir = os.path.join(gen_path, mod_dir)
-        try:
-            os.makedirs(gen_path, exist_ok=True)
-            with open(os.path.join(gen_path, "__init__.py"), "w"):
-                pass
-            os.makedirs(out_dir, exist_ok=True)
-        except Exception as e:
-            self.warning(f"Can't create directory {out_dir}: {e}", node)
-        out_path_py = os.path.join(out_dir, f"{base_name}.py")
-        out_path_pyc = os.path.join(out_dir, f"{base_name}.jbc")
-        return node.loc.mod_path, out_path_py, out_path_pyc

jaclang/compiler/passes/main/registry_pass.py

@@ -1,156 +0,0 @@
-"""Jac Registry Pass.
-
-This pass is responsible for creating object containing the senstring, scope,
-type of different important nodes in the AST as we loose access to the
-semstrings after PyASTGen pass. So we create those as a pickled file for
-each module
-"""
-
-import jaclang.compiler.absyntree as ast
-from jaclang.compiler.passes import Pass
-from jaclang.compiler.semtable import SemInfo, SemRegistry
-from jaclang.runtimelib.utils import get_sem_scope
-from jaclang.settings import settings
-
-
-class RegistryPass(Pass):
-    """Creates a registry for each module."""
-
-    modules_visited: list[ast.Module] = []
-
-    def enter_module(self, node: ast.Module) -> None:
-        """Create registry for each module."""
-        if settings.disable_mtllm:
-            self.terminate()
-            return None
-        node.registry = SemRegistry()
-        self.modules_visited.append(node)
-
-    def exit_module(self, node: ast.Module) -> None:
-        """Save registry for each module."""
-        module_name = node.name
-        try:
-            from jaclang.runtimelib.machine import JacMachine
-
-            JacMachine.get().get_sem_ir(node.registry)
-        except Exception as e:
-            self.warning(f"Can't save registry for {module_name}: {e}")
-        self.modules_visited.pop()
-
-    def exit_architype(self, node: ast.Architype) -> None:
-        """Save architype information."""
-        scope = get_sem_scope(node)
-        seminfo = SemInfo(
-            node,
-            node.name.value,
-            node.arch_type.value,
-            node.semstr.lit_value if node.semstr else "",
-        )
-        if (
-            len(self.modules_visited)
-            and self.modules_visited[-1].registry
-            and scope.parent
-        ):
-            self.modules_visited[-1].registry.add(scope.parent, seminfo)
-
-    def exit_enum(self, node: ast.Enum) -> None:
-        """Save enum information."""
-        scope = get_sem_scope(node)
-        seminfo = SemInfo(
-            node, node.name.value, "Enum", node.semstr.lit_value if node.semstr else ""
-        )
-        if (
-            len(self.modules_visited)
-            and self.modules_visited[-1].registry
-            and scope.parent
-        ):
-            self.modules_visited[-1].registry.add(scope.parent, seminfo)
-
-    def exit_has_var(self, node: ast.HasVar) -> None:
-        """Save variable information."""
-        extracted_type = (
-            "".join(self.extract_type(node.type_tag.tag)) if node.type_tag else None
-        )
-        scope = get_sem_scope(node)
-        seminfo = SemInfo(
-            node,
-            node.name.value,
-            extracted_type,
-            node.semstr.lit_value if node.semstr else "",
-        )
-        if len(self.modules_visited) and self.modules_visited[-1].registry:
-            self.modules_visited[-1].registry.add(scope, seminfo)
-
-    def exit_ability(self, node: ast.Ability) -> None:
-        """Save ability information."""
-        scope = get_sem_scope(node)
-        seminfo = SemInfo(
-            node,
-            node.name_ref.sym_name,
-            "Ability",
-            node.semstr.lit_value if node.semstr else "",
-        )
-        if len(self.modules_visited) and self.modules_visited[-1].registry:
-            (
-                self.modules_visited[-1].registry.add(scope.parent, seminfo)
-                if scope.parent
-                else None
-            )
-
-    def exit_param_var(self, node: ast.ParamVar) -> None:
-        """Save param information."""
-        scope = get_sem_scope(node)
-        extracted_type = (
-            "".join(self.extract_type(node.type_tag.tag)) if node.type_tag else None
-        )
-        seminfo = SemInfo(
-            node,
-            node.name.value,
-            extracted_type,
-            node.semstr.lit_value if node.semstr else "",
-        )
-        if len(self.modules_visited) and self.modules_visited[-1].registry:
-            self.modules_visited[-1].registry.add(scope, seminfo)
-
-    def exit_assignment(self, node: ast.Assignment) -> None:
-        """Save assignment information."""
-        if node.aug_op:
-            return
-
-        extracted_type = (
-            "".join(self.extract_type(node.type_tag.tag)) if node.type_tag else None
-        )
-        scope = get_sem_scope(node)
-        seminfo = SemInfo(
-            node,
-            (
-                node.target.items[0].value
-                if isinstance(node.target.items[0], ast.Name)
-                else ""
-            ),
-            extracted_type,
-            node.semstr.lit_value if node.semstr else "",
-        )
-        if len(self.modules_visited) and self.modules_visited[-1].registry:
-            self.modules_visited[-1].registry.add(scope, seminfo)
-
-    def exit_name(self, node: ast.Name) -> None:
-        """Save name information. for enum stmts."""
-        if (
-            node.parent
-            and node.parent.parent
-            and node.parent.parent.__class__.__name__ == "Enum"
-        ):
-            scope = get_sem_scope(node)
-            seminfo = SemInfo(node, node.value, None, "")
-            if len(self.modules_visited) and self.modules_visited[-1].registry:
-                self.modules_visited[-1].registry.add(scope, seminfo)
-
-    def extract_type(self, node: ast.AstNode) -> list[str]:
-        """Collect type information in assignment using bfs."""
-        extracted_type = []
-        if isinstance(node, (ast.BuiltinType, ast.Token)):
-            extracted_type.append(node.value)
-        for child in node.kid:
-            extracted_type.extend(self.extract_type(child))
-        return extracted_type

jaclang/compiler/passes/main/schedules.py

@@ -1,47 +0,0 @@
-"""Pass schedules.
-
-These are various pass schedules for the Jac compiler and static analysis.
-"""
-
-from __future__ import annotations
-
-
-from .sub_node_tab_pass import SubNodeTabPass  # noqa: I100
-from .import_pass import JacImportPass, PyImportPass  # noqa: I100
-from .sym_tab_build_pass import SymTabBuildPass  # noqa: I100
-from .def_impl_match_pass import DeclImplMatchPass  # noqa: I100
-from .def_use_pass import DefUsePass  # noqa: I100
-from .pyout_pass import PyOutPass  # noqa: I100
-from .pybc_gen_pass import PyBytecodeGenPass  # noqa: I100
-from .pyast_gen_pass import PyastGenPass  # noqa: I100
-from .pyjac_ast_link_pass import PyJacAstLinkPass  # noqa: I100
-from .type_check_pass import JacTypeCheckPass  # noqa: I100
-from .fuse_typeinfo_pass import FuseTypeInfoPass  # noqa: I100
-from .registry_pass import RegistryPass  # noqa: I100
-from .access_modifier_pass import AccessCheckPass  # noqa: I100
-from .py_collect_dep_pass import PyCollectDepsPass  # noqa: I100
-from .inheritance_pass import InheritancePass  # noqa: I100
-
-py_code_gen = [
-    SubNodeTabPass,
-    JacImportPass,
-    SymTabBuildPass,
-    DeclImplMatchPass,
-    DefUsePass,
-    RegistryPass,
-    PyastGenPass,
-    PyJacAstLinkPass,
-    PyBytecodeGenPass,
-]
-
-type_checker_sched = [
-    JacTypeCheckPass,
-    PyCollectDepsPass,
-    PyImportPass,
-    DefUsePass,
-    InheritancePass,
-    FuseTypeInfoPass,
-    AccessCheckPass,
-]
-py_code_gen_typed = [*py_code_gen, *type_checker_sched]
-py_compiler = [*py_code_gen, PyOutPass]

jaclang/compiler/passes/main/sub_node_tab_pass.py

@@ -1,36 +0,0 @@
-"""Subnode Table building pass.
-
-This pass builds a table of subnodes for each node in the AST. This is used
-for fast lookup of nodes of a certain type in the AST. This is just a utility
-pass and is not required for any other pass to work.
-"""
-
-from copy import copy
-
-import jaclang.compiler.absyntree as ast
-from jaclang.compiler.passes import Pass
-
-
-class SubNodeTabPass(Pass):
-    """AST Enrichment Pass for basic high level semantics."""
-
-    def enter_node(self, node: ast.AstNode) -> None:
-        """Table builder."""
-        super().enter_node(node)
-        node._sub_node_tab = {}  # clears on entry
-
-    def exit_node(self, node: ast.AstNode) -> None:
-        """Table builder."""
-        super().exit_node(node)
-        for i in node.kid:
-            if not i:
-                continue
-            for k, v in i._sub_node_tab.items():
-                if k in node._sub_node_tab:
-                    node._sub_node_tab[k].extend(v)
-                else:
-                    node._sub_node_tab[k] = copy(v)
-            if type(i) in node._sub_node_tab:
-                node._sub_node_tab[type(i)].append(i)
-            else:
-                node._sub_node_tab[type(i)] = [i]

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

@@ -1,36 +0,0 @@
-obj model {
-    can __infer__(meaning_in: str, **kwargs: dict) {
-        # print(meaning_in);
-    }
-}
-glob llm = model();
-
-obj 'Person'
-Person {
-    has name: 'Name of the Person': str,
-        age: 'Age of the Person': int;
-}
-
-enum 'Personality of the Person'
-Personality {
-   INTROVERT: 'Person who is shy and reticent' = 9,
-   EXTROVERT: 'Person who is outgoing and socially confident'
-}
-
-import:jac from fstrings, a;
-
-glob personality_examples: 'Personality Information of Famous People': dict[str, Personality|None] = {
-    'Albert Einstein': Personality.INTROVERT,
-    'Barack Obama': Personality.EXTROVERT
-};
-
-can 'Get Personality of the Person'
-get_personality (person: 'Person Object': Person) -> 'Personality of the Person': Personality by llm(reason=True, incl_info=(personality_examples));
-
-with entry {
-    einstein_age: int = 75;
-    einstein_age += 1;
-    einstein = Person('Albert Einstein', einstein_age);
-    # print(einstein.name);
-    # print(get_personality(einstein));
-}

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

@@ -1,114 +0,0 @@
-"""Test pass module."""
-
-import jaclang.compiler.absyntree as ast
-from jaclang.compiler.compile import jac_file_to_pass
-from jaclang.compiler.passes.main import DeclImplMatchPass
-from jaclang.utils.test import TestCase
-
-
-class DeclImplMatchPassTests(TestCase):
-    """Test pass module."""
-
-    def setUp(self) -> None:
-        """Set up test."""
-        return super().setUp()
-
-    def test_parameter_count_mismatch(self) -> None:
-        """Basic test for pass."""
-        state = jac_file_to_pass(
-            self.fixture_abs_path("defn_decl_mismatch.jac"), DeclImplMatchPass
-        )
-
-        expected_stdout_values = (
-            "Parameter count mismatch for ability (o)SomeObj.(c)foo.",
-            "    8 |",
-            "    9 | # Miss match parameter count.",
-            "   10 | :obj:SomeObj:can:foo(param1: str) -> str {",
-            "      | ^^^^^^^^^^^^^^^^^^^^",
-            '   11 |     return "foo";',
-            "   12 | }",
-            "From the declaration of foo.",
-            "    2 |",
-            "    3 | obj SomeObj {",
-            "    4 |     can foo(param1: str, param2:int) -> str;",
-            "      |         ^^^",
-            "    5 |     can bar(param1: str, param2:int) -> str;",
-            "    6 | }",
-        )
-
-        errors_output = ""
-        for error in state.errors_had:
-            errors_output += error.pretty_print() + "\n"
-
-        for exp in expected_stdout_values:
-            self.assertIn(exp, errors_output)
-
-    def test_ability_connected_to_decl(self) -> None:
-        """Basic test for pass."""
-        state = jac_file_to_pass(self.fixture_abs_path("base.jac"), DeclImplMatchPass)
-        self.assertFalse(state.errors_had)
-        self.assertIn("(o)Test.(c)say_hi", state.ir.sym_tab.tab)
-        self.assertIsNotNone(
-            state.ir.sym_tab.tab["(o)Test.(c)say_hi"].decl.name_of.body
-        )
-        self.assertIn("(o)Test.(c)__init__", state.ir.sym_tab.tab)
-        self.assertIsNotNone(
-            state.ir.sym_tab.tab["(o)Test.(c)__init__"].decl.name_of.body
-        )
-
-    def test_ability_connected_to_decl_post(self) -> None:
-        """Basic test for pass."""
-        state = jac_file_to_pass(self.fixture_abs_path("base2.jac"), DeclImplMatchPass)
-        self.assertFalse(state.errors_had)
-        self.assertIn("(o)Test.(c)say_hi", state.ir.sym_tab.tab)
-        self.assertIsNotNone(
-            state.ir.sym_tab.tab["(o)Test.(c)say_hi"].decl.name_of.body
-        )
-        self.assertIn("(o)Test.(c)__init__", state.ir.sym_tab.tab)
-        self.assertIsNotNone(
-            state.ir.sym_tab.tab["(o)Test.(c)__init__"].decl.name_of.body
-        )
-
-    def test_arch_ref_has_sym(self) -> None:
-        """Basic test for pass."""
-        state = jac_file_to_pass(
-            self.fixture_abs_path("defs_and_uses.jac"), DeclImplMatchPass
-        )
-        for i in state.ir.get_all_sub_nodes(ast.ArchRef):
-            self.assertIsNotNone(i.sym)
-
-    def test_obj_hasvar_initialization(self) -> None:
-        """Basic test for pass."""
-        state = jac_file_to_pass(
-            self.fixture_abs_path("uninitialized_hasvars.jac"), DeclImplMatchPass
-        )
-        self.assertTrue(state.errors_had)
-
-        expected_stdout_values = (
-            "Non default attribute 'var3' follows default attribute",
-            "    4 |     has var1: int;",
-            "    5 |     has var2: int = 42;",
-            "    6 |     has var3: int; # <-- This should be syntax error.",
-            "      |         ^^^^",
-            "    7 | }",
-            'Missing "postinit" method required by un initialized attribute(s).',
-            "   11 | obj Test2 {",
-            "   12 |     has var1: str;",
-            "   13 |     has var2: int by postinit;",
-            "      |         ^^^^",
-            "   14 | }",
-            "Non default attribute 'var4' follows default attribute",
-            "   19 |     has var2: int = 42;",
-            "   20 |     has var3: int by postinit;  # <-- This is fine.",
-            "   21 |     has var4: int;  # <-- This should be syntax error.",
-            "      |         ^^^^",
-            "   22 |",
-            "   23 |     can postinit() {",
-        )
-
-        errors_output = ""
-        for error in state.errors_had:
-            errors_output += error.pretty_print() + "\n"
-
-        for exp in expected_stdout_values:
-            self.assertIn(exp, errors_output)

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

@@ -1,31 +0,0 @@
-"""Test registry pass."""
-
-import os
-
-from jaclang.compiler.compile import jac_file_to_pass
-from jaclang.compiler.passes.main import RegistryPass
-from jaclang.utils.test import TestCase
-
-
-class RegistryPassTests(TestCase):
-    """Test pass module."""
-
-    # Need change
-    def setUp(self) -> None:
-        """Set up test."""
-        return super().setUp()
-
-    def test_registry_pass(self) -> None:
-        """Basic test for pass."""
-        state = jac_file_to_pass(self.fixture_abs_path("registry.jac"), RegistryPass)
-        self.assertFalse(state.errors_had)
-        self.assertFalse(
-            os.path.exists(
-                os.path.join(
-                    os.path.dirname(self.fixture_abs_path("registry.jac")),
-                    "__jac_gen__",
-                    "registry.registry.pkl",
-                )
-            )
-        )
-        self.assertIn("109", str(state.ir.to_dict()))

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

@@ -1,91 +0,0 @@
-"""Test pass module."""
-
-from typing import List
-
-from jaclang.compiler.compile import jac_file_to_pass
-from jaclang.compiler.passes.main.schedules import py_code_gen_typed
-from jaclang.utils.lang_tools import AstTool
-from jaclang.utils.test import TestCase
-
-
-class MypyTypeCheckPassTests(TestCase):
-    """Test pass module."""
-
-    def setUp(self) -> None:
-        """Set up test."""
-        self.__messages: List[str] = []
-        return super().setUp()
-
-    def test_type_errors(self) -> None:
-        """Basic test for pass."""
-        type_checked = jac_file_to_pass(
-            file_path=self.fixture_abs_path("func.jac"),
-            schedule=py_code_gen_typed,
-        )
-
-        errs = "\n".join([i.msg for i in type_checked.warnings_had])
-        files = "\n".join([i.loc.mod_path for i in type_checked.warnings_had])
-
-        for i in [
-            "func2.jac",
-            "func.jac",
-            '(got "int", expected "str")',
-            '(got "str", expected "int")',
-        ]:
-            self.assertIn(i, errs + files)
-
-    def test_imported_module_typecheck(self) -> None:
-        """Basic test for pass."""
-        type_checked = jac_file_to_pass(
-            file_path=self.fixture_abs_path("game1.jac"),
-            schedule=py_code_gen_typed,
-        )
-
-        errs = "\n".join([i.msg for i in type_checked.warnings_had])
-        files = "\n".join([i.loc.mod_path for i in type_checked.warnings_had])
-
-        for i in [
-            'Argument 2 to "is_pressed" of "Button" has incompatible type "int"; expected "str"',
-        ]:
-            self.assertIn(i, errs + files)
-
-    def test_type_coverage(self) -> None:
-        """Testing for type info coverage in sym_tab via ast."""
-        out = AstTool().ir(["ast", f"{self.fixture_abs_path('type_info.jac')}"])
-        lis = [
-            "introduce - Type: None",
-            "25:30 - 25:37\t        |   |   |           +-- Name - species - Type: None",  # AtomTrailer
-        ]
-        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"), 35)
-        for i in lis:
-            self.assertNotIn(i, out)
-
-    def test_data_spatial_type_info(self) -> None:
-        """Testing for type info for dataspatial constructs."""
-        out = AstTool().ir(
-            ["ast", f"{self.fixture_abs_path('data_spatial_types.jac')}"]
-        )
-        self.assertRegex(
-            out,
-            r"129:24 - 129:28.*SpecialVarRef - Jac.get_root\(\) \- Type\: jaclang.Root",
-        )
-
-        self.assertRegex(out, r"129:11 - 129:29.*FuncCall \- Type\: builtins\.str")
-        self.assertRegex(
-            out,
-            r"129:15 - 129:23.*Name \- node_dot \- Type\: builtins.str,  SymbolTable\: str",
-        )
-
-        self.assertRegex(
-            out,
-            r"128:5 - 128:25.*BinaryExpr \- Type\: jaclang.Walker",
-        )
-        self.assertRegex(
-            out,
-            r"48:11 - 48:28.*EdgeRefTrailer \- Type\: jaclang.JacList\[data_spatial_types.A\]",
-        )
-
-        self.assertRegex(out, r"24:5 - 24:25.*BinaryExpr \- Type\: builtins.bool", out)