Fix more clang-tidy cleanups in mlir/ (NFC)

Author: joker-eph

mlir/lib/Analysis/DataFlowAnalysis.cpp

@@ -756,13 +756,13 @@ void ForwardDataFlowSolver::join(Operation *owner, AbstractLatticeElement &to,
 // AbstractLatticeElement
 //===----------------------------------------------------------------------===//
 
-AbstractLatticeElement::~AbstractLatticeElement() {}
+AbstractLatticeElement::~AbstractLatticeElement() = default;
 
 //===----------------------------------------------------------------------===//
 // ForwardDataFlowAnalysisBase
 //===----------------------------------------------------------------------===//
 
-ForwardDataFlowAnalysisBase::~ForwardDataFlowAnalysisBase() {}
+ForwardDataFlowAnalysisBase::~ForwardDataFlowAnalysisBase() = default;
 
 AbstractLatticeElement &
 ForwardDataFlowAnalysisBase::getLatticeElement(Value value) {

mlir/lib/Analysis/Liveness.cpp

@@ -27,7 +27,7 @@ struct BlockInfoBuilder {
   using ValueSetT = Liveness::ValueSetT;
 
   /// Constructs an empty block builder.
-  BlockInfoBuilder() : block(nullptr) {}
+  BlockInfoBuilder() {}
 
   /// Fills the block builder with initial liveness information.
   BlockInfoBuilder(Block *block) : block(block) {
@@ -104,7 +104,7 @@ struct BlockInfoBuilder {
   }
 
   /// The current block.
-  Block *block;
+  Block *block{nullptr};
 
   /// The set of all live in values.
   ValueSetT inValues;

mlir/lib/Analysis/LoopAnalysis.cpp

@@ -182,8 +182,7 @@ static bool isAccessIndexInvariant(Value iv, Value index) {
 
 DenseSet<Value> mlir::getInvariantAccesses(Value iv, ArrayRef<Value> indices) {
   DenseSet<Value> res;
-  for (unsigned idx = 0, n = indices.size(); idx < n; ++idx) {
-    auto val = indices[idx];
+  for (auto val : indices) {
     if (isAccessIndexInvariant(iv, val)) {
       res.insert(val);
     }

mlir/lib/Analysis/Utils.cpp

@@ -817,15 +817,15 @@ mlir::computeSliceUnion(ArrayRef<Operation *> opsA, ArrayRef<Operation *> opsB,
   FlatAffineValueConstraints sliceUnionCst;
   assert(sliceUnionCst.getNumDimAndSymbolIds() == 0);
   std::vector<std::pair<Operation *, Operation *>> dependentOpPairs;
-  for (unsigned i = 0, numOpsA = opsA.size(); i < numOpsA; ++i) {
-    MemRefAccess srcAccess(opsA[i]);
-    for (unsigned j = 0, numOpsB = opsB.size(); j < numOpsB; ++j) {
-      MemRefAccess dstAccess(opsB[j]);
+  for (auto i : opsA) {
+    MemRefAccess srcAccess(i);
+    for (auto j : opsB) {
+      MemRefAccess dstAccess(j);
       if (srcAccess.memref != dstAccess.memref)
         continue;
       // Check if 'loopDepth' exceeds nesting depth of src/dst ops.
-      if ((!isBackwardSlice && loopDepth > getNestingDepth(opsA[i])) ||
-          (isBackwardSlice && loopDepth > getNestingDepth(opsB[j]))) {
+      if ((!isBackwardSlice && loopDepth > getNestingDepth(i)) ||
+          (isBackwardSlice && loopDepth > getNestingDepth(j))) {
         LLVM_DEBUG(llvm::dbgs() << "Invalid loop depth\n");
         return SliceComputationResult::GenericFailure;
       }
@@ -844,13 +844,12 @@ mlir::computeSliceUnion(ArrayRef<Operation *> opsA, ArrayRef<Operation *> opsB,
       }
       if (result.value == DependenceResult::NoDependence)
         continue;
-      dependentOpPairs.push_back({opsA[i], opsB[j]});
+      dependentOpPairs.emplace_back(i, j);
 
       // Compute slice bounds for 'srcAccess' and 'dstAccess'.
       ComputationSliceState tmpSliceState;
-      mlir::getComputationSliceState(opsA[i], opsB[j], &dependenceConstraints,
-                                     loopDepth, isBackwardSlice,
-                                     &tmpSliceState);
+      mlir::getComputationSliceState(i, j, &dependenceConstraints, loopDepth,
+                                     isBackwardSlice, &tmpSliceState);
 
       if (sliceUnionCst.getNumDimAndSymbolIds() == 0) {
         // Initialize 'sliceUnionCst' with the bounds computed in previous step.

mlir/lib/Bindings/Python/IRAffine.cpp

@@ -676,7 +676,7 @@ void mlir::python::populateIRAffine(py::module &m) {
                     std::vector<PyAffineMap> res;
                     res.reserve(compressed.size());
                     for (auto m : compressed)
-                      res.push_back(PyAffineMap(context->getRef(), m));
+                      res.emplace_back(context->getRef(), m);
                     return res;
                   })
       .def_property_readonly(

mlir/lib/Bindings/Python/IRAttributes.cpp

@@ -524,7 +524,8 @@ class PyDenseElementsAttribute
           mlirIntegerTypeIsSigned(elementType)) {
         // i32
         return bufferInfo<int32_t>(shapedType);
-      } else if (mlirIntegerTypeIsUnsigned(elementType)) {
+      }
+      if (mlirIntegerTypeIsUnsigned(elementType)) {
         // unsigned i32
         return bufferInfo<uint32_t>(shapedType);
       }
@@ -534,7 +535,8 @@ class PyDenseElementsAttribute
           mlirIntegerTypeIsSigned(elementType)) {
         // i64
         return bufferInfo<int64_t>(shapedType);
-      } else if (mlirIntegerTypeIsUnsigned(elementType)) {
+      }
+      if (mlirIntegerTypeIsUnsigned(elementType)) {
         // unsigned i64
         return bufferInfo<uint64_t>(shapedType);
       }
@@ -544,7 +546,8 @@ class PyDenseElementsAttribute
           mlirIntegerTypeIsSigned(elementType)) {
         // i8
         return bufferInfo<int8_t>(shapedType);
-      } else if (mlirIntegerTypeIsUnsigned(elementType)) {
+      }
+      if (mlirIntegerTypeIsUnsigned(elementType)) {
         // unsigned i8
         return bufferInfo<uint8_t>(shapedType);
       }
@@ -554,7 +557,8 @@ class PyDenseElementsAttribute
           mlirIntegerTypeIsSigned(elementType)) {
         // i16
         return bufferInfo<int16_t>(shapedType);
-      } else if (mlirIntegerTypeIsUnsigned(elementType)) {
+      }
+      if (mlirIntegerTypeIsUnsigned(elementType)) {
         // unsigned i16
         return bufferInfo<uint16_t>(shapedType);
       }

mlir/lib/Bindings/Python/IRInterfaces.cpp

@@ -175,8 +175,7 @@ class PyInferTypeOpInterface
     auto *data = static_cast<AppendResultsCallbackData *>(userData);
     data->inferredTypes.reserve(data->inferredTypes.size() + nTypes);
     for (intptr_t i = 0; i < nTypes; ++i) {
-      data->inferredTypes.push_back(
-          PyType(data->pyMlirContext.getRef(), types[i]));
+      data->inferredTypes.emplace_back(data->pyMlirContext.getRef(), types[i]);
     }
   }
 

mlir/lib/Bindings/Python/IRModule.cpp

@@ -29,7 +29,7 @@ PyGlobals::PyGlobals() {
   instance = this;
   // The default search path include {mlir.}dialects, where {mlir.} is the
   // package prefix configured at compile time.
-  dialectSearchPrefixes.push_back(MAKE_MLIR_PYTHON_QUALNAME("dialects"));
+  dialectSearchPrefixes.emplace_back(MAKE_MLIR_PYTHON_QUALNAME("dialects"));
 }
 
 PyGlobals::~PyGlobals() { instance = nullptr; }

mlir/lib/CAPI/IR/Diagnostics.cpp

@@ -57,7 +57,7 @@ MlirDiagnosticHandlerID mlirContextAttachDiagnosticHandler(
     MlirContext context, MlirDiagnosticHandler handler, void *userData,
     void (*deleteUserData)(void *)) {
   assert(handler && "unexpected null diagnostic handler");
-  if (deleteUserData == NULL)
+  if (deleteUserData == nullptr)
     deleteUserData = deleteUserDataNoop;
   std::shared_ptr<void> sharedUserData(userData, deleteUserData);
   DiagnosticEngine::HandlerID id =

mlir/lib/Conversion/PDLToPDLInterp/Predicate.cpp

@@ -15,7 +15,7 @@ using namespace mlir::pdl_to_pdl_interp;
 // Positions
 //===----------------------------------------------------------------------===//
 
-Position::~Position() {}
+Position::~Position() = default;
 
 /// Returns the depth of the first ancestor operation position.
 unsigned Position::getOperationDepth() const {