[lldb][NFCI] Change return type of Language::GetInstanceVariableName

[bulbazord]

Summary

I don't think this needs to be a ConstString.

lldb/include/lldb/Symbol/SymbolContext.h

public:
   ///     represented by this symbol context object, nullptr otherwise.
   Block *GetFunctionBlock();
 
   /// Determines the name of the instance variable for the this decl context.
   ///
   /// For C++ the name is "this", for Objective-C the name is "self".
   ///
   /// \return
-  ///     Returns a string for the name of the instance variable.
-  ConstString GetInstanceVariableName();
+  ///     Returns a StringRef for the name of the instance variable.
+  llvm::StringRef GetInstanceVariableName();
 
   /// Sorts the types in TypeMap according to SymbolContext to TypeList
   ///
   void SortTypeList(TypeMap &type_map, TypeList &type_list) const;
 
   /// Find a name of the innermost function for the symbol context.
   ///
   /// For instance, if the symbol context contains an inlined block, it will

lldb/include/lldb/Target/Language.h

public:
   }
 
   virtual ConstString
   FindBestAlternateFunctionMangledName(const Mangled mangled,
                                        const SymbolContext &sym_ctx) const {
     return ConstString();
   }
 
-  virtual ConstString GetInstanceVariableName() { return {}; }
+  virtual llvm::StringRef GetInstanceVariableName() { return {}; }
 
 protected:
   // Classes that inherit from Language can see and modify these
 
   Language();
 
 private:
   Language(const Language &) = delete;
   const Language &operator=(const Language &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_LANGUAGE_H

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h

static bool ExtractContextAndIdentifier(const char *name,
                                           llvm::StringRef &identifier);
 
   std::vector<ConstString>
   GenerateAlternateFunctionManglings(const ConstString mangled) const override;
 
   ConstString FindBestAlternateFunctionMangledName(
       const Mangled mangled, const SymbolContext &sym_ctx) const override;
 
-  ConstString GetInstanceVariableName() override { return ConstString("this"); }
+  llvm::StringRef GetInstanceVariableName() override { return "this"; }
 
   // PluginInterface protocol
   llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_LANGUAGE_CPLUSPLUS_CPLUSPLUSLANGUAGE_H

lldb/source/Plugins/Language/ObjC/ObjCLanguage.h

static bool IsPossibleObjCSelector(const char *name) {
     if (strchr(name, ':') == nullptr)
       return true;
     else if (name[strlen(name) - 1] == ':')
       return true;
     else
       return false;
   }
 
-  ConstString GetInstanceVariableName() override { return ConstString("self"); }
+  llvm::StringRef GetInstanceVariableName() override { return "self"; }
 
   // PluginInterface protocol
   llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_LANGUAGE_OBJC_OBJCLANGUAGE_H

lldb/source/Plugins/Language/ObjCPlusPlus/ObjCPlusPlusLanguage.h

public:
 
   // Static Functions
   static void Initialize();
 
   static void Terminate();
 
   static lldb_private::Language *CreateInstance(lldb::LanguageType language);
 
-  ConstString GetInstanceVariableName() override { return ConstString("self"); }
+  llvm::StringRef GetInstanceVariableName() override { return "self"; }
 
   static llvm::StringRef GetPluginNameStatic() { return "objcplusplus"; }
 
   // PluginInterface protocol
   llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_LANGUAGE_OBJCPLUSPLUS_OBJCPLUSPLUSLANGUAGE_H

lldb/source/Symbol/SymbolContext.cpp

if (function) {
     // There is no block information in this symbol context, so we must assume
     // that the block that is desired is the top level block of the function
     // itself.
     return &function->GetBlock(true);
   }
   return nullptr;
 }
 
-ConstString SymbolContext::GetInstanceVariableName() {
+llvm::StringRef SymbolContext::GetInstanceVariableName() {
   LanguageType lang_type = eLanguageTypeUnknown;
 
   if (Block *function_block = GetFunctionBlock())
     if (CompilerDeclContext decl_ctx = function_block->GetDeclContext())
       lang_type = decl_ctx.GetLanguage();
 
   if (lang_type == eLanguageTypeUnknown)
     lang_type = GetLanguage();

lldb/source/Target/StackFrame.cpp

ValueObjectSP StackFrame::GetValueForVariableExpressionPath(
   if (var_sp) {
     var_expr = var_expr.drop_front(name_const_string.GetLength());
   }
 
   if (!var_sp && (options & eExpressionPathOptionsAllowDirectIVarAccess)) {
     // Check for direct ivars access which helps us with implicit access to
     // ivars using "this" or "self".
     GetSymbolContext(eSymbolContextFunction | eSymbolContextBlock);
-    if (auto instance_var_name = m_sc.GetInstanceVariableName()) {
-      var_sp = variable_list->FindVariable(instance_var_name);
+    llvm::StringRef instance_var_name = m_sc.GetInstanceVariableName();
+    if (!instance_var_name.empty()) {
+      var_sp = variable_list->FindVariable(ConstString(instance_var_name));
       if (var_sp) {
         separator_idx = 0;
         if (Type *var_type = var_sp->GetType())
           if (auto compiler_type = var_type->GetForwardCompilerType())
             if (!compiler_type.IsPointerType())
               var_expr_storage = ".";
 
         if (var_expr_storage.empty())