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

jaclang/compiler/passes/main/pyjac_ast_link_pass.py

@@ -14,6 +14,7 @@ relationships between the two AST representations throughout the compilation pro
 """
 
 import ast as ast3
+from typing import Sequence
 
 import jaclang.compiler.unitree as uni
 from jaclang.compiler.passes import UniPass
@@ -50,7 +51,7 @@ class PyJacAstLinkPass(UniPass):
             self.link_jac_py_nodes(jac_node=node.body, py_nodes=node.gen.py_ast)
 
     def exit_impl_def(self, node: uni.ImplDef) -> None:
-        for i in node.target.items:
+        for i in node.target:
             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
@@ -62,12 +63,12 @@ class PyJacAstLinkPass(UniPass):
 
         if isinstance(node.decl_link, uni.Ability) and node.decl_link.signature:
             if isinstance(node.spec, uni.FuncSignature) and node.spec.params:
-                for src_prm in node.spec.params.items:
+                for src_prm in node.spec.params:
                     if (
                         isinstance(node.decl_link.signature, uni.FuncSignature)
                         and node.decl_link.signature.params
                     ):
-                        for trg_prm in node.decl_link.signature.params.items:
+                        for trg_prm in node.decl_link.signature.params:
                             if src_prm.name.sym_name == trg_prm.name.sym_name:
                                 self.link_jac_py_nodes(
                                     jac_node=src_prm, py_nodes=trg_prm.gen.py_ast
@@ -88,9 +89,9 @@ class PyJacAstLinkPass(UniPass):
                 )
 
         if isinstance(node.decl_link, uni.Ability) and isinstance(
-            node.target, uni.SubNodeList
+            node.target, Sequence
         ):
-            for arch in node.target.items:
+            for arch in node.target:
                 if arch.name_spec.name_of.sym:
                     arch.name_spec.name_of.sym.add_use(arch.name_spec)
 
@@ -107,11 +108,11 @@ class PyJacAstLinkPass(UniPass):
             self.link_jac_py_nodes(jac_node=node.alias, py_nodes=node.gen.py_ast)
 
     def exit_global_stmt(self, node: uni.GlobalStmt) -> None:
-        for x, y in enumerate(node.target.items):
+        for x, y in enumerate(node.target):
             self.link_jac_py_nodes(jac_node=y, py_nodes=[node.gen.py_ast[x]])
 
     def exit_non_local_stmt(self, node: uni.NonLocalStmt) -> None:
-        for x, y in enumerate(node.target.items):
+        for x, y in enumerate(node.target):
             self.link_jac_py_nodes(jac_node=y, py_nodes=[node.gen.py_ast[x]])
 
     def exit_k_w_pair(self, node: uni.KWPair) -> None:

jaclang/compiler/passes/main/sym_tab_build_pass.py

@@ -54,7 +54,7 @@ class SymTabBuildPass(UniPass):
 
     def exit_global_vars(self, node: uni.GlobalVars) -> None:
         for i in self.get_all_sub_nodes(node, uni.Assignment):
-            for j in i.target.items:
+            for j in i.target:
                 if isinstance(j, uni.AstSymbolNode):
                     j.sym_tab.def_insert(j, access_spec=node, single_decl="global var")
                 else:
@@ -75,12 +75,12 @@ class SymTabBuildPass(UniPass):
     def exit_module_path(self, node: uni.ModulePath) -> None:
         if node.alias:
             node.alias.sym_tab.def_insert(node.alias, single_decl="import")
-        elif node.path and isinstance(node.path.items[0], uni.Name):
+        elif node.path and isinstance(node.path[0], uni.Name):
             if node.parent_of_type(uni.Import) and not (
                 node.parent_of_type(uni.Import).from_loc
                 and node.parent_of_type(uni.Import).is_jac
             ):
-                node.path.items[0].sym_tab.def_insert(node.path.items[0])
+                node.path[0].sym_tab.def_insert(node.path[0])
         else:
             pass  # Need to support pythonic import symbols with dots in it
 

jaclang/compiler/passes/main/sym_tab_link_pass.py

@@ -97,15 +97,15 @@ class SymTabLinkPass(Transform[uni.Module, uni.Module]):
 
     def _is_all_import(self, imp_node: uni.Import, node: uni.ModulePath) -> bool:
         """Determine if this is an all import (import everything from module)."""
-        return (
-            imp_node.is_jac and node.parent and isinstance(node.parent, uni.SubNodeList)
-        ) or (imp_node.is_py and imp_node.from_loc is None and not imp_node.is_absorb)
+        return (imp_node.is_jac and node in imp_node.items) or (
+            imp_node.is_py and imp_node.from_loc is None and not imp_node.is_absorb
+        )
 
     def _get_imported_symbols(self, node: uni.ModulePath) -> list[str]:
         """Get list of specific symbols being imported."""
         symbols = []
         if node.parent and isinstance(node.parent, uni.Import):
-            for mod_items in node.parent.items.items:
+            for mod_items in node.parent.items:
                 if isinstance(mod_items, uni.ModuleItem):
                     symbols.append(mod_items.name.value)
         return symbols

jaclang/compiler/passes/main/tests/fixtures/symtab_link_tests/action/actions.jac

@@ -1,5 +1,3 @@
-
-
 node LLM{
 
     can infer with AgentNode entry{
@@ -9,15 +7,13 @@ node LLM{
     def testing_infer {
         return "LLM's response";
     }
-
 }
 
 
-obj AgentNode{
+walker Agent{
     has describ :str = "AgentNode";
 
     can connect with LLM entry{
         return "AgentNode's response";
-
     }
 }

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

@@ -1,14 +1,7 @@
-
-
-
 import from action {actions}
 
-
 with entry{
-
         openai = actions.LLM();
-        agent = actions.AgentNode();
+        agent = actions.Agent();
         print("openai: response: ", openai.testing_infer());
-
-
 }

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

@@ -3,8 +3,10 @@
 from jaclang.compiler.passes.main import CompilerMode as CMode
 from jaclang.compiler.program import JacProgram
 from jaclang.utils.test import TestCase
+import unittest
 
 
+@unittest.skip("Skipping CFG build pass tests")
 class TestCFGBuildPass(TestCase):
     """Test FuseTypeInfoPass module."""
 
@@ -30,7 +32,7 @@ class TestCFGBuildPass(TestCase):
             prog=prog,
         )
 
-        dot = cfg_pass.dotgen_cfg()
+        dot = cfg_pass.printgraph_cfg()
 
         expected_dot = (
             "digraph G {\n"
@@ -78,7 +80,7 @@ class TestCFGBuildPass(TestCase):
             prog=prog,
         )
 
-        dot = cfg_pass.dotgen_cfg()
+        dot = cfg_pass.printgraph_cfg()
 
         expected_dot = (
             "digraph G {\n"

jaclang/compiler/passes/tool/doc_ir_gen_pass.py

@@ -3,7 +3,7 @@
 This is a pass for generating DocIr for Jac code.
 """
 
-from typing import List, Optional
+from typing import List, Optional, Sequence
 
 import jaclang.compiler.passes.tool.doc_ir as doc
 import jaclang.compiler.unitree as uni
@@ -139,12 +139,7 @@ class DocIRGenPass(UniPass):
         """Exit import node."""
         parts: list[doc.DocType] = []
         for i in node.kid:
-            if isinstance(i, uni.SubNodeList) and i.items:
-                parts.append(
-                    self.indent(self.concat([self.tight_line(), i.gen.doc_ir]))
-                )
-                parts.append(self.line())
-            elif isinstance(i, uni.Token) and i.name == Tok.SEMI:
+            if isinstance(i, uni.Token) and i.name == Tok.SEMI:
                 parts.pop()
                 parts.append(i.gen.doc_ir)
             else:
@@ -179,13 +174,38 @@ class DocIRGenPass(UniPass):
     def exit_archetype(self, node: uni.Archetype) -> None:
         """Generate DocIR for archetypes."""
         parts: list[doc.DocType] = []
+        body_parts: list[doc.DocType] = []
+        prev_item = None
+        in_body = False
         for i in node.kid:
-            if i in [node.doc, node.decorators]:
+            if (node.doc and i is node.doc) or (
+                node.decorators and i in node.decorators
+            ):
                 parts.append(i.gen.doc_ir)
                 parts.append(self.hard_line())
             elif i == node.name:
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
+            elif isinstance(i, uni.Token) and i.name == Tok.LBRACE:
+                parts.append(i.gen.doc_ir)
+            elif isinstance(node.body, Sequence) and i in node.body:
+                if not in_body:
+                    body_parts.append(self.hard_line())
+                if (prev_item and type(prev_item) is not type(i)) or (
+                    prev_item and not self.is_one_line(prev_item)
+                ):
+                    body_parts.append(self.hard_line())
+                body_parts.append(i.gen.doc_ir)
+                body_parts.append(self.hard_line())
+                prev_item = i
+                in_body = True
+            elif in_body:
+                in_body = False
+                body_parts.pop()
+                parts.append(self.indent(self.concat(body_parts)))
+                parts.append(self.hard_line())
+                parts.append(i.gen.doc_ir)
+                parts.append(self.space())
             elif isinstance(i, uni.Token) and i.name == Tok.SEMI:
                 parts.pop()
                 parts.append(i.gen.doc_ir)
@@ -193,39 +213,72 @@ class DocIRGenPass(UniPass):
             else:
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
+
         node.gen.doc_ir = self.finalize(parts)
 
     def exit_ability(self, node: uni.Ability) -> None:
         """Generate DocIR for abilities."""
         parts: list[doc.DocType] = []
+        body_parts: list[doc.DocType] = []
+        in_body = False
         for i in node.kid:
-            if i in [node.doc, node.decorators]:
+            if i == node.doc or (node.decorators and i in node.decorators):
                 parts.append(i.gen.doc_ir)
                 parts.append(self.hard_line())
             elif i == node.name_ref:
                 parts.append(i.gen.doc_ir)
                 if not isinstance(node.signature, uni.FuncSignature):
                     parts.append(self.space())
+            elif isinstance(node.body, Sequence) and i in node.body:
+                if not in_body:
+                    parts.pop()
+                    body_parts.append(self.hard_line())
+                body_parts.append(i.gen.doc_ir)
+                body_parts.append(self.hard_line())
+                in_body = True
+            elif in_body:
+                in_body = False
+                body_parts.pop()
+                parts.append(self.indent(self.concat(body_parts)))
+                parts.append(self.hard_line())
+                parts.append(i.gen.doc_ir)
+                parts.append(self.space())
             elif isinstance(i, uni.Token) and i.name == Tok.SEMI:
                 parts.pop()
                 parts.append(i.gen.doc_ir)
+                parts.append(self.space())
             else:
                 parts.append(i.gen.doc_ir)
-                if not isinstance(i, uni.CommentToken):
-                    parts.append(self.space())
+                parts.append(self.space())
         node.gen.doc_ir = self.finalize(parts)
 
     def exit_func_signature(self, node: uni.FuncSignature) -> None:
         """Generate DocIR for function signatures."""
         parts: list[doc.DocType] = []
+        indent_parts: list[doc.DocType] = []
+        in_params = False
         for i in node.kid:
-            if isinstance(i, uni.Token) and i.name == Tok.LPAREN:
+            if isinstance(i, uni.Token) and i.name == Tok.LPAREN and node.params:
+                in_params = True
                 parts.append(i.gen.doc_ir)
-            elif i == node.params:
+            elif isinstance(i, uni.Token) and i.name == Tok.RPAREN and node.params:
+                in_params = False
                 parts.append(
-                    self.indent(self.concat([self.tight_line(), i.gen.doc_ir]))
+                    self.indent(self.concat([self.tight_line(), *indent_parts]))
                 )
                 parts.append(self.tight_line())
+                parts.append(i.gen.doc_ir)
+                parts.append(self.space())
+            elif isinstance(i, uni.Token) and i.name == Tok.RPAREN:
+                parts.pop()
+                parts.append(i.gen.doc_ir)
+                parts.append(self.space())
+            elif in_params:
+                if isinstance(i, uni.Token) and i.name == Tok.COMMA:
+                    indent_parts.append(i.gen.doc_ir)
+                    indent_parts.append(self.space())
+                else:
+                    indent_parts.append(i.gen.doc_ir)
             else:
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
@@ -254,7 +307,7 @@ class DocIRGenPass(UniPass):
         """Generate DocIR for assignments."""
         parts: list[doc.DocType] = []
         for i in node.kid:
-            if isinstance(i, uni.Token) and i.name == Tok.SEMI:
+            if i == node.type_tag or (isinstance(i, uni.Token) and i.name == Tok.SEMI):
                 parts.pop()
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
@@ -266,25 +319,88 @@ class DocIRGenPass(UniPass):
     def exit_if_stmt(self, node: uni.IfStmt) -> None:
         """Generate DocIR for if statements."""
         parts: list[doc.DocType] = []
+        body_parts: list[doc.DocType] = []
+        in_body = False
         for i in node.kid:
-            parts.append(i.gen.doc_ir)
-            parts.append(self.space())
+            if isinstance(node.body, Sequence) and i in node.body:
+                if not in_body:
+                    parts.pop()
+                    body_parts.append(self.hard_line())
+                body_parts.append(i.gen.doc_ir)
+                body_parts.append(self.hard_line())
+                in_body = True
+            elif in_body:
+                in_body = False
+                body_parts.pop()
+                parts.append(self.indent(self.concat(body_parts)))
+                parts.append(self.hard_line())
+                parts.append(i.gen.doc_ir)
+                parts.append(self.space())
+            elif isinstance(i, uni.Token) and i.name == Tok.SEMI:
+                parts.pop()
+                parts.append(i.gen.doc_ir)
+                parts.append(self.space())
+            else:
+                parts.append(i.gen.doc_ir)
+                parts.append(self.space())
         node.gen.doc_ir = self.finalize(parts)
 
     def exit_else_if(self, node: uni.ElseIf) -> None:
         """Generate DocIR for else if statements."""
         parts: list[doc.DocType] = []
+        body_parts: list[doc.DocType] = []
+        in_body = False
         for i in node.kid:
-            parts.append(i.gen.doc_ir)
-            parts.append(self.space())
+            if isinstance(node.body, Sequence) and i in node.body:
+                if not in_body:
+                    parts.pop()
+                    body_parts.append(self.hard_line())
+                body_parts.append(i.gen.doc_ir)
+                body_parts.append(self.hard_line())
+                in_body = True
+            elif in_body:
+                in_body = False
+                body_parts.pop()
+                parts.append(self.indent(self.concat(body_parts)))
+                parts.append(self.hard_line())
+                parts.append(i.gen.doc_ir)
+                parts.append(self.space())
+            elif isinstance(i, uni.Token) and i.name == Tok.SEMI:
+                parts.pop()
+                parts.append(i.gen.doc_ir)
+                parts.append(self.space())
+            else:
+                parts.append(i.gen.doc_ir)
+                parts.append(self.space())
         node.gen.doc_ir = self.finalize(parts)
 
     def exit_else_stmt(self, node: uni.ElseStmt) -> None:
         """Generate DocIR for else statements."""
         parts: list[doc.DocType] = []
+        body_parts: list[doc.DocType] = []
+        in_body = False
         for i in node.kid:
-            parts.append(i.gen.doc_ir)
-            parts.append(self.space())
+            if isinstance(node.body, Sequence) and i in node.body:
+                if not in_body:
+                    parts.pop()
+                    body_parts.append(self.hard_line())
+                body_parts.append(i.gen.doc_ir)
+                body_parts.append(self.hard_line())
+                in_body = True
+            elif in_body:
+                in_body = False
+                body_parts.pop()
+                parts.append(self.indent(self.concat(body_parts)))
+                parts.append(self.hard_line())
+                parts.append(i.gen.doc_ir)
+                parts.append(self.space())
+            elif isinstance(i, uni.Token) and i.name == Tok.SEMI:
+                parts.pop()
+                parts.append(i.gen.doc_ir)
+                parts.append(self.space())
+            else:
+                parts.append(i.gen.doc_ir)
+                parts.append(self.space())
         node.gen.doc_ir = self.finalize(parts)
 
     def exit_binary_expr(self, node: uni.BinaryExpr) -> None:
@@ -298,18 +414,8 @@ class DocIRGenPass(UniPass):
     def exit_expr_stmt(self, node: uni.ExprStmt) -> None:
         """Generate DocIR for expression statements."""
         parts: list[doc.DocType] = []
-        is_fstring = (
-            node.parent
-            and isinstance(node.parent, uni.SubNodeList)
-            and node.parent.parent
-            and isinstance(node.parent.parent, uni.FString)
-        )
         for i in node.kid:
-            if is_fstring:
-                parts.append(self.text("{"))
             parts.append(i.gen.doc_ir)
-            if is_fstring:
-                parts.append(self.text("}"))
         node.gen.doc_ir = self.group(self.concat(parts))
 
     def exit_concurrent_expr(self, node: uni.ConcurrentExpr) -> None:
@@ -335,8 +441,27 @@ class DocIRGenPass(UniPass):
     def exit_func_call(self, node: uni.FuncCall) -> None:
         """Generate DocIR for function calls."""
         parts: list[doc.DocType] = []
+        indent_parts: list[doc.DocType] = []
+        in_params = False
         for i in node.kid:
-            parts.append(i.gen.doc_ir)
+            if isinstance(i, uni.Token) and i.name == Tok.LPAREN and node.params:
+                in_params = True
+                parts.append(i.gen.doc_ir)
+            elif isinstance(i, uni.Token) and i.name == Tok.RPAREN and node.params:
+                in_params = False
+                parts.append(
+                    self.indent(self.concat([self.tight_line(), *indent_parts]))
+                )
+                parts.append(self.tight_line())
+                parts.append(i.gen.doc_ir)
+            elif in_params:
+                if isinstance(i, uni.Token) and i.name == Tok.COMMA:
+                    indent_parts.append(i.gen.doc_ir)
+                    indent_parts.append(self.space())
+                else:
+                    indent_parts.append(i.gen.doc_ir)
+            else:
+                parts.append(i.gen.doc_ir)
         node.gen.doc_ir = self.group(self.concat(parts))
 
     def exit_atom_trailer(self, node: uni.AtomTrailer) -> None:
@@ -395,12 +520,10 @@ class DocIRGenPass(UniPass):
             if i == node.doc:
                 parts.append(i.gen.doc_ir)
                 parts.append(self.hard_line())
-            elif (
-                isinstance(i, uni.SubNodeList)
-                and i == node.vars
-                and isinstance(i.gen.doc_ir, doc.Concat)
-            ):
-                parts.append(self.align(i.gen.doc_ir))
+            elif isinstance(i, uni.Token) and i.name == Tok.SEMI:
+                parts.pop()
+                parts.append(i.gen.doc_ir)
+                parts.append(self.space())
             else:
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
@@ -472,12 +595,7 @@ class DocIRGenPass(UniPass):
         """Generate DocIR for set values."""
         parts: list[doc.DocType] = []
         for i in node.kid:
-            if isinstance(i, uni.Token):
-                parts.append(i.gen.doc_ir)
-            elif isinstance(i, uni.SubNodeList):
-                parts.append(self.if_break(self.line(), self.space()))
-                parts.append(i.gen.doc_ir)
-                parts.append(self.if_break(self.line(), self.space()))
+            parts.append(i.gen.doc_ir)
 
         node.gen.doc_ir = self.group(self.concat(parts))
 
@@ -722,21 +840,40 @@ class DocIRGenPass(UniPass):
     def exit_module_code(self, node: uni.ModuleCode) -> None:
         """Generate DocIR for module code."""
         parts: list[doc.DocType] = []
+        body_parts: list[doc.DocType] = []
+        in_body = False
         for i in node.kid:
-            if i == node.doc:
+            if node.doc and i is node.doc:
                 parts.append(i.gen.doc_ir)
                 parts.append(self.hard_line())
-            elif isinstance(i, uni.Token):
+            elif i == node.name:
+                parts.append(i.gen.doc_ir)
+                parts.append(self.space())
+            elif isinstance(node.body, Sequence) and i in node.body:
+                if not in_body:
+                    parts.pop()
+                    body_parts.append(self.hard_line())
+                body_parts.append(i.gen.doc_ir)
+                body_parts.append(self.hard_line())
+                in_body = True
+            elif in_body:
+                in_body = False
+                body_parts.pop()
+                parts.append(self.indent(self.concat(body_parts)))
+                parts.append(self.hard_line())
+                parts.append(i.gen.doc_ir)
+                parts.append(self.space())
+            elif isinstance(i, uni.Token) and i.name == Tok.SEMI:
+                parts.pop()
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
             else:
-                parts.append(self.concat([i.gen.doc_ir]))
-
-        node.gen.doc_ir = self.group(self.concat(parts))
+                parts.append(i.gen.doc_ir)
+                parts.append(self.space())
+        node.gen.doc_ir = self.finalize(parts)
 
     def exit_global_stmt(self, node: uni.GlobalStmt) -> None:
         """Generate DocIR for global statements."""
-        # node.kid is [GLOBAL_OP_token, name_list_SubNodeList, SEMI_token]
         parts: list[doc.DocType] = []
         for i in node.kid:
             parts.append(i.gen.doc_ir)
@@ -1000,15 +1137,20 @@ class DocIRGenPass(UniPass):
         """Generate DocIR for match architecture patterns."""
         parts: list[doc.DocType] = []
         for i in node.kid:
-            parts.append(i.gen.doc_ir)
-            parts.append(self.space())
+            if isinstance(i, uni.Token) and i.name == Tok.COMMA:
+                parts.append(i.gen.doc_ir)
+                parts.append(self.space())
+            else:
+                parts.append(i.gen.doc_ir)
         node.gen.doc_ir = self.finalize(parts)
 
     def exit_enum(self, node: uni.Enum) -> None:
         """Generate DocIR for enum declarations."""
         parts: list[doc.DocType] = []
         for i in node.kid:
-            if i in [node.doc, node.decorators]:
+            if (node.doc and i is node.doc) or (
+                node.decorators and i in node.decorators
+            ):
                 parts.append(i.gen.doc_ir)
                 parts.append(self.hard_line())
             elif isinstance(i, uni.Token) and i.name == Tok.SEMI:
@@ -1028,74 +1170,11 @@ class DocIRGenPass(UniPass):
             parts.append(self.space())
         node.gen.doc_ir = self.finalize(parts)
 
-    def exit_sub_node_list(self, node: uni.SubNodeList) -> None:
-        """Generate DocIR for a SubNodeList."""
-        parts: list[doc.DocType] = []
-        indent_parts: list[doc.DocType] = []
-        prev_item: Optional[uni.UniNode] = None
-        in_codeblock = node.delim and node.delim.name == Tok.WS
-        in_archetype = (
-            node.parent
-            and isinstance(node.parent, (uni.Archetype, uni.Enum))
-            and node == node.parent.body
-        )
-        is_assignment = node.delim and node.delim.name == Tok.EQ
-        for i in node.kid:
-            if i == node.left_enc:
-                parts.append(i.gen.doc_ir)
-                indent_parts.append(self.hard_line())
-            elif i == node.right_enc:
-                if in_codeblock:
-                    indent_parts.pop()
-                parts.append(self.indent(self.concat(indent_parts)))
-                if prev_item != node.left_enc:
-                    parts.append(self.line())
-                parts.append(i.gen.doc_ir)
-            elif (
-                isinstance(i, uni.Token)
-                and node.delim
-                and i.name == node.delim.name
-                and i.name not in [Tok.DOT, Tok.DECOR_OP]
-            ):
-                indent_parts.append(i.gen.doc_ir)
-                indent_parts.append(self.line())
-            else:
-                if (
-                    in_codeblock
-                    and prev_item
-                    and self.has_gap(prev_item, i)
-                    and isinstance(i, uni.CommentToken)
-                    and (
-                        not in_archetype
-                        or not prev_item
-                        or not (
-                            self.is_one_line(prev_item) and type(prev_item) is type(i)
-                        )
-                    )
-                ) or (
-                    in_archetype
-                    and prev_item not in [None, node.left_enc, node.right_enc]
-                    and (
-                        type(prev_item) is not type(i)
-                        or (prev_item and not self.is_one_line(prev_item))
-                    )
-                ):
-                    indent_parts.append(self.hard_line())
-                indent_parts.append(i.gen.doc_ir)
-                if in_codeblock:
-                    indent_parts.append(self.hard_line())
-                elif is_assignment:
-                    indent_parts.append(self.space())
-            prev_item = i
-        if is_assignment:
-            indent_parts.pop()
-        node.gen.doc_ir = self.concat(parts) if parts else self.concat(indent_parts)
-
     def exit_impl_def(self, node: uni.ImplDef) -> None:
         """Generate DocIR for implementation definitions."""
         parts: list[doc.DocType] = []
         for i in node.kid:
-            if i in [node.doc, node.decorators]:
+            if i == node.doc or (node.decorators and i in node.decorators):
                 parts.append(i.gen.doc_ir)
                 parts.append(self.hard_line())
             elif i == node.target:
@@ -1154,9 +1233,7 @@ class DocIRGenPass(UniPass):
         is_escaped_curly = (
             node.lit_value in ["{", "}"]
             and node.parent
-            and isinstance(node.parent, uni.SubNodeList)
-            and node.parent.parent
-            and isinstance(node.parent.parent, uni.FString)
+            and isinstance(node.parent, uni.FString)
         )
 
         if "\n" in node.value:

jaclang/compiler/program.py

@@ -61,17 +61,12 @@ class JacProgram:
         self.errors_had: list[Alert] = []
         self.warnings_had: list[Alert] = []
 
-    def get_bytecode(
-        self, full_target: str, full_compile: bool = True
-    ) -> Optional[types.CodeType]:
+    def get_bytecode(self, full_target: str) -> Optional[types.CodeType]:
         """Get the bytecode for a specific module."""
         if full_target in self.mod.hub:
             codeobj = self.mod.hub[full_target].gen.py_bytecode
             return marshal.loads(codeobj) if isinstance(codeobj, bytes) else None
-        result = self.compile(
-            file_path=full_target,
-            mode=CompilerMode.COMPILE if full_compile else CompilerMode.COMPILE_SINGLE,
-        )
+        result = self.compile(file_path=full_target, mode=CompilerMode.COMPILE_SINGLE)
         return marshal.loads(result.gen.py_bytecode) if result.gen.py_bytecode else None
 
     def compile(