Delete type_sp member from TypePair

[labath]

Summary

As discussed in the review of D59217, this member is unnecessary since
always the first thing we do is convert it to a CompilerType.

This opens up possibilities for further cleanups (e.g. the whole
TypePair class now loses purpose, since we can just pass around
CompilerType everywhere), but I did not want to do that yet, because I
am not sure if this will not introduce breakages in some of the
platforms/configurations that I am not testing on.

include/lldb/DataFormatters/FormatClasses.h

public:
   }
 
   const char *GetName() {
     if (m_type.m_type_name.size())
       return m_type.m_type_name.c_str();
     return nullptr;
   }
 
-  lldb::TypeSP GetTypeSP() {
-    if (m_type.m_type_pair.IsValid())
-      return m_type.m_type_pair.GetTypeSP();
-    return lldb::TypeSP();
-  }
-
   CompilerType GetCompilerType() {
     if (m_type.m_type_pair.IsValid())
       return m_type.m_type_pair.GetCompilerType();
     return CompilerType();
   }
 
   bool IsRegex() { return m_is_regex; }
 

include/lldb/Symbol/Type.h

#endif
 
   Type *GetEncodingType();
 
   bool ResolveClangType(ResolveState compiler_type_resolve_state);
 };
 
 // these classes are used to back the SBType* objects
 
+// TODO: This class is just a wrapper around CompilerType. Delete it.
 class TypePair {
 public:
-  TypePair() : compiler_type(), type_sp() {}
+  TypePair() : compiler_type() {}
 
-  TypePair(CompilerType type) : compiler_type(type), type_sp() {}
+  TypePair(CompilerType type) : compiler_type(type) {}
 
-  TypePair(lldb::TypeSP type) : compiler_type(), type_sp(type) {
-    compiler_type = type_sp->GetForwardCompilerType();
-  }
+  TypePair(lldb::TypeSP type) : compiler_type(type->GetForwardCompilerType()) {}
 
-  bool IsValid() const {
-    return compiler_type.IsValid() || (type_sp.get() != nullptr);
-  }
+  bool IsValid() const { return compiler_type.IsValid(); }
 
   explicit operator bool() const { return IsValid(); }
 
   bool operator==(const TypePair &rhs) const {
     return compiler_type == rhs.compiler_type;
   }
 
   bool operator!=(const TypePair &rhs) const { return !(*this == rhs); }
 
-  void Clear() {
-    compiler_type.Clear();
-    type_sp.reset();
-  }
+  void Clear() { compiler_type.Clear(); }
 
   ConstString GetName() const {
-    if (type_sp)
-      return type_sp->GetName();
     if (compiler_type)
       return compiler_type.GetTypeName();
     return ConstString();
   }
 
   ConstString GetDisplayTypeName() const {
-    if (type_sp)
-      return type_sp->GetForwardCompilerType().GetDisplayTypeName();
     if (compiler_type)
       return compiler_type.GetDisplayTypeName();
     return ConstString();
   }
 
   void SetType(CompilerType type) {
-    type_sp.reset();
     compiler_type = type;
   }
 
   void SetType(lldb::TypeSP type) {
-    type_sp = type;
-    if (type_sp)
-      compiler_type = type_sp->GetForwardCompilerType();
-    else
-      compiler_type.Clear();
+    compiler_type = type->GetForwardCompilerType();
   }
 
-  lldb::TypeSP GetTypeSP() const { return type_sp; }
-
   CompilerType GetCompilerType() const { return compiler_type; }
 
-  CompilerType GetPointerType() const {
-    if (type_sp)
-      return type_sp->GetForwardCompilerType().GetPointerType();
-    return compiler_type.GetPointerType();
-  }
+  CompilerType GetPointerType() const { return compiler_type.GetPointerType(); }
 
-  CompilerType GetPointeeType() const {
-    if (type_sp)
-      return type_sp->GetForwardCompilerType().GetPointeeType();
-    return compiler_type.GetPointeeType();
-  }
+  CompilerType GetPointeeType() const { return compiler_type.GetPointeeType(); }
 
   CompilerType GetReferenceType() const {
-    if (type_sp)
-      return type_sp->GetForwardCompilerType().GetLValueReferenceType();
-    else
-      return compiler_type.GetLValueReferenceType();
   }
 
   CompilerType GetTypedefedType() const {
-    if (type_sp)
-      return type_sp->GetForwardCompilerType().GetTypedefedType();
-    else
-      return compiler_type.GetTypedefedType();
   }
 
   CompilerType GetDereferencedType() const {
-    if (type_sp)
-      return type_sp->GetForwardCompilerType().GetNonReferenceType();
-    else
-      return compiler_type.GetNonReferenceType();
   }
 
   CompilerType GetUnqualifiedType() const {
-    if (type_sp)
-      return type_sp->GetForwardCompilerType().GetFullyUnqualifiedType();
-    else
-      return compiler_type.GetFullyUnqualifiedType();
   }
 
   CompilerType GetCanonicalType() const {
-    if (type_sp)
-      return type_sp->GetForwardCompilerType().GetCanonicalType();
     return compiler_type.GetCanonicalType();
   }
 
   TypeSystem *GetTypeSystem() const { return compiler_type.GetTypeSystem(); }
 
-  lldb::ModuleSP GetModule() const {
-    if (type_sp)
-      return type_sp->GetModule();
-    return lldb::ModuleSP();
-  }
-
 protected:
   CompilerType compiler_type;
-  lldb::TypeSP type_sp;
 };
 
 // the two classes here are used by the public API as a backend to the SBType
 // and SBTypeList classes
 
 class TypeImpl {
 public:
   TypeImpl();
public:
   TypeAndOrName &operator=(const TypeAndOrName &rhs);
 
   bool operator==(const TypeAndOrName &other) const;
 
   bool operator!=(const TypeAndOrName &other) const;
 
   ConstString GetName() const;
 
-  lldb::TypeSP GetTypeSP() const { return m_type_pair.GetTypeSP(); }
-
   CompilerType GetCompilerType() const { return m_type_pair.GetCompilerType(); }
 
   void SetName(ConstString type_name);
 
   void SetName(const char *type_name_cstr);
 
   void SetTypeSP(lldb::TypeSP type_sp);
 
   void SetCompilerType(CompilerType compiler_type);
 
   bool IsEmpty() const;
 
   bool HasName() const;
 
-  bool HasTypeSP() const;
-
   bool HasCompilerType() const;
 
-  bool HasType() const { return HasTypeSP() || HasCompilerType(); }
+  bool HasType() const { return HasCompilerType(); }
 
   void Clear();
 
   explicit operator bool() { return !IsEmpty(); }
 
 private:
   TypePair m_type_pair;
   ConstString m_type_name;

source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp

if (!error.Success() || vtable_address_point == LLDB_INVALID_ADDRESS)
     return false;
 
   class_type_or_name = GetTypeInfoFromVTableAddress(in_value, original_ptr,
                                                     vtable_address_point);
 
   if (!class_type_or_name)
     return false;
 
-  TypeSP type_sp = class_type_or_name.GetTypeSP();
+  CompilerType type = class_type_or_name.GetCompilerType();
   // There can only be one type with a given name, so we've just found
   // duplicate definitions, and this one will do as well as any other. We
   // don't consider something to have a dynamic type if it is the same as
   // the static type.  So compare against the value we were handed.
-  if (!type_sp)
+  if (!type)
     return true;
 
-  if (ClangASTContext::AreTypesSame(in_value.GetCompilerType(),
-                                    type_sp->GetForwardCompilerType())) {
+  if (ClangASTContext::AreTypesSame(in_value.GetCompilerType(), type)) {
     // The dynamic type we found was the same type, so we don't have a
     // dynamic type here...
     return false;
   }
 
   // The offset_to_top is two pointers above the vtable pointer.
   const uint32_t addr_byte_size = process->GetAddressByteSize();
   const lldb::addr_t offset_to_top_location =

source/Symbol/Type.cpp

 
 void TypeAndOrName::Clear() {
   m_type_name.Clear();
   m_type_pair.Clear();
 }
 
 bool TypeAndOrName::HasName() const { return (bool)m_type_name; }
 
-bool TypeAndOrName::HasTypeSP() const {
-  return m_type_pair.GetTypeSP().get() != nullptr;
-}
-
 bool TypeAndOrName::HasCompilerType() const {
   return m_type_pair.GetCompilerType().IsValid();
 }
 
 TypeImpl::TypeImpl() : m_module_wp(), m_static_type(), m_dynamic_type() {}
 
 TypeImpl::TypeImpl(const TypeImpl &rhs)
     : m_module_wp(rhs.m_module_wp), m_static_type(rhs.m_static_type),

 void TypeImpl::SetType(const CompilerType &compiler_type,
                        const CompilerType &dynamic) {
   m_module_wp = lldb::ModuleWP();
   m_static_type.SetType(compiler_type);
   m_dynamic_type = dynamic;
 }
 
 void TypeImpl::SetType(const TypePair &pair, const CompilerType &dynamic) {
-  m_module_wp = pair.GetModule();
+  m_module_wp.reset();
   m_static_type = pair;
   m_dynamic_type = dynamic;
 }
 
 TypeImpl &TypeImpl::operator=(const TypeImpl &rhs) {
   if (rhs != *this) {
     m_module_wp = rhs.m_module_wp;
     m_static_type = rhs.m_static_type;