Use opaque_compiler_type_t in place of void*.

[clayborg]

Looks good.

lldb/trunk/include/lldb/Symbol/ClangASTContext.h

public:
     static clang::ASTContext *
     DeclContextGetClangASTContext (const CompilerDeclContext &dc);
 
     //----------------------------------------------------------------------
     // Tests
     //----------------------------------------------------------------------
     
     bool
-    IsArrayType (void *type,
+    IsArrayType (lldb::opaque_compiler_type_t type,
                  CompilerType *element_type,
                  uint64_t *size,
                  bool *is_incomplete) override;
     
     bool
-    IsVectorType (void *type,
+    IsVectorType (lldb::opaque_compiler_type_t type,
                   CompilerType *element_type,
                   uint64_t *size) override;
     
     bool
-    IsAggregateType (void *type) override;
+    IsAggregateType (lldb::opaque_compiler_type_t type) override;
     
     bool
-    IsBeingDefined (void *type) override;
+    IsBeingDefined (lldb::opaque_compiler_type_t type) override;
     
     bool
-    IsCharType (void *type) override;
+    IsCharType (lldb::opaque_compiler_type_t type) override;
     
     bool
-    IsCompleteType (void *type) override;
+    IsCompleteType (lldb::opaque_compiler_type_t type) override;
     
     bool
-    IsConst(void *type) override;
+    IsConst(lldb::opaque_compiler_type_t type) override;
     
     bool
-    IsCStringType (void *type, uint32_t &length) override;
+    IsCStringType (lldb::opaque_compiler_type_t type, uint32_t &length) override;
     
     static bool
     IsCXXClassType (const CompilerType& type);
     
     bool
-    IsDefined(void *type) override;
+    IsDefined(lldb::opaque_compiler_type_t type) override;
     
     bool
-    IsFloatingPointType (void *type, uint32_t &count, bool &is_complex) override;
+    IsFloatingPointType (lldb::opaque_compiler_type_t type, uint32_t &count, bool &is_complex) override;
     
     bool
-    IsFunctionType (void *type, bool *is_variadic_ptr) override;
+    IsFunctionType (lldb::opaque_compiler_type_t type, bool *is_variadic_ptr) override;
 
     uint32_t
-    IsHomogeneousAggregate (void *type, CompilerType* base_type_ptr) override;
+    IsHomogeneousAggregate (lldb::opaque_compiler_type_t type, CompilerType* base_type_ptr) override;
     
     size_t
-    GetNumberOfFunctionArguments (void *type) override;
+    GetNumberOfFunctionArguments (lldb::opaque_compiler_type_t type) override;
     
     CompilerType
-    GetFunctionArgumentAtIndex (void *type, const size_t index) override;
+    GetFunctionArgumentAtIndex (lldb::opaque_compiler_type_t type, const size_t index) override;
     
     bool
-    IsFunctionPointerType (void *type) override;
+    IsFunctionPointerType (lldb::opaque_compiler_type_t type) override;
     
     bool
-    IsIntegerType (void *type, bool &is_signed) override;
+    IsIntegerType (lldb::opaque_compiler_type_t type, bool &is_signed) override;
     
     static bool
     IsObjCClassType (const CompilerType& type);
     
     static bool
     IsObjCClassTypeAndHasIVars (const CompilerType& type, bool check_superclass);
     
     static bool
     IsObjCObjectOrInterfaceType (const CompilerType& type);
     
     static bool
     IsObjCObjectPointerType (const CompilerType& type, CompilerType *target_type = NULL);
     
     bool
-    IsPolymorphicClass (void *type) override;
+    IsPolymorphicClass (lldb::opaque_compiler_type_t type) override;
     
     bool
-    IsPossibleDynamicType (void *type,
+    IsPossibleDynamicType (lldb::opaque_compiler_type_t type,
                            CompilerType *target_type, // Can pass NULL
                            bool check_cplusplus,
                            bool check_objc) override;
     
     bool
-    IsRuntimeGeneratedType (void *type) override;
+    IsRuntimeGeneratedType (lldb::opaque_compiler_type_t type) override;
     
     bool
-    IsPointerType (void *type, CompilerType *pointee_type) override;
+    IsPointerType (lldb::opaque_compiler_type_t type, CompilerType *pointee_type) override;
     
     bool
-    IsPointerOrReferenceType (void *type, CompilerType *pointee_type) override;
+    IsPointerOrReferenceType (lldb::opaque_compiler_type_t type, CompilerType *pointee_type) override;
     
     bool
-    IsReferenceType (void *type, CompilerType *pointee_type, bool* is_rvalue) override;
+    IsReferenceType (lldb::opaque_compiler_type_t type, CompilerType *pointee_type, bool* is_rvalue) override;
     
     bool
-    IsScalarType (void *type) override;
+    IsScalarType (lldb::opaque_compiler_type_t type) override;
     
     bool
-    IsTypedefType (void *type) override;
+    IsTypedefType (lldb::opaque_compiler_type_t type) override;
     
     bool
-    IsVoidType (void *type) override;
+    IsVoidType (lldb::opaque_compiler_type_t type) override;
 
     bool
     SupportsLanguage (lldb::LanguageType language) override;
 
     static bool
     GetCXXClassName (const CompilerType& type, std::string &class_name);
     
     static bool
     GetObjCClassName (const CompilerType& type, std::string &class_name);
     
     //----------------------------------------------------------------------
     // Type Completion
     //----------------------------------------------------------------------
     
     bool
-    GetCompleteType (void *type) override;
+    GetCompleteType (lldb::opaque_compiler_type_t type) override;
     
     //----------------------------------------------------------------------
     // Accessors
     //----------------------------------------------------------------------
     
     ConstString
-    GetTypeName (void *type) override;
+    GetTypeName (lldb::opaque_compiler_type_t type) override;
     
     uint32_t
-    GetTypeInfo (void *type, CompilerType *pointee_or_element_clang_type) override;
+    GetTypeInfo (lldb::opaque_compiler_type_t type, CompilerType *pointee_or_element_clang_type) override;
     
     lldb::LanguageType
-    GetMinimumLanguage (void *type) override;
+    GetMinimumLanguage (lldb::opaque_compiler_type_t type) override;
     
     lldb::TypeClass
-    GetTypeClass (void *type) override;
+    GetTypeClass (lldb::opaque_compiler_type_t type) override;
     
     unsigned
-    GetTypeQualifiers(void *type) override;
+    GetTypeQualifiers(lldb::opaque_compiler_type_t type) override;
     
     //----------------------------------------------------------------------
     // Creating related types
     //----------------------------------------------------------------------
     
     // Using the current type, create a new typedef to that type using "typedef_name"
     // as the name and "decl_ctx" as the decl context.
     static CompilerType
     CreateTypedefType (const CompilerType& type,
                        const char *typedef_name,
                        const CompilerDeclContext &compiler_decl_ctx);
     
     CompilerType
-    GetArrayElementType (void *type, uint64_t *stride) override;
+    GetArrayElementType (lldb::opaque_compiler_type_t type, uint64_t *stride) override;
     
     CompilerType
-    GetCanonicalType (void *type) override;
+    GetCanonicalType (lldb::opaque_compiler_type_t type) override;
     
     CompilerType
-    GetFullyUnqualifiedType (void *type) override;
+    GetFullyUnqualifiedType (lldb::opaque_compiler_type_t type) override;
     
     // Returns -1 if this isn't a function of if the function doesn't have a prototype
     // Returns a value >= 0 if there is a prototype.
     int
-    GetFunctionArgumentCount (void *type) override;
+    GetFunctionArgumentCount (lldb::opaque_compiler_type_t type) override;
     
     CompilerType
-    GetFunctionArgumentTypeAtIndex (void *type, size_t idx) override;
+    GetFunctionArgumentTypeAtIndex (lldb::opaque_compiler_type_t type, size_t idx) override;
     
     CompilerType
-    GetFunctionReturnType (void *type) override;
+    GetFunctionReturnType (lldb::opaque_compiler_type_t type) override;
     
     size_t
-    GetNumMemberFunctions (void *type) override;
+    GetNumMemberFunctions (lldb::opaque_compiler_type_t type) override;
     
     TypeMemberFunctionImpl
-    GetMemberFunctionAtIndex (void *type, size_t idx) override;
+    GetMemberFunctionAtIndex (lldb::opaque_compiler_type_t type, size_t idx) override;
     
     CompilerType
-    GetNonReferenceType (void *type) override;
+    GetNonReferenceType (lldb::opaque_compiler_type_t type) override;
     
     CompilerType
-    GetPointeeType (void *type) override;
+    GetPointeeType (lldb::opaque_compiler_type_t type) override;
     
     CompilerType
-    GetPointerType (void *type) override;
+    GetPointerType (lldb::opaque_compiler_type_t type) override;
 
     CompilerType
-    GetLValueReferenceType (void *type) override;
+    GetLValueReferenceType (lldb::opaque_compiler_type_t type) override;
 
     CompilerType
-    GetRValueReferenceType (void *type) override;
+    GetRValueReferenceType (lldb::opaque_compiler_type_t type) override;
 
     CompilerType
-    AddConstModifier (void *type) override;
+    AddConstModifier (lldb::opaque_compiler_type_t type) override;
 
     CompilerType
-    AddVolatileModifier (void *type) override;
+    AddVolatileModifier (lldb::opaque_compiler_type_t type) override;
 
     CompilerType
-    AddRestrictModifier (void *type) override;
+    AddRestrictModifier (lldb::opaque_compiler_type_t type) override;
 
     CompilerType
-    CreateTypedef (void *type, const char *name, const CompilerDeclContext &decl_ctx) override;
+    CreateTypedef (lldb::opaque_compiler_type_t type, const char *name, const CompilerDeclContext &decl_ctx) override;
 
     // If the current object represents a typedef type, get the underlying type
     CompilerType
-    GetTypedefedType (void *type) override;
+    GetTypedefedType (lldb::opaque_compiler_type_t type) override;
 
     static CompilerType
     RemoveFastQualifiers (const CompilerType& type);
     
     //----------------------------------------------------------------------
     // Create related types using the current type's AST
     //----------------------------------------------------------------------
     CompilerType
     GetBasicTypeFromAST (lldb::BasicType basic_type) override;
     
     //----------------------------------------------------------------------
     // Exploring the type
     //----------------------------------------------------------------------
     
     uint64_t
-    GetByteSize (void *type, ExecutionContextScope *exe_scope)
+    GetByteSize (lldb::opaque_compiler_type_t type, ExecutionContextScope *exe_scope)
     {
         return (GetBitSize (type, exe_scope) + 7) / 8;
     }
     
     uint64_t
-    GetBitSize (void *type, ExecutionContextScope *exe_scope) override;
+    GetBitSize (lldb::opaque_compiler_type_t type, ExecutionContextScope *exe_scope) override;
     
     lldb::Encoding
-    GetEncoding (void *type, uint64_t &count) override;
+    GetEncoding (lldb::opaque_compiler_type_t type, uint64_t &count) override;
     
     lldb::Format
-    GetFormat (void *type) override;
+    GetFormat (lldb::opaque_compiler_type_t type) override;
     
     size_t
-    GetTypeBitAlign (void *type) override;
+    GetTypeBitAlign (lldb::opaque_compiler_type_t type) override;
     
     uint32_t
-    GetNumChildren (void *type, bool omit_empty_base_classes) override;
+    GetNumChildren (lldb::opaque_compiler_type_t type, bool omit_empty_base_classes) override;
 
     CompilerType
     GetBuiltinTypeByName (const ConstString &name) override;
 
     lldb::BasicType
-    GetBasicTypeEnumeration (void *type) override;
+    GetBasicTypeEnumeration (lldb::opaque_compiler_type_t type) override;
     
     static lldb::BasicType
-    GetBasicTypeEnumeration (void *type, const ConstString &name);
+    GetBasicTypeEnumeration (lldb::opaque_compiler_type_t type, const ConstString &name);
 
     void
-    ForEachEnumerator (void *type, std::function <bool (const CompilerType &integer_type, const ConstString &name, const llvm::APSInt &value)> const &callback) override;
+    ForEachEnumerator (lldb::opaque_compiler_type_t type, std::function <bool (const CompilerType &integer_type, const ConstString &name, const llvm::APSInt &value)> const &callback) override;
 
     uint32_t
-    GetNumFields (void *type) override;
+    GetNumFields (lldb::opaque_compiler_type_t type) override;
     
     CompilerType
-    GetFieldAtIndex (void *type,
+    GetFieldAtIndex (lldb::opaque_compiler_type_t type,
                      size_t idx,
                      std::string& name,
                      uint64_t *bit_offset_ptr,
                      uint32_t *bitfield_bit_size_ptr,
                      bool *is_bitfield_ptr) override;
 
     uint32_t
-    GetNumDirectBaseClasses (void *type) override;
+    GetNumDirectBaseClasses (lldb::opaque_compiler_type_t type) override;
 
     uint32_t
-    GetNumVirtualBaseClasses (void *type) override;
+    GetNumVirtualBaseClasses (lldb::opaque_compiler_type_t type) override;
 
     CompilerType
-    GetDirectBaseClassAtIndex (void *type,
+    GetDirectBaseClassAtIndex (lldb::opaque_compiler_type_t type,
                                size_t idx,
                                uint32_t *bit_offset_ptr) override;
 
     CompilerType
-    GetVirtualBaseClassAtIndex (void *type,
+    GetVirtualBaseClassAtIndex (lldb::opaque_compiler_type_t type,
                                 size_t idx,
                                 uint32_t *bit_offset_ptr) override;
 
     static uint32_t
     GetNumPointeeChildren (clang::QualType type);
     
     CompilerType
-    GetChildCompilerTypeAtIndex (void *type,
+    GetChildCompilerTypeAtIndex (lldb::opaque_compiler_type_t type,
                                  ExecutionContext *exe_ctx,
                                  size_t idx,
                                  bool transparent_pointers,
                                  bool omit_empty_base_classes,
                                  bool ignore_array_bounds,
                                  std::string& child_name,
                                  uint32_t &child_byte_size,
                                  int32_t &child_byte_offset,
                                  uint32_t &child_bitfield_bit_size,
                                  uint32_t &child_bitfield_bit_offset,
                                  bool &child_is_base_class,
                                  bool &child_is_deref_of_parent,
                                  ValueObject *valobj) override;
     
     // Lookup a child given a name. This function will match base class names
     // and member member names in "clang_type" only, not descendants.
     uint32_t
-    GetIndexOfChildWithName (void *type,
+    GetIndexOfChildWithName (lldb::opaque_compiler_type_t type,
                              const char *name,
                              bool omit_empty_base_classes) override;
     
     // Lookup a child member given a name. This function will match member names
     // only and will descend into "clang_type" children in search for the first
     // member in this class, or any base class that matches "name".
     // TODO: Return all matches for a given name by returning a vector<vector<uint32_t>>
     // so we catch all names that match a given child name, not just the first.
     size_t
-    GetIndexOfChildMemberWithName (void *type,
+    GetIndexOfChildMemberWithName (lldb::opaque_compiler_type_t type,
                                    const char *name,
                                    bool omit_empty_base_classes,
                                    std::vector<uint32_t>& child_indexes) override;
     
     size_t
-    GetNumTemplateArguments (void *type) override;
+    GetNumTemplateArguments (lldb::opaque_compiler_type_t type) override;
     
     CompilerType
-    GetTemplateArgument (void *type,
+    GetTemplateArgument (lldb::opaque_compiler_type_t type,
                          size_t idx,
                          lldb::TemplateArgumentKind &kind) override;
     
     //----------------------------------------------------------------------
     // Modifying RecordType
     //----------------------------------------------------------------------
     static clang::FieldDecl *
     AddFieldToRecordType (const CompilerType& type,
public:
     
     static clang::VarDecl *
     AddVariableToRecordType (const CompilerType& type,
                              const char *name,
                              const CompilerType &var_type,
                              lldb::AccessType access);
     
     clang::CXXMethodDecl *
-    AddMethodToCXXRecordType (void *type,
+    AddMethodToCXXRecordType (lldb::opaque_compiler_type_t type,
                               const char *name,
                               const CompilerType &method_type,
                               lldb::AccessType access,
                               bool is_virtual,
                               bool is_static,
                               bool is_inline,
                               bool is_explicit,
                               bool is_attr_used,
                               bool is_artificial);
     
     // C++ Base Classes
     clang::CXXBaseSpecifier *
-    CreateBaseClassSpecifier (void *type,
+    CreateBaseClassSpecifier (lldb::opaque_compiler_type_t type,
                               lldb::AccessType access,
                               bool is_virtual,
                               bool base_of_class);
     
     static void
     DeleteBaseClassSpecifiers (clang::CXXBaseSpecifier **base_classes,
                                unsigned num_base_classes);
     
     bool
-    SetBaseClassesForClassType (void *type,
+    SetBaseClassesForClassType (lldb::opaque_compiler_type_t type,
                                 clang::CXXBaseSpecifier const * const *base_classes,
                                 unsigned num_base_classes);
     
     static bool
     SetObjCSuperClass (const CompilerType& type,
                        const CompilerType &superclass_clang_type);
     
     static bool
     AddObjCClassProperty (const CompilerType& type,
                           const char *property_name,
                           const CompilerType &property_clang_type,
                           clang::ObjCIvarDecl *ivar_decl,
                           const char *property_setter_name,
                           const char *property_getter_name,
                           uint32_t property_attributes,
                           ClangASTMetadata *metadata);
     
     static clang::ObjCMethodDecl *
     AddMethodToObjCObjectType (const CompilerType& type,
-                               const char *name,  // the full symbol name as seen in the symbol table (void *type, "-[NString stringWithCString:]")
+                               const char *name,  // the full symbol name as seen in the symbol table (lldb::opaque_compiler_type_t type, "-[NString stringWithCString:]")
                                const CompilerType &method_clang_type,
                                lldb::AccessType access,
                                bool is_artificial);
     
     bool
-    SetHasExternalStorage (void *type, bool has_extern);
+    SetHasExternalStorage (lldb::opaque_compiler_type_t type, bool has_extern);
     
     
     //------------------------------------------------------------------
     // Tag Declarations
     //------------------------------------------------------------------
     static bool
     StartTagDeclarationDefinition (const CompilerType &type);
     
     static bool
     CompleteTagDeclarationDefinition (const CompilerType &type);
     
     //----------------------------------------------------------------------
     // Modifying Enumeration types
     //----------------------------------------------------------------------
     bool
-    AddEnumerationValueToEnumerationType (void *type,
+    AddEnumerationValueToEnumerationType (lldb::opaque_compiler_type_t type,
                                           const CompilerType &enumerator_qual_type,
                                           const Declaration &decl,
                                           const char *name,
                                           int64_t enum_value,
                                           uint32_t enum_value_bit_size);
     
     
     
     CompilerType
-    GetEnumerationIntegerType (void *type);
+    GetEnumerationIntegerType (lldb::opaque_compiler_type_t type);
     
     //------------------------------------------------------------------
     // Pointers & References
     //------------------------------------------------------------------
     
     // Call this function using the class type when you want to make a
     // member pointer type to pointee_type.
     static CompilerType
     CreateMemberPointerType (const CompilerType& type, const CompilerType &pointee_type);
     
     
     // Converts "s" to a floating point value and place resulting floating
     // point bytes in the "dst" buffer.
     size_t
-    ConvertStringToFloatValue (void *type,
+    ConvertStringToFloatValue (lldb::opaque_compiler_type_t type,
                                const char *s,
                                uint8_t *dst,
                                size_t dst_size) override;
     //----------------------------------------------------------------------
     // Dumping types
     //----------------------------------------------------------------------
     void
-    DumpValue (void *type,
+    DumpValue (lldb::opaque_compiler_type_t type,
                ExecutionContext *exe_ctx,
                Stream *s,
                lldb::Format format,
                const DataExtractor &data,
                lldb::offset_t data_offset,
                size_t data_byte_size,
                uint32_t bitfield_bit_size,
                uint32_t bitfield_bit_offset,
                bool show_types,
                bool show_summary,
                bool verbose,
                uint32_t depth) override;
     
     bool
-    DumpTypeValue (void *type,
+    DumpTypeValue (lldb::opaque_compiler_type_t type,
                    Stream *s,
                    lldb::Format format,
                    const DataExtractor &data,
                    lldb::offset_t data_offset,
                    size_t data_byte_size,
                    uint32_t bitfield_bit_size,
                    uint32_t bitfield_bit_offset,
                    ExecutionContextScope *exe_scope) override;
     
     void
-    DumpSummary (void *type,
+    DumpSummary (lldb::opaque_compiler_type_t type,
                  ExecutionContext *exe_ctx,
                  Stream *s,
                  const DataExtractor &data,
                  lldb::offset_t data_offset,
                  size_t data_byte_size) override;
     
     virtual void
-    DumpTypeDescription (void *type) override; // Dump to stdout
+    DumpTypeDescription (lldb::opaque_compiler_type_t type) override; // Dump to stdout
     
     void
-    DumpTypeDescription (void *type, Stream *s) override;
+    DumpTypeDescription (lldb::opaque_compiler_type_t type, Stream *s) override;
     
     static clang::EnumDecl *
     GetAsEnumDecl (const CompilerType& type);
     
     static clang::RecordDecl *
     GetAsRecordDecl (const CompilerType& type);
     
     clang::CXXRecordDecl *
-    GetAsCXXRecordDecl (void *type);
+    GetAsCXXRecordDecl (lldb::opaque_compiler_type_t type);
     
     static clang::ObjCInterfaceDecl *
     GetAsObjCInterfaceDecl (const CompilerType& type);
     
     static clang::QualType
     GetQualType (const CompilerType& type)
     {
         // Make sure we have a clang type before making a clang::QualType

 
     clang::UsingDecl *
     CreateUsingDeclaration (clang::DeclContext *current_decl_ctx, clang::NamedDecl *target);
 
     clang::VarDecl *
     CreateVariableDeclaration (clang::DeclContext *decl_context, const char *name, clang::QualType type);
 protected:
     static clang::QualType
-    GetQualType (void *type)
+    GetQualType (lldb::opaque_compiler_type_t type)
     {
         if (type)
             return clang::QualType::getFromOpaquePtr(type);
         return clang::QualType();
     }
     
     static clang::QualType
-    GetCanonicalQualType (void *type)
+    GetCanonicalQualType (lldb::opaque_compiler_type_t type)
     {
         if (type)
             return clang::QualType::getFromOpaquePtr(type).getCanonicalType();
         return clang::QualType();
     }
 
     //------------------------------------------------------------------
     // Classes that inherit from ClangASTContext can see and modify these

lldb/trunk/include/lldb/Symbol/CompilerType.h

 // to avoid code duplication.
 //----------------------------------------------------------------------
 class CompilerType
 {
 public:
     //----------------------------------------------------------------------
     // Constructors and Destructors
     //----------------------------------------------------------------------
-    CompilerType (TypeSystem *type_system, void *type);
+    CompilerType (TypeSystem *type_system, lldb::opaque_compiler_type_t type);
     CompilerType (clang::ASTContext *ast_context, clang::QualType qual_type);
 
     CompilerType (const CompilerType &rhs) :
         m_type (rhs.m_type),
         m_type_system  (rhs.m_type_system)
     {
     }
     
public:
     GetDisplayTypeName () const;
 
     uint32_t
     GetTypeInfo (CompilerType *pointee_or_element_clang_type = NULL) const;
     
     lldb::LanguageType
     GetMinimumLanguage ();
 
-    void *
+    lldb::opaque_compiler_type_t
     GetOpaqueQualType() const
     {
         return m_type;
     }
 
     lldb::TypeClass
     GetTypeClass () const;
     
     void
-    SetCompilerType (TypeSystem* type_system, void* type);
+    SetCompilerType (TypeSystem* type_system, lldb::opaque_compiler_type_t type);
     void
     SetCompilerType (clang::ASTContext *ast, clang::QualType qual_type);
 
     unsigned
     GetTypeQualifiers() const;
     
     //----------------------------------------------------------------------
     // Creating related types
public:
     
     void
     Clear()
     {
         m_type = NULL;
         m_type_system = NULL;
     }
 private:
-    void* m_type;
+    lldb::opaque_compiler_type_t m_type;
     TypeSystem *m_type_system;
     
 };
     
 bool operator == (const CompilerType &lhs, const CompilerType &rhs);
 bool operator != (const CompilerType &lhs, const CompilerType &rhs);
 
     
 } // namespace lldb_private
 
 #endif // #ifndef liblldb_CompilerType_h_

lldb/trunk/include/lldb/Symbol/GoASTContext.h

public:
     //----------------------------------------------------------------------
 
     static bool IsGoString(const CompilerType &type);
     static bool IsGoSlice(const CompilerType &type);
     static bool IsGoInterface(const CompilerType &type);
     static bool IsDirectIface(uint8_t kind);
     static bool IsPointerKind(uint8_t kind);
 
-    bool IsArrayType(void *type, CompilerType *element_type, uint64_t *size, bool *is_incomplete) override;
+    bool IsArrayType(lldb::opaque_compiler_type_t type, CompilerType *element_type, uint64_t *size, bool *is_incomplete) override;
 
-    bool IsAggregateType(void *type) override;
+    bool IsAggregateType(lldb::opaque_compiler_type_t type) override;
 
-    bool IsCharType(void *type) override;
+    bool IsCharType(lldb::opaque_compiler_type_t type) override;
 
-    bool IsCompleteType(void *type) override;
+    bool IsCompleteType(lldb::opaque_compiler_type_t type) override;
 
-    bool IsDefined(void *type) override;
+    bool IsDefined(lldb::opaque_compiler_type_t type) override;
 
-    bool IsFloatingPointType(void *type, uint32_t &count, bool &is_complex) override;
+    bool IsFloatingPointType(lldb::opaque_compiler_type_t type, uint32_t &count, bool &is_complex) override;
 
-    bool IsFunctionType(void *type, bool *is_variadic_ptr = NULL) override;
+    bool IsFunctionType(lldb::opaque_compiler_type_t type, bool *is_variadic_ptr = NULL) override;
 
-    size_t GetNumberOfFunctionArguments(void *type) override;
+    size_t GetNumberOfFunctionArguments(lldb::opaque_compiler_type_t type) override;
 
-    CompilerType GetFunctionArgumentAtIndex(void *type, const size_t index) override;
+    CompilerType GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type, const size_t index) override;
 
-    bool IsFunctionPointerType(void *type) override;
+    bool IsFunctionPointerType(lldb::opaque_compiler_type_t type) override;
 
-    bool IsIntegerType(void *type, bool &is_signed) override;
+    bool IsIntegerType(lldb::opaque_compiler_type_t type, bool &is_signed) override;
 
-    bool IsPossibleDynamicType(void *type,
+    bool IsPossibleDynamicType(lldb::opaque_compiler_type_t type,
                                        CompilerType *target_type, // Can pass NULL
                                        bool check_cplusplus, bool check_objc) override;
 
-    bool IsPointerType(void *type, CompilerType *pointee_type = NULL) override;
+    bool IsPointerType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type = NULL) override;
 
-    bool IsScalarType(void *type) override;
+    bool IsScalarType(lldb::opaque_compiler_type_t type) override;
 
-    bool IsVoidType(void *type) override;
+    bool IsVoidType(lldb::opaque_compiler_type_t type) override;
 
     bool SupportsLanguage (lldb::LanguageType language) override;
 
     //----------------------------------------------------------------------
     // Type Completion
     //----------------------------------------------------------------------
 
-    virtual bool GetCompleteType(void *type) override;
+    virtual bool GetCompleteType(lldb::opaque_compiler_type_t type) override;
 
     //----------------------------------------------------------------------
     // AST related queries
     //----------------------------------------------------------------------
 
     virtual uint32_t GetPointerByteSize() override;
 
     //----------------------------------------------------------------------
     // Accessors
     //----------------------------------------------------------------------
 
-    virtual ConstString GetTypeName(void *type) override;
+    virtual ConstString GetTypeName(lldb::opaque_compiler_type_t type) override;
 
-    virtual uint32_t GetTypeInfo(void *type, CompilerType *pointee_or_element_clang_type = NULL) override;
+    virtual uint32_t GetTypeInfo(lldb::opaque_compiler_type_t type, CompilerType *pointee_or_element_clang_type = NULL) override;
 
-    virtual lldb::LanguageType GetMinimumLanguage(void *type) override;
+    virtual lldb::LanguageType GetMinimumLanguage(lldb::opaque_compiler_type_t type) override;
 
-    virtual lldb::TypeClass GetTypeClass(void *type) override;
+    virtual lldb::TypeClass GetTypeClass(lldb::opaque_compiler_type_t type) override;
 
     //----------------------------------------------------------------------
     // Creating related types
     //----------------------------------------------------------------------
 
-    virtual CompilerType GetArrayElementType(void *type, uint64_t *stride = nullptr) override;
+    virtual CompilerType GetArrayElementType(lldb::opaque_compiler_type_t type, uint64_t *stride = nullptr) override;
 
-    virtual CompilerType GetCanonicalType(void *type) override;
+    virtual CompilerType GetCanonicalType(lldb::opaque_compiler_type_t type) override;
 
     // Returns -1 if this isn't a function of if the function doesn't have a prototype
     // Returns a value >= 0 if there is a prototype.
-    virtual int GetFunctionArgumentCount(void *type) override;
+    virtual int GetFunctionArgumentCount(lldb::opaque_compiler_type_t type) override;
 
-    virtual CompilerType GetFunctionArgumentTypeAtIndex(void *type, size_t idx) override;
+    virtual CompilerType GetFunctionArgumentTypeAtIndex(lldb::opaque_compiler_type_t type, size_t idx) override;
 
-    virtual CompilerType GetFunctionReturnType(void *type) override;
+    virtual CompilerType GetFunctionReturnType(lldb::opaque_compiler_type_t type) override;
 
-    virtual size_t GetNumMemberFunctions(void *type) override;
+    virtual size_t GetNumMemberFunctions(lldb::opaque_compiler_type_t type) override;
 
-    virtual TypeMemberFunctionImpl GetMemberFunctionAtIndex(void *type, size_t idx) override;
+    virtual TypeMemberFunctionImpl GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type, size_t idx) override;
 
-    virtual CompilerType GetPointeeType(void *type) override;
+    virtual CompilerType GetPointeeType(lldb::opaque_compiler_type_t type) override;
 
-    virtual CompilerType GetPointerType(void *type) override;
+    virtual CompilerType GetPointerType(lldb::opaque_compiler_type_t type) override;
 
     //----------------------------------------------------------------------
     // Exploring the type
     //----------------------------------------------------------------------
 
-    virtual uint64_t GetBitSize(void *type, ExecutionContextScope *exe_scope) override;
+    virtual uint64_t GetBitSize(lldb::opaque_compiler_type_t type, ExecutionContextScope *exe_scope) override;
 
-    virtual lldb::Encoding GetEncoding(void *type, uint64_t &count) override;
+    virtual lldb::Encoding GetEncoding(lldb::opaque_compiler_type_t type, uint64_t &count) override;
 
-    virtual lldb::Format GetFormat(void *type) override;
+    virtual lldb::Format GetFormat(lldb::opaque_compiler_type_t type) override;
 
-    virtual uint32_t GetNumChildren(void *type, bool omit_empty_base_classes) override;
+    virtual uint32_t GetNumChildren(lldb::opaque_compiler_type_t type, bool omit_empty_base_classes) override;
 
-    virtual lldb::BasicType GetBasicTypeEnumeration(void *type) override;
+    virtual lldb::BasicType GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) override;
 
     virtual CompilerType GetBuiltinTypeForEncodingAndBitSize (lldb::Encoding encoding,
                                                               size_t bit_size) override;
 
-    virtual uint32_t GetNumFields(void *type) override;
+    virtual uint32_t GetNumFields(lldb::opaque_compiler_type_t type) override;
 
-    virtual CompilerType GetFieldAtIndex(void *type, size_t idx, std::string &name, uint64_t *bit_offset_ptr,
+    virtual CompilerType GetFieldAtIndex(lldb::opaque_compiler_type_t type, size_t idx, std::string &name, uint64_t *bit_offset_ptr,
                                          uint32_t *bitfield_bit_size_ptr, bool *is_bitfield_ptr) override;
 
     virtual uint32_t
-    GetNumDirectBaseClasses(void *type) override
+    GetNumDirectBaseClasses(lldb::opaque_compiler_type_t type) override
     {
         return 0;
     }
 
     virtual uint32_t
-    GetNumVirtualBaseClasses(void *type) override
+    GetNumVirtualBaseClasses(lldb::opaque_compiler_type_t type) override
     {
         return 0;
     }
 
     virtual CompilerType
-    GetDirectBaseClassAtIndex(void *type, size_t idx, uint32_t *bit_offset_ptr) override
+    GetDirectBaseClassAtIndex(lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) override
     {
         return CompilerType();
     }
 
     virtual CompilerType
-    GetVirtualBaseClassAtIndex(void *type, size_t idx, uint32_t *bit_offset_ptr) override
+    GetVirtualBaseClassAtIndex(lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) override
     {
         return CompilerType();
     }
 
-    virtual CompilerType GetChildCompilerTypeAtIndex(void *type, ExecutionContext *exe_ctx, size_t idx,
+    virtual CompilerType GetChildCompilerTypeAtIndex(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx,
                                                      bool transparent_pointers, bool omit_empty_base_classes,
                                                      bool ignore_array_bounds, std::string &child_name,
                                                      uint32_t &child_byte_size, int32_t &child_byte_offset,
                                                      uint32_t &child_bitfield_bit_size,
                                                      uint32_t &child_bitfield_bit_offset, bool &child_is_base_class,
                                                      bool &child_is_deref_of_parent, ValueObject *valobj) override;
 
     // Lookup a child given a name. This function will match base class names
     // and member member names in "clang_type" only, not descendants.
-    virtual uint32_t GetIndexOfChildWithName(void *type, const char *name, bool omit_empty_base_classes) override;
+    virtual uint32_t GetIndexOfChildWithName(lldb::opaque_compiler_type_t type, const char *name, bool omit_empty_base_classes) override;
 
     // Lookup a child member given a name. This function will match member names
     // only and will descend into "clang_type" children in search for the first
     // member in this class, or any base class that matches "name".
     // TODO: Return all matches for a given name by returning a vector<vector<uint32_t>>
     // so we catch all names that match a given child name, not just the first.
-    virtual size_t GetIndexOfChildMemberWithName(void *type, const char *name, bool omit_empty_base_classes,
+    virtual size_t GetIndexOfChildMemberWithName(lldb::opaque_compiler_type_t type, const char *name, bool omit_empty_base_classes,
                                                  std::vector<uint32_t> &child_indexes) override;
 
     virtual size_t
-    GetNumTemplateArguments(void *type) override
+    GetNumTemplateArguments(lldb::opaque_compiler_type_t type) override
     {
         return 0;
     }
 
     virtual CompilerType
-    GetTemplateArgument(void *type, size_t idx, lldb::TemplateArgumentKind &kind) override
+    GetTemplateArgument(lldb::opaque_compiler_type_t type, size_t idx, lldb::TemplateArgumentKind &kind) override
     {
         return CompilerType();
     }
 
     //----------------------------------------------------------------------
     // Dumping types
     //----------------------------------------------------------------------
-    virtual void DumpValue(void *type, ExecutionContext *exe_ctx, Stream *s, lldb::Format format,
+    virtual void DumpValue(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s, lldb::Format format,
                            const DataExtractor &data, lldb::offset_t data_offset, size_t data_byte_size,
                            uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset, bool show_types, bool show_summary,
                            bool verbose, uint32_t depth) override;
 
-    virtual bool DumpTypeValue(void *type, Stream *s, lldb::Format format, const DataExtractor &data,
+    virtual bool DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s, lldb::Format format, const DataExtractor &data,
                                lldb::offset_t data_offset, size_t data_byte_size, uint32_t bitfield_bit_size,
                                uint32_t bitfield_bit_offset, ExecutionContextScope *exe_scope) override;
 
-    virtual void DumpTypeDescription(void *type) override; // Dump to stdout
+    virtual void DumpTypeDescription(lldb::opaque_compiler_type_t type) override; // Dump to stdout
 
-    virtual void DumpTypeDescription(void *type, Stream *s) override;
+    virtual void DumpTypeDescription(lldb::opaque_compiler_type_t type, Stream *s) override;
 
     //----------------------------------------------------------------------
     // TODO: These methods appear unused. Should they be removed?
     //----------------------------------------------------------------------
 
-    virtual bool IsRuntimeGeneratedType(void *type) override;
+    virtual bool IsRuntimeGeneratedType(lldb::opaque_compiler_type_t type) override;
 
-    virtual void DumpSummary(void *type, ExecutionContext *exe_ctx, Stream *s, const DataExtractor &data,
+    virtual void DumpSummary(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s, const DataExtractor &data,
                              lldb::offset_t data_offset, size_t data_byte_size) override;
 
     // Converts "s" to a floating point value and place resulting floating
     // point bytes in the "dst" buffer.
-    virtual size_t ConvertStringToFloatValue(void *type, const char *s, uint8_t *dst, size_t dst_size) override;
+    virtual size_t ConvertStringToFloatValue(lldb::opaque_compiler_type_t type, const char *s, uint8_t *dst, size_t dst_size) override;
 
     //----------------------------------------------------------------------
     // TODO: Determine if these methods should move to ClangASTContext.
     //----------------------------------------------------------------------
 
-    virtual bool IsPointerOrReferenceType(void *type, CompilerType *pointee_type = NULL) override;
+    virtual bool IsPointerOrReferenceType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type = NULL) override;
 
-    virtual unsigned GetTypeQualifiers(void *type) override;
+    virtual unsigned GetTypeQualifiers(lldb::opaque_compiler_type_t type) override;
 
-    virtual bool IsCStringType(void *type, uint32_t &length) override;
+    virtual bool IsCStringType(lldb::opaque_compiler_type_t type, uint32_t &length) override;
 
-    virtual size_t GetTypeBitAlign(void *type) override;
+    virtual size_t GetTypeBitAlign(lldb::opaque_compiler_type_t type) override;
 
     virtual CompilerType GetBasicTypeFromAST(lldb::BasicType basic_type) override;
 
-    virtual bool IsBeingDefined(void *type) override;
+    virtual bool IsBeingDefined(lldb::opaque_compiler_type_t type) override;
 
-    virtual bool IsConst(void *type) override;
+    virtual bool IsConst(lldb::opaque_compiler_type_t type) override;
 
-    virtual uint32_t IsHomogeneousAggregate(void *type, CompilerType *base_type_ptr) override;
+    virtual uint32_t IsHomogeneousAggregate(lldb::opaque_compiler_type_t type, CompilerType *base_type_ptr) override;
 
-    virtual bool IsPolymorphicClass(void *type) override;
+    virtual bool IsPolymorphicClass(lldb::opaque_compiler_type_t type) override;
 
-    virtual bool IsTypedefType(void *type) override;
+    virtual bool IsTypedefType(lldb::opaque_compiler_type_t type) override;
 
     // If the current object represents a typedef type, get the underlying type
-    virtual CompilerType GetTypedefedType(void *type) override;
+    virtual CompilerType GetTypedefedType(lldb::opaque_compiler_type_t type) override;
 
-    virtual bool IsVectorType(void *type, CompilerType *element_type, uint64_t *size) override;
+    virtual bool IsVectorType(lldb::opaque_compiler_type_t type, CompilerType *element_type, uint64_t *size) override;
 
-    virtual CompilerType GetFullyUnqualifiedType(void *type) override;
+    virtual CompilerType GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type) override;
 
-    virtual CompilerType GetNonReferenceType(void *type) override;
+    virtual CompilerType GetNonReferenceType(lldb::opaque_compiler_type_t type) override;
 
-    virtual bool IsReferenceType(void *type, CompilerType *pointee_type = nullptr, bool *is_rvalue = nullptr) override;
+    virtual bool IsReferenceType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type = nullptr, bool *is_rvalue = nullptr) override;
 
   private:
     typedef std::map<ConstString, std::unique_ptr<GoType>> TypeMap;
     int m_pointer_byte_size;
     int m_int_byte_size;
     std::unique_ptr<TypeMap> m_types;
     std::unique_ptr<DWARFASTParser> m_dwarf_ast_parser_ap;
 
     GoASTContext(const GoASTContext &) = delete;
     const GoASTContext &operator=(const GoASTContext &) = delete;
 };
 }
 
 #endif /* defined(__lldb__GoASTContext__) */

lldb/trunk/include/lldb/Symbol/TaggedASTType.h

 template <unsigned int C> class TaggedASTType : public CompilerType
 {
 public:
     TaggedASTType (const CompilerType &clang_type) :
         CompilerType(clang_type)
     {
     }
 
-    TaggedASTType (void *type, TypeSystem * type_system) :
+    TaggedASTType (lldb::opaque_compiler_type_t type, TypeSystem * type_system) :
         CompilerType(type_system, type)
     {
     }
     
     TaggedASTType (const TaggedASTType<C> &tw) :
         CompilerType(tw)
     {
     }

lldb/trunk/include/lldb/Symbol/TypeSystem.h

DeclContextIsClassMethod (void *opaque_decl_ctx,
                               bool *is_instance_method_ptr,
                               ConstString *language_object_name_ptr) = 0;
 
     //----------------------------------------------------------------------
     // Tests
     //----------------------------------------------------------------------
     
     virtual bool
-    IsArrayType (void *type,
+    IsArrayType (lldb::opaque_compiler_type_t type,
                  CompilerType *element_type,
                  uint64_t *size,
                  bool *is_incomplete) = 0;
     
     virtual bool
-    IsAggregateType (void *type) = 0;
+    IsAggregateType (lldb::opaque_compiler_type_t type) = 0;
     
     virtual bool
-    IsCharType (void *type) = 0;
+    IsCharType (lldb::opaque_compiler_type_t type) = 0;
     
     virtual bool
-    IsCompleteType (void *type) = 0;
+    IsCompleteType (lldb::opaque_compiler_type_t type) = 0;
     
     virtual bool
-    IsDefined(void *type) = 0;
+    IsDefined(lldb::opaque_compiler_type_t type) = 0;
     
     virtual bool
-    IsFloatingPointType (void *type, uint32_t &count, bool &is_complex) = 0;
+    IsFloatingPointType (lldb::opaque_compiler_type_t type, uint32_t &count, bool &is_complex) = 0;
     
     virtual bool
-    IsFunctionType (void *type, bool *is_variadic_ptr) = 0;
+    IsFunctionType (lldb::opaque_compiler_type_t type, bool *is_variadic_ptr) = 0;
 
     virtual size_t
-    GetNumberOfFunctionArguments (void *type) = 0;
+    GetNumberOfFunctionArguments (lldb::opaque_compiler_type_t type) = 0;
     
     virtual CompilerType
-    GetFunctionArgumentAtIndex (void *type, const size_t index) = 0;
+    GetFunctionArgumentAtIndex (lldb::opaque_compiler_type_t type, const size_t index) = 0;
     
     virtual bool
-    IsFunctionPointerType (void *type) = 0;
+    IsFunctionPointerType (lldb::opaque_compiler_type_t type) = 0;
     
     virtual bool
-    IsIntegerType (void *type, bool &is_signed) = 0;
+    IsIntegerType (lldb::opaque_compiler_type_t type, bool &is_signed) = 0;
     
     virtual bool
-    IsPossibleDynamicType (void *type,
+    IsPossibleDynamicType (lldb::opaque_compiler_type_t type,
                            CompilerType *target_type, // Can pass NULL
                            bool check_cplusplus,
                            bool check_objc) = 0;
     
     virtual bool
-    IsPointerType (void *type, CompilerType *pointee_type) = 0;
+    IsPointerType (lldb::opaque_compiler_type_t type, CompilerType *pointee_type) = 0;
     
     virtual bool
-    IsScalarType (void *type) = 0;
+    IsScalarType (lldb::opaque_compiler_type_t type) = 0;
     
     virtual bool
-    IsVoidType (void *type) = 0;
+    IsVoidType (lldb::opaque_compiler_type_t type) = 0;
 
     // TypeSystems can support more than one language
     virtual bool
     SupportsLanguage (lldb::LanguageType language) = 0;
 
     //----------------------------------------------------------------------
     // Type Completion
     //----------------------------------------------------------------------
     
     virtual bool
-    GetCompleteType (void *type) = 0;
+    GetCompleteType (lldb::opaque_compiler_type_t type) = 0;
     
     //----------------------------------------------------------------------
     // AST related queries
     //----------------------------------------------------------------------
     
     virtual uint32_t
     GetPointerByteSize () = 0;
     
     //----------------------------------------------------------------------
     // Accessors
     //----------------------------------------------------------------------
     
     virtual ConstString
-    GetTypeName (void *type) = 0;
+    GetTypeName (lldb::opaque_compiler_type_t type) = 0;
     
     virtual uint32_t
-    GetTypeInfo (void *type, CompilerType *pointee_or_element_clang_type) = 0;
+    GetTypeInfo (lldb::opaque_compiler_type_t type, CompilerType *pointee_or_element_clang_type) = 0;
     
     virtual lldb::LanguageType
-    GetMinimumLanguage (void *type) = 0;
+    GetMinimumLanguage (lldb::opaque_compiler_type_t type) = 0;
     
     virtual lldb::TypeClass
-    GetTypeClass (void *type) = 0;
+    GetTypeClass (lldb::opaque_compiler_type_t type) = 0;
     
     //----------------------------------------------------------------------
     // Creating related types
     //----------------------------------------------------------------------
     
     virtual CompilerType
-    GetArrayElementType (void *type, uint64_t *stride) = 0;
+    GetArrayElementType (lldb::opaque_compiler_type_t type, uint64_t *stride) = 0;
     
     virtual CompilerType
-    GetCanonicalType (void *type) = 0;
+    GetCanonicalType (lldb::opaque_compiler_type_t type) = 0;
     
     // Returns -1 if this isn't a function of if the function doesn't have a prototype
     // Returns a value >= 0 if there is a prototype.
     virtual int
-    GetFunctionArgumentCount (void *type) = 0;
+    GetFunctionArgumentCount (lldb::opaque_compiler_type_t type) = 0;
     
     virtual CompilerType
-    GetFunctionArgumentTypeAtIndex (void *type, size_t idx) = 0;
+    GetFunctionArgumentTypeAtIndex (lldb::opaque_compiler_type_t type, size_t idx) = 0;
     
     virtual CompilerType
-    GetFunctionReturnType (void *type) = 0;
+    GetFunctionReturnType (lldb::opaque_compiler_type_t type) = 0;
     
     virtual size_t
-    GetNumMemberFunctions (void *type) = 0;
+    GetNumMemberFunctions (lldb::opaque_compiler_type_t type) = 0;
     
     virtual TypeMemberFunctionImpl
-    GetMemberFunctionAtIndex (void *type, size_t idx) = 0;
+    GetMemberFunctionAtIndex (lldb::opaque_compiler_type_t type, size_t idx) = 0;
     
     virtual CompilerType
-    GetPointeeType (void *type) = 0;
+    GetPointeeType (lldb::opaque_compiler_type_t type) = 0;
     
     virtual CompilerType
-    GetPointerType (void *type) = 0;
+    GetPointerType (lldb::opaque_compiler_type_t type) = 0;
 
     virtual CompilerType
-    GetLValueReferenceType (void *type);
+    GetLValueReferenceType (lldb::opaque_compiler_type_t type);
 
     virtual CompilerType
-    GetRValueReferenceType (void *type);
+    GetRValueReferenceType (lldb::opaque_compiler_type_t type);
 
     virtual CompilerType
-    AddConstModifier (void *type);
+    AddConstModifier (lldb::opaque_compiler_type_t type);
 
     virtual CompilerType
-    AddVolatileModifier (void *type);
+    AddVolatileModifier (lldb::opaque_compiler_type_t type);
 
     virtual CompilerType
-    AddRestrictModifier (void *type);
+    AddRestrictModifier (lldb::opaque_compiler_type_t type);
 
     virtual CompilerType
-    CreateTypedef (void *type, const char *name, const CompilerDeclContext &decl_ctx);
+    CreateTypedef (lldb::opaque_compiler_type_t type, const char *name, const CompilerDeclContext &decl_ctx);
 
     //----------------------------------------------------------------------
     // Exploring the type
     //----------------------------------------------------------------------
     
     virtual uint64_t
-    GetBitSize (void *type, ExecutionContextScope *exe_scope) = 0;
+    GetBitSize (lldb::opaque_compiler_type_t type, ExecutionContextScope *exe_scope) = 0;
     
     virtual lldb::Encoding
-    GetEncoding (void *type, uint64_t &count) = 0;
+    GetEncoding (lldb::opaque_compiler_type_t type, uint64_t &count) = 0;
     
     virtual lldb::Format
-    GetFormat (void *type) = 0;
+    GetFormat (lldb::opaque_compiler_type_t type) = 0;
     
     virtual uint32_t
-    GetNumChildren (void *type, bool omit_empty_base_classes) = 0;
+    GetNumChildren (lldb::opaque_compiler_type_t type, bool omit_empty_base_classes) = 0;
 
     virtual CompilerType
     GetBuiltinTypeByName (const ConstString &name);
 
     virtual lldb::BasicType
-    GetBasicTypeEnumeration (void *type) = 0;
+    GetBasicTypeEnumeration (lldb::opaque_compiler_type_t type) = 0;
 
     virtual void
-    ForEachEnumerator (void *type, std::function <bool (const CompilerType &integer_type, const ConstString &name, const llvm::APSInt &value)> const &callback)
+    ForEachEnumerator (lldb::opaque_compiler_type_t type, std::function <bool (const CompilerType &integer_type, const ConstString &name, const llvm::APSInt &value)> const &callback)
     {
     }
 
     virtual uint32_t
-    GetNumFields (void *type) = 0;
+    GetNumFields (lldb::opaque_compiler_type_t type) = 0;
     
     virtual CompilerType
-    GetFieldAtIndex (void *type,
+    GetFieldAtIndex (lldb::opaque_compiler_type_t type,
                      size_t idx,
                      std::string& name,
                      uint64_t *bit_offset_ptr,
                      uint32_t *bitfield_bit_size_ptr,
                      bool *is_bitfield_ptr) = 0;
 
     virtual uint32_t
-    GetNumDirectBaseClasses (void *type) = 0;
+    GetNumDirectBaseClasses (lldb::opaque_compiler_type_t type) = 0;
 
     virtual uint32_t
-    GetNumVirtualBaseClasses (void *type) = 0;
+    GetNumVirtualBaseClasses (lldb::opaque_compiler_type_t type) = 0;
 
     virtual CompilerType
-    GetDirectBaseClassAtIndex (void *type,
+    GetDirectBaseClassAtIndex (lldb::opaque_compiler_type_t type,
                                size_t idx,
                                uint32_t *bit_offset_ptr) = 0;
 
     virtual CompilerType
-    GetVirtualBaseClassAtIndex (void *type,
+    GetVirtualBaseClassAtIndex (lldb::opaque_compiler_type_t type,
                                 size_t idx,
                                 uint32_t *bit_offset_ptr) = 0;
 
     virtual CompilerType
-    GetChildCompilerTypeAtIndex (void *type,
+    GetChildCompilerTypeAtIndex (lldb::opaque_compiler_type_t type,
                                  ExecutionContext *exe_ctx,
                                  size_t idx,
                                  bool transparent_pointers,
                                  bool omit_empty_base_classes,
                                  bool ignore_array_bounds,
                                  std::string& child_name,
                                  uint32_t &child_byte_size,
                                  int32_t &child_byte_offset,
                                  uint32_t &child_bitfield_bit_size,
                                  uint32_t &child_bitfield_bit_offset,
                                  bool &child_is_base_class,
                                  bool &child_is_deref_of_parent,
                                  ValueObject *valobj) = 0;
     
     // Lookup a child given a name. This function will match base class names
     // and member member names in "clang_type" only, not descendants.
     virtual uint32_t
-    GetIndexOfChildWithName (void *type,
+    GetIndexOfChildWithName (lldb::opaque_compiler_type_t type,
                              const char *name,
                              bool omit_empty_base_classes) = 0;
     
     // Lookup a child member given a name. This function will match member names
     // only and will descend into "clang_type" children in search for the first
     // member in this class, or any base class that matches "name".
     // TODO: Return all matches for a given name by returning a vector<vector<uint32_t>>
     // so we catch all names that match a given child name, not just the first.
     virtual size_t
-    GetIndexOfChildMemberWithName (void *type,
+    GetIndexOfChildMemberWithName (lldb::opaque_compiler_type_t type,
                                    const char *name,
                                    bool omit_empty_base_classes,
                                    std::vector<uint32_t>& child_indexes) = 0;
     
     virtual size_t
-    GetNumTemplateArguments (void *type) = 0;
+    GetNumTemplateArguments (lldb::opaque_compiler_type_t type) = 0;
     
     virtual CompilerType
-    GetTemplateArgument (void *type,
+    GetTemplateArgument (lldb::opaque_compiler_type_t type,
                          size_t idx,
                          lldb::TemplateArgumentKind &kind) = 0;
     
     //----------------------------------------------------------------------
     // Dumping types
     //----------------------------------------------------------------------
     virtual void
-    DumpValue (void *type,
+    DumpValue (lldb::opaque_compiler_type_t type,
                ExecutionContext *exe_ctx,
                Stream *s,
                lldb::Format format,
                const DataExtractor &data,
                lldb::offset_t data_offset,
                size_t data_byte_size,
                uint32_t bitfield_bit_size,
                uint32_t bitfield_bit_offset,
                bool show_types,
                bool show_summary,
                bool verbose,
                uint32_t depth) = 0;
     
     virtual bool
-    DumpTypeValue (void *type,
+    DumpTypeValue (lldb::opaque_compiler_type_t type,
                    Stream *s,
                    lldb::Format format,
                    const DataExtractor &data,
                    lldb::offset_t data_offset,
                    size_t data_byte_size,
                    uint32_t bitfield_bit_size,
                    uint32_t bitfield_bit_offset,
                    ExecutionContextScope *exe_scope) = 0;
     
     virtual void
-    DumpTypeDescription (void *type) = 0; // Dump to stdout
+    DumpTypeDescription (lldb::opaque_compiler_type_t type) = 0; // Dump to stdout
     
     virtual void
-    DumpTypeDescription (void *type, Stream *s) = 0;
+    DumpTypeDescription (lldb::opaque_compiler_type_t type, Stream *s) = 0;
     
     //----------------------------------------------------------------------
     // TODO: These methods appear unused. Should they be removed?
     //----------------------------------------------------------------------
 
     virtual bool
-    IsRuntimeGeneratedType (void *type) = 0;
+    IsRuntimeGeneratedType (lldb::opaque_compiler_type_t type) = 0;
     
     virtual void
-    DumpSummary (void *type,
+    DumpSummary (lldb::opaque_compiler_type_t type,
                  ExecutionContext *exe_ctx,
                  Stream *s,
                  const DataExtractor &data,
                  lldb::offset_t data_offset,
                  size_t data_byte_size) = 0;
 
     // Converts "s" to a floating point value and place resulting floating
     // point bytes in the "dst" buffer.
     virtual size_t
-    ConvertStringToFloatValue (void *type,
+    ConvertStringToFloatValue (lldb::opaque_compiler_type_t type,
                                const char *s,
                                uint8_t *dst,
                                size_t dst_size) = 0;
     
     //----------------------------------------------------------------------
     // TODO: Determine if these methods should move to ClangASTContext.
     //----------------------------------------------------------------------
 
     virtual bool
-    IsPointerOrReferenceType (void *type, CompilerType *pointee_type) = 0;
+    IsPointerOrReferenceType (lldb::opaque_compiler_type_t type, CompilerType *pointee_type) = 0;
 
     virtual unsigned
-    GetTypeQualifiers(void *type) = 0;
+    GetTypeQualifiers(lldb::opaque_compiler_type_t type) = 0;
     
     virtual bool
-    IsCStringType (void *type, uint32_t &length) = 0;
+    IsCStringType (lldb::opaque_compiler_type_t type, uint32_t &length) = 0;
     
     virtual size_t
-    GetTypeBitAlign (void *type) = 0;
+    GetTypeBitAlign (lldb::opaque_compiler_type_t type) = 0;
     
     virtual CompilerType
     GetBasicTypeFromAST (lldb::BasicType basic_type) = 0;
     
     virtual CompilerType
     GetBuiltinTypeForEncodingAndBitSize(lldb::Encoding encoding,
                                         size_t bit_size) = 0;
 
     virtual bool
-    IsBeingDefined (void *type) = 0;
+    IsBeingDefined (lldb::opaque_compiler_type_t type) = 0;
     
     virtual bool
-    IsConst(void *type) = 0;
+    IsConst(lldb::opaque_compiler_type_t type) = 0;
     
     virtual uint32_t
-    IsHomogeneousAggregate (void *type, CompilerType* base_type_ptr) = 0;
+    IsHomogeneousAggregate (lldb::opaque_compiler_type_t type, CompilerType* base_type_ptr) = 0;
     
     virtual bool
-    IsPolymorphicClass (void *type) = 0;
+    IsPolymorphicClass (lldb::opaque_compiler_type_t type) = 0;
     
     virtual bool
-    IsTypedefType (void *type) = 0;
+    IsTypedefType (lldb::opaque_compiler_type_t type) = 0;
     
     // If the current object represents a typedef type, get the underlying type
     virtual CompilerType
-    GetTypedefedType (void *type) = 0;
+    GetTypedefedType (lldb::opaque_compiler_type_t type) = 0;
 
     virtual bool
-    IsVectorType (void *type,
+    IsVectorType (lldb::opaque_compiler_type_t type,
                   CompilerType *element_type,
                   uint64_t *size) = 0;
     
     virtual CompilerType
-    GetFullyUnqualifiedType (void *type) = 0;
+    GetFullyUnqualifiedType (lldb::opaque_compiler_type_t type) = 0;
     
     virtual CompilerType
-    GetNonReferenceType (void *type) = 0;
+    GetNonReferenceType (lldb::opaque_compiler_type_t type) = 0;
     
     virtual bool
-    IsReferenceType (void *type, CompilerType *pointee_type, bool* is_rvalue) = 0;
+    IsReferenceType (lldb::opaque_compiler_type_t type, CompilerType *pointee_type, bool* is_rvalue) = 0;
     
     virtual UserExpression *
     GetUserExpression (const char *expr,
                        const char *expr_prefix,
                        lldb::LanguageType language,
                        Expression::ResultType desired_type)
     {
         return nullptr;

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)
     {
-        opaque_compiler_type_t clang_type = nullptr;
+        lldb::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, opaque_compiler_type_t clang_type, const uint8_t* bytes, size_t byte_size, int apint_byte_order, std::string &float_str)
+//ClangASTContext::ConvertFloatValueToString (ASTContext *ast, lldb::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;
 //

 }
 
 
 //----------------------------------------------------------------------
 // Tests
 //----------------------------------------------------------------------
 
 bool
-ClangASTContext::IsAggregateType (void* type)
+ClangASTContext::IsAggregateType (lldb::opaque_compiler_type_t type)
 {
     clang::QualType qual_type (GetCanonicalQualType(type));
     
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class)
     {
         case clang::Type::IncompleteArray:
         case clang::Type::VariableArray:
switch (type_class)
         default:
             break;
     }
     // The clang type does have a value
     return false;
 }
 
 bool
-ClangASTContext::IsArrayType (void* type,
+ClangASTContext::IsArrayType (lldb::opaque_compiler_type_t type,
                               CompilerType *element_type_ptr,
                               uint64_t *size,
                               bool *is_incomplete)
 {
     clang::QualType qual_type (GetCanonicalQualType(type));
     
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class)
ClangASTContext::IsArrayType (lldb::opaque_compiler_type_t type,
     if (size)
         *size = 0;
     if (is_incomplete)
         *is_incomplete = false;
     return false;
 }
 
 bool
-ClangASTContext::IsVectorType (void* type,
+ClangASTContext::IsVectorType (lldb::opaque_compiler_type_t type,
                                CompilerType *element_type,
                                uint64_t *size)
 {
     clang::QualType qual_type (GetCanonicalQualType(type));
     
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class)
     {
switch (type_class)
         }
         default:
             break;
     }
     return false;
 }
 
 bool
-ClangASTContext::IsRuntimeGeneratedType (void* type)
+ClangASTContext::IsRuntimeGeneratedType (lldb::opaque_compiler_type_t type)
 {
     clang::DeclContext* decl_ctx = ClangASTContext::GetASTContext(getASTContext())->GetDeclContextForType(GetQualType(type));
     if (!decl_ctx)
         return false;
     
     if (!llvm::isa<clang::ObjCInterfaceDecl>(decl_ctx))
         return false;
     
     clang::ObjCInterfaceDecl *result_iface_decl = llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl_ctx);
     
     ClangASTMetadata* ast_metadata = ClangASTContext::GetMetadata(getASTContext(), result_iface_decl);
     if (!ast_metadata)
         return false;
     return (ast_metadata->GetISAPtr() != 0);
 }
 
 bool
-ClangASTContext::IsCharType (void* type)
+ClangASTContext::IsCharType (lldb::opaque_compiler_type_t type)
 {
     return GetQualType(type).getUnqualifiedType()->isCharType();
 }
 
 
 bool
-ClangASTContext::IsCompleteType (void* type)
+ClangASTContext::IsCompleteType (lldb::opaque_compiler_type_t type)
 {
     const bool allow_completion = false;
     return GetCompleteQualType (getASTContext(), GetQualType(type), allow_completion);
 }
 
 bool
-ClangASTContext::IsConst(void* type)
+ClangASTContext::IsConst(lldb::opaque_compiler_type_t type)
 {
     return GetQualType(type).isConstQualified();
 }
 
 bool
-ClangASTContext::IsCStringType (void* type, uint32_t &length)
+ClangASTContext::IsCStringType (lldb::opaque_compiler_type_t type, uint32_t &length)
 {
     CompilerType pointee_or_element_clang_type;
     length = 0;
     Flags type_flags (GetTypeInfo (type, &pointee_or_element_clang_type));
     
     if (!pointee_or_element_clang_type.IsValid())
         return false;
     
if (type_flags.AnySet (eTypeIsArray | eTypeIsPointer))
             return true;
             
         }
     }
     return false;
 }
 
 bool
-ClangASTContext::IsFunctionType (void* type, bool *is_variadic_ptr)
+ClangASTContext::IsFunctionType (lldb::opaque_compiler_type_t type, bool *is_variadic_ptr)
 {
     if (type)
     {
         clang::QualType qual_type (GetCanonicalQualType(type));
         
         if (qual_type->isFunctionType())
         {
             if (is_variadic_ptr)
if (type)
                 break;
         }
     }
     return false;
 }
 
 // Used to detect "Homogeneous Floating-point Aggregates"
 uint32_t
-ClangASTContext::IsHomogeneousAggregate (void* type, CompilerType* base_type_ptr)
+ClangASTContext::IsHomogeneousAggregate (lldb::opaque_compiler_type_t type, CompilerType* base_type_ptr)
 {
     if (!type)
         return 0;
     
     clang::QualType qual_type(GetCanonicalQualType(type));
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class)
     {
switch (type_class)
             return IsHomogeneousAggregate(llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), base_type_ptr);
         default:
             break;
     }
     return 0;
 }
 
 size_t
-ClangASTContext::GetNumberOfFunctionArguments (void* type)
+ClangASTContext::GetNumberOfFunctionArguments (lldb::opaque_compiler_type_t type)
 {
     if (type)
     {
         clang::QualType qual_type (GetCanonicalQualType(type));
         const clang::FunctionProtoType* func = llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
         if (func)
             return func->getNumParams();
     }
     return 0;
 }
 
 CompilerType
-ClangASTContext::GetFunctionArgumentAtIndex (void* type, const size_t index)
+ClangASTContext::GetFunctionArgumentAtIndex (lldb::opaque_compiler_type_t type, const size_t index)
 {
     if (type)
     {
         clang::QualType qual_type (GetCanonicalQualType(type));
         const clang::FunctionProtoType* func = llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
         if (func)
         {
             if (index < func->getNumParams())
                 return CompilerType(getASTContext(), func->getParamType(index));
         }
     }
     return CompilerType();
 }
 
 bool
-ClangASTContext::IsFunctionPointerType (void* type)
+ClangASTContext::IsFunctionPointerType (lldb::opaque_compiler_type_t type)
 {
     if (type)
     {
         clang::QualType qual_type (GetCanonicalQualType(type));
         
         if (qual_type->isFunctionPointerType())
             return true;
         
if (type)
                 break;
         }
     }
     return false;
     
 }
 
 bool
-ClangASTContext::IsIntegerType (void* type, bool &is_signed)
+ClangASTContext::IsIntegerType (lldb::opaque_compiler_type_t type, bool &is_signed)
 {
     if (!type)
         return false;
     
     clang::QualType qual_type (GetCanonicalQualType(type));
     const clang::BuiltinType *builtin_type = llvm::dyn_cast<clang::BuiltinType>(qual_type->getCanonicalTypeInternal());
     
     if (builtin_type)
     {
         if (builtin_type->isInteger())
         {
             is_signed = builtin_type->isSignedInteger();
             return true;
         }
     }
     
     return false;
 }
 
 bool
-ClangASTContext::IsPointerType (void* type, CompilerType *pointee_type)
+ClangASTContext::IsPointerType (lldb::opaque_compiler_type_t type, CompilerType *pointee_type)
 {
     if (type)
     {
         clang::QualType qual_type (GetCanonicalQualType(type));
         const clang::Type::TypeClass type_class = qual_type->getTypeClass();
         switch (type_class)
         {
             case clang::Type::Builtin:
ClangASTContext::IsPointerType (lldb::opaque_compiler_type_t type, CompilerType *pointee_type)
     }
     if (pointee_type)
         pointee_type->Clear();
     return false;
 }
 
 
 bool
-ClangASTContext::IsPointerOrReferenceType (void* type, CompilerType *pointee_type)
+ClangASTContext::IsPointerOrReferenceType (lldb::opaque_compiler_type_t type, CompilerType *pointee_type)
 {
     if (type)
     {
         clang::QualType qual_type (GetCanonicalQualType(type));
         const clang::Type::TypeClass type_class = qual_type->getTypeClass();
         switch (type_class)
         {
             case clang::Type::Builtin:
ClangASTContext::IsPointerOrReferenceType (lldb::opaque_compiler_type_t type, CompilerType *pointee_type)
     }
     if (pointee_type)
         pointee_type->Clear();
     return false;
 }
 
 
 bool
-ClangASTContext::IsReferenceType (void* type, CompilerType *pointee_type, bool* is_rvalue)
+ClangASTContext::IsReferenceType (lldb::opaque_compiler_type_t type, CompilerType *pointee_type, bool* is_rvalue)
 {
     if (type)
     {
         clang::QualType qual_type (GetCanonicalQualType(type));
         const clang::Type::TypeClass type_class = qual_type->getTypeClass();
         
         switch (type_class)
         {
if (type)
         }
     }
     if (pointee_type)
         pointee_type->Clear();
     return false;
 }
 
 bool
-ClangASTContext::IsFloatingPointType (void* type, uint32_t &count, bool &is_complex)
+ClangASTContext::IsFloatingPointType (lldb::opaque_compiler_type_t type, uint32_t &count, bool &is_complex)
 {
     if (type)
     {
         clang::QualType qual_type (GetCanonicalQualType(type));
         
         if (const clang::BuiltinType *BT = llvm::dyn_cast<clang::BuiltinType>(qual_type->getCanonicalTypeInternal()))
         {
             clang::BuiltinType::Kind kind = BT->getKind();
ClangASTContext::IsFloatingPointType (lldb::opaque_compiler_type_t type, uint32_t &count, bool &is_complex)
     }
     count = 0;
     is_complex = false;
     return false;
 }
 
 
 bool
-ClangASTContext::IsDefined(void* type)
+ClangASTContext::IsDefined(lldb::opaque_compiler_type_t type)
 {
     if (!type)
         return false;
     
     clang::QualType qual_type(GetQualType(type));
     const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr());
     if (tag_type)
     {

 ClangASTContext::IsObjCObjectOrInterfaceType (const CompilerType& type)
 {
     if (IsClangType(type))
         return GetCanonicalQualType(type)->isObjCObjectOrInterfaceType();
     return false;
 }
 
 bool
-ClangASTContext::IsPolymorphicClass (void* type)
+ClangASTContext::IsPolymorphicClass (lldb::opaque_compiler_type_t type)
 {
     if (type)
     {
         clang::QualType qual_type(GetCanonicalQualType(type));
         const clang::Type::TypeClass type_class = qual_type->getTypeClass();
         switch (type_class)
         {
             case clang::Type::Record:
if (type)
             default:
                 break;
         }
     }
     return false;
 }
 
 bool
-ClangASTContext::IsPossibleDynamicType (void* type, CompilerType *dynamic_pointee_type,
+ClangASTContext::IsPossibleDynamicType (lldb::opaque_compiler_type_t type, CompilerType *dynamic_pointee_type,
                                            bool check_cplusplus,
                                            bool check_objc)
 {
     clang::QualType pointee_qual_type;
     if (type)
     {
         clang::QualType qual_type (GetCanonicalQualType(type));
         bool success = false;
ClangASTContext::IsPossibleDynamicType (lldb::opaque_compiler_type_t type, CompilerType *dynamic_pointee_type,
     }
     if (dynamic_pointee_type)
         dynamic_pointee_type->Clear();
     return false;
 }
 
 
 bool
-ClangASTContext::IsScalarType (void* type)
+ClangASTContext::IsScalarType (lldb::opaque_compiler_type_t type)
 {
     if (!type)
         return false;
     
     return (GetTypeInfo (type, nullptr) & eTypeIsScalar) != 0;
 }
 
 bool
-ClangASTContext::IsTypedefType (void* type)
+ClangASTContext::IsTypedefType (lldb::opaque_compiler_type_t type)
 {
     if (!type)
         return false;
     return GetQualType(type)->getTypeClass() == clang::Type::Typedef;
 }
 
 bool
-ClangASTContext::IsVoidType (void* type)
+ClangASTContext::IsVoidType (lldb::opaque_compiler_type_t type)
 {
     if (!type)
         return false;
     return GetCanonicalQualType(type)->isVoidType();
 }
 
 bool
 ClangASTContext::SupportsLanguage (lldb::LanguageType language)
ClangASTContext::IsCXXClassType (const CompilerType& type)
     
     clang::QualType qual_type (GetCanonicalQualType(type));
     if (!qual_type.isNull() && qual_type->getAsCXXRecordDecl() != nullptr)
         return true;
     return false;
 }
 
 bool
-ClangASTContext::IsBeingDefined (void* type)
+ClangASTContext::IsBeingDefined (lldb::opaque_compiler_type_t type)
 {
     if (!type)
         return false;
     clang::QualType qual_type (GetCanonicalQualType(type));
     const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type);
     if (tag_type)
         return tag_type->isBeingDefined();
     return false;

 }
 
 
 //----------------------------------------------------------------------
 // Type Completion
 //----------------------------------------------------------------------
 
 bool
-ClangASTContext::GetCompleteType (void* type)
+ClangASTContext::GetCompleteType (lldb::opaque_compiler_type_t type)
 {
     if (!type)
         return false;
     const bool allow_completion = true;
     return GetCompleteQualType (getASTContext(), GetQualType(type), allow_completion);
 }
 
 ConstString
-ClangASTContext::GetTypeName (void* type)
+ClangASTContext::GetTypeName (lldb::opaque_compiler_type_t type)
 {
     std::string type_name;
     if (type)
     {
         clang::PrintingPolicy printing_policy (getASTContext()->getPrintingPolicy());
         clang::QualType qual_type(GetQualType(type));
         printing_policy.SuppressTagKeyword = true;
         printing_policy.LangOpts.WChar = true;
         const clang::TypedefType *typedef_type = qual_type->getAs<clang::TypedefType>();
         if (typedef_type)
         {
             const clang::TypedefNameDecl *typedef_decl = typedef_type->getDecl();
             type_name = typedef_decl->getQualifiedNameAsString();
         }
         else
         {
             type_name = qual_type.getAsString(printing_policy);
         }
     }
     return ConstString(type_name);
 }
 
 uint32_t
-ClangASTContext::GetTypeInfo (void* type, CompilerType *pointee_or_element_clang_type)
+ClangASTContext::GetTypeInfo (lldb::opaque_compiler_type_t type, CompilerType *pointee_or_element_clang_type)
 {
     if (!type)
         return 0;
     
     if (pointee_or_element_clang_type)
         pointee_or_element_clang_type->Clear();
     
     clang::QualType qual_type (GetQualType(type));
switch (type_class)
         default:                                            return 0;
     }
     return 0;
 }
 
 
 
 lldb::LanguageType
-ClangASTContext::GetMinimumLanguage (void* type)
+ClangASTContext::GetMinimumLanguage (lldb::opaque_compiler_type_t type)
 {
     if (!type)
         return lldb::eLanguageTypeC;
     
     // If the type is a reference, then resolve it to what it refers to first:
     clang::QualType qual_type (GetCanonicalQualType(type).getNonReferenceType());
     if (qual_type->isAnyPointerType())
     {
else
             case clang::Type::Typedef:
                 return CompilerType(getASTContext(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetMinimumLanguage();
         }
     }
     return lldb::eLanguageTypeC;
 }
 
 lldb::TypeClass
-ClangASTContext::GetTypeClass (void* type)
+ClangASTContext::GetTypeClass (lldb::opaque_compiler_type_t type)
 {
     if (!type)
         return lldb::eTypeClassInvalid;
     
     clang::QualType qual_type(GetQualType(type));
     
     switch (qual_type->getTypeClass())
     {
switch (qual_type->getTypeClass())
         case clang::Type::Adjusted:                 break;
     }
     // We don't know hot to display this type...
     return lldb::eTypeClassOther;
     
 }
 
 unsigned
-ClangASTContext::GetTypeQualifiers(void* type)
+ClangASTContext::GetTypeQualifiers(lldb::opaque_compiler_type_t type)
 {
     if (type)
         return GetQualType(type).getQualifiers().getCVRQualifiers();
     return 0;
 }
 
 //----------------------------------------------------------------------
 // Creating related types
 //----------------------------------------------------------------------
 
 CompilerType
-ClangASTContext::GetArrayElementType (void* type, uint64_t *stride)
+ClangASTContext::GetArrayElementType (lldb::opaque_compiler_type_t type, uint64_t *stride)
 {
     if (type)
     {
         clang::QualType qual_type(GetCanonicalQualType(type));
         
         const clang::Type *array_eletype = qual_type.getTypePtr()->getArrayElementTypeNoTypeQual();
         
         if (!array_eletype)
             return CompilerType();
         
         CompilerType element_type (getASTContext(), array_eletype->getCanonicalTypeUnqualified());
         
         // TODO: the real stride will be >= this value.. find the real one!
         if (stride)
             *stride = element_type.GetByteSize(nullptr);
         
         return element_type;
         
     }
     return CompilerType();
 }
 
 CompilerType
-ClangASTContext::GetCanonicalType (void* type)
+ClangASTContext::GetCanonicalType (lldb::opaque_compiler_type_t type)
 {
     if (type)
         return CompilerType (getASTContext(), GetCanonicalQualType(type));
     return CompilerType();
 }
 
 static clang::QualType
 GetFullyUnqualifiedType_Impl (clang::ASTContext *ast, clang::QualType qual_type)
 {
     if (qual_type->isPointerType())
         qual_type = ast->getPointerType(GetFullyUnqualifiedType_Impl(ast, qual_type->getPointeeType()));
     else
         qual_type = qual_type.getUnqualifiedType();
     qual_type.removeLocalConst();
     qual_type.removeLocalRestrict();
     qual_type.removeLocalVolatile();
     return qual_type;
 }
 
 CompilerType
-ClangASTContext::GetFullyUnqualifiedType (void* type)
+ClangASTContext::GetFullyUnqualifiedType (lldb::opaque_compiler_type_t type)
 {
     if (type)
         return CompilerType(getASTContext(), GetFullyUnqualifiedType_Impl(getASTContext(), GetQualType(type)));
     return CompilerType();
 }
 
 
 int
-ClangASTContext::GetFunctionArgumentCount (void* type)
+ClangASTContext::GetFunctionArgumentCount (lldb::opaque_compiler_type_t type)
 {
     if (type)
     {
         const clang::FunctionProtoType* func = llvm::dyn_cast<clang::FunctionProtoType>(GetCanonicalQualType(type));
         if (func)
             return func->getNumParams();
     }
     return -1;
 }
 
 CompilerType
-ClangASTContext::GetFunctionArgumentTypeAtIndex (void* type, size_t idx)
+ClangASTContext::GetFunctionArgumentTypeAtIndex (lldb::opaque_compiler_type_t type, size_t idx)
 {
     if (type)
     {
         const clang::FunctionProtoType* func = llvm::dyn_cast<clang::FunctionProtoType>(GetCanonicalQualType(type));
         if (func)
         {
             const uint32_t num_args = func->getNumParams();
             if (idx < num_args)
                 return CompilerType(getASTContext(), func->getParamType(idx));
         }
     }
     return CompilerType();
 }
 
 CompilerType
-ClangASTContext::GetFunctionReturnType (void* type)
+ClangASTContext::GetFunctionReturnType (lldb::opaque_compiler_type_t type)
 {
     if (type)
     {
         clang::QualType qual_type(GetCanonicalQualType(type));
         const clang::FunctionProtoType* func = llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
         if (func)
             return CompilerType(getASTContext(), func->getReturnType());
     }
     return CompilerType();
 }
 
 size_t
-ClangASTContext::GetNumMemberFunctions (void* type)
+ClangASTContext::GetNumMemberFunctions (lldb::opaque_compiler_type_t type)
 {
     size_t num_functions = 0;
     if (type)
     {
         clang::QualType qual_type(GetCanonicalQualType(type));
         switch (qual_type->getTypeClass()) {
             case clang::Type::Record:
                 if (GetCompleteQualType (getASTContext(), qual_type))
if (type)
             default:
                 break;
         }
     }
     return num_functions;
 }
 
 TypeMemberFunctionImpl
-ClangASTContext::GetMemberFunctionAtIndex (void* type, size_t idx)
+ClangASTContext::GetMemberFunctionAtIndex (lldb::opaque_compiler_type_t type, size_t idx)
 {
     std::string name("");
     MemberFunctionKind kind(MemberFunctionKind::eMemberFunctionKindUnknown);
     CompilerType clang_type{};
     clang::ObjCMethodDecl *method_decl(nullptr);
     if (type)
     {
         clang::QualType qual_type(GetCanonicalQualType(type));
if (method_decl)
         return TypeMemberFunctionImpl(method_decl, name, kind);
     if (type)
         return TypeMemberFunctionImpl(clang_type, name, kind);
     
     return TypeMemberFunctionImpl();
 }
 
 CompilerType
-ClangASTContext::GetNonReferenceType (void* type)
+ClangASTContext::GetNonReferenceType (lldb::opaque_compiler_type_t type)
 {
     if (type)
         return CompilerType(getASTContext(), GetQualType(type).getNonReferenceType());
     return CompilerType();
 }
 
 CompilerType
 ClangASTContext::CreateTypedefType (const CompilerType& type,
if (type && typedef_name && typedef_name[0])
         // Get a uniqued clang::QualType for the typedef decl type
         return CompilerType (clang_ast, clang_ast->getTypedefType (decl));
     }
     return CompilerType();
     
 }
 
 CompilerType
-ClangASTContext::GetPointeeType (void* type)
+ClangASTContext::GetPointeeType (lldb::opaque_compiler_type_t type)
 {
     if (type)
     {
         clang::QualType qual_type(GetQualType(type));
         return CompilerType (getASTContext(), qual_type.getTypePtr()->getPointeeType());
     }
     return CompilerType();
 }
 
 CompilerType
-ClangASTContext::GetPointerType (void* type)
+ClangASTContext::GetPointerType (lldb::opaque_compiler_type_t type)
 {
     if (type)
     {
         clang::QualType qual_type (GetQualType(type));
         
         const clang::Type::TypeClass type_class = qual_type->getTypeClass();
         switch (type_class)
         {
             case clang::Type::ObjCObject:
             case clang::Type::ObjCInterface:
                 return CompilerType(getASTContext(), getASTContext()->getObjCObjectPointerType(qual_type));
                 
             default:
                 return CompilerType(getASTContext(), getASTContext()->getPointerType(qual_type));
         }
     }
     return CompilerType();
 }
 
 
 CompilerType
-ClangASTContext::GetLValueReferenceType (void *type)
+ClangASTContext::GetLValueReferenceType (lldb::opaque_compiler_type_t type)
 {
     if (type)
         return CompilerType(this, getASTContext()->getLValueReferenceType(GetQualType(type)).getAsOpaquePtr());
     else
         return CompilerType();
 }
 
 CompilerType
-ClangASTContext::GetRValueReferenceType (void *type)
+ClangASTContext::GetRValueReferenceType (lldb::opaque_compiler_type_t type)
 {
     if (type)
         return CompilerType(this, getASTContext()->getRValueReferenceType(GetQualType(type)).getAsOpaquePtr());
     else
         return CompilerType();
 }
 
 CompilerType
-ClangASTContext::AddConstModifier (void *type)
+ClangASTContext::AddConstModifier (lldb::opaque_compiler_type_t type)
 {
     if (type)
     {
         clang::QualType result(GetQualType(type));
         result.addConst();
         return CompilerType (this, result.getAsOpaquePtr());
     }
     return CompilerType();
 }
 
 CompilerType
-ClangASTContext::AddVolatileModifier (void *type)
+ClangASTContext::AddVolatileModifier (lldb::opaque_compiler_type_t type)
 {
     if (type)
     {
         clang::QualType result(GetQualType(type));
         result.addVolatile();
         return CompilerType (this, result.getAsOpaquePtr());
     }
     return CompilerType();
 
 }
 
 CompilerType
-ClangASTContext::AddRestrictModifier (void *type)
+ClangASTContext::AddRestrictModifier (lldb::opaque_compiler_type_t type)
 {
     if (type)
     {
         clang::QualType result(GetQualType(type));
         result.addRestrict();
         return CompilerType (this, result.getAsOpaquePtr());
     }
     return CompilerType();
 
 }
 
 CompilerType
-ClangASTContext::CreateTypedef (void *type, const char *typedef_name, const CompilerDeclContext &compiler_decl_ctx)
+ClangASTContext::CreateTypedef (lldb::opaque_compiler_type_t type, const char *typedef_name, const CompilerDeclContext &compiler_decl_ctx)
 {
     if (type)
     {
         clang::ASTContext* clang_ast = getASTContext();
         clang::QualType qual_type (GetQualType(type));
 
         clang::DeclContext *decl_ctx = ClangASTContext::DeclContextGetAsDeclContext(compiler_decl_ctx);
         if (decl_ctx == nullptr)
if (type)
         return CompilerType (this, clang_ast->getTypedefType (decl).getAsOpaquePtr());
 
     }
     return CompilerType();
 
 }
 
 CompilerType
-ClangASTContext::GetTypedefedType (void* type)
+ClangASTContext::GetTypedefedType (lldb::opaque_compiler_type_t type)
 {
     if (type)
     {
         const clang::TypedefType *typedef_type = llvm::dyn_cast<clang::TypedefType>(GetQualType(type));
         if (typedef_type)
             return CompilerType (getASTContext(), typedef_type->getDecl()->getUnderlyingType());
     }
     return CompilerType();

 {
     return ClangASTContext::GetBasicType(getASTContext(), basic_type);
 }
 //----------------------------------------------------------------------
 // Exploring the type
 //----------------------------------------------------------------------
 
 uint64_t
-ClangASTContext::GetBitSize (void* type, ExecutionContextScope *exe_scope)
+ClangASTContext::GetBitSize (lldb::opaque_compiler_type_t type, ExecutionContextScope *exe_scope)
 {
     if (GetCompleteType (type))
     {
         clang::QualType qual_type(GetCanonicalQualType(type));
         switch (qual_type->getTypeClass())
         {
             case clang::Type::ObjCInterface:
             case clang::Type::ObjCObject:
if (GetCompleteType (type))
                     return bit_size + getASTContext()->getTypeSize(getASTContext()->ObjCBuiltinClassTy);
                 return bit_size;
         }
     }
     return 0;
 }
 
 size_t
-ClangASTContext::GetTypeBitAlign (void* type)
+ClangASTContext::GetTypeBitAlign (lldb::opaque_compiler_type_t type)
 {
     if (GetCompleteType(type))
         return getASTContext()->getTypeAlign(GetQualType(type));
     return 0;
 }
 
 
 lldb::Encoding
-ClangASTContext::GetEncoding (void* type, uint64_t &count)
+ClangASTContext::GetEncoding (lldb::opaque_compiler_type_t type, uint64_t &count)
 {
     if (!type)
         return lldb::eEncodingInvalid;
     
     count = 1;
     clang::QualType qual_type(GetCanonicalQualType(type));
     
     switch (qual_type->getTypeClass())
switch (qual_type->getTypeClass())
         case clang::Type::Decayed:
             break;
     }
     count = 0;
     return lldb::eEncodingInvalid;
 }
 
 lldb::Format
-ClangASTContext::GetFormat (void* type)
+ClangASTContext::GetFormat (lldb::opaque_compiler_type_t type)
 {
     if (!type)
         return lldb::eFormatDefault;
     
     clang::QualType qual_type(GetCanonicalQualType(type));
     
     switch (qual_type->getTypeClass())
     {
while (class_interface_decl)
             class_interface_decl = class_interface_decl->getSuperClass();
         else
             break;
     }
     return false;
 }
 
 uint32_t
-ClangASTContext::GetNumChildren (void* type, bool omit_empty_base_classes)
+ClangASTContext::GetNumChildren (lldb::opaque_compiler_type_t type, bool omit_empty_base_classes)
 {
     if (!type)
         return 0;
     
     uint32_t num_children = 0;
     clang::QualType qual_type(GetQualType(type));
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class)

 
 CompilerType
 ClangASTContext::GetBuiltinTypeByName (const ConstString &name)
 {
     return GetBasicType (GetBasicTypeEnumeration (name));
 }
 
 lldb::BasicType
-ClangASTContext::GetBasicTypeEnumeration (void* type)
+ClangASTContext::GetBasicTypeEnumeration (lldb::opaque_compiler_type_t type)
 {
     if (type)
     {
         clang::QualType qual_type(GetQualType(type));
         const clang::Type::TypeClass type_class = qual_type->getTypeClass();
         if (type_class == clang::Type::Builtin)
         {
             switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind())
if (type)
                     return eBasicTypeOther;
             }
         }
     }
     return eBasicTypeInvalid;
 }
 
 void
-ClangASTContext::ForEachEnumerator (void* type, std::function <bool (const CompilerType &integer_type, const ConstString &name, const llvm::APSInt &value)> const &callback)
+ClangASTContext::ForEachEnumerator (lldb::opaque_compiler_type_t type, std::function <bool (const CompilerType &integer_type, const ConstString &name, const llvm::APSInt &value)> const &callback)
 {
     const clang::EnumType *enum_type = llvm::dyn_cast<clang::EnumType>(GetCanonicalQualType(type));
     if (enum_type)
     {
         const clang::EnumDecl *enum_decl = enum_type->getDecl();
         if (enum_decl)
         {
             CompilerType integer_type(this, enum_decl->getIntegerType().getAsOpaquePtr());
 
             clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos;
             for (enum_pos = enum_decl->enumerator_begin(), enum_end_pos = enum_decl->enumerator_end(); enum_pos != enum_end_pos; ++enum_pos)
             {
                 ConstString name(enum_pos->getNameAsString().c_str());
                 if (!callback (integer_type, name, enum_pos->getInitVal()))
                     break;
             }
         }
     }
 }
 
 
 #pragma mark Aggregate Types
 
 uint32_t
-ClangASTContext::GetNumFields (void* type)
+ClangASTContext::GetNumFields (lldb::opaque_compiler_type_t type)
 {
     if (!type)
         return 0;
     
     uint32_t count = 0;
     clang::QualType qual_type(GetCanonicalQualType(type));
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class)
switch (type_class)
             break;
             
         default:
             break;
     }
     return count;
 }
 
-static opaque_compiler_type_t
+static lldb::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)
 {
if (class_interface_decl)
                 }
             }
         }
     }
     return nullptr;
 }
 
 CompilerType
-ClangASTContext::GetFieldAtIndex (void* type, size_t idx,
+ClangASTContext::GetFieldAtIndex (lldb::opaque_compiler_type_t type, size_t idx,
                                      std::string& name,
                                      uint64_t *bit_offset_ptr,
                                      uint32_t *bitfield_bit_size_ptr,
                                      bool *is_bitfield_ptr)
 {
     if (!type)
         return CompilerType();
     
switch (type_class)
             
         default:
             break;
     }
     return CompilerType();
 }
 
 uint32_t
-ClangASTContext::GetNumDirectBaseClasses (void *type)
+ClangASTContext::GetNumDirectBaseClasses (lldb::opaque_compiler_type_t type)
 {
     uint32_t count = 0;
     clang::QualType qual_type(GetCanonicalQualType(type));
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class)
     {
         case clang::Type::Record:
             if (GetCompleteType(type))
switch (type_class)
         default:
             break;
     }
     return count;
 
 }
 
 uint32_t
-ClangASTContext::GetNumVirtualBaseClasses (void *type)
+ClangASTContext::GetNumVirtualBaseClasses (lldb::opaque_compiler_type_t type)
 {
     uint32_t count = 0;
     clang::QualType qual_type(GetCanonicalQualType(type));
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class)
     {
         case clang::Type::Record:
             if (GetCompleteType(type))
switch (type_class)
         default:
             break;
     }
     return count;
 
 }
 
 CompilerType
-ClangASTContext::GetDirectBaseClassAtIndex (void *type, size_t idx, uint32_t *bit_offset_ptr)
+ClangASTContext::GetDirectBaseClassAtIndex (lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr)
 {
     clang::QualType qual_type(GetCanonicalQualType(type));
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class)
     {
         case clang::Type::Record:
             if (GetCompleteType(type))
             {
switch (type_class)
 
         default:
             break;
     }
     return CompilerType();
 }
 
 CompilerType
-ClangASTContext::GetVirtualBaseClassAtIndex (void *type,
+ClangASTContext::GetVirtualBaseClassAtIndex (lldb::opaque_compiler_type_t type,
                                              size_t idx,
                                              uint32_t *bit_offset_ptr)
 {
     clang::QualType qual_type(GetCanonicalQualType(type));
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class)
     {
         case clang::Type::Record:
switch (type_class)
         default:
             break;
     }
     return 0;
 }
 
 
 CompilerType
-ClangASTContext::GetChildCompilerTypeAtIndex (void* type,
+ClangASTContext::GetChildCompilerTypeAtIndex (lldb::opaque_compiler_type_t type,
                                               ExecutionContext *exe_ctx,
                                               size_t idx,
                                               bool transparent_pointers,
                                               bool omit_empty_base_classes,
                                               bool ignore_array_bounds,
                                               std::string& child_name,
                                               uint32_t &child_byte_size,
                                               int32_t &child_byte_offset,

 // The second index 1 is the child index for "m_b" within class A
 //
 // With omit_empty_base_classes == true we would get an integer array back with:
 // { 0,  1 }
 // The first index 0 is the child index for "class A" within class C (since class B doesn't have any members it doesn't count)
 // The second index 1 is the child index for "m_b" within class A
 
 size_t
-ClangASTContext::GetIndexOfChildMemberWithName (void* type, const char *name,
+ClangASTContext::GetIndexOfChildMemberWithName (lldb::opaque_compiler_type_t type, const char *name,
                                                    bool omit_empty_base_classes,
                                                    std::vector<uint32_t>& child_indexes)
 {
     if (type && name && name[0])
     {
         clang::QualType qual_type(GetCanonicalQualType(type));
         const clang::Type::TypeClass type_class = qual_type->getTypeClass();
         switch (type_class)

 }
 
 
 // Get the index of the child of "clang_type" whose name matches. This function
 // doesn't descend into the children, but only looks one level deep and name
 // matches can include base class names.
 
 uint32_t
-ClangASTContext::GetIndexOfChildWithName (void* type, const char *name, bool omit_empty_base_classes)
+ClangASTContext::GetIndexOfChildWithName (lldb::opaque_compiler_type_t type, const char *name, bool omit_empty_base_classes)
 {
     if (type && name && name[0])
     {
         clang::QualType qual_type(GetCanonicalQualType(type));
         
         const clang::Type::TypeClass type_class = qual_type->getTypeClass();
         
         switch (type_class)
if (type && name && name[0])
                 break;
         }
     }
     return UINT32_MAX;
 }
 
 
 size_t
-ClangASTContext::GetNumTemplateArguments (void* type)
+ClangASTContext::GetNumTemplateArguments (lldb::opaque_compiler_type_t type)
 {
     if (!type)
         return 0;
 
     clang::QualType qual_type (GetCanonicalQualType(type));
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class)
     {
switch (type_class)
         default:
             break;
     }
 
     return 0;
 }
 
 CompilerType
-ClangASTContext::GetTemplateArgument (void* type, size_t arg_idx, lldb::TemplateArgumentKind &kind)
+ClangASTContext::GetTemplateArgument (lldb::opaque_compiler_type_t type, size_t arg_idx, lldb::TemplateArgumentKind &kind)
 {
     if (!type)
         return CompilerType();
 
     clang::QualType qual_type (GetCanonicalQualType(type));
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class)
     {

 {
     const clang::RecordType *record_type = llvm::dyn_cast<clang::RecordType>(GetCanonicalQualType(type));
     if (record_type)
         return record_type->getDecl();
     return nullptr;
 }
 
 clang::CXXRecordDecl *
-ClangASTContext::GetAsCXXRecordDecl (void* type)
+ClangASTContext::GetAsCXXRecordDecl (lldb::opaque_compiler_type_t type)
 {
     return GetCanonicalQualType(type)->getAsCXXRecordDecl();
 }
 
 clang::ObjCInterfaceDecl *
 ClangASTContext::GetAsObjCInterfaceDecl (const CompilerType& type)
 {
     const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(GetCanonicalQualType(type));

 #endif
         }
     }
     return var_decl;
 }
 
 
 clang::CXXMethodDecl *
-ClangASTContext::AddMethodToCXXRecordType (void* type, const char *name,
+ClangASTContext::AddMethodToCXXRecordType (lldb::opaque_compiler_type_t type, const char *name,
                                               const CompilerType &method_clang_type,
                                               lldb::AccessType access,
                                               bool is_virtual,
                                               bool is_static,
                                               bool is_inline,
                                               bool is_explicit,
                                               bool is_attr_used,
                                               bool is_artificial)
#endif
     //    printf ("decl->hasTrivialDestructor()      = %i\n", cxx_record_decl->hasTrivialDestructor());
     return cxx_method_decl;
 }
 
 
 #pragma mark C++ Base Classes
 
 clang::CXXBaseSpecifier *
-ClangASTContext::CreateBaseClassSpecifier (void* type, AccessType access, bool is_virtual, bool base_of_class)
+ClangASTContext::CreateBaseClassSpecifier (lldb::opaque_compiler_type_t type, AccessType access, bool is_virtual, bool base_of_class)
 {
     if (type)
         return new clang::CXXBaseSpecifier (clang::SourceRange(),
                                             is_virtual,
                                             base_of_class,
                                             ClangASTContext::ConvertAccessTypeToAccessSpecifier (access),
                                             getASTContext()->getTrivialTypeSourceInfo (GetQualType(type)),
                                             clang::SourceLocation());
     return nullptr;
 }
 
 void
 ClangASTContext::DeleteBaseClassSpecifiers (clang::CXXBaseSpecifier **base_classes, unsigned num_base_classes)
 {
     for (unsigned i=0; i<num_base_classes; ++i)
     {
         delete base_classes[i];
         base_classes[i] = nullptr;
     }
 }
 
 bool
-ClangASTContext::SetBaseClassesForClassType (void* type, clang::CXXBaseSpecifier const * const *base_classes,
+ClangASTContext::SetBaseClassesForClassType (lldb::opaque_compiler_type_t type, clang::CXXBaseSpecifier const * const *base_classes,
                                                 unsigned num_base_classes)
 {
     if (type)
     {
         clang::CXXRecordDecl *cxx_record_decl = GetAsCXXRecordDecl(type);
         if (cxx_record_decl)
         {
             cxx_record_decl->setBases(base_classes, num_base_classes);
ClangASTContext::IsObjCClassTypeAndHasIVars (const CompilerType& type, bool check_superclass)
     if (class_interface_decl)
         return ObjCDeclHasIVars (class_interface_decl, check_superclass);
     return false;
 }
 
 
 clang::ObjCMethodDecl *
 ClangASTContext::AddMethodToObjCObjectType (const CompilerType& type,
-                                            const char *name,  // the full symbol name as seen in the symbol table (void* type, "-[NString stringWithCString:]")
+                                            const char *name,  // the full symbol name as seen in the symbol table (lldb::opaque_compiler_type_t type, "-[NString stringWithCString:]")
                                             const CompilerType &method_clang_type,
                                             lldb::AccessType access,
                                             bool is_artificial)
 {
     if (!type || !method_clang_type.IsValid())
         return nullptr;
     
     clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl(type);

 #ifdef LLDB_CONFIGURATION_DEBUG
     VerifyDecl(objc_method_decl);
 #endif
     
     return objc_method_decl;
 }
 
 bool
-ClangASTContext::SetHasExternalStorage (void* type, bool has_extern)
+ClangASTContext::SetHasExternalStorage (lldb::opaque_compiler_type_t type, bool has_extern)
 {
     if (!type)
         return false;
     
     clang::QualType qual_type (GetCanonicalQualType(type));
     
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class)
if (type)
                 return true;
             }
         }
     }
     return false;
 }
 
 bool
-ClangASTContext::AddEnumerationValueToEnumerationType (void* type,
+ClangASTContext::AddEnumerationValueToEnumerationType (lldb::opaque_compiler_type_t type,
                                                        const CompilerType &enumerator_clang_type,
                                                        const Declaration &decl,
                                                        const char *name,
                                                        int64_t enum_value,
                                                        uint32_t enum_value_bit_size)
 {
     if (type && enumerator_clang_type.IsValid() && name && name[0])
     {
#endif
                 }
             }
         }
     }
     return false;
 }
 
 CompilerType
-ClangASTContext::GetEnumerationIntegerType (void* type)
+ClangASTContext::GetEnumerationIntegerType (lldb::opaque_compiler_type_t type)
 {
     clang::QualType enum_qual_type (GetCanonicalQualType(type));
     const clang::Type *clang_type = enum_qual_type.getTypePtr();
     if (clang_type)
     {
         const clang::EnumType *enutype = llvm::dyn_cast<clang::EnumType>(clang_type);
         if (enutype)
         {
if (type && pointee_type.IsValid() && type.GetTypeSystem() == pointee_type.GetTypeSystem())
                              ast->getASTContext()->getMemberPointerType (GetQualType(pointee_type),
                                                                          GetQualType(type).getTypePtr()));
     }
     return CompilerType();
 }
 
 
 size_t
-ClangASTContext::ConvertStringToFloatValue (void* type, const char *s, uint8_t *dst, size_t dst_size)
+ClangASTContext::ConvertStringToFloatValue (lldb::opaque_compiler_type_t type, const char *s, uint8_t *dst, size_t dst_size)
 {
     if (type)
     {
         clang::QualType qual_type (GetCanonicalQualType(type));
         uint32_t count = 0;
         bool is_complex = false;
         if (IsFloatingPointType (type, count, is_complex))
         {

 
 
 //----------------------------------------------------------------------
 // Dumping types
 //----------------------------------------------------------------------
 #define DEPTH_INCREMENT 2
 
 void
-ClangASTContext::DumpValue (void* type, ExecutionContext *exe_ctx,
+ClangASTContext::DumpValue (lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx,
                                Stream *s,
                                lldb::Format format,
                                const lldb_private::DataExtractor &data,
                                lldb::offset_t data_byte_offset,
                                size_t data_byte_size,
                                uint32_t bitfield_bit_size,
                                uint32_t bitfield_bit_offset,
                                bool show_types,
switch (qual_type->getTypeClass())
             break;
     }
 }
 
 
 
 
 bool
-ClangASTContext::DumpTypeValue (void* type, Stream *s,
+ClangASTContext::DumpTypeValue (lldb::opaque_compiler_type_t type, Stream *s,
                                    lldb::Format format,
                                    const lldb_private::DataExtractor &data,
                                    lldb::offset_t byte_offset,
                                    size_t byte_size,
                                    uint32_t bitfield_bit_size,
                                    uint32_t bitfield_bit_offset,
                                    ExecutionContextScope *exe_scope)
 {
else
         }
     }
     return 0;
 }
 
 
 
 void
-ClangASTContext::DumpSummary (void* type, ExecutionContext *exe_ctx,
+ClangASTContext::DumpSummary (lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx,
                                  Stream *s,
                                  const lldb_private::DataExtractor &data,
                                  lldb::offset_t data_byte_offset,
                                  size_t data_byte_size)
 {
     uint32_t length = 0;
     if (IsCStringType (type, length))
     {
if (IsCStringType (type, length))
                 if (total_cstr_len > 0)
                     s->PutChar ('"');
             }
         }
     }
 }
 
 void
-ClangASTContext::DumpTypeDescription (void* type)
+ClangASTContext::DumpTypeDescription (lldb::opaque_compiler_type_t type)
 {
     StreamFile s (stdout, false);
     DumpTypeDescription (&s);
     ClangASTMetadata *metadata = ClangASTContext::GetMetadata (getASTContext(), type);
     if (metadata)
     {
         metadata->Dump (&s);
     }
 }
 
 void
-ClangASTContext::DumpTypeDescription (void* type, Stream *s)
+ClangASTContext::DumpTypeDescription (lldb::opaque_compiler_type_t type, Stream *s)
 {
     if (type)
     {
         clang::QualType qual_type(GetQualType(type));
         
         llvm::SmallVector<char, 1024> buf;
         llvm::raw_svector_ostream llvm_ostrm (buf);
         

lldb/trunk/source/Symbol/CompilerType.cpp

 
 #include <iterator>
 #include <mutex>
 
 using namespace lldb;
 using namespace lldb_private;
 
 CompilerType::CompilerType (TypeSystem *type_system,
-                            void* type) :
+                            lldb::opaque_compiler_type_t type) :
     m_type (type),
     m_type_system (type_system)
 {
 }
 
 CompilerType::CompilerType (clang::ASTContext *ast,
                             clang::QualType qual_type) :
     m_type (qual_type.getAsOpaquePtr()),
CompilerType::GetTypeClass () const
     if (!IsValid())
         return lldb::eTypeClassInvalid;
     
     return m_type_system->GetTypeClass(m_type);
     
 }
 
 void
-CompilerType::SetCompilerType (TypeSystem* type_system, void*  type)
+CompilerType::SetCompilerType (TypeSystem* type_system, lldb::opaque_compiler_type_t type)
 {
     m_type_system = type_system;
     m_type = type;
 }
 
 void
 CompilerType::SetCompilerType (clang::ASTContext *ast, clang::QualType qual_type)
 {

lldb/trunk/source/Symbol/GoASTContext.cpp

 }
 
 
 //----------------------------------------------------------------------
 // Tests
 //----------------------------------------------------------------------
 
 bool
-GoASTContext::IsArrayType(void *type, CompilerType *element_type, uint64_t *size, bool *is_incomplete)
+GoASTContext::IsArrayType(lldb::opaque_compiler_type_t type, CompilerType *element_type, uint64_t *size, bool *is_incomplete)
 {
     if (element_type)
         element_type->Clear();
     if (size)
         *size = 0;
     if (is_incomplete)
         *is_incomplete = false;
     GoArray *array = static_cast<GoType *>(type)->GetArray();
     if (array)
     {
         if (size)
             *size = array->GetLength();
         if (element_type)
             *element_type = array->GetElementType();
         return true;
     }
     return false;
 }
 
 bool
-GoASTContext::IsVectorType(void *type, CompilerType *element_type, uint64_t *size)
+GoASTContext::IsVectorType(lldb::opaque_compiler_type_t type, CompilerType *element_type, uint64_t *size)
 {
     if (element_type)
         element_type->Clear();
     if (size)
         *size = 0;
     return false;
 }
 
 bool
-GoASTContext::IsAggregateType(void *type)
+GoASTContext::IsAggregateType(lldb::opaque_compiler_type_t type)
 {
     int kind = static_cast<GoType *>(type)->GetGoKind();
     if (kind < GoType::KIND_ARRAY)
         return false;
     if (kind == GoType::KIND_PTR)
         return false;
     if (kind == GoType::KIND_STRING)
         return false;
     if (kind == GoType::KIND_UNSAFEPOINTER)
         return false;
     return true;
 }
 
 bool
-GoASTContext::IsBeingDefined(void *type)
+GoASTContext::IsBeingDefined(lldb::opaque_compiler_type_t type)
 {
     return false;
 }
 
 bool
-GoASTContext::IsCharType(void *type)
+GoASTContext::IsCharType(lldb::opaque_compiler_type_t type)
 {
     // Go's DWARF doesn't distinguish between rune and int32.
     return false;
 }
 
 bool
-GoASTContext::IsCompleteType(void *type)
+GoASTContext::IsCompleteType(lldb::opaque_compiler_type_t type)
 {
     if (!type)
         return false;
     GoType *t = static_cast<GoType *>(type);
     if (GoStruct *s = t->GetStruct())
         return s->IsComplete();
     if (t->IsTypedef() || t->GetGoKind() == GoType::KIND_PTR)
         return t->GetElementType().IsCompleteType();
     return true;
 }
 
 bool
-GoASTContext::IsConst(void *type)
+GoASTContext::IsConst(lldb::opaque_compiler_type_t type)
 {
     return false;
 }
 
 bool
-GoASTContext::IsCStringType(void *type, uint32_t &length)
+GoASTContext::IsCStringType(lldb::opaque_compiler_type_t type, uint32_t &length)
 {
     return false;
 }
 
 bool
-GoASTContext::IsDefined(void *type)
+GoASTContext::IsDefined(lldb::opaque_compiler_type_t type)
 {
     return type != nullptr;
 }
 
 bool
-GoASTContext::IsFloatingPointType(void *type, uint32_t &count, bool &is_complex)
+GoASTContext::IsFloatingPointType(lldb::opaque_compiler_type_t type, uint32_t &count, bool &is_complex)
 {
     int kind = static_cast<GoType *>(type)->GetGoKind();
     if (kind >= GoType::KIND_FLOAT32 && kind <= GoType::KIND_COMPLEX128)
     {
         if (kind >= GoType::KIND_COMPLEX64)
         {
             is_complex = true;
             count = 2;
         }
         else
         {
             is_complex = false;
             count = 1;
         }
         return true;
     }
     count = 0;
     is_complex = false;
     return false;
 }
 
 bool
-GoASTContext::IsFunctionType(void *type, bool *is_variadic_ptr)
+GoASTContext::IsFunctionType(lldb::opaque_compiler_type_t type, bool *is_variadic_ptr)
 {
     GoFunction *func = static_cast<GoType *>(type)->GetFunction();
     if (func)
     {
         if (is_variadic_ptr)
             *is_variadic_ptr = func->IsVariadic();
         return true;
     }
     if (is_variadic_ptr)
         *is_variadic_ptr = false;
     return false;
 }
 
 uint32_t
-GoASTContext::IsHomogeneousAggregate(void *type, CompilerType *base_type_ptr)
+GoASTContext::IsHomogeneousAggregate(lldb::opaque_compiler_type_t type, CompilerType *base_type_ptr)
 {
     return false;
 }
 
 size_t
-GoASTContext::GetNumberOfFunctionArguments(void *type)
+GoASTContext::GetNumberOfFunctionArguments(lldb::opaque_compiler_type_t type)
 {
     return 0;
 }
 
 CompilerType
-GoASTContext::GetFunctionArgumentAtIndex(void *type, const size_t index)
+GoASTContext::GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type, const size_t index)
 {
     return CompilerType();
 }
 
 bool
-GoASTContext::IsFunctionPointerType(void *type)
+GoASTContext::IsFunctionPointerType(lldb::opaque_compiler_type_t type)
 {
     return IsFunctionType(type);
 }
 
 bool
-GoASTContext::IsIntegerType(void *type, bool &is_signed)
+GoASTContext::IsIntegerType(lldb::opaque_compiler_type_t type, bool &is_signed)
 {
     is_signed = false;
     // TODO: Is bool an integer?
     if (type)
     {
         int kind = static_cast<GoType *>(type)->GetGoKind();
         if (kind <= GoType::KIND_UINTPTR)
         {
             is_signed = (kind != GoType::KIND_BOOL) & (kind <= GoType::KIND_INT64);
             return true;
         }
     }
     return false;
 }
 
 bool
-GoASTContext::IsPolymorphicClass(void *type)
+GoASTContext::IsPolymorphicClass(lldb::opaque_compiler_type_t type)
 {
     return false;
 }
 
 bool
-GoASTContext::IsPossibleDynamicType(void *type,
+GoASTContext::IsPossibleDynamicType(lldb::opaque_compiler_type_t type,
                                     CompilerType *target_type, // Can pass NULL
                                     bool check_cplusplus, bool check_objc)
 {
     if (target_type)
         target_type->Clear();
     if (type)
         return static_cast<GoType *>(type)->GetGoKind() == GoType::KIND_INTERFACE;
     return false;
 }
 
 bool
-GoASTContext::IsRuntimeGeneratedType(void *type)
+GoASTContext::IsRuntimeGeneratedType(lldb::opaque_compiler_type_t type)
 {
     return false;
 }
 
 bool
-GoASTContext::IsPointerType(void *type, CompilerType *pointee_type)
+GoASTContext::IsPointerType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type)
 {
     if (!type)
         return false;
     GoType *t = static_cast<GoType *>(type);
     if (pointee_type)
     {
         *pointee_type = t->GetElementType();
     }
     switch (t->GetGoKind())
     {
         case GoType::KIND_PTR:
         case GoType::KIND_UNSAFEPOINTER:
         case GoType::KIND_CHAN:
             // TODO: is map a pointer? string? function?
             return true;
         default:
             return false;
     }
 }
 
 bool
-GoASTContext::IsPointerOrReferenceType(void *type, CompilerType *pointee_type)
+GoASTContext::IsPointerOrReferenceType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type)
 {
     return IsPointerType(type, pointee_type);
 }
 
 bool
-GoASTContext::IsReferenceType(void *type, CompilerType *pointee_type, bool *is_rvalue)
+GoASTContext::IsReferenceType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type, bool *is_rvalue)
 {
     return false;
 }
 
 bool
-GoASTContext::IsScalarType(void *type)
+GoASTContext::IsScalarType(lldb::opaque_compiler_type_t type)
 {
     return !IsAggregateType(type);
 }
 
 bool
-GoASTContext::IsTypedefType(void *type)
+GoASTContext::IsTypedefType(lldb::opaque_compiler_type_t type)
 {
     if (type)
         return static_cast<GoType *>(type)->IsTypedef();
     return false;
 }
 
 bool
-GoASTContext::IsVoidType(void *type)
+GoASTContext::IsVoidType(lldb::opaque_compiler_type_t type)
 {
     if (!type)
         return false;
     return static_cast<GoType *>(type)->GetGoKind() == GoType::KIND_LLDB_VOID;
 }
 
 bool
 GoASTContext::SupportsLanguage (lldb::LanguageType language)
 {
     return language == eLanguageTypeGo;
 }
 
 //----------------------------------------------------------------------
 // Type Completion
 //----------------------------------------------------------------------
 
 bool
-GoASTContext::GetCompleteType(void *type)
+GoASTContext::GetCompleteType(lldb::opaque_compiler_type_t type)
 {
     if (!type)
         return false;
     GoType *t = static_cast<GoType *>(type);
     if (t->IsTypedef() || t->GetGoKind() == GoType::KIND_PTR || t->GetArray())
         return t->GetElementType().GetCompleteType();
     if (GoStruct *s = t->GetStruct())
     {
GoASTContext::GetPointerByteSize()
     return m_pointer_byte_size;
 }
 
 //----------------------------------------------------------------------
 // Accessors
 //----------------------------------------------------------------------
 
 ConstString
-GoASTContext::GetTypeName(void *type)
+GoASTContext::GetTypeName(lldb::opaque_compiler_type_t type)
 {
     if (type)
         return static_cast<GoType *>(type)->GetName();
     return ConstString();
 }
 
 uint32_t
-GoASTContext::GetTypeInfo(void *type, CompilerType *pointee_or_element_clang_type)
+GoASTContext::GetTypeInfo(lldb::opaque_compiler_type_t type, CompilerType *pointee_or_element_clang_type)
 {
     if (pointee_or_element_clang_type)
         pointee_or_element_clang_type->Clear();
     if (!type)
         return 0;
     GoType *t = static_cast<GoType *>(type);
     if (pointee_or_element_clang_type)
         *pointee_or_element_clang_type = t->GetElementType();
GoASTContext::GetTypeInfo(lldb::opaque_compiler_type_t type, CompilerType *pointee_or_element_clang_type)
     if (IsPointerType(type))
         return eTypeIsPointer | eTypeHasValue | eTypeHasChildren;
     if (kind == GoType::KIND_LLDB_VOID)
         return 0;
     return eTypeHasChildren | eTypeIsStructUnion;
 }
 
 lldb::TypeClass
-GoASTContext::GetTypeClass(void *type)
+GoASTContext::GetTypeClass(lldb::opaque_compiler_type_t type)
 {
     if (!type)
         return eTypeClassInvalid;
     int kind = static_cast<GoType *>(type)->GetGoKind();
     if (kind == GoType::KIND_FUNC)
         return eTypeClassFunction;
     if (IsPointerType(type))
         return eTypeClassPointer;
     if (kind < GoType::KIND_COMPLEX64)
         return eTypeClassBuiltin;
     if (kind <= GoType::KIND_COMPLEX128)
         return eTypeClassComplexFloat;
     if (kind == GoType::KIND_LLDB_VOID)
         return eTypeClassInvalid;
     return eTypeClassStruct;
 }
 
 lldb::BasicType
-GoASTContext::GetBasicTypeEnumeration(void *type)
+GoASTContext::GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type)
 {
     ConstString name = GetTypeName(type);
     if (name)
     {
         typedef UniqueCStringMap<lldb::BasicType> TypeNameToBasicTypeMap;
         static TypeNameToBasicTypeMap g_type_map;
         static std::once_flag g_once_flag;
         std::call_once(g_once_flag, [](){
if (name)
         });
         
         return g_type_map.Find(name.GetCString(), eBasicTypeInvalid);
     }
     return eBasicTypeInvalid;
 }
 
 lldb::LanguageType
-GoASTContext::GetMinimumLanguage(void *type)
+GoASTContext::GetMinimumLanguage(lldb::opaque_compiler_type_t type)
 {
     return lldb::eLanguageTypeGo;
 }
 
 unsigned
-GoASTContext::GetTypeQualifiers(void *type)
+GoASTContext::GetTypeQualifiers(lldb::opaque_compiler_type_t type)
 {
     return 0;
 }
 
 //----------------------------------------------------------------------
 // Creating related types
 //----------------------------------------------------------------------
 
 CompilerType
-GoASTContext::GetArrayElementType(void *type, uint64_t *stride)
+GoASTContext::GetArrayElementType(lldb::opaque_compiler_type_t type, uint64_t *stride)
 {
     GoArray *array = static_cast<GoType *>(type)->GetArray();
     if (array)
     {
         if (stride)
         {
             *stride = array->GetElementType().GetByteSize(nullptr);
         }
         return array->GetElementType();
     }
     return CompilerType();
 }
 
 CompilerType
-GoASTContext::GetCanonicalType(void *type)
+GoASTContext::GetCanonicalType(lldb::opaque_compiler_type_t type)
 {
     GoType *t = static_cast<GoType *>(type);
     if (t->IsTypedef())
         return t->GetElementType();
     return CompilerType(this, type);
 }
 
 CompilerType
-GoASTContext::GetFullyUnqualifiedType(void *type)
+GoASTContext::GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type)
 {
     return CompilerType(this, type);
 }
 
 // Returns -1 if this isn't a function of if the function doesn't have a prototype
 // Returns a value >= 0 if there is a prototype.
 int
-GoASTContext::GetFunctionArgumentCount(void *type)
+GoASTContext::GetFunctionArgumentCount(lldb::opaque_compiler_type_t type)
 {
     return GetNumberOfFunctionArguments(type);
 }
 
 CompilerType
-GoASTContext::GetFunctionArgumentTypeAtIndex(void *type, size_t idx)
+GoASTContext::GetFunctionArgumentTypeAtIndex(lldb::opaque_compiler_type_t type, size_t idx)
 {
     return GetFunctionArgumentAtIndex(type, idx);
 }
 
 CompilerType
-GoASTContext::GetFunctionReturnType(void *type)
+GoASTContext::GetFunctionReturnType(lldb::opaque_compiler_type_t type)
 {
     CompilerType result;
     if (type)
     {
         GoType *t = static_cast<GoType *>(type);
         if (t->GetGoKind() == GoType::KIND_FUNC)
             result = t->GetElementType();
     }
     return result;
 }
 
 size_t
-GoASTContext::GetNumMemberFunctions(void *type)
+GoASTContext::GetNumMemberFunctions(lldb::opaque_compiler_type_t type)
 {
     return 0;
 }
 
 TypeMemberFunctionImpl
-GoASTContext::GetMemberFunctionAtIndex(void *type, size_t idx)
+GoASTContext::GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type, size_t idx)
 {
     return TypeMemberFunctionImpl();
 }
 
 CompilerType
-GoASTContext::GetNonReferenceType(void *type)
+GoASTContext::GetNonReferenceType(lldb::opaque_compiler_type_t type)
 {
     return CompilerType(this, type);
 }
 
 CompilerType
-GoASTContext::GetPointeeType(void *type)
+GoASTContext::GetPointeeType(lldb::opaque_compiler_type_t type)
 {
     if (!type)
         return CompilerType();
     return static_cast<GoType *>(type)->GetElementType();
 }
 
 CompilerType
-GoASTContext::GetPointerType(void *type)
+GoASTContext::GetPointerType(lldb::opaque_compiler_type_t type)
 {
     if (!type)
         return CompilerType();
     ConstString type_name = GetTypeName(type);
     ConstString pointer_name(std::string("*") + type_name.GetCString());
     GoType *pointer = (*m_types)[pointer_name].get();
     if (pointer == nullptr)
     {
         pointer = new GoElem(GoType::KIND_PTR, pointer_name, CompilerType(this, type));
         (*m_types)[pointer_name].reset(pointer);
     }
     return CompilerType(this, pointer);
 }
 
 // If the current object represents a typedef type, get the underlying type
 CompilerType
-GoASTContext::GetTypedefedType(void *type)
+GoASTContext::GetTypedefedType(lldb::opaque_compiler_type_t type)
 {
     if (IsTypedefType(type))
         return static_cast<GoType *>(type)->GetElementType();
     return CompilerType();
 }
 
 //----------------------------------------------------------------------
 // Create related types using the current type's AST

 }
 
 
 //----------------------------------------------------------------------
 // Exploring the type
 //----------------------------------------------------------------------
 
 uint64_t
-GoASTContext::GetBitSize(void *type, ExecutionContextScope *exe_scope)
+GoASTContext::GetBitSize(lldb::opaque_compiler_type_t type, ExecutionContextScope *exe_scope)
 {
     if (!type)
         return 0;
     if (!GetCompleteType(type))
         return 0;
     GoType *t = static_cast<GoType *>(type);
     GoArray *array = nullptr;
     switch (t->GetGoKind())
switch (t->GetGoKind())
             return t->GetStruct()->GetByteSize() * 8;
         default:
             assert(false);
     }
     return 0;
 }
 
 lldb::Encoding
-GoASTContext::GetEncoding(void *type, uint64_t &count)
+GoASTContext::GetEncoding(lldb::opaque_compiler_type_t type, uint64_t &count)
 {
     count = 1;
     bool is_signed;
     if (IsIntegerType(type, is_signed))
         return is_signed ? lldb::eEncodingSint : eEncodingUint;
     bool is_complex;
     uint32_t complex_count;
     if (IsFloatingPointType(type, complex_count, is_complex))
     {
         count = complex_count;
         return eEncodingIEEE754;
     }
     if (IsPointerType(type))
         return eEncodingUint;
     return eEncodingInvalid;
 }
 
 lldb::Format
-GoASTContext::GetFormat(void *type)
+GoASTContext::GetFormat(lldb::opaque_compiler_type_t type)
 {
     if (!type)
         return eFormatDefault;
     switch (static_cast<GoType *>(type)->GetGoKind())
     {
         case GoType::KIND_BOOL:
             return eFormatBoolean;
         case GoType::KIND_INT:
switch (static_cast<GoType *>(type)->GetGoKind())
         case GoType::KIND_STRUCT:
         default:
             // Don't know how to display this.
             return eFormatBytes;
     }
 }
 
 size_t
-GoASTContext::GetTypeBitAlign(void *type)
+GoASTContext::GetTypeBitAlign(lldb::opaque_compiler_type_t type)
 {
     return 0;
 }
 
 uint32_t
-GoASTContext::GetNumChildren(void *type, bool omit_empty_base_classes)
+GoASTContext::GetNumChildren(lldb::opaque_compiler_type_t type, bool omit_empty_base_classes)
 {
     if (!type || !GetCompleteType(type))
         return 0;
     GoType *t = static_cast<GoType *>(type);
     if (t->GetGoKind() == GoType::KIND_PTR)
     {
         CompilerType elem = t->GetElementType();
         if (elem.IsAggregateType())
             return elem.GetNumChildren(omit_empty_base_classes);
         return 1;
     }
     else if (GoArray *array = t->GetArray())
     {
         return array->GetLength();
     }
     return GetNumFields(type);
 }
 
 uint32_t
-GoASTContext::GetNumFields(void *type)
+GoASTContext::GetNumFields(lldb::opaque_compiler_type_t type)
 {
     if (!type || !GetCompleteType(type))
         return 0;
     GoType *t = static_cast<GoType *>(type);
     if (t->IsTypedef())
         return t->GetElementType().GetNumFields();
     GoStruct *s = t->GetStruct();
     if (s)
         return s->GetNumFields();
     return 0;
 }
 
 CompilerType
-GoASTContext::GetFieldAtIndex(void *type, size_t idx, std::string &name, uint64_t *bit_offset_ptr,
+GoASTContext::GetFieldAtIndex(lldb::opaque_compiler_type_t type, size_t idx, std::string &name, uint64_t *bit_offset_ptr,
                               uint32_t *bitfield_bit_size_ptr, bool *is_bitfield_ptr)
 {
     if (bit_offset_ptr)
         *bit_offset_ptr = 0;
     if (bitfield_bit_size_ptr)
         *bitfield_bit_size_ptr = 0;
     if (is_bitfield_ptr)
         *is_bitfield_ptr = false;
if (s)
                 *bit_offset_ptr = field->m_byte_offset * 8;
             return field->m_type;
         }
     }
     return CompilerType();
 }
 
 CompilerType
-GoASTContext::GetChildCompilerTypeAtIndex(void *type, ExecutionContext *exe_ctx, size_t idx, bool transparent_pointers,
+GoASTContext::GetChildCompilerTypeAtIndex(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx, bool transparent_pointers,
                                           bool omit_empty_base_classes, bool ignore_array_bounds, std::string &child_name,
                                           uint32_t &child_byte_size, int32_t &child_byte_offset,
                                           uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset,
                                           bool &child_is_base_class, bool &child_is_deref_of_parent, ValueObject *valobj)
 {
     child_name.clear();
     child_byte_size = 0;
     child_byte_offset = 0;
else if (t->IsTypedef())
             child_is_deref_of_parent, valobj);
     }
     return CompilerType();
 }
 
 // Lookup a child given a name. This function will match base class names
 // and member member names in "clang_type" only, not descendants.
 uint32_t
-GoASTContext::GetIndexOfChildWithName(void *type, const char *name, bool omit_empty_base_classes)
+GoASTContext::GetIndexOfChildWithName(lldb::opaque_compiler_type_t type, const char *name, bool omit_empty_base_classes)
 {
     GoType *t = static_cast<GoType *>(type);
     GoStruct *s = t->GetStruct();
     if (s)
     {
         for (uint32_t i = 0; i < s->GetNumFields(); ++i)
         {
             const GoStruct::Field *f = s->GetField(i);

 }
 
 // Lookup a child member given a name. This function will match member names
 // only and will descend into "clang_type" children in search for the first
 // member in this class, or any base class that matches "name".
 // TODO: Return all matches for a given name by returning a vector<vector<uint32_t>>
 // so we catch all names that match a given child name, not just the first.
 size_t
-GoASTContext::GetIndexOfChildMemberWithName(void *type, const char *name, bool omit_empty_base_classes,
+GoASTContext::GetIndexOfChildMemberWithName(lldb::opaque_compiler_type_t type, const char *name, bool omit_empty_base_classes,
                                             std::vector<uint32_t> &child_indexes)
 {
     uint32_t index = GetIndexOfChildWithName(type, name, omit_empty_base_classes);
     if (index == UINT_MAX)
         return 0;
     child_indexes.push_back(index);
     return 1;
 }
 
 // Converts "s" to a floating point value and place resulting floating
 // point bytes in the "dst" buffer.
 size_t
-GoASTContext::ConvertStringToFloatValue(void *type, const char *s, uint8_t *dst, size_t dst_size)
+GoASTContext::ConvertStringToFloatValue(lldb::opaque_compiler_type_t type, const char *s, uint8_t *dst, size_t dst_size)
 {
     assert(false);
     return 0;
 }
 //----------------------------------------------------------------------
 // Dumping types
 //----------------------------------------------------------------------
 void
-GoASTContext::DumpValue(void *type, ExecutionContext *exe_ctx, Stream *s, lldb::Format format,
+GoASTContext::DumpValue(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s, lldb::Format format,
                         const DataExtractor &data, lldb::offset_t data_offset, size_t data_byte_size,
                         uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset, bool show_types, bool show_summary,
                         bool verbose, uint32_t depth)
 {
     assert(false);
 }
 
 bool
-GoASTContext::DumpTypeValue(void *type, Stream *s, lldb::Format format, const DataExtractor &data,
+GoASTContext::DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s, lldb::Format format, const DataExtractor &data,
                             lldb::offset_t byte_offset, size_t byte_size, uint32_t bitfield_bit_size,
                             uint32_t bitfield_bit_offset, ExecutionContextScope *exe_scope)
 {
     if (!type)
         return false;
     if (IsAggregateType(type))
     {
         return false;
else
         }
         return data.Dump(s, byte_offset, format, byte_size, item_count, UINT32_MAX, LLDB_INVALID_ADDRESS,
                          bitfield_bit_size, bitfield_bit_offset, exe_scope);
     }
     return 0;
 }
 
 void
-GoASTContext::DumpSummary(void *type, ExecutionContext *exe_ctx, Stream *s, const DataExtractor &data,
+GoASTContext::DumpSummary(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s, const DataExtractor &data,
                           lldb::offset_t data_offset, size_t data_byte_size)
 {
     assert(false);
 }
 
 void
-GoASTContext::DumpTypeDescription(void *type)
+GoASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type)
 {
     assert(false);
 } // Dump to stdout
 
 void
-GoASTContext::DumpTypeDescription(void *type, Stream *s)
+GoASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type, Stream *s)
 {
     assert(false);
 }
 
 CompilerType
 GoASTContext::CreateArrayType(const ConstString &name, const CompilerType &element_type, uint64_t length)
 {
     GoType *type = new GoArray(name, length, element_type);

lldb/trunk/source/Symbol/TypeSystem.cpp

while ((create_callback = PluginManager::GetTypeSystemCreateCallbackAtIndex (i++)) != nullptr)
         if (type_system_sp)
             return type_system_sp;
     }
 
     return lldb::TypeSystemSP();
 }
 
 CompilerType
-TypeSystem::GetLValueReferenceType (void *type)
+TypeSystem::GetLValueReferenceType (lldb::opaque_compiler_type_t type)
 {
     return CompilerType();
 }
 
 CompilerType
-TypeSystem::GetRValueReferenceType (void *type)
+TypeSystem::GetRValueReferenceType (lldb::opaque_compiler_type_t type)
 {
     return CompilerType();
 }
 
 CompilerType
-TypeSystem::AddConstModifier (void *type)
+TypeSystem::AddConstModifier (lldb::opaque_compiler_type_t type)
 {
     return CompilerType();
 }
 
 CompilerType
-TypeSystem::AddVolatileModifier (void *type)
+TypeSystem::AddVolatileModifier (lldb::opaque_compiler_type_t type)
 {
     return CompilerType();
 }
 
 CompilerType
-TypeSystem::AddRestrictModifier (void *type)
+TypeSystem::AddRestrictModifier (lldb::opaque_compiler_type_t type)
 {
     return CompilerType();
 }
 
 CompilerType
-TypeSystem::CreateTypedef (void *type, const char *name, const CompilerDeclContext &decl_ctx)
+TypeSystem::CreateTypedef (lldb::opaque_compiler_type_t type, const char *name, const CompilerDeclContext &decl_ctx)
 {
     return CompilerType();
 }
 
 CompilerType
 TypeSystem::GetBuiltinTypeByName (const ConstString &name)
 {
     return CompilerType();
 }