jaclang 0.5.17__py3-none-any.whl → 0.6.0__py3-none-any.whl

jaclang/compiler/passes/main/pyast_gen_pass.py

@@ -492,17 +492,20 @@ class PyastGenPass(Pass):
             py_nodes.append(
                 self.sync(ast3.Expr(value=node.doc.gen.py_ast[0]), jac_node=node.doc)
             )
-        py_compat_path_str = []
-        path_alias = {}
-        for path in node.paths:
-            py_compat_path_str.append(path.path_str.lstrip("."))
-            path_alias[path.path_str] = path.alias.sym_name if path.alias else None
+        path_alias: dict[str, Optional[str]] = (
+            {node.from_loc.path_str: None} if node.from_loc else {}
+        )
         imp_from = {}
         if node.items:
             for item in node.items.items:
-                imp_from[item.name.sym_name] = (
-                    item.alias.sym_name if item.alias else False
-                )
+                if isinstance(item, ast.ModuleItem):
+                    imp_from[item.name.sym_name] = (
+                        item.alias.sym_name if item.alias else False
+                    )
+                elif isinstance(item, ast.ModulePath):
+                    path_alias[item.path_str] = (
+                        item.alias.sym_name if item.alias else None
+                    )
 
         keys = []
         values = []
@@ -594,10 +597,13 @@ class PyastGenPass(Pass):
                 )
             )
         if node.is_absorb:
+            source = node.items.items[0]
+            if not isinstance(source, ast.ModulePath):
+                raise self.ice()
             py_nodes.append(
                 self.sync(
                     py_node=ast3.ImportFrom(
-                        module=py_compat_path_str[0] if py_compat_path_str[0] else None,
+                        module=(source.path_str.lstrip(".") if source else None),
                         names=[self.sync(ast3.alias(name="*"), node)],
                         level=0,
                     ),
@@ -605,18 +611,21 @@ class PyastGenPass(Pass):
                 )
             )
             if node.items:
-                self.warning(
-                    "Includes import * in target module into current namespace."
-                )
-        if not node.items:
-            py_nodes.append(
-                self.sync(ast3.Import(names=[i.gen.py_ast[0] for i in node.paths]))
-            )
+                pass
+                # self.warning(
+                #     "Includes import * in target module into current namespace."
+                # )
+        if not node.from_loc:
+            py_nodes.append(self.sync(ast3.Import(names=node.items.gen.py_ast)))
         else:
             py_nodes.append(
                 self.sync(
                     ast3.ImportFrom(
-                        module=py_compat_path_str[0] if py_compat_path_str[0] else None,
+                        module=(
+                            node.from_loc.path_str.lstrip(".")
+                            if node.from_loc
+                            else None
+                        ),
                         names=node.items.gen.py_ast,
                         level=0,
                     )
@@ -668,8 +677,6 @@ class PyastGenPass(Pass):
         doc: Optional[String],
         decorators: Optional[SubNodeList[ExprType]],
         """
-        self.needs_jac_feature()
-        self.needs_dataclass()
         body = self.resolve_stmt_block(
             node.body.body if isinstance(node.body, ast.ArchDef) else node.body,
             doc=node.doc,
@@ -681,6 +688,8 @@ class PyastGenPass(Pass):
         )
         ds_on_entry, ds_on_exit = self.collect_events(node)
         if node.arch_type.name != Tok.KW_CLASS:
+            self.needs_jac_feature()
+            self.needs_dataclass()
             decorators.append(
                 self.sync(
                     ast3.Call(
@@ -715,24 +724,26 @@ class PyastGenPass(Pass):
                     )
                 )
             )
-        decorators.append(
-            self.sync(
-                ast3.Call(
-                    func=self.sync(ast3.Name(id="__jac_dataclass__", ctx=ast3.Load())),
-                    args=[],
-                    keywords=[
-                        self.sync(
-                            ast3.keyword(
-                                arg="eq",
-                                value=self.sync(
-                                    ast3.Constant(value=False),
-                                ),
+            decorators.append(
+                self.sync(
+                    ast3.Call(
+                        func=self.sync(
+                            ast3.Name(id="__jac_dataclass__", ctx=ast3.Load())
+                        ),
+                        args=[],
+                        keywords=[
+                            self.sync(
+                                ast3.keyword(
+                                    arg="eq",
+                                    value=self.sync(
+                                        ast3.Constant(value=False),
+                                    ),
+                                )
                             )
-                        )
-                    ],
+                        ],
+                    )
                 )
             )
-        )
         base_classes = node.base_classes.gen.py_ast if node.base_classes else []
         if node.is_abstract:
             self.needs_jac_feature()
@@ -1057,7 +1068,11 @@ class PyastGenPass(Pass):
                 if isinstance(node.signature, ast.FuncSignature)
                 else []
             )
-            action = node.semstr.gen.py_ast[0] if node.semstr else None
+            action = (
+                node.semstr.gen.py_ast[0]
+                if node.semstr
+                else self.sync(ast3.Constant(value=None))
+            )
             return [
                 self.sync(
                     ast3.Assign(
@@ -1377,12 +1392,20 @@ class PyastGenPass(Pass):
             ):
                 node.gen.py_ast = [
                     self.sync(
-                        ast3.Attribute(
-                            value=self.sync(
-                                ast3.Name(id=Con.JAC_FEATURE.value, ctx=ast3.Load())
+                        ast3.Call(
+                            func=self.sync(
+                                ast3.Attribute(
+                                    value=self.sync(
+                                        ast3.Name(
+                                            id=Con.JAC_FEATURE.value, ctx=ast3.Load()
+                                        )
+                                    ),
+                                    attr="get_root_type",
+                                    ctx=ast3.Load(),
+                                )
                             ),
-                            attr="RootType",
-                            ctx=ast3.Load(),
+                            args=[],
+                            keywords=[],
                         )
                     )
                 ]
@@ -1674,7 +1697,7 @@ class PyastGenPass(Pass):
             self.sync(
                 ast3.Try(
                     body=self.resolve_stmt_block(node.body),
-                    handlers=node.excepts.gen.py_ast if node.excepts else None,
+                    handlers=node.excepts.gen.py_ast if node.excepts else [],
                     orelse=node.else_body.gen.py_ast if node.else_body else [],
                     finalbody=node.finally_body.gen.py_ast if node.finally_body else [],
                 )
@@ -2376,7 +2399,19 @@ class PyastGenPass(Pass):
         node.gen.py_ast = [
             self.sync(
                 ast3.Lambda(
-                    args=node.signature.gen.py_ast[0],
+                    args=(
+                        node.signature.gen.py_ast[0]
+                        if node.signature
+                        else self.sync(
+                            ast3.arguments(
+                                posonlyargs=[],
+                                args=[],
+                                kwonlyargs=[],
+                                kw_defaults=[],
+                                defaults=[],
+                            )
+                        )
+                    ),
                     body=node.body.gen.py_ast[0],
                 )
             )
@@ -2435,11 +2470,16 @@ class PyastGenPass(Pass):
                 )
             ]
         elif node.op.name in [Tok.STAR_MUL]:
+            ctx_val = (
+                node.operand.py_ctx_func()
+                if isinstance(node.operand, ast.AstSymbolNode)
+                else ast3.Load()
+            )
             node.gen.py_ast = [
                 self.sync(
                     ast3.Starred(
                         value=node.operand.gen.py_ast[0],
-                        ctx=ast3.Load(),
+                        ctx=ctx_val,
                     )
                 )
             ]
@@ -3648,7 +3688,22 @@ class PyastGenPass(Pass):
         pos_start: int,
         pos_end: int,
         """
-        node.gen.py_ast = [self.sync(ast3.Constant(value=int(node.value)))]
+
+        def handle_node_value(value: str) -> int:
+            if value.startswith(("0x", "0X")):
+                return int(value, 16)
+            elif value.startswith(("0b", "0B")):
+                return int(value, 2)
+            elif value.startswith(("0o", "0O")):
+                return int(value, 8)
+            else:
+                return int(value)
+
+        node.gen.py_ast = [
+            self.sync(
+                ast3.Constant(value=handle_node_value(str(node.value)), kind=None)
+            )
+        ]
 
     def exit_string(self, node: ast.String) -> None:
         """Sub objects.