4 files changed, 86 insertions, 144 deletions

diff --git a/lldb/source/API/SBModule.cpp b/lldb/source/API/SBModule.cpp
index 390ca64e6c1..5f5fc9292cd 100644
--- a/lldb/source/API/SBModule.cpp
+++ b/lldb/source/API/SBModule.cpp
@@ -506,7 +506,7 @@ SBModule::FindFirstType (const char *name_cstr)
         sb_type = SBType (module_sp->FindFirstType(sc, name, exact_match));
         
         if (!sb_type.IsValid())
-            sb_type = SBType (ClangASTType::GetBasicType (module_sp->GetClangASTContext().getASTContext(), name));
+            sb_type = SBType (ClangASTContext::GetBasicType (module_sp->GetClangASTContext().getASTContext(), name));
     }
     return sb_type;
 }
@@ -516,7 +516,7 @@ SBModule::GetBasicType(lldb::BasicType type)
 {
     ModuleSP module_sp (GetSP ());
     if (module_sp)
-        return SBType (ClangASTType::GetBasicType (module_sp->GetClangASTContext().getASTContext(), type));
+        return SBType (ClangASTContext::GetBasicType (module_sp->GetClangASTContext().getASTContext(), type));
     return SBType();
 }
 
@@ -549,7 +549,7 @@ SBModule::FindTypes (const char *type)
         }
         else
         {
-            SBType sb_type(ClangASTType::GetBasicType (module_sp->GetClangASTContext().getASTContext(), name));
+            SBType sb_type(ClangASTContext::GetBasicType (module_sp->GetClangASTContext().getASTContext(), name));
             if (sb_type.IsValid())
                 retval.Append(sb_type);
         }
diff --git a/lldb/source/API/SBTarget.cpp b/lldb/source/API/SBTarget.cpp
index 7e47fbf0187..f37c8f8a614 100644
--- a/lldb/source/API/SBTarget.cpp
+++ b/lldb/source/API/SBTarget.cpp
@@ -2153,7 +2153,7 @@ SBTarget::FindFirstType (const char* typename_cstr)
         // No matches, search for basic typename matches
         ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext();
         if (clang_ast)
-            return SBType (ClangASTType::GetBasicType (clang_ast->getASTContext(), const_typename));
+            return SBType (ClangASTContext::GetBasicType (clang_ast->getASTContext(), const_typename));
     }
     return SBType();
 }
@@ -2166,7 +2166,7 @@ SBTarget::GetBasicType(lldb::BasicType type)
     {
         ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext();
         if (clang_ast)
-            return SBType (ClangASTType::GetBasicType (clang_ast->getASTContext(), type));
+            return SBType (ClangASTContext::GetBasicType (clang_ast->getASTContext(), type));
     }
     return SBType();
 }
@@ -2233,7 +2233,7 @@ SBTarget::FindTypes (const char* typename_cstr)
             // No matches, search for basic typename matches
             ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext();
             if (clang_ast)
-                sb_type_list.Append (SBType (ClangASTType::GetBasicType (clang_ast->getASTContext(), const_typename)));
+                sb_type_list.Append (SBType (ClangASTContext::GetBasicType (clang_ast->getASTContext(), const_typename)));
         }
     }
     return sb_type_list;
diff --git a/lldb/source/API/SBType.cpp b/lldb/source/API/SBType.cpp
index f6d2fc5568a..372d073acf1 100644
--- a/lldb/source/API/SBType.cpp
+++ b/lldb/source/API/SBType.cpp
@@ -142,7 +142,7 @@ SBType::GetByteSize()
     if (!IsValid())
         return 0;
     
-    return ClangASTType::GetTypeByteSize(m_opaque_sp->GetASTContext(), m_opaque_sp->GetOpaqueQualType());
+    return m_opaque_sp->GetClangASTType().GetByteSize();
     
 }
 
@@ -151,13 +151,7 @@ SBType::IsPointerType()
 {
     if (!IsValid())
         return false;
-    
-    QualType qt = QualType::getFromOpaquePtr(m_opaque_sp->GetOpaqueQualType());
-    const clang::Type* typePtr = qt.getTypePtrOrNull();
-    
-    if (typePtr)
-        return typePtr->isAnyPointerType();
-    return false;
+    return m_opaque_sp->GetClangASTType().IsPointerType();
 }
 
 bool
@@ -165,13 +159,7 @@ SBType::IsReferenceType()
 {
     if (!IsValid())
         return false;
-
-    QualType qt = QualType::getFromOpaquePtr(m_opaque_sp->GetOpaqueQualType());
-    const clang::Type* typePtr = qt.getTypePtrOrNull();
-    
-    if (typePtr)
-        return typePtr->isReferenceType();
-    return false;
+    return m_opaque_sp->GetClangASTType().IsReferenceType();
 }
 
 SBType
@@ -180,8 +168,7 @@ SBType::GetPointerType()
     if (!IsValid())
         return SBType();
 
-    return SBType(ClangASTType(m_opaque_sp->GetASTContext(),
-                               ClangASTContext::CreatePointerType(m_opaque_sp->GetASTContext(), m_opaque_sp->GetOpaqueQualType())));
+    return SBType(ClangASTType(m_opaque_sp->GetClangASTType().GetPointerType()));
 }
 
 SBType
@@ -189,13 +176,7 @@ SBType::GetPointeeType()
 {
     if (!IsValid())
         return SBType();
-
-    QualType qt = QualType::getFromOpaquePtr(m_opaque_sp->GetOpaqueQualType());
-    const clang::Type* typePtr = qt.getTypePtrOrNull();
-    
-    if (typePtr)
-        return SBType(ClangASTType(m_opaque_sp->GetASTContext(),typePtr->getPointeeType().getAsOpaquePtr()));
-    return SBType();
+    return SBType(ClangASTType(m_opaque_sp->GetClangASTType().GetPointeeType()));
 }
 
 SBType
@@ -203,9 +184,7 @@ SBType::GetReferenceType()
 {
     if (!IsValid())
         return SBType();
-    
-    return SBType(ClangASTType(m_opaque_sp->GetASTContext(),
-                               ClangASTContext::CreateLValueReferenceType(m_opaque_sp->GetASTContext(), m_opaque_sp->GetOpaqueQualType())));
+    return SBType(ClangASTType(m_opaque_sp->GetClangASTType().GetLValueReferenceType()));
 }
 
 SBType
@@ -213,32 +192,23 @@ SBType::GetDereferencedType()
 {
     if (!IsValid())
         return SBType();
-
-    QualType qt = QualType::getFromOpaquePtr(m_opaque_sp->GetOpaqueQualType());
-    
-    return SBType(ClangASTType(m_opaque_sp->GetASTContext(),qt.getNonReferenceType().getAsOpaquePtr()));
+    return SBType(ClangASTType(m_opaque_sp->GetClangASTType().GetNonReferenceType()));
 }
 
 bool 
 SBType::IsFunctionType ()
 {
-    if (IsValid())
-    {
-        QualType qual_type(QualType::getFromOpaquePtr(m_opaque_sp->GetOpaqueQualType()));
-        const FunctionProtoType* func = dyn_cast<FunctionProtoType>(qual_type.getTypePtr());
-        return func != NULL;
-    }
-    return false;
+    if (!IsValid())
+        return false;
+    return m_opaque_sp->GetClangASTType().IsFunctionType();
 }
 
 bool
 SBType::IsPolymorphicClass ()
 {
-    if (IsValid())
-    {
-        return ClangASTType::IsPolymorphicClass (m_opaque_sp->GetASTContext(), m_opaque_sp->GetOpaqueQualType());
-    }
-    return false;
+    if (!IsValid())
+        return false;
+    return m_opaque_sp->GetClangASTType().IsPolymorphicClass();
 }
 
 
@@ -248,12 +218,9 @@ SBType::GetFunctionReturnType ()
 {
     if (IsValid())
     {
-        QualType qual_type(QualType::getFromOpaquePtr(m_opaque_sp->GetOpaqueQualType()));
-        const FunctionProtoType* func = dyn_cast<FunctionProtoType>(qual_type.getTypePtr());
-        
-        if (func)
-            return SBType(ClangASTType(m_opaque_sp->GetASTContext(),
-                                       func->getResultType().getAsOpaquePtr()));
+        ClangASTType return_clang_type (m_opaque_sp->GetClangASTType().GetFunctionReturnType());
+        if (return_clang_type.IsValid())
+            return SBType(return_clang_type);
     }
     return lldb::SBType();
 }
@@ -281,19 +248,14 @@ SBType::GetUnqualifiedType()
 {
     if (!IsValid())
         return SBType();
-        
-    QualType qt (QualType::getFromOpaquePtr(m_opaque_sp->GetOpaqueQualType()));
-    return SBType(ClangASTType(m_opaque_sp->GetASTContext(),qt.getUnqualifiedType().getAsOpaquePtr()));
+    return SBType(m_opaque_sp->GetClangASTType().GetFullyUnqualifiedType());
 }
 
 lldb::SBType
 SBType::GetCanonicalType()
 {
     if (IsValid())
-    {
-        QualType qt (QualType::getFromOpaquePtr(m_opaque_sp->GetOpaqueQualType()));
-        return SBType(ClangASTType(m_opaque_sp->GetASTContext(),qt.getCanonicalType().getAsOpaquePtr()));
-    }
+        return SBType(m_opaque_sp->GetClangASTType().GetCanonicalType());
     return SBType();
 }
 
@@ -302,15 +264,15 @@ lldb::BasicType
 SBType::GetBasicType()
 {
     if (IsValid())
-        return ClangASTContext::GetLLDBBasicTypeEnumeration (m_opaque_sp->GetOpaqueQualType());
+        return m_opaque_sp->GetClangASTType().GetBasicTypeEnumeration ();
     return eBasicTypeInvalid;
 }
 
 SBType
-SBType::GetBasicType(lldb::BasicType type)
+SBType::GetBasicType(lldb::BasicType basic_type)
 {
     if (IsValid())
-        return SBType (ClangASTType::GetBasicType (m_opaque_sp->GetASTContext(), type));
+        return SBType (ClangASTContext::GetBasicType (m_opaque_sp->GetASTContext(), basic_type));
     return SBType();
 }
 
@@ -318,7 +280,7 @@ uint32_t
 SBType::GetNumberOfDirectBaseClasses ()
 {
     if (IsValid())
-        return ClangASTContext::GetNumDirectBaseClasses(m_opaque_sp->GetASTContext(), m_opaque_sp->GetOpaqueQualType());
+        return m_opaque_sp->GetClangASTType().GetNumDirectBaseClasses();
     return 0;
 }
 
@@ -326,7 +288,7 @@ uint32_t
 SBType::GetNumberOfVirtualBaseClasses ()
 {
     if (IsValid())
-        return ClangASTContext::GetNumVirtualBaseClasses(m_opaque_sp->GetASTContext(), m_opaque_sp->GetOpaqueQualType());
+        return m_opaque_sp->GetClangASTType().GetNumVirtualBaseClasses();
     return 0;
 }
 
@@ -334,7 +296,7 @@ uint32_t
 SBType::GetNumberOfFields ()
 {
     if (IsValid())
-        return ClangASTContext::GetNumFields(m_opaque_sp->GetASTContext(), m_opaque_sp->GetOpaqueQualType());
+        return m_opaque_sp->GetClangASTType().GetNumFields();
     return 0;
 }
 
@@ -361,13 +323,15 @@ SBType::GetDirectBaseClassAtIndex (uint32_t idx)
     SBTypeMember sb_type_member;
     if (IsValid())
     {
-        clang::ASTContext* ast = m_opaque_sp->GetASTContext();
-        uint32_t bit_offset = 0;
-        clang_type_t clang_type = ClangASTContext::GetDirectBaseClassAtIndex (ast, m_opaque_sp->GetOpaqueQualType(), idx, &bit_offset);
-        if (clang_type)
+        ClangASTType this_type (m_opaque_sp->GetClangASTType ());
+        if (this_type.IsValid())
         {
-            TypeImplSP type_impl_sp (new TypeImpl(ClangASTType (ast, clang_type)));
-            sb_type_member.reset (new TypeMemberImpl (type_impl_sp, bit_offset));
+            uint32_t bit_offset = 0;
+            ClangASTType base_class_type (this_type.GetDirectBaseClassAtIndex(idx, &bit_offset));
+            if (base_class_type.IsValid())
+            {
+                sb_type_member.reset (new TypeMemberImpl (TypeImplSP(new TypeImpl(base_class_type)), bit_offset));
+            }
         }
     }
     return sb_type_member;
@@ -380,14 +344,16 @@ SBType::GetVirtualBaseClassAtIndex (uint32_t idx)
     SBTypeMember sb_type_member;
     if (IsValid())
     {
-        uint32_t bit_offset = 0;
-        clang::ASTContext* ast = m_opaque_sp->GetASTContext();
-        clang_type_t clang_type = ClangASTContext::GetVirtualBaseClassAtIndex (ast, m_opaque_sp->GetOpaqueQualType(), idx, &bit_offset);
-        if (clang_type)
+        ClangASTType this_type (m_opaque_sp->GetClangASTType ());
+        if (this_type.IsValid())
         {
-            TypeImplSP type_impl_sp (new TypeImpl(ClangASTType (ast, clang_type)));
-            sb_type_member.reset (new TypeMemberImpl (type_impl_sp, bit_offset));
-        }        
+            uint32_t bit_offset = 0;
+            ClangASTType base_class_type (this_type.GetVirtualBaseClassAtIndex(idx, &bit_offset));
+            if (base_class_type.IsValid())
+            {
+                sb_type_member.reset (new TypeMemberImpl (TypeImplSP(new TypeImpl(base_class_type)), bit_offset));
+            }
+        }
     }
     return sb_type_member;
 }
@@ -398,20 +364,30 @@ SBType::GetFieldAtIndex (uint32_t idx)
     SBTypeMember sb_type_member;
     if (IsValid())
     {
-        uint64_t bit_offset = 0;
-        uint32_t bitfield_bit_size = 0;
-        bool is_bitfield = false;
-        clang::ASTContext* ast = m_opaque_sp->GetASTContext();
-        std::string name_sstr;
-        clang_type_t clang_type = ClangASTContext::GetFieldAtIndex (ast, m_opaque_sp->GetOpaqueQualType(), idx, name_sstr, &bit_offset, &bitfield_bit_size, &is_bitfield);
-        if (clang_type)
+        ClangASTType this_type (m_opaque_sp->GetClangASTType ());
+        if (this_type.IsValid())
         {
-            ConstString name;
-            if (!name_sstr.empty())
-                name.SetCString(name_sstr.c_str());
-            TypeImplSP type_impl_sp (new TypeImpl(ClangASTType (ast, clang_type)));
-            sb_type_member.reset (new TypeMemberImpl (type_impl_sp, bit_offset, name, bitfield_bit_size, is_bitfield));
-        }        
+            uint64_t bit_offset = 0;
+            uint32_t bitfield_bit_size = 0;
+            bool is_bitfield = false;
+            std::string name_sstr;
+            ClangASTType field_type (this_type.GetFieldAtIndex (idx,
+                                                                name_sstr,
+                                                                &bit_offset,
+                                                                &bitfield_bit_size,
+                                                                &is_bitfield));
+            if (field_type.IsValid())
+            {
+                ConstString name;
+                if (!name_sstr.empty())
+                    name.SetCString(name_sstr.c_str());
+                sb_type_member.reset (new TypeMemberImpl (TypeImplSP (new TypeImpl(field_type)),
+                                                          bit_offset,
+                                                          name,
+                                                          bitfield_bit_size,
+                                                          is_bitfield));
+            }
+        }
     }
     return sb_type_member;
 }
@@ -420,9 +396,8 @@ bool
 SBType::IsTypeComplete()
 {
     if (!IsValid())
-        return false;
-    
-    return ClangASTContext::IsCompleteType(m_opaque_sp->GetASTContext(), m_opaque_sp->GetOpaqueQualType());
+        return false;    
+    return m_opaque_sp->GetClangASTType().IsCompleteType();
 }
 
 const char*
@@ -430,17 +405,14 @@ SBType::GetName()
 {
     if (!IsValid())
         return "";
-
-    return ClangASTType::GetConstTypeName(m_opaque_sp->GetASTContext(),
-                                          m_opaque_sp->GetOpaqueQualType()).GetCString();
+    return m_opaque_sp->GetClangASTType().GetConstTypeName().GetCString();
 }
 
 lldb::TypeClass
 SBType::GetTypeClass ()
 {
     if (IsValid())
-        return ClangASTType::GetTypeClass (m_opaque_sp->GetASTContext(),
-                                           m_opaque_sp->GetOpaqueQualType());
+        return m_opaque_sp->GetClangASTType().GetTypeClass();
     return lldb::eTypeClassInvalid;
 }
 
@@ -448,10 +420,7 @@ uint32_t
 SBType::GetNumberOfTemplateArguments ()
 {
     if (IsValid())
-    {
-        return ClangASTContext::GetNumTemplateArguments (m_opaque_sp->GetASTContext(),
-                                                         m_opaque_sp->GetOpaqueQualType());
-    }
+        return m_opaque_sp->GetClangASTType().GetNumTemplateArguments();
     return 0;
 }
 
@@ -461,11 +430,9 @@ SBType::GetTemplateArgumentType (uint32_t idx)
     if (IsValid())
     {
         TemplateArgumentKind kind = eTemplateArgumentKindNull;
-        return SBType(ClangASTType(m_opaque_sp->GetASTContext(),
-                                   ClangASTContext::GetTemplateArgument(m_opaque_sp->GetASTContext(),
-                                                                        m_opaque_sp->GetOpaqueQualType(), 
-                                                                        idx, 
-                                                                        kind)));
+        ClangASTType template_arg_type = m_opaque_sp->GetClangASTType().GetTemplateArgument (idx, kind);
+        if (template_arg_type.IsValid())
+            return SBType(template_arg_type);
     }
     return SBType();
 }
@@ -476,18 +443,11 @@ SBType::GetTemplateArgumentKind (uint32_t idx)
 {
     TemplateArgumentKind kind = eTemplateArgumentKindNull;
     if (IsValid())
-    {
-        ClangASTContext::GetTemplateArgument(m_opaque_sp->GetASTContext(),
-                                             m_opaque_sp->GetOpaqueQualType(), 
-                                             idx, 
-                                             kind);
-    }
+        m_opaque_sp->GetClangASTType().GetTemplateArgument (idx, kind);
     return kind;
 }
 
 
-
-
 SBTypeList::SBTypeList() :
     m_opaque_ap(new TypeListImpl())
 {
@@ -543,20 +503,6 @@ SBTypeList::~SBTypeList()
 {
 }
 
-bool
-SBType::IsPointerType (void *opaque_type)
-{
-    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    
-    bool ret_value = ClangASTContext::IsPointerType (opaque_type);
-    
-    if (log)
-        log->Printf ("SBType::IsPointerType (opaque_type=%p) ==> '%s'", opaque_type, (ret_value ? "true" : "false"));
-    
-    return ret_value;
-}
-
-
 SBTypeMember::SBTypeMember() :
     m_opaque_ap()
 {
diff --git a/lldb/source/API/SBValue.cpp b/lldb/source/API/SBValue.cpp
index 33608f3ebeb..aa9b23ac7c6 100644
--- a/lldb/source/API/SBValue.cpp
+++ b/lldb/source/API/SBValue.cpp
@@ -473,7 +473,7 @@ SBValue::GetType()
     TypeImplSP type_sp;
     if (value_sp)
     {
-        type_sp.reset (new TypeImpl(ClangASTType (value_sp->GetClangAST(), value_sp->GetClangType())));
+        type_sp.reset (new TypeImpl(value_sp->GetClangType()));
         sb_type.SetSP(type_sp);
     }
     if (log)
@@ -761,17 +761,14 @@ SBValue::CreateValueFromAddress(const char* name, lldb::addr_t address, SBType s
     lldb::TypeImplSP type_impl_sp (sb_type.GetSP());
     if (value_sp && type_impl_sp)
     {
-        ClangASTType pointee_ast_type(type_impl_sp->GetASTContext(), type_impl_sp->GetClangASTType().GetPointerType ());
-        lldb::TypeImplSP pointee_type_impl_sp (new TypeImpl(pointee_ast_type));
-        if (pointee_type_impl_sp)
+        ClangASTType pointee_ast_type(type_impl_sp->GetClangASTType().GetPointerType ());
+        if (pointee_ast_type)
         {
-        
             lldb::DataBufferSP buffer(new lldb_private::DataBufferHeap(&address,sizeof(lldb::addr_t)));
         
             ExecutionContext exe_ctx (value_sp->GetExecutionContextRef());
             ValueObjectSP ptr_result_valobj_sp(ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(),
-                                                                               pointee_type_impl_sp->GetASTContext(),
-                                                                               pointee_type_impl_sp->GetOpaqueQualType(),
+                                                                               pointee_ast_type,
                                                                                ConstString(name),
                                                                                buffer,
                                                                                lldb::endian::InlHostByteOrder(), 
@@ -811,8 +808,7 @@ SBValue::CreateValueFromData (const char* name, SBData data, SBType type)
         ExecutionContext exe_ctx (value_sp->GetExecutionContextRef());
 
         new_value_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(),
-                                                       type.m_opaque_sp->GetASTContext() ,
-                                                       type.m_opaque_sp->GetOpaqueQualType(),
+                                                       type.m_opaque_sp->GetClangASTType(),
                                                        ConstString(name),
                                                        *data.m_opaque_sp,
                                                        LLDB_INVALID_ADDRESS);
@@ -1187,7 +1183,7 @@ SBValue::GetOpaqueType()
     ValueLocker locker;
     lldb::ValueObjectSP value_sp(GetSP(locker));
     if (value_sp)
-        return value_sp->GetClangType();
+        return value_sp->GetClangType().GetOpaqueQualType();
     return NULL;
 }
 
@@ -1665,7 +1661,7 @@ SBValue::Watch (bool resolve_location, bool read, bool write, SBError &error)
             watch_type |= LLDB_WATCH_TYPE_WRITE;
         
         Error rc;
-        ClangASTType type (value_sp->GetClangAST(), value_sp->GetClangType());
+        ClangASTType type (value_sp->GetClangType());
         WatchpointSP watchpoint_sp = target_sp->CreateWatchpoint(addr, byte_size, &type, watch_type, rc);
         error.SetError(rc);