mindspore 2.0.0rc1__cp38-none-any.whl → 2.2.0__cp38-none-any.whl

mindspore/rewrite/parsers/attribute_parser.py

@@ -15,13 +15,11 @@
 """Parse ast.Assign in construct function to node of SymbolTree."""
 import ast
 
-from mindspore.rewrite.parser import Parser
+from mindspore.rewrite.parsers.parser import Parser
 from mindspore.rewrite.symbol_tree import SymbolTree
-from mindspore.rewrite.parser_register import ParserRegister
-
-from mindspore.rewrite.parser_register import reg_parser
+from mindspore.rewrite.parsers.parser_register import ParserRegister, reg_parser
 from ..common import error_str
-
+from ..node.node_manager import NodeManager
 
 class AttributeParser(Parser):
     """Parse ast.Attribute in construct function to node of SymbolTree."""
@@ -30,13 +28,14 @@ class AttributeParser(Parser):
         """Parse target type."""
         return ast.Attribute
 
-    def process(self, stree: SymbolTree, node: ast.Attribute):
+    def process(self, stree: SymbolTree, node: ast.Attribute, node_manager: NodeManager):
         """
         Parse ast.Attribute node.
 
         Args:
             stree ([SymbolTree]): Symbol Tree under parsing.
             node ([ast.Attribute]): An ast.Attribute node.
+            node_manager (NodeManager): NodeManager those asts belong to.
 
         Returns:
             The value of node.
@@ -47,8 +46,11 @@ class AttributeParser(Parser):
         if not isinstance(node, ast.Attribute):
             raise TypeError(error_str(f"Attribute parser only supports parsing ast.Attribute type nodes, but got "
                                       f"'{type(node).__name__}'", father_node=node))
+        if not isinstance(node.value, (ast.Name, ast.Attribute)):
+            raise RuntimeError(error_str(f"Attribute parser only supports (ast.Attribute, ast.Name) as value of "
+                                         f"ast.Attribute, but got '{type(node).__name__}'", father_node=node))
         parser = ParserRegister.instance().get_parser(type(node.value))
-        value = parser.process(stree, node.value)
+        value = parser.process(stree, node.value, node_manager)
 
         return ".".join([value, node.attr])
 

mindspore/rewrite/parsers/class_def_parser.py

@@ -13,18 +13,19 @@
 # limitations under the License.
 # ============================================================================
 """Parse ast.ClassDef which is subclass of Cell to SymbolTree."""
-import sys
-import ast
 import inspect
-import astunparse
+from typing import Union, Dict
+import ast
 from mindspore import log as logger
+from mindspore.nn import Cell
 from mindspore._extends.parse.namespace import CellNamespace
-from mindspore.rewrite.ast_creator_register import ast_creator_registry
 from ..symbol_tree import SymbolTree
-from ..parser import Parser
-from ..parser_register import ParserRegister, reg_parser
+from .parser import Parser
+from .parser_register import ParserRegister, reg_parser
 from ..ast_helpers import AstReplacer
 from ..common import error_str
+from ..parsers.module_parser import ModuleParser
+from ..node.node_manager import NodeManager
 
 
 class AstScopeChecker:
@@ -107,91 +108,58 @@ class AstScopeChecker:
 class ClassDefParser(Parser):
     """Parse ast.ClassDef which is subclass of Cell to SymbolTree."""
 
+    # a denied_function_decorator_list which is registered by user
+    denied_function_decorator_list = []
+    # Entry function of the forward computation process
+    entry_function = "construct"
+
     def __init__(self):
         """Constructor"""
         super(ClassDefParser, self).__init__()
         self._cell_namespace = CellNamespace('mindspore.nn')
 
-    def target(self):
-        """Parse target type"""
-        return ast.ClassDef
-
-    def handle_father_class(self, stree, node: ast.ClassDef):
-        """Handle father class."""
-        for base in node.bases:
-            parser: Parser = ParserRegister.instance().get_parser(type(base))
-            father_class = parser.process(stree, base)
-            if "Cell" not in father_class:
-                for k, m in sys.modules.items():
-                    if k in ("_ast", "ast"):
-                        continue
-                    if hasattr(m, father_class):
-                        cls = getattr(m, father_class)
-                        source_code = inspect.getsource(cls)
-                        ast_root: ast.Module = ast.parse(source_code)
-                        stree._father_class_ast.append(ast_root) # pylint: disable=protected-access
-                        break
-
-    def process(self, stree: SymbolTree, node: ast.ClassDef):
-        """
-        Parse init and construct in ast.ClassDef.
-
-        Args:
-            stree ([SymbolTree]): Symbol Tree under parsing.
-            node ([ast.ClassDef]): An ast.ClassDef node.
-        """
-        replacer = AstReplacer(node)
-        replacer.replace_all(stree.get_ori_cls_name(), stree.get_opt_cls_name())
-
-        stree.set_class_ast(node)
-        self.handle_father_class(stree, node)
-
-        if self._need_add_init_func(node):
-            self._add_init_func(node)
-
-        for body in node.body:
-            if isinstance(body, ast.FunctionDef):
-                if body.name == "__init__":
-                    self._process_init_func_ast(stree, node, body)
-                    stree.set_init_func_ast(body)
-                elif body.name == "construct":
-                    parser: Parser = ParserRegister.instance().get_parser(ast.FunctionDef)
-                    parser.process(stree, body)
-                else:
-                    logger.info(
-                        "Ignoring ast.FunctionDef in ast.ClassDef except __init__ and construct function: %s",
-                        body.name)
-            else:
-                logger.info("Ignoring unsupported node(%s) in ast.ClassDef.", type(body).__name__)
-
-    def _is_subtree_field(self, ori_net, field) -> bool:
-        op = getattr(ori_net, field)
-        return not type(op).__name__ in self._cell_namespace
-
-    def _process_init_func_ast(self, stree: SymbolTree, cls_ast: ast.ClassDef, init_ast: ast.FunctionDef):
+    @staticmethod
+    def _process_init_func_ast(init_ast: ast.FunctionDef, class_name: str, is_father_class: bool,
+                               father_classes: dict):
         """Process init func"""
         ClassDefParser._modify_arguments_of_init_func(init_ast)
-        new_bodies = self._replace_ori_field_of_init_func(stree, cls_ast, init_ast.body)
+        new_bodies = ClassDefParser._create_bodys_of_init_func(class_name, is_father_class, father_classes)
         init_ast.body = new_bodies
 
     @staticmethod
-    def _is_super_expr(expr: ast.AST) -> bool:
-        """Check whether ast node is super().__init__()"""
-        if not isinstance(expr, ast.Expr):
-            return False
-        expr_value = expr.value
-        if not isinstance(expr_value, ast.Call):
-            return False
-        expr_value_func = expr_value.func
-        if not isinstance(expr_value_func, ast.Attribute):
-            return False
-        expr_value_func_value = expr_value_func.value
-        if expr_value_func.attr != "__init__" or not isinstance(expr_value_func_value, ast.Call):
-            return False
-        expr_value_func_value_func = expr_value_func_value.func
-        if not isinstance(expr_value_func_value_func, ast.Name) or expr_value_func_value_func.id != "super":
-            return False
-        return True
+    def _create_bodys_of_init_func(class_name: str, is_father_class: bool, father_classes: dict):
+        """Modify bodys of init func."""
+        new_bodies = []
+        # update father class init in new class
+        father_class_init_bodies = ClassDefParser._father_class_init_process(father_classes, is_father_class)
+        new_bodies.extend(father_class_init_bodies)
+        # copy variables into new class
+        if is_father_class:
+            ast_copy_attr = ast.parse(
+                "for key, value in obj.__dict__.items():\n"
+                "    if not key.startswith('__'):\n"
+                f"        setattr({class_name}, key, value)").body[0]
+            new_bodies.append(ast_copy_attr)
+        else:
+            ast_copy_attr = ast.parse(
+                "for key, value in obj.__dict__.items(): setattr(self, key, value)").body[0]
+            new_bodies.append(ast_copy_attr)
+        return new_bodies
+
+    @staticmethod
+    def _father_class_init_process(father_classes: dict, is_father_class: bool) -> [ast.AST]:
+        """Add ast bodies of code: father_class.__init__(...)"""
+        father_class_init_bodies = []
+        for idx, father_class in father_classes.items():
+            if father_class == "Cell":
+                father_class_init_code = "super().__init__()"
+            elif is_father_class:
+                father_class_init_code = f"{father_class}.__init__(self, obj.__bases__[{idx}])"
+            else:
+                father_class_init_code = f"{father_class}.__init__(self, obj.__class__.__bases__[{idx}])"
+            father_class_init_ast = ast.parse(father_class_init_code).body[0]
+            father_class_init_bodies.append(father_class_init_ast)
+        return father_class_init_bodies
 
     @staticmethod
     def _modify_arguments_of_init_func(ast_init_fn: ast.FunctionDef):
@@ -203,159 +171,152 @@ class ClassDefParser(Parser):
         ast.fix_missing_locations(ast_init_fn)
 
     @staticmethod
-    def _remove_empty_ast_in_init_func(bodies: []):
-        """Remove ast.If, ast.For or other ast node with body when their body is empty recursively."""
-        body_index_to_be_deleted = []
-        for body_index, body in enumerate(bodies):
-            if isinstance(body, ast.If):
-                ClassDefParser._remove_empty_ast_in_init_func(body.body)
-                ClassDefParser._remove_empty_ast_in_init_func(body.orelse)
-                if not body.body and not body.orelse:
-                    body_index_to_be_deleted.append(body_index)
-                if not body.body and body.orelse:
-                    body.body.append(ast.Pass())
+    def get_ast_name(ast_node: Union[ast.Name, ast.Attribute]) -> str:
+        """Get ast id name"""
+        if isinstance(ast_node, ast.Name):
+            return ast_node.id
+        if isinstance(ast_node, ast.Attribute):
+            return ast_node.attr
+        return ""
+
+    @staticmethod
+    def _process_class_variables(stree: SymbolTree, function_defs: list):
+        """Process class variables of class, only used in child class."""
+        init_func_ast = stree.get_init_func_ast()
+        for key, value in stree.get_origin_network().__class__.__dict__.items():
+            if key.startswith('__'):
+                # ignore inner functions
                 continue
-            if isinstance(body, ast.For):
-                ClassDefParser._remove_empty_ast_in_init_func(body.body)
-                ClassDefParser._remove_empty_ast_in_init_func(body.orelse)
-                if not body.body or not body.orelse:
-                    body_index_to_be_deleted.append(body_index)
+            if callable(value) and key in function_defs:
+                # ignore functions defined by self
                 continue
-            if hasattr(body, "body"):
-                ClassDefParser._remove_empty_ast_in_init_func(body.body)
-                if not body.body:
-                    body_index_to_be_deleted.append(body_index)
-        for counter, index in enumerate(body_index_to_be_deleted):
-            bodies.pop(index - counter)
-
-    def _handle_tuple_for_replace_ori_field(self, ast_tuple: ast.Tuple, new_bodies):
-        """ Handle ast.Assign node with target of ast.Tuple in init func to new ast nodes. """
-        for e in ast_tuple.elts:
-            if isinstance(e, ast.Attribute):
-                field_name = e.attr
-                value = ast.Call(ast.Name('getattr', ast.Load()),
-                                 [ast.Name('obj', ast.Load()),
-                                  ast.Constant(value=field_name, kind=None)], [])
-                new_assign = ast_creator_registry.get("Assign")(targets=[e], value=value)
-                new_bodies.append(new_assign)
-
-    def _handle_express_for_replace_ori_field(self, cls_ast, ast_expr: ast.Expr, stree, new_bodies):
-        """ Handle ast.Expr node in init func to new ast nodes. """
-        ast_call = ast_expr.value
-        if not isinstance(ast_call.func, ast.Attribute) or not isinstance(ast_call.func.value, ast.Name)\
-            or ast_call.func.value.id != 'self':
-            return
-        for func_def in cls_ast.body:
-            if isinstance(func_def, ast.FunctionDef) and func_def.name == ast_call.func.attr:
-                for func_def_body in func_def.body:
-                    self._handle_bodies_for_replace_ori_field(cls_ast, func_def_body, stree, new_bodies)
-                return
-
-    def _handle_assign_for_replace_ori_field(self, ast_assign: ast.Assign, stree, new_bodies):
-        """ Handle ast.Assign node in init func to new ast nodes. """
-        if len(ast_assign.targets) != 1:
-            raise RuntimeError("not support multi-targets in assign now!", father_node=ast_assign)
-        target = ast_assign.targets[0]
-        if isinstance(target, ast.Tuple):
-            self._handle_tuple_for_replace_ori_field(target, new_bodies)
-            return
-        if not isinstance(target, ast.Attribute) or not isinstance(target.value, ast.Name)\
-            or target.value.id != 'self':
-            logger.info(f"Ignoring {astunparse.unparse(target)} in __init__ function.")
-            return
-        field_name = target.attr
-        # Ensure that the instance has corresponding attribute
-        if not hasattr(stree.get_origin_network(), field_name):
-            return
-        # Check to avoid repeat code
-        for new_ast in new_bodies:
-            if isinstance(new_ast, ast.Assign) and isinstance(new_ast.targets[0], ast.Attribute)\
-                and new_ast.targets[0].attr == field_name:
-                return
-        value = ast.Call(ast.Name('getattr', ast.Load()),
-                         [ast.Name('obj', ast.Load()),
-                          ast.Constant(value=field_name, kind=None)], [])
-        new_assign = ast_creator_registry.get("Assign")(targets=[target], value=value)
-        new_bodies.append(new_assign)
-
-    def _handle_bodies_for_replace_ori_field(self, cls_ast, body, stree, new_bodies):
-        """ handle_bodies_for_replace_ori_field. """
-        if self._is_super_expr(body):
-            new_bodies.append(body)
-            return
-        if isinstance(body, ast.If):
-            for if_body in body.body + body.orelse:
-                self._handle_bodies_for_replace_ori_field(cls_ast, if_body, stree, new_bodies)
-            return
-        if isinstance(body, ast.Expr) and isinstance(body.value, ast.Call):
-            self._handle_express_for_replace_ori_field(cls_ast, body, stree, new_bodies)
-            return
-        if isinstance(body, ast.Assign):  # if not assign node, delete
-            self._handle_assign_for_replace_ori_field(body, stree, new_bodies)
-            return
-
-    def _need_add_init_func(self, cls_ast: ast.ClassDef) -> bool:
-        """If class has base nn.Cell but not have init func, then we need to add init func"""
-        base_nn_cell = False
-        for base in cls_ast.bases:
-            if isinstance(base, ast.Name) and base.id == 'Cell'\
-                or isinstance(base, ast.Attribute) and isinstance(base.value, ast.Name)\
-                and base.value.id == "nn" and base.attr == 'Cell':
-                base_nn_cell = True
-                break
-        if not base_nn_cell:
-            return False
+            assign_code = f"self.__class__.{key} = obj.__class__.{key}"
+            assign_ast = ast.parse(assign_code).body[0]
+            init_func_ast.body.append(assign_ast)
+
+    @staticmethod
+    def _need_add_init_func(cls_ast: ast.ClassDef) -> bool:
+        """If the class don't have init func, we need to add an init func"""
         for body in cls_ast.body:
             if isinstance(body, ast.FunctionDef) and body.name == '__init__':
                 return False
         return True
 
-    def _add_init_func(self, cls_ast: ast.ClassDef):
+    @staticmethod
+    def _add_init_func(cls_ast: ast.ClassDef):
         """Add init func with super().__init__()"""
-        init_func_ast = ast.FunctionDef(
-            name='__init__',
-            args=ast.arguments(
-                posonlyargs=[],
-                args=[
-                    ast.arg(arg='self')],
-                kwonlyargs=[],
-                kw_defaults=[],
-                defaults=[]),
-            body=[
-                ast.Expr(
-                    value=ast.Call(
-                        func=ast.Attribute(
-                            value=ast.Call(
-                                func=ast.Name(id='super', ctx=ast.Load()),
-                                args=[],
-                                keywords=[]),
-                            attr='__init__',
-                            ctx=ast.Load()),
-                        args=[],
-                        keywords=[]))],
-            decorator_list=[])
+        init_func_ast = ast.parse("def __init__(self): super().__init__()").body[0]
         cls_ast.body.insert(0, init_func_ast)
         ast.fix_missing_locations(cls_ast)
 
-    def _replace_ori_field_of_init_func(self, stree: SymbolTree, cls_ast: ast.ClassDef, bodies: []):
+    @staticmethod
+    def _process_father_classes(stree, node: ast.ClassDef, cur_class_def: type) -> list:
+        """Process father class."""
+        father_classes: Dict[int, str] = {}
+        for idx, base in enumerate(node.bases):
+            father_class_name = ClassDefParser.get_ast_name(base)
+            if not father_class_name:
+                continue
+            father_classes[idx] = father_class_name
+            if father_class_name == "Cell":
+                continue
+            father_class_def = cur_class_def.__bases__[idx]
+            ClassDefParser._process_one_father_class(stree, father_class_def, father_class_name)
+            node.bases[idx] = ast.Name(id=father_class_name, ctx=ast.Load())
+        return father_classes
+
+    @staticmethod
+    def _process_one_father_class(stree: SymbolTree, father_class_def: type, father_class_name: str):
+        """Process one father class"""
+        # save father class's file path and imports into symbol tree
+        net_path = inspect.getfile(father_class_def)
+        ModuleParser.save_file_path_to_sys(stree, 0, net_path)
+        ModuleParser.save_imports_from_file(stree, net_path)
+        # get father class's ast
+        source_code = inspect.getsource(father_class_def)
+        father_class_ast: ast.ClassDef = ast.parse(source_code).body[0]
+        # process father class's father classes
+        father_classes = ClassDefParser._process_father_classes(stree, father_class_ast, father_class_def)
+        # process father class's __init__ function
+        if ClassDefParser._need_add_init_func(father_class_ast):
+            ClassDefParser._add_init_func(father_class_ast)
+        for body in father_class_ast.body[:]:
+            if isinstance(body, ast.FunctionDef) and body.name == "__init__":
+                # Add function decorator
+                ClassDefParser._func_decorator_process(body)
+                ClassDefParser._process_init_func_ast(body, father_class_name, True, father_classes)
+            else:
+                # Remove other codes, which are copied in __init__ function.
+                father_class_ast.body.remove(body)
+        # save father class's ast into symbol tree
+        stree.get_father_class_ast().append(father_class_ast)
+
+    @staticmethod
+    def _func_decorator_process(node: ast.FunctionDef):
+        """
+        User should set the denied function decorators,
+        because the symbol_tree cant pass the correct parameters to decorators but the instance "obj".
         """
-        Replace original field in init func to self.XX = getattr(self._handler, "XX").
-        Only keep following two kinds of ast nodes in bodies right now:
-            1. Ast.If and test is self.XX.
-            2. Ast.Assign and target is self.XX.
+        for decorator in node.decorator_list[:]:
+            decorator_name = ""
+            if isinstance(decorator, ast.Call):
+                func = decorator.func
+                if isinstance(func, ast.Name):
+                    decorator_name = func.id
+            elif isinstance(decorator, ast.Name):
+                decorator_name = decorator.id
+            if decorator_name in ClassDefParser.denied_function_decorator_list:
+                node.decorator_list.remove(decorator)
 
-        Args:
-            bodies ([]): bodied of init ast.FunctionDef.
+    def target(self):
+        """Parse target type"""
+        return ast.ClassDef
 
-        Raises:
-            RuntimeError: Not support multi-targets in assign.
-            RuntimeError: Only support target.value in [ast.Name] in assign node.
+    def process(self, stree: SymbolTree, node: ast.ClassDef, node_manager: NodeManager):
         """
+        Parse init and entry function(default: construct) in ast.ClassDef.
 
-        new_bodies = []
-        for body in bodies:
-            self._handle_bodies_for_replace_ori_field(cls_ast, body, stree, new_bodies)
-        return new_bodies
+        Args:
+            stree ([SymbolTree]): Symbol Tree under parsing.
+            node ([ast.ClassDef]): An ast.ClassDef node.
+            node_manager (NodeManager): NodeManager those asts belong to.
+        """
+        # Update network's class name from xxx to xxxOpt in ast
+        replacer = AstReplacer(node)
+        replacer.replace_all(stree.get_ori_cls_name(), stree.get_opt_cls_name())
+
+        # process network's father classes
+        stree.set_class_ast(node)
+        cur_class_def = type(stree.get_origin_network())
+        father_classes = ClassDefParser._process_father_classes(stree, node, cur_class_def)
+
+        # add __init__ function to network if necessary
+        if isinstance(stree.get_origin_network(), Cell) and ClassDefParser._need_add_init_func(node):
+            ClassDefParser._add_init_func(node)
 
+        # save function defs in ast node to filter function class variables.
+        function_defs = []
+        for body in node.body[:]:
+            if isinstance(body, ast.FunctionDef):
+                function_defs.append(body.name)
+                ClassDefParser._func_decorator_process(body)
+                if body.name == "__init__":
+                    stree.set_init_func_ast(body)
+                    ClassDefParser._process_init_func_ast(body, stree.get_opt_cls_name(), False, father_classes)
+                elif body.name == ClassDefParser.entry_function:
+                    stree.set_ast_root(body)
+                    parser: Parser = ParserRegister.instance().get_parser(ast.FunctionDef)
+                    parser.process(stree, body, stree)
+                else:
+                    logger.info(
+                        "Ignoring ast.FunctionDef in ast.ClassDef except __init__ and construct function: %s",
+                        body.name)
+            elif isinstance(body, (ast.Assign, ast.If, ast.IfExp)):
+                # Remove class variables, which are copied in __init__ function.
+                node.body.remove(body)
+            else:
+                logger.info("Ignoring unsupported node(%s) in ast.ClassDef.", type(body).__name__)
+        # Copy function class variables into new network
+        ClassDefParser._process_class_variables(stree, function_defs)
 
 g_classdef_parser = reg_parser(ClassDefParser())

mindspore/rewrite/parsers/constant_parser.py

@@ -15,11 +15,11 @@
 """Parse ast.Assign in construct function to node of SymbolTree."""
 import ast
 
-from mindspore.rewrite.parser import Parser
+from mindspore.rewrite.parsers.parser import Parser
 from mindspore.rewrite.symbol_tree import SymbolTree
-from mindspore.rewrite.parser_register import reg_parser
+from mindspore.rewrite.parsers.parser_register import reg_parser
 from ..common import error_str
-
+from ..node.node_manager import NodeManager
 
 class NameParser(Parser):
     """Parse ast.Name in construct function to node of SymbolTree."""
@@ -28,13 +28,14 @@ class NameParser(Parser):
         """Parse target type."""
         return ast.Name
 
-    def process(self, stree: SymbolTree, node: ast.Name):
+    def process(self, stree: SymbolTree, node: ast.Name, node_manager: NodeManager):
         """
         Parse ast.Name node.
 
         Args:
             stree ([SymbolTree]): Symbol Tree under parsing.
             node ([ast.Name]): An ast.Name node.
+            node_manager (NodeManager): NodeManager those asts belong to.
 
         Raises:
             TypeError: Name parser only supports parsing ast.Name type nodes.
@@ -52,13 +53,14 @@ class NumParser(Parser):
         """Parse target type."""
         return ast.Num
 
-    def process(self, stree: SymbolTree, node: ast.Num):
+    def process(self, stree: SymbolTree, node: ast.Num, node_manager: NodeManager):
         """
         Parse ast.Num node.
 
         Args:
             stree ([SymbolTree]): Symbol Tree under parsing.
             node ([ast.Num]): An ast.Num node.
+            node_manager (NodeManager): NodeManager those asts belong to.
 
         Raises:
             TypeError: Num parser only supports parsing ast.Num type nodes.
@@ -76,13 +78,14 @@ class StrParser(Parser):
         """Parse target type."""
         return ast.Str
 
-    def process(self, stree: SymbolTree, node: ast.Str):
+    def process(self, stree: SymbolTree, node: ast.Str, node_manager: NodeManager):
         """
         Parse ast.Str node.
 
         Args:
             stree ([SymbolTree]): Symbol Tree under parsing.
             node ([ast.Str]): An ast.Str node.
+            node_manager (NodeManager): NodeManager those asts belong to.
 
         Returns:
             The value of node.

mindspore/rewrite/parsers/container_parser.py

@@ -15,12 +15,12 @@
 """Parse Container in construct function to node of SymbolTree."""
 import ast
 
-from mindspore.rewrite.parser import Parser
+from mindspore.rewrite.parsers.parser import Parser
 from mindspore.rewrite.symbol_tree import SymbolTree
-from mindspore.rewrite.parser_register import ParserRegister
+from mindspore.rewrite.parsers.parser_register import ParserRegister, reg_parser
 
-from mindspore.rewrite.parser_register import reg_parser
 from ..common import error_str
+from ..node.node_manager import NodeManager
 
 
 class ListParser(Parser):
@@ -30,13 +30,14 @@ class ListParser(Parser):
         """Parse target type."""
         return list
 
-    def process(self, stree: SymbolTree, node: list):
+    def process(self, stree: SymbolTree, node: list, node_manager: NodeManager):
         """
         Parse list.
 
         Args:
             stree ([SymbolTree]): Symbol Tree under parsing.
             node ([list]): An list of node.
+            father_node_managernode (NodeManager): NodeManager those asts belong to.
 
         Returns:
             A list of value.
@@ -50,7 +51,7 @@ class ListParser(Parser):
         result = []
         for n in node:
             parser = ParserRegister.instance().get_parser(type(n))
-            value = parser.process(stree, n)
+            value = parser.process(stree, n, node_manager)
             result.append(value)
         return result
 
@@ -62,13 +63,14 @@ class TupleParser(Parser):
         """Parse target type."""
         return tuple
 
-    def process(self, stree: SymbolTree, node: tuple):
+    def process(self, stree: SymbolTree, node: tuple, node_manager: NodeManager):
         """
         Parse tuple.
 
         Args:
             stree ([SymbolTree]): Symbol Tree under parsing.
             node ([tuple]): An tuple of node.
+            node_manager (NodeManager): NodeManager those asts belong to.
 
         Returns:
             A tuple of value.
@@ -79,7 +81,7 @@ class TupleParser(Parser):
         result = []
         for n in node:
             parser = ParserRegister.instance().get_parser(type(n))
-            value = parser.process(stree, n)
+            value = parser.process(stree, n, node_manager)
             result.append(value)
         return tuple(result)