diff --git a/mindspore/ccsrc/frontend/optimizer/ad/dfunctor.cc b/mindspore/ccsrc/frontend/optimizer/ad/dfunctor.cc
index cda2cd09ba1..eeae71bb77e 100644
--- a/mindspore/ccsrc/frontend/optimizer/ad/dfunctor.cc
+++ b/mindspore/ccsrc/frontend/optimizer/ad/dfunctor.cc
@@ -361,13 +361,7 @@ void DFunctor::ReplaceEquivdout(const CNodePtr &cnode, const CNodePtr &cnode_mor
   auto func_graph = GetValueNode<FuncGraphPtr>(input_fg);
   MS_EXCEPTION_IF_NULL(func_graph);
   auto manager = Manage({fg, func_graph}, false);
-  auto need_replace_forward = true;
-  auto forward_value = GenNewTensor(manager, equivdout, forward, need_replace_forward);
-  if (!need_replace_forward) {
-    cnode_morph->clear_inputs_value();
-    MS_LOG(DEBUG) << "No need replace forward result";
-    return;
-  }
+  auto forward_value = GenNewTensor(manager, equivdout, forward, true);
   MS_LOG(DEBUG) << "Replace: " << equivdout->ToString() << " with " << forward;
   auto value_node = NewValueNode(forward_value);
   value_node->set_has_new_value(true);
@@ -406,7 +400,7 @@ void DFunctor::ReplaceEquivdout(const CNodePtr &cnode, const CNodePtr &cnode_mor
   }
   auto out_node = c_input->cast<ValueNodePtr>();
   MS_EXCEPTION_IF_NULL(out_node);
-  out_node->set_value(GenNewTensor(manager, out_node, out_node->value(), need_replace_forward));
+  out_node->set_value(GenNewTensor(manager, out_node, out_node->value(), true));
 }
 
 bool DFunctor::IsFreeMorphism(const AnfNodePtr &node) {
diff --git a/mindspore/ccsrc/pipeline/jit/parse/parse_dynamic.cc b/mindspore/ccsrc/pipeline/jit/parse/parse_dynamic.cc
index de5ca45858a..d0dc12aedec 100644
--- a/mindspore/ccsrc/pipeline/jit/parse/parse_dynamic.cc
+++ b/mindspore/ccsrc/pipeline/jit/parse/parse_dynamic.cc
@@ -33,8 +33,8 @@ static const std::set<std::string> unchanged_named_primitive = {parse::NAMED_PRI
                                                                 parse::NAMED_PRIMITIVE_NAMECONSTANT,
                                                                 parse::NAMED_PRIMITIVE_NUM, parse::NAMED_PRIMITIVE_STR};
 
-std::string DynamicAnalysis::ParseNodeName(const std::shared_ptr<parse::ParseAst> &ast, const py::object &node,
-                                           parse::AstMainType type) {
+std::string DynamicParser::ParseNodeName(const std::shared_ptr<parse::ParseAst> &ast, const py::object &node,
+                                         parse::AstMainType type) {
   MS_EXCEPTION_IF_NULL(ast);
   if (py::isinstance<py::none>(node)) {
     MS_LOG(DEBUG) << "Get none type node!";
@@ -53,7 +53,7 @@ std::string DynamicAnalysis::ParseNodeName(const std::shared_ptr<parse::ParseAst
   return node_name;
 }
 
-void DynamicAnalysis::ParseInputArgs(const std::shared_ptr<parse::ParseAst> &ast, const py::object &fn_node) {
+void DynamicParser::ParseInputArgs(const std::shared_ptr<parse::ParseAst> &ast, const py::object &fn_node) {
   MS_EXCEPTION_IF_NULL(ast);
   py::list args = ast->GetArgs(fn_node);
   for (size_t i = 1; i < args.size(); i++) {
@@ -63,7 +63,7 @@ void DynamicAnalysis::ParseInputArgs(const std::shared_ptr<parse::ParseAst> &ast
   }
 }
 
-bool DynamicAnalysis::ParseIfWhileExprNode(const std::shared_ptr<parse::ParseAst> &ast, const py::object &node) {
+bool DynamicParser::ParseIfWhileExprNode(const std::shared_ptr<parse::ParseAst> &ast, const py::object &node) {
   MS_LOG(DEBUG) << "Parse if/while expr";
   py::object test_node = parse::python_adapter::GetPyObjAttr(node, parse::NAMED_PRIMITIVE_TEST);
   const auto &node_name = ParseNodeName(ast, test_node, parse::AST_MAIN_TYPE_EXPR);
@@ -112,7 +112,7 @@ bool DynamicAnalysis::ParseIfWhileExprNode(const std::shared_ptr<parse::ParseAst
   return false;
 }
 
-bool DynamicAnalysis::ParseAssignExprNode(const std::shared_ptr<parse::ParseAst> &ast, const py::object &node) {
+bool DynamicParser::ParseAssignExprNode(const std::shared_ptr<parse::ParseAst> &ast, const py::object &node) {
   MS_LOG(DEBUG) << "Parse assign expr";
   py::object value_node = parse::python_adapter::GetPyObjAttr(node, parse::NAMED_PRIMITIVE_VALUE);
   const auto &node_name = ParseNodeName(ast, value_node, parse::AST_MAIN_TYPE_EXPR);
@@ -140,8 +140,8 @@ bool DynamicAnalysis::ParseAssignExprNode(const std::shared_ptr<parse::ParseAst>
   return false;
 }
 
-bool DynamicAnalysis::ParseAugAssignExprNode(const std::shared_ptr<parse::ParseAst> &ast, const py::object &node,
-                                             const std::vector<std::string> &compare_prim) {
+bool DynamicParser::ParseAugAssignExprNode(const std::shared_ptr<parse::ParseAst> &ast, const py::object &node,
+                                           const std::vector<std::string> &compare_prim) {
   MS_LOG(DEBUG) << "Parse augassign expr";
   bool ret = false;
   if (compare_prim.empty()) {
@@ -168,7 +168,7 @@ bool DynamicAnalysis::ParseAugAssignExprNode(const std::shared_ptr<parse::ParseA
   return ret;
 }
 
-bool DynamicAnalysis::ParseForExprNode(const std::shared_ptr<parse::ParseAst> &ast, const py::object &node) {
+bool DynamicParser::ParseForExprNode(const std::shared_ptr<parse::ParseAst> &ast, const py::object &node) {
   MS_LOG(DEBUG) << "Parse for expr";
   py::object body_node = parse::python_adapter::GetPyObjAttr(node, parse::NAMED_PRIMITIVE_BODY);
   if (py::isinstance<py::none>(body_node)) {
@@ -188,8 +188,8 @@ bool DynamicAnalysis::ParseForExprNode(const std::shared_ptr<parse::ParseAst> &a
   return false;
 }
 
-bool DynamicAnalysis::ParseBodyContext(const std::shared_ptr<parse::ParseAst> &ast, const py::object &fn_node,
-                                       const std::vector<std::string> &compare_prim) {
+bool DynamicParser::ParseBodyContext(const std::shared_ptr<parse::ParseAst> &ast, const py::object &fn_node,
+                                     const std::vector<std::string> &compare_prim) {
   MS_EXCEPTION_IF_NULL(ast);
   py::object func_obj = parse::python_adapter::GetPyObjAttr(fn_node, parse::NAMED_PRIMITIVE_BODY);
   if (py::isinstance<py::none>(func_obj)) {
@@ -220,7 +220,7 @@ bool DynamicAnalysis::ParseBodyContext(const std::shared_ptr<parse::ParseAst> &a
   return ret;
 }
 
-std::string DynamicAnalysis::GetCellInfo(const py::object &cell) {
+std::string DynamicParser::GetCellInfo(const py::object &cell) {
   if (py::isinstance<Cell>(cell)) {
     auto c_cell = py::cast<CellPtr>(cell);
     MS_EXCEPTION_IF_NULL(c_cell);
@@ -230,7 +230,7 @@ std::string DynamicAnalysis::GetCellInfo(const py::object &cell) {
   return "";
 }
 
-bool DynamicAnalysis::IsDynamicCell(const py::object &cell) {
+bool DynamicParser::IsDynamicCell(const py::object &cell) {
   std::string cell_info = GetCellInfo(cell);
   if (ignore_judge_dynamic_cell.find(cell_info) != ignore_judge_dynamic_cell.end()) {
     return false;
diff --git a/mindspore/ccsrc/pipeline/jit/parse/parse_dynamic.h b/mindspore/ccsrc/pipeline/jit/parse/parse_dynamic.h
index 25584db5c6c..73ce81cbd62 100644
--- a/mindspore/ccsrc/pipeline/jit/parse/parse_dynamic.h
+++ b/mindspore/ccsrc/pipeline/jit/parse/parse_dynamic.h
@@ -26,10 +26,10 @@
 
 namespace mindspore::parse {
 
-class DynamicAnalysis {
+class DynamicParser {
  public:
-  DynamicAnalysis() = default;
-  ~DynamicAnalysis() = default;
+  DynamicParser() = default;
+  ~DynamicParser() = default;
 
   // Check cell struct
   static bool IsDynamicCell(const py::object &cell);
diff --git a/mindspore/ccsrc/pipeline/pynative/pynative_execute.cc b/mindspore/ccsrc/pipeline/pynative/pynative_execute.cc
index 3cd1a3d1189..e8e6f4f88f3 100644
--- a/mindspore/ccsrc/pipeline/pynative/pynative_execute.cc
+++ b/mindspore/ccsrc/pipeline/pynative/pynative_execute.cc
@@ -1971,7 +1971,7 @@ void GradExecutor::NewGraphInner(py::object *ret, const py::object &cell, const
   InitResourceAndDfBuilder(cell_id, args);
   // Check whether cell has dynamic construct
   if (!top_cell()->is_dynamic()) {
-    bool is_dynamic = parse::DynamicAnalysis::IsDynamicCell(cell);
+    bool is_dynamic = parse::DynamicParser::IsDynamicCell(cell);
     MS_LOG(DEBUG) << "Current cell dynamic " << is_dynamic;
     if (is_dynamic) {
       top_cell()->set_is_dynamic(is_dynamic);