jaclang 0.7.17__py3-none-any.whl → 0.7.21__py3-none-any.whl

jaclang/cli/cli.py

@@ -8,7 +8,6 @@ import pickle
 import shutil
 import types
 from typing import Optional
-from uuid import UUID
 
 import jaclang.compiler.absyntree as ast
 from jaclang import jac_import
@@ -159,10 +158,9 @@ def get_object(
         raise ValueError("Not a valid file!\nOnly supports `.jac` and `.jir`")
 
     data = {}
-    if id == "root":
-        data = jctx.root.__getstate__()
-    elif obj := jctx.mem.find_by_id(UUID(id)):
-        data = obj.__getstate__()
+    obj = Jac.get_object(id)
+    if obj:
+        data = obj.__jac__.__getstate__()
     else:
         print(f"Object with id {id} not found.")
 
@@ -431,8 +429,8 @@ def dot(
 
     if filename.endswith(".jac"):
         jac_machine = JacMachine(base)
-        jac_import(target=mod, base_path=base)
-        module = jac_machine.loaded_modules.get(mod)
+        jac_import(target=mod, base_path=base, override_name="__main__")
+        module = jac_machine.loaded_modules.get("__main__")
         globals().update(vars(module))
         try:
             node = globals().get(initial, eval(initial)) if initial else None

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/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/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/compiler/passes/ir_pass.py

@@ -133,6 +133,8 @@ class Pass(Transform[T]):
         else:
             self.prune_signal = False
         self.cur_node = node
+        if self.term_signal:
+            return node
         self.exit_node(node)
         return node
 

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/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/compiler/passes/main/import_pass.py

@@ -7,12 +7,14 @@ symbols are available for matching.
 
 import ast as py_ast
 import os
+import pathlib
 from typing import Optional
 
 
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.passes import Pass
 from jaclang.compiler.passes.main import SubNodeTabPass, SymTabBuildPass
+from jaclang.settings import settings
 from jaclang.utils.log import logging
 
 
@@ -105,7 +107,7 @@ class JacImportPass(Pass):
                 or test_folder == os.path.dirname(cur_file)
             ) and cur_file.endswith(".test.jac"):
                 mod = self.import_jac_mod_from_file(cur_file)
-                if mod:
+                if mod and not settings.ignore_test_annex:
                     node.test_mod.append(mod)
                     node.add_kids_right([mod], pos_update=False)
                     mod.parent = node
@@ -199,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)
@@ -295,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/compiler/passes/main/py_collect_dep_pass.py

@@ -7,6 +7,8 @@ that are only relevant to actual references source from Jac code.
 from __future__ import annotations
 
 
+import os
+
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.passes import Pass
 from jaclang.settings import settings
@@ -28,11 +30,15 @@ class PyCollectDepsPass(Pass):
         if not isinstance(node, ast.AstSymbolNode):
             return
 
+        # Adding the path of the file related to the py import
         path: str = ""
         if isinstance(node, ast.ModulePath):
             if node.path:
                 path = ".".join([i.value for i in node.path])
             node.abs_path = self.ir.py_mod_dep_map.get(path)
+            if node.abs_path and os.path.isfile(node.abs_path.replace(".pyi", ".py")):
+                node.abs_path = node.abs_path.replace(".pyi", ".py")
+
         elif isinstance(node, ast.ModuleItem):
             imp = node.parent_of_type(ast.Import)
             mod_path_node = imp.get_all_sub_nodes(ast.ModulePath)[0]
@@ -40,6 +46,8 @@ class PyCollectDepsPass(Pass):
                 path = ".".join([i.value for i in mod_path_node.path])
             path += f".{node.name.value}"
             node.abs_path = self.ir.py_mod_dep_map.get(path)
+            if node.abs_path and os.path.isfile(node.abs_path.replace(".pyi", ".py")):
+                node.abs_path = node.abs_path.replace(".pyi", ".py")
 
         if len(node.gen.mypy_ast) == 0:
             return

jaclang/compiler/passes/main/pyast_gen_pass.py

@@ -2641,6 +2641,31 @@ class PyastGenPass(Pass):
             ]
         elif node.op.name in [Tok.STAR_POW]:
             node.gen.py_ast = node.operand.gen.py_ast
+        elif node.op.name in [Tok.BW_AND]:
+            node.gen.py_ast = [
+                self.sync(
+                    ast3.Call(
+                        func=self.sync(
+                            ast3.Attribute(
+                                value=self.sync(
+                                    ast3.Name(id=Con.JAC_FEATURE.value, ctx=ast3.Load())
+                                ),
+                                attr="get_object",
+                                ctx=ast3.Load(),
+                            )
+                        ),
+                        args=[],
+                        keywords=[
+                            self.sync(
+                                ast3.keyword(
+                                    arg="id",
+                                    value=node.operand.gen.py_ast[0],
+                                )
+                            ),
+                        ],
+                    )
+                )
+            ]
         else:
             self.ice(f"Unknown Unary operator {node.op.value}")