jaclang 0.7.1__py3-none-any.whl → 0.7.5__py3-none-any.whl

jaclang/compiler/passes/main/pyjac_ast_link_pass.py

@@ -1,4 +1,9 @@
-"""Jac to python ast link pass."""
+"""Jac to python ast link pass.
+
+This pass is needed so cases where there are multiple Jac nodes relevant to a
+single python node can be linked. For example FuncDef doesn't have a Name node
+however Ability does.
+"""
 
 import ast as ast3
 
@@ -52,10 +57,13 @@ class PyJacAstLinkPass(Pass):
         decorators: Optional[SubNodeList[ExprType]],
         """
         for i in node.target.archs:
-            if i.sym_link:
-                self.link_jac_py_nodes(jac_node=i, py_nodes=i.sym_link.decl.gen.py_ast)
+            if i.name_spec.name_of.sym:
+                self.link_jac_py_nodes(
+                    jac_node=i, py_nodes=i.name_spec.name_of.sym.decl.gen.py_ast
+                )
                 self.link_jac_py_nodes(
-                    jac_node=i.name_ref, py_nodes=i.sym_link.decl.gen.py_ast
+                    jac_node=i.name_spec,
+                    py_nodes=i.name_spec.name_of.sym.decl.gen.py_ast,
                 )
 
     def exit_enum(self, node: ast.Enum) -> None:
@@ -80,10 +88,13 @@ class PyJacAstLinkPass(Pass):
         decorators: Optional[SubNodeList[ExprType]],
         """
         for i in node.target.archs:
-            if i.sym_link:
-                self.link_jac_py_nodes(jac_node=i, py_nodes=i.sym_link.decl.gen.py_ast)
+            if i.name_spec.name_of.sym:
                 self.link_jac_py_nodes(
-                    jac_node=i.name_ref, py_nodes=i.sym_link.decl.gen.py_ast
+                    jac_node=i, py_nodes=i.name_spec.name_of.sym.decl.gen.py_ast
+                )
+                self.link_jac_py_nodes(
+                    jac_node=i.name_spec,
+                    py_nodes=i.name_spec.name_of.sym.decl.gen.py_ast,
                 )
 
     def exit_ability(self, node: ast.Ability) -> None:
@@ -114,10 +125,13 @@ class PyJacAstLinkPass(Pass):
         decorators: Optional[SubNodeList[ExprType]],
         """
         for i in node.target.archs:
-            if i.sym_link:
-                self.link_jac_py_nodes(jac_node=i, py_nodes=i.sym_link.decl.gen.py_ast)
+            if i.name_spec.name_of.sym:
+                self.link_jac_py_nodes(
+                    jac_node=i, py_nodes=i.name_spec.name_of.sym.decl.gen.py_ast
+                )
                 self.link_jac_py_nodes(
-                    jac_node=i.name_ref, py_nodes=i.sym_link.decl.gen.py_ast
+                    jac_node=i.name_spec,
+                    py_nodes=i.name_spec.name_of.sym.decl.gen.py_ast,
                 )
 
         if isinstance(node.parent, ast.Ability) and node.parent.signature:
@@ -214,5 +228,5 @@ class PyJacAstLinkPass(Pass):
         """
         if node.is_attr and isinstance(node.right, ast.AstSymbolNode):
             self.link_jac_py_nodes(
-                jac_node=node.right.sym_name_node, py_nodes=node.gen.py_ast
+                jac_node=node.right.name_spec, py_nodes=node.gen.py_ast
             )

jaclang/compiler/passes/main/pyout_pass.py

@@ -35,7 +35,9 @@ class PyOutPass(Pass):
                 f"Unable to find module {node.loc.mod_path} or no code present.", node
             )
             return
-        mods = [node] + self.get_all_sub_nodes(node, ast.Module)
+        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(

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/sym_tab_build_pass.py

@@ -17,19 +17,6 @@ from jaclang.compiler.symtable import Symbol, SymbolAccess, 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():
@@ -44,21 +31,20 @@ class SymTabPass(Pass):
     ) -> 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 node.sym and table == node.sym.parent_tab:
+            return node.sym
         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
+        return node.sym
 
     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
+        node.name_spec.py_ctx_func = ast3.Store
+        if isinstance(node.name_spec, ast.AstSymbolNode):
+            node.name_spec.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
@@ -66,11 +52,11 @@ class SymTabPass(Pass):
             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
+                        item.operand.name_spec.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
+                            i.name_spec.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)):
@@ -84,28 +70,23 @@ class SymTabPass(Pass):
         sym_table: Optional[SymbolTable] = None,
     ) -> Optional[Symbol]:
         """Link to symbol."""
-        if self.seen(node):
-            return node.sym_link
+        if node.sym:
+            return node.sym
         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
+            lookup = sym_table.lookup(name=node.sym_name, deep=True)
+            lookup.add_use(node.name_spec) if lookup else None
+        return node.sym
 
     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[-1].name_spec.py_ctx_func = ast3.Store
+        if isinstance(node_list[-1].name_spec, ast.AstSymbolNode):
+            node_list[-1].name_spec.py_ctx_func = ast3.Store
 
         node_list = node_list[:-1]  # Just performs lookup mappings of pre assign chain
         for i in node_list:
@@ -165,25 +146,6 @@ class SymTabPass(Pass):
             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,
@@ -238,7 +200,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,6 +208,7 @@ class SymTabBuildPass(SymTabPass):
                 name=Tok.NAME,
                 value=str(obj),
                 line=0,
+                end_line=0,
                 col_start=0,
                 col_end=0,
                 pos_start=0,
@@ -253,6 +216,7 @@ class SymTabBuildPass(SymTabPass):
             )
             self.sync_node_to_scope(builtin)
             self.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 +227,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.
@@ -510,6 +458,9 @@ class SymTabBuildPass(SymTabPass):
         self.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:
+            self.def_insert(ast.Name.gen_stub_from_node(node, "self"))
+            self.def_insert(ast.Name.gen_stub_from_node(node, "super"))
 
     def exit_ability(self, node: ast.Ability) -> None:
         """Sub objects.
@@ -896,6 +847,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/tests/test_import_pass.py

@@ -41,3 +41,11 @@ class ImportPassPassTests(TestCase):
         self.assertIn("autoimpl", mod_names)
         self.assertIn("autoimpl.impl", mod_names)
         self.assertIn("autoimpl.something.else.impl", mod_names)
+
+    def test_annexalbe_by_discovery(self) -> None:
+        """Basic test for pass."""
+        state = jac_file_to_pass(
+            self.fixture_abs_path("incautoimpl.jac"), JacImportPass
+        )
+        for i in state.ir.get_all_sub_nodes(ast.Module):
+            self.assertEqual(i.annexable_by, self.fixture_abs_path("autoimpl.jac"))

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"), 27)
+        self.assertEqual(out.count("Type: builtins.str"), 28)
         for i in lis:
             self.assertNotIn(i, out)

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

@@ -421,7 +421,10 @@ class JacFormatPass(Pass):
                     self.emit_ln(node, "")
                     self.emit_ln(node, i.gen.jac)
             if isinstance(i, ast.Token) and i.name == Tok.KW_BY:
-                self.emit(node, f"{i.gen.jac} ")
+                if not node.params:
+                    self.emit(node, f"{i.gen.jac} ")
+                else:
+                    self.emit(node, f" {i.gen.jac} ")
             else:
                 if (
                     line_break_needed
@@ -481,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.
@@ -1868,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.
 
@@ -1999,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:
@@ -2010,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, "")
 
@@ -2402,7 +2426,16 @@ class JacFormatPass(Pass):
             and isinstance(node.parent.parent, ast.FString)
         ):
             self.emit(node, node.value)
-        self.emit(node, node.value)
+        if "\n" in node.value:
+            string_type = node.value[0:3]
+            pure_string = node.value[3:-3]
+            lines = pure_string.split("\n")
+            self.emit(node, string_type)
+            for line in lines[:-1]:
+                self.emit_ln(node, line)
+            self.emit_ln(node, f"{lines[-1]}{string_type}")
+        else:
+            self.emit(node, node.value)
 
     def enter_bool(self, node: ast.Bool) -> None:
         """Sub objects.

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);
+}

jaclang/compiler/passes/tool/tests/fixtures/corelib_fmt.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);
+}

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

@@ -0,0 +1,15 @@
+class foo {
+    """
+    doc string
+    """
+    can print_here() {
+        print("i'm here");
+    }
+
+    """this is a
+    multiline docstring
+    to test"""
+    can also_print() {
+        print("I'm in also");
+    }
+}

jaclang/compiler/passes/tool/tests/test_jac_format_pass.py

@@ -44,8 +44,8 @@ class JacFormatPassTests(TestCaseMicroSuite, AstSyncTestMixin):
 
             if diff:
                 print(f"Differences found in comparison:\n{diff}")
-                # raise AssertionError("Files differ after formatting.")
-                self.skipTest("Test failed, but skipping instead of failing.")
+                raise AssertionError("Files differ after formatting.")
+
         except FileNotFoundError:
             print(f"File not found: {original_file} or {formatted_file}")
             raise
@@ -76,6 +76,9 @@ class JacFormatPassTests(TestCaseMicroSuite, AstSyncTestMixin):
         self.compare_files(
             os.path.join(self.fixture_abs_path(""), "corelib_fmt.jac"),
         )
+        self.compare_files(
+            os.path.join(self.fixture_abs_path(""), "doc_string.jac"),
+        )
 
     def test_compare_myca_fixtures(self) -> None:
         """Tests if files in the myca fixtures directory do not change after being formatted."""
@@ -135,14 +138,13 @@ class JacFormatPassTests(TestCaseMicroSuite, AstSyncTestMixin):
             diff = "\n".join(unified_diff(before.splitlines(), after.splitlines()))
             self.assertFalse(diff, "AST structures differ after formatting.")
 
-        except Exception:
+        except Exception as e:
             print(add_line_numbers(code_gen_pure.ir.source.code))
             print("\n+++++++++++++++++++++++++++++++++++++++\n")
             print(add_line_numbers(code_gen_format.ir.gen.jac))
             print("\n+++++++++++++++++++++++++++++++++++++++\n")
             print("\n".join(unified_diff(before.splitlines(), after.splitlines())))
-            self.skipTest("Test failed, but skipping instead of failing.")
-            # raise e
+            raise e
 
 
 JacFormatPassTests.self_attach_micro_tests()

jaclang/compiler/passes/tool/tests/test_unparse_validate.py

@@ -30,7 +30,7 @@ class JacUnparseTests(TestCaseMicroSuite, AstSyncTestMixin):
             self.assertEqual(x, y)
         except Exception as e:
             print("\n".join(unified_diff(x.splitlines(), y.splitlines())))
-            self.skipTest(f"Test failed, but skipping instead of failing: {e}")
+            raise e
 
     def micro_suite_test(self, filename: str) -> None:
         """Parse micro jac file."""
@@ -75,7 +75,6 @@ class JacUnparseTests(TestCaseMicroSuite, AstSyncTestMixin):
 
         except Exception as e:
             raise e
-            # self.skipTest(f"Test failed, but skipping instead of failing: {e}")
 
 
 JacUnparseTests.self_attach_micro_tests()