[Support] Add StringSwitch::AsOptional

[lenary]

Summary

A StringSwitch does not always have a default value. In these cases, you
can currently achieve the same using the following, which is pretty
ugly:

std::optional<InnerT> Foo = llvm::StringSwitch<std::optional<InnerT>>(str)
  .Case("foo", std::optional(InnerT(...)))
  .Default(std::nullopt);

This commit allows you to achieve the same using the following, which I
think makes the intent a lot clearer (and avoids a nested optional
internally):

std::optional<InnerT> Foo = llvm::StringSwitch<InnerT>(str)
  .Case("foo", InnerT(...))
  .AsOptional();

[barannikov88]

llvm/include/llvm/ADT/StringSwitch.h

189–192

Would that work? Note that Result is std::optional<T> and std::optional has a converting move constructor.

[lenary]

llvm/include/llvm/ADT/StringSwitch.h

189–192

Maybe. I'm not super familiar with move semantics, but i can see how that should work based on the description at cppreference.com, and I like that it's simpler. I'll try it with the follow-on patch that uses it.

[tmatheson]

I'm not convinced this gives us much over using InnerT=optional directly; arguably it just obfuscates the type. There are no examples in the codebase for StringSwitch<std::optional>, but there are about 80 of StringSwitch<llvm::Optional>, and they typically look like this:

auto Level = llvm::StringSwitch<Optional<Driver::ReproLevel>>(A->getValue())
                 .Case("off", Driver::ReproLevel::Off)
                 .Case("crash", Driver::ReproLevel::OnCrash)
                 .Case("error", Driver::ReproLevel::OnError)
                 .Case("always", Driver::ReproLevel::Always)
                 .Default(None);

The std::optional equivalent can be written pretty much the same. In your before example, you don't need explicit std::optional constructor calls, you can use auto because they type is obvious from the RHS, and you can use the default constructor for std::optional (debatable whether that is preferable to std::nullopt):

auto Foo = llvm::StringSwitch<std::optional<InnerT>>(str)
    .Case("foo", InnerT(...))
    .Default({});

[lenary]

Ah, ok, yeah that is simpler.

llvm/include/llvm/ADT/StringSwitch.h

public:
   }
 
   [[nodiscard]] R Default(T Value) {
     if (Result)
       return std::move(*Result);
     return Value;
   }
 
+  [[nodiscard]] std::optional<R> AsOptional() {
+    if (Result)
+      return std::optional(std::move(*Result));
+
+    return std::nullopt;
+  }
+
   [[nodiscard]] operator R() {
     assert(Result && "Fell off the end of a string-switch");
     return std::move(*Result);
   }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_ADT_STRINGSWITCH_H

llvm/unittests/ADT/StringSwitchTest.cpp

TEST(StringSwitchTest, CasesLower) {
   EXPECT_EQ(OSType::Linux, Translate("POSIX"));
 
   EXPECT_EQ(OSType::Windows, Translate(llvm::StringRef("wind\0ws", 7)));
   EXPECT_EQ(OSType::Linux, Translate("linux"));
 
   EXPECT_EQ(OSType::Unknown, Translate("wind"));
   EXPECT_EQ(OSType::Unknown, Translate(""));
 }
+
+TEST(StringSwitchTest, AsOptional) {
+  enum class Color { Red };
+
+  auto Translate = [](StringRef S) {
+    return llvm::StringSwitch<Color>(S)
+      .Case("red", Color::Red)
+      .AsOptional();
+  };
+
+  EXPECT_TRUE(Translate("red").has_value());
+  EXPECT_EQ(Color::Red, Translate("red").value());
+
+  EXPECT_EQ(std::nullopt, Translate("blue"));
+}