jaclang 0.8.8__py3-none-any.whl → 0.8.9__py3-none-any.whl

jaclang/compiler/parser.py

@@ -108,9 +108,14 @@ class JacParser(Transform[uni.Source, uni.Module]):
 
         def feed_current_token(iparser: jl.InteractiveParser, tok: jl.Token) -> bool:
             """Feed the current token to the parser."""
+            max_attempts = 100  # Prevent infinite loops
+            attempts = 0
             while tok.type not in iparser.accepts():
+                if attempts >= max_attempts:
+                    return False  # Give up after too many attempts
                 if not try_feed_missing_token(iparser):
                     return False
+                attempts += 1
             iparser.feed_token(tok)
             return True
 
@@ -650,11 +655,12 @@ class JacParser(Transform[uni.Source, uni.Module]):
         def sem_def(self, _: None) -> uni.SemDef:
             """Grammar rule.
 
-            sem_def: KW_SEM dotted_name EQ multistring SEMI
+            sem_def: KW_SEM dotted_name (EQ | KW_IS) STRING SEMI
             """
             self.consume_token(Tok.KW_SEM)
             target = self.extract_from_list(self.consume(list), uni.NameAtom)
-            self.consume_token(Tok.EQ)
+            if not self.match_token(Tok.KW_IS):
+                self.consume_token(Tok.EQ)
             value = self.consume(uni.String)
             self.consume_token(Tok.SEMI)
             return uni.SemDef(
@@ -1705,15 +1711,18 @@ class JacParser(Transform[uni.Source, uni.Module]):
             lambda_expr: KW_LAMBDA func_decl_params? (RETURN_HINT expression)? COLON expression
             """
             return_type: uni.Expr | None = None
+            return_hint_tok: uni.Token | None = None
             sig_kid: list[uni.UniNode] = []
             self.consume_token(Tok.KW_LAMBDA)
             params = self.match(list)
-            if self.match_token(Tok.RETURN_HINT):
+            if return_hint_tok := self.match_token(Tok.RETURN_HINT):
                 return_type = self.consume(uni.Expr)
             self.consume_token(Tok.COLON)
             body = self.consume(uni.Expr)
             if params:
                 sig_kid.extend(params)
+            if return_hint_tok:
+                sig_kid.append(return_hint_tok)
             if return_type:
                 sig_kid.append(return_type)
             signature = (
@@ -1731,7 +1740,11 @@ class JacParser(Transform[uni.Source, uni.Module]):
                 if params or return_type
                 else None
             )
-            new_kid = [i for i in self.cur_nodes if i != params and i != return_type]
+            new_kid = [
+                i
+                for i in self.cur_nodes
+                if i != params and i != return_type and i != return_hint_tok
+            ]
             new_kid.insert(1, signature) if signature else None
             return uni.LambdaExpr(
                 signature=signature,
@@ -1965,25 +1978,31 @@ class JacParser(Transform[uni.Source, uni.Module]):
                 )
             return self._binary_expr_unwind(self.cur_nodes)
 
+        def await_expr(self, _: None) -> uni.Expr:
+            """Grammar rule.
+
+            await_expr: KW_AWAIT? pipe_call
+            """
+            if self.match_token(Tok.KW_AWAIT):
+                operand = self.consume(uni.Expr)
+                return uni.AwaitExpr(
+                    target=operand,
+                    kid=self.cur_nodes,
+                )
+            return self._binary_expr_unwind(self.cur_nodes)
+
         def pipe_call(self, _: None) -> uni.Expr:
             """Grammar rule.
 
-            pipe_call: (PIPE_FWD | A_PIPE_FWD | KW_SPAWN | KW_AWAIT)? atomic_chain
+            pipe_call: (PIPE_FWD | A_PIPE_FWD | KW_SPAWN)? atomic_chain
             """
-            if len(self.cur_nodes) == 2:
-                if self.match_token(Tok.KW_AWAIT):
-                    target = self.consume(uni.Expr)
-                    return uni.AwaitExpr(
-                        target=target,
-                        kid=self.cur_nodes,
-                    )
-                elif op := self.match(uni.Token):
-                    operand = self.consume(uni.Expr)
-                    return uni.UnaryExpr(
-                        op=op,
-                        operand=operand,
-                        kid=self.cur_nodes,
-                    )
+            if len(self.cur_nodes) == 2 and (op := self.match(uni.Token)):
+                operand = self.consume(uni.Expr)
+                return uni.UnaryExpr(
+                    op=op,
+                    operand=operand,
+                    kid=self.cur_nodes,
+                )
             return self._binary_expr_unwind(self.cur_nodes)
 
         def aug_op(self, _: None) -> uni.Token:
@@ -1991,7 +2010,6 @@ class JacParser(Transform[uni.Source, uni.Module]):
 
             aug_op: RSHIFT_EQ
                    | LSHIFT_EQ
-                   | BW_NOT_EQ
                    | BW_XOR_EQ
                    | BW_OR_EQ
                    | BW_AND_EQ
@@ -2045,6 +2063,14 @@ class JacParser(Transform[uni.Source, uni.Module]):
             atomic_call: atomic_chain LPAREN param_list? by_llm? RPAREN
             """
             target = self.consume(uni.Expr)
+            gencompr = self.match(uni.GenCompr)
+            if gencompr:
+                return uni.FuncCall(
+                    target=target,
+                    params=[gencompr],
+                    genai_call=None,
+                    kid=self.cur_nodes,
+                )
             self.consume_token(Tok.LPAREN)
             params_sn = self.match(list)
             genai_call = self.match(uni.Expr)
@@ -2188,10 +2214,22 @@ class JacParser(Transform[uni.Source, uni.Module]):
 
             fstring: FSTR_START fstr_parts FSTR_END
                 | FSTR_SQ_START fstr_sq_parts FSTR_SQ_END
+                | FSTR_TRIPLE_START fstr_triple_parts FSTR_TRIPLE_END
+                | FSTR_SQ_TRIPLE_START fstr_sq_triple_parts FSTR_SQ_TRIPLE_END
             """
-            self.match_token(Tok.FSTR_START) or self.consume_token(Tok.FSTR_SQ_START)
+            (
+                self.match_token(Tok.FSTR_TRIPLE_START)
+                or self.match_token(Tok.FSTR_SQ_TRIPLE_START)
+                or self.match_token(Tok.FSTR_START)
+                or self.consume_token(Tok.FSTR_SQ_START)
+            )
             target = self.match(list)
-            self.match_token(Tok.FSTR_END) or self.consume_token(Tok.FSTR_SQ_END)
+            (
+                self.match_token(Tok.FSTR_TRIPLE_END)
+                or self.match_token(Tok.FSTR_SQ_TRIPLE_END)
+                or self.match_token(Tok.FSTR_END)
+                or self.consume_token(Tok.FSTR_SQ_END)
+            )
             return uni.FString(
                 parts=(
                     self.extract_from_list(target, (uni.String, uni.ExprStmt))
@@ -2239,6 +2277,44 @@ class JacParser(Transform[uni.Source, uni.Module]):
             ]
             return valid_parts
 
+        def fstr_triple_parts(self, _: None) -> list[uni.UniNode]:
+            """Grammar rule.
+
+            fstr_triple_parts: (FSTR_TRIPLE_PIECE | FSTR_BESC | LBRACE expression RBRACE )*
+            """
+            valid_parts: list[uni.UniNode] = [
+                (
+                    i
+                    if isinstance(i, uni.String)
+                    else (
+                        uni.ExprStmt(expr=i, in_fstring=True, kid=[i])
+                        if isinstance(i, uni.Expr)
+                        else i
+                    )
+                )
+                for i in self.cur_nodes
+            ]
+            return valid_parts
+
+        def fstr_sq_triple_parts(self, _: None) -> list[uni.UniNode]:
+            """Grammar rule.
+
+            fstr_sq_triple_parts: (FSTR_SQ_TRIPLE_PIECE | FSTR_BESC | LBRACE expression RBRACE )*
+            """
+            valid_parts: list[uni.UniNode] = [
+                (
+                    i
+                    if isinstance(i, uni.String)
+                    else (
+                        uni.ExprStmt(expr=i, in_fstring=True, kid=[i])
+                        if isinstance(i, uni.Expr)
+                        else i
+                    )
+                )
+                for i in self.cur_nodes
+            ]
+            return valid_parts
+
         def list_val(self, _: None) -> uni.ListVal:
             """Grammar rule.
 
@@ -2468,7 +2544,7 @@ class JacParser(Transform[uni.Source, uni.Module]):
         def assignment_list(self, _: None) -> list[uni.UniNode]:
             """Grammar rule.
 
-            assignment_list: (assignment_list COMMA)? (assignment | NAME)
+            assignment_list: (assignment | named_ref) (COMMA (assignment | named_ref))* COMMA?
             """
 
             def name_to_assign(name_consume: uni.NameAtom) -> uni.Assignment:
@@ -2476,15 +2552,23 @@ class JacParser(Transform[uni.Source, uni.Module]):
                     target=[name_consume], value=None, type_tag=None, kid=[name_consume]
                 )
 
-            if self.match(list):
-                self.consume_token(Tok.COMMA)
+            # Match first (assignment | named_ref)
             if self.match(uni.Assignment):
                 pass
             elif name_consume := self.match(uni.NameAtom):
                 self.cur_nodes[self.node_idx - 1] = name_to_assign(name_consume)
             else:
-                assign = self.consume(uni.Assignment)
-                self.cur_nodes[self.node_idx - 1] = assign
+                raise self.ice()
+
+            # Match (COMMA (assignment | named_ref))* COMMA?
+            while self.match_token(Tok.COMMA):
+                if self.match(uni.Assignment):
+                    pass
+                elif name_consume := self.match(uni.NameAtom):
+                    self.cur_nodes[self.node_idx - 1] = name_to_assign(name_consume)
+                else:
+                    break  # trailing comma
+
             return self.flat_cur_nodes
 
         def type_ref(self, kid: list[uni.UniNode]) -> uni.TypeRef:
@@ -2946,6 +3030,36 @@ class JacParser(Transform[uni.Source, uni.Module]):
             value = self.consume(uni.MatchPattern)
             return uni.MatchKVPair(key=pattern, value=value, kid=self.cur_nodes)
 
+        def attr_pattern(self, _: None) -> uni.MatchValue:
+            """Grammar rule.
+
+            attr_pattern: NAME (DOT NAME)+
+            """
+            name_idx = 0
+            cur_element = self.consume(uni.NameAtom)
+            name_idx += 1
+            trailer: uni.AtomTrailer | None = None
+            while dot := self.match_token(Tok.DOT):
+                target = trailer if trailer else cur_element
+                right = self.consume(uni.NameAtom)
+                name_idx += 2
+                trailer = uni.AtomTrailer(
+                    target=target,
+                    right=right,
+                    is_attr=True,
+                    is_null_ok=False,
+                    kid=[target, dot, right],
+                )
+            name = trailer if trailer else cur_element
+            if not isinstance(name, (uni.NameAtom, uni.AtomTrailer)):
+                raise TypeError(
+                    f"Expected name to be either NameAtom or AtomTrailer, got {type(name)}"
+                )
+            return uni.MatchValue(
+                value=name,
+                kid=[name, *self.flat_cur_nodes[name_idx:]],
+            )
+
         def class_pattern(self, _: None) -> uni.MatchArch:
             """Grammar rule.
 
@@ -3052,6 +3166,8 @@ class JacParser(Transform[uni.Source, uni.Module]):
                 Tok.FSTR_BESC,
                 Tok.FSTR_PIECE,
                 Tok.FSTR_SQ_PIECE,
+                Tok.FSTR_TRIPLE_PIECE,
+                Tok.FSTR_SQ_TRIPLE_PIECE,
             ]:
                 ret_type = uni.String
                 if token.type == Tok.FSTR_BESC:

jaclang/compiler/passes/main/def_use_pass.py

@@ -37,6 +37,7 @@ class DefUsePass(UniPass):
                 + node.get_all_sub_nodes(uni.DisengageStmt)
                 + node.get_all_sub_nodes(uni.EdgeOpRef)
                 + node.get_all_sub_nodes(uni.EventSignature)
+                + node.get_all_sub_nodes(uni.TypedCtxBlock)
             ):
                 i.from_walker = True
 

jaclang/compiler/passes/main/pyast_gen_pass.py

@@ -64,7 +64,6 @@ TOKEN_AST_MAP: dict[Tok, type[ast3.AST]] = {
     Tok.MINUS: ast3.Sub,
     Tok.SUB_EQ: ast3.Sub,
     Tok.BW_NOT: ast3.Invert,
-    Tok.BW_NOT_EQ: ast3.Invert,
     Tok.NOT: ast3.Not,
     Tok.EQ: ast3.NotEq,
     Tok.EE: ast3.Eq,
@@ -92,11 +91,34 @@ UNARY_OP_MAP: dict[Tok, type[ast3.unaryop]] = {
 class PyastGenPass(UniPass):
     """Jac blue transpilation to python pass."""
 
+    # Builtins that should be imported from jaclang.runtimelib.builtin
+    KNOWN_BUILTINS = {
+        "abstractmethod",
+        "ClassVar",
+        "override",
+        "printgraph",
+        "jid",
+        "jobj",
+        "grant",
+        "revoke",
+        "allroots",
+        "save",
+        "commit",
+        "NoPerm",
+        "ReadPerm",
+        "ConnectPerm",
+        "WritePerm",
+    }
+
     def before_pass(self) -> None:
+        self.child_passes: list[PyastGenPass] = []
         for i in self.ir_in.impl_mod + self.ir_in.test_mod:
-            PyastGenPass(ir_in=i, prog=self.prog)
+            child_pass = PyastGenPass(ir_in=i, prog=self.prog)
+            self.child_passes.append(child_pass)
         self.debuginfo: dict[str, list[str]] = {"jac_mods": []}
         self.already_added: list[str] = []
+        self.jaclib_imports: set[str] = set()  # Track individual jaclib imports
+        self.builtin_imports: set[str] = set()  # Track individual builtin imports
         self.preamble: list[ast3.AST] = [
             self.sync(
                 ast3.ImportFrom(
@@ -106,40 +128,6 @@ class PyastGenPass(UniPass):
                 ),
                 jac_node=self.ir_out,
             ),
-            (
-                self.sync(
-                    ast3.ImportFrom(
-                        module="jaclang.runtimelib.builtin",
-                        names=[
-                            self.sync(
-                                ast3.alias(
-                                    name="*",
-                                    asname=None,
-                                )
-                            )
-                        ],
-                        level=0,
-                    ),
-                    jac_node=self.ir_out,
-                )
-            ),
-            (
-                self.sync(
-                    ast3.ImportFrom(
-                        module="jaclang",
-                        names=[
-                            self.sync(
-                                ast3.alias(
-                                    name="JacMachineInterface",
-                                    asname=settings.pyout_jaclib_alias,
-                                )
-                            ),
-                        ],
-                        level=0,
-                    ),
-                    jac_node=self.ir_out,
-                )
-            ),
         ]
 
     def enter_node(self, node: uni.UniNode) -> None:
@@ -161,15 +149,31 @@ class PyastGenPass(UniPass):
 
     def jaclib_obj(self, obj_name: str) -> ast3.Name | ast3.Attribute:
         """Return the object from jaclib as ast node based on the import config."""
-        return self.sync(
-            ast3.Attribute(
-                value=self.sync(
-                    ast3.Name(id=settings.pyout_jaclib_alias, ctx=ast3.Load())
-                ),
-                attr=obj_name,
-                ctx=ast3.Load(),
+        if settings.library_mode:
+            self.jaclib_imports.add(obj_name)
+            return self.sync(ast3.Name(id=obj_name, ctx=ast3.Load()))
+        else:
+            self.needs_jaclib()
+            return self.sync(
+                ast3.Attribute(
+                    value=self.sync(
+                        ast3.Name(id=settings.pyout_jaclib_alias, ctx=ast3.Load())
+                    ),
+                    attr=obj_name,
+                    ctx=ast3.Load(),
+                )
             )
-        )
+
+    def builtin_name(self, name: str) -> ast3.Name:
+        """Return a builtin name and track it for importing.
+
+        Note: Some names like 'Enum' are provided by other imports (e.g., needs_enum)
+        and should not be added to builtin_imports.
+        """
+        # Enum is imported via needs_enum, not from builtins
+        if name not in ["Enum"]:
+            self.builtin_imports.add(name)
+        return self.sync(ast3.Name(id=name, ctx=ast3.Load()))
 
     def _add_preamble_once(self, key: str, node: ast3.AST) -> None:
         """Append an import statement to the preamble once."""
@@ -187,15 +191,6 @@ class PyastGenPass(UniPass):
             ),
         )
 
-    def needs_mtllm(self) -> None:
-        """Ensure byLLM is imported only once."""
-        self._add_preamble_once(
-            self.needs_mtllm.__name__,
-            ast3.Import(
-                names=[self.sync(ast3.alias(name="byllm"), jac_node=self.ir_out)]
-            ),
-        )
-
     def needs_enum(self) -> None:
         """Ensure Enum utilities are imported only once."""
         self._add_preamble_once(
@@ -221,6 +216,24 @@ class PyastGenPass(UniPass):
             ),
         )
 
+    def needs_jaclib(self) -> None:
+        """Ensure JacMachineInterface is imported only once."""
+        self._add_preamble_once(
+            self.needs_jaclib.__name__,
+            ast3.ImportFrom(
+                module="jaclang",
+                names=[
+                    self.sync(
+                        ast3.alias(
+                            name="JacMachineInterface",
+                            asname=settings.pyout_jaclib_alias,
+                        )
+                    )
+                ],
+                level=0,
+            ),
+        )
+
     def _get_sem_decorator(self, node: uni.UniNode) -> ast3.Call | None:
         """Create a semstring decorator for the given semantic strings.
 
@@ -283,7 +296,10 @@ class PyastGenPass(UniPass):
                 else {}
             )
 
-        if not semstr and not inner_semstr:
+        # Only add sem decorator if there's actual semantic content
+        if not semstr and (
+            not inner_semstr or all(not v for v in inner_semstr.values())
+        ):
             return None
 
         return self.sync(
@@ -417,6 +433,48 @@ class PyastGenPass(UniPass):
         node.gen.py_ast = node.tag.gen.py_ast
 
     def exit_module(self, node: uni.Module) -> None:
+        # Check if any child passes (impl_mod or test_mod) needed jaclib
+        for child_pass in self.child_passes:
+            if "needs_jaclib" in child_pass.already_added:
+                self.needs_jaclib()
+                break
+            # Merge jaclib and builtin imports from child passes
+            if settings.library_mode:
+                self.jaclib_imports.update(child_pass.jaclib_imports)
+            self.builtin_imports.update(child_pass.builtin_imports)
+
+        # Add builtin imports if any were used
+        if self.builtin_imports:
+            self.preamble.append(
+                self.sync(
+                    ast3.ImportFrom(
+                        module="jaclang.runtimelib.builtin",
+                        names=[
+                            self.sync(ast3.alias(name=name, asname=None))
+                            for name in sorted(self.builtin_imports)
+                        ],
+                        level=0,
+                    ),
+                    jac_node=self.ir_out,
+                )
+            )
+
+        # Add library mode imports at the end of preamble
+        if settings.library_mode and self.jaclib_imports:
+            self.preamble.append(
+                self.sync(
+                    ast3.ImportFrom(
+                        module="jaclang.lib",
+                        names=[
+                            self.sync(ast3.alias(name=name, asname=None))
+                            for name in sorted(self.jaclib_imports)
+                        ],
+                        level=0,
+                    ),
+                    jac_node=self.ir_out,
+                )
+            )
+
         clean_body = [i for i in node.body if not isinstance(i, uni.ImplDef)]
         pre_body: list[uni.UniNode] = []
         for pbody in node.impl_mod:
@@ -722,7 +780,7 @@ class PyastGenPass(UniPass):
             decorators.append(sem_decorator)
 
         base_classes = [cast(ast3.expr, i.gen.py_ast[0]) for i in node.base_classes]
-        base_classes.append(self.sync(ast3.Name(id="Enum", ctx=ast3.Load())))
+        base_classes.append(self.builtin_name("Enum"))
         node.gen.py_ast = [
             self.sync(
                 ast3.ClassDef(
@@ -744,23 +802,9 @@ class PyastGenPass(UniPass):
         self, model: ast3.expr, caller: ast3.expr, args: ast3.Dict
     ) -> ast3.Call:
         """Reusable method to codegen call_llm(model, caller, args)."""
-        self.needs_mtllm()
-        mtir_cls_ast = self.sync(
-            ast3.Attribute(
-                value=self.sync(ast3.Name(id="byllm", ctx=ast3.Load())),
-                attr="MTIR",
-                ctx=ast3.Load(),
-            )
-        )
         mtir_ast = self.sync(
             ast3.Call(
-                func=self.sync(
-                    ast3.Attribute(
-                        value=mtir_cls_ast,
-                        attr="factory",
-                        ctx=ast3.Load(),
-                    )
-                ),
+                func=self.jaclib_obj("get_mtir"),
                 args=[],
                 keywords=[
                     self.sync(
@@ -928,7 +972,9 @@ class PyastGenPass(UniPass):
         if isinstance(node.signature, uni.EventSignature):
             decorator_list.append(
                 self.jaclib_obj(
-                    "entry" if node.signature.event.name == Tok.KW_ENTRY else "exit"
+                    "on_entry"
+                    if node.signature.event.name == Tok.KW_ENTRY
+                    else "on_exit"
                 )
             )
 
@@ -943,11 +989,9 @@ class PyastGenPass(UniPass):
                 )
             )
         if node.is_abstract:
-            decorator_list.append(
-                self.sync(ast3.Name(id="abstractmethod", ctx=ast3.Load()))
-            )
+            decorator_list.append(self.builtin_name("abstractmethod"))
         if node.is_override:
-            decorator_list.append(self.sync(ast3.Name(id="override", ctx=ast3.Load())))
+            decorator_list.append(self.builtin_name("override"))
         if node.is_static:
             decorator_list.insert(
                 0, self.sync(ast3.Name(id="staticmethod", ctx=ast3.Load()))
@@ -1145,7 +1189,7 @@ class PyastGenPass(UniPass):
         elif is_static_var:
             annotation = self.sync(
                 ast3.Subscript(
-                    value=self.sync(ast3.Name(id="ClassVar", ctx=ast3.Load())),
+                    value=self.builtin_name("ClassVar"),
                     slice=cast(ast3.expr, annotation),
                     ctx=ast3.Load(),
                 )
@@ -1222,8 +1266,29 @@ class PyastGenPass(UniPass):
         ]
 
     def exit_typed_ctx_block(self, node: uni.TypedCtxBlock) -> None:
-        # TODO: Come back
-        pass
+        loc = self.sync(
+            ast3.Name(id=Con.HERE.value, ctx=ast3.Load())
+            if node.from_walker
+            else ast3.Name(id=Con.VISITOR.value, ctx=ast3.Load())
+        )
+        node.gen.py_ast = [
+            self.sync(
+                ast3.If(
+                    test=self.sync(
+                        ast3.Call(
+                            func=self.sync(ast3.Name(id="isinstance", ctx=ast3.Load())),
+                            args=[
+                                loc,
+                                cast(ast3.expr, node.type_ctx.gen.py_ast[0]),
+                            ],
+                            keywords=[],
+                        )
+                    ),
+                    body=cast(list[ast3.stmt], self.resolve_stmt_block(node.body)),
+                    orelse=[],
+                )
+            )
+        ]
 
     def exit_if_stmt(self, node: uni.IfStmt) -> None:
         node.gen.py_ast = [
@@ -1999,7 +2064,7 @@ class PyastGenPass(UniPass):
                 keywords.append(
                     self.sync(
                         ast3.keyword(
-                            arg="filter",
+                            arg="filter_on",
                             value=cast(
                                 ast3.expr,
                                 node.op.edge_spec.filter_cond.gen.py_ast[0],
@@ -2206,7 +2271,7 @@ class PyastGenPass(UniPass):
             node.gen.py_ast = [
                 self.sync(
                     ast3.Call(
-                        func=self.sync(ast3.Name(id="jobj", ctx=ast3.Load())),
+                        func=self.builtin_name("jobj"),
                         args=[],
                         keywords=[
                             self.sync(
@@ -2431,7 +2496,7 @@ class PyastGenPass(UniPass):
             node.gen.py_ast = [
                 self.sync(
                     ast3.Call(
-                        func=self.jaclib_obj("filter"),
+                        func=self.jaclib_obj("filter_on"),
                         args=[],
                         keywords=[
                             self.sync(
@@ -2454,7 +2519,7 @@ class PyastGenPass(UniPass):
             node.gen.py_ast = [
                 self.sync(
                     ast3.Call(
-                        func=self.jaclib_obj("assign"),
+                        func=self.jaclib_obj("assign_all"),
                         args=cast(
                             list[ast3.expr],
                             [node.target.gen.py_ast[0], node.right.gen.py_ast[0]],
@@ -2685,7 +2750,7 @@ class PyastGenPass(UniPass):
                     func=self.sync(
                         ast3.Attribute(
                             value=pynode,
-                            attr=f"_{cur.edge_dir.name.lower()}",
+                            attr=f"edge_{cur.edge_dir.name.lower()}",
                             ctx=ast3.Load(),
                         )
                     ),
@@ -3026,6 +3091,9 @@ class PyastGenPass(UniPass):
 
     def exit_name(self, node: uni.Name) -> None:
         name = node.sym_name
+        # Track if this name is a known builtin
+        if name in self.KNOWN_BUILTINS:
+            self.builtin_imports.add(name)
         node.gen.py_ast = [self.sync(ast3.Name(id=name, ctx=node.py_ctx_func()))]
 
     def exit_float(self, node: uni.Float) -> None:

jaclang/compiler/passes/main/pyast_load_pass.py

@@ -96,6 +96,8 @@ class PyastBuildPass(Transform[uni.PythonModuleAst, uni.Module]):
             body: list[stmt]
             type_ignores: list[TypeIgnore]
         """
+        if not node.body:
+            return uni.Module.make_stub(inject_src=self.ir_in)
         elements: list[uni.UniNode] = [self.convert(i) for i in node.body]
         elements[0] = (
             elements[0].expr

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

@@ -175,7 +175,6 @@ class TypeCheckerPassTests(TestCase):
         """, program.errors_had[0].pretty_print())
 
     def test_param_arg_match(self) -> None:
-        path = self.fixture_abs_path("checker_param_types.jac")
         program = JacProgram()
         path = self.fixture_abs_path("checker_arg_param_match.jac")
         mod = program.compile(path)