fix clean code problem

mindspore/_extends/parse/standard_method.py

@@ -51,6 +51,7 @@ itemsize_map = {mstype.bool_: 1, mstype.int8: 1, mstype.uint8: 1,
 
 nan_tensor = Tensor(float('nan'), dtype=mstype.float32)
 
+
 def mean(x, axis=(), keep_dims=False):
     """
     Reduces a dimension of a tensor by averaging all elements in the dimension.
@@ -1648,6 +1649,7 @@ check_axis_type = constexpr(validator.check_axis_type)
 check_and_canonicalize_axes = constexpr(validator.check_and_canonicalize_axes)
 empty_compile = constexpr(validator.empty_compile)
 
+
 def tensor_bool(x):
     """tensor as condition, if is constant, return immediate bool value"""
     is_cond = check_is_tensor_bool_cond(F.shape(x))

mindspore/ccsrc/debug/trace.cc

@@ -480,7 +480,6 @@ struct TraceNodeProviderRegister {
       auto stack = GetCNodeDebugStack();
       if (!stack.empty()) {
         auto conf = stack.back();
-        MS_EXCEPTION_IF_NULL(conf);
         *node = conf->node();
       }
     });

mindspore/ccsrc/frontend/optimizer/ad/kpynative.cc

@@ -172,6 +172,7 @@ FuncGraphPtr BuildFakeBProp(const PrimitivePtr &prim, size_t inputs_num) {
   for (size_t i = 0; i < inputs_num; ++i) {
     // Mock params for inputs
     auto param = func_graph->add_parameter();
+    MS_EXCEPTION_IF_NULL(param);
     // Mock derivatives for each inputs
     outputs.push_back(fake_input_sens);
   }
@@ -191,10 +192,10 @@ class PynativeAdjoint {
       : tape_(tape), op_args_(op_args), out_(out), fg_(fg), fg_type_(fg_type) {}
 
   AnfNodePtrList &users() { return users_; }
-  const ValuePtrList &op_args() { return op_args_; }
-  const ValuePtr &out() { return out_; }
-  const FuncGraphPtr &fg() { return fg_; }
-  const FuncGraphType &fg_type() { return fg_type_; }
+  const ValuePtrList &op_args() const { return op_args_; }
+  const ValuePtr &out() const { return out_; }
+  const FuncGraphPtr &fg() const { return fg_; }
+  const FuncGraphType &fg_type() const { return fg_type_; }
   AnfNodePtr RealDout() {
     if (dout_ != nullptr) {
       return dout_;
@@ -249,11 +250,11 @@ class KPynativeCellImpl : public KPynativeCell {
     tape_->debug_info()->set_name("grad_top");
     for (size_t i = 0; i < cell_inputs.size(); ++i) {
       TraceGuard trace_guard(std::make_shared<TraceCopy>(cell_inputs[i]->debug_info()));
-      tape_->add_parameter();
+      (void)tape_->add_parameter();
       // Build adjoint for every input parameter
       auto input_adjoint =
         std::make_shared<PynativeAdjoint>(tape_, ValuePtrList{}, input_param_values[i], FuncGraphPtr(nullptr));
-      anfnode_to_adjoin_.insert(std::make_pair(cell_inputs[i], input_adjoint));
+      (void)anfnode_to_adjoin_.insert(std::make_pair(cell_inputs[i], input_adjoint));
     }
   }
   ~KPynativeCellImpl() override = default;
@@ -348,11 +349,11 @@ FuncGraphPtr KPynativeCellImpl::Finish(const AnfNodePtrList &weights, bool grad_
   SetSensAndWeights(weights, has_sens_arg);
   // Build forward CNode;
   if (build_formal_param) {
-    BuildKNode();
+    (void)BuildKNode();
   }
   // BackPropagate sensitivity, except when the last node is a valuenode which may be obtained by constant folding;
   if (!last_node_->isa<ValueNode>()) {
-    BackPropagate(!build_formal_param);
+    (void)BackPropagate(!build_formal_param);
   }
   // Return the gradient;
   SetOutput(weights, grad_inputs, grad_weights);
@@ -394,7 +395,7 @@ bool KPynativeCellImpl::KPynativeOp(const CNodePtr &cnode, const ValuePtrList &o
     }
   }
   MS_EXCEPTION_IF_NULL(bprop_fg);
-  BuildAdjoint(cnode, op_args, out, bprop_fg);
+  (void)BuildAdjoint(cnode, op_args, out, bprop_fg);
 
   return true;
 }
@@ -413,7 +414,7 @@ bool KPynativeCellImpl::KPynativeWithBProp(const CNodePtr &cnode, const ValuePtr
     MS_LOG(EXCEPTION) << "Should be func graph, but: " << cnode->DebugString();
   }
   MS_EXCEPTION_IF_NULL(bprop_fg);
-  BuildAdjoint(cnode, op_args, out, bprop_fg);
+  (void)BuildAdjoint(cnode, op_args, out, bprop_fg);
 
   return true;
 }
@@ -423,7 +424,7 @@ bool KPynativeCellImpl::KPynativeWithFProp(const CNodePtr &cnode, const ValuePtr
   MS_EXCEPTION_IF_NULL(cnode);
   MS_EXCEPTION_IF_NULL(fprop_fg);
 
-  BuildAdjoint(cnode, op_args, out, fprop_fg, PynativeAdjoint::kForwardPropagate);
+  (void)BuildAdjoint(cnode, op_args, out, fprop_fg, PynativeAdjoint::kForwardPropagate);
 
   return true;
 }
@@ -446,7 +447,7 @@ void KPynativeCellImpl::UpdateOutputNodeOfTopCell(const AnfNodePtr &output_node)
       MS_LOG(DEBUG) << "Build adjoint for valuenode: " << v_node->ToString();
       auto v_node_pynative_adjoint =
         std::make_shared<PynativeAdjoint>(tape_, ValuePtrList{}, v_node->value(), FuncGraphPtr(nullptr));
-      anfnode_to_adjoin_.insert(std::make_pair(output_node, v_node_pynative_adjoint));
+      (void)anfnode_to_adjoin_.insert(std::make_pair(output_node, v_node_pynative_adjoint));
       return;
     }
     MS_LOG(EXCEPTION) << "BackPropagate adjoint does not exist for input: " << last_node_->DebugString();
@@ -461,8 +462,8 @@ ValuePtr ShallowCopyValue(const ValuePtr &value) {
   } else if (value->isa<ValueTuple>()) {
     std::vector<ValuePtr> values;
     auto value_tuple = value->cast<ValueTuplePtr>();
-    std::transform(value_tuple->value().begin(), value_tuple->value().end(), std::back_inserter(values),
-                   [](const ValuePtr &elem) { return ShallowCopyValue(elem); });
+    (void)std::transform(value_tuple->value().begin(), value_tuple->value().end(), std::back_inserter(values),
+                         [](const ValuePtr &elem) { return ShallowCopyValue(elem); });
     return std::make_shared<ValueTuple>(values);
   } else {
     return value;
@@ -504,7 +505,7 @@ PynativeAdjointPtr KPynativeCellImpl::ForgeGetItemAdjoint(const CNodePtr &cnode)
   if (index_value->value() < 0) {
     MS_LOG(EXCEPTION) << "CNode input 2 should not less than 0, CNode: " << cnode->DebugString();
   }
-  size_t index_value_imm = index_value->value();
+  size_t index_value_imm = LongToSize(index_value->value());
   if (index_value_imm >= input_1_out->size()) {
     MS_LOG(EXCEPTION) << "CNode input 2 should be index between [0, " << input_1_out->size()
                       << ", but: " << index_value->ToString();
@@ -608,7 +609,7 @@ void KPynativeCellImpl::BuildAdjointForInput(const CNodePtr &cnode, const ValueP
       } else {
         auto input_adjoint =
           std::make_shared<PynativeAdjoint>(tape_, ValuePtrList{}, op_args[i - 1], FuncGraphPtr(nullptr));
-        anfnode_to_adjoin_.insert(std::make_pair(input, input_adjoint));
+        (void)anfnode_to_adjoin_.insert(std::make_pair(input, input_adjoint));
         input_adjoint->users().push_back(cnode);
       }
     } else {
@@ -623,8 +624,8 @@ bool KPynativeCellImpl::BuildAdjoint(const CNodePtr &cnode, const ValuePtrList &
   // Clone op_args and out, so the address of tensor data can be reset to nullptr if the value of tensor
   // is not used in bprop_fg;
   ValuePtrList cloned_op_args;
-  std::transform(op_args.begin(), op_args.end(), std::back_inserter(cloned_op_args),
-                 [](const ValuePtr &value) { return ShallowCopyValue(value); });
+  (void)std::transform(op_args.begin(), op_args.end(), std::back_inserter(cloned_op_args),
+                       [](const ValuePtr &value) { return ShallowCopyValue(value); });
   ValuePtr cloned_out = ShallowCopyValue(out);
   PynativeAdjointPtr cnode_adjoint;
   if (fg_type == PynativeAdjoint::kBackwardPropagate) {
@@ -636,7 +637,7 @@ bool KPynativeCellImpl::BuildAdjoint(const CNodePtr &cnode, const ValuePtrList &
 
   BuildAdjointForInput(cnode, op_args);
 
-  anfnode_to_adjoin_.insert(std::make_pair(cnode, cnode_adjoint));
+  (void)anfnode_to_adjoin_.insert(std::make_pair(cnode, cnode_adjoint));
 
   return true;
 }
@@ -718,7 +719,7 @@ const AnfNodePtrList KPynativeCellImpl::BuildKNodeListFromPrimalCNode(const CNod
   MS_EXCEPTION_IF_NULL(adjoint);
   AnfNodePtrList node_list;
   for (size_t i = 1; i < cnode->inputs().size(); ++i) {
-    node_list.emplace_back(BuildKNodeForCNodeInput(adjoint, cnode->input(i), i));
+    (void)node_list.emplace_back(BuildKNodeForCNodeInput(adjoint, cnode->input(i), i));
   }
   return node_list;
 }
@@ -758,7 +759,7 @@ bool KPynativeCellImpl::BackPropagateOneCNodeWithBPropFuncGraph(const CNodePtr &
     node_list.push_back(adjoint->RealDout());
   } else {
     const auto &k_node_list = BuildKNodeListFromPrimalCNode(cnode, adjoint);
-    node_list.insert(node_list.end(), k_node_list.begin(), k_node_list.end());
+    (void)node_list.insert(node_list.end(), k_node_list.begin(), k_node_list.end());
     // out;
     node_list.push_back(adjoint->k_node());
     // dout;
@@ -767,7 +768,7 @@ bool KPynativeCellImpl::BackPropagateOneCNodeWithBPropFuncGraph(const CNodePtr &
   // Back propagate process
   auto bprop_app = tape_->NewCNode(node_list);
   bprop_app->set_abstract(bprop_output_abs);
-  BackPropagate(cnode, bprop_app);
+  (void)BackPropagate(cnode, bprop_app);
   return true;
 }
 
@@ -780,12 +781,12 @@ bool KPynativeCellImpl::BackPropagateOneCNodeWithFPropFuncGraph(const CNodePtr &
   CNodePtr bprop_cnode;
   if (by_value) {
     AnfNodePtrList args_node_list;
-    std::transform(adjoint->op_args().begin(), adjoint->op_args().end(), std::back_inserter(args_node_list),
-                   [](const ValuePtr &value) {
-                     auto v_node = NewValueNode(value);
-                     v_node->set_abstract(value->ToAbstract()->Broaden());
-                     return v_node;
-                   });
+    (void)std::transform(adjoint->op_args().begin(), adjoint->op_args().end(), std::back_inserter(args_node_list),
+                         [](const ValuePtr &value) {
+                           auto v_node = NewValueNode(value);
+                           v_node->set_abstract(value->ToAbstract()->Broaden());
+                           return v_node;
+                         });
 
     bprop_cnode = GetBPropFromFProp(fprop_fg, args_node_list);
   } else {
@@ -797,7 +798,7 @@ bool KPynativeCellImpl::BackPropagateOneCNodeWithFPropFuncGraph(const CNodePtr &
   node_list.push_back(adjoint->RealDout());
   // Back propagate process
   auto bprop_app = tape_->NewCNode(node_list);
-  BackPropagate(cnode, bprop_app);
+  (void)BackPropagate(cnode, bprop_app);
   return true;
 }
 
@@ -829,9 +830,9 @@ bool KPynativeCellImpl::BackPropagate(bool by_value) {
     auto fg_type = iter->second->fg_type();
 
     if (fg_type == PynativeAdjoint::kBackwardPropagate) {
-      BackPropagateOneCNodeWithBPropFuncGraph(cnode, iter->second, fg, by_value);
+      (void)BackPropagateOneCNodeWithBPropFuncGraph(cnode, iter->second, fg, by_value);
     } else {
-      BackPropagateOneCNodeWithFPropFuncGraph(cnode, iter->second, fg, by_value);
+      (void)BackPropagateOneCNodeWithFPropFuncGraph(cnode, iter->second, fg, by_value);
     }
   }
   return true;
@@ -921,6 +922,7 @@ FuncGraphPtr KPynativeCellImpl::BuildMakeSequenceBprop(const PrimitivePtr &prim,
   b->debug_info()->set_name(ss.str());
   for (size_t i = 0; i < inputs_num; ++i) {
     auto param = b->add_parameter();
+    MS_EXCEPTION_IF_NULL(param);
   }
   // out, dout
   auto p1 = b->add_parameter();
@@ -974,7 +976,7 @@ void KPynativeCellImpl::SetSensAndWeights(const AnfNodePtrList &weights, bool ha
   for (const auto &weight : weights) {
     TraceGuard trace_guard(std::make_shared<TraceCopy>(weight->debug_info()));
     auto p = tape_->add_parameter();
-    need_grad_weights_.emplace(weight);
+    (void)need_grad_weights_.emplace(weight);
     auto input_w = weight->cast<ParameterPtr>();
     MS_EXCEPTION_IF_NULL(input_w);
     // Use name to match weight parameter in high order
@@ -1066,7 +1068,7 @@ bool KPynativeCellImpl::BuildKNode() {
     auto cnode = iter->first->cast<CNodePtr>();
     MS_EXCEPTION_IF_NULL(cnode);
     for (size_t i = 0; i < cnode->inputs().size(); ++i) {
-      node_list.emplace_back(BuildKNodeForCNodeInput(iter->second, cnode->input(i), i));
+      (void)node_list.emplace_back(BuildKNodeForCNodeInput(iter->second, cnode->input(i), i));
     }
     auto k_node = tape_->NewCNode(node_list);
     k_node->set_abstract(iter->second->out()->ToAbstract()->Broaden());
@@ -1091,7 +1093,7 @@ CNodePtr KPynativeCellImpl::GetBPropFromFProp(const FuncGraphPtr &fprop_fg, cons
   auto get_bprop =
     bprop_builder->NewCNode({NewValueNode(prim::kPrimTupleGetItem), fprop_app, NewValueNode(static_cast<int64_t>(1))});
   bprop_builder->set_output(get_bprop);
-  bprop_builder_inputs.insert(bprop_builder_inputs.begin(), NewValueNode(bprop_builder));
+  (void)bprop_builder_inputs.insert(bprop_builder_inputs.begin(), NewValueNode(bprop_builder));
   get_bprop = tape_->NewCNode(bprop_builder_inputs);
 
   return get_bprop;
@@ -1103,7 +1105,7 @@ void KPynativeCellImpl::ReplacePrimalParameter(const AnfNodePtrList &weights, bo
   const auto &parameters = tape_->parameters();
   auto cell_inputs_size = cell_inputs_.size();
   for (size_t i = 0; i < cell_inputs_size; ++i) {
-    tr.Replace(cell_inputs_[i], parameters[i]);
+    (void)tr.Replace(cell_inputs_[i], parameters[i]);
   }
   // (Inputs, sens, weights) or (Inputs, weights)
   size_t weight_offset = cell_inputs_size;
@@ -1111,7 +1113,7 @@ void KPynativeCellImpl::ReplacePrimalParameter(const AnfNodePtrList &weights, bo
     weight_offset = weight_offset + 1;
   }
   for (size_t i = 0; i < weights.size(); ++i) {
-    tr.Replace(weights[i], parameters[weight_offset + i]);
+    (void)tr.Replace(weights[i], parameters[weight_offset + i]);
   }
   tr.Commit();
 }

mindspore/ccsrc/pipeline/jit/static_analysis/remove_random_op_monad.cc

@@ -69,13 +69,13 @@ class RemoveMonad {
     auto &inputs = cnode->inputs();
     std::vector<AnfNodePtr> new_random_node_inputs;
     // Remove monad input, in order to parallel execution of random number operators
-    std::copy_if(inputs.begin(), inputs.end(), std::back_inserter(new_random_node_inputs),
-                 [](const AnfNodePtr &input) { return !HasAbstractMonad(input); });
+    (void)std::copy_if(inputs.begin(), inputs.end(), std::back_inserter(new_random_node_inputs),
+                       [](const AnfNodePtr &input) { return !HasAbstractMonad(input); });
     auto new_random_node = func_graph_->NewCNode(new_random_node_inputs);
     MS_EXCEPTION_IF_NULL(node->abstract());
     new_random_node->set_abstract(node->abstract());
     new_random_node->set_scope(node->scope());
-    manager_->Replace(node, new_random_node);
+    (void)manager_->Replace(node, new_random_node);
   }
 
   void RemoveRandomNodesFromMonadChain(const AnfNodePtr &node) {
@@ -88,7 +88,7 @@ class RemoveMonad {
     if (attach_input->isa<CNode>()) {
       auto prim = GetCNodePrimitive(attach_input);
       if (prim != nullptr && CheckPrimRandomEffect(prim)) {
-        manager_->Replace(cnode, monad_input);
+        (void)manager_->Replace(cnode, monad_input);
       }
     }
   }

mindspore/ccsrc/pipeline/jit/static_analysis/static_analysis.cc

@@ -709,6 +709,7 @@ std::string JoinBranchesFailedInfo(const AbstractBasePtr &spec, const AbstractBa
                                    const AnfNodePtr &node, const std::string &error_info) {
   std::ostringstream buffer;
   buffer << "The return values of different branches do not match. " << error_info
+         << ". For more details, please refer to the FAQ at https://www.mindspore.cn."
          << " The abstract type of the return value of the current branch is " << spec->ToString()
          << ", and that of the previous branch is " << last_spec->ToString() << ". Please check the node "
          << node->DebugString();

mindspore/core/abstract/prim_others.cc

@@ -544,7 +544,7 @@ AbstractBasePtr InferImplGpuConvertToDynamicShape(const AnalysisEnginePtr &, con
   AbstractTensorPtr input = CheckArg<AbstractTensor>(op_name, args_spec_list, 0);
 
   ShapeVector input_shape = input->shape()->shape();
-  int32_t input_rank = input_shape.size();
+  int32_t input_rank = SizeToInt(input_shape.size());
   ShapeVector inferred_shape(input_rank, Shape::SHP_ANY);
   ShapeVector min_shape(input_rank, 1);
   ShapeVector max_shape = input_shape;

mindspore/core/ir/manager.cc

@@ -671,15 +671,15 @@ void FuncGraphManager::EraseOneGraph(FuncGraph *fg) {
 }
 
 void FuncGraphTransaction::SetParameters(FuncGraphPtr fg, const std::vector<AnfNodePtr> &params) {
-  changes_.emplace_back(Change::kTxSetParams, ArgsOfSetParams{fg, params});
+  (void)changes_.emplace_back(Change::kTxSetParams, ArgsOfSetParams{fg, params});
 }
 
 void FuncGraphTransaction::AddParameter(FuncGraphPtr fg, const AnfNodePtr &param) {
-  changes_.emplace_back(Change::kTxAddParam, ArgsOfAddParam{fg, param});
+  (void)changes_.emplace_back(Change::kTxAddParam, ArgsOfAddParam{fg, param});
 }
 
 void FuncGraphTransaction::InsertFrontParameter(FuncGraphPtr fg, const AnfNodePtr &param) {
-  changes_.emplace_back(Change::kTxInsertFrontParam, ArgsOfInsertFrontParam{fg, param});
+  (void)changes_.emplace_back(Change::kTxInsertFrontParam, ArgsOfInsertFrontParam{fg, param});
 }
 
 bool FuncGraphTransaction::Replace(const AnfNodePtr &old_node, const AnfNodePtr &new_node) {