Index: include/llvm/ADT/StringSwitch.h
===================================================================
--- include/llvm/ADT/StringSwitch.h
+++ include/llvm/ADT/StringSwitch.h
@@ -14,6 +14,7 @@
 #define LLVM_ADT_STRINGSWITCH_H
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/Support/Compiler.h"
 #include <cassert>
 #include <cstring>
@@ -44,14 +45,13 @@
   /// \brief The string we are matching.
   StringRef Str;
 
-  /// \brief The pointer to the result of this switch statement, once known,
-  /// null before that.
-  const T *Result;
+  /// \brief The result of this switch statement.
+  Optional<T> Result;
 
 public:
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   explicit StringSwitch(StringRef S)
-  : Str(S), Result(nullptr) { }
+  : Str(S), Result() { }
 
   // StringSwitch is not copyable.
   StringSwitch(const StringSwitch &) = delete;
@@ -71,56 +71,54 @@
   // Case-sensitive case matchers
   template<unsigned N>
   LLVM_ATTRIBUTE_ALWAYS_INLINE
-  StringSwitch& Case(const char (&S)[N], const T& Value) {
+  StringSwitch& Case(const char (&S)[N], T Value) {
     assert(N);
     if (!Result && N-1 == Str.size() &&
         (N == 1 || std::memcmp(S, Str.data(), N-1) == 0)) {
-      Result = &Value;
+      Result = std::move(Value);
     }
     return *this;
   }
 
   template<unsigned N>
   LLVM_ATTRIBUTE_ALWAYS_INLINE
-  StringSwitch& EndsWith(const char (&S)[N], const T &Value) {
+  StringSwitch& EndsWith(const char (&S)[N], T Value) {
     assert(N);
     if (!Result && Str.size() >= N-1 &&
         (N == 1 || std::memcmp(S, Str.data() + Str.size() + 1 - N, N-1) == 0)) {
-      Result = &Value;
+      Result = std::move(Value);
     }
     return *this;
   }
 
   template<unsigned N>
   LLVM_ATTRIBUTE_ALWAYS_INLINE
-  StringSwitch& StartsWith(const char (&S)[N], const T &Value) {
+  StringSwitch& StartsWith(const char (&S)[N], T Value) {
     assert(N);
     if (!Result && Str.size() >= N-1 &&
         (N == 1 || std::memcmp(S, Str.data(), N-1) == 0)) {
-      Result = &Value;
+      Result = std::move(Value);
     }
     return *this;
   }
 
   template<unsigned N0, unsigned N1>
   LLVM_ATTRIBUTE_ALWAYS_INLINE
-  StringSwitch &Cases(const char (&S0)[N0], const char (&S1)[N1],
-                      const T& Value) {
+  StringSwitch &Cases(const char (&S0)[N0], const char (&S1)[N1], T Value) {
     return Case(S0, Value).Case(S1, Value);
   }
 
   template<unsigned N0, unsigned N1, unsigned N2>
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   StringSwitch &Cases(const char (&S0)[N0], const char (&S1)[N1],
-                      const char (&S2)[N2], const T& Value) {
+                      const char (&S2)[N2], T Value) {
     return Case(S0, Value).Cases(S1, S2, Value);
   }
 
   template<unsigned N0, unsigned N1, unsigned N2, unsigned N3>
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   StringSwitch &Cases(const char (&S0)[N0], const char (&S1)[N1],
-                      const char (&S2)[N2], const char (&S3)[N3],
-                      const T& Value) {
+                      const char (&S2)[N2], const char (&S3)[N3], T Value) {
     return Case(S0, Value).Cases(S1, S2, S3, Value);
   }
 
@@ -128,7 +126,7 @@
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   StringSwitch &Cases(const char (&S0)[N0], const char (&S1)[N1],
                       const char (&S2)[N2], const char (&S3)[N3],
-                      const char (&S4)[N4], const T& Value) {
+                      const char (&S4)[N4], T Value) {
     return Case(S0, Value).Cases(S1, S2, S3, S4, Value);
   }
 
@@ -137,8 +135,7 @@
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   StringSwitch &Cases(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) {
+                      const char (&S4)[N4], const char (&S5)[N5], T Value) {
     return Case(S0, Value).Cases(S1, S2, S3, S4, S5, Value);
   }
 
@@ -148,7 +145,7 @@
   StringSwitch &Cases(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) {
+                      const char (&S6)[N6], T Value) {
     return Case(S0, Value).Cases(S1, S2, S3, S4, S5, S6, Value);
   }
 
@@ -158,8 +155,7 @@
   StringSwitch &Cases(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) {
+                      const char (&S6)[N6], const char (&S7)[N7], T Value) {
     return Case(S0, Value).Cases(S1, S2, S3, S4, S5, S6, S7, Value);
   }
 
@@ -170,7 +166,7 @@
                       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) {
+                      const char (&S8)[N8], T Value) {
     return Case(S0, Value).Cases(S1, S2, S3, S4, S5, S6, S7, S8, Value);
   }
 
@@ -181,67 +177,66 @@
                       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) {
+                      const char (&S8)[N8], const char (&S9)[N9], T Value) {
     return Case(S0, Value).Cases(S1, S2, S3, S4, S5, S6, S7, S8, S9, Value);
   }
 
   // Case-insensitive case matchers.
   template <unsigned N>
   LLVM_ATTRIBUTE_ALWAYS_INLINE StringSwitch &CaseLower(const char (&S)[N],
-                                                       const T &Value) {
+                                                       T Value) {
     if (!Result && Str.equals_lower(StringRef(S, N - 1)))
-      Result = &Value;
+      Result = std::move(Value);
 
     return *this;
   }
 
   template <unsigned N>
   LLVM_ATTRIBUTE_ALWAYS_INLINE StringSwitch &EndsWithLower(const char (&S)[N],
-                                                           const T &Value) {
+                                                           T Value) {
     if (!Result && Str.endswith_lower(StringRef(S, N - 1)))
-      Result = &Value;
+      Result = std::move(Value);
 
     return *this;
   }
 
   template <unsigned N>
   LLVM_ATTRIBUTE_ALWAYS_INLINE StringSwitch &StartsWithLower(const char (&S)[N],
-                                                             const T &Value) {
+                                                             T Value) {
     if (!Result && Str.startswith_lower(StringRef(S, N - 1)))
-      Result = &Value;
+      Result = std::move(Value);
 
     return *this;
   }
   template <unsigned N0, unsigned N1>
   LLVM_ATTRIBUTE_ALWAYS_INLINE StringSwitch &
-  CasesLower(const char (&S0)[N0], const char (&S1)[N1], const T &Value) {
+  CasesLower(const char (&S0)[N0], const char (&S1)[N1], T Value) {
     return CaseLower(S0, Value).CaseLower(S1, Value);
   }
 
   template <unsigned N0, unsigned N1, unsigned N2>
   LLVM_ATTRIBUTE_ALWAYS_INLINE StringSwitch &
   CasesLower(const char (&S0)[N0], const char (&S1)[N1], const char (&S2)[N2],
-             const T &Value) {
+             T Value) {
     return CaseLower(S0, Value).CasesLower(S1, S2, Value);
   }
 
   template <unsigned N0, unsigned N1, unsigned N2, unsigned N3>
   LLVM_ATTRIBUTE_ALWAYS_INLINE StringSwitch &
   CasesLower(const char (&S0)[N0], const char (&S1)[N1], const char (&S2)[N2],
-             const char (&S3)[N3], const T &Value) {
+             const char (&S3)[N3], T Value) {
     return CaseLower(S0, Value).CasesLower(S1, S2, S3, Value);
   }
 
   template <unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4>
   LLVM_ATTRIBUTE_ALWAYS_INLINE StringSwitch &
   CasesLower(const char (&S0)[N0], const char (&S1)[N1], const char (&S2)[N2],
-             const char (&S3)[N3], const char (&S4)[N4], const T &Value) {
+             const char (&S3)[N3], const char (&S4)[N4], T Value) {
     return CaseLower(S0, Value).CasesLower(S1, S2, S3, S4, Value);
   }
 
   LLVM_ATTRIBUTE_ALWAYS_INLINE
-  R Default(const T &Value) const {
+  R Default(T Value) const {
     if (Result)
       return *Result;
     return Value;