[lldb][NFCI] Remove use of ConstString from StructuredDataDarwinLog static functions

[bulbazord]

Summary

The strings "DarwinLog" and "log" probably do not need to be in the
ConstString StringPool. We still create ConstStrings from them in some
places (for now) but that's because we don't have an implicit
constructor to convert a StringRef to a ConstString.

[JDevlieghere]

LGTM

lldb/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp

1495–1497

You could get rid of the .str().c_str() if you used LLDB_LOG

[bulbazord]

LLDB_LOGF -> LLDB_LOG to avoid a temporary string construction.

lldb/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp

const char *const s_filter_attributes[] = {
     "subsystem"       // subsystem of the log message
 
     // Consider implementing this action as it would be cheaper to filter.
     // "message" requires always formatting the message, which is a waste of
     // cycles if it ends up being rejected. "format",      // format string
     // used to format message text
 };
 
-static ConstString GetDarwinLogTypeName() {
-  static const ConstString s_key_name("DarwinLog");
+static llvm::StringRef GetDarwinLogTypeName() {
+  static constexpr llvm::StringLiteral s_key_name("DarwinLog");
   return s_key_name;
 }
 
-static ConstString GetLogEventType() {
-  static const ConstString s_event_type("log");
+static llvm::StringRef GetLogEventType() {
+  static constexpr llvm::StringLiteral s_event_type("log");
   return s_event_type;
 }
 
 class FilterRule;
 using FilterRuleSP = std::shared_ptr<FilterRule>;
 
 class FilterRule {
 public:
bool DoExecute(Args &command, CommandReturnObject &result) override {
     // If the process is no longer alive, we can't do this now. We'll catch it
     // the next time the process is started up.
     if (!process_sp->IsAlive()) {
       result.SetStatus(eReturnStatusSuccessFinishNoResult);
       return true;
     }
 
     // Get the plugin for the process.
-    auto plugin_sp =
-        process_sp->GetStructuredDataPlugin(GetDarwinLogTypeName());
+    auto plugin_sp = process_sp->GetStructuredDataPlugin(
+        ConstString(GetDarwinLogTypeName()));
     if (!plugin_sp || (plugin_sp->GetPluginName() !=
                        StructuredDataDarwinLog::GetStaticPluginName())) {
       result.AppendError("failed to get StructuredDataPlugin for "
                          "the process");
     }
     StructuredDataDarwinLog &plugin =
         *static_cast<StructuredDataDarwinLog *>(plugin_sp.get());
 
     if (m_enable) {
       // Hook up the breakpoint for the process that detects when libtrace has
       // been sufficiently initialized to really start the os_log stream.  This
       // is insurance to assure us that logging is really enabled.  Requesting
       // that logging be enabled for a process before libtrace is initialized
       // results in a scenario where no errors occur, but no logging is
       // captured, either.  This step is to eliminate that possibility.
       plugin.AddInitCompletionHook(*process_sp);
     }
 
     // Send configuration to the feature by way of the process. Construct the
     // options we will use.
     auto config_sp = m_options_sp->BuildConfigurationData(m_enable);
-    const Status error =
-        process_sp->ConfigureStructuredData(GetDarwinLogTypeName(), config_sp);
+    const Status error = process_sp->ConfigureStructuredData(
+        ConstString(GetDarwinLogTypeName()), config_sp);
 
     // Report results.
     if (!error.Success()) {
       result.AppendError(error.AsCString());
       // Our configuration failed, so we're definitely disabled.
       plugin.SetEnabled(false);
     } else {
       result.SetStatus(eReturnStatusSuccessFinishNoResult);
bool DoExecute(Args &command, CommandReturnObject &result) override {
     // available for that process.
     Target &target = GetSelectedOrDummyTarget();
     auto process_sp = target.GetProcessSP();
     if (!process_sp) {
       stream.PutCString("Availability: unknown (requires process)\n");
       stream.PutCString("Enabled: not applicable "
                         "(requires process)\n");
     } else {
-      auto plugin_sp =
-          process_sp->GetStructuredDataPlugin(GetDarwinLogTypeName());
+      auto plugin_sp = process_sp->GetStructuredDataPlugin(
+          ConstString(GetDarwinLogTypeName()));
       stream.Printf("Availability: %s\n",
                     plugin_sp ? "available" : "unavailable");
       llvm::StringRef plugin_name = StructuredDataDarwinLog::GetStaticPluginName();
       const bool enabled =
           plugin_sp ? plugin_sp->GetEnabled(ConstString(plugin_name)) : false;
       stream.Printf("Enabled: %s\n", enabled ? "true" : "false");
     }
 
if (!object_sp) {
     return;
   }
 
   // Ignore any data that isn't for us.
   if (type_name != GetDarwinLogTypeName()) {
     LLDB_LOGF(log,
               "StructuredDataDarwinLog::%s() StructuredData type "
               "expected to be %s but was %s, ignoring",
-              __FUNCTION__, GetDarwinLogTypeName().AsCString(),
+              __FUNCTION__, GetDarwinLogTypeName().str().c_str(),
               type_name.AsCString());
     return;
   }
 
   // Broadcast the structured data event if we have that enabled. This is the
   // way that the outside world (all clients) get access to this data.  This
   // plugin sets policy as to whether we do that.
   DebuggerSP debugger_sp = process.GetTarget().GetDebugger().shared_from_this();
Status StructuredDataDarwinLog::GetDescription(
   if (!dictionary) {
     SetErrorWithJSON(error, "Structured data should have been a dictionary "
                             "but wasn't",
                      *object_sp);
     return error;
   }
 
   // Validate this is really a message for our plugin.
-  ConstString type_name;
+  llvm::StringRef type_name;
   if (!dictionary->GetValueForKeyAsString("type", type_name)) {
     SetErrorWithJSON(error, "Structured data doesn't contain mandatory "
                             "type field",
                      *object_sp);
     return error;
   }
 
   if (type_name != GetDarwinLogTypeName()) {
LLDB_LOGF(log,
               "StructuredDataDarwinLog::%s() warning: invalid "
               "process in context, ignoring",
               __FUNCTION__);
     return false;
   }
   LLDB_LOGF(log, "StructuredDataDarwinLog::%s() call is for process uid %d",
             __FUNCTION__, process_sp->GetUniqueID());
 
-  auto plugin_sp = process_sp->GetStructuredDataPlugin(GetDarwinLogTypeName());
+  auto plugin_sp =
+      process_sp->GetStructuredDataPlugin(ConstString(GetDarwinLogTypeName()));
   if (!plugin_sp) {
-    LLDB_LOGF(log,
-              "StructuredDataDarwinLog::%s() warning: no plugin for "
-              "feature %s in process uid %u",
-              __FUNCTION__, GetDarwinLogTypeName().AsCString(),
-              process_sp->GetUniqueID());
+    LLDB_LOG(log, "warning: no plugin for feature {0} in process uid {1}",
+             GetDarwinLogTypeName(), process_sp->GetUniqueID());
     return false;
   }
 
   // Create the callback for when the thread plan completes.
   bool called_enable_method = false;
   const auto process_uid = process_sp->GetUniqueID();
 
   std::weak_ptr<StructuredDataPlugin> plugin_wp(plugin_sp);
StructuredDataDarwinLog::DumpHeader(Stream &output_stream,
   output_stream.PutCString(stream.GetString());
 
   return stream.GetSize();
 }
 
 size_t StructuredDataDarwinLog::HandleDisplayOfEvent(
     const StructuredData::Dictionary &event, Stream &stream) {
   // Check the type of the event.
-  ConstString event_type;
+  llvm::StringRef event_type;
   if (!event.GetValueForKeyAsString("type", event_type)) {
     // Hmm, we expected to get events that describe what they are.  Continue
     // anyway.
     return 0;
   }
 
   if (event_type != GetLogEventType())
     return 0;
LLDB_LOGF(log,
               "build configuration data for enable options, skipping "
               "(process uid %u)",
               __FUNCTION__, process_sp->GetUniqueID());
     return;
   }
 
   // We can run it directly.
   // Send configuration to the feature by way of the process.
-  const Status error =
-      process_sp->ConfigureStructuredData(GetDarwinLogTypeName(), config_sp);
+  const Status error = process_sp->ConfigureStructuredData(
+      ConstString(GetDarwinLogTypeName()), config_sp);
 
   // Report results.
   if (!error.Success()) {
     LLDB_LOGF(log,
               "StructuredDataDarwinLog::%s() "
               "ConfigureStructuredData() call failed "
               "(process uid %u): %s",
               __FUNCTION__, process_sp->GetUniqueID(), error.AsCString());