ClangASTType is now CompilerType.

This is more preparation for multiple different kinds of types from different compilers (clang, Pascal, Go, RenderScript, Swift, etc).

llvm-svn: 244689

13 files changed, 92 insertions, 92 deletions

diff --git a/lldb/source/Core/Value.cpp b/lldb/source/Core/Value.cpp
index a416d0745a6..0b2bb4899d7 100644
--- a/lldb/source/Core/Value.cpp
+++ b/lldb/source/Core/Value.cpp
@@ -18,7 +18,7 @@
 #include "lldb/Core/Module.h"
 #include "lldb/Core/State.h"
 #include "lldb/Core/Stream.h"
-#include "lldb/Symbol/ClangASTType.h"
+#include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
@@ -275,7 +275,7 @@ Value::GetValueByteSize (Error *error_ptr)
     case eContextTypeLLDBType:         // Type *
     case eContextTypeVariable:         // Variable *
         {
-            const ClangASTType &ast_type = GetClangType();
+            const CompilerType &ast_type = GetClangType();
             if (ast_type.IsValid())
                 byte_size = ast_type.GetByteSize(nullptr);
         }
@@ -297,7 +297,7 @@ Value::GetValueByteSize (Error *error_ptr)
     return byte_size;
 }
 
-const ClangASTType &
+const CompilerType &
 Value::GetClangType ()
 {
     if (!m_clang_type.IsValid())
@@ -336,7 +336,7 @@ Value::GetClangType ()
 }
 
 void
-Value::SetClangType (const ClangASTType &clang_type)
+Value::SetClangType (const CompilerType &clang_type)
 {
     m_clang_type = clang_type;
 }
@@ -355,7 +355,7 @@ Value::GetValueDefaultFormat ()
     case eContextTypeLLDBType:
     case eContextTypeVariable:
         {
-            const ClangASTType &ast_type = GetClangType();
+            const CompilerType &ast_type = GetClangType();
             if (ast_type.IsValid())
                 return ast_type.GetFormat();
         }
@@ -407,7 +407,7 @@ Value::GetValueAsData (ExecutionContext *exe_ctx,
     lldb::addr_t address = LLDB_INVALID_ADDRESS;
     AddressType address_type = eAddressTypeFile;
     Address file_so_addr;
-    const ClangASTType &ast_type = GetClangType();
+    const CompilerType &ast_type = GetClangType();
     switch (m_value_type)
     {
     case eValueTypeVector:
@@ -721,7 +721,7 @@ Value::GetValueAsData (ExecutionContext *exe_ctx,
 Scalar &
 Value::ResolveValue(ExecutionContext *exe_ctx)
 {
-    const ClangASTType &clang_type = GetClangType();
+    const CompilerType &clang_type = GetClangType();
     if (clang_type.IsValid())
     {
         switch (m_value_type)
diff --git a/lldb/source/Core/ValueObject.cpp b/lldb/source/Core/ValueObject.cpp
index ba738bf3f76..3d757bd4a07 100644
--- a/lldb/source/Core/ValueObject.cpp
+++ b/lldb/source/Core/ValueObject.cpp
@@ -42,7 +42,7 @@
 
 #include "lldb/Interpreter/CommandInterpreter.h"
 
-#include "lldb/Symbol/ClangASTType.h"
+#include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Type.h"
@@ -316,16 +316,16 @@ ValueObject::ClearDynamicTypeInformation ()
     m_children_count_valid = false;
     m_did_calculate_complete_objc_class_type = false;
     m_last_format_mgr_revision = 0;
-    m_override_type = ClangASTType();
+    m_override_type = CompilerType();
     SetValueFormat(lldb::TypeFormatImplSP());
     SetSummaryFormat(lldb::TypeSummaryImplSP());
     SetSyntheticChildren(lldb::SyntheticChildrenSP());
 }
 
-ClangASTType
+CompilerType
 ValueObject::MaybeCalculateCompleteType ()
 {
-    ClangASTType clang_type(GetClangTypeImpl());
+    CompilerType clang_type(GetClangTypeImpl());
         
     if (m_did_calculate_complete_objc_class_type)
     {
@@ -335,7 +335,7 @@ ValueObject::MaybeCalculateCompleteType ()
             return clang_type;
     }
     
-    ClangASTType class_type;
+    CompilerType class_type;
     bool is_pointer_type = false;
     
     if (ClangASTContext::IsObjCObjectPointerType(clang_type, &class_type))
@@ -371,7 +371,7 @@ ValueObject::MaybeCalculateCompleteType ()
                     
                     if (complete_objc_class_type_sp)
                     {
-                        ClangASTType complete_class(complete_objc_class_type_sp->GetClangFullType());
+                        CompilerType complete_class(complete_objc_class_type_sp->GetClangFullType());
                         
                         if (complete_class.GetCompleteType())
                         {
@@ -395,7 +395,7 @@ ValueObject::MaybeCalculateCompleteType ()
     return clang_type;
 }
 
-ClangASTType
+CompilerType
 ValueObject::GetClangType ()
 {
     return MaybeCalculateCompleteType();
@@ -830,7 +830,7 @@ ValueObject::CreateChildAtIndex (size_t idx, bool synthetic_array_member, int32_
     bool child_is_deref_of_parent = false;
 
     const bool transparent_pointers = synthetic_array_member == false;
-    ClangASTType child_clang_type;
+    CompilerType child_clang_type;
     
     ExecutionContext exe_ctx (GetExecutionContextRef());
     
@@ -937,7 +937,7 @@ ValueObject::GetSummaryAsCString (std::string& destination,
 bool
 ValueObject::IsCStringContainer(bool check_pointer)
 {
-    ClangASTType pointee_or_element_clang_type;
+    CompilerType pointee_or_element_clang_type;
     const Flags type_flags (GetTypeInfo (&pointee_or_element_clang_type));
     bool is_char_arr_ptr (type_flags.AnySet (eTypeIsArray | eTypeIsPointer) &&
                           pointee_or_element_clang_type.IsCharType ());
@@ -958,7 +958,7 @@ ValueObject::GetPointeeData (DataExtractor& data,
                              uint32_t item_idx,
                              uint32_t item_count)
 {
-    ClangASTType pointee_or_element_clang_type;
+    CompilerType pointee_or_element_clang_type;
     const uint32_t type_info = GetTypeInfo (&pointee_or_element_clang_type);
     const bool is_pointer_type = type_info & eTypeIsPointer;
     const bool is_array_type = type_info & eTypeIsArray;
@@ -1226,8 +1226,8 @@ ValueObject::ReadPointedString (lldb::DataBufferSP& buffer_sp,
     size_t bytes_read = 0;
     size_t total_bytes_read = 0;
     
-    ClangASTType clang_type = GetClangType();
-    ClangASTType elem_or_pointee_clang_type;
+    CompilerType clang_type = GetClangType();
+    CompilerType elem_or_pointee_clang_type;
     const Flags type_flags (GetTypeInfo (&elem_or_pointee_clang_type));
     if (type_flags.AnySet (eTypeIsArray | eTypeIsPointer) &&
         elem_or_pointee_clang_type.IsCharType ())
@@ -1385,7 +1385,7 @@ ValueObject::GetObjectDescription ()
     if (runtime == NULL)
     {
         // Aw, hell, if the things a pointer, or even just an integer, let's try ObjC anyway...
-        ClangASTType clang_type = GetClangType();
+        CompilerType clang_type = GetClangType();
         if (clang_type)
         {
             bool is_signed;
@@ -2023,7 +2023,7 @@ ValueObject::GetSyntheticChild (const ConstString &key) const
 }
 
 uint32_t
-ValueObject::GetTypeInfo (ClangASTType *pointee_or_element_clang_type)
+ValueObject::GetTypeInfo (CompilerType *pointee_or_element_clang_type)
 {
     return GetClangType().GetTypeInfo (pointee_or_element_clang_type);
 }
@@ -2180,7 +2180,7 @@ ValueObject::GetSyntheticBitFieldChild (uint32_t from, uint32_t to, bool can_cre
 }
 
 ValueObjectSP
-ValueObject::GetSyntheticChildAtOffset(uint32_t offset, const ClangASTType& type, bool can_create)
+ValueObject::GetSyntheticChildAtOffset(uint32_t offset, const CompilerType& type, bool can_create)
 {
     
     ValueObjectSP synthetic_child_sp;
@@ -2222,7 +2222,7 @@ ValueObject::GetSyntheticChildAtOffset(uint32_t offset, const ClangASTType& type
 }
 
 ValueObjectSP
-ValueObject::GetSyntheticBase (uint32_t offset, const ClangASTType& type, bool can_create)
+ValueObject::GetSyntheticBase (uint32_t offset, const CompilerType& type, bool can_create)
 {
     ValueObjectSP synthetic_child_sp;
     
@@ -2417,7 +2417,7 @@ ValueObject::GetBaseClassPath (Stream &s)
     if (IsBaseClass())
     {
         bool parent_had_base_class = GetParent() && GetParent()->GetBaseClassPath (s);
-        ClangASTType clang_type = GetClangType();
+        CompilerType clang_type = GetClangType();
         std::string cxx_class_name;
         bool this_had_base_class = ClangASTContext::GetCXXClassName (clang_type, cxx_class_name);
         if (this_had_base_class)
@@ -2536,7 +2536,7 @@ ValueObject::GetExpressionPath (Stream &s, bool qualify_cxx_base_classes, GetExp
             ValueObject *non_base_class_parent = GetNonBaseClassParent();
             if (non_base_class_parent)
             {
-                ClangASTType non_base_class_parent_clang_type = non_base_class_parent->GetClangType();
+                CompilerType non_base_class_parent_clang_type = non_base_class_parent->GetClangType();
                 if (non_base_class_parent_clang_type)
                 {
                     if (parent && parent->IsDereferenceOfParent() && epformat == eGetExpressionPathFormatHonorPointers)
@@ -2757,8 +2757,8 @@ ValueObject::GetValueForExpressionPath_Impl(const char* expression_cstr,
         
         const char* expression_cstr = *first_unparsed; // hide the top level expression_cstr
         
-        ClangASTType root_clang_type = root->GetClangType();
-        ClangASTType pointee_clang_type;
+        CompilerType root_clang_type = root->GetClangType();
+        CompilerType pointee_clang_type;
         Flags pointee_clang_type_info;
         
         Flags root_clang_type_info(root_clang_type.GetTypeInfo(&pointee_clang_type));
@@ -3281,8 +3281,8 @@ ValueObject::ExpandArraySliceExpression(const char* expression_cstr,
         
         const char* expression_cstr = *first_unparsed; // hide the top level expression_cstr
         
-        ClangASTType root_clang_type = root->GetClangType();
-        ClangASTType pointee_clang_type;
+        CompilerType root_clang_type = root->GetClangType();
+        CompilerType pointee_clang_type;
         Flags pointee_clang_type_info;
         Flags root_clang_type_info(root_clang_type.GetTypeInfo(&pointee_clang_type));
         if (pointee_clang_type)
@@ -3677,8 +3677,8 @@ ValueObject::GetQualifiedRepresentationIfAvailable (lldb::DynamicValueType dynVa
 lldb::addr_t
 ValueObject::GetCPPVTableAddress (AddressType &address_type)
 {
-    ClangASTType pointee_type;
-    ClangASTType this_type(GetClangType());
+    CompilerType pointee_type;
+    CompilerType this_type(GetClangType());
     uint32_t type_info = this_type.GetTypeInfo(&pointee_type);
     if (type_info)
     {
@@ -3726,8 +3726,8 @@ ValueObject::Dereference (Error &error)
         bool child_is_base_class = false;
         bool child_is_deref_of_parent = false;
         const bool transparent_pointers = false;
-        ClangASTType clang_type = GetClangType();
-        ClangASTType child_clang_type;
+        CompilerType clang_type = GetClangType();
+        CompilerType child_clang_type;
 
         ExecutionContext exe_ctx (GetExecutionContextRef());
 
@@ -3806,7 +3806,7 @@ ValueObject::AddressOf (Error &error)
         case eAddressTypeFile:
         case eAddressTypeLoad:
             {
-                ClangASTType clang_type = GetClangType();
+                CompilerType clang_type = GetClangType();
                 if (clang_type)
                 {
                     std::string name (1, '&');
@@ -3836,13 +3836,13 @@ ValueObject::AddressOf (Error &error)
 }
 
 ValueObjectSP
-ValueObject::Cast (const ClangASTType &clang_ast_type)
+ValueObject::Cast (const CompilerType &clang_ast_type)
 {
     return ValueObjectCast::Create (*this, GetName(), clang_ast_type);
 }
 
 ValueObjectSP
-ValueObject::CastPointerType (const char *name, ClangASTType &clang_ast_type)
+ValueObject::CastPointerType (const char *name, CompilerType &clang_ast_type)
 {
     ValueObjectSP valobj_sp;
     AddressType address_type;
@@ -4104,11 +4104,11 @@ lldb::ValueObjectSP
 ValueObject::CreateValueObjectFromAddress (const char* name,
                                            uint64_t address,
                                            const ExecutionContext& exe_ctx,
-                                           ClangASTType type)
+                                           CompilerType type)
 {
     if (type)
     {
-        ClangASTType pointer_type(type.GetPointerType());
+        CompilerType pointer_type(type.GetPointerType());
         if (pointer_type)
         {
             lldb::DataBufferSP buffer(new lldb_private::DataBufferHeap(&address,sizeof(lldb::addr_t)));
@@ -4136,7 +4136,7 @@ lldb::ValueObjectSP
 ValueObject::CreateValueObjectFromData (const char* name,
                                         const DataExtractor& data,
                                         const ExecutionContext& exe_ctx,
-                                        ClangASTType type)
+                                        CompilerType type)
 {
     lldb::ValueObjectSP new_value_sp;
     new_value_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(),
@@ -4258,7 +4258,7 @@ ValueObject::CanProvideValue ()
     // we need to support invalid types as providers of values because some bare-board
     // debugging scenarios have no notion of types, but still manage to have raw numeric
     // values for things like registers. sigh.
-    const ClangASTType &type(GetClangType());
+    const CompilerType &type(GetClangType());
     return (false == type.IsValid()) || (0 != (type.GetTypeInfo() & eTypeHasValue));
 }
 
diff --git a/lldb/source/Core/ValueObjectCast.cpp b/lldb/source/Core/ValueObjectCast.cpp
index b20371b128d..6b6f67e08f0 100644
--- a/lldb/source/Core/ValueObjectCast.cpp
+++ b/lldb/source/Core/ValueObjectCast.cpp
@@ -20,7 +20,7 @@
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObject.h"
 
-#include "lldb/Symbol/ClangASTType.h"
+#include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/Type.h"
@@ -38,7 +38,7 @@ using namespace lldb_private;
 lldb::ValueObjectSP
 ValueObjectCast::Create (ValueObject &parent, 
                          const ConstString &name, 
-                         const ClangASTType &cast_type)
+                         const CompilerType &cast_type)
 {
     ValueObjectCast *cast_valobj_ptr = new ValueObjectCast (parent, name, cast_type);
     return cast_valobj_ptr->GetSP();
@@ -48,7 +48,7 @@ ValueObjectCast::ValueObjectCast
 (
     ValueObject &parent, 
     const ConstString &name, 
-    const ClangASTType &cast_type
+    const CompilerType &cast_type
 ) :
     ValueObject(parent),
     m_cast_type (cast_type)
@@ -62,7 +62,7 @@ ValueObjectCast::~ValueObjectCast()
 {
 }
 
-ClangASTType
+CompilerType
 ValueObjectCast::GetClangTypeImpl ()
 {
     return m_cast_type;
@@ -98,7 +98,7 @@ ValueObjectCast::UpdateValue ()
         Value old_value(m_value);
         m_update_point.SetUpdated();
         m_value = m_parent->GetValue();
-        ClangASTType clang_type (GetClangType());
+        CompilerType clang_type (GetClangType());
         //m_value.SetContext (Value::eContextTypeClangType, clang_type);
         m_value.SetClangType (clang_type);
         SetAddressTypeOfChildren(m_parent->GetAddressTypeOfChildren());
diff --git a/lldb/source/Core/ValueObjectChild.cpp b/lldb/source/Core/ValueObjectChild.cpp
index dd7e05715d6..92b0ad44a17 100644
--- a/lldb/source/Core/ValueObjectChild.cpp
+++ b/lldb/source/Core/ValueObjectChild.cpp
@@ -12,7 +12,7 @@
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ValueObjectList.h"
 
-#include "lldb/Symbol/ClangASTType.h"
+#include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/Type.h"
@@ -27,7 +27,7 @@ using namespace lldb_private;
 ValueObjectChild::ValueObjectChild
 (
     ValueObject &parent,
-    const ClangASTType &clang_type,
+    const CompilerType &clang_type,
     const ConstString &name,
     uint64_t byte_size,
     int32_t byte_offset,
diff --git a/lldb/source/Core/ValueObjectConstResult.cpp b/lldb/source/Core/ValueObjectConstResult.cpp
index 7aec555617d..3fb1cfb25c7 100644
--- a/lldb/source/Core/ValueObjectConstResult.cpp
+++ b/lldb/source/Core/ValueObjectConstResult.cpp
@@ -16,7 +16,7 @@
 #include "lldb/Core/ValueObjectDynamicValue.h"
 #include "lldb/Core/ValueObjectList.h"
 
-#include "lldb/Symbol/ClangASTType.h"
+#include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/Type.h"
@@ -61,7 +61,7 @@ ValueObjectSP
 ValueObjectConstResult::Create
 (
     ExecutionContextScope *exe_scope,
-    const ClangASTType &clang_type,
+    const CompilerType &clang_type,
     const ConstString &name,
     const DataExtractor &data,
     lldb::addr_t address
@@ -75,7 +75,7 @@ ValueObjectConstResult::Create
 }
 
 ValueObjectConstResult::ValueObjectConstResult (ExecutionContextScope *exe_scope,
-                                                const ClangASTType &clang_type,
+                                                const CompilerType &clang_type,
                                                 const ConstString &name,
                                                 const DataExtractor &data,
                                                 lldb::addr_t address) :
@@ -103,7 +103,7 @@ ValueObjectConstResult::ValueObjectConstResult (ExecutionContextScope *exe_scope
 
 ValueObjectSP
 ValueObjectConstResult::Create (ExecutionContextScope *exe_scope,
-                                const ClangASTType &clang_type,
+                                const CompilerType &clang_type,
                                 const ConstString &name,
                                 const lldb::DataBufferSP &data_sp,
                                 lldb::ByteOrder data_byte_order,
@@ -129,7 +129,7 @@ ValueObjectConstResult::Create (ExecutionContextScope *exe_scope,
 }
 
 ValueObjectConstResult::ValueObjectConstResult (ExecutionContextScope *exe_scope,
-                                                const ClangASTType &clang_type,
+                                                const CompilerType &clang_type,
                                                 const ConstString &name,
                                                 const lldb::DataBufferSP &data_sp,
                                                 lldb::ByteOrder data_byte_order, 
@@ -155,7 +155,7 @@ ValueObjectConstResult::ValueObjectConstResult (ExecutionContextScope *exe_scope
 
 ValueObjectSP
 ValueObjectConstResult::Create (ExecutionContextScope *exe_scope,
-                                const ClangASTType &clang_type,
+                                const CompilerType &clang_type,
                                 const ConstString &name,
                                 lldb::addr_t address,
                                 AddressType address_type,
@@ -170,7 +170,7 @@ ValueObjectConstResult::Create (ExecutionContextScope *exe_scope,
 }
 
 ValueObjectConstResult::ValueObjectConstResult (ExecutionContextScope *exe_scope,
-                                                const ClangASTType &clang_type,
+                                                const CompilerType &clang_type,
                                                 const ConstString &name,
                                                 lldb::addr_t address,
                                                 AddressType address_type,
@@ -241,7 +241,7 @@ ValueObjectConstResult::~ValueObjectConstResult()
 {
 }
 
-ClangASTType
+CompilerType
 ValueObjectConstResult::GetClangTypeImpl()
 {
     return m_value.GetClangType();
@@ -313,7 +313,7 @@ ValueObjectConstResult::Dereference (Error &error)
 }
 
 lldb::ValueObjectSP
-ValueObjectConstResult::GetSyntheticChildAtOffset(uint32_t offset, const ClangASTType& type, bool can_create)
+ValueObjectConstResult::GetSyntheticChildAtOffset(uint32_t offset, const CompilerType& type, bool can_create)
 {
     return m_impl.GetSyntheticChildAtOffset(offset, type, can_create);
 }
@@ -366,7 +366,7 @@ ValueObjectConstResult::GetDynamicValue (lldb::DynamicValueType use_dynamic)
 }
 
 lldb::ValueObjectSP
-ValueObjectConstResult::Cast (const ClangASTType &clang_ast_type)
+ValueObjectConstResult::Cast (const CompilerType &clang_ast_type)
 {
     return m_impl.Cast(clang_ast_type);
 }
diff --git a/lldb/source/Core/ValueObjectConstResultCast.cpp b/lldb/source/Core/ValueObjectConstResultCast.cpp
index 32123f94f36..0c61cd1955c 100644
--- a/lldb/source/Core/ValueObjectConstResultCast.cpp
+++ b/lldb/source/Core/ValueObjectConstResultCast.cpp
@@ -19,7 +19,7 @@ using namespace lldb_private;
 ValueObjectConstResultCast::ValueObjectConstResultCast(
     ValueObject &parent,
     const ConstString &name,
-    const ClangASTType &cast_type,
+    const CompilerType &cast_type,
     lldb::addr_t live_address) :
     ValueObjectCast (parent, name, cast_type),
     m_impl(this, live_address)
@@ -39,7 +39,7 @@ ValueObjectConstResultCast::Dereference (Error &error)
 
 lldb::ValueObjectSP
 ValueObjectConstResultCast::GetSyntheticChildAtOffset(uint32_t offset,
-                                                      const ClangASTType& type,
+                                                      const CompilerType& type,
                                                       bool can_create)
 {
     return m_impl.GetSyntheticChildAtOffset(offset, type, can_create);
@@ -69,7 +69,7 @@ ValueObjectConstResultCast::GetPointeeData (DataExtractor& data,
 }
 
 lldb::ValueObjectSP
-ValueObjectConstResultCast::Cast (const ClangASTType &clang_ast_type)
+ValueObjectConstResultCast::Cast (const CompilerType &clang_ast_type)
 {
     return m_impl.Cast(clang_ast_type);
 }
diff --git a/lldb/source/Core/ValueObjectConstResultChild.cpp b/lldb/source/Core/ValueObjectConstResultChild.cpp
index 8bf49e8a5a6..ca06cc6a9c4 100644
--- a/lldb/source/Core/ValueObjectConstResultChild.cpp
+++ b/lldb/source/Core/ValueObjectConstResultChild.cpp
@@ -19,7 +19,7 @@ using namespace lldb_private;
 ValueObjectConstResultChild::ValueObjectConstResultChild
 (
     ValueObject &parent,
-    const ClangASTType &clang_type,
+    const CompilerType &clang_type,
     const ConstString &name,
     uint32_t byte_size,
     int32_t byte_offset,
@@ -55,7 +55,7 @@ ValueObjectConstResultChild::Dereference (Error &error)
 }
 
 lldb::ValueObjectSP
-ValueObjectConstResultChild::GetSyntheticChildAtOffset(uint32_t offset, const ClangASTType& type, bool can_create)
+ValueObjectConstResultChild::GetSyntheticChildAtOffset(uint32_t offset, const CompilerType& type, bool can_create)
 {
     return m_impl.GetSyntheticChildAtOffset(offset, type, can_create);
 }
@@ -81,7 +81,7 @@ ValueObjectConstResultChild::GetPointeeData (DataExtractor& data,
 }
 
 lldb::ValueObjectSP
-ValueObjectConstResultChild::Cast (const ClangASTType &clang_ast_type)
+ValueObjectConstResultChild::Cast (const CompilerType &clang_ast_type)
 {
     return m_impl.Cast(clang_ast_type);
 }
diff --git a/lldb/source/Core/ValueObjectConstResultImpl.cpp b/lldb/source/Core/ValueObjectConstResultImpl.cpp
index 7355063bb6f..eb02fe4f439 100644
--- a/lldb/source/Core/ValueObjectConstResultImpl.cpp
+++ b/lldb/source/Core/ValueObjectConstResultImpl.cpp
@@ -18,7 +18,7 @@
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ValueObjectList.h"
 
-#include "lldb/Symbol/ClangASTType.h"
+#include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/Type.h"
@@ -71,8 +71,8 @@ ValueObjectConstResultImpl::CreateChildAtIndex (size_t idx, bool synthetic_array
     bool child_is_deref_of_parent = false;
     
     const bool transparent_pointers = synthetic_array_member == false;
-    ClangASTType clang_type = m_impl_backend->GetClangType();
-    ClangASTType child_clang_type;
+    CompilerType clang_type = m_impl_backend->GetClangType();
+    CompilerType child_clang_type;
     
     ExecutionContext exe_ctx (m_impl_backend->GetExecutionContextRef());
     
@@ -114,7 +114,7 @@ ValueObjectConstResultImpl::CreateChildAtIndex (size_t idx, bool synthetic_array
 }
 
 lldb::ValueObjectSP
-ValueObjectConstResultImpl::GetSyntheticChildAtOffset (uint32_t offset, const ClangASTType& type, bool can_create)
+ValueObjectConstResultImpl::GetSyntheticChildAtOffset (uint32_t offset, const CompilerType& type, bool can_create)
 {
     if (m_impl_backend == NULL)
         return lldb::ValueObjectSP();
@@ -132,7 +132,7 @@ ValueObjectConstResultImpl::AddressOf (Error &error)
         return lldb::ValueObjectSP();
     if (m_live_address != LLDB_INVALID_ADDRESS)
     {
-        ClangASTType clang_type(m_impl_backend->GetClangType());
+        CompilerType clang_type(m_impl_backend->GetClangType());
         
         lldb::DataBufferSP buffer(new lldb_private::DataBufferHeap(&m_live_address,sizeof(lldb::addr_t)));
         
@@ -156,7 +156,7 @@ ValueObjectConstResultImpl::AddressOf (Error &error)
 }
 
 lldb::ValueObjectSP
-ValueObjectConstResultImpl::Cast (const ClangASTType &clang_ast_type)
+ValueObjectConstResultImpl::Cast (const CompilerType &clang_ast_type)
 {
     if (m_impl_backend == NULL)
         return lldb::ValueObjectSP();
diff --git a/lldb/source/Core/ValueObjectDynamicValue.cpp b/lldb/source/Core/ValueObjectDynamicValue.cpp
index 9eaa6c3756d..80c16c84ca4 100644
--- a/lldb/source/Core/ValueObjectDynamicValue.cpp
+++ b/lldb/source/Core/ValueObjectDynamicValue.cpp
@@ -20,7 +20,7 @@
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObject.h"
 
-#include "lldb/Symbol/ClangASTType.h"
+#include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/Type.h"
@@ -49,7 +49,7 @@ ValueObjectDynamicValue::~ValueObjectDynamicValue()
     m_owning_valobj_sp.reset();
 }
 
-ClangASTType
+CompilerType
 ValueObjectDynamicValue::GetClangTypeImpl ()
 {
     const bool success = UpdateValueIfNeeded(false);
@@ -149,13 +149,13 @@ FixupTypeAndOrName (const TypeAndOrName& type_andor_name,
         // The type will always be the type of the dynamic object.  If our parent's type was a pointer,
         // then our type should be a pointer to the type of the dynamic object.  If a reference, then the original type
         // should be okay...
-        ClangASTType orig_type = type_andor_name.GetClangASTType();
-        ClangASTType corrected_type = orig_type;
+        CompilerType orig_type = type_andor_name.GetCompilerType();
+        CompilerType corrected_type = orig_type;
         if (parent.IsPointerType())
             corrected_type = orig_type.GetPointerType ();
         else if (parent.IsPointerOrReferenceType())
             corrected_type = ClangASTContext::GetLValueReferenceType(orig_type);
-        ret.SetClangASTType(corrected_type);
+        ret.SetCompilerType(corrected_type);
     }
     else /*if (m_dynamic_type_info.HasName())*/
     {
@@ -166,7 +166,7 @@ FixupTypeAndOrName (const TypeAndOrName& type_andor_name,
         else if (parent.IsPointerOrReferenceType())
             corrected_name.append(" &");
         // the parent type should be a correctly pointer'ed or referenc'ed type
-        ret.SetClangASTType(parent.GetClangType());
+        ret.SetCompilerType(parent.GetClangType());
         ret.SetName(corrected_name.c_str());
     }
     return ret;
@@ -241,7 +241,7 @@ ValueObjectDynamicValue::UpdateValue ()
     {
         if (class_type_or_name.HasType())
         {
-            m_type_impl = TypeImpl(m_parent->GetClangType(),FixupTypeAndOrName(class_type_or_name, *m_parent).GetClangASTType());
+            m_type_impl = TypeImpl(m_parent->GetClangType(),FixupTypeAndOrName(class_type_or_name, *m_parent).GetCompilerType());
         }
         else
         {
@@ -303,7 +303,7 @@ ValueObjectDynamicValue::UpdateValue ()
     m_dynamic_type_info = FixupTypeAndOrName(m_dynamic_type_info, *m_parent);
 
     //m_value.SetContext (Value::eContextTypeClangType, corrected_type);
-    m_value.SetClangType (m_dynamic_type_info.GetClangASTType());
+    m_value.SetClangType (m_dynamic_type_info.GetCompilerType());
 
     // Our address is the location of the dynamic type stored in memory.  It isn't a load address,
     // because we aren't pointing to the LOCATION that stores the pointer to us, we're pointing to us...
diff --git a/lldb/source/Core/ValueObjectMemory.cpp b/lldb/source/Core/ValueObjectMemory.cpp
index 31a8d5c1f4f..8ad0d344e05 100644
--- a/lldb/source/Core/ValueObjectMemory.cpp
+++ b/lldb/source/Core/ValueObjectMemory.cpp
@@ -46,7 +46,7 @@ ValueObjectSP
 ValueObjectMemory::Create (ExecutionContextScope *exe_scope, 
                            const char *name,
                            const Address &address, 
-                           const ClangASTType &ast_type)
+                           const CompilerType &ast_type)
 {
     return (new ValueObjectMemory (exe_scope, name, address, ast_type))->GetSP();
 }
@@ -90,7 +90,7 @@ ValueObjectMemory::ValueObjectMemory (ExecutionContextScope *exe_scope,
 ValueObjectMemory::ValueObjectMemory (ExecutionContextScope *exe_scope,
                                       const char *name, 
                                       const Address &address,
-                                      const ClangASTType &ast_type) :
+                                      const CompilerType &ast_type) :
     ValueObject(exe_scope),
     m_address (address),
     m_type_sp(),
@@ -131,7 +131,7 @@ ValueObjectMemory::~ValueObjectMemory()
 {
 }
 
-ClangASTType
+CompilerType
 ValueObjectMemory::GetClangTypeImpl ()
 {
     if (m_type_sp)
diff --git a/lldb/source/Core/ValueObjectRegister.cpp b/lldb/source/Core/ValueObjectRegister.cpp
index 0db1f0cd45c..4f9e0f01505 100644
--- a/lldb/source/Core/ValueObjectRegister.cpp
+++ b/lldb/source/Core/ValueObjectRegister.cpp
@@ -15,7 +15,7 @@
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Module.h"
-#include "lldb/Symbol/ClangASTType.h"
+#include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Target/ExecutionContext.h"
@@ -42,10 +42,10 @@ ValueObjectRegisterContext::~ValueObjectRegisterContext()
 {
 }
 
-ClangASTType
+CompilerType
 ValueObjectRegisterContext::GetClangTypeImpl ()
 {
-    return ClangASTType();
+    return CompilerType();
 }
 
 ConstString
@@ -144,10 +144,10 @@ ValueObjectRegisterSet::~ValueObjectRegisterSet()
 {
 }
 
-ClangASTType
+CompilerType
 ValueObjectRegisterSet::GetClangTypeImpl ()
 {
-    return ClangASTType();
+    return CompilerType();
 }
 
 ConstString
@@ -307,7 +307,7 @@ ValueObjectRegister::~ValueObjectRegister()
 {
 }
 
-ClangASTType
+CompilerType
 ValueObjectRegister::GetClangTypeImpl ()
 {
     if (!m_clang_type.IsValid())
diff --git a/lldb/source/Core/ValueObjectSyntheticFilter.cpp b/lldb/source/Core/ValueObjectSyntheticFilter.cpp
index 867b5201629..2a20ae3f150 100644
--- a/lldb/source/Core/ValueObjectSyntheticFilter.cpp
+++ b/lldb/source/Core/ValueObjectSyntheticFilter.cpp
@@ -82,7 +82,7 @@ ValueObjectSynthetic::~ValueObjectSynthetic()
 {
 }
 
-ClangASTType
+CompilerType
 ValueObjectSynthetic::GetClangTypeImpl ()
 {
     return m_parent->GetClangType();
diff --git a/lldb/source/Core/ValueObjectVariable.cpp b/lldb/source/Core/ValueObjectVariable.cpp
index c86bece42eb..3cca6c08799 100644
--- a/lldb/source/Core/ValueObjectVariable.cpp
+++ b/lldb/source/Core/ValueObjectVariable.cpp
@@ -54,13 +54,13 @@ ValueObjectVariable::~ValueObjectVariable()
 {
 }
 
-ClangASTType
+CompilerType
 ValueObjectVariable::GetClangTypeImpl ()
 {
     Type *var_type = m_variable_sp->GetType();
     if (var_type)
         return var_type->GetClangForwardType();
-    return ClangASTType();
+    return CompilerType();
 }
 
 ConstString
@@ -93,7 +93,7 @@ ValueObjectVariable::GetQualifiedTypeName()
 size_t
 ValueObjectVariable::CalculateNumChildren()
 {    
-    ClangASTType type(GetClangType());
+    CompilerType type(GetClangType());
     
     if (!type.IsValid())
         return 0;
@@ -107,7 +107,7 @@ ValueObjectVariable::GetByteSize()
 {
     ExecutionContext exe_ctx(GetExecutionContextRef());
     
-    ClangASTType type(GetClangType());
+    CompilerType type(GetClangType());
     
     if (!type.IsValid())
         return 0;
@@ -168,7 +168,7 @@ ValueObjectVariable::UpdateValue ()
             m_resolved_value = m_value;
             m_value.SetContext(Value::eContextTypeVariable, variable);
             
-            ClangASTType clang_type = GetClangType();
+            CompilerType clang_type = GetClangType();
             if (clang_type.IsValid())
                 m_value.SetClangType(clang_type);