[lldb] Refactor deduction of the instance variable's name (NFC)

[kastiglione]

Summary

Move responsibility of providing the instance variable name (this, self) from
TypeSystem to Language.

Language the natural place for this, but also has downstream benefits. Some languages
have multiple TypeSystem implementations (ex Swift), and by placing this logic in the
Language, redundancy is avoided.

This change relies on the tests from D145348 and D146320.

lldb/include/lldb/Symbol/CompilerDeclContext.h

public:
   /// \return
   ///     Returns true if this is a decl context that represents a method
   ///     in a struct, union or class.
   bool IsClassMethod();
 
   /// Determines the original language of the decl context.
   lldb::LanguageType GetLanguage();
 
-  /// 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(lldb::LanguageType language);
-
   /// Check if the given other decl context is contained in the lookup
   /// of this decl context (for example because the other context is a nested
   /// inline namespace).
   ///
   /// @param[in] other
   ///     The other decl context for which we should check if it is contained
   ///     in the lookoup of this context.
   ///

lldb/include/lldb/Symbol/TypeSystem.h

#endif
 
   virtual bool IsVoidType(lldb::opaque_compiler_type_t type) = 0;
 
   virtual bool CanPassInRegisters(const CompilerType &type) = 0;
 
   // TypeSystems can support more than one language
   virtual bool SupportsLanguage(lldb::LanguageType language) = 0;
 
-  /// The name of the variable used for explicitly accessing data scoped to the
-  /// current instance (or type). C++ uses "this", ObjC uses "self".
-  virtual ConstString GetInstanceVariableName(lldb::LanguageType language) = 0;
-
   // Type Completion
 
   virtual bool GetCompleteType(lldb::opaque_compiler_type_t type) = 0;
 
   virtual bool IsForcefullyCompleted(lldb::opaque_compiler_type_t type) {
     return false;
   }
 

lldb/include/lldb/Target/Language.h

public:
   }
 
   virtual ConstString
   FindBestAlternateFunctionMangledName(const Mangled mangled,
                                        const SymbolContext &sym_ctx) const {
     return ConstString();
   }
 
+  virtual ConstString 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"); }
+
   // 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"); }
+
   // 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"); }
+
   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/Plugins/TypeSystem/Clang/TypeSystemClang.h

#endif
   bool IsTypedefType(lldb::opaque_compiler_type_t type) override;
 
   bool IsVoidType(lldb::opaque_compiler_type_t type) override;
 
   bool CanPassInRegisters(const CompilerType &type) override;
 
   bool SupportsLanguage(lldb::LanguageType language) override;
 
-  ConstString GetInstanceVariableName(lldb::LanguageType language) override;
-
   static std::optional<std::string> GetCXXClassName(const CompilerType &type);
 
   // Type Completion
 
   bool GetCompleteType(lldb::opaque_compiler_type_t type) override;
 
   bool IsForcefullyCompleted(lldb::opaque_compiler_type_t type) override;
 

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

bool TypeSystemClang::CanPassInRegisters(const CompilerType &type) {
   }
   return false;
 }
 
 bool TypeSystemClang::SupportsLanguage(lldb::LanguageType language) {
   return TypeSystemClangSupportsLanguage(language);
 }
 
-ConstString
-TypeSystemClang::GetInstanceVariableName(lldb::LanguageType language) {
-  switch (language) {
-  case LanguageType::eLanguageTypeC_plus_plus:
-  case LanguageType::eLanguageTypeC_plus_plus_03:
-  case LanguageType::eLanguageTypeC_plus_plus_11:
-  case LanguageType::eLanguageTypeC_plus_plus_14:
-    return ConstString("this");
-  case LanguageType::eLanguageTypeObjC:
-  case LanguageType::eLanguageTypeObjC_plus_plus:
-    return ConstString("self");
-  default:
-    return {};
-  }
-}
-
 std::optional<std::string>
 TypeSystemClang::GetCXXClassName(const CompilerType &type) {
   if (!type)
     return std::nullopt;
 
   clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type));
   if (qual_type.isNull())
     return std::nullopt;

lldb/source/Symbol/CompilerDeclContext.cpp

 }
 
 lldb::LanguageType CompilerDeclContext::GetLanguage() {
   if (IsValid())
     return m_type_system->DeclContextGetLanguage(m_opaque_decl_ctx);
   return {};
 }
 
-ConstString
-CompilerDeclContext::GetInstanceVariableName(lldb::LanguageType language) {
-  if (IsValid())
-    return m_type_system->GetInstanceVariableName(language);
-  return {};
-}
-
 bool CompilerDeclContext::IsContainedInLookup(CompilerDeclContext other) const {
   if (!IsValid())
     return false;
 
   // If the other context is just the current context, we don't need to go
   // over the type system to know that the lookup is identical.
   if (this == &other)
     return true;

lldb/source/Symbol/SymbolContext.cpp

 #include "lldb/Host/Host.h"
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/Variable.h"
+#include "lldb/Target/Language.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
+#include "lldb/lldb-enumerations.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SymbolContext::SymbolContext() : target_sp(), module_sp(), line_entry() {}
 
 SymbolContext::SymbolContext(const ModuleSP &m, CompileUnit *cu, Function *f,
                              Block *b, LineEntry *le, Symbol *s)
if (function) {
     // that the block that is desired is the top level block of the function
     // itself.
     return &function->GetBlock(true);
   }
   return nullptr;
 }
 
 ConstString SymbolContext::GetInstanceVariableName() {
+  LanguageType lang_type = eLanguageTypeUnknown;
+
   if (Block *function_block = GetFunctionBlock())
-    if (CompilerDeclContext decl_ctx = function_block->GetDeclContext()) {
-      auto language = decl_ctx.GetLanguage();
-      if (language == eLanguageTypeUnknown)
-        language = GetLanguage();
-      return decl_ctx.GetInstanceVariableName(language);
-    }
+    if (CompilerDeclContext decl_ctx = function_block->GetDeclContext())
+      lang_type = decl_ctx.GetLanguage();
+
+  if (lang_type == eLanguageTypeUnknown)
+    lang_type = GetLanguage();
+
+  if (auto *lang = Language::FindPlugin(lang_type))
+    return lang->GetInstanceVariableName();
 
   return {};
 }
 
 void SymbolContext::SortTypeList(TypeMap &type_map, TypeList &type_list) const {
   Block *curr_block = block;
   bool isInlinedblock = false;
   if (curr_block != nullptr &&