jaclang 0.7.13__py3-none-any.whl → 0.7.15__py3-none-any.whl

jaclang/cli/cli.py

@@ -19,10 +19,10 @@ from jaclang.compiler.constant import Constants
 from jaclang.compiler.passes.main.pyast_load_pass import PyastBuildPass
 from jaclang.compiler.passes.main.schedules import py_code_gen_typed
 from jaclang.compiler.passes.tool.schedules import format_pass
-from jaclang.core.constructs import Architype
 from jaclang.plugin.builtin import dotgen
 from jaclang.plugin.feature import JacCmd as Cmd
 from jaclang.plugin.feature import JacFeature as Jac
+from jaclang.runtimelib.constructs import Architype
 from jaclang.utils.helpers import debugger as db
 from jaclang.utils.lang_tools import AstTool
 
@@ -86,11 +86,10 @@ def run(
             else ""
         )
 
-    Jac.context().init_memory(session)
-
     base, mod = os.path.split(filename)
     base = base if base else "./"
     mod = mod[:-4]
+    Jac.context().init_memory(base_path=base, session=session)
     if filename.endswith(".jac"):
         ret_module = jac_import(
             target=mod,
@@ -146,7 +145,7 @@ def get_object(id: str, session: str = "") -> dict:
     if session == "":
         session = cmd_registry.args.session if "session" in cmd_registry.args else ""
 
-    Jac.context().init_memory(session)
+    Jac.context().init_memory(session=session)
 
     if id == "root":
         id_uuid = UUID(int=0)
@@ -357,11 +356,10 @@ def dot(
             else ""
         )
 
-    Jac.context().init_memory(session)
-
     base, mod = os.path.split(filename)
     base = base if base else "./"
     mod = mod[:-4]
+    Jac.context().init_memory(base_path=base, session=session)
     if filename.endswith(".jac"):
         jac_import(
             target=mod,
@@ -437,12 +435,17 @@ def start_cli() -> None:
     parser = cmd_registry.parser
     args = parser.parse_args()
     cmd_registry.args = args
+
+    if args.version:
+        version = importlib.metadata.version("jaclang")
+        print(f"Jac version {version}")
+        return
+
     command = cmd_registry.get(args.command)
     if command:
         args_dict = vars(args)
         args_dict.pop("command")
-        if command not in ["run"]:
-            args_dict.pop("session")
+        args_dict.pop("version", None)
         ret = command.call(**args_dict)
         if ret:
             print(ret)

jaclang/cli/cmdreg.py

@@ -38,7 +38,7 @@ class CommandRegistry:
         self.registry = {}
         self.parser = argparse.ArgumentParser(prog="jac")
         self.parser.add_argument(
-            "--session", help="Session file path", nargs="?", default=""
+            "-V", "--version", action="store_true", help="Show the Jac version"
         )
         self.sub_parsers = self.parser.add_subparsers(title="commands", dest="command")
         self.args = argparse.Namespace()
@@ -172,17 +172,14 @@ class CommandShell(cmd.Cmd):
 
     def default(self, line: str) -> None:
         """Process the command line input."""
-        try:
-            args = vars(self.cmd_reg.parser.parse_args(line.split()))
-            command = self.cmd_reg.get(args["command"])
-            if command:
-                args.pop("command")
-                ret = command.call(**args)
-                if ret:
-                    ret_str = pprint.pformat(ret, indent=2)
-                    self.stdout.write(f"{ret_str}\n")
-        except Exception as e:
-            print(e)
+        args = vars(self.cmd_reg.parser.parse_args(line.split()))
+        command = self.cmd_reg.get(args["command"])
+        if command:
+            args.pop("command")
+            ret = command.call(**args)
+            if ret:
+                ret_str = pprint.pformat(ret, indent=2)
+                self.stdout.write(f"{ret_str}\n")
 
     def do_help(self, arg: str) -> None:
         """Jac CLI 'help' implementaion."""

jaclang/compiler/__init__.py

@@ -34,8 +34,6 @@ def generate_static_parser(force: bool = False) -> None:
         except Exception as e:
             logging.error(f"Error generating reference files: {e}")
 
-
-generate_static_parser()
 try:
     from jaclang.compiler.generated import jac_parser as jac_lark
 except ModuleNotFoundError:

jaclang/compiler/absyntree.py

@@ -55,15 +55,10 @@ class AstNode:
         """Get symbol table."""
         # sym_tab should never be accessed without being set in codebase
         if not self._sym_tab:
-            import traceback
-
-            if self.parent:
-                print(f"Parent: {self.parent.pp()}")
-            print("Node: ", self.pp())
-            stack_trace = traceback.format_stack()
-            print("".join(stack_trace))
             raise ValueError(
-                f"Symbol table not set for {type(self).__name__}. Impossible."
+                f"Symbol table not set for {type(self).__name__}. Impossible.\n"
+                f"Node: {self.pp()}\n"
+                f"Parent: {self.parent.pp() if self.parent else None}\n"
             )
         return self._sym_tab
 
@@ -621,6 +616,7 @@ class Module(AstDocNode):
         doc: Optional[String],
         body: Sequence[ElementStmt | String | EmptyToken],
         is_imported: bool,
+        terminals: list[Token],
         kid: Sequence[AstNode],
         stub_only: bool = False,
         registry: Optional[SemRegistry] = None,
@@ -635,6 +631,7 @@ class Module(AstDocNode):
         self.test_mod: list[Module] = []
         self.mod_deps: dict[str, Module] = {}
         self.registry = registry
+        self.terminals: list[Token] = terminals
         AstNode.__init__(self, kid=kid)
         AstDocNode.__init__(self, doc=doc)
 
@@ -642,15 +639,15 @@ class Module(AstDocNode):
     def annexable_by(self) -> Optional[str]:
         """Get annexable by."""
         if not self.stub_only and (
-            self.loc.mod_path.endswith("impl.jac")
-            or self.loc.mod_path.endswith("test.jac")
+            self.loc.mod_path.endswith(".impl.jac")
+            or self.loc.mod_path.endswith(".test.jac")
         ):
             head_mod_name = self.name.split(".")[0]
             potential_path = os.path.join(
                 os.path.dirname(self.loc.mod_path),
                 f"{head_mod_name}.jac",
             )
-            if os.path.exists(potential_path):
+            if os.path.exists(potential_path) and potential_path != self.loc.mod_path:
                 return potential_path
             annex_dir = os.path.split(os.path.dirname(self.loc.mod_path))[-1]
             if annex_dir.endswith(".impl") or annex_dir.endswith(".test"):
@@ -661,7 +658,10 @@ class Module(AstDocNode):
                     os.path.dirname(os.path.dirname(self.loc.mod_path)),
                     f"{head_mod_name}.jac",
                 )
-                if os.path.exists(potential_path):
+                if (
+                    os.path.exists(potential_path)
+                    and potential_path != self.loc.mod_path
+                ):
                     return potential_path
         return None
 

jaclang/compiler/parser.py

@@ -56,6 +56,7 @@ class JacParser(Pass):
             source=self.source,
             doc=None,
             body=[],
+            terminals=[],
             is_imported=False,
             kid=[ast.EmptyToken()],
         )
@@ -120,6 +121,7 @@ class JacParser(Pass):
             """Initialize transformer."""
             super().__init__(*args, **kwargs)
             self.parse_ref = parser
+            self.terminals: list[ast.Token] = []
 
         def ice(self) -> Exception:
             """Raise internal compiler error."""
@@ -160,6 +162,7 @@ class JacParser(Pass):
                 doc=doc,
                 body=body,
                 is_imported=False,
+                terminals=self.terminals,
                 kid=kid if len(kid) else [ast.EmptyToken()],
             )
             return self.nu(mod)
@@ -3983,4 +3986,5 @@ class JacParser(Pass):
                     err.line = ret.loc.first_line
                     err.column = ret.loc.col_start
                     raise err
+            self.terminals.append(ret)
             return self.nu(ret)

jaclang/compiler/passes/ir_pass.py

@@ -115,7 +115,7 @@ class Pass(Transform[T]):
         self.after_pass()
         self.time_taken = time.time() - start_time
         if settings.pass_timer:
-            print(
+            self.log_info(
                 f"Time taken in {self.__class__.__name__}: {self.time_taken:.4f} seconds"
             )
         return self.ir
@@ -136,21 +136,12 @@ class Pass(Transform[T]):
         self.exit_node(node)
         return node
 
-    def update_code_loc(self, node: Optional[ast.AstNode] = None) -> None:
-        """Update code location."""
-        if node is None:
-            node = self.cur_node
-        if not isinstance(node, ast.AstNode):
-            self.ice("Current node is not an AstNode.")
-
     def error(self, msg: str, node_override: Optional[ast.AstNode] = None) -> None:
         """Pass Error."""
-        self.update_code_loc(node_override)
         self.log_error(f"{msg}", node_override=node_override)
 
     def warning(self, msg: str, node_override: Optional[ast.AstNode] = None) -> None:
         """Pass Error."""
-        self.update_code_loc(node_override)
         self.log_warning(f"{msg}", node_override=node_override)
 
     def ice(self, msg: str = "Something went horribly wrong!") -> RuntimeError:
@@ -166,10 +157,10 @@ class PrinterPass(Pass):
 
     def enter_node(self, node: ast.AstNode) -> None:
         """Run on entering node."""
-        print("Entering:", node)
+        self.log_info(f"Entering: {node.__class__.__name__}: {node.loc}")
         super().enter_node(node)
 
     def exit_node(self, node: ast.AstNode) -> None:
         """Run on exiting node."""
         super().exit_node(node)
-        print("Exiting:", node)
+        self.log_info(f"Exiting: {node.__class__.__name__}: {node.loc}")

jaclang/compiler/passes/main/fuse_typeinfo_pass.py

@@ -6,7 +6,6 @@ mypy apis into Jac and use jac py ast in it.
 
 from __future__ import annotations
 
-import traceback
 from typing import Callable, TypeVar
 
 import jaclang.compiler.absyntree as ast
@@ -32,7 +31,7 @@ class FuseTypeInfoPass(Pass):
 
     def __debug_print(self, *argv: object) -> None:
         if settings.fuse_type_info_debug:
-            print("FuseTypeInfo::", *argv)
+            self.log_info("FuseTypeInfo::", *argv)
 
     def __call_type_handler(
         self, node: ast.AstSymbolNode, mypy_type: MypyTypes.ProperType
@@ -72,7 +71,9 @@ class FuseTypeInfoPass(Pass):
     ) -> Callable[[FuseTypeInfoPass, T], None]:
         def node_handler(self: FuseTypeInfoPass, node: T) -> None:
             if not isinstance(node, ast.AstSymbolNode):
-                print(f"Warning {node.__class__.__name__} is not an AstSymbolNode")
+                self.__debug_print(
+                    f"Warning {node.__class__.__name__} is not an AstSymbolNode"
+                )
 
             try:
                 jac_node_str = f'jac node "{node.loc}::{node.__class__.__name__}'
@@ -119,8 +120,6 @@ class FuseTypeInfoPass(Pass):
                 self.__debug_print(
                     f'Internal error happened while parsing "{e.obj.__class__.__name__}"'
                 )
-                traceback.print_exc()
-                print(e)
 
         return node_handler
 

jaclang/compiler/passes/main/import_pass.py

@@ -17,6 +17,9 @@ from jaclang.compiler.passes import Pass
 from jaclang.compiler.passes.main import SubNodeTabPass
 from jaclang.settings import settings
 from jaclang.utils.helpers import import_target_to_relative_path, is_standard_lib_module
+from jaclang.utils.log import logging
+
+logger = logging.getLogger(__name__)
 
 
 class JacImportPass(Pass):
@@ -182,6 +185,7 @@ class JacImportPass(Pass):
                 source=ast.JacSource("", mod_path=target),
                 doc=None,
                 body=[],
+                terminals=[],
                 is_imported=False,
                 stub_only=True,
                 kid=[ast.EmptyToken()],
@@ -203,7 +207,7 @@ class JacImportPass(Pass):
             self.warnings_had += mod_pass.warnings_had
             mod = mod_pass.ir
         except Exception as e:
-            print(e)
+            logger.info(e)
             mod = None
         if isinstance(mod, ast.Module):
             self.import_table[target] = mod
@@ -251,7 +255,6 @@ class PyImportPass(JacImportPass):
                 if spec.origin in self.import_table:
                     return self.import_table[spec.origin]
                 with open(spec.origin, "r", encoding="utf-8") as f:
-                    # print(f"\nImporting python module {node.path_str}")
                     mod = PyastBuildPass(
                         input_ir=ast.PythonModuleAst(
                             py_ast.parse(f.read()), mod_path=spec.origin

jaclang/compiler/passes/main/pyast_gen_pass.py

@@ -11,7 +11,7 @@ from typing import Optional, Sequence, TypeVar
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.constant import Constants as Con, EdgeDir, Tokens as Tok
 from jaclang.compiler.passes import Pass
-from jaclang.core.utils import extract_params, extract_type, get_sem_scope
+from jaclang.runtimelib.utils import extract_params, extract_type, get_sem_scope
 
 T = TypeVar("T", bound=ast3.AST)
 
@@ -19,24 +19,25 @@ T = TypeVar("T", bound=ast3.AST)
 class PyastGenPass(Pass):
     """Jac blue transpilation to python pass."""
 
-    @staticmethod
-    def node_compilable_test(node: ast3.AST) -> None:
-        """Convert any AST node to a compilable module node."""
-        if isinstance(node, ast3.Module):
-            pass
-        elif isinstance(node, (ast3.Expr, ast3.stmt)):
-            node = ast3.Module(body=[node], type_ignores=[])
-        elif isinstance(node, list) and all(isinstance(n, ast3.stmt) for n in node):
-            node = ast3.Module(body=node, type_ignores=[])
-        else:
-            node = ast3.Module(body=[], type_ignores=[])
-        try:
-            compile(node, "<ast>", "exec")
-        except TypeError as e:
-            print(ast3.dump(node, indent=2))
-            raise e
-        except Exception:
-            pass
+    # TODO: This should live in utils and perhaps a test added using it
+    # @staticmethod
+    # def node_compilable_test(node: ast3.AST) -> None:
+    #     """Convert any AST node to a compilable module node."""
+    #     if isinstance(node, ast3.Module):
+    #         pass
+    #     elif isinstance(node, (ast3.Expr, ast3.stmt)):
+    #         node = ast3.Module(body=[node], type_ignores=[])
+    #     elif isinstance(node, list) and all(isinstance(n, ast3.stmt) for n in node):
+    #         node = ast3.Module(body=node, type_ignores=[])
+    #     else:
+    #         node = ast3.Module(body=[], type_ignores=[])
+    #     try:
+    #         compile(node, "<ast>", "exec")
+    #     except TypeError as e:
+    #         print(ast3.dump(node, indent=2))
+    #         raise e
+    #     except Exception:
+    #         pass
 
     def before_pass(self) -> None:
         """Initialize pass."""
@@ -80,7 +81,7 @@ class PyastGenPass(Pass):
 
     def needs_jac_import(self) -> None:
         """Check if import is needed."""
-        if "jimport" in self.already_added:
+        if self.needs_jac_import.__name__ in self.already_added:
             return
         self.preamble.append(
             self.sync(
@@ -96,11 +97,11 @@ class PyastGenPass(Pass):
                 jac_node=self.ir,
             )
         )
-        self.already_added.append("jimport")
+        self.already_added.append(self.needs_jac_import.__name__)
 
     def needs_typing(self) -> None:
         """Check if enum is needed."""
-        if "typing" in self.already_added:
+        if self.needs_typing.__name__ in self.already_added:
             return
         self.preamble.append(
             self.sync(
@@ -115,11 +116,11 @@ class PyastGenPass(Pass):
                 jac_node=self.ir,
             )
         )
-        self.already_added.append("typing")
+        self.already_added.append(self.needs_typing.__name__)
 
     def needs_enum(self) -> None:
         """Check if enum is needed."""
-        if "enum" in self.already_added:
+        if self.needs_enum.__name__ in self.already_added:
             return
         self.preamble.append(
             self.sync(
@@ -134,11 +135,11 @@ class PyastGenPass(Pass):
                 jac_node=self.ir,
             )
         )
-        self.already_added.append("enum")
+        self.already_added.append(self.needs_enum.__name__)
 
     def needs_jac_feature(self) -> None:
         """Check if enum is needed."""
-        if "jac_feature" in self.already_added:
+        if self.needs_jac_feature.__name__ in self.already_added:
             return
         self.preamble.append(
             self.sync(
@@ -164,11 +165,11 @@ class PyastGenPass(Pass):
                 jac_node=self.ir,
             )
         )
-        self.already_added.append("jac_feature")
+        self.already_added.append(self.needs_jac_feature.__name__)
 
     def needs_dataclass(self) -> None:
         """Check if enum is needed."""
-        if "dataclass" in self.already_added:
+        if self.needs_dataclass.__name__ in self.already_added:
             return
         self.preamble.append(
             self.sync(
@@ -184,11 +185,11 @@ class PyastGenPass(Pass):
                 jac_node=self.ir,
             )
         )
-        self.already_added.append("dataclass")
+        self.already_added.append(self.needs_dataclass.__name__)
 
     def needs_dataclass_field(self) -> None:
         """Check if enum is needed."""
-        if "dataclass_field" in self.already_added:
+        if self.needs_dataclass_field.__name__ in self.already_added:
             return
         self.preamble.append(
             self.sync(
@@ -202,7 +203,7 @@ class PyastGenPass(Pass):
                 jac_node=self.ir,
             )
         )
-        self.already_added.append("dataclass_field")
+        self.already_added.append(self.needs_dataclass_field.__name__)
 
     def flatten(self, body: list[T | list[T] | None]) -> list[T]:
         """Flatten ast list."""
@@ -434,14 +435,7 @@ class PyastGenPass(Pass):
         body: SubNodeList[CodeBlockStmt],
         doc: Optional[String],
         """
-        if node.doc:
-            doc = self.sync(ast3.Expr(value=node.doc.gen.py_ast[0]), jac_node=node.doc)
-            if isinstance(node.body.gen.py_ast, list):
-                node.gen.py_ast = [doc] + node.body.gen.py_ast
-            else:
-                raise self.ice()
-        else:
-            node.gen.py_ast = node.body.gen.py_ast
+        node.gen.py_ast = self.resolve_stmt_block(node.body, doc=node.doc)
         if node.name:
             node.gen.py_ast = [
                 self.sync(

jaclang/compiler/passes/main/pyast_load_pass.py

@@ -124,6 +124,7 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             source=ast.JacSource("", mod_path=self.mod_path),
             doc=doc_str,
             body=valid[1:] if valid and isinstance(valid[0], ast.String) else valid,
+            terminals=[],
             is_imported=False,
             kid=valid,
         )

jaclang/compiler/passes/main/registry_pass.py

@@ -13,7 +13,7 @@ import jaclang.compiler.absyntree as ast
 from jaclang.compiler.constant import Constants as Con
 from jaclang.compiler.passes import Pass
 from jaclang.compiler.semtable import SemInfo, SemRegistry
-from jaclang.core.utils import get_sem_scope
+from jaclang.runtimelib.utils import get_sem_scope
 
 
 class RegistryPass(Pass):

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

@@ -47,8 +47,12 @@ class ImportPassPassTests(TestCase):
         state = jac_file_to_pass(
             self.fixture_abs_path("incautoimpl.jac"), JacImportPass
         )
+        count = 0
         for i in state.ir.get_all_sub_nodes(ast.Module):
-            self.assertEqual(i.annexable_by, self.fixture_abs_path("autoimpl.jac"))
+            if i.name != "autoimpl":
+                count += 1
+                self.assertEqual(i.annexable_by, self.fixture_abs_path("autoimpl.jac"))
+        self.assertEqual(count, 3)
 
     def test_py_resolve_list(self) -> None:
         """Basic test for pass."""

jaclang/compiler/passes/tool/fuse_comments_pass.py

@@ -27,7 +27,12 @@ class FuseCommentsPass(Pass):
         """Insert comment tokens into all_tokens."""
         comment_stream = iter(self.comments)  # Iterator for comments
         code_stream = iter(self.all_tokens)  # Iterator for code tokens
-        new_stream: list[ast.AstNode] = []  # New stream to hold ordered tokens
+        new_stream: list[ast.Token] = []  # New stream to hold ordered tokens
+
+        if not isinstance(self.ir, ast.Module):
+            raise self.ice(
+                f"FuseCommentsPass can only be run on a Module, not a {type(self.ir)}"
+            )
 
         try:
             next_comment = next(comment_stream)  # Get the first comment
@@ -39,12 +44,20 @@ class FuseCommentsPass(Pass):
         except StopIteration:
             next_code = None
 
+        if next_comment and (not next_code or is_comment_next(next_comment, next_code)):
+            self.ir.terminals.insert(0, next_comment)
+
         while next_comment or next_code:
             if next_comment and (
                 not next_code or is_comment_next(next_comment, next_code)
             ):
                 # Add the comment to the new stream
+                last_tok = new_stream[-1] if len(new_stream) else None
                 new_stream.append(next_comment)
+                if last_tok:
+                    self.ir.terminals.insert(
+                        self.ir.terminals.index(last_tok) + 1, next_comment
+                    )
                 try:
                     next_comment = next(comment_stream)
                 except StopIteration:
@@ -70,7 +83,6 @@ class FuseCommentsPass(Pass):
                         parent_kids.insert(insert_index, token)
                         prev_token.parent.set_kids(parent_kids)
                     else:
-                        prev_token.pp()
                         raise self.ice(
                             "Token without parent in AST should be impossible"
                         )

jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -27,6 +27,22 @@ class JacFormatPass(Pass):
         node.gen.jac = ""
         super().enter_node(node)
 
+    def token_before(self, node: ast.Token) -> Optional[ast.Token]:
+        """Token before."""
+        if not isinstance(self.ir, ast.Module):
+            raise self.ice("IR must be module. Impossible")
+        if self.ir.terminals.index(node) == 0:
+            return None
+        return self.ir.terminals[self.ir.terminals.index(node) - 1]
+
+    def token_after(self, node: ast.Token) -> Optional[ast.Token]:
+        """Token after."""
+        if not isinstance(self.ir, ast.Module):
+            raise self.ice("IR must be module. Impossible")
+        if self.ir.terminals.index(node) == len(self.ir.terminals) - 1:
+            return None
+        return self.ir.terminals[self.ir.terminals.index(node) + 1]
+
     def indent_str(self) -> str:
         """Return string for indent."""
         return " " * self.indent_size * self.indent_level
@@ -196,7 +212,7 @@ class JacFormatPass(Pass):
         items: list[T],
         """
         prev_token = None
-        for i, stmt in enumerate(node.kid):
+        for stmt in node.kid:
             if isinstance(node.parent, (ast.EnumDef, ast.Enum)) and stmt.gen.jac == ",":
                 self.indent_level -= 1
                 self.emit_ln(node, f"{stmt.gen.jac}")
@@ -220,40 +236,15 @@ class JacFormatPass(Pass):
                     self.emit_ln(node, "")
                     self.indent_level += 1
                 if stmt.name == Tok.LBRACE:
-                    next_kid = node.kid[i + 1]
-                    if isinstance(next_kid, ast.CommentToken) and next_kid.is_inline:
-                        self.emit(node, f" {stmt.value}")
-                    else:
-                        self.emit(node, f" {stmt.value}")
+                    self.emit(node, f" {stmt.value}")
                 elif stmt.name == Tok.RBRACE:
                     if self.indent_level > 0:
                         self.indent_level -= 1
                     if stmt.parent and stmt.parent.gen.jac.strip() == "{":
-                        self.emit_ln(node, stmt.gen.jac.strip())
-                    elif (
-                        stmt.parent
-                        and stmt.parent.parent
-                        and isinstance(
-                            stmt.parent.parent,
-                            (ast.ElseIf, ast.IfStmt, ast.IterForStmt, ast.TryStmt),
-                        )
-                    ):
                         self.emit(node, f"{stmt.value}")
                     else:
-                        next_kid = (
-                            node.kid[i + 1]
-                            if i < (len(node.kid) - 1)
-                            else ast.EmptyToken()
-                        )
-                        if (
-                            isinstance(next_kid, ast.CommentToken)
-                            and next_kid.is_inline
-                        ):
-                            self.emit(node, f" {stmt.value}")
-                        elif not (node.gen.jac).endswith("\n"):
-                            self.indent_level -= 1
+                        if not (node.gen.jac).endswith("\n"):
                             self.emit_ln(node, "")
-                            self.indent_level += 1
                             self.emit(node, f"{stmt.value}")
                         else:
                             self.emit(node, f"{stmt.value}")
@@ -1392,8 +1383,12 @@ class JacFormatPass(Pass):
                     self.emit(node, i.gen.jac)
                     if isinstance(prev_token, ast.Semi):
                         self.emit_ln(node, "")
+                elif (tok := self.token_before(i)) and (i.line_no - tok.line_no > 1):
+                    self.emit_ln(node, "")
+                    self.emit_ln(node, i.gen.jac)
                 else:
                     self.emit_ln(node, i.gen.jac)
+                    self.emit_ln(node, "")
             elif isinstance(i, ast.Semi):
                 self.emit(node, f"{i.gen.jac} ")
             elif isinstance(i, ast.SubNodeList) and i.gen.jac.startswith("@"):

jaclang/compiler/passes/transform.py

@@ -70,3 +70,7 @@ class Transform(ABC, Generic[T]):
         )
         self.warnings_had.append(alrt)
         self.logger.warning(str(alrt))
+
+    def log_info(self, msg: str) -> None:
+        """Log info."""
+        self.logger.info(msg)

jaclang/compiler/semtable.py

@@ -127,9 +127,11 @@ class SemRegistry:
                 break
         return i
 
-    def pp(self) -> None:
+    def pp(self) -> str:
         """Pretty print the registry."""
+        ret_str = ""
         for k, v in self.registry.items():
-            print(k)
+            ret_str += f"{k}\n"
             for i in v:
-                print(f"  {i.name} {i.type} {i.semstr}")
+                ret_str += f"  {i.name} {i.type} {i.semstr}\n"
+        return ret_str