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

jaclang/compiler/parser.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-
+import keyword
 import logging
 import os
 from typing import Callable, TypeAlias
@@ -167,7 +167,6 @@ class JacParser(Pass):
             """Grammar rule.
 
             element: py_code_block
-                | include_stmt
                 | import_stmt
                 | ability
                 | architype
@@ -283,7 +282,10 @@ class JacParser(Pass):
 
             import_stmt: KW_IMPORT sub_name KW_FROM from_path COMMA import_items SEMI
                     | KW_IMPORT sub_name import_path (COMMA import_path)* SEMI
+                    | include_stmt
             """
+            if len(kid) == 1 and isinstance(kid[0], ast.Import):
+                return self.nu(kid[0])
             lang = kid[1]
             paths = [i for i in kid if isinstance(i, ast.ModulePath)]
 
@@ -2321,16 +2323,34 @@ class JacParser(Pass):
         def atomic_call(self, kid: list[ast.AstNode]) -> ast.FuncCall:
             """Grammar rule.
 
-            atomic_call: atomic_chain LPAREN param_list? RPAREN
+            atomic_call: atomic_chain LPAREN param_list? (KW_BY atomic_call)? RPAREN
             """
+            if (
+                len(kid) > 4
+                and isinstance(kid[0], ast.Expr)
+                and kid[-2]
+                and isinstance(kid[-2], ast.FuncCall)
+            ):
+                return self.nu(
+                    ast.FuncCall(
+                        target=kid[0],
+                        params=kid[2] if isinstance(kid[2], ast.SubNodeList) else None,
+                        genai_call=kid[-2],
+                        kid=kid,
+                    )
+                )
             if (
                 len(kid) == 4
                 and isinstance(kid[0], ast.Expr)
                 and isinstance(kid[2], ast.SubNodeList)
             ):
-                return self.nu(ast.FuncCall(target=kid[0], params=kid[2], kid=kid))
+                return self.nu(
+                    ast.FuncCall(target=kid[0], params=kid[2], genai_call=None, kid=kid)
+                )
             elif len(kid) == 3 and isinstance(kid[0], ast.Expr):
-                return self.nu(ast.FuncCall(target=kid[0], params=None, kid=kid))
+                return self.nu(
+                    ast.FuncCall(target=kid[0], params=None, genai_call=None, kid=kid)
+                )
             else:
                 raise self.ice()
 
@@ -3814,21 +3834,7 @@ class JacParser(Pass):
         def __default_token__(self, token: jl.Token) -> ast.Token:
             """Token handler."""
             ret_type = ast.Token
-            if token.type == Tok.KWESC_NAME:
-                return self.nu(
-                    ast.Name(
-                        file_path=self.parse_ref.mod_path,
-                        name=token.type,
-                        value=token.value[2:],
-                        line=token.line if token.line is not None else 0,
-                        col_start=token.column if token.column is not None else 0,
-                        col_end=token.end_column if token.end_column is not None else 0,
-                        pos_start=token.start_pos if token.start_pos is not None else 0,
-                        pos_end=token.end_pos if token.end_pos is not None else 0,
-                        is_kwesc=True,
-                    )
-                )
-            elif token.type == Tok.NAME:
+            if token.type in [Tok.NAME, Tok.KWESC_NAME]:
                 ret_type = ast.Name
             elif token.type == Tok.SEMI:
                 ret_type = ast.Semi
@@ -3854,15 +3860,22 @@ class JacParser(Pass):
                 ret_type = ast.Bool
             elif token.type == Tok.PYNLINE and isinstance(token.value, str):
                 token.value = token.value.replace("::py::", "")
-            return self.nu(
-                ret_type(
-                    file_path=self.parse_ref.mod_path,
-                    name=token.type,
-                    value=token.value,
-                    line=token.line if token.line is not None else 0,
-                    col_start=token.column if token.column is not None else 0,
-                    col_end=token.end_column if token.end_column is not None else 0,
-                    pos_start=token.start_pos if token.start_pos is not None else 0,
-                    pos_end=token.end_pos if token.end_pos is not None else 0,
-                )
+            ret = ret_type(
+                file_path=self.parse_ref.mod_path,
+                name=token.type,
+                value=token.value[2:] if token.type == Tok.KWESC_NAME else token.value,
+                line=token.line if token.line is not None else 0,
+                col_start=token.column if token.column is not None else 0,
+                col_end=token.end_column if token.end_column is not None else 0,
+                pos_start=token.start_pos if token.start_pos is not None else 0,
+                pos_end=token.end_pos if token.end_pos is not None else 0,
             )
+            if isinstance(ret, ast.Name):
+                if token.type == Tok.KWESC_NAME:
+                    ret.is_kwesc = True
+                if ret.value in keyword.kwlist:
+                    err = jl.UnexpectedInput(f"Python keyword {ret.value} used as name")
+                    err.line = ret.loc.first_line
+                    err.column = ret.loc.col_start
+                    raise err
+            return self.nu(ret)

jaclang/compiler/passes/main/fuse_typeinfo_pass.py

@@ -13,9 +13,11 @@ from typing import Callable, TypeVar
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.passes import Pass
 from jaclang.utils.helpers import pascal_to_snake
+from jaclang.vendor.mypy.nodes import Node as VNode  # bit of a hack
 
-import mypy.nodes as MypyNode  # noqa N812
+import mypy.nodes as MypyNodes  # noqa N812
 import mypy.types as MypyTypes  # noqa N812
+from mypy.checkexpr import Type as MyType
 
 
 T = TypeVar("T", bound=ast.AstSymbolNode)
@@ -24,6 +26,8 @@ T = TypeVar("T", bound=ast.AstSymbolNode)
 class FuseTypeInfoPass(Pass):
     """Python and bytecode file self.__debug_printing pass."""
 
+    node_type_hash: dict[MypyNodes.Node | VNode, MyType] = {}
+
     def __debug_print(self, *argv: object) -> None:
         if "FuseTypeInfoDebug" in os.environ:
             print("FuseTypeInfo::", *argv)
@@ -89,7 +93,9 @@ class FuseTypeInfoPass(Pass):
                             jac_node_str, "has multiple mypy nodes associated to it"
                         )
                     else:
-                        # self.__debug_print(jac_node_str, "has duplicate mypy nodes associated to it")
+                        self.__debug_print(
+                            jac_node_str, "has duplicate mypy nodes associated to it"
+                        )
                         func(self, node)
                         self.__set_sym_table_link(node)
 
@@ -108,32 +114,28 @@ class FuseTypeInfoPass(Pass):
 
         return node_handler
 
-    def enter_import(self, node: ast.Import) -> None:
-        """Pass handler for import nodes."""
-        # Pruning the import nodes
-        self.prune()
-
-    @__handle_node
-    def enter_name(self, node: ast.NameSpec) -> None:
-        """Pass handler for name nodes."""
+    def __collect_type_from_symbol(self, node: ast.AstSymbolNode) -> None:
         mypy_node = node.gen.mypy_ast[0]
 
         if hasattr(mypy_node, "node"):
             # orig_node = mypy_node
             mypy_node = mypy_node.node
 
-            if isinstance(mypy_node, (MypyNode.Var, MypyNode.FuncDef)):
+            if isinstance(mypy_node, (MypyNodes.Var, MypyNodes.FuncDef)):
                 self.__call_type_handler(node, mypy_node.type)
 
-            elif isinstance(mypy_node, MypyNode.MypyFile):
+            elif isinstance(mypy_node, MypyNodes.MypyFile):
                 node.sym_info = ast.SymbolInfo("types.ModuleType")
 
-            elif isinstance(mypy_node, MypyNode.TypeInfo):
+            elif isinstance(mypy_node, MypyNodes.TypeInfo):
                 node.sym_info = ast.SymbolInfo(mypy_node.fullname)
 
-            elif isinstance(mypy_node, MypyNode.OverloadedFuncDef):
+            elif isinstance(mypy_node, MypyNodes.OverloadedFuncDef):
                 self.__call_type_handler(node, mypy_node.items[0].func.type)
 
+            elif mypy_node is None:
+                node.sym_info = ast.SymbolInfo("None")
+
             else:
                 self.__debug_print(
                     f'"{node.loc}::{node.__class__.__name__}" mypy (with node attr) node isn\'t supported',
@@ -141,19 +143,31 @@ class FuseTypeInfoPass(Pass):
                 )
 
         else:
-            if isinstance(mypy_node, MypyNode.ClassDef):
+            if isinstance(mypy_node, MypyNodes.ClassDef):
                 node.sym_info.typ = mypy_node.fullname
                 self.__set_sym_table_link(node)
-            elif isinstance(mypy_node, MypyNode.FuncDef):
+            elif isinstance(mypy_node, MypyNodes.FuncDef):
                 self.__call_type_handler(node, mypy_node.type)
-            elif isinstance(mypy_node, MypyNode.Argument):
+            elif isinstance(mypy_node, MypyNodes.Argument):
                 self.__call_type_handler(node, mypy_node.variable.type)
+            elif isinstance(mypy_node, MypyNodes.Decorator):
+                self.__call_type_handler(node, mypy_node.func.type.ret_type)
             else:
                 self.__debug_print(
                     f'"{node.loc}::{node.__class__.__name__}" mypy node isn\'t supported',
                     type(mypy_node),
                 )
 
+    def enter_import(self, node: ast.Import) -> None:
+        """Pass handler for import nodes."""
+        # Pruning the import nodes
+        self.prune()
+
+    @__handle_node
+    def enter_name(self, node: ast.NameSpec) -> None:
+        """Pass handler for name nodes."""
+        self.__collect_type_from_symbol(node)
+
     @__handle_node
     def enter_module_path(self, node: ast.ModulePath) -> None:
         """Pass handler for ModulePath nodes."""
@@ -167,7 +181,7 @@ class FuseTypeInfoPass(Pass):
     @__handle_node
     def enter_architype(self, node: ast.Architype) -> None:
         """Pass handler for Architype nodes."""
-        self.__debug_print("Getting type not supported in", type(node))
+        self.__collect_type_from_symbol(node)
 
     @__handle_node
     def enter_arch_def(self, node: ast.ArchDef) -> None:
@@ -177,7 +191,7 @@ class FuseTypeInfoPass(Pass):
     @__handle_node
     def enter_enum(self, node: ast.Enum) -> None:
         """Pass handler for Enum nodes."""
-        self.__debug_print("Getting type not supported in", type(node))
+        self.__collect_type_from_symbol(node)
 
     @__handle_node
     def enter_enum_def(self, node: ast.EnumDef) -> None:
@@ -187,23 +201,30 @@ class FuseTypeInfoPass(Pass):
     @__handle_node
     def enter_ability(self, node: ast.Ability) -> None:
         """Pass handler for Ability nodes."""
-        if isinstance(node.gen.mypy_ast[0], MypyNode.FuncDef):
+        if isinstance(node.gen.mypy_ast[0], MypyNodes.FuncDef):
             self.__call_type_handler(node, node.gen.mypy_ast[0].type.ret_type)
         else:
             self.__debug_print(
-                f"{node.loc}: Can't get type of an ability from mypy node other than Ability."
+                f"{node.loc}: Can't get type of an ability from mypy node other than Ability.",
+                type(node.gen.mypy_ast[0]),
             )
 
     @__handle_node
     def enter_ability_def(self, node: ast.AbilityDef) -> None:
         """Pass handler for AbilityDef nodes."""
-        self.__debug_print("Getting type not supported in", type(node))
+        if isinstance(node.gen.mypy_ast[0], MypyNodes.FuncDef):
+            self.__call_type_handler(node, node.gen.mypy_ast[0].type.ret_type)
+        else:
+            self.__debug_print(
+                f"{node.loc}: Can't get type of an AbilityDef from mypy node other than FuncDef.",
+                type(node.gen.mypy_ast[0]),
+            )
 
     @__handle_node
     def enter_param_var(self, node: ast.ParamVar) -> None:
         """Pass handler for ParamVar nodes."""
-        if isinstance(node.gen.mypy_ast[0], MypyNode.Argument):
-            mypy_node: MypyNode.Argument = node.gen.mypy_ast[0]
+        if isinstance(node.gen.mypy_ast[0], MypyNodes.Argument):
+            mypy_node: MypyNodes.Argument = node.gen.mypy_ast[0]
             if mypy_node.variable.type:
                 self.__call_type_handler(node, mypy_node.variable.type)
         else:
@@ -216,9 +237,9 @@ class FuseTypeInfoPass(Pass):
     def enter_has_var(self, node: ast.HasVar) -> None:
         """Pass handler for HasVar nodes."""
         mypy_node = node.gen.mypy_ast[0]
-        if isinstance(mypy_node, MypyNode.AssignmentStmt):
+        if isinstance(mypy_node, MypyNodes.AssignmentStmt):
             n = mypy_node.lvalues[0].node
-            if isinstance(n, (MypyNode.Var, MypyNode.FuncDef)):
+            if isinstance(n, (MypyNodes.Var, MypyNodes.FuncDef)):
                 self.__call_type_handler(node, n.type)
             else:
                 self.__debug_print(
@@ -242,32 +263,50 @@ class FuseTypeInfoPass(Pass):
     @__handle_node
     def enter_list_val(self, node: ast.ListVal) -> None:
         """Pass handler for ListVal nodes."""
-        self.__debug_print("Getting type not supported in", type(node))
+        mypy_node = node.gen.mypy_ast[0]
+        if mypy_node in self.node_type_hash:
+            node.sym_info.typ = str(self.node_type_hash[mypy_node])
+        else:
+            node.sym_info.typ = "builtins.list"
 
     @__handle_node
     def enter_set_val(self, node: ast.SetVal) -> None:
         """Pass handler for SetVal nodes."""
-        self.__debug_print("Getting type not supported in", type(node))
+        mypy_node = node.gen.mypy_ast[0]
+        if mypy_node in self.node_type_hash:
+            node.sym_info.typ = str(self.node_type_hash[mypy_node])
+        else:
+            node.sym_info.typ = "builtins.set"
 
     @__handle_node
     def enter_tuple_val(self, node: ast.TupleVal) -> None:
         """Pass handler for TupleVal nodes."""
-        self.__debug_print("Getting type not supported in", type(node))
+        mypy_node = node.gen.mypy_ast[0]
+        if mypy_node in self.node_type_hash:
+            node.sym_info.typ = str(self.node_type_hash[mypy_node])
+        else:
+            node.sym_info.typ = "builtins.tuple"
 
     @__handle_node
     def enter_dict_val(self, node: ast.DictVal) -> None:
         """Pass handler for DictVal nodes."""
-        self.__debug_print("Getting type not supported in", type(node))
+        mypy_node = node.gen.mypy_ast[0]
+        if mypy_node in self.node_type_hash:
+            node.sym_info.typ = str(self.node_type_hash[mypy_node])
+        else:
+            node.sym_info.typ = "builtins.dict"
 
     @__handle_node
     def enter_list_compr(self, node: ast.ListCompr) -> None:
         """Pass handler for ListCompr nodes."""
-        self.__debug_print("Getting type not supported in", type(node))
+        mypy_node = node.gen.mypy_ast[0]
+        node.sym_info.typ = str(self.node_type_hash[mypy_node])
 
     @__handle_node
     def enter_dict_compr(self, node: ast.DictCompr) -> None:
         """Pass handler for DictCompr nodes."""
-        self.__debug_print("Getting type not supported in", type(node))
+        mypy_node = node.gen.mypy_ast[0]
+        node.sym_info.typ = str(self.node_type_hash[mypy_node])
 
     @__handle_node
     def enter_index_slice(self, node: ast.IndexSlice) -> None:
@@ -277,13 +316,17 @@ class FuseTypeInfoPass(Pass):
     @__handle_node
     def enter_arch_ref(self, node: ast.ArchRef) -> None:
         """Pass handler for ArchRef nodes."""
-        if isinstance(node.gen.mypy_ast[0], MypyNode.ClassDef):
-            mypy_node: MypyNode.ClassDef = node.gen.mypy_ast[0]
+        if isinstance(node.gen.mypy_ast[0], MypyNodes.ClassDef):
+            mypy_node: MypyNodes.ClassDef = node.gen.mypy_ast[0]
             node.sym_info.typ = mypy_node.fullname
             self.__set_sym_table_link(node)
+        elif isinstance(node.gen.mypy_ast[0], MypyNodes.FuncDef):
+            mypy_node2: MypyNodes.FuncDef = node.gen.mypy_ast[0]
+            self.__call_type_handler(node, mypy_node2.type)
         else:
             self.__debug_print(
-                f"{node.loc}: Can't get ArchRef value from mypyNode other than ClassDef"
+                f"{node.loc}: Can't get ArchRef value from mypyNode other than ClassDef",
+                type(node.gen.mypy_ast[0]),
             )
 
     @__handle_node
@@ -294,7 +337,7 @@ class FuseTypeInfoPass(Pass):
     @__handle_node
     def enter_edge_op_ref(self, node: ast.EdgeOpRef) -> None:
         """Pass handler for EdgeOpRef nodes."""
-        self.__debug_print("Getting type not supported in", type(node))
+        self.__collect_type_from_symbol(node)
 
     @__handle_node
     def enter_filter_compr(self, node: ast.FilterCompr) -> None:
@@ -329,7 +372,7 @@ class FuseTypeInfoPass(Pass):
     @__handle_node
     def enter_builtin_type(self, node: ast.BuiltinType) -> None:
         """Pass handler for BuiltinType nodes."""
-        self.__debug_print("Getting type not supported in", type(node))
+        self.__collect_type_from_symbol(node)
 
     def get_type_from_instance(
         self, node: ast.AstSymbolNode, mypy_type: MypyTypes.Instance
@@ -355,3 +398,15 @@ class FuseTypeInfoPass(Pass):
     ) -> None:
         """Get type info from mypy type NoneType."""
         node.sym_info = ast.SymbolInfo("None")
+
+    def get_type_from_any_type(
+        self, node: ast.AstSymbolNode, mypy_type: MypyTypes.AnyType
+    ) -> None:
+        """Get type info from mypy type NoneType."""
+        node.sym_info = ast.SymbolInfo("Any")
+
+    def get_type_from_tuple_type(
+        self, node: ast.AstSymbolNode, mypy_type: MypyTypes.TupleType
+    ) -> None:
+        """Get type info from mypy type TupleType."""
+        node.sym_info = ast.SymbolInfo("builtins.tuple")

jaclang/compiler/passes/main/import_pass.py

@@ -7,6 +7,7 @@ symbols are available for matching.
 
 import ast as py_ast
 import importlib.util
+import os
 import sys
 from os import path
 from typing import Optional
@@ -47,10 +48,12 @@ class ImportPass(Pass):
                     self.annex_impl(mod)
                     i.sub_module = mod
                     i.add_kids_right([mod], pos_update=False)
-                # elif i.parent.lang.tag.value == "py":
-                #     mod = self.import_py_module(node=i, mod_path=node.loc.mod_path)
-                #     i.sub_module = mod
-                #     i.add_kids_right([mod], pos_update=False)
+                elif i.parent.lang.tag.value == "py" and os.environ.get(
+                    "JAC_PROC_DEBUG", False
+                ):
+                    mod = self.import_py_module(node=i, mod_path=node.loc.mod_path)
+                    i.sub_module = mod
+                    i.add_kids_right([mod], pos_update=False)
                 self.enter_module_path(i)
             SubNodeTabPass(prior=self, input_ir=node)
         self.annex_impl(node)
@@ -95,7 +98,7 @@ class ImportPass(Pass):
         """Import a module."""
         self.cur_node = node  # impacts error reporting
         target = import_target_to_relative_path(
-            node.path_str, path.dirname(node.loc.mod_path)
+            node.level, node.path_str, path.dirname(node.loc.mod_path)
         )
         return self.import_mod_from_file(target)