Rename StringSwitch::Cases StringSwitch::Case.

[ruiu]

Summary

When you add a condition to a StringSwitch::Case, you also have
to change the function to call Cases instead of Case. Not a big deal
but it's always slightly annoying.

This patch renames Cases Case so that we have single overloaded
function

Cases(<one or more strings>, <result>)

instead of two functions

Case(<string>, <result>) and
Cases(<two or more strings>, <result>)

I'll delete Cases after updating LLVM subproject's source.

include/llvm/ADT/StringSwitch.h

 /// \code
 /// Color color = StringSwitch<Color>(argv[i])
 ///   .Case("red", Red)
 ///   .Case("orange", Orange)
 ///   .Case("yellow", Yellow)
 ///   .Case("green", Green)
 ///   .Case("blue", Blue)
 ///   .Case("indigo", Indigo)
-///   .Cases("violet", "purple", Violet)
+///   .Case("violet", "purple", Violet)
 ///   .Default(UnknownColor);
 /// \endcode
 template<typename T, typename R = T>
 class StringSwitch {
   /// \brief The string we are matching.
   StringRef Str;
 
   /// \brief The pointer to the result of this switch statement, once known,
public:
   StringSwitch& Case(const char (&S)[N], const T& Value) {
     if (!Result && N-1 == Str.size() &&
         (std::memcmp(S, Str.data(), N-1) == 0)) {
       Result = &Value;
     }
     return *this;
   }
 
+  template<unsigned N0, unsigned N1>
+  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  StringSwitch &Case(const char (&S0)[N0], const char (&S1)[N1],
+                     const T& Value) {
+    return Case(S0, Value).Case(S1, Value);
+  }
+
+  template<unsigned N0, unsigned N1, unsigned N2>
+  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  StringSwitch &Case(const char (&S0)[N0], const char (&S1)[N1],
+                     const char (&S2)[N2], const T& Value) {
+    return Case(S0, Value).Case(S1, S2, Value);
+  }
+
+  template<unsigned N0, unsigned N1, unsigned N2, unsigned N3>
+  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  StringSwitch &Case(const char (&S0)[N0], const char (&S1)[N1],
+                     const char (&S2)[N2], const char (&S3)[N3],
+                     const T& Value) {
+    return Case(S0, Value).Case(S1, S2, S3, Value);
+  }
+
+  template<unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4>
+  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  StringSwitch &Case(const char (&S0)[N0], const char (&S1)[N1],
+                     const char (&S2)[N2], const char (&S3)[N3],
+                     const char (&S4)[N4], const T& Value) {
+    return Case(S0, Value).Case(S1, S2, S3, S4, Value);
+  }
+
+  template <unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
+            unsigned N5>
+  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  StringSwitch &Case(const char (&S0)[N0], const char (&S1)[N1],
+                     const char (&S2)[N2], const char (&S3)[N3],
+                     const char (&S4)[N4], const char (&S5)[N5],
+                     const T &Value) {
+    return Case(S0, Value).Case(S1, S2, S3, S4, S5, Value);
+  }
+
+  template <unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
+            unsigned N5, unsigned N6>
+  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  StringSwitch &Case(const char (&S0)[N0], const char (&S1)[N1],
+                     const char (&S2)[N2], const char (&S3)[N3],
+                     const char (&S4)[N4], const char (&S5)[N5],
+                     const char (&S6)[N6], const T &Value) {
+    return Case(S0, Value).Case(S1, S2, S3, S4, S5, S6, Value);
+  }
+
+  template <unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
+            unsigned N5, unsigned N6, unsigned N7>
+  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  StringSwitch &Case(const char (&S0)[N0], const char (&S1)[N1],
+                     const char (&S2)[N2], const char (&S3)[N3],
+                     const char (&S4)[N4], const char (&S5)[N5],
+                     const char (&S6)[N6], const char (&S7)[N7],
+                     const T &Value) {
+    return Case(S0, Value).Case(S1, S2, S3, S4, S5, S6, S7, Value);
+  }
+
+  template <unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
+            unsigned N5, unsigned N6, unsigned N7, unsigned N8>
+  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  StringSwitch &Case(const char (&S0)[N0], const char (&S1)[N1],
+                     const char (&S2)[N2], const char (&S3)[N3],
+                     const char (&S4)[N4], const char (&S5)[N5],
+                     const char (&S6)[N6], const char (&S7)[N7],
+                     const char (&S8)[N8], const T &Value) {
+    return Case(S0, Value).Case(S1, S2, S3, S4, S5, S6, S7, S8, Value);
+  }
+
+  template <unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
+            unsigned N5, unsigned N6, unsigned N7, unsigned N8, unsigned N9>
+  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  StringSwitch &Case(const char (&S0)[N0], const char (&S1)[N1],
+                     const char (&S2)[N2], const char (&S3)[N3],
+                     const char (&S4)[N4], const char (&S5)[N5],
+                     const char (&S6)[N6], const char (&S7)[N7],
+                     const char (&S8)[N8], const char (&S9)[N9],
+                     const T &Value) {
+    return Case(S0, Value).Case(S1, S2, S3, S4, S5, S6, S7, S8, S9, Value);
+  }
+
   template<unsigned N>
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   StringSwitch& EndsWith(const char (&S)[N], const T &Value) {
     if (!Result && Str.size() >= N-1 &&
         std::memcmp(S, Str.data() + Str.size() + 1 - N, N-1) == 0) {
       Result = &Value;
     }
     return *this;

lib/MC/MCParser/ELFAsmParser.cpp

if (PreviousSection.first == nullptr)
       return TokError(".previous without corresponding .section");
   getStreamer().SwitchSection(PreviousSection.first, PreviousSection.second);
 
   return false;
 }
 
 static MCSymbolAttr MCAttrForString(StringRef Type) {
   return StringSwitch<MCSymbolAttr>(Type)
-          .Cases("STT_FUNC", "function", MCSA_ELF_TypeFunction)
-          .Cases("STT_OBJECT", "object", MCSA_ELF_TypeObject)
-          .Cases("STT_TLS", "tls_object", MCSA_ELF_TypeTLS)
-          .Cases("STT_COMMON", "common", MCSA_ELF_TypeCommon)
-          .Cases("STT_NOTYPE", "notype", MCSA_ELF_TypeNoType)
-          .Cases("STT_GNU_IFUNC", "gnu_indirect_function",
+          .Case("STT_FUNC", "function", MCSA_ELF_TypeFunction)
+          .Case("STT_OBJECT", "object", MCSA_ELF_TypeObject)
+          .Case("STT_TLS", "tls_object", MCSA_ELF_TypeTLS)
+          .Case("STT_COMMON", "common", MCSA_ELF_TypeCommon)
+          .Case("STT_NOTYPE", "notype", MCSA_ELF_TypeNoType)
+          .Case("STT_GNU_IFUNC", "gnu_indirect_function",
                  MCSA_ELF_TypeIndFunction)
           .Case("gnu_unique_object", MCSA_ELF_TypeGnuUniqueObject)
           .Default(MCSA_Invalid);
 }
 
 /// ParseDirectiveELFType
 ///  ::= .type identifier , STT_<TYPE_IN_UPPER_CASE>
 ///  ::= .type identifier , #attribute

lib/Support/TargetParser.cpp

 static StringRef getHWDivSynonym(StringRef HWDiv) {
   return StringSwitch<StringRef>(HWDiv)
       .Case("thumb,arm", "arm,thumb")
       .Default(HWDiv);
 }
 
 static StringRef getFPUSynonym(StringRef FPU) {
   return StringSwitch<StringRef>(FPU)
-      .Cases("fpa", "fpe2", "fpe3", "maverick", "invalid") // Unsupported
+      .Case("fpa", "fpe2", "fpe3", "maverick", "invalid") // Unsupported
       .Case("vfp2", "vfpv2")
       .Case("vfp3", "vfpv3")
       .Case("vfp4", "vfpv4")
       .Case("vfp3-d16", "vfpv3-d16")
       .Case("vfp4-d16", "vfpv4-d16")
-      .Cases("fp4-sp-d16", "vfpv4-sp-d16", "fpv4-sp-d16")
-      .Cases("fp4-dp-d16", "fpv4-dp-d16", "vfpv4-d16")
+      .Case("fp4-sp-d16", "vfpv4-sp-d16", "fpv4-sp-d16")
+      .Case("fp4-dp-d16", "fpv4-dp-d16", "vfpv4-d16")
       .Case("fp5-sp-d16", "fpv5-sp-d16")
-      .Cases("fp5-dp-d16", "fpv5-dp-d16", "fpv5-d16")
+      .Case("fp5-dp-d16", "fpv5-dp-d16", "fpv5-d16")
       // FIXME: Clang uses it, but it's bogus, since neon defaults to vfpv3.
       .Case("neon-vfpv3", "neon")
       .Default(FPU);
 }
 
 static StringRef getArchSynonym(StringRef Arch) {
   return StringSwitch<StringRef>(Arch)
       .Case("v5", "v5t")
       .Case("v5e", "v5te")
       .Case("v6j", "v6")
       .Case("v6hl", "v6k")
-      .Cases("v6m", "v6sm", "v6s-m", "v6-m")
-      .Cases("v6z", "v6zk", "v6kz")
-      .Cases("v7", "v7a", "v7hl", "v7l", "v7-a")
+      .Case("v6m", "v6sm", "v6s-m", "v6-m")
+      .Case("v6z", "v6zk", "v6kz")
+      .Case("v7", "v7a", "v7hl", "v7l", "v7-a")
       .Case("v7r", "v7-r")
       .Case("v7m", "v7-m")
       .Case("v7em", "v7e-m")
-      .Cases("v8", "v8a", "aarch64", "arm64", "v8-a")
+      .Case("v8", "v8a", "aarch64", "arm64", "v8-a")
       .Case("v8.1a", "v8.1-a")
       .Case("v8.2a", "v8.2-a")
       .Case("v8m.base", "v8-m.base")
       .Case("v8m.main", "v8-m.main")
       .Default(Arch);
 }
 
 // MArch is expected to be of the form (arm|thumb)?(eb)?(v.+)?(eb)?, but

lib/Support/Triple.cpp

else
       return Triple::thumb;
   }
 
   return arch;
 }
 
 static Triple::ArchType parseArch(StringRef ArchName) {
   auto AT = StringSwitch<Triple::ArchType>(ArchName)
-    .Cases("i386", "i486", "i586", "i686", Triple::x86)
+    .Case("i386", "i486", "i586", "i686", Triple::x86)
     // FIXME: Do we need to support these?
-    .Cases("i786", "i886", "i986", Triple::x86)
-    .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64)
-    .Cases("powerpc", "ppc32", Triple::ppc)
-    .Cases("powerpc64", "ppu", "ppc64", Triple::ppc64)
-    .Cases("powerpc64le", "ppc64le", Triple::ppc64le)
+    .Case("i786", "i886", "i986", Triple::x86)
+    .Case("amd64", "x86_64", "x86_64h", Triple::x86_64)
+    .Case("powerpc", "ppc32", Triple::ppc)
+    .Case("powerpc64", "ppu", "ppc64", Triple::ppc64)
+    .Case("powerpc64le", "ppc64le", Triple::ppc64le)
     .Case("xscale", Triple::arm)
     .Case("xscaleeb", Triple::armeb)
     .Case("aarch64", Triple::aarch64)
     .Case("aarch64_be", Triple::aarch64_be)
     .Case("arm64", Triple::aarch64)
     .Case("arm", Triple::arm)
     .Case("armeb", Triple::armeb)
     .Case("thumb", Triple::thumb)
     .Case("thumbeb", Triple::thumbeb)
     .Case("avr", Triple::avr)
     .Case("msp430", Triple::msp430)
-    .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
-    .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
-    .Cases("mips64", "mips64eb", Triple::mips64)
+    .Case("mips", "mipseb", "mipsallegrex", Triple::mips)
+    .Case("mipsel", "mipsallegrexel", Triple::mipsel)
+    .Case("mips64", "mips64eb", Triple::mips64)
     .Case("mips64el", Triple::mips64el)
     .Case("r600", Triple::r600)
     .Case("amdgcn", Triple::amdgcn)
     .Case("hexagon", Triple::hexagon)
-    .Cases("s390x", "systemz", Triple::systemz)
+    .Case("s390x", "systemz", Triple::systemz)
     .Case("sparc", Triple::sparc)
     .Case("sparcel", Triple::sparcel)
-    .Cases("sparcv9", "sparc64", Triple::sparcv9)
+    .Case("sparcv9", "sparc64", Triple::sparcv9)
     .Case("tce", Triple::tce)
     .Case("xcore", Triple::xcore)
     .Case("nvptx", Triple::nvptx)
     .Case("nvptx64", Triple::nvptx64)
     .Case("le32", Triple::le32)
     .Case("le64", Triple::le64)
     .Case("amdil", Triple::amdil)
     .Case("amdil64", Triple::amdil64)

lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp

for (auto &Arg : F.args()) {
     auto AccQual = cast<MDString>(F.getMetadata(
         "kernel_arg_access_qual")->getOperand(I))->getString();
     RuntimeMD::KernelArg::Kind Kind;
     if (TypeQual.find("pipe") != StringRef::npos)
       Kind = RuntimeMD::KernelArg::Pipe;
     else Kind = StringSwitch<RuntimeMD::KernelArg::Kind>(BaseTypeName)
       .Case("sampler_t", RuntimeMD::KernelArg::Sampler)
       .Case("queue_t",   RuntimeMD::KernelArg::Queue)
-      .Cases("image1d_t", "image1d_array_t", "image1d_buffer_t",
+      .Case("image1d_t", "image1d_array_t", "image1d_buffer_t",
              "image2d_t" , "image2d_array_t",  RuntimeMD::KernelArg::Image)
-      .Cases("image2d_depth_t", "image2d_array_depth_t",
+      .Case("image2d_depth_t", "image2d_array_depth_t",
              "image2d_msaa_t", "image2d_array_msaa_t",
              "image2d_msaa_depth_t",  RuntimeMD::KernelArg::Image)
-      .Cases("image2d_array_msaa_depth_t", "image3d_t",
+      .Case("image2d_array_msaa_depth_t", "image3d_t",
              RuntimeMD::KernelArg::Image)
       .Default(isa<PointerType>(T) ?
                    (T->getPointerAddressSpace() == AMDGPUAS::LOCAL_ADDRESS ?
                    RuntimeMD::KernelArg::DynamicSharedPointer :
                    RuntimeMD::KernelArg::GlobalBuffer) :
                    RuntimeMD::KernelArg::ByValue);
     emitRuntimeMetadataForKernelArg(DL, *OutStreamer, T,
         Kind, BaseTypeName, TypeName, ArgName, TypeQual, AccQual);

lib/Target/X86/AsmParser/X86AsmParser.cpp

std::unique_ptr<X86Operand> X86AsmParser::ParseOperand() {
   if (isParsingIntelSyntax())
     return ParseIntelOperand();
   return ParseATTOperand();
 }
 
 /// getIntelMemOperandSize - Return intel memory operand size.
 static unsigned getIntelMemOperandSize(StringRef OpStr) {
   unsigned Size = StringSwitch<unsigned>(OpStr)
-    .Cases("BYTE", "byte", 8)
-    .Cases("WORD", "word", 16)
-    .Cases("DWORD", "dword", 32)
-    .Cases("FWORD", "fword", 48)
-    .Cases("QWORD", "qword", 64)
-    .Cases("MMWORD","mmword", 64)
-    .Cases("XWORD", "xword", 80)
-    .Cases("TBYTE", "tbyte", 80)
-    .Cases("XMMWORD", "xmmword", 128)
-    .Cases("YMMWORD", "ymmword", 256)
-    .Cases("ZMMWORD", "zmmword", 512)
-    .Cases("OPAQUE", "opaque", -1U) // needs to be non-zero, but doesn't matter
+    .Case("BYTE", "byte", 8)
+    .Case("WORD", "word", 16)
+    .Case("DWORD", "dword", 32)
+    .Case("FWORD", "fword", 48)
+    .Case("QWORD", "qword", 64)
+    .Case("MMWORD","mmword", 64)
+    .Case("XWORD", "xword", 80)
+    .Case("TBYTE", "tbyte", 80)
+    .Case("XMMWORD", "xmmword", 128)
+    .Case("YMMWORD", "ymmword", 256)
+    .Case("ZMMWORD", "zmmword", 512)
+    .Case("OPAQUE", "opaque", -1U) // needs to be non-zero, but doesn't matter
     .Default(0);
   return Size;
 }
 
 std::unique_ptr<X86Operand> X86AsmParser::CreateMemForInlineAsm(
     unsigned SegReg, const MCExpr *Disp, unsigned BaseReg, unsigned IndexReg,
     unsigned Scale, SMLoc Start, SMLoc End, unsigned Size, StringRef Identifier,
     InlineAsmIdentifierInfo &Info) {

tools/llvm-cov/llvm-cov.cpp

int main(int argc, const char **argv) {
   if (argc > 1) {
     typedef int (*MainFunction)(int, const char *[]);
     MainFunction Func = StringSwitch<MainFunction>(argv[1])
                             .Case("convert-for-testing", convertForTestingMain)
                             .Case("export", exportMain)
                             .Case("gcov", gcovMain)
                             .Case("report", reportMain)
                             .Case("show", showMain)
-                            .Cases("-h", "-help", "--help", helpMain)
-                            .Cases("-version", "--version", versionMain)
+                            .Case("-h", "-help", "--help", helpMain)
+                            .Case("-version", "--version", versionMain)
                             .Default(nullptr);
 
     if (Func) {
       std::string Invocation = std::string(argv[0]) + " " + argv[1];
       argv[1] = Invocation.c_str();
       return Func(argc - 1, argv + 1);
     }
   }

utils/TableGen/FastISelEmitter.cpp

for (CodeGenDAGPatterns::ptm_iterator I = CGP.ptm_begin(),
     }
 
     // Check if the operands match one of the patterns handled by FastISel.
     std::string ManglingSuffix;
     raw_string_ostream SuffixOS(ManglingSuffix);
     Operands.PrintManglingSuffix(SuffixOS, ImmediatePredicates, true);
     SuffixOS.flush();
     if (!StringSwitch<bool>(ManglingSuffix)
-        .Cases("", "r", "rr", "ri", "rf", true)
-        .Cases("rri", "i", "f", true)
+        .Case("", "r", "rr", "ri", "rf", true)
+        .Case("rri", "i", "f", true)
         .Default(false))
       continue;
 
     // Get the predicate that guards this pattern.
     std::string PredicateCheck = Pattern.getPredicateCheck();
 
     // Ok, we found a pattern that we can handle. Remember it.
     InstructionMemo Memo = {