Demo fix for readability-simplify-boolean-expr (WIP)

[mehdi_amini]

Full repo run

mlir/lib/Analysis/Utils.cpp

LogicalResult MemRefRegion::compute(Operation *op, unsigned loopDepth,
   getLoopIVs(*op, &enclosingIVs);
   assert(loopDepth <= enclosingIVs.size() && "invalid loop depth");
   enclosingIVs.resize(loopDepth);
   SmallVector<Value, 4> ids;
   cst.getValues(cst.getNumDimIds(), cst.getNumDimAndSymbolIds(), &ids);
   for (auto id : ids) {
     AffineForOp iv;
     if ((iv = getForInductionVarOwner(id)) &&
-        llvm::is_contained(enclosingIVs, iv) == false) {
+        !llvm::is_contained(enclosingIVs, iv)) {
       cst.projectOut(id);
     }
   }
 
   // Project out any local variables (these would have been added for any
   // mod/divs).
   cst.projectOut(cst.getNumDimAndSymbolIds(), cst.getNumLocalIds());
 

mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp

if (srcSize == dstSize) {
         }
       }
     }
     currDstDim++;
   }
 
   // If both iterators didn't reach the end, we have leftover dimentions which
   // implies that we have a mismatch in shape.
-  if (currSrcDim != srcShape.size() || currDstDim != dstShape.size()) {
-    return false;
-  }
-
-  return true;
+  return !(currSrcDim != srcShape.size() || currDstDim != dstShape.size());
 }
 
 namespace {
 
 template <typename SrcOp>
 class PointwiseConverter : public OpRewritePattern<SrcOp> {
 public:
   using OpRewritePattern<SrcOp>::OpRewritePattern;

mlir/lib/Conversion/VectorToGPU/VectorToGPU.cpp

static bool transferReadSupportsMMAMatrixType(vector::TransferReadOp readOp) {
   AffineMap map = readOp.permutation_map();
   OpBuilder b(readOp.getContext());
   AffineExpr innerDim = b.getAffineDimExpr(map.getNumDims() - 1);
   AffineExpr zero = b.getAffineConstantExpr(0);
   auto broadcastInnerDim = AffineMap::get(map.getNumDims(), 0, {zero, innerDim},
                                           readOp.getContext());
   // TODO: Support transpose once it is added to GPU dialect ops.
   // For now we only support (d0, d1) -> (d0, d1) and (d0, d1) -> (0, d1).
-  if (!map.isMinorIdentity() && map != broadcastInnerDim)
-    return false;
-  return true;
+  return !(!map.isMinorIdentity() && map != broadcastInnerDim);
 }
 
 // Return true if the transfer op can be converted to a MMA matrix store.
 static bool
 transferWriteSupportsMMAMatrixType(vector::TransferWriteOp writeOp) {
   // TODO: support 0-d corner case.
   if (writeOp.getTransferRank() == 0)
     return false;

mlir/lib/Dialect/Linalg/ComprehensiveBufferize/ComprehensiveBufferize.cpp

bool nonWritable =
       aliasesNonWritableBuffer(opOperand.get(), aliasInfo, state);
   if (!nonWritable)
     return false;
 
   // This is a problem only if the buffer is written to via some alias.
   bool hasWrite = aliasesInPlaceWrite(opResult, aliasInfo, state) ||
                   aliasesInPlaceWrite(opOperand.get(), aliasInfo, state) ||
                   state.bufferizesToMemoryWrite(opOperand);
-  if (!hasWrite)
-    return false;
-
-  return true;
+  return hasWrite;
 }
 
 //===----------------------------------------------------------------------===//
 // Bufferization analyses.
 //===----------------------------------------------------------------------===//
 
 /// Determine if `operand` can be bufferized in-place with `result`.
 static LogicalResult bufferizableInPlaceAnalysisImpl(

mlir/lib/Dialect/Linalg/ComprehensiveBufferize/LinalgInterfaceImpl.cpp

for (OpOperand &operand : op->getOpOperands()) {
             if (!opResult)
               return true;
             if (!aliasInfo.isInPlace(opResult))
               return true;
             // Only equivalent tensors are supported at the moment.
             // TODO: Support cases such as extract_slice(init_tensor).
             SmallVector<OpOperand *> opOperands =
                 state.getAliasingOpOperand(opResult);
-            if (!llvm::all_of(opOperands, [&](OpOperand *operand) {
-                  return aliasInfo.areEquivalentBufferizedValues(operand->get(),
-                                                                 opResult);
-                }))
-              return true;
-            return false;
+            return !llvm::all_of(opOperands, [&](OpOperand *operand) {
+            });
           });
 
       // Replace only if the reverse use-def chain ends at exactly one
       // InitTensorOp.
       if (maybeInitTensor.size() != 1 ||
           !maybeInitTensor.front().getDefiningOp<InitTensorOp>())
         return WalkResult::skip();
       Value initTensor = maybeInitTensor.front();

mlir/lib/Dialect/Linalg/Transforms/Detensorize.cpp

target.markUnknownOpDynamicallyLegal([&](Operation *op) {
       // A function is legal if all of its non-entry blocks are legal. We
       // don't legalize the entry block (i.e. the function's signature)
       // since detensoring can't happen along external calling convention
       // boundaries, which we conservatively approximate as all function
       // signatures.
       if (op->hasTrait<OpTrait::FunctionLike>()) {
         auto &body = function_like_impl::getFunctionBody(op);
         return llvm::all_of(llvm::drop_begin(body, 1), [&](Block &block) {
-          if (llvm::any_of(
-                  blockArgsToDetensor, [&](BlockArgument blockArgument) {
-                    return blockArgument.getOwner() == &block &&
-                           !typeConverter.isLegal(blockArgument.getType());
-                  })) {
-            return false;
-          }
-          return true;
+          return !llvm::any_of(
+              });
         });
       }
 
       if (isNotBranchOpInterfaceOrReturnLikeOp(op) ||
           isLegalForReturnOpTypeConversionPattern(op, typeConverter,
                                                   /*returnOpAlwaysLegal*/ true))
         return true;
 

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

if (aT && bT) {
 
     auto aEltType = (aT) ? aT.getElementType() : uaT.getElementType();
     auto bEltType = (bT) ? bT.getElementType() : ubT.getElementType();
     if (aEltType != bEltType)
       return false;
 
     auto aMemSpace = (aT) ? aT.getMemorySpace() : uaT.getMemorySpace();
     auto bMemSpace = (bT) ? bT.getMemorySpace() : ubT.getMemorySpace();
-    if (aMemSpace != bMemSpace)
-      return false;
-
-    return true;
+    return aMemSpace == bMemSpace;
   }
 
   return false;
 }
 
 OpFoldResult CastOp::fold(ArrayRef<Attribute> operands) {
   return succeeded(foldMemRefCast(*this)) ? getResult() : Value();
 }

mlir/lib/Dialect/StandardOps/Transforms/FuncConversions.cpp

bool mlir::isLegalForReturnOpTypeConversionPattern(Operation *op,
   // If this is a `return` and the user pass wants to convert/transform across
   // function boundaries, then `converter` is invoked to check whether the the
   // `return` op is legal.
   if (dyn_cast<ReturnOp>(op) && !returnOpAlwaysLegal)
     return converter.isLegal(op);
 
   // ReturnLike operations have to be legalized with their parent. For
   // return this is handled, for other ops they remain as is.
-  if (op->hasTrait<OpTrait::ReturnLike>())
-    return true;
-
-  return false;
+  return op->hasTrait<OpTrait::ReturnLike>();
 }
 
 bool mlir::isNotBranchOpInterfaceOrReturnLikeOp(Operation *op) {
   // If it is not a terminator, ignore it.
   if (!op->mightHaveTrait<OpTrait::IsTerminator>())
     return true;
 
   // If it is not the last operation in the block, also ignore it. We do

mlir/lib/Dialect/Vector/VectorUtils.cpp

assert((ratio.hasValue() || !mustDivide) &&
          "vector.transfer operation in which super-vector size is not an"
          " integer multiple of sub-vector size");
 
   // This catches cases that are not strictly necessary to have multiplicity but
   // still aren't divisible by the sub-vector shape.
   // This could be useful information if we wanted to reshape at the level of
   // the vector type (but we would have to look at the compute and distinguish
   // between parallel, reduction and possibly other cases.
-  if (!ratio.hasValue()) {
-    return false;
-  }
-
-  return true;
+  return ratio.hasValue();
 }
 
 bool mlir::isDisjointTransferIndices(VectorTransferOpInterface transferA,
                                      VectorTransferOpInterface transferB) {
   // For simplicity only look at transfer of same type.
   if (transferA.getVectorType() != transferB.getVectorType())
     return false;
   unsigned rankOffset = transferA.getLeadingShapedRank();

mlir/lib/Transforms/NormalizeMemRefs.cpp

for (FuncOp &funcOp : normalizableFuncs)
     normalizeFuncOpMemRefs(funcOp, moduleOp);
 }
 
 /// Check whether all the uses of oldMemRef are either dereferencing uses or the
 /// op is of type : DeallocOp, CallOp or ReturnOp. Only if these constraints
 /// are satisfied will the value become a candidate for replacement.
 /// TODO: Extend this for DimOps.
 static bool isMemRefNormalizable(Value::user_range opUsers) {
-  if (llvm::any_of(opUsers, [](Operation *op) {
-        if (op->hasTrait<OpTrait::MemRefsNormalizable>())
-          return false;
-        return true;
-      }))
-    return false;
-  return true;
+  return !llvm::any_of(opUsers, [](Operation *op) {
+  });
 }
 
 /// Set all the calling functions and the callees of the function as not
 /// normalizable.
 void NormalizeMemRefs::setCalleesAndCallersNonNormalizable(
     FuncOp funcOp, ModuleOp moduleOp, DenseSet<FuncOp> &normalizableFuncs) {
   if (!normalizableFuncs.contains(funcOp))
     return;

mlir/lib/Transforms/Utils/LoopFusionUtils.cpp

 }
 
 /// Returns true if 'op' is a load or store operation which access a memref
 /// accessed 'values' and at least one of the access is a store operation.
 /// Returns false otherwise.
 static bool isDependentLoadOrStoreOp(Operation *op,
                                      DenseMap<Value, bool> &values) {
   if (auto loadOp = dyn_cast<AffineReadOpInterface>(op)) {
-    return values.count(loadOp.getMemRef()) > 0 &&
-           values[loadOp.getMemRef()] == true;
+    return values.count(loadOp.getMemRef()) > 0 && values[loadOp.getMemRef()];
   }
   if (auto storeOp = dyn_cast<AffineWriteOpInterface>(op)) {
     return values.count(storeOp.getMemRef()) > 0;
   }
   return false;
 }
 
 // Returns the first operation in range ('opA', 'opB') which has a data

mlir/lib/Transforms/Utils/LoopUtils.cpp

 static bool areInnerBoundsInvariant(AffineForOp forOp) {
   auto walkResult = forOp.walk([&](AffineForOp aForOp) {
     for (auto controlOperand : aForOp.getControlOperands()) {
       if (!forOp.isDefinedOutsideOfLoop(controlOperand))
         return WalkResult::interrupt();
     }
     return WalkResult::advance();
   });
-  if (walkResult.wasInterrupted())
-    return false;
-  return true;
+  return !walkResult.wasInterrupted();
 }
 
 // Gathers all maximal sub-blocks of operations that do not themselves
 // include a for op (a operation could have a descendant for op though
 // in its tree).  Ignore the block terminators.
 struct JamBlockGatherer {
   // Store iterators to the first and last op of each sub-block found.
   std::vector<std::pair<Block::iterator, Block::iterator>> subBlocks;

mlir/test/lib/Dialect/Tosa/TosaTestPasses.cpp

if (outputElementType.isSigned() ||
     return failure();
 
   double typeRangeMin = double(outputElementType.getStorageTypeMin() -
                                outputElementType.getZeroPoint()) *
                         outputElementType.getScale();
   double typeRangeMax = double(outputElementType.getStorageTypeMax() -
                                outputElementType.getZeroPoint()) *
                         outputElementType.getScale();
-  bool narrowRange = outputElementType.getStorageTypeMin() == 1 ? true : false;
+  bool narrowRange = outputElementType.getStorageTypeMin() == 1;
 
   auto dstQConstType = RankedTensorType::get(
       outputType.getShape(),
       buildQTypeFromMinMax(rewriter, outputElementType.getExpressedType(),
                            rewriter.getF64FloatAttr(typeRangeMin),
                            rewriter.getF64FloatAttr(typeRangeMax),
                            rewriter.getI32IntegerAttr(
                                outputElementType.getStorageTypeIntegralWidth()),

mlir/test/lib/Dialect/Vector/TestVectorTransforms.cpp

void runOnFunction() override {
     FuncOp func = getFunction();
     func.walk([&](arith::AddFOp op) {
       // Check that the operation type can be broken down into a loop.
       VectorType type = op.getType().dyn_cast<VectorType>();
       if (!type || type.getRank() != 1 ||
           type.getNumElements() % multiplicity != 0)
         return mlir::WalkResult::advance();
       auto filterAlloc = [](Operation *op) {
-        if (isa<arith::ConstantOp, memref::AllocOp, CallOp>(op))
-          return false;
-        return true;
+        return !isa<arith::ConstantOp, memref::AllocOp, CallOp>(op);
       };
       auto dependentOps = getSlice(op, filterAlloc);
       // Create a loop and move instructions from the Op slice into the loop.
       OpBuilder builder(op);
       auto zero = builder.create<arith::ConstantIndexOp>(op.getLoc(), 0);
       auto one = builder.create<arith::ConstantIndexOp>(op.getLoc(), 1);
       auto numIter =
           builder.create<arith::ConstantIndexOp>(op.getLoc(), multiplicity);