DataFormatters: Rename clang_type to compiler_type.

[granata.enrico]

Fine by me

lldb/trunk/include/lldb/DataFormatters/FormatManager.h

 
 private:
     
     static std::vector<lldb::LanguageType>
     GetCandidateLanguages (ValueObject& valobj);
     
     static void
     GetPossibleMatches (ValueObject& valobj,
-                        CompilerType clang_type,
+                        CompilerType compiler_type,
                         uint32_t reason,
                         lldb::DynamicValueType use_dynamic,
                         FormattersMatchVector& entries,
                         bool did_strip_ptr,
                         bool did_strip_ref,
                         bool did_strip_typedef,
                         bool root_level = false);
     

lldb/trunk/include/lldb/DataFormatters/ValueObjectPrinter.h

     
 private:
     
     ValueObject *m_orig_valobj;
     ValueObject *m_valobj;
     Stream *m_stream;
     DumpValueObjectOptions options;
     Flags m_type_flags;
-    CompilerType m_clang_type;
+    CompilerType m_compiler_type;
     DumpValueObjectOptions::PointerDepth m_ptr_depth;
     uint32_t m_curr_depth;
     LazyBool m_should_print;
     LazyBool m_is_nil;
     LazyBool m_is_ptr;
     LazyBool m_is_ref;
     LazyBool m_is_aggregate;
     std::pair<TypeSummaryImpl*,bool> m_summary_formatter;

lldb/trunk/source/DataFormatters/FormatManager.cpp

FormatManager::DisableAllCategories ()
     {
         if (iter.second)
             iter.second->Disable();
     }
 }
 
 void
 FormatManager::GetPossibleMatches (ValueObject& valobj,
-                                   CompilerType clang_type,
+                                   CompilerType compiler_type,
                                    uint32_t reason,
                                    lldb::DynamicValueType use_dynamic,
                                    FormattersMatchVector& entries,
                                    bool did_strip_ptr,
                                    bool did_strip_ref,
                                    bool did_strip_typedef,
                                    bool root_level)
 {
-    clang_type = ClangASTContext::RemoveFastQualifiers(clang_type);
-    ConstString type_name(clang_type.GetConstTypeName());
+    compiler_type = ClangASTContext::RemoveFastQualifiers(compiler_type);
+    ConstString type_name(compiler_type.GetConstTypeName());
     if (valobj.GetBitfieldBitSize() > 0)
     {
         StreamString sstring;
         sstring.Printf("%s:%d",type_name.AsCString(),valobj.GetBitfieldBitSize());
         ConstString bitfieldname = ConstString(sstring.GetData());
         entries.push_back({bitfieldname,0,did_strip_ptr,did_strip_ref,did_strip_typedef});
         reason |= lldb_private::eFormatterChoiceCriterionStrippedBitField;
     }
     entries.push_back({type_name,reason,did_strip_ptr,did_strip_ref,did_strip_typedef});
 
-    ConstString display_type_name(clang_type.GetDisplayTypeName());
+    ConstString display_type_name(compiler_type.GetDisplayTypeName());
     if (display_type_name != type_name)
         entries.push_back({display_type_name,reason,did_strip_ptr,did_strip_ref,did_strip_typedef});
 
-    for (bool is_rvalue_ref = true, j = true; j && clang_type.IsReferenceType(nullptr, &is_rvalue_ref); j = false)
+    for (bool is_rvalue_ref = true, j = true; j && compiler_type.IsReferenceType(nullptr, &is_rvalue_ref); j = false)
     {
-        CompilerType non_ref_type = clang_type.GetNonReferenceType();
+        CompilerType non_ref_type = compiler_type.GetNonReferenceType();
         GetPossibleMatches(valobj,
                            non_ref_type,
                            reason | lldb_private::eFormatterChoiceCriterionStrippedPointerReference,
                            use_dynamic,
                            entries,
                            did_strip_ptr,
                            true,
                            did_strip_typedef);
         if (non_ref_type.IsTypedefType())
         {
             CompilerType deffed_referenced_type = non_ref_type.GetTypedefedType();
             deffed_referenced_type = is_rvalue_ref ? ClangASTContext::GetRValueReferenceType(deffed_referenced_type) : ClangASTContext::GetLValueReferenceType(deffed_referenced_type);
             GetPossibleMatches(valobj,
                                deffed_referenced_type,
                                reason | lldb_private::eFormatterChoiceCriterionNavigatedTypedefs,
                                use_dynamic,
                                entries,
                                did_strip_ptr,
                                did_strip_ref,
                                true); // this is not exactly the usual meaning of stripping typedefs
         }
     }
     
-    if (clang_type.IsPointerType())
+    if (compiler_type.IsPointerType())
     {
-        CompilerType non_ptr_type = clang_type.GetPointeeType();
+        CompilerType non_ptr_type = compiler_type.GetPointeeType();
         GetPossibleMatches(valobj,
                            non_ptr_type,
                            reason | lldb_private::eFormatterChoiceCriterionStrippedPointerReference,
                            use_dynamic,
                            entries,
                            true,
                            did_strip_ref,
                            did_strip_typedef);
for (lldb::LanguageType language_type : GetCandidateLanguages(valobj))
                                    did_strip_ptr,
                                    did_strip_ref,
                                    did_strip_typedef});
             }
         }
     }
         
     // try to strip typedef chains
-    if (clang_type.IsTypedefType())
+    if (compiler_type.IsTypedefType())
     {
-        CompilerType deffed_type = clang_type.GetTypedefedType();
+        CompilerType deffed_type = compiler_type.GetTypedefedType();
         GetPossibleMatches(valobj,
                            deffed_type,
                            reason | lldb_private::eFormatterChoiceCriterionNavigatedTypedefs,
                            use_dynamic,
                            entries,
                            did_strip_ptr,
                            did_strip_ref,
                            true);
     }
     
     if (root_level)
     {
         do {
-            if (!clang_type.IsValid())
+            if (!compiler_type.IsValid())
                 break;
             
-            CompilerType unqual_clang_ast_type = clang_type.GetFullyUnqualifiedType();
-            if (!unqual_clang_ast_type.IsValid())
+            CompilerType unqual_compiler_ast_type = compiler_type.GetFullyUnqualifiedType();
+            if (!unqual_compiler_ast_type.IsValid())
                 break;
-            if (unqual_clang_ast_type.GetOpaqueQualType() != clang_type.GetOpaqueQualType())
+            if (unqual_compiler_ast_type.GetOpaqueQualType() != compiler_type.GetOpaqueQualType())
                 GetPossibleMatches (valobj,
-                                    unqual_clang_ast_type,
+                                    unqual_compiler_ast_type,
                                     reason,
                                     use_dynamic,
                                     entries,
                                     did_strip_ptr,
                                     did_strip_ref,
                                     did_strip_typedef);
         } while(false);
         

lldb/trunk/source/DataFormatters/TypeFormat.cpp

if (valobj->CanProvideValue())
                            0,
                            0,
                            exe_ctx.GetBestExecutionContextScope());
                 dest.swap(reg_sstr.GetString());
             }
         }
         else
         {
-            CompilerType clang_type = value.GetCompilerType ();
-            if (clang_type)
+            CompilerType compiler_type = value.GetCompilerType ();
+            if (compiler_type)
             {
                 // put custom bytes to display in the DataExtractor to override the default value logic
                 if (GetFormat() == eFormatCString)
                 {
-                    lldb_private::Flags type_flags(clang_type.GetTypeInfo(NULL)); // disambiguate w.r.t. TypeFormatImpl::Flags
+                    lldb_private::Flags type_flags(compiler_type.GetTypeInfo(NULL)); // disambiguate w.r.t. TypeFormatImpl::Flags
                     if (type_flags.Test(eTypeIsPointer) && !type_flags.Test(eTypeIsObjC))
                     {
                         // if we are dumping a pointer as a c-string, get the pointee data as a string
                         TargetSP target_sp(valobj->GetTargetSP());
                         if (target_sp)
                         {
                             size_t max_len = target_sp->GetMaximumSizeOfStringSummary();
                             Error error;
                             DataBufferSP buffer_sp(new DataBufferHeap(max_len+1,0));
                             Address address(valobj->GetPointerValue());
                             if (target_sp->ReadCStringFromMemory(address, (char*)buffer_sp->GetBytes(), max_len, error) && error.Success())
                                 data.SetData(buffer_sp);
                         }
                     }
                 }
                 else
                 {
                     Error error;
                     valobj->GetData(data, error);
                     if (error.Fail())
                         return false;
                 }
                 
                 StreamString sstr;
-                clang_type.DumpTypeValue (&sstr,                         // The stream to use for display
+                compiler_type.DumpTypeValue (&sstr,                         // The stream to use for display
                                           GetFormat(),                  // Format to display this type with
                                           data,                         // Data to extract from
                                           0,                             // Byte offset into "m_data"
                                           valobj->GetByteSize(),                 // Byte size of item in "m_data"
                                           valobj->GetBitfieldBitSize(),          // Bitfield bit size
                                           valobj->GetBitfieldBitOffset(),        // Bitfield bit offset
                                           exe_ctx.GetBestExecutionContextScope());
                 // Given that we do not want to set the ValueObject's m_error

lldb/trunk/source/DataFormatters/ValueObjectPrinter.cpp

else
             if (options.m_use_synthetic == true)
             {
                 ValueObject *synthetic = m_valobj->GetSyntheticValue().get();
                 if (synthetic)
                     m_valobj = synthetic;
             }
         }
     }
-    m_clang_type = m_valobj->GetCompilerType();
-    m_type_flags = m_clang_type.GetTypeInfo ();
+    m_compiler_type = m_valobj->GetCompilerType();
+    m_type_flags = m_compiler_type.GetTypeInfo ();
     return true;
 }
 
 const char*
 ValueObjectPrinter::GetDescriptionForDisplay ()
 {
     const char* str = m_valobj->GetObjectDescription();
     if (!str)