[MLIR] Fix warnings in AffineOps.cpp

[bondhugula]

Summary

Fix warnings in AffineOps.cpp.

mlir/lib/Dialect/Affine/IR/AffineOps.cpp

 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Transforms/InliningUtils.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallBitVector.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/Debug.h"
 
 using namespace mlir;
-using llvm::dbgs;
 
 #define DEBUG_TYPE "affine-analysis"
 
 /// A utility function to check if a value is defined at the top level of
 /// `region` or is an argument of `region`. A value of index type defined at the
 /// top level of a `AffineScope` region is always a valid symbol for all
 /// uses in that region.
 static bool isTopLevelValue(Value value, Region *region) {
p.printOptionalAttrDict(op->getAttrs(),
                           /*elidedAttrs=*/{T::getMapAttrName()});
 }
 
 template <typename T>
 static ParseResult parseAffineMinMaxOp(OpAsmParser &parser,
                                        OperationState &result) {
   auto &builder = parser.getBuilder();
   auto indexType = builder.getIndexType();
-  SmallVector<OpAsmParser::OperandType, 8> dim_infos;
-  SmallVector<OpAsmParser::OperandType, 8> sym_infos;
+  SmallVector<OpAsmParser::OperandType, 8> dimInfos;
+  SmallVector<OpAsmParser::OperandType, 8> symInfos;
   AffineMapAttr mapAttr;
   return failure(
       parser.parseAttribute(mapAttr, T::getMapAttrName(), result.attributes) ||
-      parser.parseOperandList(dim_infos, OpAsmParser::Delimiter::Paren) ||
-      parser.parseOperandList(sym_infos,
+      parser.parseOperandList(dimInfos, OpAsmParser::Delimiter::Paren) ||
+      parser.parseOperandList(symInfos,
                               OpAsmParser::Delimiter::OptionalSquare) ||
       parser.parseOptionalAttrDict(result.attributes) ||
-      parser.resolveOperands(dim_infos, indexType, result.operands) ||
-      parser.resolveOperands(sym_infos, indexType, result.operands) ||
+      parser.resolveOperands(dimInfos, indexType, result.operands) ||
+      parser.resolveOperands(symInfos, indexType, result.operands) ||
       parser.addTypeToList(indexType, result.types));
 }
 
 /// Fold an affine min or max operation with the given operands. The operand
 /// list may contain nulls, which are interpreted as the operand not being a
 /// constant.
 template <typename T>
 static OpFoldResult foldMinMaxOp(T op, ArrayRef<Attribute> operands) {
assert(llvm::all_of(lbMaps,
          "and symbols");
   assert(llvm::all_of(ubMaps,
                       [ubMaps](AffineMap m) {
                         return m.getNumDims() == ubMaps[0].getNumDims() &&
                                m.getNumSymbols() == ubMaps[0].getNumSymbols();
                       }) &&
          "expected all upper bounds maps to have the same number of dimensions "
          "and symbols");
-  assert(lbMaps.empty() ||
-         lbMaps[0].getNumInputs() == lbArgs.size() &&
-             "expected lower bound maps to have as many inputs as lower bound "
-             "operands");
-  assert(ubMaps.empty() ||
-         ubMaps[0].getNumInputs() == ubArgs.size() &&
-             "expected upper bound maps to have as many inputs as upper bound "
-             "operands");
+  assert((lbMaps.empty() || lbMaps[0].getNumInputs() == lbArgs.size()) &&
+  assert((ubMaps.empty() || ubMaps[0].getNumInputs() == ubArgs.size()) &&
 
   result.addTypes(resultTypes);
 
   // Convert the reductions to integer attributes.
   SmallVector<Attribute, 4> reductionAttrs;
   for (AtomicRMWKind reduction : reductions)
     reductionAttrs.push_back(
         builder.getI64IntegerAttr(static_cast<int64_t>(reduction)));