[mlir] Fix some style comments from D89268

[silvas]

Summary

That change was a pure move, so split out the stylistic changes into
this patch.

[rriddle]

Thanks!

[silvas]

remove more braces

mlir/lib/Transforms/Bufferize.cpp

 // BufferizeTypeConverter
 //===----------------------------------------------------------------------===//
 
 /// Registers conversions into BufferizeTypeConverter
 BufferizeTypeConverter::BufferizeTypeConverter() {
   // Keep all types unchanged.
   addConversion([](Type type) { return type; });
   // Convert RankedTensorType to MemRefType.
-  addConversion([](RankedTensorType type) {
-    return (Type)MemRefType::get(type.getShape(), type.getElementType());
+  addConversion([](RankedTensorType type) -> Type {
+    return MemRefType::get(type.getShape(), type.getElementType());
   });
   // Convert UnrankedTensorType to UnrankedMemRefType.
-  addConversion([](UnrankedTensorType type) {
-    return (Type)UnrankedMemRefType::get(type.getElementType(), 0);
+  addConversion([](UnrankedTensorType type) -> Type {
+    return UnrankedMemRefType::get(type.getElementType(), 0);
   });
 }
 
 /// This method tries to decompose a value of a certain type using provided
 /// decompose callback functions. If it is unable to do so, the original value
 /// is returned.
 void BufferizeTypeConverter::tryDecomposeValue(
     OpBuilder &builder, Location loc, Type type, Value value,
     SmallVectorImpl<Value> &results) {
-  for (auto conversion : decomposeValueConversions)
-    if (conversion(builder, loc, type, value, results) != llvm::None)
+  for (auto &conversion : decomposeValueConversions)
+    if (conversion(builder, loc, type, value, results))
       return;
   results.push_back(value);
 }
 
 /// This method tries to decompose a type using provided decompose callback
 /// functions. If it is unable to do so, the original type is returned.
 void BufferizeTypeConverter::tryDecomposeType(Type type,
                                               SmallVectorImpl<Type> &types) {
-  for (auto conversion : decomposeTypeConversions)
-    if (conversion(type, types) != llvm::None)
+  for (auto &conversion : decomposeTypeConversions)
+    if (conversion(type, types))
       return;
   types.push_back(type);
 }
 
 /// This method returns ResultConversionKind for the input type.
 BufferizeTypeConverter::ResultConversionKind
 BufferizeTypeConverter::getResultConversionKind(Type origin, Type converted) {
-  for (auto conversion : resultTypeConversions) {
-    auto res = conversion(origin, converted);
-    if (res != llvm::None)
+  for (auto &conversion : resultTypeConversions) {
+    if (auto res = conversion(origin, converted))
       return res.getValue();
   }
   return KeepAsFunctionResult;
 }
 
 //===----------------------------------------------------------------------===//
 // BufferizeFuncOpConverter
 //===----------------------------------------------------------------------===//
LogicalResult BufferizeFuncOpConverter::matchAndRewrite(
   SmallVector<Type, 2> newResultTypes;
   newResultTypes.reserve(funcOp.getNumResults());
   for (Type resultType : funcType.getResults()) {
     SmallVector<Type, 2> originTypes;
     converter.tryDecomposeType(resultType, originTypes);
     for (auto origin : originTypes) {
       Type converted = converter.convertType(origin);
       auto kind = converter.getResultConversionKind(origin, converted);
-      if (kind == BufferizeTypeConverter::AppendToArgumentsList)
+      if (kind == BufferizeTypeConverter::AppendToArgumentsList) {
         conversion.addInputs(converted);
-      else
-        // kind = BufferizeTypeConverter::KeepAsFunctionResult
+      } else {
+        assert(kind == BufferizeTypeConverter::KeepAsFunctionResult);
         newResultTypes.push_back(converted);
       }
     }
+  }
 
   if (failed(rewriter.convertRegionTypes(&funcOp.getBody(), converter,
                                          &conversion)))
     return failure();
 
   // Update the signature of the function.
   rewriter.updateRootInPlace(funcOp, [&] {
     funcOp.setType(rewriter.getFunctionType(conversion.getConvertedTypes(),
public:
   /// This method returns the mapping values list. The unknown result values
   /// that only their indicies are available are replaced with their values.
   void getMappingValues(ValueRange valuesToReplaceIndices,
                         SmallVectorImpl<Value> &values) {
     // Append available values to the list.
     SmallVector<std::pair<unsigned, Value>, 2> res(toValuesMapping.begin(),
                                                    toValuesMapping.end());
     // Replace the indices with the actual values.
-    llvm::for_each(
-        toIndicesMapping, [&](const std::pair<unsigned, unsigned> &entry) {
-          assert(entry.second < valuesToReplaceIndices.size() &&
-                 "The value index is out of range.");
-          res.push_back({entry.first, valuesToReplaceIndices[entry.second]});
-        });
+    for (const std::pair<unsigned, unsigned> &entry : toIndicesMapping) {
+    }
     // Sort the values based on their adding orders.
     llvm::sort(res, [](const std::pair<unsigned, Value> &v1,
                        const std::pair<unsigned, Value> &v2) {
       return v1.first < v2.first;
     });
     // Fill the values.
-    llvm::for_each(res, [&](const std::pair<unsigned, Value> &entry) {
+    for (const std::pair<unsigned, Value> &entry : res)
       values.push_back(entry.second);
-    });
   }
 
 private:
   /// Keeping the inserting order of mapping values.
   int order;
 
   /// Containing the mapping values with their inserting orders.
   SmallVector<std::pair<unsigned, Value>, 2> toValuesMapping;
LogicalResult BufferizeCallOpConverter::matchAndRewrite(
   // to an externally defined symbol like an external library calls), only
   // convert if some special attribute is set.
   // This will allow more control of interop across ABI boundaries.
 
   // Create the operands list of the new `CallOp`. It unpacks the decomposable
   // values if a decompose callback function has been provided by the user.
   for (auto operand : operands) {
     SmallVector<Value, 2> values;
-    this->converter.tryDecomposeValue(builder, loc, operand.getType(), operand,
-                                      values);
+    converter.tryDecomposeValue(builder, loc, operand.getType(), operand,
     newOperands.append(values.begin(), values.end());
   }
 
   // Create the new result types for the new `CallOp` and a mapping from the old
   // result to new value(s).
   SmallVector<Type, 2> newResultTypes;
   SmallVector<CallOpResultMapping, 4> mappings;
   mappings.resize(callOp.getNumResults());