Remove the TypePair class

[labath]

Summary

After D59297, the TypePair class kind of lost its purpose as it was no
longer a "pair". This finished the job started in that patch and deletes
the class altogether. All usages have been updated to use CompilerType
class directly.

include/lldb/DataFormatters/FormatClasses.h

TypeNameSpecifierImpl(llvm::StringRef name, bool is_regex)
     m_type.m_type_name = name;
   }
 
   // if constructing with a given type, is_regex cannot be true since we are
   // giving an exact type to match
   TypeNameSpecifierImpl(lldb::TypeSP type) : m_is_regex(false), m_type() {
     if (type) {
       m_type.m_type_name = type->GetName().GetStringRef();
-      m_type.m_type_pair.SetType(type);
+      m_type.m_compiler_type = type->GetForwardCompilerType();
     }
   }
 
   TypeNameSpecifierImpl(CompilerType type) : m_is_regex(false), m_type() {
     if (type.IsValid()) {
       m_type.m_type_name.assign(type.GetConstTypeName().GetCString());
-      m_type.m_type_pair.SetType(type);
+      m_type.m_compiler_type = type;
     }
   }
 
   const char *GetName() {
     if (m_type.m_type_name.size())
       return m_type.m_type_name.c_str();
     return nullptr;
   }
 
   CompilerType GetCompilerType() {
-    if (m_type.m_type_pair.IsValid())
-      return m_type.m_type_pair.GetCompilerType();
+    if (m_type.m_compiler_type.IsValid())
+      return m_type.m_compiler_type;
     return CompilerType();
   }
 
   bool IsRegex() { return m_is_regex; }
 
 private:
   bool m_is_regex;
-  // this works better than TypeAndOrName because the latter only wraps a
-  // TypeSP whereas TypePair can also be backed by a CompilerType
+  // TODO: Replace this with TypeAndOrName.
   struct TypeOrName {
     std::string m_type_name;
-    TypePair m_type_pair;
+    CompilerType m_compiler_type;
   };
   TypeOrName m_type;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(TypeNameSpecifierImpl);
 };
 
 } // namespace lldb_private
 
 #endif // lldb_FormatClasses_h_

include/lldb/Symbol/Type.h

#endif
     bool is_complete_objc_class : 1;
   } m_flags;
 
   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() {}
-
-  TypePair(CompilerType type) : compiler_type(type) {}
-
-  TypePair(lldb::TypeSP type) : compiler_type(type->GetForwardCompilerType()) {}
-
-  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(); }
-
-  ConstString GetName() const {
-    if (compiler_type)
-      return compiler_type.GetTypeName();
-    return ConstString();
-  }
-
-  ConstString GetDisplayTypeName() const {
-    if (compiler_type)
-      return compiler_type.GetDisplayTypeName();
-    return ConstString();
-  }
-
-  void SetType(CompilerType type) {
-    compiler_type = type;
-  }
-
-  void SetType(lldb::TypeSP type) {
-    compiler_type = type->GetForwardCompilerType();
-  }
-
-  CompilerType GetCompilerType() const { return compiler_type; }
-
-  CompilerType GetPointerType() const { return compiler_type.GetPointerType(); }
-
-  CompilerType GetPointeeType() const { return compiler_type.GetPointeeType(); }
-
-  CompilerType GetReferenceType() const {
-    return compiler_type.GetLValueReferenceType();
-  }
-
-  CompilerType GetTypedefedType() const {
-    return compiler_type.GetTypedefedType();
-  }
-
-  CompilerType GetDereferencedType() const {
-    return compiler_type.GetNonReferenceType();
-  }
-
-  CompilerType GetUnqualifiedType() const {
-    return compiler_type.GetFullyUnqualifiedType();
-  }
-
-  CompilerType GetCanonicalType() const {
-    return compiler_type.GetCanonicalType();
-  }
-
-  TypeSystem *GetTypeSystem() const { return compiler_type.GetTypeSystem(); }
-
-protected:
-  CompilerType compiler_type;
-};
-
 // the two classes here are used by the public API as a backend to the SBType
 // and SBTypeList classes
 
 class TypeImpl {
 public:
   TypeImpl();
 
   ~TypeImpl() {}
 
   TypeImpl(const TypeImpl &rhs);
 
   TypeImpl(const lldb::TypeSP &type_sp);
 
   TypeImpl(const CompilerType &compiler_type);
 
   TypeImpl(const lldb::TypeSP &type_sp, const CompilerType &dynamic);
 
   TypeImpl(const CompilerType &compiler_type, const CompilerType &dynamic);
 
-  TypeImpl(const TypePair &pair, const CompilerType &dynamic);
-
   void SetType(const lldb::TypeSP &type_sp);
 
   void SetType(const CompilerType &compiler_type);
 
   void SetType(const lldb::TypeSP &type_sp, const CompilerType &dynamic);
 
   void SetType(const CompilerType &compiler_type, const CompilerType &dynamic);
 
-  void SetType(const TypePair &pair, const CompilerType &dynamic);
-
   TypeImpl &operator=(const TypeImpl &rhs);
 
   bool operator==(const TypeImpl &rhs) const;
 
   bool operator!=(const TypeImpl &rhs) const;
 
   bool IsValid() const;
 
public:
 
   bool GetDescription(lldb_private::Stream &strm,
                       lldb::DescriptionLevel description_level);
 
 private:
   bool CheckModule(lldb::ModuleSP &module_sp) const;
 
   lldb::ModuleWP m_module_wp;
-  TypePair m_static_type;
+  CompilerType m_static_type;
   CompilerType m_dynamic_type;
 };
 
 class TypeListImpl {
 public:
   TypeListImpl() : m_content() {}
 
   void Append(const lldb::TypeImplSP &type) { m_content.push_back(type); }

 /// objects, and then if it
 /// has a full type, you can use that, but if not at least you can print the
 /// name for informational
 /// purposes.
 ///
 
 class TypeAndOrName {
 public:
-  TypeAndOrName();
+  TypeAndOrName() = default;
   TypeAndOrName(lldb::TypeSP &type_sp);
   TypeAndOrName(const CompilerType &compiler_type);
   TypeAndOrName(const char *type_str);
-  TypeAndOrName(const TypeAndOrName &rhs);
   TypeAndOrName(ConstString &type_const_string);
 
-  TypeAndOrName &operator=(const TypeAndOrName &rhs);
-
   bool operator==(const TypeAndOrName &other) const;
 
   bool operator!=(const TypeAndOrName &other) const;
 
   ConstString GetName() const;
 
-  CompilerType GetCompilerType() const { return m_type_pair.GetCompilerType(); }
+  CompilerType GetCompilerType() const { return m_compiler_type; }
 
   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 HasCompilerType() const;
 
   bool HasType() const { return HasCompilerType(); }
 
   void Clear();
 
   explicit operator bool() { return !IsEmpty(); }
 
 private:
-  TypePair m_type_pair;
+  CompilerType m_compiler_type;
   ConstString m_type_name;
 };
 
 class TypeMemberFunctionImpl {
 public:
   TypeMemberFunctionImpl()
       : m_type(), m_decl(), m_name(), m_kind(lldb::eMemberFunctionKindUnknown) {
   }

include/lldb/lldb-forward.h

 class TypeMap;
 class TypeListImpl;
 class TypeMemberImpl;
 class TypeMemberFunctionImpl;
 class TypeEnumMemberImpl;
 class TypeEnumMemberListImpl;
 class TypeFormatImpl;
 class TypeNameSpecifierImpl;
-class TypePair;
 class TypeValidatorImpl;
 class UUID;
 class UnixSignals;
 class Unwind;
 class UnwindAssembly;
 class UnwindPlan;
 class UnwindTable;
 class UserExpression;

source/Symbol/Type.cpp

 }
 
 ModuleSP Type::GetModule() {
   if (m_symbol_file)
     return m_symbol_file->GetObjectFile()->GetModule();
   return ModuleSP();
 }
 
-TypeAndOrName::TypeAndOrName() : m_type_pair(), m_type_name() {}
-
-TypeAndOrName::TypeAndOrName(TypeSP &in_type_sp) : m_type_pair(in_type_sp) {
-  if (in_type_sp)
+TypeAndOrName::TypeAndOrName(TypeSP &in_type_sp) {
+  if (in_type_sp) {
+    m_compiler_type = in_type_sp->GetForwardCompilerType();
     m_type_name = in_type_sp->GetName();
   }
+}
 
 TypeAndOrName::TypeAndOrName(const char *in_type_str)
     : m_type_name(in_type_str) {}
 
-TypeAndOrName::TypeAndOrName(const TypeAndOrName &rhs)
-    : m_type_pair(rhs.m_type_pair), m_type_name(rhs.m_type_name) {}
-
 TypeAndOrName::TypeAndOrName(ConstString &in_type_const_string)
     : m_type_name(in_type_const_string) {}
 
-TypeAndOrName &TypeAndOrName::operator=(const TypeAndOrName &rhs) {
-  if (this != &rhs) {
-    m_type_name = rhs.m_type_name;
-    m_type_pair = rhs.m_type_pair;
-  }
-  return *this;
-}
-
 bool TypeAndOrName::operator==(const TypeAndOrName &other) const {
-  if (m_type_pair != other.m_type_pair)
+  if (m_compiler_type != other.m_compiler_type)
     return false;
   if (m_type_name != other.m_type_name)
     return false;
   return true;
 }
 
 bool TypeAndOrName::operator!=(const TypeAndOrName &other) const {
   return !(*this == other);
 }
 
 ConstString TypeAndOrName::GetName() const {
   if (m_type_name)
     return m_type_name;
-  if (m_type_pair)
-    return m_type_pair.GetName();
+  if (m_compiler_type)
+    return m_compiler_type.GetTypeName();
   return ConstString("<invalid>");
 }
 
 void TypeAndOrName::SetName(ConstString type_name) {
   m_type_name = type_name;
 }
 
 void TypeAndOrName::SetName(const char *type_name_cstr) {
   m_type_name.SetCString(type_name_cstr);
 }
 
 void TypeAndOrName::SetTypeSP(lldb::TypeSP type_sp) {
-  m_type_pair.SetType(type_sp);
-  if (m_type_pair)
-    m_type_name = m_type_pair.GetName();
+  if (type_sp) {
+    m_compiler_type = type_sp->GetForwardCompilerType();
+    m_type_name = type_sp->GetName();
+  } else
+    Clear();
 }
 
 void TypeAndOrName::SetCompilerType(CompilerType compiler_type) {
-  m_type_pair.SetType(compiler_type);
-  if (m_type_pair)
-    m_type_name = m_type_pair.GetName();
+  m_compiler_type = compiler_type;
+  if (m_compiler_type)
+    m_type_name = m_compiler_type.GetTypeName();
 }
 
 bool TypeAndOrName::IsEmpty() const {
-  return !((bool)m_type_name || (bool)m_type_pair);
+  return !((bool)m_type_name || (bool)m_compiler_type);
 }
 
 void TypeAndOrName::Clear() {
   m_type_name.Clear();
-  m_type_pair.Clear();
+  m_compiler_type.Clear();
 }
 
 bool TypeAndOrName::HasName() const { return (bool)m_type_name; }
 
 bool TypeAndOrName::HasCompilerType() const {
-  return m_type_pair.GetCompilerType().IsValid();
+  return m_compiler_type.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),
       m_dynamic_type(rhs.m_dynamic_type) {}
 
 TypeImpl::TypeImpl(const lldb::TypeSP &type_sp)
     : m_module_wp(), m_static_type(), m_dynamic_type() {
   SetType(type_sp);
 }
 
 TypeImpl::TypeImpl(const CompilerType &compiler_type)
     : m_module_wp(), m_static_type(), m_dynamic_type() {
   SetType(compiler_type);
 }
 
 TypeImpl::TypeImpl(const lldb::TypeSP &type_sp, const CompilerType &dynamic)
-    : m_module_wp(), m_static_type(type_sp), m_dynamic_type(dynamic) {
+    : m_module_wp(), m_static_type(), m_dynamic_type(dynamic) {
   SetType(type_sp, dynamic);
 }
 
 TypeImpl::TypeImpl(const CompilerType &static_type,
                    const CompilerType &dynamic_type)
     : m_module_wp(), m_static_type(), m_dynamic_type() {
   SetType(static_type, dynamic_type);
 }
 
-TypeImpl::TypeImpl(const TypePair &pair, const CompilerType &dynamic)
-    : m_module_wp(), m_static_type(), m_dynamic_type() {
-  SetType(pair, dynamic);
-}
-
 void TypeImpl::SetType(const lldb::TypeSP &type_sp) {
-  m_static_type.SetType(type_sp);
-  if (type_sp)
+  if (type_sp) {
+    m_static_type = type_sp->GetForwardCompilerType();
     m_module_wp = type_sp->GetModule();
-  else
+  } else {
+    m_static_type.Clear();
     m_module_wp = lldb::ModuleWP();
   }
+}
 
 void TypeImpl::SetType(const CompilerType &compiler_type) {
   m_module_wp = lldb::ModuleWP();
-  m_static_type.SetType(compiler_type);
+  m_static_type = compiler_type;
 }
 
 void TypeImpl::SetType(const lldb::TypeSP &type_sp,
                        const CompilerType &dynamic) {
   SetType(type_sp);
   m_dynamic_type = dynamic;
 }
 
 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.reset();
-  m_static_type = pair;
+  m_static_type = compiler_type;
   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;
     m_dynamic_type = rhs.m_dynamic_type;
void TypeImpl::Clear() {
   m_dynamic_type.Clear();
 }
 
 ConstString TypeImpl::GetName() const {
   ModuleSP module_sp;
   if (CheckModule(module_sp)) {
     if (m_dynamic_type)
       return m_dynamic_type.GetTypeName();
-    return m_static_type.GetName();
+    return m_static_type.GetTypeName();
   }
   return ConstString();
 }
 
 ConstString TypeImpl::GetDisplayTypeName() const {
   ModuleSP module_sp;
   if (CheckModule(module_sp)) {
     if (m_dynamic_type)
TypeImpl TypeImpl::GetPointeeType() const {
   }
   return TypeImpl();
 }
 
 TypeImpl TypeImpl::GetReferenceType() const {
   ModuleSP module_sp;
   if (CheckModule(module_sp)) {
     if (m_dynamic_type.IsValid()) {
-      return TypeImpl(m_static_type.GetReferenceType(),
+      return TypeImpl(m_static_type.GetLValueReferenceType(),
                       m_dynamic_type.GetLValueReferenceType());
     }
-    return TypeImpl(m_static_type.GetReferenceType());
+    return TypeImpl(m_static_type.GetLValueReferenceType());
   }
   return TypeImpl();
 }
 
 TypeImpl TypeImpl::GetTypedefedType() const {
   ModuleSP module_sp;
   if (CheckModule(module_sp)) {
     if (m_dynamic_type.IsValid()) {
       return TypeImpl(m_static_type.GetTypedefedType(),
                       m_dynamic_type.GetTypedefedType());
     }
     return TypeImpl(m_static_type.GetTypedefedType());
   }
   return TypeImpl();
 }
 
 TypeImpl TypeImpl::GetDereferencedType() const {
   ModuleSP module_sp;
   if (CheckModule(module_sp)) {
     if (m_dynamic_type.IsValid()) {
-      return TypeImpl(m_static_type.GetDereferencedType(),
+      return TypeImpl(m_static_type.GetNonReferenceType(),
                       m_dynamic_type.GetNonReferenceType());
     }
-    return TypeImpl(m_static_type.GetDereferencedType());
+    return TypeImpl(m_static_type.GetNonReferenceType());
   }
   return TypeImpl();
 }
 
 TypeImpl TypeImpl::GetUnqualifiedType() const {
   ModuleSP module_sp;
   if (CheckModule(module_sp)) {
     if (m_dynamic_type.IsValid()) {
-      return TypeImpl(m_static_type.GetUnqualifiedType(),
+      return TypeImpl(m_static_type.GetFullyUnqualifiedType(),
                       m_dynamic_type.GetFullyUnqualifiedType());
     }
-    return TypeImpl(m_static_type.GetUnqualifiedType());
+    return TypeImpl(m_static_type.GetFullyUnqualifiedType());
   }
   return TypeImpl();
 }
 
 TypeImpl TypeImpl::GetCanonicalType() const {
   ModuleSP module_sp;
   if (CheckModule(module_sp)) {
     if (m_dynamic_type.IsValid()) {
       return TypeImpl(m_static_type.GetCanonicalType(),
                       m_dynamic_type.GetCanonicalType());
     }
     return TypeImpl(m_static_type.GetCanonicalType());
   }
   return TypeImpl();
 }
 
 CompilerType TypeImpl::GetCompilerType(bool prefer_dynamic) {
   ModuleSP module_sp;
   if (CheckModule(module_sp)) {
     if (prefer_dynamic) {
       if (m_dynamic_type.IsValid())
         return m_dynamic_type;
     }
-    return m_static_type.GetCompilerType();
+    return m_static_type;
   }
   return CompilerType();
 }
 
 TypeSystem *TypeImpl::GetTypeSystem(bool prefer_dynamic) {
   ModuleSP module_sp;
   if (CheckModule(module_sp)) {
     if (prefer_dynamic) {
       if (m_dynamic_type.IsValid())
         return m_dynamic_type.GetTypeSystem();
     }
-    return m_static_type.GetCompilerType().GetTypeSystem();
+    return m_static_type.GetTypeSystem();
   }
   return NULL;
 }
 
 bool TypeImpl::GetDescription(lldb_private::Stream &strm,
                               lldb::DescriptionLevel description_level) {
   ModuleSP module_sp;
   if (CheckModule(module_sp)) {
     if (m_dynamic_type.IsValid()) {
       strm.Printf("Dynamic:\n");
       m_dynamic_type.DumpTypeDescription(&strm);
       strm.Printf("\nStatic:\n");
     }
-    m_static_type.GetCompilerType().DumpTypeDescription(&strm);
+    m_static_type.DumpTypeDescription(&strm);
   } else {
     strm.PutCString("Invalid TypeImpl module for type has been deleted\n");
   }
   return true;
 }
 
 bool TypeMemberFunctionImpl::IsValid() {
   return m_type.IsValid() && m_kind != lldb::eMemberFunctionKindUnknown;