diff --git a/llvm/lib/IR/Verifier.cpp b/llvm/lib/IR/Verifier.cpp
--- a/llvm/lib/IR/Verifier.cpp
+++ b/llvm/lib/IR/Verifier.cpp
@@ -764,8 +764,7 @@
               Init);
         for (Value *Op : InitArray->operands()) {
           Value *V = Op->stripPointerCasts();
-          Check(isa<GlobalVariable>(V) || isa<Function>(V) ||
-                    isa<GlobalAlias>(V),
+          Check((isa<GlobalVariable, Function, GlobalAlias>(V)),
                 Twine("invalid ") + GV.getName() + " member", V);
           Check(V->hasName(),
                 Twine("members of ") + GV.getName() + " must be named", V);
@@ -853,7 +852,7 @@
   Check(GA.getType() == Aliasee->getType(),
         "Alias and aliasee types should match!", &GA);
 
-  Check(isa<GlobalValue>(Aliasee) || isa<ConstantExpr>(Aliasee),
+  Check((isa<GlobalValue, ConstantExpr>(Aliasee)),
         "Aliasee should be either GlobalValue or ConstantExpr", &GA);
 
   visitAliaseeSubExpr(GA, *Aliasee);
@@ -1015,27 +1014,25 @@
   CheckDI(!N.getRawCountNode() || !N.getRawUpperBound(),
           "Subrange can have any one of count or upperBound", &N);
   auto *CBound = N.getRawCountNode();
-  CheckDI(!CBound || isa<ConstantAsMetadata>(CBound) ||
-              isa<DIVariable>(CBound) || isa<DIExpression>(CBound),
-          "Count must be signed constant or DIVariable or DIExpression", &N);
+  CheckDI(
+      (!CBound || isa<ConstantAsMetadata, DIVariable, DIExpression>(CBound)),
+      "Count must be signed constant or DIVariable or DIExpression", &N);
   auto Count = N.getCount();
   CheckDI(!Count || !Count.is<ConstantInt *>() ||
               Count.get<ConstantInt *>()->getSExtValue() >= -1,
           "invalid subrange count", &N);
   auto *LBound = N.getRawLowerBound();
-  CheckDI(!LBound || isa<ConstantAsMetadata>(LBound) ||
-              isa<DIVariable>(LBound) || isa<DIExpression>(LBound),
-          "LowerBound must be signed constant or DIVariable or DIExpression",
-          &N);
+  CheckDI(
+      (!LBound || isa<ConstantAsMetadata, DIVariable, DIExpression>(LBound)),
+      "LowerBound must be signed constant or DIVariable or DIExpression", &N);
   auto *UBound = N.getRawUpperBound();
-  CheckDI(!UBound || isa<ConstantAsMetadata>(UBound) ||
-              isa<DIVariable>(UBound) || isa<DIExpression>(UBound),
-          "UpperBound must be signed constant or DIVariable or DIExpression",
-          &N);
+  CheckDI(
+      (!UBound || isa<ConstantAsMetadata, DIVariable, DIExpression>(UBound)),
+      "UpperBound must be signed constant or DIVariable or DIExpression", &N);
   auto *Stride = N.getRawStride();
-  CheckDI(!Stride || isa<ConstantAsMetadata>(Stride) ||
-              isa<DIVariable>(Stride) || isa<DIExpression>(Stride),
-          "Stride must be signed constant or DIVariable or DIExpression", &N);
+  CheckDI(
+      (!Stride || isa<ConstantAsMetadata, DIVariable, DIExpression>(Stride)),
+      "Stride must be signed constant or DIVariable or DIExpression", &N);
 }
 
 void Verifier::visitDIGenericSubrange(const DIGenericSubrange &N) {
@@ -1045,21 +1042,19 @@
   CheckDI(!N.getRawCountNode() || !N.getRawUpperBound(),
           "GenericSubrange can have any one of count or upperBound", &N);
   auto *CBound = N.getRawCountNode();
-  CheckDI(!CBound || isa<DIVariable>(CBound) || isa<DIExpression>(CBound),
-          "Count must be signed constant or DIVariable or DIExpression", &N);
+  CheckDI((!CBound || isa<DIVariable, DIExpression>(CBound)),
+          "Count must be DIVariable or DIExpression", &N);
   auto *LBound = N.getRawLowerBound();
   CheckDI(LBound, "GenericSubrange must contain lowerBound", &N);
-  CheckDI(isa<DIVariable>(LBound) || isa<DIExpression>(LBound),
-          "LowerBound must be signed constant or DIVariable or DIExpression",
-          &N);
+  CheckDI((isa<DIVariable, DIExpression>(LBound)),
+          "LowerBound must be DIVariable or DIExpression", &N);
   auto *UBound = N.getRawUpperBound();
-  CheckDI(!UBound || isa<DIVariable>(UBound) || isa<DIExpression>(UBound),
-          "UpperBound must be signed constant or DIVariable or DIExpression",
-          &N);
+  CheckDI((!UBound || isa<DIVariable, DIExpression>(UBound)),
+          "UpperBound must be DIVariable or DIExpression", &N);
   auto *Stride = N.getRawStride();
   CheckDI(Stride, "GenericSubrange must contain stride", &N);
-  CheckDI(isa<DIVariable>(Stride) || isa<DIExpression>(Stride),
-          "Stride must be signed constant or DIVariable or DIExpression", &N);
+  CheckDI((isa<DIVariable, DIExpression>(Stride)),
+          "Stride must be DIVariable or DIExpression", &N);
 }
 
 void Verifier::visitDIEnumerator(const DIEnumerator &N) {
@@ -1325,7 +1320,7 @@
     auto *Node = dyn_cast<MDTuple>(RawNode);
     CheckDI(Node, "invalid retained nodes list", &N, RawNode);
     for (Metadata *Op : Node->operands()) {
-      CheckDI(Op && (isa<DILocalVariable>(Op) || isa<DILabel>(Op)),
+      CheckDI(Op && (isa<DILocalVariable, DILabel>(Op)),
               "invalid retained nodes, expected DILocalVariable or DILabel", &N,
               Node, Op);
     }
@@ -2380,23 +2375,18 @@
 
   // Check that the only uses of this gc.statepoint are gc.result or
   // gc.relocate calls which are tied to this statepoint and thus part
-  // of the same statepoint sequence
+  // of the same statepoint sequence.
   for (const User *U : Call.users()) {
     const CallInst *UserCall = dyn_cast<const CallInst>(U);
     Check(UserCall, "illegal use of statepoint token", Call, U);
-    if (!UserCall)
-      continue;
-    Check(isa<GCRelocateInst>(UserCall) || isa<GCResultInst>(UserCall),
-          "gc.result or gc.relocate are the only value uses "
+    Check((isa<GCRelocateInst, GCResultInst>(UserCall)),
+          "gc.result or gc.relocate are the only valid uses "
           "of a gc.statepoint",
           Call, U);
-    if (isa<GCResultInst>(UserCall)) {
-      Check(UserCall->getArgOperand(0) == &Call,
-            "gc.result connected to wrong gc.statepoint", Call, UserCall);
-    } else if (isa<GCRelocateInst>(Call)) {
-      Check(UserCall->getArgOperand(0) == &Call,
-            "gc.relocate connected to wrong gc.statepoint", Call, UserCall);
-    }
+    Check(UserCall->getArgOperand(0) == &Call,
+          Twine(isa<GCRelocateInst>(UserCall) ? "gc.relocate" : "gc.result",
+                StringRef(" result connected to wrong gc.statepoint")),
+          Call, UserCall);
   }
 
   // Note: It is legal for a single derived pointer to be listed multiple
@@ -3303,7 +3293,7 @@
 
     if (Call.paramHasAttr(i, Attribute::ImmArg)) {
       Value *ArgVal = Call.getArgOperand(i);
-      Check(isa<ConstantInt>(ArgVal) || isa<ConstantFP>(ArgVal),
+      Check((isa<ConstantInt, ConstantFP>(ArgVal)),
             "immarg operand has non-immediate parameter", ArgVal, Call);
     }
 
@@ -3949,8 +3939,7 @@
   // Check that swifterror value is only used by loads, stores, or as
   // a swifterror argument.
   for (const User *U : SwiftErrorVal->users()) {
-    Check(isa<LoadInst>(U) || isa<StoreInst>(U) || isa<CallInst>(U) ||
-              isa<InvokeInst>(U),
+    Check((isa<LoadInst, StoreInst, CallInst, InvokeInst>(U)),
           "swifterror value can only be loaded and stored from, or "
           "as a swifterror argument!",
           SwiftErrorVal, U);
@@ -4131,7 +4120,7 @@
 
       // This will be diagnosed on the corresponding instruction already. We
       // need the extra check here to make sure getParentPad() works.
-      Check(isa<FuncletPadInst>(FromPad) || isa<CatchSwitchInst>(FromPad),
+      Check((isa<FuncletPadInst, CatchSwitchInst>(FromPad)),
             "Parent pad must be catchpad/cleanuppad/catchswitch", TI);
     }
   }
@@ -4169,7 +4158,7 @@
             "Catch operand does not have pointer type!", &LPI);
     } else {
       Check(LPI.isFilter(i), "Clause is neither catch nor filter!", &LPI);
-      Check(isa<ConstantArray>(Clause) || isa<ConstantAggregateZero>(Clause),
+      Check((isa<ConstantArray, ConstantAggregateZero>(Clause)),
             "Filter operand is not an array of constants!", &LPI);
     }
   }
@@ -4233,7 +4222,7 @@
         "CleanupPadInst not the first non-PHI instruction in the block.", &CPI);
 
   auto *ParentPad = CPI.getParentPad();
-  Check(isa<ConstantTokenNone>(ParentPad) || isa<FuncletPadInst>(ParentPad),
+  Check((isa<ConstantTokenNone, FuncletPadInst>(ParentPad)),
         "CleanupPadInst has an invalid parent.", &CPI);
 
   visitEHPadPredecessors(CPI);
@@ -4415,7 +4404,7 @@
         &CatchSwitch);
 
   auto *ParentPad = CatchSwitch.getParentPad();
-  Check(isa<ConstantTokenNone>(ParentPad) || isa<FuncletPadInst>(ParentPad),
+  Check((isa<ConstantTokenNone, FuncletPadInst>(ParentPad)),
         "CatchSwitchInst has an invalid parent.", ParentPad);
 
   if (BasicBlock *UnwindDest = CatchSwitch.getUnwindDest()) {
@@ -4487,7 +4476,7 @@
         "dereferenceable, dereferenceable_or_null "
         "apply only to pointer types",
         &I);
-  Check((isa<LoadInst>(I) || isa<IntToPtrInst>(I)),
+  Check((isa<LoadInst, IntToPtrInst>(I)),
         "dereferenceable, dereferenceable_or_null apply only to load"
         " and inttoptr instructions, use attributes for calls or invokes",
         &I);
@@ -4679,7 +4668,7 @@
 
   // Check that the instruction doesn't produce metadata. Calls are already
   // checked against the callee type.
-  Check(!I.getType()->isMetadataTy() || isa<CallInst>(I) || isa<InvokeInst>(I),
+  Check((!I.getType()->isMetadataTy() || isa<CallInst, InvokeInst>(I)),
         "Invalid use of metadata!", &I);
 
   // Check that all uses of the instruction, if they are instructions
@@ -4786,13 +4775,13 @@
   }
 
   if (MDNode *Range = I.getMetadata(LLVMContext::MD_range)) {
-    Check(isa<LoadInst>(I) || isa<CallInst>(I) || isa<InvokeInst>(I),
+    Check((isa<LoadInst, CallInst, InvokeInst>(I)),
           "Ranges are only for loads, calls and invokes!", &I);
     visitRangeMetadata(I, Range, I.getType());
   }
 
   if (I.hasMetadata(LLVMContext::MD_invariant_group)) {
-    Check(isa<LoadInst>(I) || isa<StoreInst>(I),
+    Check((isa<LoadInst, StoreInst>(I)),
           "invariant.group metadata is only for loads and stores", &I);
   }
 
@@ -4980,7 +4969,7 @@
           "info argument of llvm.coro.id must refer to an initialized "
           "constant");
     Constant *Init = GV->getInitializer();
-    Check(isa<ConstantStruct>(Init) || isa<ConstantArray>(Init),
+    Check((isa<ConstantStruct, ConstantArray>(Init)),
           "info argument of llvm.coro.id must refer to either a struct or "
           "an array");
     break;
@@ -5278,7 +5267,7 @@
       // This covers relocates on a normal return path of invoke statepoint and
       // relocates of a call statepoint.
       auto *Token = Call.getArgOperand(0);
-      Check(isa<GCStatepointInst>(Token) || isa<UndefValue>(Token),
+      Check((isa<GCStatepointInst, UndefValue>(Token)),
             "gc relocate is incorrectly tied to the statepoint", Call, Token);
     }
 
@@ -5973,7 +5962,7 @@
 
 void Verifier::visitDbgIntrinsic(StringRef Kind, DbgVariableIntrinsic &DII) {
   auto *MD = DII.getRawLocation();
-  CheckDI(isa<ValueAsMetadata>(MD) || isa<DIArgList>(MD) ||
+  CheckDI((isa<ValueAsMetadata, DIArgList>(MD)) ||
               (isa<MDNode>(MD) && !cast<MDNode>(MD)->getNumOperands()),
           "invalid llvm.dbg." + Kind + " intrinsic address/value", &DII, MD);
   CheckDI(isa<DILocalVariable>(DII.getRawVariable()),
@@ -6582,9 +6571,8 @@
 }
 
 bool TBAAVerifier::visitTBAAMetadata(Instruction &I, const MDNode *MD) {
-  CheckTBAA(isa<LoadInst>(I) || isa<StoreInst>(I) || isa<CallInst>(I) ||
-                isa<VAArgInst>(I) || isa<AtomicRMWInst>(I) ||
-                isa<AtomicCmpXchgInst>(I),
+  CheckTBAA((isa<LoadInst, StoreInst, CallInst, VAArgInst, AtomicRMWInst,
+                 AtomicCmpXchgInst>(I)),
             "This instruction shall not have a TBAA access tag!", &I);
 
   bool IsStructPathTBAA =