[MLIR] Use `if constexpr` in `StorageUniquer` and `IR/AffineExpr`

[jloser]

Summary

Querying the type trait is something that can be done at compile time. So,
replace the runtime if with if constexpr.

[jloser]

Update title to reflect IR/AffineExpr changes as well

mlir/include/mlir/IR/AffineExpr.h

public:
   bool operator!=(AffineExpr other) const { return !(*this == other); }
   bool operator==(int64_t v) const;
   bool operator!=(int64_t v) const { return !(*this == v); }
   explicit operator bool() const { return expr; }
 
   bool operator!() const { return expr == nullptr; }
 
   template <typename U>
-  bool isa() const;
+  constexpr bool isa() const;
   template <typename U>
   U dyn_cast() const;
   template <typename U>
   U dyn_cast_or_null() const;
   template <typename U>
   U cast() const;
 
   MLIRContext *getContext() const;

 AffineExpr getAffineExprFromFlatForm(ArrayRef<int64_t> flatExprs,
                                      unsigned numDims, unsigned numSymbols,
                                      ArrayRef<AffineExpr> localExprs,
                                      MLIRContext *context);
 
 raw_ostream &operator<<(raw_ostream &os, AffineExpr expr);
 
 template <typename U>
-bool AffineExpr::isa() const {
-  if (std::is_same<U, AffineBinaryOpExpr>::value)
+constexpr bool AffineExpr::isa() const {
+  if constexpr (std::is_same_v<U, AffineBinaryOpExpr>)
     return getKind() <= AffineExprKind::LAST_AFFINE_BINARY_OP;
-  if (std::is_same<U, AffineDimExpr>::value)
+  if constexpr (std::is_same_v<U, AffineDimExpr>)
     return getKind() == AffineExprKind::DimId;
-  if (std::is_same<U, AffineSymbolExpr>::value)
+  if constexpr (std::is_same_v<U, AffineSymbolExpr>)
     return getKind() == AffineExprKind::SymbolId;
-  if (std::is_same<U, AffineConstantExpr>::value)
+  if constexpr (std::is_same_v<U, AffineConstantExpr>)
     return getKind() == AffineExprKind::Constant;
 }
 template <typename U>
 U AffineExpr::dyn_cast() const {
   if (isa<U>())
     return U(expr);
   return U(nullptr);
 }

mlir/include/mlir/Support/StorageUniquer.h

public:
 
   /// Register a new parametric storage class, this is necessary to create
   /// instances of this class type. `id` is the type identifier that will be
   /// used to identify this type when creating instances of it via 'get'.
   template <typename Storage>
   void registerParametricStorageType(TypeID id) {
     // If the storage is trivially destructible, we don't need a destructor
     // function.
-    if (std::is_trivially_destructible<Storage>::value)
+    if constexpr (std::is_trivially_destructible_v<Storage>)
       return registerParametricStorageTypeImpl(id, nullptr);
     registerParametricStorageTypeImpl(id, [](BaseStorage *storage) {
       static_cast<Storage *>(storage)->~Storage();
     });
   }
   /// Utility override when the storage type represents the type id.
   template <typename Storage>
   void registerParametricStorageType() {