jaclang 0.7.19__tar.gz → 0.7.21__tar.gz

{jaclang-0.7.19 → jaclang-0.7.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jaclang
-Version: 0.7.19
+Version: 0.7.21
 Summary: Jac is a unique and powerful programming language that runs on top of Python, offering an unprecedented level of intelligence and intuitive understanding.
 Home-page: https://jaseci.org
 License: MIT

{jaclang-0.7.19 → jaclang-0.7.21}/jaclang/compiler/absyntree.py

@@ -4212,7 +4212,7 @@ class Literal(Token, AtomExpr):
         raise NotImplementedError
 
 
-class BuiltinType(Name, Literal, NameAtom):
+class BuiltinType(Name, Literal):
     """Type node type for Jac Ast."""
 
     SYMBOL_TYPE = SymbolType.VAR

{jaclang-0.7.19 → jaclang-0.7.21}/jaclang/compiler/jac.lark

@@ -25,7 +25,7 @@ from_path: (DOT | ELLIPSIS)* import_path
          | (DOT | ELLIPSIS)+
 
 import_path: named_ref (DOT named_ref)* (KW_AS NAME)?
-import_items: (import_item COMMA)* import_item
+import_items: (import_item COMMA)* import_item COMMA?
 import_item: named_ref (KW_AS NAME)?
 sub_name: COLON NAME
 include_stmt: KW_INCLUDE sub_name? import_path SEMI
@@ -63,7 +63,7 @@ enum: decorators? enum_decl
 
 enum_decl: KW_ENUM access_tag? STRING? NAME inherited_archs? (enum_block | SEMI)
 enum_def: arch_to_enum_chain enum_block
-enum_block: LBRACE ((enum_stmt COMMA)* enum_stmt)? RBRACE
+enum_block: LBRACE ((enum_stmt COMMA)* enum_stmt COMMA?)? RBRACE
 
 enum_stmt: NAME (COLON STRING)? EQ expression
          | NAME (COLON STRING)?
@@ -83,7 +83,7 @@ abstract_ability: KW_OVERRIDE? KW_STATIC? KW_CAN access_tag? STRING? named_ref (
 genai_ability: KW_OVERRIDE? KW_STATIC? KW_CAN access_tag? STRING? named_ref (func_decl) KW_BY atomic_call SEMI
 event_clause: KW_WITH expression? (KW_EXIT | KW_ENTRY) (STRING? RETURN_HINT expression)?
 func_decl: (LPAREN func_decl_params? RPAREN)? (RETURN_HINT (STRING COLON)? expression)?
-func_decl_params: (param_var COMMA)* param_var
+func_decl_params: (param_var COMMA)* param_var COMMA?
 param_var: (STAR_POW | STAR_MUL)? NAME (COLON STRING)? type_tag (EQ expression)?
 
 // Global variables
@@ -364,9 +364,9 @@ index_slice: LSQUARE expression? COLON expression? (COLON expression?)? RSQUARE
 // Function calls
 atomic_call: atomic_chain LPAREN param_list? (KW_BY atomic_call)? RPAREN
 
-param_list: expr_list COMMA kw_expr_list
-          | kw_expr_list
-          | expr_list
+param_list: expr_list COMMA kw_expr_list COMMA?
+          | kw_expr_list COMMA?
+          | expr_list COMMA?
 
 // Atom
 atom: named_ref
@@ -412,20 +412,20 @@ set_compr: LBRACE expression inner_compr+ RBRACE
 dict_compr: LBRACE kv_pair inner_compr+ RBRACE
 inner_compr: KW_ASYNC? KW_FOR atomic_chain KW_IN pipe_call (KW_IF walrus_assign)*
 
-dict_val: LBRACE ((kv_pair COMMA)* kv_pair)? RBRACE
-list_val: LSQUARE expr_list? RSQUARE
+dict_val: LBRACE ((kv_pair COMMA)* kv_pair COMMA?)? RBRACE
+list_val: LSQUARE (expr_list COMMA?)? RSQUARE
 tuple_val: LPAREN tuple_list? RPAREN
-set_val: LBRACE expr_list RBRACE
+set_val: LBRACE expr_list COMMA? RBRACE
 
 kv_pair: expression COLON expression | STAR_POW expression
 expr_list: (expr_list COMMA)? expression
 
 // Tuples and Jac Tuples
-tuple_list: expression COMMA expr_list COMMA kw_expr_list
-          | expression COMMA kw_expr_list
-          | expression COMMA expr_list
+tuple_list: expression COMMA expr_list COMMA kw_expr_list COMMA?
+          | expression COMMA kw_expr_list COMMA?
+          | expression COMMA expr_list COMMA?
           | expression COMMA
-          | kw_expr_list
+          | kw_expr_list COMMA?
 
 kw_expr_list: (kw_expr_list COMMA)? kw_expr
 kw_expr: named_ref EQ expression | STAR_POW expression
@@ -662,4 +662,4 @@ FSTR_BESC.1: /{{|}}/
 COMMENT: /#\*(.|\n|\r)*?\*#|#.*/
 WS.-2: /[ \t\f\r\n]/+
 %ignore COMMENT
-%ignore WS
+%ignore WS

{jaclang-0.7.19 → jaclang-0.7.21}/jaclang/compiler/parser.py

@@ -429,7 +429,7 @@ class JacParser(Pass):
         ) -> ast.SubNodeList[ast.ModuleItem]:
             """Grammar rule.
 
-            import_items: (import_item COMMA)* import_item
+            import_items: (import_item COMMA)* import_item COMMA?
             """
             ret = ast.SubNodeList[ast.ModuleItem](
                 items=[i for i in kid if isinstance(i, ast.ModuleItem)],
@@ -693,7 +693,7 @@ class JacParser(Pass):
         ) -> ast.SubNodeList[ast.EnumBlockStmt]:
             """Grammar rule.
 
-            enum_block: LBRACE ((enum_stmt COMMA)* enum_stmt)? RBRACE
+            enum_block: LBRACE ((enum_stmt COMMA)* enum_stmt COMMA?)? RBRACE
             """
             ret = ast.SubNodeList[ast.EnumBlockStmt](items=[], delim=Tok.COMMA, kid=kid)
             ret.items = [i for i in kid if isinstance(i, ast.EnumBlockStmt)]
@@ -1022,7 +1022,7 @@ class JacParser(Pass):
         ) -> ast.SubNodeList[ast.ParamVar]:
             """Grammar rule.
 
-            func_decl_params: (param_var COMMA)* param_var
+            func_decl_params: (param_var COMMA)* param_var COMMA?
             """
             ret = ast.SubNodeList[ast.ParamVar](
                 items=[i for i in kid if isinstance(i, ast.ParamVar)],
@@ -1267,29 +1267,30 @@ class JacParser(Pass):
         def statement(self, kid: list[ast.AstNode]) -> ast.CodeBlockStmt:
             """Grammar rule.
 
-            statement: py_code_block
-                    | walker_stmt
-                    | return_stmt SEMI
-                    | report_stmt SEMI
-                    | delete_stmt SEMI
-                    | ctrl_stmt SEMI
-                    | assert_stmt SEMI
-                    | raise_stmt SEMI
-                    | with_stmt
+            statement: import_stmt
+                    | ability
+                    | architype
+                    | if_stmt
                     | while_stmt
                     | for_stmt
                     | try_stmt
-                    | if_stmt
-                    | expression SEMI
-                    | (yield_expr | KW_YIELD) SEMI
-                    | static_assignment
-                    | assignment SEMI
+                    | match_stmt
+                    | with_stmt
                     | global_ref SEMI
                     | nonlocal_ref SEMI
                     | typed_ctx_block
-                    | ability
-                    | architype
-                    | import_stmt
+                    | return_stmt SEMI
+                    | (yield_expr | KW_YIELD) SEMI
+                    | raise_stmt SEMI
+                    | assert_stmt SEMI
+                    | check_stmt SEMI
+                    | assignment SEMI
+                    | delete_stmt SEMI
+                    | report_stmt SEMI
+                    | expression SEMI
+                    | ctrl_stmt SEMI
+                    | py_code_block
+                    | walker_stmt
                     | SEMI
             """
             if isinstance(kid[0], ast.CodeBlockStmt) and len(kid) < 2:
@@ -2180,30 +2181,21 @@ class JacParser(Pass):
         def arithmetic(self, kid: list[ast.AstNode]) -> ast.Expr:
             """Grammar rule.
 
-            arithmetic: term MINUS arithmetic
-                      | term PLUS arithmetic
-                      | term
+            arithmetic: (arithmetic (MINUS | PLUS))? term
             """
             return self.binary_expr_unwind(kid)
 
         def term(self, kid: list[ast.AstNode]) -> ast.Expr:
             """Grammar rule.
 
-            term: factor MOD term
-                 | factor DIV term
-                 | factor FLOOR_DIV term
-                 | factor STAR_MUL term
-                 | factor
+            term: (term (MOD | DIV | FLOOR_DIV | STAR_MUL | DECOR_OP))? power
             """
             return self.binary_expr_unwind(kid)
 
         def factor(self, kid: list[ast.AstNode]) -> ast.Expr:
             """Grammar rule.
 
-            factor: power
-                  | BW_NOT factor
-                  | MINUS factor
-                  | PLUS factor
+            factor: (BW_NOT | MINUS | PLUS) factor | connect
             """
             if len(kid) == 2:
                 if isinstance(kid[0], ast.Token) and isinstance(kid[1], ast.Expr):
@@ -2221,8 +2213,7 @@ class JacParser(Pass):
         def power(self, kid: list[ast.AstNode]) -> ast.Expr:
             """Grammar rule.
 
-            power: connect STAR_POW power
-                  | connect
+            power: (power STAR_POW)? factor
             """
             return self.binary_expr_unwind(kid)
 
@@ -2513,8 +2504,7 @@ class JacParser(Pass):
         def yield_expr(self, kid: list[ast.AstNode]) -> ast.YieldExpr:
             """Grammar rule.
 
-            yield_expr:
-                | KW_YIELD KW_FROM? expression
+            yield_expr: KW_YIELD KW_FROM? expression
             """
             if isinstance(kid[-1], ast.Expr):
                 return self.nu(
@@ -2565,7 +2555,7 @@ class JacParser(Pass):
         def multistring(self, kid: list[ast.AstNode]) -> ast.AtomExpr:
             """Grammar rule.
 
-            multistring: (fstring | STRING)+
+            multistring: (fstring | STRING | DOC_STRING)+
             """
             valid_strs = [i for i in kid if isinstance(i, (ast.String, ast.FString))]
             if len(valid_strs) == len(kid):
@@ -2582,6 +2572,7 @@ class JacParser(Pass):
             """Grammar rule.
 
             fstring: FSTR_START fstr_parts FSTR_END
+                | FSTR_SQ_START fstr_sq_parts FSTR_SQ_END
             """
             if len(kid) == 2:
                 return self.nu(
@@ -2605,7 +2596,7 @@ class JacParser(Pass):
         ) -> ast.SubNodeList[ast.String | ast.ExprStmt]:
             """Grammar rule.
 
-            fstr_parts: (FSTR_PIECE | FSTR_BESC | LBRACE expression RBRACE | fstring)*
+            fstr_parts: (FSTR_PIECE | FSTR_BESC | LBRACE expression RBRACE )*
             """
             valid_parts: list[ast.String | ast.ExprStmt] = [
                 (
@@ -2651,7 +2642,7 @@ class JacParser(Pass):
         def list_val(self, kid: list[ast.AstNode]) -> ast.ListVal:
             """Grammar rule.
 
-            list_val: LSQUARE expr_list? RSQUARE
+            list_val: LSQUARE (expr_list COMMA?)? RSQUARE
             """
             if len(kid) == 2:
                 return self.nu(
@@ -2695,7 +2686,7 @@ class JacParser(Pass):
         def set_val(self, kid: list[ast.AstNode]) -> ast.SetVal:
             """Grammar rule.
 
-            set_val: LBRACE expr_list RBRACE
+            set_val: LBRACE expr_list COMMA? RBRACE
             """
             if len(kid) == 2:
                 return self.nu(
@@ -2822,25 +2813,37 @@ class JacParser(Pass):
         ) -> ast.SubNodeList[ast.Expr | ast.KWPair]:
             """Grammar rule.
 
-            tuple_list: expression COMMA expr_list COMMA kw_expr_list
-                    | expression COMMA kw_expr_list
-                    | expression COMMA expr_list
-                    | expression COMMA
-                    | kw_expr_list
+            tuple_list: expression COMMA expr_list    COMMA kw_expr_list COMMA?
+                      | expression COMMA kw_expr_list COMMA?
+                      | expression COMMA expr_list    COMMA?
+                      | expression COMMA
+                      | kw_expr_list COMMA?
             """
             chomp = [*kid]
             first_expr = None
             if isinstance(chomp[0], ast.SubNodeList):
+                # The chomp will be like this:
+                #     kw_expr_list, [COMMA]
+                if len(chomp) > 1:
+                    # Add the comma to the subnode list if it exists, otherwise the last comma will not be a part of
+                    # the ast, we need it for formatting.
+                    chomp[0].kid.append(chomp[1])
                 return self.nu(chomp[0])
             else:
-                first_expr = chomp[0]
-                chomp = chomp[2:]
+                # The chomp will be like this:
+                #     expression, COMMA, [subnode_list, [COMMA, [kw_expr_list, [COMMA]]]]
+                # Pop the first expression from chomp.
+                first_expr = chomp[0]  # Get the first expression.
+                chomp = chomp[2:]  # Get rid of expr and comma.
+
+            # The chomp will be like this:
+            #     [subnode_list, [COMMA, [kw_expr_list, [COMMA]]]]
             expr_list = []
             if len(chomp):
-                expr_list = chomp[0].kid
-                chomp = chomp[1:]
+                expr_list = chomp[0].kid  # Get the kids subnode list.
+                chomp = chomp[2:]  # Get rid of the subnode list and a comma if exists.
                 if len(chomp):
-                    chomp = chomp[1:]
+                    # The chomp will be like this: [kw_expr_list, [COMMA]]
                     expr_list = [*expr_list, *chomp[0].kid]
             expr_list = [first_expr, *expr_list]
             valid_kid = [i for i in expr_list if isinstance(i, (ast.Expr, ast.KWPair))]
@@ -2855,7 +2858,7 @@ class JacParser(Pass):
         def dict_val(self, kid: list[ast.AstNode]) -> ast.DictVal:
             """Grammar rule.
 
-            dict_val: LBRACE ((kv_pair COMMA)* kv_pair)? RBRACE
+            dict_val: LBRACE ((kv_pair COMMA)* kv_pair COMMA?)? RBRACE
             """
             ret = ast.DictVal(
                 kv_pairs=[],
@@ -2912,7 +2915,7 @@ class JacParser(Pass):
         def gen_compr(self, kid: list[ast.AstNode]) -> ast.GenCompr:
             """Grammar rule.
 
-            gen_compr: LSQUARE expression inner_compr+ RSQUARE
+            gen_compr: LPAREN expression inner_compr+ RPAREN
             """
             comprs = [i for i in kid if isinstance(i, ast.InnerCompr)]
             if isinstance(kid[1], ast.Expr):
@@ -2929,7 +2932,7 @@ class JacParser(Pass):
         def set_compr(self, kid: list[ast.AstNode]) -> ast.SetCompr:
             """Grammar rule.
 
-            set_compr: LSQUARE expression inner_compr+ RSQUARE
+            set_compr: LBRACE expression inner_compr+ RBRACE
             """
             comprs = [i for i in kid if isinstance(i, ast.InnerCompr)]
             if isinstance(kid[1], ast.Expr) and isinstance(kid[2], ast.InnerCompr):
@@ -2993,12 +2996,21 @@ class JacParser(Pass):
         ) -> ast.SubNodeList[ast.Expr | ast.KWPair]:
             """Grammar rule.
 
-            param_list: expr_list COMMA kw_expr_list
-                    | kw_expr_list
-                    | expr_list
+            param_list: expr_list    COMMA kw_expr_list COMMA?
+                      | kw_expr_list COMMA?
+                      | expr_list    COMMA?
             """
-            if len(kid) == 1:
+            ends_with_comma = (
+                len(kid) > 1
+                and isinstance(kid[-1], ast.Token)
+                and kid[-1].name == "COMMA"
+            )
+            if len(kid) == 1 or (len(kid) == 2 and ends_with_comma):
                 if isinstance(kid[0], ast.SubNodeList):
+                    if (
+                        ends_with_comma
+                    ):  # Append the trailing comma to the subnode list.
+                        kid[0].kid.append(kid[1])
                     return self.nu(kid[0])
                 else:
                     raise self.ice()
@@ -3146,7 +3158,7 @@ class JacParser(Pass):
         def type_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef:
             """Grammar rule.
 
-            type_ref: TYPE_OP name_ref
+            type_ref: TYPE_OP (named_ref | builtin_type)
             """
             if isinstance(kid[0], ast.Token) and isinstance(kid[1], ast.NameAtom):
                 return self.nu(
@@ -3587,7 +3599,7 @@ class JacParser(Pass):
             match_case_block: KW_CASE pattern_seq (KW_IF expression)? COLON statement_list
             """
             pattern = kid[1]
-            guard = kid[3] if len(kid) > 4 else None
+            guard = kid[3] if isinstance(kid[3], ast.Expr) else None
             stmts = [i for i in kid if isinstance(i, ast.CodeBlockStmt)]
             if isinstance(pattern, ast.MatchPattern) and isinstance(
                 guard, (ast.Expr, type(None))

{jaclang-0.7.19 → jaclang-0.7.21}/jaclang/compiler/passes/main/__init__.py

@@ -13,7 +13,7 @@ from .type_check_pass import JacTypeCheckPass  # noqa: I100
 from .registry_pass import RegistryPass  # noqa: I100
 
 
-pass_schedule = py_code_gen
+pass_schedule = py_code_gen  # type: ignore[has-type]
 
 __all__ = [
     "SubNodeTabPass",

{jaclang-0.7.19 → jaclang-0.7.21}/jaclang/compiler/passes/main/fuse_typeinfo_pass.py

@@ -6,6 +6,7 @@ mypy apis into Jac and use jac py ast in it.
 
 from __future__ import annotations
 
+import re
 from typing import Callable, Optional, TypeVar
 
 import jaclang.compiler.absyntree as ast
@@ -46,24 +47,24 @@ class FuseTypeInfoPass(Pass):
             )
 
     def __set_sym_table_link(self, node: ast.AstSymbolNode) -> None:
-        typ = node.sym_type.split(".")
         typ_sym_table = self.ir.sym_tab
+        assert isinstance(self.ir, ast.Module)
 
-        if typ[0] == "builtins":
-            return
+        sym_type = node.sym_type
+        if re.match(r"builtins.(list|dict|tuple)", sym_type):
+            sym_type = re.sub(r"\[.*\]", "", sym_type)
+
+        typ = sym_type.split(".")
 
         if node.sym_type == "types.ModuleType" and node.sym:
             node.name_spec.type_sym_tab = node.sym.parent_tab.find_scope(node.sym_name)
 
-        assert isinstance(self.ir, ast.Module)
-
-        if typ_sym_table:
-            for i in typ:
-                if i == self.ir.name:
-                    continue
-                f = typ_sym_table.find_scope(i)
-                if f:
-                    typ_sym_table = f
+        for i in typ:
+            if i == self.ir.name:
+                continue
+            f = typ_sym_table.find_scope(i)
+            if f:
+                typ_sym_table = f
 
         if typ_sym_table != self.ir.sym_tab:
             node.name_spec.type_sym_tab = typ_sym_table
@@ -144,6 +145,11 @@ class FuseTypeInfoPass(Pass):
                         self.__set_sym_table_link(node)
                         self.__collect_python_dependencies(node)
 
+                # Special handing for BuiltinType
+                elif isinstance(node, ast.BuiltinType):
+                    func(self, node)  # type: ignore
+                    self.__set_sym_table_link(node)
+
                 # Jac node doesn't have mypy nodes linked to it
                 else:
                     self.__debug_print(
@@ -209,10 +215,21 @@ class FuseTypeInfoPass(Pass):
                     f"{type(mypy_node)}"
                 )
 
+    def __check_builltin_symbol(self, node: ast.NameAtom) -> None:
+        if isinstance(node.parent, ast.AtomTrailer) and node is node.parent.right:
+            return
+        builtins_sym_tab = self.ir.sym_tab.find_scope("builtins")
+        assert builtins_sym_tab is not None
+        builtins_sym = builtins_sym_tab.lookup(node.sym_name)
+        if builtins_sym:
+            node.name_spec._sym = builtins_sym
+
     @__handle_node
     def enter_name(self, node: ast.NameAtom) -> None:
         """Pass handler for name nodes."""
         self.__collect_type_from_symbol(node)
+        if node.sym is None:
+            self.__check_builltin_symbol(node)
 
     @__handle_node
     def enter_module_path(self, node: ast.ModulePath) -> None:
@@ -423,7 +440,8 @@ class FuseTypeInfoPass(Pass):
     @__handle_node
     def enter_builtin_type(self, node: ast.BuiltinType) -> None:
         """Pass handler for BuiltinType nodes."""
-        self.__collect_type_from_symbol(node)
+        self.__check_builltin_symbol(node)
+        node.name_spec.sym_type = f"builtins.{node.sym_name}"
 
     def get_type_from_instance(
         self, node: ast.AstSymbolNode, mypy_type: MypyTypes.Instance
@@ -483,6 +501,21 @@ class FuseTypeInfoPass(Pass):
                 if self_obj.type_sym_tab and isinstance(right_obj, ast.AstSymbolNode):
                     self_obj.type_sym_tab.def_insert(right_obj)
 
+        # Support adding the correct type symbol table in case of ModuleType
+        # This will only work for target=Val & target1=target2=val and
+        #   target is a moduleType
+        # it won't work in case of
+        #   - target1, target2 = Val1, Val2  <-- tuples need more attention
+        #   - target = a.b.c                 <-- will be fixed after thakee's PR
+        #   - a.b.c = val                    <-- will be fixed after thakee's PR
+        for target in node.target.items:
+            if (
+                isinstance(target, ast.Name)
+                and target.sym_type == "types.ModuleType"
+                and isinstance(node.value, ast.Name)
+            ):
+                target.type_sym_tab = node.value.type_sym_tab
+
     def expand_atom_trailer(self, node_list: list[ast.AstNode]) -> list[ast.AstNode]:
         """Expand the atom trailer object in a list of AstNode."""
         out: list[ast.AstNode] = []
@@ -552,6 +585,10 @@ class FuseTypeInfoPass(Pass):
                 type_symtab: Optional[SymbolTable] = self.ir.sym_tab
                 assert isinstance(self.ir, ast.Module)
                 assert isinstance(type_symtab, SymbolTable)
+
+                if re.match(r"builtins.(list|dict|tuple)", node_type):
+                    node_type = re.sub(r"\[.*\]", "", node_type)
+
                 for j in node_type.split("."):
                     if j == self.ir.name:
                         continue

{jaclang-0.7.19 → jaclang-0.7.21}/jaclang/compiler/passes/main/import_pass.py

@@ -7,6 +7,7 @@ symbols are available for matching.
 
 import ast as py_ast
 import os
+import pathlib
 from typing import Optional
 
 
@@ -200,6 +201,7 @@ class PyImportPass(JacImportPass):
     def before_pass(self) -> None:
         """Only run pass if settings are set to raise python."""
         super().before_pass()
+        self.__load_builtins()
 
     def __get_current_module(self, node: ast.AstNode) -> str:
         parent = node.find_parent_of_type(ast.Module)
@@ -296,6 +298,31 @@ class PyImportPass(JacImportPass):
             raise e
         return None
 
+    def __load_builtins(self) -> None:
+        """Pyraise builtins to help with builtins auto complete."""
+        from jaclang.compiler.passes.main import PyastBuildPass
+
+        assert isinstance(self.ir, ast.Module)
+
+        file_to_raise = str(
+            pathlib.Path(os.path.dirname(__file__)).parent.parent.parent
+            / "vendor"
+            / "mypy"
+            / "typeshed"
+            / "stdlib"
+            / "builtins.pyi"
+        )
+        with open(file_to_raise, "r", encoding="utf-8") as f:
+            mod = PyastBuildPass(
+                input_ir=ast.PythonModuleAst(
+                    py_ast.parse(f.read()), mod_path=file_to_raise
+                ),
+            ).ir
+            mod.parent = self.ir
+            SubNodeTabPass(input_ir=mod, prior=self)
+            SymTabBuildPass(input_ir=mod, prior=self)
+            mod.parent = None
+
     def annex_impl(self, node: ast.Module) -> None:
         """Annex impl and test modules."""
         return None

{jaclang-0.7.19 → jaclang-0.7.21}/jaclang/compiler/passes/main/sym_tab_build_pass.py

@@ -4,10 +4,7 @@ This pass builds the symbol table tree for the Jaseci Ast. It also adds symbols
 for globals, imports, architypes, and abilities declarations and definitions.
 """
 
-import builtins
-
 import jaclang.compiler.absyntree as ast
-from jaclang.compiler.constant import Tokens as Tok
 from jaclang.compiler.passes import Pass
 from jaclang.compiler.symtable import SymbolTable
 
@@ -54,21 +51,6 @@ class SymTabBuildPass(Pass):
         """
         self.push_scope(node.name, node)
         self.sync_node_to_scope(node)
-        for obj in dir(builtins):
-            builtin = ast.Name(
-                file_path=node.loc.mod_path,
-                name=Tok.NAME,
-                value=str(obj),
-                line=0,
-                end_line=0,
-                col_start=0,
-                col_end=0,
-                pos_start=0,
-                pos_end=0,
-            )
-            self.sync_node_to_scope(builtin)
-            builtin.sym_tab.def_insert(builtin)
-        # self.def_insert(ast.Name.gen_stub_from_node(node.name, "root"))
 
     def exit_module(self, node: ast.Module) -> None:
         """Sub objects.

jaclang-0.7.21/jaclang/compiler/passes/main/tests/fixtures/mod_type_assign.jac

@@ -0,0 +1,7 @@
+import:jac blip;
+
+
+with entry{
+    kl = blip;
+    l1 = l2 = blip;
+}

{jaclang-0.7.19 → jaclang-0.7.21}/jaclang/compiler/passes/main/tests/test_type_check_pass.py

@@ -59,6 +59,6 @@ class MypyTypeCheckPassTests(TestCase):
         self.assertIn("HasVar - species - Type: builtins.str", out)
         self.assertIn("myDog - Type: type_info.Dog", out)
         self.assertIn("Body - Type: type_info.Dog.Body", out)
-        self.assertEqual(out.count("Type: builtins.str"), 28)
+        self.assertEqual(out.count("Type: builtins.str"), 34)
         for i in lis:
             self.assertNotIn(i, out)

jaclang-0.7.21/jaclang/compiler/passes/main/tests/test_typeinfo_pass.py

@@ -0,0 +1,29 @@
+"""Test pass module."""
+
+from jaclang.compiler.compile import jac_file_to_pass
+from jaclang.compiler.passes.main.fuse_typeinfo_pass import FuseTypeInfoPass
+from jaclang.compiler.passes.main.schedules import py_code_gen_typed
+from jaclang.utils.test import TestCase
+
+
+class TestFuseTypeInfo(TestCase):
+    """Test FuseTypeInfoPass module."""
+
+    def setUp(self) -> None:
+        """Set up test."""
+        return super().setUp()
+
+    def test_mod_type_assign(self) -> None:
+        """Test module type assignment."""
+        gen_ast = jac_file_to_pass(
+            self.fixture_abs_path("mod_type_assign.jac"),
+            FuseTypeInfoPass,
+            schedule=py_code_gen_typed,
+        ).ir.pp()
+        type_info_list = [
+            "kl - Type: types.ModuleType,  SymbolTable: blip",
+            "l1 - Type: types.ModuleType,  SymbolTable: blip",
+            "l2 - Type: types.ModuleType,  SymbolTable: blip",
+        ]
+        for type_info in type_info_list:
+            self.assertIn(type_info, str(gen_ast))

{jaclang-0.7.19 → jaclang-0.7.21}/jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -282,6 +282,16 @@ class JacFormatPass(Pass):
                         if prev_token and isinstance(prev_token, ast.Ability):
                             self.emit(node, f"{stmt.gen.jac}")
                         else:
+                            token_before = self.token_before(stmt)
+                            if (
+                                token_before is not None
+                                and isinstance(token_before, ast.Token)
+                                and token_before.name == Tok.LBRACE
+                                and stmt.loc.first_line - token_before.loc.last_line > 1
+                            ):
+                                self.indent_level -= 1
+                                self.emit_ln(node, "")
+                                self.indent_level += 1
                             self.emit(node, stmt.gen.jac)
                             self.indent_level -= 1
                             self.emit_ln(stmt, "")
@@ -394,7 +404,9 @@ class JacFormatPass(Pass):
                     indented = True
                 for count, j in enumerate(i.kid):
                     if j.gen.jac == ",":
-                        if i.kid[count + 1].gen.jac.startswith("#"):
+                        if len(i.kid) > count + 1 and i.kid[
+                            count + 1
+                        ].gen.jac.startswith("#"):
                             self.indent_level -= 1
                             self.emit(node, f"{j.gen.jac} ")
                             self.indent_level += 1