jaclang 0.7.2__py3-none-any.whl → 0.7.7__py3-none-any.whl

jaclang/compiler/passes/main/registry_pass.py

@@ -12,7 +12,7 @@ import pickle
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.constant import Constants as Con
 from jaclang.compiler.passes import Pass
-from jaclang.core.registry import SemInfo, SemRegistry
+from jaclang.compiler.semtable import SemInfo, SemRegistry
 from jaclang.core.utils import get_sem_scope
 
 
@@ -48,7 +48,7 @@ class RegistryPass(Pass):
         seminfo = SemInfo(
             node.name.value,
             node.arch_type.value,
-            node.semstr.lit_value if node.semstr else None,
+            node.semstr.lit_value if node.semstr else "",
         )
         if (
             len(self.modules_visited)
@@ -61,7 +61,7 @@ class RegistryPass(Pass):
         """Save enum information."""
         scope = get_sem_scope(node)
         seminfo = SemInfo(
-            node.name.value, "Enum", node.semstr.lit_value if node.semstr else None
+            node.name.value, "Enum", node.semstr.lit_value if node.semstr else ""
         )
         if (
             len(self.modules_visited)
@@ -79,7 +79,7 @@ class RegistryPass(Pass):
         seminfo = SemInfo(
             node.name.value,
             extracted_type,
-            node.semstr.lit_value if node.semstr else None,
+            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)
@@ -100,7 +100,7 @@ class RegistryPass(Pass):
                 else ""
             ),
             extracted_type,
-            node.semstr.lit_value if node.semstr else None,
+            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)
@@ -113,7 +113,7 @@ class RegistryPass(Pass):
             and node.parent.parent.__class__.__name__ == "Enum"
         ):
             scope = get_sem_scope(node)
-            seminfo = SemInfo(node.value, None, None)
+            seminfo = SemInfo(node.value, None, "")
             if len(self.modules_visited) and self.modules_visited[-1].registry:
                 self.modules_visited[-1].registry.add(scope, seminfo)
 

jaclang/compiler/passes/main/sub_node_tab_pass.py

@@ -6,7 +6,6 @@ pass and is not required for any other pass to work.
 """
 
 from copy import copy
-from typing import Optional
 
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.passes import Pass
@@ -15,10 +14,6 @@ from jaclang.compiler.passes import Pass
 class SubNodeTabPass(Pass):
     """AST Enrichment Pass for basic high level semantics."""
 
-    def before_pass(self) -> None:
-        """Initialize pass."""
-        self.cur_module: Optional[ast.Module] = None
-
     def enter_node(self, node: ast.AstNode) -> None:
         """Table builder."""
         super().enter_node(node)

jaclang/compiler/passes/main/sym_tab_build_pass.py

@@ -4,210 +4,19 @@ This pass builds the symbol table tree for the Jaseci Ast. It also adds symbols
 for globals, imports, architypes, and abilities declarations and definitions.
 """
 
-import ast as ast3
 import builtins
-from typing import Optional, Sequence
 
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.constant import Tokens as Tok
 from jaclang.compiler.passes import Pass
-from jaclang.compiler.symtable import Symbol, SymbolAccess, SymbolTable
+from jaclang.compiler.symtable import SymbolTable
 
 
-class SymTabPass(Pass):
-    """Jac Ast build pass."""
-
-    def before_pass(self) -> None:
-        """Before pass."""
-        self.unlinked: set[ast.AstSymbolNode] = set()  # Failed use lookups
-        self.linked: set[ast.AstSymbolNode] = set()  # Successful use lookups
-
-    def seen(self, node: ast.AstSymbolNode) -> bool:
-        """Check if seen."""
-        result = node in self.linked or node in self.unlinked
-        if node.sym_link and not result:
-            self.linked.add(node)
-            return True
-        return result
-
-    def inherit_sym_tab(self, scope: SymbolTable, sym_tab: SymbolTable) -> None:
-        """Inherit symbol table."""
-        for i in sym_tab.tab.values():
-            self.def_insert(i.decl, access_spec=i.access, table_override=scope)
-
-    def def_insert(
-        self,
-        node: ast.AstSymbolNode,
-        access_spec: Optional[ast.AstAccessNode] | SymbolAccess = None,
-        single_decl: Optional[str] = None,
-        table_override: Optional[SymbolTable] = None,
-    ) -> Optional[Symbol]:
-        """Insert into symbol table."""
-        table = table_override if table_override else node.sym_tab
-        if self.seen(node) and node.sym_link and table == node.sym_link.parent_tab:
-            return node.sym_link
-        if table:
-            table.insert(
-                node=node, single=single_decl is not None, access_spec=access_spec
-            )
-        self.update_py_ctx_for_def(node)
-        self.handle_hit_outcome(node)
-        return node.sym_link
-
-    def update_py_ctx_for_def(self, node: ast.AstSymbolNode) -> None:
-        """Update python context for definition."""
-        node.py_ctx_func = ast3.Store
-        if isinstance(node.sym_name_node, ast.AstSymbolNode):
-            node.sym_name_node.py_ctx_func = ast3.Store
-        if isinstance(node, (ast.TupleVal, ast.ListVal)) and node.values:
-            # Handling of UnaryExpr case for item is only necessary for
-            # the generation of Starred nodes in the AST for examples
-            # like `(a, *b) = (1, 2, 3, 4)`.
-            def fix(item: ast.TupleVal | ast.ListVal | ast.UnaryExpr) -> None:
-                if isinstance(item, ast.UnaryExpr):
-                    if isinstance(item.operand, ast.AstSymbolNode):
-                        item.operand.py_ctx_func = ast3.Store
-                elif isinstance(item, (ast.TupleVal, ast.ListVal)):
-                    for i in item.values.items if item.values else []:
-                        if isinstance(i, ast.AstSymbolNode):
-                            i.py_ctx_func = ast3.Store
-                        elif isinstance(i, ast.AtomTrailer):
-                            self.chain_def_insert(self.unwind_atom_trailer(i))
-                        if isinstance(i, (ast.TupleVal, ast.ListVal, ast.UnaryExpr)):
-                            fix(i)
-
-            fix(node)
-
-    def use_lookup(
-        self,
-        node: ast.AstSymbolNode,
-        sym_table: Optional[SymbolTable] = None,
-    ) -> Optional[Symbol]:
-        """Link to symbol."""
-        if self.seen(node):
-            return node.sym_link
-        if not sym_table:
-            sym_table = node.sym_tab
-        if sym_table:
-            node.sym_link = (
-                sym_table.lookup(name=node.sym_name, deep=True) if sym_table else None
-            )
-            # If successful lookup mark linked, add to table uses, and link others
-            if node.sym_link:
-                sym_table.uses.append(node)
-        self.handle_hit_outcome(node)
-        return node.sym_link
-
-    def chain_def_insert(self, node_list: Sequence[ast.AstSymbolNode]) -> None:
-        """Link chain of containing names to symbol."""
-        if not node_list:
-            return
-        cur_sym_tab = node_list[0].sym_tab
-        node_list[-1].py_ctx_func = ast3.Store
-        if isinstance(node_list[-1].sym_name_node, ast.AstSymbolNode):
-            node_list[-1].sym_name_node.py_ctx_func = ast3.Store
-
-        node_list = node_list[:-1]  # Just performs lookup mappings of pre assign chain
-        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
-            )
-
-    def chain_use_lookup(self, node_list: Sequence[ast.AstSymbolNode]) -> None:
-        """Link chain of containing names to symbol."""
-        if not node_list:
-            return
-        cur_sym_tab = node_list[0].sym_tab
-        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
-            )
-
-    def unwind_atom_trailer(self, node: ast.AtomTrailer) -> list[ast.AstSymbolNode]:
-        """Sub objects.
-
-        target: ExprType,
-        right: AtomType,
-        is_scope_contained: bool,
-        """
-        left = node.right if isinstance(node.right, ast.AtomTrailer) else node.target
-        right = node.target if isinstance(node.right, ast.AtomTrailer) else node.right
-        trag_list: list[ast.AstSymbolNode] = (
-            [right] if isinstance(right, ast.AstSymbolNode) else []
-        )
-        if not trag_list:
-            self.ice("Something went very wrong with atom trailer not valid")
-        while isinstance(left, ast.AtomTrailer) and left.is_attr:
-            if isinstance(left.right, ast.AstSymbolNode):
-                trag_list.insert(0, left.right)
-            else:
-                raise self.ice("Something went very wrong with atom trailer not valid")
-            left = left.target
-        if isinstance(left, ast.AstSymbolNode):
-            trag_list.insert(0, left)
-        return trag_list
-
-    def handle_hit_outcome(
-        self,
-        node: ast.AstSymbolNode,
-    ) -> None:
-        """Handle outcome of lookup or insert."""
-        # If successful lookup mark linked, add to table uses, and link others
-        if node.sym_link:
-            self.linked.add(node)
-            if isinstance(node.sym_name_node, ast.AstSymbolNode):
-                node.sym_name_node.sym_link = node.sym_link
-        if not node.sym_link:
-            # Mark nodes that were not successfully linked
-            self.unlinked.add(node)
-            if (
-                isinstance(node.sym_name_node, ast.AstSymbolNode)
-                and not node.sym_name_node.sym_link
-            ):
-                self.unlinked.add(node.sym_name_node)
-
-    def already_declared_err(
-        self,
-        name: str,
-        typ: str,
-        original: ast.AstNode,
-        other_nodes: Optional[list[ast.AstNode]] = None,
-    ) -> None:
-        """Already declared error."""
-        err_msg = (
-            f"Name used for {typ} '{name}' already declared at "
-            f"{original.loc.mod_path}, line {original.loc.first_line}"
-        )
-        if other_nodes:
-            for i in other_nodes:
-                err_msg += f", also see {i.loc.mod_path}, line {i.loc.first_line}"
-        self.warning(err_msg)
-
-
-class SymTabBuildPass(SymTabPass):
+class SymTabBuildPass(Pass):
     """Jac Symbol table build pass."""
 
     def before_pass(self) -> None:
         """Before pass."""
-        super().before_pass()
         self.cur_sym_tab: list[SymbolTable] = []
 
     def push_scope(self, name: str, key_node: ast.AstNode, fresh: bool = False) -> None:
@@ -215,19 +24,20 @@ class SymTabBuildPass(SymTabPass):
         if fresh:
             self.cur_sym_tab.append(SymbolTable(name, key_node))
         else:
-            self.cur_sym_tab.append(self.cur_scope().push_scope(name, key_node))
+            self.cur_sym_tab.append(self.cur_scope.push_scope(name, key_node))
 
     def pop_scope(self) -> SymbolTable:
         """Pop scope."""
         return self.cur_sym_tab.pop()
 
+    @property
     def cur_scope(self) -> SymbolTable:
         """Return current scope."""
         return self.cur_sym_tab[-1]
 
     def sync_node_to_scope(self, node: ast.AstNode) -> None:
         """Sync node to scope."""
-        node.sym_tab = self.cur_scope()
+        node.sym_tab = self.cur_scope
 
     def enter_module(self, node: ast.Module) -> None:
         """Sub objects.
@@ -238,7 +48,7 @@ class SymTabBuildPass(SymTabPass):
         mod_path: str,
         is_imported: bool,
         """
-        self.push_scope(node.name, node, fresh=True)
+        self.push_scope(node.name, node, fresh=(node == self.ir))
         self.sync_node_to_scope(node)
         for obj in dir(builtins):
             builtin = ast.Name(
@@ -246,13 +56,15 @@ class SymTabBuildPass(SymTabPass):
                 name=Tok.NAME,
                 value=str(obj),
                 line=0,
+                end_line=0,
                 col_start=0,
                 col_end=0,
                 pos_start=0,
                 pos_end=0,
             )
             self.sync_node_to_scope(builtin)
-            self.def_insert(builtin)
+            builtin.sym_tab.def_insert(builtin)
+        # self.def_insert(ast.Name.gen_stub_from_node(node.name, "root"))
 
     def exit_module(self, node: ast.Module) -> None:
         """Sub objects.
@@ -263,23 +75,7 @@ class SymTabBuildPass(SymTabPass):
         mod_path: str,
         is_imported: bool,
         """
-        s = self.pop_scope()
-        # If not the main module add all the other modules symbol table
-        # as a child to the current symbol table
-        if node != self.ir:
-            self.cur_scope().kid.append(s)
-            s.parent = self.cur_scope()
-
-        if (
-            isinstance(node.parent, ast.Module)
-            and node
-            in [
-                node.parent.impl_mod,
-                node.parent.test_mod,
-            ]
-            and node.sym_tab
-        ):
-            self.inherit_sym_tab(scope=self.cur_scope(), sym_tab=node.sym_tab)
+        self.pop_scope()
 
     def enter_global_vars(self, node: ast.GlobalVars) -> None:
         """Sub objects.
@@ -302,7 +98,7 @@ class SymTabBuildPass(SymTabPass):
         for i in self.get_all_sub_nodes(node, ast.Assignment):
             for j in i.target.items:
                 if isinstance(j, ast.AstSymbolNode):
-                    self.def_insert(j, access_spec=node, single_decl="global var")
+                    j.sym_tab.def_insert(j, access_spec=node, single_decl="global var")
                 else:
                     self.ice("Expected name type for globabl vars")
 
@@ -328,7 +124,14 @@ class SymTabBuildPass(SymTabPass):
         description: Token,
         body: CodeBlock,
         """
+        self.push_scope(node.sym_name, node)
         self.sync_node_to_scope(node)
+        import unittest
+
+        for i in [j for j in dir(unittest.TestCase()) if j.startswith("assert")]:
+            node.sym_tab.def_insert(
+                ast.Name.gen_stub_from_node(node, i, set_name_of=node)
+            )
 
     def exit_test(self, node: ast.Test) -> None:
         """Sub objects.
@@ -338,9 +141,6 @@ class SymTabBuildPass(SymTabPass):
         description: Token,
         body: CodeBlock,
         """
-        self.def_insert(node, single_decl="test")
-        self.push_scope(node.name.value, node)
-        self.sync_node_to_scope(node)
         self.pop_scope()
 
     def enter_module_code(self, node: ast.ModuleCode) -> None:
@@ -392,22 +192,16 @@ class SymTabBuildPass(SymTabPass):
         """
         if not node.is_absorb:
             for i in node.items.items:
-                self.def_insert(i, single_decl="import item")
+                i.sym_tab.def_insert(i, single_decl="import item")
         elif node.is_absorb and node.hint.tag.value == "jac":
             source = node.items.items[0]
-            if (
-                not isinstance(source, ast.ModulePath)
-                or not source.sub_module
-                or not source.sub_module.sym_tab
-            ):
+            if not isinstance(source, ast.ModulePath) or not source.sub_module:
                 self.error(
                     f"Module {node.from_loc.path_str if node.from_loc else 'from location'}"
                     f" not found to include *, or ICE occurred!"
                 )
             else:
-                self.inherit_sym_tab(
-                    scope=self.cur_scope(), sym_tab=source.sub_module.sym_tab
-                )
+                node.sym_tab.inherit_sym_tab(source.sub_module.sym_tab)
 
     def enter_module_path(self, node: ast.ModulePath) -> None:
         """Sub objects.
@@ -426,9 +220,9 @@ class SymTabBuildPass(SymTabPass):
         sub_module: Optional[Module] = None,
         """
         if node.alias:
-            self.def_insert(node.alias, single_decl="import")
+            node.alias.sym_tab.def_insert(node.alias, single_decl="import")
         elif node.path and isinstance(node.path[0], ast.Name):
-            self.def_insert(node.path[0])
+            node.path[0].sym_tab.def_insert(node.path[0])
         else:
             pass  # Need to support pythonic import symbols with dots in it
 
@@ -453,7 +247,7 @@ class SymTabBuildPass(SymTabPass):
         body: Optional[ArchBlock],
         """
         self.sync_node_to_scope(node)
-        self.def_insert(node, access_spec=node, single_decl="architype")
+        node.sym_tab.def_insert(node, access_spec=node, single_decl="architype")
         self.push_scope(node.name.value, node)
         self.sync_node_to_scope(node)
 
@@ -479,7 +273,7 @@ class SymTabBuildPass(SymTabPass):
         body: ArchBlock,
         """
         self.sync_node_to_scope(node)
-        self.def_insert(node, single_decl="arch def")
+        node.sym_tab.def_insert(node, single_decl="arch def")
         self.push_scope(node.sym_name, node)
         self.sync_node_to_scope(node)
 
@@ -507,9 +301,16 @@ class SymTabBuildPass(SymTabPass):
         body: Optional[CodeBlock],
         """
         self.sync_node_to_scope(node)
-        self.def_insert(node, access_spec=node, single_decl="ability")
+        node.sym_tab.def_insert(node, access_spec=node, single_decl="ability")
         self.push_scope(node.sym_name, node)
         self.sync_node_to_scope(node)
+        if node.is_method:
+            node.sym_tab.def_insert(ast.Name.gen_stub_from_node(node, "self"))
+            node.sym_tab.def_insert(
+                ast.Name.gen_stub_from_node(
+                    node, "super", set_name_of=node.owner_method
+                )
+            )
 
     def exit_ability(self, node: ast.Ability) -> None:
         """Sub objects.
@@ -535,7 +336,7 @@ class SymTabBuildPass(SymTabPass):
         body: CodeBlock,
         """
         self.sync_node_to_scope(node)
-        self.def_insert(node, single_decl="ability def")
+        node.sym_tab.def_insert(node, single_decl="ability def")
         self.push_scope(node.sym_name, node)
         self.sync_node_to_scope(node)
 
@@ -595,7 +396,7 @@ class SymTabBuildPass(SymTabPass):
         body: Optional['EnumBlock'],
         """
         self.sync_node_to_scope(node)
-        self.def_insert(node, access_spec=node, single_decl="enum")
+        node.sym_tab.def_insert(node, access_spec=node, single_decl="enum")
         self.push_scope(node.sym_name, node)
         self.sync_node_to_scope(node)
 
@@ -619,7 +420,7 @@ class SymTabBuildPass(SymTabPass):
         body: EnumBlock,
         """
         self.sync_node_to_scope(node)
-        self.def_insert(node, single_decl="enum def")
+        node.sym_tab.def_insert(node, single_decl="enum def")
         self.push_scope(node.sym_name, node)
         self.sync_node_to_scope(node)
 
@@ -896,6 +697,13 @@ class SymTabBuildPass(SymTabPass):
         """
         self.sync_node_to_scope(node)
 
+    def enter_check_stmt(self, node: ast.CheckStmt) -> None:
+        """Sub objects.
+
+        target: Expr,
+        """
+        self.sync_node_to_scope(node)
+
     def enter_ctrl_stmt(self, node: ast.CtrlStmt) -> None:
         """Sub objects.
 

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

@@ -1,5 +1,6 @@
 """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
@@ -17,15 +18,31 @@ class DeclImplMatchPassTests(TestCase):
         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.body)
+        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.body)
+        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.body)
+        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.body)
+        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)

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

@@ -18,13 +18,8 @@ class DefUsePassTests(TestCase):
             file_path=self.fixture_abs_path("defs_and_uses.jac"),
             target=DefUsePass,
         )
-        # for i in state.unlinked:
-        #     print(f"Unlinked {i.__class__.__name__} {i.sym_name} {i.loc}")
-        # for i in state.linked:
-        #     print(
-        #         f"Linked {i.__class__.__name__} {i.sym_name} {i.loc} "
-        #         f", {i.sym_link.decl.loc if i.sym_link else None}"
-        #     )
-        self.assertGreater(len(state.linked), 5)
-        self.assertLess(len(state.warnings_had), 50)
-        self.assertEqual(len(state.errors_had), 0)
+        uses = [i.uses for i in state.ir.sym_tab.kid[0].tab.values()]
+        self.assertEqual(len(uses[1]), 1)
+        self.assertEqual(len(uses[2]), 1)
+        self.assertIn("output", [uses[1][0].sym_name, uses[2][0].sym_name])
+        self.assertIn("message", [uses[1][0].sym_name, uses[2][0].sym_name])

jaclang/compiler/passes/main/type_check_pass.py

@@ -8,9 +8,9 @@ import os
 import pathlib
 import sys
 
-
 import jaclang.compiler.absyntree as ast
 import jaclang.compiler.passes.utils.mypy_ast_build as myab
+from jaclang.compiler.constant import Constants as Con
 from jaclang.compiler.passes import Pass
 
 
@@ -48,6 +48,7 @@ class JacTypeCheckPass(Pass):
         """Call mypy APIs to implement type checking in Jac."""
         # Creating mypy api objects
         options = myab.myb.Options()
+        options.cache_dir = Con.JAC_MYPY_CACHE
         errors = myab.Errors(self, options)
         fs_cache = myab.FileSystemCache()
         search_paths = myab.compute_search_paths([], options, str(self.__path))

jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -484,7 +484,7 @@ class JacFormatPass(Pass):
 
         var: Token,
         """
-        self.emit(node, node.var.value)
+        self.emit(node, node.orig.value)
 
     def exit_ability_def(self, node: ast.AbilityDef) -> None:
         """Sub objects.
@@ -1871,6 +1871,32 @@ class JacFormatPass(Pass):
         if isinstance(node.kid[-1], (ast.Semi, ast.CommentToken)):
             self.emit_ln(node, "")
 
+    def exit_check_stmt(self, node: ast.CheckStmt) -> None:
+        """Sub objects.
+
+        target: ExprType,
+        """
+        start = True
+        for i in node.kid:
+            if isinstance(i, ast.CommentToken):
+                if i.is_inline:
+                    self.emit(node, f" {i.gen.jac}")
+                else:
+                    if not node.gen.jac.endswith("\n"):
+                        self.emit_ln(node, "")
+                    self.emit_ln(node, "")
+                    self.emit(node, i.gen.jac)
+            elif isinstance(i, ast.Semi):
+                self.emit(node, i.gen.jac)
+            else:
+                if start:
+                    self.emit(node, i.gen.jac)
+                    start = False
+                else:
+                    self.emit(node, f" {i.gen.jac}")
+        if isinstance(node.kid[-1], (ast.Semi, ast.CommentToken)):
+            self.emit_ln(node, "")
+
     def exit_ctrl_stmt(self, node: ast.CtrlStmt) -> None:
         """Sub objects.
 
@@ -2002,7 +2028,6 @@ class JacFormatPass(Pass):
         doc: Optional[Token],
         body: CodeBlock,
         """
-        start = True
         for i in node.kid:
             if isinstance(i, ast.CommentToken):
                 if i.is_inline:
@@ -2013,14 +2038,10 @@ class JacFormatPass(Pass):
             elif isinstance(i, ast.Semi):
                 self.emit(node, i.gen.jac)
             elif isinstance(i, ast.Name):
-                if not i.value.startswith("test_t"):
-                    self.emit(node, f" {i.value} ")
+                if not i.value.startswith("_jac_gen_"):
+                    self.emit(node, f" {i.value}")
             else:
-                if start:
-                    self.emit(node, i.gen.jac)
-                    start = False
-                else:
-                    self.emit(node, f" {i.gen.jac}")
+                self.emit(node, i.gen.jac)
         if isinstance(node.kid[-1], (ast.Semi, ast.CommentToken)):
             self.emit_ln(node, "")
 

jaclang/compiler/passes/tool/tests/fixtures/corelib.jac

@@ -478,3 +478,19 @@ obj JacPlugin {
 (walker_obj: Any, expr: Any) -> bool {
     return walker_obj._jac_.visit_node(expr);
 }
+
+glob expected_area = 78.53981633974483;
+
+test a1 {
+    check assertAlmostEqual(calculate_area(RAD), expected_area);
+}
+
+test a2 {
+    c = Circle(RAD);
+    check assertAlmostEqual(c.area(), expected_area);
+}
+
+test a3 {
+    c = Circle(RAD);
+    check assertEqual(c.shape_type, ShapeType.CIRCLE);
+}