mindspore 2.2.14__cp39-cp39-win_amd64.whl → 2.4.0__cp39-cp39-win_amd64.whl

mindspore/rewrite/parsers/attribute_parser.py

@@ -15,10 +15,9 @@
 """Parse ast.Assign in construct function to node of SymbolTree."""
 import ast
 
-from mindspore.rewrite.parsers.parser import Parser
-from mindspore.rewrite.symbol_tree import SymbolTree
-from mindspore.rewrite.parsers.parser_register import ParserRegister, reg_parser
-from ..common import error_str
+from . import Parser, ParserRegister, reg_parser
+from ..symbol_tree import SymbolTree
+from ..common.error_log import error_str
 from ..node.node_manager import NodeManager
 
 class AttributeParser(Parser):

mindspore/rewrite/parsers/class_def_parser.py

@@ -14,131 +14,71 @@
 # ============================================================================
 """Parse ast.ClassDef which is subclass of Cell to SymbolTree."""
 import inspect
-from typing import Union, Dict
+from typing import Dict
 import ast
+import sys
+from textwrap import dedent
 from mindspore import log as logger
 from mindspore.nn import Cell
-from mindspore._extends.parse.namespace import CellNamespace
+from mindspore._extends.parse.namespace import ModuleNamespace
+from . import Parser, ParserRegister, reg_parser
+from ..node import NodeManager
 from ..symbol_tree import SymbolTree
-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
+from ..ast_helpers import AstReplacer, AstConverter
+from ..common.error_log import error_str
 
 
-class AstScopeChecker:
-    """
-    Check scope of ast node meets the constraints recursively.
-
-    Args:
-        scope_constraints (str): A string represents constraints of scope.
-    """
-
-    def __init__(self, scope_constraints: str):
-        self._scope = scope_constraints
-
-    def check(self, node: ast.AST) -> bool:
-        """
-        Check scope of `node` meets the constraints recursively.
-
-        Args:
-            node (ast.AST): A ast.AST node to be checked.
-
-        Returns:
-            A bool represents if input `node` meets constraints.
-        """
-        if isinstance(node, ast.Compare):
-            return self._check_compare(node)
-        if isinstance(node, ast.Attribute):
-            return self._check_attribute(node)
-        if isinstance(node, ast.Name):
-            return False
-        if isinstance(node, ast.BoolOp):
-            return self._check_bool(node)
-        if isinstance(node, ast.UnaryOp):
-            return self._check_unary(node)
-        if isinstance(node, ast.Call):
-            return self._check_call(node)
-        if isinstance(node, (ast.Constant, ast.NameConstant, ast.Bytes, ast.Str, ast.Num)):
-            return True
-        raise RuntimeError(error_str(f"only support (ast.Compare, ast.Attribute, ast.Name, ast.BoolOp, ast.UnaryOp"
-                                     f"ast.Call, ast.Constant, ast.NameConstant, ast.Bytes, ast.Str, ast.Num"
-                                     f") as test check, but got ast type '{type(node).__name__}'", father_node=node))
-
-    def _check_attribute(self, node: ast.Attribute):
-        """Check an ast.Attribute meets the constraints recursively."""
-        if not isinstance(node.value, ast.Name):
-            return False
-        if node.value.id != self._scope:
-            return False
-        return True
-
-    def _check_compare(self, node: ast.Compare):
-        """Check an ast.Compare meets the constraints recursively."""
-        left = node.left
-        for comparator in node.comparators:
-            if not self.check(comparator):
-                return False
-        return self.check(left)
-
-    def _check_bool(self, node: ast.BoolOp):
-        """Check an ast.BoolOp meets the constraints recursively."""
-        for value in node.values:
-            if not self.check(value):
-                return False
-        return True
-
-    def _check_call(self, node: ast.Call):
-        """Check an ast.Call meets the constraints recursively."""
-        for arg in node.args:
-            if not self.check(arg):
-                return False
-        for kwarg in node.keywords:
-            if not self.check(kwarg):
-                return False
-        return self.check(node.func)
-
-    def _check_unary(self, node: ast.UnaryOp):
-        """Check an ast.UnaryOp meets the constraints recursively."""
-        return self.check(node.operand)
+if sys.version_info >= (3, 9):
+    import ast as astunparse # pylint: disable=reimported, ungrouped-imports
+else:
+    import astunparse
 
 
 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 = []
+    # List of denied function decorators
+    denied_function_decorator_list = ["cell_attr_register"]
     # Entry function of the forward computation process
-    entry_function = "construct"
+    entry_functions = ["construct"]
+    # Final networks where the paring action stops
+    final_networks = [Cell]
 
     def __init__(self):
         """Constructor"""
         super(ClassDefParser, self).__init__()
-        self._cell_namespace = CellNamespace('mindspore.nn')
+        self._cell_namespace = ModuleNamespace('mindspore.nn')
+
+    @staticmethod
+    def _save_imports(stree):
+        """save imports in module where network is located."""
+        origin_net = stree.get_origin_network()
+        net_path = inspect.getfile(type(origin_net))
+        stree.save_imports_from_file(net_path)
 
     @staticmethod
-    def _process_init_func_ast(init_ast: ast.FunctionDef, class_name: str, is_father_class: bool,
-                               father_classes: dict):
+    def _process_init_func_ast(init_ast: ast.FunctionDef, class_name_ori: str, class_name_opt: str,
+                               is_father_class: bool, father_classes: dict):
         """Process init func"""
-        ClassDefParser._modify_arguments_of_init_func(init_ast)
-        new_bodies = ClassDefParser._create_bodys_of_init_func(class_name, is_father_class, father_classes)
+        ClassDefParser._modify_arguments_of_init_func(init_ast, is_father_class)
+        new_bodies = ClassDefParser._create_bodys_of_init_func(class_name_ori, class_name_opt,
+                                                               is_father_class, father_classes)
         init_ast.body = new_bodies
 
     @staticmethod
-    def _create_bodys_of_init_func(class_name: str, is_father_class: bool, father_classes: dict):
+    def _create_bodys_of_init_func(class_name_ori: str, class_name_opt: 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)
+        father_class_init_bodies = ClassDefParser._father_class_init_process(father_classes)
         new_bodies.extend(father_class_init_bodies)
-        # copy variables into new class
+        # copy class 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]
+                f"for key, value in {class_name_ori}.__dict__.items():\n"
+                f"    if not key.startswith('__'):\n"
+                f"        setattr({class_name_opt}, key, value)").body[0]
             new_bodies.append(ast_copy_attr)
         else:
             ast_copy_attr = ast.parse(
@@ -147,38 +87,25 @@ class ClassDefParser(Parser):
         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__(...)"""
+    def _father_class_init_process(father_classes: dict) -> [ast.AST]:
+        """Add ast bodies of code: father_class.__init__(self)"""
         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}])"
+        for _, class_name in father_classes.items():
+            father_class_init_code = f"{class_name}.__init__(self)"
             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):
+    def _modify_arguments_of_init_func(ast_init_fn: ast.FunctionDef, is_father_class: bool):
         """Replace init function input parameters to self and global_vars."""
-        arg_self = ast.arg(arg="self", annotation="")
-        arg_global_vars = ast.arg(arg="obj", annotation="")
-        ast_init_fn.args = ast.arguments(args=[arg_self, arg_global_vars], posonlyargs=[], kwonlyargs=[],
+        arg_list = [ast.arg(arg="self", annotation="")]
+        if not is_father_class:
+            arg_list.append(ast.arg(arg="obj", annotation=""))
+        ast_init_fn.args = ast.arguments(args=arg_list, posonlyargs=[], kwonlyargs=[],
                                          kw_defaults=[], defaults=[], vararg=None, kwarg=None)
         ast.fix_missing_locations(ast_init_fn)
 
-    @staticmethod
-    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."""
@@ -187,10 +114,14 @@ class ClassDefParser(Parser):
             if key.startswith('__'):
                 # ignore inner functions
                 continue
-            if callable(value) and key in function_defs:
+            is_staticmethod = isinstance(value, staticmethod)
+            if not is_staticmethod and callable(value) and key in function_defs:
                 # ignore functions defined by self
                 continue
-            assign_code = f"self.__class__.{key} = obj.__class__.{key}"
+            if is_staticmethod:
+                assign_code = f"self.{key} = obj.__class__.{key}"
+            else:
+                assign_code = f"self.__class__.{key} = obj.__class__.{key}"
             assign_ast = ast.parse(assign_code).body[0]
             init_func_ast.body.append(assign_ast)
 
@@ -210,46 +141,69 @@ class ClassDefParser(Parser):
         ast.fix_missing_locations(cls_ast)
 
     @staticmethod
-    def _process_father_classes(stree, node: ast.ClassDef, cur_class_def: type) -> list:
+    def _add_ori_cls_into_father_class(stree: SymbolTree, node: ast.ClassDef, class_type: type):
+        """Add original class into node.bases as the father class."""
+        class_name = class_type.__name__
+        # ignore if origin class already exist in bases
+        exist_bases = [base.id for base in node.bases if isinstance(base, ast.Name)]
+        if class_name in exist_bases:
+            return
+        # add name to node.bases
+        node.bases.insert(0, ast.Name(id=class_name, ctx=ast.Load()))
+        # add import
+        module = inspect.getmodule(class_type)
+        stree.add_import(module, class_name, node)
+
+    @staticmethod
+    def _process_father_classes(stree: SymbolTree, node: ast.ClassDef, class_type: 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)
+            father_class_type = class_type.__bases__[idx]
+            father_class_name = AstConverter.get_ast_name(base)
             if not father_class_name:
+                logger.warning(error_str("Failed to parse base class:", child_node=base))
                 continue
-            father_classes[idx] = father_class_name
-            if father_class_name == "Cell":
+            if father_class_type in ClassDefParser.final_networks:
+                father_classes[idx] = astunparse.unparse(base).strip()
                 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())
+            # update father class name
+            father_class_name_opt = f"{father_class_name}Opt"
+            father_classes[idx] = father_class_name_opt
+            ClassDefParser._process_one_father_class(stree, father_class_type, father_class_name, father_class_name_opt)
+            node.bases[idx] = ast.Name(id=father_class_name_opt, ctx=ast.Load())
         return father_classes
 
     @staticmethod
-    def _process_one_father_class(stree: SymbolTree, father_class_def: type, father_class_name: str):
+    def _process_one_father_class(stree: SymbolTree, class_type: type, class_name_ori: str, class_name_opt: 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]
+        source_code = inspect.getsource(class_type)
+        class_ast: ast.ClassDef = ast.parse(dedent(source_code)).body[0]
+        # update class name from xxx to xxxOpt
+        replacer = AstReplacer(class_ast)
+        replacer.replace_all(class_name_ori, class_name_opt)
         # process father class's father classes
-        father_classes = ClassDefParser._process_father_classes(stree, father_class_ast, father_class_def)
+        father_classes = ClassDefParser._process_father_classes(stree, class_ast, class_type)
         # 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 ClassDefParser._need_add_init_func(class_ast):
+            ClassDefParser._add_init_func(class_ast)
+        for body in 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)
+                ClassDefParser._process_init_func_ast(body, class_name_ori, class_name_opt, True, father_classes)
             else:
                 # Remove other codes, which are copied in __init__ function.
-                father_class_ast.body.remove(body)
+                class_ast.body.remove(body)
         # save father class's ast into symbol tree
-        stree.get_father_class_ast().append(father_class_ast)
+        stree.get_father_class_ast()[class_ast] = []
+        # save father class's file path and imports into symbol tree
+        net_path = inspect.getfile(class_type)
+        stree.save_imports_from_file(net_path, class_ast)
+        # set origin class as father class
+        ClassDefParser._add_ori_cls_into_father_class(stree, class_ast, class_type)
+
 
     @staticmethod
     def _func_decorator_process(node: ast.FunctionDef):
@@ -285,10 +239,16 @@ class ClassDefParser(Parser):
         replacer = AstReplacer(node)
         replacer.replace_all(stree.get_ori_cls_name(), stree.get_opt_cls_name())
 
-        # process network's father classes
+        # save imports of current class
         stree.set_class_ast(node)
-        cur_class_def = type(stree.get_origin_network())
-        father_classes = ClassDefParser._process_father_classes(stree, node, cur_class_def)
+        ClassDefParser._save_imports(stree)
+
+        # process network's father classes
+        cur_class_type = type(stree.get_origin_network())
+        father_classes = ClassDefParser._process_father_classes(stree, node, cur_class_type)
+
+        # set origin class as father class
+        ClassDefParser._add_ori_cls_into_father_class(stree, node, cur_class_type)
 
         # add __init__ function to network if necessary
         if isinstance(stree.get_origin_network(), Cell) and ClassDefParser._need_add_init_func(node):
@@ -302,18 +262,25 @@ class ClassDefParser(Parser):
                 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:
+                    ClassDefParser._process_init_func_ast(body, stree.get_ori_cls_name(),
+                                                          stree.get_opt_cls_name(), False, father_classes)
+                elif body.name in ClassDefParser.entry_functions:
                     stree.set_ast_root(body)
                     parser: Parser = ParserRegister.instance().get_parser(ast.FunctionDef)
                     parser.process(stree, body, stree)
                 else:
-                    logger.info(
+                    logger.debug(
                         "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)
+            elif isinstance(body, ast.Expr) and \
+                (isinstance(body.value, ast.Str) or (isinstance(body.value, ast.Constant) and \
+                                                     isinstance(body.value.value, str))):
+                # delete the comments
+                node.body.remove(body)
+                continue
             else:
                 logger.info("Ignoring unsupported node(%s) in ast.ClassDef.", type(body).__name__)
         # Copy function class variables into new network

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.parsers.parser import Parser
-from mindspore.rewrite.symbol_tree import SymbolTree
-from mindspore.rewrite.parsers.parser_register import reg_parser
-from ..common import error_str
-from ..node.node_manager import NodeManager
+from . import Parser, reg_parser
+from ..node import NodeManager
+from ..symbol_tree import SymbolTree
+from ..common.error_log import error_str
+
 
 class NameParser(Parser):
     """Parse ast.Name in construct function to node of SymbolTree."""

mindspore/rewrite/parsers/container_parser.py

@@ -15,12 +15,10 @@
 """Parse Container in construct function to node of SymbolTree."""
 import ast
 
-from mindspore.rewrite.parsers.parser import Parser
-from mindspore.rewrite.symbol_tree import SymbolTree
-from mindspore.rewrite.parsers.parser_register import ParserRegister, reg_parser
-
-from ..common import error_str
-from ..node.node_manager import NodeManager
+from . import Parser, ParserRegister, reg_parser
+from ..symbol_tree import SymbolTree
+from ..node import NodeManager
+from ..common.error_log import error_str
 
 
 class ListParser(Parser):

mindspore/rewrite/parsers/expr_parser.py

@@ -0,0 +1,55 @@
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+""" Parse ast.Expr node """
+import ast
+import sys
+
+from mindspore import log as logger
+from . import Parser, reg_parser, AssignParser
+from ..node import NodeManager
+from ..symbol_tree import SymbolTree
+if sys.version_info >= (3, 9):
+    import ast as astunparse # pylint: disable=reimported, ungrouped-imports
+else:
+    import astunparse
+
+
+class ExprParser(Parser):
+    """ Class that implements parsing ast.Expr nodes """
+
+    def target(self):
+        """Parse target type"""
+        return ast.Expr
+
+    def process(self, stree: SymbolTree, node: ast.Expr, node_manager: NodeManager):
+        """ Process ast.Expr node """
+        # ast.Expr is not supported to be parsed.
+        stree.append_python_node(node, node, node_manager)
+        # when value of ast.Expr is ast.Call, add imports to make sure that the
+        # function object can be accessed.
+        if isinstance(node.value, ast.Call):
+            ast_call = node.value
+            func_full_name = astunparse.unparse(ast_call.func).strip()
+            func_name = func_full_name.split('.')[0]
+            module, _ = AssignParser._get_module_of_node_manager(node_manager) # pylint: disable=protected-access
+            if module is None:
+                logger.warning(f"Cannot get module where '{func_full_name}' is located.")
+                return
+            top_node_manager = node_manager.get_top_manager()
+            belonging_ast = None if isinstance(top_node_manager, SymbolTree) else top_node_manager.get_manager_ast()
+            stree.add_import(module, func_name, belonging_ast)
+
+
+g_expr_parser = reg_parser(ExprParser())

mindspore/rewrite/parsers/for_parser.py

@@ -13,116 +13,49 @@
 # limitations under the License.
 # ============================================================================
 """ Parse ast.For node """
-import sys
 import ast
 
-from mindspore.rewrite.api.scoped_value import ScopedValue, ValueType
-from mindspore.rewrite.ast_helpers.ast_modifier import AstModifier
-from mindspore import log as logger
-from mindspore import nn
+from . import Parser, ParserRegister, reg_parser
+from ..node import NodeManager, ControlFlow
 from ..symbol_tree import SymbolTree
-from .parser import Parser
-from .parser_register import reg_parser
-from ..common.event import Event
-from ..node.node_manager import NodeManager
-
-if sys.version_info >= (3, 9):
-    import ast as astunparse # pylint: disable=reimported, ungrouped-imports
-else:
-    import astunparse
-
-EVAL_WHITE_LIST = ("self.", "range(", "zip(", "enumerate(", "reversed(")
+from ..ast_helpers import AstConverter, AstFlattener
 
 
 class ForParser(Parser):
     """ Class that implements parsing ast.For nodes """
 
-    @staticmethod
-    def modify_init_ast(stree, i, obj, iter_var_name):
-        """Modify the ast node in init function."""
-        target = f"{iter_var_name.strip()}{str(i)}"
-        setattr(stree.get_origin_network(), target, obj)
-        stree.get_origin_network().insert_child_to_cell(target, obj)
-        AstModifier.insert_assign_to_function(stree.get_init_func_ast(),
-                                              targets=[ScopedValue(ValueType.NamingValue, "self", target)],
-                                              expr=ScopedValue(ValueType.NamingValue, "", "getattr"),
-                                              args=[ScopedValue(ValueType.NamingValue, "", "obj"),
-                                                    ScopedValue(ValueType.ConstantValue, "", target)])
-
-    @staticmethod
-    def modify_construct_ast(stree, ast_node, old_name, new_name):
-        """Modify the ast node in construct function."""
-        node_str: str = astunparse.unparse(ast_node)
-        node_str = node_str.replace(old_name+'(', new_name+'(')
-        module_node = ast.parse(node_str)
-        new_node = module_node.body[0]
-        return new_node
-
     def target(self):
+        """Parse target type"""
         return ast.For
 
     def process(self, stree: SymbolTree, node: ast.For, node_manager: NodeManager):
         """ Process ast.For node """
-        if isinstance(node.target, ast.Name):
-            targets = node.target.id
-        if isinstance(node.iter, ast.Str) or (isinstance(node.iter, ast.Constant) and
-                                              isinstance(node.iter.val, str)):
-            # Ast.For which has iter with type of str is converted to python node to avoid instruction injection
-            stree.try_append_python_node(node, node)
-            return
-        iter_code = astunparse.unparse(node.iter)
-        if not iter_code.startswith(EVAL_WHITE_LIST):
-            logger.info(
-                f"For MindSpore Rewrtie, illegal iteration condition for For node, it must start with{EVAL_WHITE_LIST}")
-            return
-        if "self" in iter_code:
-            iter_code = iter_code.replace("self", "stree.get_origin_network()")
-        try:
-            iter_obj = eval(iter_code)
-        except (NameError, TypeError) as e:
-            _info = f"For MindSpore Rewrtie, when eval '{iter_code}' by using JIT Fallback feature, " \
-                         f"an error occurred: {str(e)}"
-            logger.info(_info)
-            stree.try_append_python_node(node, node, node_manager)
-            return
-
-        iter_var_name = iter_code.split(".")[-1]
-        ast_functiondef = node_manager.get_ast_functiondef()
-        if not ast_functiondef:
-            logger.info(f"ast_functiondef is None in node_manager {node_manager.get_manager_name()} "
-                        "when parsing 'for' statement.")
-            stree.try_append_python_node(node, node, node_manager)
-            return
-        index = ast_functiondef.body.index(node) + 1
-        if isinstance(iter_obj, (list, nn.CellList)):
-            for obj in iter_obj:
-                if not isinstance(obj, nn.Cell):
-                    stree.try_append_python_node(node, node, node_manager)
-                    return
-            for i, obj in enumerate(iter_obj):
-                ForParser.modify_init_ast(stree, i, obj, iter_var_name)
-                for body in node.body:
-                    new_func_name = f"self.{iter_var_name.strip()}{str(i)}".strip()
-                    new_node = ForParser.modify_construct_ast(stree, body, targets, new_func_name)
-                    ast_functiondef.body.insert(index, new_node)
-                    index += 1
-            # Expand "for" statement and replace the body with Pass
-            for body in node.body[:]:
-                node.body.remove(body)
-            node.body.append(ast.Pass())
-
-            if stree.get_ori_cls_name() == "SequentialCell":
-                stree.on_change(Event.CodeChangeEvent)
-            return
-        if isinstance(iter_obj, range):
-            logger.info("For MindSpore Rewrite, range not support.")
-        elif isinstance(iter_obj, zip):
-            logger.info("For MindSpore Rewrite, zip not support.")
-        elif isinstance(iter_obj, enumerate):
-            logger.info("For MindSpore Rewrite, enumerate not support.")
-        else:
-            logger.info(f"For MindSpore Rewrite, not supported type: {type(iter_obj).__name__}")
-        stree.try_append_python_node(node, node, node_manager)
-        return
+        # expand codes in ast.for
+        ast_for = AstFlattener().transform_control_flow(node, stree)
+        # parse ast codes of for branch into ControlFlow Node
+        args = [AstConverter.create_scopedvalue(node.iter)]
+        for_node = ControlFlow("for_node", ast_for, False, args, stree)
+        for_node.loop_vars = AstConverter.get_ast_target_elems(node.target, True)
+        stree.append_origin_field(for_node, node_manager)
+        for_node.set_node_manager(node_manager)
+        for body in ast_for.body:
+            parser: Parser = ParserRegister.instance().get_parser(type(body))
+            if parser is None:
+                stree.append_python_node(ast_for, body, node_manager=for_node)
+            else:
+                parser.process(stree, body, node_manager=for_node)
+        # parse ast codes of else branch into ControlFlow Node
+        if ast_for.orelse:
+            for_else_node = ControlFlow("for_else_node", ast_for, True, args, stree)
+            for_else_node.loop_vars = AstConverter.get_ast_target_elems(node.target, True)
+            stree.append_origin_field(for_else_node, node_manager)
+            for body in ast_for.orelse:
+                parser: Parser = ParserRegister.instance().get_parser(type(body))
+                if parser is None:
+                    stree.append_python_node(ast_for, body, node_manager=for_else_node)
+                else:
+                    parser.process(stree, body, node_manager=for_else_node)
+            for_else_node.set_body_node(for_node)
+            for_node.set_orelse_node(for_else_node)
 
 g_for_parser = reg_parser(ForParser())