[NFC] Use isa<> instead of dyn_cast.

[jurahul]

Summary

• As subject.

mlir/lib/Dialect/Async/Transforms/AsyncToAsyncRuntime.cpp

if (isAllowedToBlock(func))
       return;
     // N.B. To refactor this code into a separate pass the lookup in
     // outlinedFunctions is the most obvious obstacle. Looking at an arbitrary
     // func and recognizing if it has a coroutine structure is messy. Passing
     // this dict between the passes is ugly.
     if (isAllowedToBlock(func) ||
         outlinedFunctions.find(func) == outlinedFunctions.end()) {
       for (Operation &op : func.getBody().getOps()) {
-        if (dyn_cast<AwaitOp>(op) || dyn_cast<AwaitAllOp>(op)) {
+        if (isa<AwaitOp, AwaitAllOp>(op)) {
           funcWorklist.push_back(func);
           break;
         }
       }
     }
   };
 
   // Traverse in post-order collecting for each func op the await ops it has.

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

 }
 
 bool mlir::isLegalForReturnOpTypeConversionPattern(Operation *op,
                                                    TypeConverter &converter,
                                                    bool returnOpAlwaysLegal) {
   // 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)
+  if (isa<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.
   return op->hasTrait<OpTrait::ReturnLike>();
 }
 
 bool mlir::isNotBranchOpInterfaceOrReturnLikeOp(Operation *op) {

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

void compute(FunctionOpInterface func,
 
         // 2.3 - The current item is the result of a FromElementsOp, it will be
         // trivially detensored later as part of canonicalization patterns
         // applied at the end of detensoring.
         //
         // Note: No need to check whether the result type of this op is
         // detensorable since if it wasn't we wouldn't reach that point in the
         // work list.
-        if (dyn_cast<tensor::FromElementsOp>(currentItemDefiningOp))
+        if (isa<tensor::FromElementsOp>(currentItemDefiningOp))
           continue;
 
         // 2.4 - The current item is the result of a scalar op, add all its
         // operands to the work list.
         if (llvm::all_of(
                 currentItemDefiningOp->getResultTypes(),
                 [&](Type resultType) { return resultType.isIntOrFloat(); }))
           llvm::append_range(workList, currentItemDefiningOp->getOperands());