[lldb] Refactor ObjCLanguage::MethodName

The goal of this patch is to make it easier to reason about the state of
ObjCLanguage::MethodName. I do that in several ways:
- Instead of using the constructor directly, you go through a factory
  method. It returns a std::optional<MethodName> so either you got an
  ObjCLanguage::MethodName or you didn't. No more checking if it's valid
  to know if you can use it or not.
- ObjCLanguage::MethodName is now immutable. You cannot change its
  internals once it is created.
- ObjCLanguage::MethodName::GetFullNameWithoutCategory previously had a
  parameter that let you get back an empty string if the method had no
  category. Every caller of this method was enabling this behavior so I
  dropped the parameter and made it the default behavior.
- No longer store all the various components of the method name as
  ConstStrings. The relevant `Get` methods now return llvm::StringRefs
  backed by the MethodName's internal storage. The lifetime of these
  StringRefs are tied to the MethodName itself, so if you need to
  persist these you need to create copies.

Differential Revision: https://reviews.llvm.org/D149914

1 files changed, 36 insertions, 36 deletions

diff --git a/lldb/unittests/Language/ObjC/ObjCLanguageTest.cpp b/lldb/unittests/Language/ObjC/ObjCLanguageTest.cpp
index 683b16d..59cc51b 100644
--- a/lldb/unittests/Language/ObjC/ObjCLanguageTest.cpp
+++ b/lldb/unittests/Language/ObjC/ObjCLanguageTest.cpp
@@ -42,53 +42,51 @@ TEST(ObjCLanguage, MethodNameParsing) {
 
   // First, be strict
   for (const auto &test : strict_cases) {
-    ObjCLanguage::MethodName method(test.input, /*strict = */ true);
-    EXPECT_TRUE(method.IsValid(/*strict = */ true));
-    EXPECT_EQ(
-        test.full_name_sans_category,
-        method.GetFullNameWithoutCategory(/*empty_if_no_category = */ true)
-            .GetStringRef());
-    EXPECT_EQ(test.class_name, method.GetClassName().GetStringRef());
+    std::optional<const ObjCLanguage::MethodName> method =
+        ObjCLanguage::MethodName::Create(test.input, /*strict = */ true);
+    EXPECT_TRUE(method.has_value());
+    EXPECT_EQ(test.full_name_sans_category,
+              method->GetFullNameWithoutCategory());
+    EXPECT_EQ(test.class_name, method->GetClassName());
     EXPECT_EQ(test.class_name_with_category,
-              method.GetClassNameWithCategory().GetStringRef());
-    EXPECT_EQ(test.category, method.GetCategory().GetStringRef());
-    EXPECT_EQ(test.selector, method.GetSelector().GetStringRef());
+              method->GetClassNameWithCategory());
+    EXPECT_EQ(test.category, method->GetCategory());
+    EXPECT_EQ(test.selector, method->GetSelector());
   }
 
   // We should make sure strict parsing does not accept lax cases
   for (const auto &test : lax_cases) {
-    ObjCLanguage::MethodName method(test.input, /*strict = */ true);
-    EXPECT_FALSE(method.IsValid(/*strict = */ true));
+    std::optional<const ObjCLanguage::MethodName> method =
+        ObjCLanguage::MethodName::Create(test.input, /*strict = */ true);
+    EXPECT_FALSE(method.has_value());
   }
 
   // All strict cases should work when not lax
   for (const auto &test : strict_cases) {
-    ObjCLanguage::MethodName method(test.input, /*strict = */ false);
-    EXPECT_TRUE(method.IsValid(/*strict = */ false));
-    EXPECT_EQ(
-        test.full_name_sans_category,
-        method.GetFullNameWithoutCategory(/*empty_if_no_category = */ true)
-            .GetStringRef());
-    EXPECT_EQ(test.class_name, method.GetClassName().GetStringRef());
+    std::optional<const ObjCLanguage::MethodName> method =
+        ObjCLanguage::MethodName::Create(test.input, /*strict = */ false);
+    EXPECT_TRUE(method.has_value());
+    EXPECT_EQ(test.full_name_sans_category,
+              method->GetFullNameWithoutCategory());
+    EXPECT_EQ(test.class_name, method->GetClassName());
     EXPECT_EQ(test.class_name_with_category,
-              method.GetClassNameWithCategory().GetStringRef());
-    EXPECT_EQ(test.category, method.GetCategory().GetStringRef());
-    EXPECT_EQ(test.selector, method.GetSelector().GetStringRef());
+              method->GetClassNameWithCategory());
+    EXPECT_EQ(test.category, method->GetCategory());
+    EXPECT_EQ(test.selector, method->GetSelector());
   }
 
   // Make sure non-strict parsing works
   for (const auto &test : lax_cases) {
-    ObjCLanguage::MethodName method(test.input, /*strict = */ false);
-    EXPECT_TRUE(method.IsValid(/*strict = */ false));
-    EXPECT_EQ(
-        test.full_name_sans_category,
-        method.GetFullNameWithoutCategory(/*empty_if_no_category = */ true)
-            .GetStringRef());
-    EXPECT_EQ(test.class_name, method.GetClassName().GetStringRef());
+    std::optional<const ObjCLanguage::MethodName> method =
+        ObjCLanguage::MethodName::Create(test.input, /*strict = */ false);
+    EXPECT_TRUE(method.has_value());
+    EXPECT_EQ(test.full_name_sans_category,
+              method->GetFullNameWithoutCategory());
+    EXPECT_EQ(test.class_name, method->GetClassName());
     EXPECT_EQ(test.class_name_with_category,
-              method.GetClassNameWithCategory().GetStringRef());
-    EXPECT_EQ(test.category, method.GetCategory().GetStringRef());
-    EXPECT_EQ(test.selector, method.GetSelector().GetStringRef());
+              method->GetClassNameWithCategory());
+    EXPECT_EQ(test.category, method->GetCategory());
+    EXPECT_EQ(test.selector, method->GetSelector());
   }
 }
 
@@ -105,10 +103,12 @@ TEST(ObjCLanguage, InvalidMethodNameParsing) {
                                   "[]"};
 
   for (const auto &name : test_cases) {
-    ObjCLanguage::MethodName strict_method(name, /*strict = */ true);
-    EXPECT_FALSE(strict_method.IsValid(true));
+    std::optional<const ObjCLanguage::MethodName> strict_method =
+        ObjCLanguage::MethodName::Create(name, /*strict = */ false);
+    EXPECT_FALSE(strict_method.has_value());
 
-    ObjCLanguage::MethodName lax_method(name, /*strict = */ false);
-    EXPECT_FALSE(lax_method.IsValid(true));
+    std::optional<const ObjCLanguage::MethodName> lax_method =
+        ObjCLanguage::MethodName::Create(name, /*strict = */ false);
+    EXPECT_FALSE(lax_method.has_value());
   }
 }