[llvm][ADT] Allow returning `std::nullopt` in TypeSwitch

[zero9178]

Summary

Returning std::nullopt from the case of a TypeSwitch yields broken results, by either falling through to another case, or falling of the switch entirely and hitting an assertion. This is simply due to the use of operator= of what is now std::optional, which has an overload specifically for std::nullopt, causing the internal optional, used for the TypeSwitch result to be reset, instead of a value being constructed from the std::nullopt.

The fix is to simply use the emplace method of std::optional, causing a value to always be constructed from the value returned by the case function.

llvm/include/llvm/ADT/TypeSwitch.h

public:
   /// Add a case on the given type.
   template <typename CaseT, typename CallableT>
   TypeSwitch<T, ResultT> &Case(CallableT &&caseFn) {
     if (result)
       return *this;
 
     // Check to see if CaseT applies to 'value'.
     if (auto caseValue = BaseT::template castValue<CaseT>(this->value))
-      result = caseFn(caseValue);
+      result.emplace(caseFn(caseValue));
     return *this;
   }
 
   /// As a default, invoke the given callable within the root value.
   template <typename CallableT>
   [[nodiscard]] ResultT Default(CallableT &&defaultFn) {
     if (result)
       return std::move(*result);

llvm/unittests/ADT/TypeSwitchTest.cpp

auto translate = [](auto value) {
     return result;
   };
   EXPECT_EQ(0, translate(DerivedA()));
   EXPECT_EQ(0, translate(DerivedB()));
   EXPECT_EQ(1, translate(DerivedC()));
   EXPECT_EQ(0, translate(DerivedD()));
   EXPECT_EQ(-1, translate(DerivedE()));
 }
+
+TEST(TypeSwitchTest, CaseOptional) {
+  auto translate = [](auto value) {
+    return TypeSwitch<Base *, std::optional<int>>(&value)
+        .Case([](DerivedA *) { return 0; })
+        .Case([](DerivedC *) { return std::nullopt; })
+        .Default([](Base *) { return -1; });
+  };
+  EXPECT_EQ(0, translate(DerivedA()));
+  EXPECT_EQ(std::nullopt, translate(DerivedC()));
+  EXPECT_EQ(-1, translate(DerivedD()));
+  EXPECT_EQ(std::nullopt,
+            (TypeSwitch<Base *, std::optional<int>>(nullptr).Default(
+                [](Base *) { return std::nullopt; })));
+}
+
+TEST(TypeSwitchTest, CasesOptional) {
+  auto translate = [](auto value) {
+    return TypeSwitch<Base *, std::optional<int>>(&value)
+        .Case<DerivedB, DerivedC>([](auto *) { return std::nullopt; })
+        .Case([](DerivedA *) { return 0; })
+        .Default([](Base *) { return -1; });
+  };
+  EXPECT_EQ(0, translate(DerivedA()));
+  EXPECT_EQ(std::nullopt, translate(DerivedB()));
+  EXPECT_EQ(std::nullopt, translate(DerivedC()));
+  EXPECT_EQ(-1, translate(DerivedD()));
+}