[NFC][LLVM] Document and adopt variadic isa in a few places

- Add mention of variadic `isa<>` in the LLVM Programmers Manual.
- Adopt it in a new places, there are several more throughout the
  codebase.

Author: jurahul

llvm/docs/ProgrammersManual.rst

@@ -115,7 +115,9 @@ rarely have to include this file directly).
   The ``isa<>`` operator works exactly like the Java "``instanceof``" operator.
   It returns true or false depending on whether a reference or pointer points to
   an instance of the specified class.  This can be very useful for constraint
-  checking of various sorts (example below).
+  checking of various sorts (example below). It's a variadic operator, so you
+  can specify more than one class to check if the reference or pointer points
+  to an instance of one of the classes specified.
 
 ``cast<>``:
   The ``cast<>`` operator is a "checked cast" operation.  It converts a pointer
@@ -131,7 +133,11 @@ rarely have to include this file directly).
       if (isa<Constant>(V) || isa<Argument>(V) || isa<GlobalValue>(V))
         return true;
 
-      // Otherwise, it must be an instruction...
+      // Alternate, more compact form.
+      if (isa<Constant, Argument, GlobalValue>(V))
+        return true;
+
+      // Otherwise, it must be an instruction.
       return !L->contains(cast<Instruction>(V)->getParent());
     }
 
@@ -168,7 +174,8 @@ rarely have to include this file directly).
   The ``isa_and_present<>`` operator works just like the ``isa<>`` operator,
   except that it allows for a null pointer as an argument (which it then
   returns false).  This can sometimes be useful, allowing you to combine several
-  null checks into one.
+  null checks into one. Similar to ``isa<>`` operator, you can specify more than
+  one classes to check.
 
 ``cast_if_present<>``:
   The ``cast_if_present<>`` operator works just like the ``cast<>`` operator,

llvm/tools/llvm-diff/lib/DifferenceEngine.cpp

@@ -569,7 +569,7 @@ class FunctionDifferenceEngine {
 
     // Constants of the "same type" don't always actually have the same
     // type; I don't know why.  Just white-list them.
-    if (isa<ConstantPointerNull>(L) || isa<UndefValue>(L) || isa<ConstantAggregateZero>(L))
+    if (isa<ConstantPointerNull, UndefValue, ConstantAggregateZero>(L))
       return true;
 
     // Block addresses only match if we've already encountered the

llvm/tools/llvm-reduce/deltas/ReduceDIMetadata.cpp

@@ -63,7 +63,7 @@ void identifyUninterestingMDNodes(Oracle &O, MDNodeList &MDs) {
     for (size_t I = 0; I < Tup->getNumOperands(); ++I) {
       // Ignore any operands that are not DebugInfo metadata nodes.
       if (Metadata *Op = Tup->getOperand(I).get()) {
-        if (isa<DINode>(Op) || isa<DIGlobalVariableExpression>(Op))
+        if (isa<DINode, DIGlobalVariableExpression>(Op))
           // Don't add uninteresting operands to the tuple.
           if (!O.shouldKeep())
             continue;

llvm/tools/llvm-reduce/deltas/Utils.cpp

@@ -39,9 +39,8 @@ Value *llvm::getDefaultValue(Type *T) {
 }
 
 bool llvm::hasAliasUse(Function &F) {
-  return any_of(F.users(), [](User *U) {
-      return isa<GlobalAlias>(U) || isa<GlobalIFunc>(U);
-    });
+  return any_of(F.users(),
+                [](User *U) { return isa<GlobalAlias, GlobalIFunc>(U); });
 }
 
 bool llvm::hasAliasOrBlockAddressUse(Function &F) {

llvm/utils/TableGen/Common/CodeGenDAGPatterns.cpp

@@ -2915,7 +2915,7 @@ TreePatternNodePtr TreePattern::ParseTreePattern(const Init *TheInit,
     return Res;
   }
 
-  if (isa<IntInit>(TheInit) || isa<BitInit>(TheInit)) {
+  if (isa<IntInit, BitInit>(TheInit)) {
     if (!OpName.empty())
       error("Constant int or bit argument should not have a name!");
     if (isa<BitInit>(TheInit))

llvm/utils/TableGen/Common/GlobalISel/GlobalISelMatchTable.cpp

@@ -558,7 +558,7 @@ void GroupMatcher::optimize() {
 //===- SwitchMatcher ------------------------------------------------------===//
 
 bool SwitchMatcher::isSupportedPredicateType(const PredicateMatcher &P) {
-  return isa<InstructionOpcodeMatcher>(P) || isa<LLTOperandMatcher>(P);
+  return isa<InstructionOpcodeMatcher, LLTOperandMatcher>(P);
 }
 
 bool SwitchMatcher::candidateConditionMatches(

llvm/utils/TableGen/Common/VarLenCodeEmitterGen.cpp

@@ -463,7 +463,7 @@ std::string VarLenCodeEmitterGen::getInstructionCaseForEncoding(
     const Init *Val = ES.Value;
     // If it's a StringInit or DagInit, it's a reference to an operand
     // or part of an operand.
-    if (isa<StringInit>(Val) || isa<DagInit>(Val)) {
+    if (isa<StringInit, DagInit>(Val)) {
       StringRef OperandName;
       unsigned LoBit = 0U;
       if (const auto *SV = dyn_cast<StringInit>(Val)) {

llvm/utils/TableGen/SearchableTableEmitter.cpp

@@ -237,7 +237,7 @@ bool SearchableTableEmitter::compareBy(const Record *LHS, const Record *RHS,
     const Init *LHSI = LHS->getValueInit(Field.Name);
     const Init *RHSI = RHS->getValueInit(Field.Name);
 
-    if (isa<BitsRecTy>(Field.RecType) || isa<IntRecTy>(Field.RecType)) {
+    if (isa<BitsRecTy, IntRecTy>(Field.RecType)) {
       int64_t LHSi = getAsInt(LHSI);
       int64_t RHSi = getAsInt(RHSI);
       if (LHSi < RHSi)