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

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,
         )
@@ -143,12 +144,15 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             if sys.version_info >= (3, 12):
             type_params: list[type_param]
         """
+        from jaclang.compiler import TOKEN_MAP
+
+        reserved_keywords = [v for _, v in TOKEN_MAP.items()]
+
+        value = node.name if node.name not in reserved_keywords else f"<>{node.name}"
         name = ast.Name(
             file_path=self.mod_path,
             name=Tok.NAME,
-            value=(
-                node.name if node.name != "root" else "root_"
-            ),  # root is a reserved keyword
+            value=value,
             line=node.lineno,
             end_line=node.end_lineno if node.end_lineno else node.lineno,
             col_start=node.col_offset,
@@ -1874,10 +1878,19 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
         id: _Identifier
         ctx: expr_context
         """
+        from jaclang.compiler import TOKEN_MAP
+
+        reserved_keywords = [
+            v
+            for _, v in TOKEN_MAP.items()
+            if v not in ["float", "int", "str", "bool", "self"]
+        ]
+
+        value = node.id if node.id not in reserved_keywords else f"<>{node.id}"
         ret = ast.Name(
             file_path=self.mod_path,
             name=Tok.NAME,
-            value=node.id if node.id != "root" else "root_",  # reserved word
+            value=value,
             line=node.lineno,
             end_line=node.end_lineno if node.end_lineno else node.lineno,
             col_start=node.col_offset,
@@ -1912,13 +1925,18 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
         class Nonlocal(stmt):
             names: list[_Identifier]
         """
+        from jaclang.compiler import TOKEN_MAP
+
+        reserved_keywords = [v for _, v in TOKEN_MAP.items()]
+
         names: list[ast.NameAtom] = []
         for name in node.names:
+            value = name if name not in reserved_keywords else f"<>{name}"
             names.append(
                 ast.Name(
                     file_path=self.mod_path,
                     name=Tok.NAME,
-                    value=name if name != "root" else "root_",
+                    value=value,
                     line=node.lineno,
                     end_line=node.end_lineno if node.end_lineno else node.lineno,
                     col_start=node.col_offset,
@@ -2237,10 +2255,19 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             arg: _Identifier
             annotation: expr | None
         """
+        from jaclang.compiler import TOKEN_MAP
+
+        reserved_keywords = [
+            v
+            for _, v in TOKEN_MAP.items()
+            if v not in ["float", "int", "str", "bool", "self"]
+        ]
+
+        value = node.arg if node.arg not in reserved_keywords else f"<>{node.arg}"
         name = ast.Name(
             file_path=self.mod_path,
             name=Tok.NAME,
-            value=node.arg if node.arg != "root" else "root_",  # reserved word
+            value=value,
             line=node.lineno,
             end_line=node.end_lineno if node.end_lineno else node.lineno,
             col_start=node.col_offset,

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):
@@ -46,6 +46,7 @@ class RegistryPass(Pass):
         """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 "",
@@ -61,7 +62,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 ""
+            node, node.name.value, "Enum", node.semstr.lit_value if node.semstr else ""
         )
         if (
             len(self.modules_visited)
@@ -77,6 +78,38 @@ class RegistryPass(Pass):
         )
         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 "",
@@ -94,6 +127,7 @@ class RegistryPass(Pass):
         )
         scope = get_sem_scope(node)
         seminfo = SemInfo(
+            node,
             (
                 node.target.items[0].value
                 if isinstance(node.target.items[0], ast.Name)
@@ -113,7 +147,7 @@ class RegistryPass(Pass):
             and node.parent.parent.__class__.__name__ == "Enum"
         ):
             scope = get_sem_scope(node)
-            seminfo = SemInfo(node.value, None, "")
+            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)
 

jaclang/compiler/passes/main/sym_tab_build_pass.py

@@ -193,7 +193,7 @@ class SymTabBuildPass(Pass):
         if not node.is_absorb:
             for i in node.items.items:
                 i.sym_tab.def_insert(i, single_decl="import item")
-        elif node.is_absorb and node.hint.tag.value == "jac":
+        elif node.is_absorb and node.is_jac:
             source = node.items.items[0]
             if not isinstance(source, ast.ModulePath) or not source.sub_module:
                 self.error(

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

@@ -1 +1 @@
-"""Tests for Jac passes."""
+"""Various tests for Jac passes."""

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/main/type_check_pass.py

@@ -49,7 +49,14 @@ class JacTypeCheckPass(Pass):
         """Call mypy APIs to implement type checking in Jac."""
         # Creating mypy api objects
         options = myab.myb.Options()
+        options.ignore_missing_imports = True
         options.cache_dir = Con.JAC_MYPY_CACHE
+        options.mypy_path = [
+            str(
+                pathlib.Path(os.path.dirname(__file__)).parent.parent.parent.parent
+                / "stubs"
+            )
+        ]
         errors = myab.Errors(self, options)
         fs_cache = myab.FileSystemCache()
         search_paths = myab.compute_search_paths([], options, str(self.__path))

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

@@ -10,6 +10,7 @@ import jaclang.compiler.absyntree as ast
 from jaclang.compiler.absyntree import AstNode
 from jaclang.compiler.constant import Tokens as Tok
 from jaclang.compiler.passes import Pass
+from jaclang.settings import settings
 
 
 class JacFormatPass(Pass):
@@ -20,20 +21,37 @@ class JacFormatPass(Pass):
         self.comments: list[ast.CommentToken] = []
         self.indent_size = 4
         self.indent_level = 0
-        self.MAX_LINE_LENGTH = 44
+        self.MAX_LINE_LENGTH = int(float(settings.max_line_length) / 2)
 
     def enter_node(self, node: ast.AstNode) -> None:
         """Enter node."""
         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
 
     def emit(self, node: ast.AstNode, s: str, strip_mode: bool = True) -> None:
         """Emit code to node."""
-        node.gen.jac += self.indent_str() + s.replace("\n", "\n" + self.indent_str())
+        indented_str = re.sub(r"\n(?!\n)", f"\n{self.indent_str()}", s)
+        node.gen.jac += self.indent_str() + indented_str
         if "\n" in node.gen.jac:
             if strip_mode:
                 node.gen.jac = node.gen.jac.rstrip(" ")
@@ -113,9 +131,15 @@ class JacFormatPass(Pass):
             else:
                 if isinstance(last_element, ast.Import):
                     self.emit_ln(node, "")
-                self.emit_ln(node, i.gen.jac)
-                if not node.gen.jac.endswith("\n"):
+                if last_element and (
+                    isinstance(i, ast.Architype)
+                    and isinstance(last_element, ast.Architype)
+                    and i.loc.first_line - last_element.loc.last_line == 2
+                    and not node.gen.jac.endswith("\n\n")
+                ):
                     self.emit_ln(node, "")
+                self.emit_ln(node, i.gen.jac)
+
                 if counter <= len(node.body) - 1:
                     if (
                         isinstance(i, ast.Ability)
@@ -126,6 +150,7 @@ class JacFormatPass(Pass):
                             and len(node.body[counter].kid[-1].kid) == 2
                             and len(node.body[counter - 1].kid[-1].kid) == 2
                         )
+                        and node.gen.jac.endswith("\n")
                     ):
                         self.emit(node, "")
                     else:
@@ -196,7 +221,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,52 +245,20 @@ 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
+                    self.indent_level = max(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}")
+                        self.emit(node, f"{stmt.value}")
                 elif isinstance(stmt, ast.CommentToken):
                     if stmt.is_inline:
                         if isinstance(prev_token, ast.Semi) or (
                             isinstance(prev_token, ast.Token)
-                            and prev_token.name
-                            in [
-                                Tok.LBRACE,
-                                Tok.RBRACE,
-                            ]
+                            and prev_token.name in [Tok.LBRACE, Tok.RBRACE]
                         ):
                             self.indent_level -= 1
                             self.emit(node, f" {stmt.gen.jac}")
@@ -289,48 +282,33 @@ class JacFormatPass(Pass):
                             self.emit(node, stmt.gen.jac)
                             if not stmt.gen.jac.endswith("postinit;"):
                                 self.indent_level -= 1
+                                self.emit_ln(stmt, "")
                                 self.emit_ln(node, "")
                                 self.indent_level += 1
                 elif stmt.gen.jac == ",":
                     self.emit(node, f"{stmt.value} ")
                 elif stmt.value == "=":
                     self.emit(node, f" {stmt.value} ")
+                elif prev_token and prev_token.gen.jac.strip() == "@":
+                    self.emit_ln(node, stmt.value)
                 else:
-                    self.emit(node, f"{stmt.value}")
+                    self.emit(node, f"{stmt.gen.jac}")
                 prev_token = stmt
                 continue
             elif isinstance(stmt, ast.Semi):
                 self.emit(node, stmt.gen.jac)
-            elif isinstance(prev_token, (ast.HasVar, ast.ArchHas)) and not isinstance(
-                stmt, (ast.HasVar, ast.ArchHas)
+            elif (
+                isinstance(prev_token, (ast.HasVar, ast.ArchHas))
+                and not isinstance(stmt, (ast.HasVar, ast.ArchHas))
+            ) or (
+                isinstance(prev_token, ast.Ability)
+                and isinstance(stmt, (ast.Ability, ast.AbilityDef))
             ):
                 if not isinstance(prev_token.kid[-1], ast.CommentToken):
                     self.indent_level -= 1
                     self.emit_ln(node, "")
                     self.indent_level += 1
                 self.emit(node, stmt.gen.jac)
-            elif isinstance(prev_token, ast.Ability) and isinstance(
-                stmt, (ast.Ability, ast.AbilityDef)
-            ):
-                if not isinstance(prev_token.kid[-1], ast.CommentToken) and (
-                    stmt.body and not isinstance(stmt.body, ast.FuncCall)
-                ):
-                    self.indent_level -= 1
-                    self.emit_ln(node, "")
-                    self.indent_level += 1
-                    self.emit(node, f"{stmt.gen.jac}")
-                elif stmt.body and isinstance(
-                    stmt.body, (ast.FuncCall, ast.EventSignature)
-                ):
-                    self.indent_level -= 1
-                    self.emit_ln(node, "")
-                    self.indent_level += 1
-                    self.emit(node, stmt.gen.jac)
-                else:
-                    self.indent_level -= 1
-                    self.emit_ln(node, "")
-                    self.indent_level += 1
-                    self.emit(node, f"{stmt.gen.jac}")
             else:
                 if prev_token and prev_token.gen.jac.strip() == "{":
                     self.emit_ln(node, "")
@@ -755,7 +733,7 @@ class JacFormatPass(Pass):
                             self.indent_level += indent_val
                             indented = True
                     else:
-                        self.emit(node, f"{j.gen.jac.strip()}")
+                        self.emit(node, j.gen.jac.lstrip())
                 if indented:
                     self.indent_level -= indent_val
             else:
@@ -921,6 +899,8 @@ class JacFormatPass(Pass):
         """Check if the length of the current generated code exceeds the max line length."""
         if max_line_length == 0:
             max_line_length = self.MAX_LINE_LENGTH
+        # print(content)
+        # print(len(content))
         return len(content) > max_line_length
 
     def exit_binary_expr(self, node: ast.BinaryExpr) -> None:
@@ -970,6 +950,7 @@ class JacFormatPass(Pass):
                 self.error(
                     f"Binary operator {node.op.value} not supported in bootstrap Jac"
                 )
+        # print(node.gen)
         if isinstance(
             node.kid[-1], (ast.Semi, ast.CommentToken)
         ) and not node.gen.jac.endswith("\n"):
@@ -1102,6 +1083,9 @@ class JacFormatPass(Pass):
             if isinstance(i, ast.CommentToken):
                 if i.is_inline:
                     self.emit(node, f" {i.gen.jac}")
+                elif (tok := self.token_before(i)) and (i.line_no - tok.line_no == 1):
+                    self.emit_ln(node, "")
+                    self.emit(node, i.gen.jac)
                 else:
                     self.emit_ln(node, "")
                     self.emit_ln(node, "")
@@ -1332,38 +1316,96 @@ class JacFormatPass(Pass):
         if isinstance(node.kid[-1], (ast.Semi, ast.CommentToken)):
             self.emit_ln(node, "")
 
+    def handle_long_assignment(self, node: ast.Assignment, kid: ast.AstNode) -> None:
+        """Handle long assignment lines."""
+        parts = re.split(r"(=)", kid.gen.jac)
+        first_part = parts.pop(0).strip()
+        self.emit_ln(
+            node, f"{first_part} {parts.pop(0).strip()} {parts.pop(0).strip()}"
+        )
+        for j in range(0, len(parts) - 1, 2):
+            op = parts[j]
+            var = parts[j + 1].strip() if j + 1 < len(parts) else ""
+            if var:
+                self.indent_level += 1
+                self.emit(node, f"{op} {var}")
+                self.indent_level -= 1
+                self.emit_ln(node, "")
+            else:
+                self.indent_level += 1
+                self.emit(node, op)
+                self.indent_level -= 1
+
+    def handle_long_expression(self, node: ast.AstNode, kid: ast.AstNode) -> None:
+        """Handle long expressions with multiple operators."""
+        parts = re.split(r"(\+|\-|\*|\/)", kid.gen.jac)
+        self.emit_ln(node, f"{parts.pop(0).strip()}")
+        for j in range(0, len(parts) - 1, 2):
+            op = parts[j]
+            var = parts[j + 1].strip() if j + 1 < len(parts) else ""
+            if j < len(parts) - 2:
+                self.indent_level += 1
+                self.emit(node, f"{op} {var}")
+                self.indent_level -= 1
+                self.emit_ln(node, "")
+            else:
+                self.indent_level += 1
+                self.emit(node, f"{op} {var}")
+                self.indent_level -= 1
+
     def exit_assignment(self, node: ast.Assignment) -> None:
         """Sub objects.
 
-        target: SubNodeList[AtomType],
-        value: Optional[ExprType | YieldStmt],
-        type_tag: Optional[SubTag[ExprType]],
+        target: SubNodeList[Expr],
+        value: Optional[Expr | YieldExpr],
+        type_tag: Optional[SubTag[Expr]],
         mutable: bool = True,
-        aug_op: Optional[Token] = None
+        aug_op: Optional[Token] = None,
+        semstr: Optional[String] = None,
+        is_enum_stmt: bool = False,
         """
-        for i in node.kid:
-            if isinstance(i, ast.CommentToken):
-                if i.is_inline:
-                    self.emit(node, i.gen.jac)
+        prev_token = None
+        for kid in node.kid:
+            if isinstance(kid, ast.CommentToken):
+                if kid.is_inline:
+                    self.emit(node, kid.gen.jac)
                 else:
-                    if i.gen.jac not in [
+                    if kid.gen.jac not in [
                         "# Update any new user level buddy schedule",
                         "# Construct prompt here",
                     ]:
                         self.emit_ln(node, "")
                         self.emit_ln(node, "")
-                        self.emit_ln(node, i.gen.jac)
+                        self.emit_ln(node, kid.gen.jac)
                     else:
                         self.emit_ln(node, "")
-                        self.emit(node, i.gen.jac)
-            elif isinstance(i, ast.Token) and (
-                i.name == Tok.KW_LET or i.gen.jac == ":"
+                        self.emit(node, kid.gen.jac)
+            elif isinstance(kid, ast.Token) and (
+                kid.name == Tok.KW_LET or kid.gen.jac == ":"
             ):
-                self.emit(node, f"{i.gen.jac} ")
-            elif isinstance(i, ast.Token) and "=" in i.gen.jac:
-                self.emit(node, f" {i.gen.jac} ")
+                self.emit(node, f"{kid.gen.jac} ")
+            elif isinstance(kid, ast.Token) and "=" in kid.gen.jac:
+                self.emit(node, f" {kid.gen.jac} ")
+            elif (
+                "=" in kid.gen.jac
+                and self.is_line_break_needed(
+                    kid.gen.jac, max_line_length=self.MAX_LINE_LENGTH * 2
+                )
+                and "\n" not in kid.gen.jac
+            ):
+                self.handle_long_assignment(node, kid)
+            elif (
+                prev_token
+                and "=" in prev_token.gen.jac
+                and self.is_line_break_needed(
+                    kid.gen.jac, max_line_length=self.MAX_LINE_LENGTH * 2
+                )
+                and "\n" not in kid.gen.jac
+            ):
+                self.handle_long_expression(node, kid)
             else:
-                self.emit(node, i.gen.jac)
+                self.emit(node, kid.gen.jac)
+            prev_token = kid
         if isinstance(
             node.kid[-1], (ast.Semi, ast.CommentToken)
         ) and not node.gen.jac.endswith("\n"):
@@ -1392,8 +1434,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("@"):
@@ -2374,7 +2420,7 @@ class JacFormatPass(Pass):
         """
         self.emit(node, f"<>{node.value}" if node.is_kwesc else node.value)
 
-    def enter_float(self, node: ast.Float) -> None:
+    def exit_float(self, node: ast.Float) -> None:
         """Sub objects.
 
         name: str,
@@ -2387,7 +2433,7 @@ class JacFormatPass(Pass):
         """
         self.emit(node, node.value)
 
-    def enter_int(self, node: ast.Int) -> None:
+    def exit_int(self, node: ast.Int) -> None:
         """Sub objects.
 
         name: str,
@@ -2400,7 +2446,7 @@ class JacFormatPass(Pass):
         """
         self.emit(node, node.value)
 
-    def enter_string(self, node: ast.String) -> None:
+    def exit_string(self, node: ast.String) -> None:
         """Sub objects.
 
         name: str,
@@ -2412,7 +2458,11 @@ class JacFormatPass(Pass):
         pos_end: int,
         """
         # if string is in docstring format and spans multiple lines turn into the multiple single quoted strings
-        if "\n" in node.value and node.parent and isinstance(node.parent, ast.Expr):
+        if "\n" in node.value and (
+            node.parent
+            and isinstance(node.parent, ast.Expr)
+            and not isinstance(node.parent, ast.MultiString)
+        ):
             string_type = node.value[0:3]
             pure_string = node.value[3:-3]
             lines = pure_string.split("\n")
@@ -2430,14 +2480,14 @@ class JacFormatPass(Pass):
             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}")
+            self.emit_ln(node, f"{string_type}{lines[0].lstrip()}")
+            for line in lines[1:-1]:
+                self.emit_ln(node, line.lstrip())
+            self.emit(node, f"{lines[-1].lstrip()}{string_type}")
         else:
             self.emit(node, node.value)
 
-    def enter_bool(self, node: ast.Bool) -> None:
+    def exit_bool(self, node: ast.Bool) -> None:
         """Sub objects.
 
         name: str,