Rename clang_type_t to opaque_t.

[brucem]

Summary

This is no longer related to Clang and is just an opaque pointer
to data for a compiler type.

[brucem]

I think this might be better as opaque_compiler_type_t or something. It is longer, but if we switch the opaque decls over, it is confusing to have the types have the same name, I think.

[brucem]

Rename to opaque_compiler_type_t instead.

[clayborg]

Looks good. We should switch all of TypeSystem's methods over to use this instead of "void *" as well in a future commit.

[brucem]

I already have that as a commit lined up. Just wanted this to land separately first. :)

lldb/trunk/include/lldb/Expression/ASTDumper.h

     
 class ASTDumper
 {
 public:
     ASTDumper (clang::Decl *decl);
     ASTDumper (clang::DeclContext *decl_ctx);
     ASTDumper (const clang::Type *type);
     ASTDumper (clang::QualType type);
-    ASTDumper (lldb::clang_type_t type);
+    ASTDumper (lldb::opaque_compiler_type_t type);
     ASTDumper (const CompilerType &clang_type);
     
     const char *GetCString();
     void ToSTDERR();
     void ToLog(Log *log, const char *prefix);
     void ToStream(lldb::StreamSP &stream);
 private:
     std::string m_dump;
 };
 
 } // namespace lldb_private
 
 #endif

lldb/trunk/include/lldb/Symbol/ClangASTImporter.h

public:
     {
     }
     
     clang::QualType
     CopyType (clang::ASTContext *dst_ctx,
               clang::ASTContext *src_ctx,
               clang::QualType type);
     
-    lldb::clang_type_t
+    lldb::opaque_compiler_type_t
     CopyType (clang::ASTContext *dst_ctx,
               clang::ASTContext *src_ctx,
-              lldb::clang_type_t type);
+              lldb::opaque_compiler_type_t type);
     
     clang::Decl *
     CopyDecl (clang::ASTContext *dst_ctx,
               clang::ASTContext *src_ctx,
               clang::Decl *decl);
     
-    lldb::clang_type_t
+    lldb::opaque_compiler_type_t
     DeportType (clang::ASTContext *dst_ctx,
                 clang::ASTContext *src_ctx,
-                lldb::clang_type_t type);
+                lldb::opaque_compiler_type_t type);
     
     clang::Decl *
     DeportDecl (clang::ASTContext *dst_ctx,
                 clang::ASTContext *src_ctx,
                 clang::Decl *decl);
     
     void
     CompleteDecl (clang::Decl *decl);

lldb/trunk/include/lldb/lldb-types.h

 {
     typedef uint64_t    addr_t;
     typedef uint64_t    user_id_t;
     typedef uint64_t    pid_t;
     typedef uint64_t    tid_t;
     typedef uint64_t    offset_t;
     typedef int32_t     break_id_t;
     typedef int32_t     watch_id_t;
-    typedef void *      clang_type_t;
+    typedef void *      opaque_compiler_type_t;
     typedef uint64_t    queue_id_t;
 }
 
 
 #endif  // LLDB_lldb_types_h_

lldb/trunk/source/Commands/CommandObjectMemory.cpp

#undef ALL_KEYWORDS
                                                type_list);
             }
             
             if (type_list.GetSize() == 0 && lookup_type_name.GetCString() && *lookup_type_name.GetCString() == '$')
             {
                 clang::TypeDecl *tdecl = target->GetPersistentVariables().GetPersistentType(ConstString(lookup_type_name));
                 if (tdecl)
                 {
-                    clang_ast_type.SetCompilerType(ClangASTContext::GetASTContext(&tdecl->getASTContext()),(const lldb::clang_type_t)tdecl->getTypeForDecl());
+                    clang_ast_type.SetCompilerType(ClangASTContext::GetASTContext(&tdecl->getASTContext()),(const lldb::opaque_compiler_type_t)tdecl->getTypeForDecl());
                 }
             }
             
             if (clang_ast_type.IsValid() == false)
             {
                 if (type_list.GetSize() == 0)
                 {
                     result.AppendErrorWithFormat ("unable to find any types that match the raw type '%s' for full type '%s'\n",

lldb/trunk/source/Expression/ASTDumper.cpp

ASTDumper::ASTDumper (const clang::Type *type)
     m_dump = clang::QualType(type, 0).getAsString();
 }
 
 ASTDumper::ASTDumper (clang::QualType type)
 {
     m_dump = type.getAsString();
 }
 
-ASTDumper::ASTDumper (lldb::clang_type_t type)
+ASTDumper::ASTDumper (lldb::opaque_compiler_type_t type)
 {
     m_dump = clang::QualType::getFromOpaquePtr(type).getAsString();
 }
 
 ASTDumper::ASTDumper (const CompilerType &clang_type)
 {
     m_dump = ClangASTContext::GetQualType(clang_type).getAsString();
 }

lldb/trunk/source/Expression/ClangASTSource.cpp

ClangASTSource::GetCompleteObjCInterface (clang::ObjCInterfaceDecl *interface_decl)
     ConstString class_name(interface_decl->getNameAsString().c_str());
 
     lldb::TypeSP complete_type_sp(language_runtime->LookupInCompleteClassCache(class_name));
 
     if (!complete_type_sp)
         return NULL;
 
     TypeFromUser complete_type = TypeFromUser(complete_type_sp->GetFullCompilerType ());
-    lldb::clang_type_t complete_opaque_type = complete_type.GetOpaqueQualType();
+    lldb::opaque_compiler_type_t complete_opaque_type = complete_type.GetOpaqueQualType();
 
     if (!complete_opaque_type)
         return NULL;
 
     const clang::Type *complete_clang_type = QualType::getFromOpaquePtr(complete_opaque_type).getTypePtr();
     const ObjCInterfaceType *complete_interface_type = dyn_cast<ObjCInterfaceType>(complete_clang_type);
 
     if (!complete_interface_type)

lldb/trunk/source/Expression/ClangExpressionDeclMap.cpp

else
                     AddOneGenericVariable(context, *data_symbol, current_id);
                     context.m_found.variable = true;
                 }
             }
         }
     }
 }
 
-//static clang_type_t
+//static opaque_compiler_type_t
 //MaybePromoteToBlockPointerType
 //(
 //    ASTContext *ast_context,
-//    clang_type_t candidate_type
+//    opaque_compiler_type_t candidate_type
 //)
 //{
 //    if (!candidate_type)
 //        return candidate_type;
 //
 //    QualType candidate_qual_type = QualType::getFromOpaquePtr(candidate_type);
 //
 //    const PointerType *candidate_pointer_type = dyn_cast<PointerType>(candidate_qual_type);
for (size_t index = 0, num_entities = m_found_entities.GetSize();
             {
                 ASTDumper ast_dumper(const_cast<VarDecl*>(var_decl));
                 log->Printf("Variable of unknown type now has Decl %s", ast_dumper.GetCString());
             }
 
             QualType var_type = var_decl->getType();
             TypeFromParser parser_type(var_type.getAsOpaquePtr(), ClangASTContext::GetASTContext(&var_decl->getASTContext()));
 
-            lldb::clang_type_t copied_type = m_ast_importer->CopyType(scratch_ast_context->getASTContext(), &var_decl->getASTContext(), var_type.getAsOpaquePtr());
+            lldb::opaque_compiler_type_t copied_type = m_ast_importer->CopyType(scratch_ast_context->getASTContext(), &var_decl->getASTContext(), var_type.getAsOpaquePtr());
 
             if (!copied_type)
             {
                 if (log)
                     log->Printf("ClangExpressionDeclMap::ResolveUnknownType - Couldn't import the type for a variable");
 
                 return (bool) lldb::ExpressionVariableSP();
             }

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

public:
     ParseCompileUnit (DWARFCompileUnit* dwarf_cu, uint32_t cu_idx);
 
     virtual lldb_private::DWARFExpression::LocationListFormat
     GetLocationListFormat() const;
 
 protected:
     typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb_private::Type *> DIEToTypePtr;
     typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb::VariableSP> DIEToVariableSP;
-    typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb::clang_type_t> DIEToClangType;
-    typedef llvm::DenseMap<lldb::clang_type_t, DIERef> ClangTypeToDIE;
+    typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb::opaque_compiler_type_t> DIEToClangType;
+    typedef llvm::DenseMap<lldb::opaque_compiler_type_t, DIERef> ClangTypeToDIE;
 
     enum
     {
         flagsGotDebugAbbrevData     = (1 << 0),
         flagsGotDebugAddrData       = (1 << 1),
         flagsGotDebugArangesData    = (1 << 2),
         flagsGotDebugFrameData      = (1 << 3),
         flagsGotDebugInfoData       = (1 << 4),

lldb/trunk/source/Symbol/ClangASTContext.cpp

ClangASTContext::GetBasicType (lldb::BasicType basic_type)
     return GetBasicType (getASTContext(), basic_type);
 }
 
 CompilerType
 ClangASTContext::GetBasicType (ASTContext *ast, lldb::BasicType basic_type)
 {
     if (ast)
     {
-        clang_type_t clang_type = nullptr;
+        opaque_compiler_type_t clang_type = nullptr;
         
         switch (basic_type)
         {
             case eBasicTypeInvalid:
             case eBasicTypeOther:
                 break;
             case eBasicTypeVoid:
                 clang_type = ast->VoidTy.getAsOpaquePtr();

 
 // Disable this for now since I can't seem to get a nicely formatted float
 // out of the APFloat class without just getting the float, double or quad
 // and then using a formatted print on it which defeats the purpose. We ideally
 // would like to get perfect string values for any kind of float semantics
 // so we can support remote targets. The code below also requires a patch to
 // llvm::APInt.
 //bool
-//ClangASTContext::ConvertFloatValueToString (ASTContext *ast, clang_type_t clang_type, const uint8_t* bytes, size_t byte_size, int apint_byte_order, std::string &float_str)
+//ClangASTContext::ConvertFloatValueToString (ASTContext *ast, opaque_compiler_type_t clang_type, const uint8_t* bytes, size_t byte_size, int apint_byte_order, std::string &float_str)
 //{
 //  uint32_t count = 0;
 //  bool is_complex = false;
 //  if (ClangASTContext::IsFloatingPointType (clang_type, count, is_complex))
 //  {
 //      unsigned num_bytes_per_float = byte_size / count;
 //      unsigned num_bits_per_float = num_bytes_per_float * 8;
 //
switch (type_class)
             break;
             
         default:
             break;
     }
     return count;
 }
 
-static clang_type_t
+static opaque_compiler_type_t
 GetObjCFieldAtIndex (clang::ASTContext *ast,
                      clang::ObjCInterfaceDecl *class_interface_decl,
                      size_t idx,
                      std::string& name,
                      uint64_t *bit_offset_ptr,
                      uint32_t *bitfield_bit_size_ptr,
                      bool *is_bitfield_ptr)
 {

lldb/trunk/source/Symbol/ClangASTImporter.cpp

ClangASTImporter::CopyType (clang::ASTContext *dst_ast,
     MinionSP minion_sp (GetMinion(dst_ast, src_ast));
     
     if (minion_sp)
         return minion_sp->Import(type);
     
     return QualType();
 }
 
-lldb::clang_type_t
+lldb::opaque_compiler_type_t
 ClangASTImporter::CopyType (clang::ASTContext *dst_ast,
                             clang::ASTContext *src_ast,
-                            lldb::clang_type_t type)
+                            lldb::opaque_compiler_type_t type)
 {
     return CopyType (dst_ast, src_ast, QualType::getFromOpaquePtr(type)).getAsOpaquePtr();
 }
 
 clang::Decl *
 ClangASTImporter::CopyDecl (clang::ASTContext *dst_ast,
                             clang::ASTContext *src_ast,
                             clang::Decl *decl)
~DeclContextOverride()
         for (const std::pair<clang::Decl *, Backup> &backup : m_backups)
         {
             backup.first->setDeclContext(backup.second.decl_context);
             backup.first->setLexicalDeclContext(backup.second.lexical_decl_context);
         }
     }
 };
 
-lldb::clang_type_t
+lldb::opaque_compiler_type_t
 ClangASTImporter::DeportType (clang::ASTContext *dst_ctx,
                               clang::ASTContext *src_ctx,
-                              lldb::clang_type_t type)
+                              lldb::opaque_compiler_type_t type)
 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
   
     if (log)
         log->Printf("    [ClangASTImporter] DeportType called on (%sType*)0x%llx from (ASTContext*)%p to (ASTContext*)%p",
                     QualType::getFromOpaquePtr(type)->getTypeClassName(), (unsigned long long)type,
                     static_cast<void*>(src_ctx),
                     static_cast<void*>(dst_ctx));
ClangASTImporter::DeportType (clang::ASTContext *dst_ctx,
     if (const clang::TagType *tag_type = clang::QualType::getFromOpaquePtr(type)->getAs<TagType>())
     {
         decl_context_override.OverrideAllDeclsFromContainingFunction(tag_type->getDecl());
     }
     
     minion_sp->InitDeportWorkQueues(&decls_to_deport,
                                     &decls_already_deported);
     
-    lldb::clang_type_t result = CopyType(dst_ctx, src_ctx, type);
+    lldb::opaque_compiler_type_t result = CopyType(dst_ctx, src_ctx, type);
     
     minion_sp->ExecuteDeportWorkQueues();
     
     if (!result)
         return nullptr;
     
     return result;
 

lldb/trunk/source/Symbol/CompilerType.cpp

if (byte_size > 0)
                 return process->WriteMemory(addr, new_value.GetData(), byte_size, error) == byte_size;
             }
         }
     }
     return false;
 }
 
 //clang::CXXRecordDecl *
-//CompilerType::GetAsCXXRecordDecl (lldb::clang_type_t opaque_clang_qual_type)
+//CompilerType::GetAsCXXRecordDecl (lldb::opaque_compiler_type_t opaque_clang_qual_type)
 //{
 //    if (opaque_clang_qual_type)
 //        return clang::QualType::getFromOpaquePtr(opaque_clang_qual_type)->getAsCXXRecordDecl();
 //    return NULL;
 //}
 
 bool
 lldb_private::operator == (const lldb_private::CompilerType &lhs, const lldb_private::CompilerType &rhs)