jaclang 0.5.11__py3-none-any.whl → 0.5.16__py3-none-any.whl

jaclang/compiler/passes/main/pyast_load_pass.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import ast as py_ast
 import os
-from typing import Optional, TypeAlias, TypeVar
+from typing import Optional, Sequence, TypeAlias, TypeVar
 
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.constant import Tokens as Tok
@@ -29,9 +29,9 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
 
     def pp(self, node: py_ast.AST) -> None:
         """Print python node."""
-        print(
-            f"{node.__class__.__name__} - {[(k, type(v)) for k, v in vars(node).items()]}"
-        )
+        # print(
+        #     f"{node.__class__.__name__} - {[(k, type(v)) for k, v in vars(node).items()]}"
+        # )
 
     def convert(self, node: py_ast.AST) -> ast.AstNode:
         """Get python node type."""
@@ -45,6 +45,7 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
         # print(f"finshed {type(node).__name__} ---------------------")
         # print("normalizing", ret.__class__.__name__)
         # print(ret.unparse())
+        # ret.unparse()
         return ret
 
     def transform(self, ir: ast.PythonModuleAst) -> ast.Module:
@@ -59,12 +60,16 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
 
         def gen_mod_code(with_entry_body: list[ast.CodeBlockStmt]) -> ast.ModuleCode:
             with_entry_subnodelist = ast.SubNodeList[ast.CodeBlockStmt](
-                items=with_entry_body, delim=Tok.WS, kid=with_entry_body
+                items=with_entry_body,
+                delim=Tok.WS,
+                kid=with_entry_body,
+                left_enc=self.operator(Tok.LBRACE, "{"),
+                right_enc=self.operator(Tok.RBRACE, "}"),
             )
             return ast.ModuleCode(
                 name=None,
                 body=with_entry_subnodelist,
-                kid=with_entry_body,
+                kid=[with_entry_subnodelist],
                 doc=None,
             )
 
@@ -72,12 +77,16 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
         with_entry_body: list[ast.CodeBlockStmt] = []
         for i in body:
             if isinstance(i, exclude_types):
+                if len(with_entry_body):
+                    extracted.append(gen_mod_code(with_entry_body))
+                    with_entry_body = []
                 extracted.append(i)
             elif isinstance(i, ast.CodeBlockStmt):
+                if isinstance(i, ast.ExprStmt) and isinstance(i.expr, ast.String):
+                    self.convert_to_doc(i.expr)
                 with_entry_body.append(i)
             else:
                 self.ice("Invalid type for with entry body")
-
         if len(with_entry_body):
             extracted.append(gen_mod_code(with_entry_body))
         return extracted
@@ -97,14 +106,20 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             and isinstance(elements[0].expr, ast.String)
             else elements[0]
         )
+        doc_str_list = [elements[0]] if isinstance(elements[0], ast.String) else []
         valid = (
-            [elements[0]] if isinstance(elements[0], ast.String) else []
-        ) + self.extract_with_entry(elements[1:], (ast.ElementStmt, ast.EmptyToken))
+            (doc_str_list)
+            + self.extract_with_entry(elements[1:], (ast.ElementStmt, ast.EmptyToken))
+            if doc_str_list
+            else self.extract_with_entry(elements[:], (ast.ElementStmt, ast.EmptyToken))
+        )
+        doc_str = elements[0] if isinstance(elements[0], ast.String) else None
+        self.convert_to_doc(doc_str) if doc_str else None
         ret = ast.Module(
             name=self.mod_path.split(os.path.sep)[-1].split(".")[0],
             source=ast.JacSource("", mod_path=self.mod_path),
-            doc=(elements[0] if isinstance(elements[0], ast.String) else None),
-            body=valid[1:] if isinstance(valid[0], ast.String) else valid,
+            doc=doc_str,
+            body=valid[1:] if valid and isinstance(valid[0], ast.String) else valid,
             is_imported=False,
             kid=valid,
         )
@@ -146,13 +161,22 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             and isinstance(valid[0].expr, ast.String)
         ):
             doc = valid[0].expr
+            self.convert_to_doc(doc)
             valid_body = ast.SubNodeList[ast.CodeBlockStmt](
-                items=valid[1:], delim=Tok.WS, kid=valid[1:]
+                items=valid[1:],
+                delim=Tok.WS,
+                kid=valid[1:],
+                left_enc=self.operator(Tok.LBRACE, "{"),
+                right_enc=self.operator(Tok.RBRACE, "}"),
             )
         else:
             doc = None
             valid_body = ast.SubNodeList[ast.CodeBlockStmt](
-                items=valid, delim=Tok.WS, kid=valid
+                items=valid,
+                delim=Tok.WS,
+                kid=valid,
+                left_enc=self.operator(Tok.LBRACE, "{"),
+                right_enc=self.operator(Tok.RBRACE, "}"),
             )
         decorators = [self.convert(i) for i in node.decorator_list]
         valid_dec = [i for i in decorators if isinstance(i, ast.Expr)]
@@ -212,7 +236,7 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
         ability.is_async = True
         return ability
 
-    def proc_class_def(self, node: py_ast.ClassDef) -> ast.Architype:
+    def proc_class_def(self, node: py_ast.ClassDef) -> ast.Architype | ast.Enum:
         """Process python node.
 
         class ClassDef(stmt):
@@ -239,7 +263,7 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
         arch_type = ast.Token(
             file_path=self.mod_path,
             name=Tok.KW_OBJECT,
-            value="object",
+            value="obj",
             line=node.lineno,
             col_start=0,
             col_end=0,
@@ -247,37 +271,139 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             pos_end=0,
         )
         body = [self.convert(i) for i in node.body]
-        valid: list[ast.ArchBlockStmt] = self.extract_with_entry(
-            body, ast.ArchBlockStmt
+        for body_stmt in body:
+            if (
+                isinstance(body_stmt, ast.Ability)
+                and isinstance(body_stmt.name_ref, ast.Name)
+                and body_stmt.name_ref.value == "__init__"
+            ):
+                tok = ast.Token(
+                    file_path=self.mod_path,
+                    name=Tok.KW_INIT,
+                    value="init",
+                    line=node.lineno,
+                    col_start=node.col_offset,
+                    col_end=node.col_offset + len("init"),
+                    pos_start=0,
+                    pos_end=0,
+                )
+                body_stmt.name_ref = ast.SpecialVarRef(var=tok, kid=[tok])
+            if (
+                isinstance(body_stmt, ast.Ability)
+                and body_stmt.signature
+                and isinstance(body_stmt.signature, ast.FuncSignature)
+                and body_stmt.signature.params
+            ):
+                body_stmt.signature.params.items = [
+                    param
+                    for param in body_stmt.signature.params.items
+                    if param.name.value != "self"
+                ]
+        doc = (
+            body[0].expr
+            if isinstance(body[0], ast.ExprStmt)
+            and isinstance(body[0].expr, ast.String)
+            else None
+        )
+        self.convert_to_doc(doc) if doc else None
+        body = body[1:] if doc else body
+        valid: list[ast.ArchBlockStmt] = (
+            self.extract_with_entry(body, ast.ArchBlockStmt)
+            if not (isinstance(body[0], ast.Semi) and len(body) == 1)
+            else []
         )
+        empty_block: Sequence[ast.AstNode] = [
+            self.operator(Tok.LBRACE, "{"),
+            self.operator(Tok.RBRACE, "}"),
+        ]
         valid_body = ast.SubNodeList[ast.ArchBlockStmt](
-            items=valid, delim=Tok.WS, kid=body
+            items=valid,
+            delim=Tok.WS,
+            kid=(valid if valid else empty_block),
+            left_enc=self.operator(Tok.LBRACE, "{"),
+            right_enc=self.operator(Tok.RBRACE, "}"),
         )
-
-        base_classes = [self.convert(base) for base in node.bases]
-        valid2: list[ast.Expr] = [
-            base for base in base_classes if isinstance(base, ast.Expr)
+        converted_base_classes = [self.convert(base) for base in node.bases]
+        base_classes: list[ast.Expr] = [
+            base for base in converted_base_classes if isinstance(base, ast.Expr)
         ]
-        if len(valid2) != len(base_classes):
-            raise self.ice("Length mismatch in base classes")
         valid_bases = (
-            ast.SubNodeList[ast.Expr](items=valid2, delim=Tok.COMMA, kid=base_classes)
-            if len(valid2)
+            ast.SubNodeList[ast.Expr](
+                items=base_classes, delim=Tok.COMMA, kid=base_classes
+            )
+            if base_classes
             else None
         )
-        doc = None
-        decorators = [self.convert(i) for i in node.decorator_list]
-        valid_dec = [i for i in decorators if isinstance(i, ast.Expr)]
-        if len(valid_dec) != len(decorators):
-            raise self.ice("Length mismatch in decorators in class")
+        converted_decorators_list = [self.convert(i) for i in node.decorator_list]
+        decorators = [i for i in converted_decorators_list if isinstance(i, ast.Expr)]
         valid_decorators = (
             ast.SubNodeList[ast.Expr](
-                items=valid_dec, delim=Tok.DECOR_OP, kid=decorators
+                items=decorators, delim=Tok.DECOR_OP, kid=decorators
             )
-            if len(valid_dec)
+            if decorators
             else None
         )
-        kid = [name, valid_bases, valid_body] if valid_bases else [name, valid_body]
+        if (
+            base_classes
+            and isinstance(base_classes[0], ast.Name)
+            and base_classes[0].value == "Enum"
+        ):
+            if len(base_classes) > 1:
+                raise ValueError(
+                    "Python's Enum class cannot be used with multiple inheritance."
+                )
+            arch_type.name = Tok.KW_ENUM
+            arch_type.value = "enum"
+            valid_enum_body: list[ast.EnumBlockStmt] = []
+            for class_body_stmt in node.body:
+                converted_stmt = self.convert(class_body_stmt)
+                if isinstance(converted_stmt, ast.EnumBlockStmt):
+                    if isinstance(converted_stmt, ast.Assignment):
+                        converted_stmt.is_enum_stmt = True
+                    valid_enum_body.append(converted_stmt)
+                else:
+                    if isinstance(converted_stmt, ast.ExprStmt) and isinstance(
+                        converted_stmt.expr, ast.String
+                    ):
+                        continue
+                    tok = ast.Token(
+                        file_path=self.mod_path,
+                        name=Tok.PYNLINE,
+                        value=py_ast.unparse(class_body_stmt),
+                        line=node.lineno,
+                        col_start=node.col_offset,
+                        col_end=node.col_offset + len(py_ast.unparse(class_body_stmt)),
+                        pos_start=0,
+                        pos_end=0,
+                    )
+                    valid_enum_body.append(ast.PyInlineCode(code=tok, kid=[tok]))
+
+            valid_enum_body2: list[ast.EnumBlockStmt] = [
+                i for i in valid_enum_body if isinstance(i, ast.EnumBlockStmt)
+            ]
+            enum_body = ast.SubNodeList[ast.EnumBlockStmt](
+                items=valid_enum_body2, delim=Tok.COMMA, kid=valid_enum_body2
+            )
+            if doc:
+                doc.line_no = name.line_no
+            return ast.Enum(
+                name=name,
+                access=None,
+                base_classes=None,
+                body=enum_body,
+                kid=[doc, name, enum_body] if doc else [name, enum_body],
+                doc=doc,
+                decorators=valid_decorators,
+            )
+        kid = (
+            [name, valid_bases, valid_body, doc]
+            if doc and valid_bases
+            else (
+                [name, valid_bases, valid_body]
+                if valid_bases
+                else [name, valid_body, doc] if doc else [name, valid_body]
+            )
+        )
         return ast.Architype(
             arch_type=arch_type,
             name=name,
@@ -320,13 +446,14 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
         target = ast.SubNodeList[ast.Expr | ast.KWPair](
             items=[*valid_exprs], delim=Tok.COMMA, kid=exprs
         )
+        target_1 = (
+            valid_exprs[0]
+            if len(valid_exprs) > 1
+            else ast.TupleVal(values=target, kid=[target])
+        )
         return ast.DeleteStmt(
-            target=(
-                valid_exprs[0]
-                if len(valid_exprs) > 1
-                else ast.TupleVal(values=target, kid=[target])
-            ),
-            kid=exprs,
+            target=target_1,
+            kid=[target],
         )
 
     def proc_assign(self, node: py_ast.Assign) -> ast.Assignment:
@@ -408,10 +535,11 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             and isinstance(annotation, ast.Expr)
             and isinstance(target, ast.Expr)
         ):
+            target = ast.SubNodeList[ast.Expr](
+                items=[target], delim=Tok.EQ, kid=[target]
+            )
             return ast.Assignment(
-                target=ast.SubNodeList[ast.Expr](
-                    items=[target], delim=Tok.EQ, kid=[target]
-                ),
+                target=target,
                 value=value if isinstance(value, (ast.Expr, ast.YieldExpr)) else None,
                 type_tag=annotation_subtag,
                 kid=(
@@ -441,7 +569,11 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             raise self.ice("Length mismatch in for body")
 
         valid_body = ast.SubNodeList[ast.CodeBlockStmt](
-            items=val_body, delim=Tok.WS, kid=val_body
+            items=val_body,
+            delim=Tok.WS,
+            kid=val_body,
+            left_enc=self.operator(Tok.LBRACE, "{"),
+            right_enc=self.operator(Tok.RBRACE, "}"),
         )
         orelse = [self.convert(i) for i in node.orelse]
         val_orelse = [i for i in orelse if isinstance(i, ast.CodeBlockStmt)]
@@ -449,7 +581,11 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             raise self.ice("Length mismatch in for orelse")
         if orelse:
             valid_orelse = ast.SubNodeList[ast.CodeBlockStmt](
-                items=val_orelse, delim=Tok.WS, kid=orelse
+                items=val_orelse,
+                delim=Tok.WS,
+                kid=orelse,
+                left_enc=self.operator(Tok.LBRACE, "{"),
+                right_enc=self.operator(Tok.RBRACE, "}"),
             )
         else:
             valid_orelse = None
@@ -492,7 +628,11 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             raise self.ice("Length mismatch in for body")
 
         valid_body = ast.SubNodeList[ast.CodeBlockStmt](
-            items=val_body, delim=Tok.WS, kid=val_body
+            items=val_body,
+            delim=Tok.WS,
+            kid=val_body,
+            left_enc=self.operator(Tok.LBRACE, "{"),
+            right_enc=self.operator(Tok.RBRACE, "}"),
         )
         orelse = [self.convert(i) for i in node.orelse]
         val_orelse = [i for i in orelse if isinstance(i, ast.CodeBlockStmt)]
@@ -500,7 +640,11 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             raise self.ice("Length mismatch in for orelse")
         if orelse:
             valid_orelse = ast.SubNodeList[ast.CodeBlockStmt](
-                items=val_orelse, delim=Tok.WS, kid=orelse
+                items=val_orelse,
+                delim=Tok.WS,
+                kid=orelse,
+                left_enc=self.operator(Tok.LBRACE, "{"),
+                right_enc=self.operator(Tok.RBRACE, "}"),
             )
         else:
             valid_orelse = None
@@ -540,7 +684,11 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
         if len(valid_body) != len(body):
             raise self.ice("Length mismatch in while body")
         fin_body = ast.SubNodeList[ast.CodeBlockStmt](
-            items=valid_body, delim=Tok.WS, kid=valid_body
+            items=valid_body,
+            delim=Tok.WS,
+            kid=valid_body,
+            left_enc=self.operator(Tok.LBRACE, "{"),
+            right_enc=self.operator(Tok.RBRACE, "}"),
         )
         if isinstance(test, ast.Expr):
             return ast.WhileStmt(
@@ -566,7 +714,11 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
         if len(valid_body) != len(body):
             self.error("Length mismatch in async for body")
         body2 = ast.SubNodeList[ast.CodeBlockStmt](
-            items=valid_body, delim=Tok.WS, kid=body
+            items=valid_body,
+            delim=Tok.WS,
+            kid=body,
+            left_enc=self.operator(Tok.LBRACE, "{"),
+            right_enc=self.operator(Tok.RBRACE, "}"),
         )
 
         orelse = [self.convert(stmt) for stmt in node.orelse]
@@ -584,7 +736,11 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
                 )
             else:
                 orelse2 = ast.SubNodeList[ast.CodeBlockStmt](
-                    items=valid_orelse, delim=Tok.WS, kid=orelse
+                    items=valid_orelse,
+                    delim=Tok.WS,
+                    kid=orelse,
+                    left_enc=self.operator(Tok.LBRACE, "{"),
+                    right_enc=self.operator(Tok.RBRACE, "}"),
                 )
                 else_body = ast.ElseStmt(body=orelse2, kid=[orelse2])
         else:
@@ -622,7 +778,11 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
         if len(valid_body) != len(body):
             raise self.ice("Length mismatch in async for body")
         body_sub = ast.SubNodeList[ast.CodeBlockStmt](
-            items=valid_body, delim=Tok.WS, kid=body
+            items=valid_body,
+            delim=Tok.WS,
+            kid=body,
+            left_enc=self.operator(Tok.LBRACE, "{"),
+            right_enc=self.operator(Tok.RBRACE, "}"),
         )
         return ast.WithStmt(
             is_async=False, exprs=items_sub, body=body_sub, kid=[items_sub, body_sub]
@@ -648,7 +808,11 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
         if len(valid_body) != len(body):
             raise self.ice("Length mismatch in async for body")
         body_sub = ast.SubNodeList[ast.CodeBlockStmt](
-            items=valid_body, delim=Tok.WS, kid=body
+            items=valid_body,
+            delim=Tok.WS,
+            kid=body,
+            left_enc=self.operator(Tok.LBRACE, "{"),
+            right_enc=self.operator(Tok.RBRACE, "}"),
         )
         return ast.WithStmt(
             is_async=True, exprs=items_sub, body=body_sub, kid=[items_sub, body_sub]
@@ -855,6 +1019,7 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             return ast.FuncCall(
                 target=func,
                 params=params_in2,
+                genai_call=None,
                 kid=[func, params_in2] if params_in2 else [func],
             )
         else:
@@ -924,7 +1089,11 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             return type_mapping[value_type](
                 file_path=self.mod_path,
                 name=token_type,
-                value=str(node.value),
+                value=(
+                    f'"{repr(node.value)[1:-1]}"'
+                    if value_type == str
+                    else str(node.value)
+                ),
                 line=node.lineno,
                 col_start=node.col_offset,
                 col_end=node.col_offset + len(str(node.value)),
@@ -1014,6 +1183,17 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             body: list[stmt]
         """
         type = self.convert(node.type) if node.type is not None else None
+        if not type:
+            type = ast.Name(
+                file_path=self.mod_path,
+                name=Tok.NAME,
+                value="Any",
+                line=node.lineno,
+                col_start=node.col_offset,
+                col_end=node.col_offset + 3,
+                pos_start=0,
+                pos_end=0,
+            )
         name = (
             ast.Name(
                 file_path=self.mod_path,
@@ -1034,7 +1214,11 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
         if len(valid) != len(body):
             raise self.ice("Length mismatch in except handler body")
         valid_body = ast.SubNodeList[ast.CodeBlockStmt](
-            items=valid, delim=Tok.WS, kid=valid
+            items=valid,
+            delim=Tok.WS,
+            kid=valid,
+            left_enc=self.operator(Tok.LBRACE, "{"),
+            right_enc=self.operator(Tok.RBRACE, "}"),
         )
         kid = []
         if type:
@@ -1360,32 +1544,37 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
         else:
             raise self.ice()
 
-    def proc_match_as(self, node: py_ast.MatchAs) -> ast.MatchAs:
+    def proc_match_as(self, node: py_ast.MatchAs) -> ast.MatchAs | ast.MatchWild:
         """Process python node.
 
         class MatchAs(pattern):
             pattern: _Pattern | None
             name: _Identifier | None
         """
-        pattern = self.convert(node.pattern) if node.pattern is not None else None
+        pattern = self.convert(node.pattern) if node.pattern else None
         name = ast.Name(
             file_path=self.mod_path,
             name=Tok.NAME,
-            value=node.name if node.name is not None else "_",
+            value=node.name if node.name else "_",
             line=node.lineno,
             col_start=node.col_offset,
-            col_end=node.col_offset + len(node.name if node.name is not None else "_"),
+            col_end=(
+                (node.col_offset + len(node.name))
+                if node.name
+                else (node.col_offset + 1)
+            ),
             pos_start=0,
             pos_end=0,
         )
-        if isinstance(pattern, ast.MatchPattern) or pattern is None:
+
+        if isinstance(pattern, ast.MatchPattern):
             return ast.MatchAs(
                 name=name,
                 pattern=pattern,
-                kid=[name, pattern] if pattern is not None else [name],
+                kid=[name, pattern] if pattern else [name],
             )
         else:
-            raise self.ice()
+            return ast.MatchWild(kid=[name])
 
     def proc_match_class(self, node: py_ast.MatchClass) -> ast.MatchArch:
         """Process python node.
@@ -1443,6 +1632,8 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
                 items=kv_pairs, delim=Tok.COMMA, kid=kv_pairs
             )
             kid.append(kw_patterns)
+        else:
+            kw_patterns = None
         if isinstance(cls, ast.NameSpec):
             return ast.MatchArch(
                 name=cls, arg_patterns=patterns_sub, kw_patterns=kw_patterns, kid=kid
@@ -1764,7 +1955,11 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
         if len(valid) != len(body):
             raise self.ice("Length mismatch in try body")
         valid_body = ast.SubNodeList[ast.CodeBlockStmt](
-            items=valid, delim=Tok.WS, kid=valid
+            items=valid,
+            delim=Tok.WS,
+            kid=valid,
+            left_enc=self.operator(Tok.LBRACE, "{"),
+            right_enc=self.operator(Tok.RBRACE, "}"),
         )
         kid: list[ast.AstNode] = [valid_body]
 
@@ -1786,7 +1981,11 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             if len(orelse) != len(valid_orelse):
                 raise self.ice("Length mismatch in try orelse")
             else_body = ast.SubNodeList[ast.CodeBlockStmt](
-                items=valid_orelse, delim=Tok.WS, kid=valid_orelse
+                items=valid_orelse,
+                delim=Tok.WS,
+                kid=valid_orelse,
+                left_enc=self.operator(Tok.LBRACE, "{"),
+                right_enc=self.operator(Tok.RBRACE, "}"),
             )
             kid.append(else_body)
         else:
@@ -1800,7 +1999,11 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             if len(finalbody) != len(valid_finalbody):
                 raise self.ice("Length mismatch in try finalbody")
             finally_body = ast.SubNodeList[ast.CodeBlockStmt](
-                items=valid_finalbody, delim=Tok.WS, kid=valid_finalbody
+                items=valid_finalbody,
+                delim=Tok.WS,
+                kid=valid_finalbody,
+                left_enc=self.operator(Tok.LBRACE, "{"),
+                right_enc=self.operator(Tok.RBRACE, "}"),
             )
             kid.append(finally_body)
         else:
@@ -2270,3 +2473,7 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
 
     def proc_type_var_tuple(self, node: py_ast.TypeVarTuple) -> None:
         """Process python node."""
+
+    def convert_to_doc(self, string: ast.String) -> None:
+        """Convert a string to a docstring."""
+        string.value = f'""{string.value}""'

jaclang/compiler/passes/main/registry_pass.py

@@ -28,10 +28,10 @@ class RegistryPass(Pass):
 
     def exit_module(self, node: ast.Module) -> None:
         """Save registry for each module."""
+        module_name = node.name
         module_dir = os.path.join(
             os.path.abspath(os.path.dirname(node.source.file_path)), Con.JAC_GEN_DIR
         )
-        module_name = node.name
         os.makedirs(module_dir, exist_ok=True)
         with open(os.path.join(module_dir, f"{module_name}.registry.pkl"), "wb") as f:
             pickle.dump(node.registry, f)
@@ -68,9 +68,7 @@ class RegistryPass(Pass):
     def exit_has_var(self, node: ast.HasVar) -> None:
         """Save variable information."""
         extracted_type = (
-            "".join(self.extract_type(node.type_tag.kid[1:][0]))
-            if node.type_tag
-            else None
+            "".join(self.extract_type(node.type_tag.tag)) if node.type_tag else None
         )
         scope = get_sem_scope(node)
         seminfo = SemInfo(
@@ -87,9 +85,7 @@ class RegistryPass(Pass):
             return
 
         extracted_type = (
-            "".join(self.extract_type(node.type_tag.kid[1:][0]))
-            if node.type_tag
-            else None
+            "".join(self.extract_type(node.type_tag.tag)) if node.type_tag else None
         )
         scope = get_sem_scope(node)
         seminfo = SemInfo(

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

@@ -57,6 +57,8 @@ class PyastGenPassTests(TestCaseMicroSuite, AstSyncTestMixin):
             captured_output = io.StringIO()
             sys.stdout = captured_output
             module = types.ModuleType("__main__")
+            module.__dict__["__file__"] = code_gen.ir.loc.mod_path
+            module.__dict__["__jac_mod_bundle__"] = None
             exec(prog, module.__dict__)
             sys.stdout = sys.__stdout__
             stdout_value = captured_output.getvalue()

jaclang/compiler/passes/main/type_check_pass.py

@@ -33,7 +33,10 @@ class JacTypeCheckPass(Pass):
 
     def after_pass(self) -> None:
         """Call mypy api after traversing all the modules."""
-        self.api()
+        try:
+            self.api()
+        except Exception as e:
+            self.error(f"Unable to run type checking: {e}")
         return super().after_pass()
 
     def default_message_cb(

jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -20,6 +20,11 @@ class JacFormatPass(Pass):
         self.indent_level = 0
         self.MAX_LINE_LENGTH = 44
 
+    def enter_node(self, node: ast.AstNode) -> None:
+        """Enter node."""
+        node.gen.jac = ""
+        super().enter_node(node)
+
     def indent_str(self) -> str:
         """Return string for indent."""
         return " " * self.indent_size * self.indent_level
@@ -337,6 +342,8 @@ class JacFormatPass(Pass):
                 else:
                     self.emit_ln(node, "")
                     self.emit_ln(node, i.gen.jac)
+            if isinstance(i, ast.Token) and i.name == Tok.KW_BY:
+                self.emit(node, f"{i.gen.jac} ")
             else:
                 self.emit(node, i.gen.jac)
         if isinstance(node.kid[-1], (ast.Semi, ast.CommentToken)):