[MISC] Fix compilation warnings of unnecessary std::move() calls

Fix compilation warnings of "moving a temporary object prevents copy elision"

Author: Hzfengsy

src/relax/analysis/graph_partitioner.cc

@@ -286,7 +286,7 @@ size_t GraphPartitioner::CountFusedArgs(const IndexedForwardGraph& graph,
 }
 
 void GraphPartitioner::InitGroups(const IndexedForwardGraph& graph) {
-  auto args_counter = [this](const tvm::Object* obj) {
+  auto args_counter = [](const tvm::Object* obj) {
     size_t args_num = 0;
     if (auto call_node = GetRef<ObjectRef>(obj).as<CallNode>()) {
       for (auto& it : call_node->args) {

src/relax/ir/expr.cc

@@ -621,7 +621,7 @@ Function::Function(Array<Var> params, Expr body, Optional<StructInfo> ret_struct
   ObjectPtr<FunctionNode> n = make_object<FunctionNode>();
   n->params = std::move(params);
   n->body = std::move(body);
-  n->ret_struct_info = std::move(ret_struct_info.value());
+  n->ret_struct_info = ret_struct_info.value();
   n->is_pure = is_pure;
   n->struct_info_ = std::move(func_sinfo);
   n->attrs = std::move(attrs);

src/relax/op/nn/attention.cc

@@ -37,7 +37,7 @@ Expr attention(Expr query, Expr key, Expr value, Optional<Expr> bias, Optional<F
 
   if (bias) {
     return Call(Op::Get("relax.nn.attention_bias"),
-                {std::move(query), std::move(key), std::move(value), std::move(bias.value())},
+                {std::move(query), std::move(key), std::move(value), bias.value()},
                 Attrs(attrs), {});
   }
   return Call(Op::Get("relax.nn.attention"), {std::move(query), std::move(key), std::move(value)},

src/relax/op/nn/convolution.cc

@@ -595,7 +595,7 @@ Expr conv1d_transpose(Expr data, Expr weight, Array<IntImm> strides, Array<IntIm
   attrs->groups = groups;
   attrs->data_layout = data_layout;
   attrs->kernel_layout = std::move(kernel_layout);
-  attrs->out_layout = std::move(out_layout.value_or(data_layout));
+  attrs->out_layout = out_layout.value_or(data_layout);
   attrs->out_dtype = std::move(out_dtype.value_or(DataType::Void()));
   const Op& op = Op::Get("relax.nn.conv1d_transpose");
   return Call(op, {data, weight}, Attrs(attrs), {});
@@ -732,7 +732,7 @@ Expr conv2d_transpose(Expr data, Expr weight, Array<IntImm> strides, Array<IntIm
   attrs->groups = groups;
   attrs->data_layout = data_layout;
   attrs->kernel_layout = std::move(kernel_layout);
-  attrs->out_layout = std::move(out_layout.value_or(data_layout));
+  attrs->out_layout = out_layout.value_or(data_layout);
   attrs->out_dtype = std::move(out_dtype.value_or(DataType::Void()));
   const Op& op = Op::Get("relax.nn.conv2d_transpose");
   return Call(op, {data, weight}, Attrs(attrs), {});

src/relax/op/nn/nn.cc

@@ -905,7 +905,7 @@ Expr nll_loss(Expr predictions, Expr targets, Optional<Expr> weights, String red
 
   static const Op& op = Op::Get("relax.nn.nll_loss");
   if (weights.defined()) {
-    return Call(op, {std::move(predictions), std::move(targets), std::move(weights.value())},
+    return Call(op, {std::move(predictions), std::move(targets), weights.value()},
                 Attrs{attrs}, {});
   } else {
     return Call(op, {std::move(predictions), std::move(targets)}, Attrs{attrs}, {});

src/relax/op/tensor/grad.cc

@@ -101,10 +101,9 @@ Expr nll_loss_backward(Expr output_grad, Expr predictions, Expr targets, Optiona
 
   static const Op& op = Op::Get("relax.grad.nll_loss_backward");
   if (weights.defined()) {
-    return Call(op,
-                {std::move(output_grad), std::move(predictions), std::move(targets),
-                 std::move(weights.value())},
-                Attrs{attrs}, {});
+    return Call(
+        op, {std::move(output_grad), std::move(predictions), std::move(targets), weights.value()},
+        Attrs{attrs}, {});
   } else {
     return Call(op, {std::move(output_grad), std::move(predictions), std::move(targets)},
                 Attrs{attrs}, {});

src/relax/transform/convert_layout.cc

@@ -127,7 +127,7 @@ class LayoutConvertMutator : public ExprMutator {
         ObjectPtr<LayoutTransformAttrs> attrs = make_object<LayoutTransformAttrs>();
         Array<IntImm> axis_separator;
         Array<IntImm> input_axis_separator;
-        attrs->index_map = std::move(Downcast<IndexMap>(LoadJSON(SaveJSON(index_map))));
+        attrs->index_map = Downcast<IndexMap>(LoadJSON(SaveJSON(index_map)));
         attrs->axis_separators = std::move(axis_separator);
         attrs->input_axis_separators = std::move(input_axis_separator);
         const Op& layout_transform_op_ = Op::Get("relax.layout_transform");

src/relax/transform/fuse_tir.cc

@@ -846,7 +846,7 @@ class FusedTIRConstructor : public ExprVisitor {
     if (is_inplace) {
       const auto* attrs = call->attrs.as<CallTIRInplaceAttrs>();
       CHECK(attrs) << "Must have CallTIRInplaceAttrs for an in-place call";
-      output_idxs = std::move(GetInplaceOutputIndices(attrs->inplace_indices, num_inputs));
+      output_idxs = GetInplaceOutputIndices(attrs->inplace_indices, num_inputs);
     } else {
       for (size_t i = 0; i < output_size; i++) {
         output_idxs.push_back(num_inputs + i);

src/relax/transform/legalize_ops.cc

@@ -63,7 +63,7 @@ class LegalizeMutator : public ExprMutator {
                            bool enable_warning)
       : ExprMutator(mod), mod_(std::move(mod)), enable_warning_(enable_warning) {
     if (cmap) {
-      cmap_ = std::move(cmap.value());
+      cmap_ = cmap.value();
     }
   }
 

src/relax/transform/remove_purity_checking.cc

@@ -36,7 +36,7 @@ class PurityRemover : public ExprMutator {
     bool purity = func->is_pure;
     auto ret = func;
     if (purity) {
-      ret = std::move(WithAttr<Function>(func, relax::attr::kForcePure, true));
+      ret = WithAttr<Function>(func, relax::attr::kForcePure, true);
     }
     auto new_body = VisitExpr(ret->body);
     if (!new_body.same_as(ret->body)) {