Apply clang-tidy fixes for performance-move-const-arg to MLIR (NFC)

Author: joker-eph

mlir/examples/toy/Ch7/include/toy/Parser.h

@@ -253,11 +253,11 @@ class Parser {
       if (args.size() != 1)
         return parseError<ExprAST>("<single arg>", "as argument to print()");
 
-      return std::make_unique<PrintExprAST>(std::move(loc), std::move(args[0]));
+      return std::make_unique<PrintExprAST>(loc, std::move(args[0]));
     }
 
     // Call to a user-defined function
-    return std::make_unique<CallExprAST>(std::move(loc), std::string(name),
+    return std::make_unique<CallExprAST>(loc, std::string(name),
                                          std::move(args));
   }
 

mlir/include/mlir/ExecutionEngine/MemRefUtils.h

@@ -198,7 +198,7 @@ class OwningMemRef {
   DescriptorType &operator*() { return descriptor; }
   DescriptorType *operator->() { return &descriptor; }
   T &operator[](std::initializer_list<int64_t> indices) {
-    return descriptor[std::move(indices)];
+    return descriptor[indices];
   }
 
 private:

mlir/include/mlir/IR/BuiltinAttributeInterfaces.h

@@ -38,7 +38,7 @@ struct ElementsAttrIndexer {
   ElementsAttrIndexer(ElementsAttrIndexer &&rhs)
       : isContiguous(rhs.isContiguous), isSplat(rhs.isSplat) {
     if (isContiguous)
-      conState = std::move(rhs.conState);
+      conState = rhs.conState;
     else
       new (&nonConState) NonContiguousState(std::move(rhs.nonConState));
   }

mlir/include/mlir/IR/BuiltinAttributes.h

@@ -900,8 +900,7 @@ auto SparseElementsAttr::value_begin() const -> iterator<T> {
   auto valueIt = getValues().value_begin<T>();
   const std::vector<ptrdiff_t> flatSparseIndices(getFlattenedSparseIndices());
   std::function<T(ptrdiff_t)> mapFn =
-      [flatSparseIndices{std::move(flatSparseIndices)},
-       valueIt{std::move(valueIt)},
+      [flatSparseIndices{flatSparseIndices}, valueIt{std::move(valueIt)},
        zeroValue{std::move(zeroValue)}](ptrdiff_t index) {
         // Try to map the current index to one of the sparse indices.
         for (unsigned i = 0, e = flatSparseIndices.size(); i != e; ++i)

mlir/include/mlir/Support/Timing.h

@@ -228,8 +228,7 @@ class Timer {
   ///
   /// The `nameBuilder` function is not guaranteed to be called.
   Timer nest(const void *id, function_ref<std::string()> nameBuilder) {
-    return tm ? Timer(*tm, tm->nestTimer(handle, id, std::move(nameBuilder)))
-              : Timer();
+    return tm ? Timer(*tm, tm->nestTimer(handle, id, nameBuilder)) : Timer();
   }
 
   /// See above.

mlir/include/mlir/TableGen/Format.h

@@ -152,7 +152,7 @@ class FmtObjectBase {
   FmtObjectBase(const FmtObjectBase &that) = delete;
 
   FmtObjectBase(FmtObjectBase &&that)
-      : fmt(std::move(that.fmt)), context(that.context),
+      : fmt(that.fmt), context(that.context),
         adapters(), // adapters are initialized by FmtObject
         replacements(std::move(that.replacements)) {}
 

mlir/include/mlir/Transforms/DialectConversion.h

@@ -778,7 +778,7 @@ class ConversionTarget {
                                   StringRef name, Names... names) {
     SmallVector<StringRef, 2> dialectNames({name, names...});
     setDialectAction(dialectNames, LegalizationAction::Dynamic);
-    setLegalityCallback(dialectNames, std::move(callback));
+    setLegalityCallback(dialectNames, callback);
   }
   template <typename... Args>
   void addDynamicallyLegalDialect(DynamicLegalityCallbackFn callback) {