[llb] Remove the user-defined copy-ctor in ConstString

[JDevlieghere]

Summary

ConstString is essentially trivially copyable yet it has a user defined copy constructor that copies its one member pointer. Remove it so it qualifies as trivial in the eyes of the compiler.

[shafik]

lldb/include/lldb/Utility/ConstString.h

44–45

Since your touching this type, why not modernize it and use an in class member initializer for m_string Then default the constructor.

[teemperor]

Btw, this might spawn a bunch of warnings about unused ConstString variables (I remember I did a similar change locally to find unused ConstStrings some time ago) as the compiler maybe now understands that empty ConstString construction/destruction doesn't have side effects. So you might want to check for them before committing. But LGTM

lldb/include/lldb/Utility/ConstString.h

 ///
 /// No reference counting is done on strings that are added to the string
 /// pool, once strings are added they are in the string pool for the life of
 /// the program.
 class ConstString {
 public:
   /// Default constructor
   ///
   /// Initializes the string to an empty string.
-  ConstString() : m_string(nullptr) {}
-
-  /// Copy constructor
-  ///
-  /// Copies the string value in \a rhs into this object.
-  ///
-  /// \param[in] rhs
-  ///     Another string object to copy.
-  ConstString(const ConstString &rhs) : m_string(rhs.m_string) {}
+  ConstString() = default;
 
   explicit ConstString(const llvm::StringRef &s);
 
   /// Construct with C String value
   ///
   /// Constructs this object with a C string by looking to see if the
   /// C string already exists in the global string pool. If it doesn't
   /// exist, it is added to the string pool.
public:
   /// \param[in] max_cstr_len
   ///     The max length of \a cstr. If the string length of \a cstr
   ///     is less than \a max_cstr_len, then the string will be
   ///     truncated. If the string length of \a cstr is greater than
   ///     \a max_cstr_len, then only max_cstr_len bytes will be used
   ///     from \a cstr.
   explicit ConstString(const char *cstr, size_t max_cstr_len);
 
-  /// Destructor
-  ///
-  /// Since constant string values are currently not reference counted, there
-  /// isn't much to do here.
-  ~ConstString() = default;
-
   /// C string equality binary predicate function object for ConstString
   /// objects.
   struct StringIsEqual {
     /// C equality test.
     ///
     /// Two C strings are equal when they are contained in ConstString objects
     /// when their pointer values are equal to each other.
     ///
public:
   /// { ...
   /// \endcode
   ///
   /// \return
   ///     /b True this object contains a valid non-empty C string, \b
   ///     false otherwise.
   explicit operator bool() const { return !IsEmpty(); }
 
-  /// Assignment operator
-  ///
-  /// Assigns the string in this object with the value from \a rhs.
-  ///
-  /// \param[in] rhs
-  ///     Another string object to copy into this object.
-  ///
-  /// \return
-  ///     A const reference to this object.
-  ConstString operator=(ConstString rhs) {
-    m_string = rhs.m_string;
-    return *this;
-  }
-
   /// Equal to operator
   ///
   /// Returns true if this string is equal to the string in \a rhs. This
   /// operation is very fast as it results in a pointer comparison since all
   /// strings are in a uniqued in a global string pool.
   ///
   /// \param[in] rhs
   ///     Another string object to compare this object to.
protected:
   template <typename T> friend struct ::llvm::DenseMapInfo;
   /// Only used by DenseMapInfo.
   static ConstString FromStringPoolPointer(const char *ptr) {
     ConstString s;
     s.m_string = ptr;
     return s;
   };
 
-  // Member variables
-  const char *m_string;
+  const char *m_string = nullptr;
 };
 
 /// Stream the string value \a str to the stream \a s
 Stream &operator<<(Stream &s, ConstString str);
 
 } // namespace lldb_private
 
 namespace llvm {

lldb/source/Core/IOHandlerCursesGUI.cpp

void Run(Debugger &debugger) {
     // to receive async process events while in this loop.
 
     halfdelay(delay_in_tenths_of_a_second); // Poll using some number of tenths
                                             // of seconds seconds when calling
                                             // Window::GetChar()
 
     ListenerSP listener_sp(
         Listener::MakeListener("lldb.IOHandler.curses.Application"));
-    ConstString broadcaster_class_target(Target::GetStaticBroadcasterClass());
     ConstString broadcaster_class_process(Process::GetStaticBroadcasterClass());
-    ConstString broadcaster_class_thread(Thread::GetStaticBroadcasterClass());
     debugger.EnableForwardEvents(listener_sp);
 
     bool update = true;
 #if defined(__APPLE__)
     std::deque<int> escape_chars;
 #endif
 
     while (!done) {