jaclang 0.5.6__py3-none-any.whl → 0.5.8__py3-none-any.whl

jaclang/compiler/passes/main/pyast_gen_pass.py

@@ -138,6 +138,16 @@ class PyastGenPass(Pass):
                 jac_node=self.ir,
             )
         )
+        self.preamble.append(
+            self.sync(
+                ast3.ImportFrom(
+                    module="jaclang.plugin.builtin",
+                    names=[self.sync(ast3.alias(name="*", asname=None))],
+                    level=0,
+                ),
+                jac_node=self.ir,
+            )
+        )
         self.already_added.append("jac_feature")
 
     def needs_dataclass(self) -> None:
@@ -200,9 +210,18 @@ class PyastGenPass(Pass):
                 i.col_offset = jac_node.loc.col_start
                 i.end_lineno = jac_node.loc.last_line
                 i.end_col_offset = jac_node.loc.col_end
-                i.jac_link = jac_node  # type: ignore
+                i.jac_link: list[ast3.AST] = [jac_node]  # type: ignore
         return py_node
 
+    def link_jac_py_nodes(
+        self, jac_node: ast.AstNode, py_nodes: list[ast3.AST]
+    ) -> None:
+        """Link jac name ast to py ast nodes."""
+        jac_node.gen.py_ast = py_nodes
+        for i in py_nodes:
+            if isinstance(i.jac_link, list):  # type: ignore
+                i.jac_link.append(jac_node)  # type: ignore
+
     def pyinline_sync(
         self,
         py_nodes: list[ast3.AST],
@@ -215,7 +234,7 @@ class PyastGenPass(Pass):
                         i.lineno += self.cur_node.loc.first_line
                     if hasattr(i, "end_lineno") and i.end_lineno is not None:
                         i.end_lineno += self.cur_node.loc.first_line
-                    i.jac_link = self.cur_node  # type: ignore
+                    i.jac_link: ast3.AST = [self.cur_node]  # type: ignore
         return py_nodes
 
     def resolve_stmt_block(
@@ -237,7 +256,7 @@ class PyastGenPass(Pass):
                     [
                         x.gen.py_ast
                         for x in node.items
-                        # if not isinstance(x, ast.AstImplOnlyNode)
+                        if not isinstance(x, ast.AstImplOnlyNode)
                     ]
                 )
                 if node and isinstance(node.gen.py_ast, list)
@@ -295,7 +314,8 @@ class PyastGenPass(Pass):
         body: Sequence[ElementStmt],
         is_imported: bool,
         """
-        pre_body = [*node.impl_mod.body, *node.body] if node.impl_mod else node.body
+        clean_body = [i for i in node.body if not isinstance(i, ast.AstImplOnlyNode)]
+        pre_body = [*node.impl_mod.body, *clean_body] if node.impl_mod else clean_body
         pre_body = [*pre_body, *node.test_mod.body] if node.test_mod else pre_body
         body = (
             [
@@ -557,6 +577,8 @@ class PyastGenPass(Pass):
                 )
             )
         ]
+        if node.alias:
+            self.link_jac_py_nodes(jac_node=node.alias, py_nodes=node.gen.py_ast)
 
     def exit_module_item(self, node: ast.ModuleItem) -> None:
         """Sub objects.
@@ -681,6 +703,9 @@ class PyastGenPass(Pass):
                 )
             )
         ]
+        self.link_jac_py_nodes(jac_node=node.name, py_nodes=node.gen.py_ast)
+        if isinstance(node.body, ast.ArchDef):
+            self.link_jac_py_nodes(jac_node=node.body, py_nodes=node.gen.py_ast)
 
     def collect_events(
         self, node: ast.Architype
@@ -733,6 +758,12 @@ class PyastGenPass(Pass):
         doc: Optional[String],
         decorators: Optional[SubNodeList[ExprType]],
         """
+        for i in node.target.archs:
+            if i.sym_link:
+                self.link_jac_py_nodes(jac_node=i, py_nodes=i.sym_link.decl.gen.py_ast)
+                self.link_jac_py_nodes(
+                    jac_node=i.name_ref, py_nodes=i.sym_link.decl.gen.py_ast
+                )
 
     def exit_enum(self, node: ast.Enum) -> None:
         """Sub objects.
@@ -773,6 +804,8 @@ class PyastGenPass(Pass):
                 )
             )
         ]
+        if isinstance(node.body, ast.EnumDef):
+            self.link_jac_py_nodes(jac_node=node.body, py_nodes=node.gen.py_ast)
 
     def exit_enum_def(self, node: ast.EnumDef) -> None:
         """Sub objects.
@@ -782,6 +815,12 @@ class PyastGenPass(Pass):
         doc: Optional[String],
         decorators: Optional[SubNodeList[ExprType]],
         """
+        for i in node.target.archs:
+            if i.sym_link:
+                self.link_jac_py_nodes(jac_node=i, py_nodes=i.sym_link.decl.gen.py_ast)
+                self.link_jac_py_nodes(
+                    jac_node=i.name_ref, py_nodes=i.sym_link.decl.gen.py_ast
+                )
 
     def exit_ability(self, node: ast.Ability) -> None:
         """Sub objects.
@@ -793,27 +832,33 @@ class PyastGenPass(Pass):
         is_abstract: bool,
         access: Optional[SubTag[Token]],
         signature: Optional[FuncSignature | ExprType | EventSignature],
-        body: Optional[SubNodeList[CodeBlockStmt]],
+        body: Optional[SubNodeList[CodeBlockStmt] | AbilityDef | FuncCall],
         doc: Optional[String],
         decorators: Optional[SubNodeList[ExprType]],
         """
         func_type = ast3.AsyncFunctionDef if node.is_async else ast3.FunctionDef
         body = (
-            [
-                self.sync(ast3.Expr(value=node.doc.gen.py_ast[0]), jac_node=node.doc),
-                self.sync(ast3.Pass(), node.body),
-            ]
-            if node.doc and node.is_abstract
+            self.gen_llm_body(node)
+            if isinstance(node.body, ast.FuncCall)
             else (
-                [self.sync(ast3.Pass(), node.body)]
-                if node.is_abstract
-                else self.resolve_stmt_block(
-                    (
-                        node.body.body
-                        if isinstance(node.body, ast.AbilityDef)
-                        else node.body
+                [
+                    self.sync(
+                        ast3.Expr(value=node.doc.gen.py_ast[0]), jac_node=node.doc
                     ),
-                    doc=node.doc,
+                    self.sync(ast3.Pass(), node.body),
+                ]
+                if node.doc and node.is_abstract
+                else (
+                    [self.sync(ast3.Pass(), node.body)]
+                    if node.is_abstract
+                    else self.resolve_stmt_block(
+                        (
+                            node.body.body
+                            if isinstance(node.body, ast.AbilityDef)
+                            else node.body
+                        ),
+                        doc=node.doc,
+                    )
                 )
             )
         )
@@ -857,8 +902,10 @@ class PyastGenPass(Pass):
             decorator_list.insert(
                 0, self.sync(ast3.Name(id="staticmethod", ctx=ast3.Load()))
             )
-        if not body:
+        if not body and not isinstance(node.body, ast.FuncCall):
             self.error("Ability has no body. Perhaps an impl must be imported.", node)
+            body = [self.sync(ast3.Pass(), node)]
+
         node.gen.py_ast = [
             self.sync(
                 func_type(
@@ -875,6 +922,184 @@ class PyastGenPass(Pass):
                 )
             )
         ]
+        self.link_jac_py_nodes(jac_node=node.name_ref, py_nodes=node.gen.py_ast)
+        if isinstance(node.body, ast.AbilityDef):
+            self.link_jac_py_nodes(jac_node=node.body, py_nodes=node.gen.py_ast)
+
+    def gen_llm_body(self, node: ast.Ability) -> list[ast3.AST]:
+        """Generate llm body."""
+        if isinstance(node.body, ast.FuncCall):
+            model_params = (
+                {
+                    param.key: param.value
+                    for param in node.body.params.items
+                    if isinstance(param, ast.KWPair)
+                }
+                if node.body.params
+                else {}
+            )
+            return [
+                self.sync(
+                    ast3.Return(
+                        value=self.sync(
+                            ast3.Call(
+                                func=self.sync(
+                                    ast3.Attribute(
+                                        value=self.sync(
+                                            ast3.Name(
+                                                id=Con.JAC_FEATURE.value,
+                                                ctx=ast3.Load(),
+                                            )
+                                        ),
+                                        attr="with_llm",
+                                        ctx=ast3.Load(),
+                                    )
+                                ),
+                                args=[],
+                                keywords=[
+                                    self.sync(
+                                        ast3.keyword(
+                                            arg="model",
+                                            value=node.body.target.gen.py_ast[0],
+                                        )
+                                    ),
+                                    self.sync(
+                                        ast3.keyword(
+                                            arg="model_params",
+                                            value=self.sync(
+                                                ast3.Dict(
+                                                    keys=[
+                                                        self.sync(ast3.Constant(value=key.value))  # type: ignore
+                                                        for key in model_params.keys()
+                                                    ],
+                                                    values=[
+                                                        value.gen.py_ast[0]
+                                                        for value in model_params.values()
+                                                    ],
+                                                )
+                                            ),
+                                        )
+                                    ),
+                                    self.sync(
+                                        ast3.keyword(
+                                            arg="incl_info",
+                                            value=self.sync(
+                                                ast3.Constant(value=None)
+                                            ),  # TODO: Add incl_info
+                                        )
+                                    ),
+                                    self.sync(
+                                        ast3.keyword(
+                                            arg="excl_info",
+                                            value=self.sync(
+                                                ast3.Constant(value=None)
+                                            ),  # TODO: Add excl_info
+                                        )
+                                    ),
+                                    self.sync(
+                                        ast3.keyword(
+                                            arg="inputs",
+                                            value=self.sync(
+                                                ast3.List(
+                                                    elts=(
+                                                        [
+                                                            self.sync(
+                                                                ast3.Tuple(
+                                                                    elts=[
+                                                                        (
+                                                                            param.semstr.gen.py_ast[
+                                                                                0
+                                                                            ]
+                                                                            if param.semstr
+                                                                            else None
+                                                                        ),
+                                                                        (
+                                                                            param.type_tag.tag.gen.py_ast[
+                                                                                0
+                                                                            ]
+                                                                            if param.type_tag
+                                                                            else None
+                                                                        ),
+                                                                        self.sync(
+                                                                            ast3.Constant(
+                                                                                value=param.name.value
+                                                                            )
+                                                                        ),
+                                                                        self.sync(
+                                                                            ast3.Name(
+                                                                                id=param.name.value,
+                                                                                ctx=ast3.Load(),
+                                                                            )
+                                                                        ),
+                                                                    ],
+                                                                    ctx=ast3.Load(),
+                                                                )
+                                                            )
+                                                            for param in node.signature.params.items
+                                                        ]
+                                                        if isinstance(
+                                                            node.signature,
+                                                            ast.FuncSignature,
+                                                        )
+                                                        and node.signature.params
+                                                        else []
+                                                    ),
+                                                    ctx=ast3.Load(),
+                                                )
+                                            ),
+                                        )
+                                    ),
+                                    self.sync(
+                                        ast3.keyword(
+                                            arg="outputs",
+                                            value=self.sync(
+                                                ast3.Tuple(
+                                                    elts=(
+                                                        [
+                                                            (
+                                                                node.signature.semstr.gen.py_ast[
+                                                                    0
+                                                                ]
+                                                                if node.signature.semstr
+                                                                else None
+                                                            ),
+                                                            (
+                                                                node.signature.return_type.gen.py_ast[
+                                                                    0
+                                                                ]
+                                                                if node.signature.return_type
+                                                                else None
+                                                            ),
+                                                        ]
+                                                        if isinstance(
+                                                            node.signature,
+                                                            ast.FuncSignature,
+                                                        )
+                                                        else []
+                                                    ),
+                                                    ctx=ast3.Load(),
+                                                )
+                                            ),
+                                        )
+                                    ),  # TODO: Add Meaning Types of Outputs
+                                    self.sync(
+                                        ast3.keyword(
+                                            arg="action",
+                                            value=(
+                                                node.semstr.gen.py_ast[0]
+                                                if node.semstr
+                                                else None
+                                            ),
+                                        )
+                                    ),
+                                ],
+                            )
+                        )
+                    )
+                )
+            ]
+        else:
+            return []
 
     def exit_ability_def(self, node: ast.AbilityDef) -> None:
         """Sub objects.
@@ -885,6 +1110,15 @@ class PyastGenPass(Pass):
         doc: Optional[String],
         decorators: Optional[SubNodeList[ExprType]],
         """
+        for i in node.target.archs:
+            if i.sym_link:
+                self.link_jac_py_nodes(jac_node=i, py_nodes=i.sym_link.decl.gen.py_ast)
+                self.link_jac_py_nodes(
+                    jac_node=i.name_ref, py_nodes=i.sym_link.decl.gen.py_ast
+                )
+        if isinstance(node.parent, ast.Ability) and node.parent.signature:
+            # TODO: Here we need to do a link for each subnode to the original parent signature
+            pass
 
     def exit_func_signature(self, node: ast.FuncSignature) -> None:
         """Sub objects.
@@ -973,7 +1207,7 @@ class PyastGenPass(Pass):
         if node.arch.name == Tok.TYPE_OP:
             if (
                 isinstance(node.name_ref, ast.SpecialVarRef)
-                and node.name_ref.var.name == Tok.ROOT_OP
+                and node.name_ref.var.name == Tok.KW_ROOT
             ):
                 node.gen.py_ast = [
                     self.sync(
@@ -1041,6 +1275,7 @@ class PyastGenPass(Pass):
                 )
             )
         ]
+        self.link_jac_py_nodes(jac_node=node.name, py_nodes=node.gen.py_ast)
 
     def exit_arch_has(self, node: ast.ArchHas) -> None:
         """Sub objects.
@@ -1296,6 +1531,8 @@ class PyastGenPass(Pass):
                 )
             )
         ]
+        if node.name:
+            self.link_jac_py_nodes(jac_node=node.name, py_nodes=node.gen.py_ast)
 
     def exit_finally_stmt(self, node: ast.FinallyStmt) -> None:
         """Sub objects.
@@ -1403,6 +1640,9 @@ class PyastGenPass(Pass):
                 )
             )
         ]
+        self.link_jac_py_nodes(jac_node=node.expr, py_nodes=node.gen.py_ast)
+        if node.alias:
+            self.link_jac_py_nodes(jac_node=node.alias, py_nodes=node.gen.py_ast)
 
     def exit_raise_stmt(self, node: ast.RaiseStmt) -> None:
         """Sub objects.
@@ -1660,6 +1900,7 @@ class PyastGenPass(Pass):
                     jac_node=x,
                 )
             )
+            self.link_jac_py_nodes(jac_node=x, py_nodes=[py_nodes[-1]])
         node.gen.py_ast = [*py_nodes]
 
     def exit_non_local_stmt(self, node: ast.NonLocalStmt) -> None:
@@ -1675,6 +1916,7 @@ class PyastGenPass(Pass):
                     jac_node=x,
                 )
             )
+            self.link_jac_py_nodes(jac_node=x, py_nodes=[py_nodes[-1]])
         node.gen.py_ast = [*py_nodes]
 
     def exit_assignment(self, node: ast.Assignment) -> None:
@@ -1685,6 +1927,21 @@ class PyastGenPass(Pass):
         type_tag: Optional[SubTag[ExprType]],
         mutable: bool =True,
         """
+        value = (
+            node.value.gen.py_ast[0]
+            if node.value
+            else (
+                self.sync(
+                    ast3.Call(
+                        func=self.sync(ast3.Name(id="__jac_auto__", ctx=ast3.Load())),
+                        args=[],
+                        keywords=[],
+                    )
+                )
+                if node.is_enum_stmt
+                else self.ice()
+            )
+        )
         if node.type_tag:
             node.gen.py_ast = [
                 self.sync(
@@ -1696,25 +1953,19 @@ class PyastGenPass(Pass):
                     )
                 )
             ]
-        elif not node.value:
-            self.ice()
         elif node.aug_op:
             node.gen.py_ast = [
                 self.sync(
                     ast3.AugAssign(
                         target=node.target.items[0].gen.py_ast[0],
                         op=node.aug_op.gen.py_ast[0],
-                        value=node.value.gen.py_ast[0],
+                        value=value,
                     )
                 )
             ]
         else:
             node.gen.py_ast = [
-                self.sync(
-                    ast3.Assign(
-                        targets=node.target.gen.py_ast, value=node.value.gen.py_ast[0]
-                    )
-                )
+                self.sync(ast3.Assign(targets=node.target.gen.py_ast, value=value))
             ]
 
     def exit_binary_expr(self, node: ast.BinaryExpr) -> None:
@@ -1845,7 +2096,9 @@ class PyastGenPass(Pass):
                 params=(
                     node.left.values
                     if isinstance(node.left, ast.TupleVal)
-                    else ast.SubNodeList(items=[node.left], kid=[node.left])
+                    else ast.SubNodeList(
+                        items=[node.left], delim=Tok.COMMA, kid=[node.left]
+                    )
                 ),
                 kid=node.kid,
             )
@@ -1879,7 +2132,9 @@ class PyastGenPass(Pass):
                 params=(
                     node.right.values
                     if isinstance(node.right, ast.TupleVal)
-                    else ast.SubNodeList(items=[node.right], kid=[node.right])
+                    else ast.SubNodeList(
+                        items=[node.right], delim=Tok.COMMA, kid=[node.right]
+                    )
                 ),
                 kid=node.kid,
             )
@@ -2101,13 +2356,6 @@ class PyastGenPass(Pass):
             else [self.sync(ast3.Constant(value=""))]
         )
 
-    def exit_expr_list(self, node: ast.ExprList) -> None:
-        """Sub objects.
-
-        values: Optional[SubNodeList[ExprType]],
-        """
-        node.gen.py_ast = node.values.gen.py_ast if node.values else []
-
     def exit_list_val(self, node: ast.ListVal) -> None:
         """Sub objects.
 
@@ -2188,6 +2436,8 @@ class PyastGenPass(Pass):
                 )
             )
         ]
+        if node.key:
+            self.link_jac_py_nodes(jac_node=node.key, py_nodes=node.gen.py_ast)
 
     def exit_inner_compr(self, node: ast.InnerCompr) -> None:
         """Sub objects.
@@ -2202,7 +2452,11 @@ class PyastGenPass(Pass):
                 ast3.comprehension(
                     target=node.target.gen.py_ast[0],
                     iter=node.collection.gen.py_ast[0],
-                    ifs=node.conditional.gen.py_ast if node.conditional else [],
+                    ifs=(
+                        [x.gen.py_ast[0] for x in node.conditional]
+                        if node.conditional
+                        else []
+                    ),
                     is_async=0,
                 )
             )
@@ -2212,7 +2466,7 @@ class PyastGenPass(Pass):
         """Sub objects.
 
         out_expr: ExprType,
-        compr: InnerCompr,
+        compr: list[InnerCompr]
         """
         node.gen.py_ast = [
             self.sync(
@@ -2227,7 +2481,7 @@ class PyastGenPass(Pass):
         """Sub objects.
 
         out_expr: ExprType,
-        compr: InnerCompr,
+        compr: list[InnerCompr]
         """
         node.gen.py_ast = [
             self.sync(
@@ -2242,7 +2496,7 @@ class PyastGenPass(Pass):
         """Sub objects.
 
         out_expr: ExprType,
-        compr: InnerCompr,
+        compr: list[InnerCompr]
         """
         node.gen.py_ast = [
             self.sync(
@@ -2276,27 +2530,25 @@ class PyastGenPass(Pass):
 
         target: Expr,
         right: AtomExpr | Expr,
-        is_attr: Optional[Token],
+        is_attr: bool,
         is_null_ok: bool,
         """
         if node.is_attr:
-            node.gen.py_ast = [
-                self.sync(
-                    ast3.Attribute(
-                        value=node.target.gen.py_ast[0],
-                        attr=(
-                            node.right.sym_name
-                            if isinstance(node.right, ast.AstSymbolNode)
-                            else ""
-                        ),
-                        ctx=(
-                            node.right.py_ctx_func()
-                            if isinstance(node.right, ast.AstSymbolNode)
-                            else ast3.Load()
-                        ),
+            if isinstance(node.right, ast.AstSymbolNode):
+                node.gen.py_ast = [
+                    self.sync(
+                        ast3.Attribute(
+                            value=node.target.gen.py_ast[0],
+                            attr=(node.right.sym_name),
+                            ctx=(node.right.py_ctx_func()),
+                        )
                     )
+                ]
+                self.link_jac_py_nodes(
+                    jac_node=node.right.sym_name_node, py_nodes=node.gen.py_ast
                 )
-            ]
+            else:
+                self.error("Invalid attribute access")
         elif isinstance(node.right, ast.FilterCompr):
             node.gen.py_ast = [
                 self.sync(
@@ -2376,19 +2628,11 @@ class PyastGenPass(Pass):
         target: Expr,
         params: Optional[SubNodeList[Expr | KWPair]],
         """
-        node.gen.py_ast = [self.sync(self.gen_func_call(node.target, node.params))]
-
-    def gen_func_call(
-        self,
-        target: ast.Expr,
-        params: Optional[ast.SubNodeList[ast.Expr | ast.KWPair]],
-    ) -> ast3.Call:
-        """Generate a function call."""
-        func = target.gen.py_ast[0]
+        func = node.target.gen.py_ast[0]
         args = []
         keywords = []
-        if params and len(params.items) > 0:
-            for x in params.items:
+        if node.params and len(node.params.items) > 0:
+            for x in node.params.items:
                 if isinstance(x, ast.UnaryExpr) and x.op.name == Tok.STAR_POW:
                     keywords.append(
                         self.sync(ast3.keyword(value=x.operand.gen.py_ast[0]), x)
@@ -2401,7 +2645,9 @@ class PyastGenPass(Pass):
                     keywords.append(x.gen.py_ast[0])
                 else:
                     self.ice("Invalid Parameter")
-        return ast3.Call(func=func, args=args, keywords=keywords)
+        node.gen.py_ast = [
+            self.sync(ast3.Call(func=func, args=args, keywords=keywords))
+        ]
 
     def exit_index_slice(self, node: ast.IndexSlice) -> None:
         """Sub objects.
@@ -2441,7 +2687,7 @@ class PyastGenPass(Pass):
     def exit_edge_ref_trailer(self, node: ast.EdgeRefTrailer) -> None:
         """Sub objects.
 
-        chain: list[Expr],
+        chain: list[Expr|FilterCompr],
         edges_only: bool,
         """
         pynode = node.chain[0].gen.py_ast[0]
@@ -2461,11 +2707,23 @@ class PyastGenPass(Pass):
                 not next_i or not isinstance(next_i, ast.EdgeOpRef)
             ):
                 pynode = self.translate_edge_op_ref(
-                    pynode,
-                    cur,
-                    targ=next_i.gen.py_ast[0] if next_i else None,
+                    loc=pynode,
+                    node=cur,
+                    targ=(
+                        next_i.gen.py_ast[0]
+                        if next_i and not isinstance(next_i, ast.FilterCompr)
+                        else None
+                    ),
                     edges_only=node.edges_only and cur == last_edge,
                 )
+                if next_i and isinstance(next_i, ast.FilterCompr):
+                    pynode = self.sync(
+                        ast3.Call(
+                            func=next_i.gen.py_ast[0],
+                            args=[pynode],
+                            keywords=[],
+                        )
+                    )
                 chomp = chomp[1:] if next_i else chomp
             elif isinstance(cur, ast.EdgeOpRef) and isinstance(next_i, ast.EdgeOpRef):
                 pynode = self.translate_edge_op_ref(
@@ -2772,14 +3030,14 @@ class PyastGenPass(Pass):
 
         pattern: MatchPattern,
         guard: Optional[ExprType],
-        body: SubNodeList[CodeBlockStmt],
+        body: list[CodeBlockStmt],
         """
         node.gen.py_ast = [
             self.sync(
                 ast3.match_case(
                     pattern=node.pattern.gen.py_ast[0],
                     guard=node.guard.gen.py_ast[0] if node.guard else None,
-                    body=self.resolve_stmt_block(node.body),
+                    body=[x.gen.py_ast[0] for x in node.body],
                 )
             )
         ]
@@ -3000,24 +3258,6 @@ class PyastGenPass(Pass):
         node.gen.py_ast = [
             self.sync(ast3.Name(id=node.sym_name, ctx=node.py_ctx_func()))
         ]
-        if node.is_enum_singleton and isinstance(node.gen.py_ast[0], ast3.Name):
-            node.gen.py_ast[0].ctx = ast3.Store()
-            node.gen.py_ast = [
-                self.sync(
-                    ast3.Assign(
-                        targets=node.gen.py_ast,
-                        value=self.sync(
-                            ast3.Call(
-                                func=self.sync(
-                                    ast3.Name(id="__jac_auto__", ctx=ast3.Load())
-                                ),
-                                args=[],
-                                keywords=[],
-                            )
-                        ),
-                    )
-                )
-            ]
 
     def exit_float(self, node: ast.Float) -> None:
         """Sub objects.