diff --git a/lldb/source/Symbol/ClangASTType.cpp b/lldb/source/Symbol/ClangASTType.cpp index 7d457073670d..67542fe00527 100644 --- a/lldb/source/Symbol/ClangASTType.cpp +++ b/lldb/source/Symbol/ClangASTType.cpp @@ -50,11 +50,9 @@ using namespace lldb; using namespace lldb_private; -using namespace clang; -using namespace llvm; static bool -GetCompleteQualType (ASTContext *ast, QualType qual_type, bool allow_completion = true) +GetCompleteQualType (clang::ASTContext *ast, clang::QualType qual_type, bool allow_completion = true) { const clang::Type::TypeClass type_class = qual_type->getTypeClass(); switch (type_class) @@ -63,7 +61,7 @@ GetCompleteQualType (ASTContext *ast, QualType qual_type, bool allow_completion case clang::Type::IncompleteArray: case clang::Type::VariableArray: { - const ArrayType *array_type = dyn_cast(qual_type.getTypePtr()); + const clang::ArrayType *array_type = llvm::dyn_cast(qual_type.getTypePtr()); if (array_type) return GetCompleteQualType (ast, array_type->getElementType(), allow_completion); @@ -73,10 +71,10 @@ GetCompleteQualType (ASTContext *ast, QualType qual_type, bool allow_completion case clang::Type::Record: case clang::Type::Enum: { - const TagType *tag_type = dyn_cast(qual_type.getTypePtr()); + const clang::TagType *tag_type = llvm::dyn_cast(qual_type.getTypePtr()); if (tag_type) { - TagDecl *tag_decl = tag_type->getDecl(); + clang::TagDecl *tag_decl = tag_type->getDecl(); if (tag_decl) { if (tag_decl->isCompleteDefinition()) @@ -89,7 +87,7 @@ GetCompleteQualType (ASTContext *ast, QualType qual_type, bool allow_completion { if (ast) { - ExternalASTSource *external_ast_source = ast->getExternalSource(); + clang::ExternalASTSource *external_ast_source = ast->getExternalSource(); if (external_ast_source) { external_ast_source->CompleteType(tag_decl); @@ -107,10 +105,10 @@ GetCompleteQualType (ASTContext *ast, QualType qual_type, bool allow_completion case clang::Type::ObjCObject: case clang::Type::ObjCInterface: { - const ObjCObjectType *objc_class_type = dyn_cast(qual_type); + const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast(qual_type); if (objc_class_type) { - ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); + clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); // We currently can't complete objective C types through the newly added ASTContext // because it only supports TagDecl objects right now... if (class_interface_decl) @@ -125,7 +123,7 @@ GetCompleteQualType (ASTContext *ast, QualType qual_type, bool allow_completion { if (ast) { - ExternalASTSource *external_ast_source = ast->getExternalSource(); + clang::ExternalASTSource *external_ast_source = ast->getExternalSource(); if (external_ast_source) { external_ast_source->CompleteType (class_interface_decl); @@ -140,13 +138,13 @@ GetCompleteQualType (ASTContext *ast, QualType qual_type, bool allow_completion break; case clang::Type::Typedef: - return GetCompleteQualType (ast, cast(qual_type)->getDecl()->getUnderlyingType(), allow_completion); + return GetCompleteQualType (ast, llvm::cast(qual_type)->getDecl()->getUnderlyingType(), allow_completion); case clang::Type::Elaborated: - return GetCompleteQualType (ast, cast(qual_type)->getNamedType(), allow_completion); + return GetCompleteQualType (ast, llvm::cast(qual_type)->getNamedType(), allow_completion); case clang::Type::Paren: - return GetCompleteQualType (ast, cast(qual_type)->desugar(), allow_completion); + return GetCompleteQualType (ast, llvm::cast(qual_type)->desugar(), allow_completion); default: break; @@ -155,18 +153,18 @@ GetCompleteQualType (ASTContext *ast, QualType qual_type, bool allow_completion return true; } -static ObjCIvarDecl::AccessControl +static clang::ObjCIvarDecl::AccessControl ConvertAccessTypeToObjCIvarAccessControl (AccessType access) { switch (access) { - case eAccessNone: return ObjCIvarDecl::None; - case eAccessPublic: return ObjCIvarDecl::Public; - case eAccessPrivate: return ObjCIvarDecl::Private; - case eAccessProtected: return ObjCIvarDecl::Protected; - case eAccessPackage: return ObjCIvarDecl::Package; + case eAccessNone: return clang::ObjCIvarDecl::None; + case eAccessPublic: return clang::ObjCIvarDecl::Public; + case eAccessPrivate: return clang::ObjCIvarDecl::Private; + case eAccessProtected: return clang::ObjCIvarDecl::Protected; + case eAccessPackage: return clang::ObjCIvarDecl::Package; } - return ObjCIvarDecl::None; + return clang::ObjCIvarDecl::None; } //---------------------------------------------------------------------- @@ -194,7 +192,7 @@ ClangASTType::IsAggregateType () const if (!IsValid()) return false; - QualType qual_type (GetCanonicalQualType()); + clang::QualType qual_type (GetCanonicalQualType()); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); switch (type_class) @@ -209,11 +207,11 @@ ClangASTType::IsAggregateType () const case clang::Type::ObjCInterface: return true; case clang::Type::Elaborated: - return ClangASTType(m_ast, cast(qual_type)->getNamedType()).IsAggregateType(); + return ClangASTType(m_ast, llvm::cast(qual_type)->getNamedType()).IsAggregateType(); case clang::Type::Typedef: - return ClangASTType(m_ast, cast(qual_type)->getDecl()->getUnderlyingType()).IsAggregateType(); + return ClangASTType(m_ast, llvm::cast(qual_type)->getDecl()->getUnderlyingType()).IsAggregateType(); case clang::Type::Paren: - return ClangASTType(m_ast, cast(qual_type)->desugar()).IsAggregateType(); + return ClangASTType(m_ast, llvm::cast(qual_type)->desugar()).IsAggregateType(); default: break; } @@ -228,7 +226,7 @@ ClangASTType::IsArrayType (ClangASTType *element_type_ptr, { if (IsValid()) { - QualType qual_type (GetCanonicalQualType()); + clang::QualType qual_type (GetCanonicalQualType()); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); switch (type_class) @@ -238,14 +236,14 @@ ClangASTType::IsArrayType (ClangASTType *element_type_ptr, case clang::Type::ConstantArray: if (element_type_ptr) - element_type_ptr->SetClangType (m_ast, cast(qual_type)->getElementType()); + element_type_ptr->SetClangType (m_ast, llvm::cast(qual_type)->getElementType()); if (size) - *size = cast(qual_type)->getSize().getLimitedValue(ULLONG_MAX); + *size = llvm::cast(qual_type)->getSize().getLimitedValue(ULLONG_MAX); return true; case clang::Type::IncompleteArray: if (element_type_ptr) - element_type_ptr->SetClangType (m_ast, cast(qual_type)->getElementType()); + element_type_ptr->SetClangType (m_ast, llvm::cast(qual_type)->getElementType()); if (size) *size = 0; if (is_incomplete) @@ -254,28 +252,28 @@ ClangASTType::IsArrayType (ClangASTType *element_type_ptr, case clang::Type::VariableArray: if (element_type_ptr) - element_type_ptr->SetClangType (m_ast, cast(qual_type)->getElementType()); + element_type_ptr->SetClangType (m_ast, llvm::cast(qual_type)->getElementType()); if (size) *size = 0; return true; case clang::Type::DependentSizedArray: if (element_type_ptr) - element_type_ptr->SetClangType (m_ast, cast(qual_type)->getElementType()); + element_type_ptr->SetClangType (m_ast, llvm::cast(qual_type)->getElementType()); if (size) *size = 0; return true; case clang::Type::Typedef: - return ClangASTType (m_ast, cast(qual_type)->getDecl()->getUnderlyingType()).IsArrayType (element_type_ptr, + return ClangASTType (m_ast, llvm::cast(qual_type)->getDecl()->getUnderlyingType()).IsArrayType (element_type_ptr, size, is_incomplete); case clang::Type::Elaborated: - return ClangASTType (m_ast, cast(qual_type)->getNamedType()).IsArrayType (element_type_ptr, + return ClangASTType (m_ast, llvm::cast(qual_type)->getNamedType()).IsArrayType (element_type_ptr, size, is_incomplete); case clang::Type::Paren: - return ClangASTType (m_ast, cast(qual_type)->desugar()).IsArrayType (element_type_ptr, + return ClangASTType (m_ast, llvm::cast(qual_type)->desugar()).IsArrayType (element_type_ptr, size, is_incomplete); } @@ -352,7 +350,7 @@ ClangASTType::IsCStringType (uint32_t &length) const { // We know the size of the array and it could be a C string // since it is an array of characters - length = cast(GetCanonicalQualType().getTypePtr())->getSize().getLimitedValue(); + length = llvm::cast(GetCanonicalQualType().getTypePtr())->getSize().getLimitedValue(); } return true; @@ -366,7 +364,7 @@ ClangASTType::IsFunctionType (bool *is_variadic_ptr) const { if (IsValid()) { - QualType qual_type (GetCanonicalQualType()); + clang::QualType qual_type (GetCanonicalQualType()); if (qual_type->isFunctionType()) { @@ -387,16 +385,16 @@ ClangASTType::IsFunctionType (bool *is_variadic_ptr) const default: break; case clang::Type::Typedef: - return ClangASTType (m_ast, cast(qual_type)->getDecl()->getUnderlyingType()).IsFunctionType(); + return ClangASTType (m_ast, llvm::cast(qual_type)->getDecl()->getUnderlyingType()).IsFunctionType(); case clang::Type::Elaborated: - return ClangASTType (m_ast, cast(qual_type)->getNamedType()).IsFunctionType(); + return ClangASTType (m_ast, llvm::cast(qual_type)->getNamedType()).IsFunctionType(); case clang::Type::Paren: - return ClangASTType (m_ast, cast(qual_type)->desugar()).IsFunctionType(); + return ClangASTType (m_ast, llvm::cast(qual_type)->desugar()).IsFunctionType(); case clang::Type::LValueReference: case clang::Type::RValueReference: { - const ReferenceType *reference_type = cast(qual_type.getTypePtr()); + const clang::ReferenceType *reference_type = llvm::cast(qual_type.getTypePtr()); if (reference_type) return ClangASTType (m_ast, reference_type->getPointeeType()).IsFunctionType(); } @@ -413,35 +411,35 @@ ClangASTType::IsHomogeneousAggregate (ClangASTType* base_type_ptr) const if (!IsValid()) return 0; - QualType qual_type(GetCanonicalQualType()); + clang::QualType qual_type(GetCanonicalQualType()); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); switch (type_class) { case clang::Type::Record: if (GetCompleteType ()) { - const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); + const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); if (cxx_record_decl) { if (cxx_record_decl->getNumBases() || cxx_record_decl->isDynamicClass()) return 0; } - const RecordType *record_type = cast(qual_type.getTypePtr()); + const clang::RecordType *record_type = llvm::cast(qual_type.getTypePtr()); if (record_type) { - const RecordDecl *record_decl = record_type->getDecl(); + const clang::RecordDecl *record_decl = record_type->getDecl(); if (record_decl) { // We are looking for a structure that contains only floating point types - RecordDecl::field_iterator field_pos, field_end = record_decl->field_end(); + clang::RecordDecl::field_iterator field_pos, field_end = record_decl->field_end(); uint32_t num_fields = 0; bool is_hva = false; bool is_hfa = false; - QualType base_qual_type; + clang::QualType base_qual_type; for (field_pos = record_decl->field_begin(); field_pos != field_end; ++field_pos) { - QualType field_qual_type = field_pos->getType(); + clang::QualType field_qual_type = field_pos->getType(); if (field_qual_type->isFloatingType()) { if (field_qual_type->isComplexType()) @@ -462,7 +460,7 @@ ClangASTType::IsHomogeneousAggregate (ClangASTType* base_type_ptr) const } else if (field_qual_type->isVectorType() || field_qual_type->isExtVectorType()) { - const VectorType *array = cast(field_qual_type.getTypePtr()); + const clang::VectorType *array = llvm::cast(field_qual_type.getTypePtr()); if (array && array->getNumElements() <= 4) { if (num_fields == 0) @@ -492,10 +490,10 @@ ClangASTType::IsHomogeneousAggregate (ClangASTType* base_type_ptr) const break; case clang::Type::Typedef: - return ClangASTType(m_ast, cast(qual_type)->getDecl()->getUnderlyingType()).IsHomogeneousAggregate (base_type_ptr); + return ClangASTType(m_ast, llvm::cast(qual_type)->getDecl()->getUnderlyingType()).IsHomogeneousAggregate (base_type_ptr); case clang::Type::Elaborated: - return ClangASTType(m_ast, cast(qual_type)->getNamedType()).IsHomogeneousAggregate (base_type_ptr); + return ClangASTType(m_ast, llvm::cast(qual_type)->getNamedType()).IsHomogeneousAggregate (base_type_ptr); default: break; } @@ -507,8 +505,8 @@ ClangASTType::GetNumberOfFunctionArguments () const { if (IsValid()) { - QualType qual_type (GetCanonicalQualType()); - const FunctionProtoType* func = dyn_cast(qual_type.getTypePtr()); + clang::QualType qual_type (GetCanonicalQualType()); + const clang::FunctionProtoType* func = llvm::dyn_cast(qual_type.getTypePtr()); if (func) return func->getNumParams(); } @@ -520,8 +518,8 @@ ClangASTType::GetFunctionArgumentAtIndex (const size_t index) { if (IsValid()) { - QualType qual_type (GetCanonicalQualType()); - const FunctionProtoType* func = dyn_cast(qual_type.getTypePtr()); + clang::QualType qual_type (GetCanonicalQualType()); + const clang::FunctionProtoType* func = llvm::dyn_cast(qual_type.getTypePtr()); if (func) { if (index < func->getNumParams()) @@ -536,7 +534,7 @@ ClangASTType::IsFunctionPointerType () const { if (IsValid()) { - QualType qual_type (GetCanonicalQualType()); + clang::QualType qual_type (GetCanonicalQualType()); if (qual_type->isFunctionPointerType()) return true; @@ -547,16 +545,16 @@ ClangASTType::IsFunctionPointerType () const default: break; case clang::Type::Typedef: - return ClangASTType (m_ast, cast(qual_type)->getDecl()->getUnderlyingType()).IsFunctionPointerType(); + return ClangASTType (m_ast, llvm::cast(qual_type)->getDecl()->getUnderlyingType()).IsFunctionPointerType(); case clang::Type::Elaborated: - return ClangASTType (m_ast, cast(qual_type)->getNamedType()).IsFunctionPointerType(); + return ClangASTType (m_ast, llvm::cast(qual_type)->getNamedType()).IsFunctionPointerType(); case clang::Type::Paren: - return ClangASTType (m_ast, cast(qual_type)->desugar()).IsFunctionPointerType(); + return ClangASTType (m_ast, llvm::cast(qual_type)->desugar()).IsFunctionPointerType(); case clang::Type::LValueReference: case clang::Type::RValueReference: { - const ReferenceType *reference_type = cast(qual_type.getTypePtr()); + const clang::ReferenceType *reference_type = llvm::cast(qual_type.getTypePtr()); if (reference_type) return ClangASTType (m_ast, reference_type->getPointeeType()).IsFunctionPointerType(); } @@ -573,8 +571,8 @@ ClangASTType::IsIntegerType (bool &is_signed) const if (!IsValid()) return false; - QualType qual_type (GetCanonicalQualType()); - const BuiltinType *builtin_type = dyn_cast(qual_type->getCanonicalTypeInternal()); + clang::QualType qual_type (GetCanonicalQualType()); + const clang::BuiltinType *builtin_type = llvm::dyn_cast(qual_type->getCanonicalTypeInternal()); if (builtin_type) { @@ -593,12 +591,12 @@ ClangASTType::IsPointerType (ClangASTType *pointee_type) const { if (IsValid()) { - QualType qual_type (GetCanonicalQualType()); + clang::QualType qual_type (GetCanonicalQualType()); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); switch (type_class) { case clang::Type::Builtin: - switch (cast(qual_type)->getKind()) + switch (llvm::cast(qual_type)->getKind()) { default: break; @@ -609,26 +607,26 @@ ClangASTType::IsPointerType (ClangASTType *pointee_type) const return false; case clang::Type::ObjCObjectPointer: if (pointee_type) - pointee_type->SetClangType (m_ast, cast(qual_type)->getPointeeType()); + pointee_type->SetClangType (m_ast, llvm::cast(qual_type)->getPointeeType()); return true; case clang::Type::BlockPointer: if (pointee_type) - pointee_type->SetClangType (m_ast, cast(qual_type)->getPointeeType()); + pointee_type->SetClangType (m_ast, llvm::cast(qual_type)->getPointeeType()); return true; case clang::Type::Pointer: if (pointee_type) - pointee_type->SetClangType (m_ast, cast(qual_type)->getPointeeType()); + pointee_type->SetClangType (m_ast, llvm::cast(qual_type)->getPointeeType()); return true; case clang::Type::MemberPointer: if (pointee_type) - pointee_type->SetClangType (m_ast, cast(qual_type)->getPointeeType()); + pointee_type->SetClangType (m_ast, llvm::cast(qual_type)->getPointeeType()); return true; case clang::Type::Typedef: - return ClangASTType (m_ast, cast(qual_type)->getDecl()->getUnderlyingType()).IsPointerType(pointee_type); + return ClangASTType (m_ast, llvm::cast(qual_type)->getDecl()->getUnderlyingType()).IsPointerType(pointee_type); case clang::Type::Elaborated: - return ClangASTType (m_ast, cast(qual_type)->getNamedType()).IsPointerType(pointee_type); + return ClangASTType (m_ast, llvm::cast(qual_type)->getNamedType()).IsPointerType(pointee_type); case clang::Type::Paren: - return ClangASTType (m_ast, cast(qual_type)->desugar()).IsPointerType(pointee_type); + return ClangASTType (m_ast, llvm::cast(qual_type)->desugar()).IsPointerType(pointee_type); default: break; } @@ -644,12 +642,12 @@ ClangASTType::IsPointerOrReferenceType (ClangASTType *pointee_type) const { if (IsValid()) { - QualType qual_type (GetCanonicalQualType()); + clang::QualType qual_type (GetCanonicalQualType()); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); switch (type_class) { case clang::Type::Builtin: - switch (cast(qual_type)->getKind()) + switch (llvm::cast(qual_type)->getKind()) { default: break; @@ -660,34 +658,34 @@ ClangASTType::IsPointerOrReferenceType (ClangASTType *pointee_type) const return false; case clang::Type::ObjCObjectPointer: if (pointee_type) - pointee_type->SetClangType(m_ast, cast(qual_type)->getPointeeType()); + pointee_type->SetClangType(m_ast, llvm::cast(qual_type)->getPointeeType()); return true; case clang::Type::BlockPointer: if (pointee_type) - pointee_type->SetClangType(m_ast, cast(qual_type)->getPointeeType()); + pointee_type->SetClangType(m_ast, llvm::cast(qual_type)->getPointeeType()); return true; case clang::Type::Pointer: if (pointee_type) - pointee_type->SetClangType(m_ast, cast(qual_type)->getPointeeType()); + pointee_type->SetClangType(m_ast, llvm::cast(qual_type)->getPointeeType()); return true; case clang::Type::MemberPointer: if (pointee_type) - pointee_type->SetClangType(m_ast, cast(qual_type)->getPointeeType()); + pointee_type->SetClangType(m_ast, llvm::cast(qual_type)->getPointeeType()); return true; case clang::Type::LValueReference: if (pointee_type) - pointee_type->SetClangType(m_ast, cast(qual_type)->desugar()); + pointee_type->SetClangType(m_ast, llvm::cast(qual_type)->desugar()); return true; case clang::Type::RValueReference: if (pointee_type) - pointee_type->SetClangType(m_ast, cast(qual_type)->desugar()); + pointee_type->SetClangType(m_ast, llvm::cast(qual_type)->desugar()); return true; case clang::Type::Typedef: - return ClangASTType (m_ast, cast(qual_type)->getDecl()->getUnderlyingType()).IsPointerOrReferenceType(pointee_type); + return ClangASTType (m_ast, llvm::cast(qual_type)->getDecl()->getUnderlyingType()).IsPointerOrReferenceType(pointee_type); case clang::Type::Elaborated: - return ClangASTType (m_ast, cast(qual_type)->getNamedType()).IsPointerOrReferenceType(pointee_type); + return ClangASTType (m_ast, llvm::cast(qual_type)->getNamedType()).IsPointerOrReferenceType(pointee_type); case clang::Type::Paren: - return ClangASTType (m_ast, cast(qual_type)->desugar()).IsPointerOrReferenceType(pointee_type); + return ClangASTType (m_ast, llvm::cast(qual_type)->desugar()).IsPointerOrReferenceType(pointee_type); default: break; } @@ -703,29 +701,29 @@ ClangASTType::IsReferenceType (ClangASTType *pointee_type, bool* is_rvalue) cons { if (IsValid()) { - QualType qual_type (GetCanonicalQualType()); + clang::QualType qual_type (GetCanonicalQualType()); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); switch (type_class) { case clang::Type::LValueReference: if (pointee_type) - pointee_type->SetClangType(m_ast, cast(qual_type)->desugar()); + pointee_type->SetClangType(m_ast, llvm::cast(qual_type)->desugar()); if (is_rvalue) *is_rvalue = false; return true; case clang::Type::RValueReference: if (pointee_type) - pointee_type->SetClangType(m_ast, cast(qual_type)->desugar()); + pointee_type->SetClangType(m_ast, llvm::cast(qual_type)->desugar()); if (is_rvalue) *is_rvalue = true; return true; case clang::Type::Typedef: - return ClangASTType(m_ast, cast(qual_type)->getDecl()->getUnderlyingType()).IsReferenceType(pointee_type, is_rvalue); + return ClangASTType(m_ast, llvm::cast(qual_type)->getDecl()->getUnderlyingType()).IsReferenceType(pointee_type, is_rvalue); case clang::Type::Elaborated: - return ClangASTType(m_ast, cast(qual_type)->getNamedType()).IsReferenceType(pointee_type, is_rvalue); + return ClangASTType(m_ast, llvm::cast(qual_type)->getNamedType()).IsReferenceType(pointee_type, is_rvalue); case clang::Type::Paren: - return ClangASTType(m_ast, cast(qual_type)->desugar()).IsReferenceType(pointee_type, is_rvalue); + return ClangASTType(m_ast, llvm::cast(qual_type)->desugar()).IsReferenceType(pointee_type, is_rvalue); default: break; @@ -741,19 +739,19 @@ ClangASTType::IsFloatingPointType (uint32_t &count, bool &is_complex) const { if (IsValid()) { - QualType qual_type (GetCanonicalQualType()); + clang::QualType qual_type (GetCanonicalQualType()); - if (const BuiltinType *BT = dyn_cast(qual_type->getCanonicalTypeInternal())) + if (const clang::BuiltinType *BT = llvm::dyn_cast(qual_type->getCanonicalTypeInternal())) { clang::BuiltinType::Kind kind = BT->getKind(); - if (kind >= BuiltinType::Float && kind <= BuiltinType::LongDouble) + if (kind >= clang::BuiltinType::Float && kind <= clang::BuiltinType::LongDouble) { count = 1; is_complex = false; return true; } } - else if (const ComplexType *CT = dyn_cast(qual_type->getCanonicalTypeInternal())) + else if (const clang::ComplexType *CT = llvm::dyn_cast(qual_type->getCanonicalTypeInternal())) { if (ClangASTType (m_ast, CT->getElementType()).IsFloatingPointType (count, is_complex)) { @@ -762,7 +760,7 @@ ClangASTType::IsFloatingPointType (uint32_t &count, bool &is_complex) const return true; } } - else if (const VectorType *VT = dyn_cast(qual_type->getCanonicalTypeInternal())) + else if (const clang::VectorType *VT = llvm::dyn_cast(qual_type->getCanonicalTypeInternal())) { if (ClangASTType (m_ast, VT->getElementType()).IsFloatingPointType (count, is_complex)) { @@ -784,21 +782,21 @@ ClangASTType::IsDefined() const if (!IsValid()) return false; - QualType qual_type(GetQualType()); - const TagType *tag_type = dyn_cast(qual_type.getTypePtr()); + clang::QualType qual_type(GetQualType()); + const clang::TagType *tag_type = llvm::dyn_cast(qual_type.getTypePtr()); if (tag_type) { - TagDecl *tag_decl = tag_type->getDecl(); + clang::TagDecl *tag_decl = tag_type->getDecl(); if (tag_decl) return tag_decl->isCompleteDefinition(); return false; } else { - const ObjCObjectType *objc_class_type = dyn_cast(qual_type); + const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast(qual_type); if (objc_class_type) { - ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); + clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); if (class_interface_decl) return class_interface_decl->getDefinition() != nullptr; return false; @@ -812,9 +810,9 @@ ClangASTType::IsObjCClassType () const { if (IsValid()) { - QualType qual_type (GetCanonicalQualType()); + clang::QualType qual_type (GetCanonicalQualType()); - const ObjCObjectPointerType *obj_pointer_type = dyn_cast(qual_type); + const clang::ObjCObjectPointerType *obj_pointer_type = llvm::dyn_cast(qual_type); if (obj_pointer_type) return obj_pointer_type->isObjCClassType(); @@ -835,18 +833,18 @@ ClangASTType::IsPolymorphicClass () const { if (IsValid()) { - QualType qual_type(GetCanonicalQualType()); + clang::QualType qual_type(GetCanonicalQualType()); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); switch (type_class) { case clang::Type::Record: if (GetCompleteType()) { - const RecordType *record_type = cast(qual_type.getTypePtr()); - const RecordDecl *record_decl = record_type->getDecl(); + const clang::RecordType *record_type = llvm::cast(qual_type.getTypePtr()); + const clang::RecordDecl *record_decl = record_type->getDecl(); if (record_decl) { - const CXXRecordDecl *cxx_record_decl = dyn_cast(record_decl); + const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast(record_decl); if (cxx_record_decl) return cxx_record_decl->isPolymorphic(); } @@ -865,16 +863,16 @@ ClangASTType::IsPossibleDynamicType (ClangASTType *dynamic_pointee_type, bool check_cplusplus, bool check_objc) const { - QualType pointee_qual_type; + clang::QualType pointee_qual_type; if (m_type) { - QualType qual_type (GetCanonicalQualType()); + clang::QualType qual_type (GetCanonicalQualType()); bool success = false; const clang::Type::TypeClass type_class = qual_type->getTypeClass(); switch (type_class) { case clang::Type::Builtin: - if (check_objc && cast(qual_type)->getKind() == BuiltinType::ObjCId) + if (check_objc && llvm::cast(qual_type)->getKind() == clang::BuiltinType::ObjCId) { if (dynamic_pointee_type) dynamic_pointee_type->SetClangType(m_ast, m_type); @@ -886,37 +884,37 @@ ClangASTType::IsPossibleDynamicType (ClangASTType *dynamic_pointee_type, if (check_objc) { if (dynamic_pointee_type) - dynamic_pointee_type->SetClangType(m_ast, cast(qual_type)->getPointeeType()); + dynamic_pointee_type->SetClangType(m_ast, llvm::cast(qual_type)->getPointeeType()); return true; } break; case clang::Type::Pointer: - pointee_qual_type = cast(qual_type)->getPointeeType(); + pointee_qual_type = llvm::cast(qual_type)->getPointeeType(); success = true; break; case clang::Type::LValueReference: case clang::Type::RValueReference: - pointee_qual_type = cast(qual_type)->getPointeeType(); + pointee_qual_type = llvm::cast(qual_type)->getPointeeType(); success = true; break; case clang::Type::Typedef: return ClangASTType (m_ast, - cast(qual_type)->getDecl()->getUnderlyingType()).IsPossibleDynamicType (dynamic_pointee_type, + llvm::cast(qual_type)->getDecl()->getUnderlyingType()).IsPossibleDynamicType (dynamic_pointee_type, check_cplusplus, check_objc); case clang::Type::Elaborated: return ClangASTType (m_ast, - cast(qual_type)->getNamedType()).IsPossibleDynamicType (dynamic_pointee_type, + llvm::cast(qual_type)->getNamedType()).IsPossibleDynamicType (dynamic_pointee_type, check_cplusplus, check_objc); case clang::Type::Paren: return ClangASTType (m_ast, - cast(qual_type)->desugar()).IsPossibleDynamicType (dynamic_pointee_type, + llvm::cast(qual_type)->desugar()).IsPossibleDynamicType (dynamic_pointee_type, check_cplusplus, check_objc); default: @@ -932,55 +930,55 @@ ClangASTType::IsPossibleDynamicType (ClangASTType *dynamic_pointee_type, switch (pointee_type_class) { case clang::Type::Builtin: - switch (cast(pointee_qual_type)->getKind()) + switch (llvm::cast(pointee_qual_type)->getKind()) { - case BuiltinType::UnknownAny: - case BuiltinType::Void: + case clang::BuiltinType::UnknownAny: + case clang::BuiltinType::Void: if (dynamic_pointee_type) dynamic_pointee_type->SetClangType(m_ast, pointee_qual_type); return true; - case BuiltinType::NullPtr: - case BuiltinType::Bool: - case BuiltinType::Char_U: - case BuiltinType::UChar: - case BuiltinType::WChar_U: - case BuiltinType::Char16: - case BuiltinType::Char32: - case BuiltinType::UShort: - case BuiltinType::UInt: - case BuiltinType::ULong: - case BuiltinType::ULongLong: - case BuiltinType::UInt128: - case BuiltinType::Char_S: - case BuiltinType::SChar: - case BuiltinType::WChar_S: - case BuiltinType::Short: - case BuiltinType::Int: - case BuiltinType::Long: - case BuiltinType::LongLong: - case BuiltinType::Int128: - case BuiltinType::Float: - case BuiltinType::Double: - case BuiltinType::LongDouble: - case BuiltinType::Dependent: - case BuiltinType::Overload: - case BuiltinType::ObjCId: - case BuiltinType::ObjCClass: - case BuiltinType::ObjCSel: - case BuiltinType::BoundMember: - case BuiltinType::Half: - case BuiltinType::ARCUnbridgedCast: - case BuiltinType::PseudoObject: - case BuiltinType::BuiltinFn: - case BuiltinType::OCLEvent: - case BuiltinType::OCLImage1d: - case BuiltinType::OCLImage1dArray: - case BuiltinType::OCLImage1dBuffer: - case BuiltinType::OCLImage2d: - case BuiltinType::OCLImage2dArray: - case BuiltinType::OCLImage3d: - case BuiltinType::OCLSampler: + case clang::BuiltinType::NullPtr: + case clang::BuiltinType::Bool: + case clang::BuiltinType::Char_U: + case clang::BuiltinType::UChar: + case clang::BuiltinType::WChar_U: + case clang::BuiltinType::Char16: + case clang::BuiltinType::Char32: + case clang::BuiltinType::UShort: + case clang::BuiltinType::UInt: + case clang::BuiltinType::ULong: + case clang::BuiltinType::ULongLong: + case clang::BuiltinType::UInt128: + case clang::BuiltinType::Char_S: + case clang::BuiltinType::SChar: + case clang::BuiltinType::WChar_S: + case clang::BuiltinType::Short: + case clang::BuiltinType::Int: + case clang::BuiltinType::Long: + case clang::BuiltinType::LongLong: + case clang::BuiltinType::Int128: + case clang::BuiltinType::Float: + case clang::BuiltinType::Double: + case clang::BuiltinType::LongDouble: + case clang::BuiltinType::Dependent: + case clang::BuiltinType::Overload: + case clang::BuiltinType::ObjCId: + case clang::BuiltinType::ObjCClass: + case clang::BuiltinType::ObjCSel: + case clang::BuiltinType::BoundMember: + case clang::BuiltinType::Half: + case clang::BuiltinType::ARCUnbridgedCast: + case clang::BuiltinType::PseudoObject: + case clang::BuiltinType::BuiltinFn: + case clang::BuiltinType::OCLEvent: + case clang::BuiltinType::OCLImage1d: + case clang::BuiltinType::OCLImage1dArray: + case clang::BuiltinType::OCLImage1dBuffer: + case clang::BuiltinType::OCLImage2d: + case clang::BuiltinType::OCLImage2dArray: + case clang::BuiltinType::OCLImage3d: + case clang::BuiltinType::OCLSampler: break; } break; @@ -988,7 +986,7 @@ ClangASTType::IsPossibleDynamicType (ClangASTType *dynamic_pointee_type, case clang::Type::Record: if (check_cplusplus) { - CXXRecordDecl *cxx_record_decl = pointee_qual_type->getAsCXXRecordDecl(); + clang::CXXRecordDecl *cxx_record_decl = pointee_qual_type->getAsCXXRecordDecl(); if (cxx_record_decl) { bool is_complete = cxx_record_decl->isCompleteDefinition(); @@ -1090,9 +1088,9 @@ ClangASTType::GetCXXClassName (std::string &class_name) const { if (IsValid()) { - QualType qual_type (GetCanonicalQualType()); + clang::QualType qual_type (GetCanonicalQualType()); - CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); + clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); if (cxx_record_decl) { class_name.assign (cxx_record_decl->getIdentifier()->getNameStart()); @@ -1110,7 +1108,7 @@ ClangASTType::IsCXXClassType () const if (!IsValid()) return false; - QualType qual_type (GetCanonicalQualType()); + clang::QualType qual_type (GetCanonicalQualType()); if (qual_type->getAsCXXRecordDecl() != nullptr) return true; return false; @@ -1121,8 +1119,8 @@ ClangASTType::IsBeingDefined () const { if (!IsValid()) return false; - QualType qual_type (GetCanonicalQualType()); - const clang::TagType *tag_type = dyn_cast(qual_type); + clang::QualType qual_type (GetCanonicalQualType()); + const clang::TagType *tag_type = llvm::dyn_cast(qual_type); if (tag_type) return tag_type->isBeingDefined(); return false; @@ -1134,7 +1132,7 @@ ClangASTType::IsObjCObjectPointerType (ClangASTType *class_type_ptr) if (!IsValid()) return false; - QualType qual_type (GetCanonicalQualType()); + clang::QualType qual_type (GetCanonicalQualType()); if (qual_type->isObjCObjectPointerType()) { @@ -1143,11 +1141,11 @@ ClangASTType::IsObjCObjectPointerType (ClangASTType *class_type_ptr) if (!qual_type->isObjCClassType() && !qual_type->isObjCIdType()) { - const ObjCObjectPointerType *obj_pointer_type = dyn_cast(qual_type); + const clang::ObjCObjectPointerType *obj_pointer_type = llvm::dyn_cast(qual_type); if (obj_pointer_type == nullptr) class_type_ptr->Clear(); else - class_type_ptr->SetClangType (m_ast, QualType(obj_pointer_type->getInterfaceType(), 0)); + class_type_ptr->SetClangType (m_ast, clang::QualType(obj_pointer_type->getInterfaceType(), 0)); } } return true; @@ -1163,12 +1161,12 @@ ClangASTType::GetObjCClassName (std::string &class_name) if (!IsValid()) return false; - QualType qual_type (GetCanonicalQualType()); + clang::QualType qual_type (GetCanonicalQualType()); - const ObjCObjectType *object_type = dyn_cast(qual_type); + const clang::ObjCObjectType *object_type = llvm::dyn_cast(qual_type); if (object_type) { - const ObjCInterfaceDecl *interface = object_type->getInterface(); + const clang::ObjCInterfaceDecl *interface = object_type->getInterface(); if (interface) { class_name = interface->getNameAsString(); @@ -1227,14 +1225,14 @@ ClangASTType::GetTypeName () const std::string type_name; if (IsValid()) { - PrintingPolicy printing_policy (m_ast->getPrintingPolicy()); - QualType qual_type(GetQualType()); + clang::PrintingPolicy printing_policy (m_ast->getPrintingPolicy()); + clang::QualType qual_type(GetQualType()); printing_policy.SuppressTagKeyword = true; printing_policy.LangOpts.WChar = true; - const TypedefType *typedef_type = qual_type->getAs(); + const clang::TypedefType *typedef_type = qual_type->getAs(); if (typedef_type) { - const TypedefNameDecl *typedef_decl = typedef_type->getDecl(); + const clang::TypedefNameDecl *typedef_decl = typedef_type->getDecl(); type_name = typedef_decl->getQualifiedNameAsString(); } else @@ -1255,14 +1253,14 @@ ClangASTType::GetTypeInfo (ClangASTType *pointee_or_element_clang_type) const if (pointee_or_element_clang_type) pointee_or_element_clang_type->Clear(); - QualType qual_type (GetQualType()); + clang::QualType qual_type (GetQualType()); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); switch (type_class) { case clang::Type::Builtin: { - const BuiltinType *builtin_type = dyn_cast(qual_type->getCanonicalTypeInternal()); + const clang::BuiltinType *builtin_type = llvm::dyn_cast(qual_type->getCanonicalTypeInternal()); uint32_t builtin_type_flags = eTypeIsBuiltIn | eTypeHasValue; switch (builtin_type->getKind()) @@ -1326,10 +1324,10 @@ ClangASTType::GetTypeInfo (ClangASTType *pointee_or_element_clang_type) const case clang::Type::Complex: { uint32_t complex_type_flags = eTypeIsBuiltIn | eTypeHasValue | eTypeIsComplex; - const ComplexType *complex_type = dyn_cast(qual_type->getCanonicalTypeInternal()); + const clang::ComplexType *complex_type = llvm::dyn_cast(qual_type->getCanonicalTypeInternal()); if (complex_type) { - QualType complex_element_type (complex_type->getElementType()); + clang::QualType complex_element_type (complex_type->getElementType()); if (complex_element_type->isIntegerType()) complex_type_flags |= eTypeIsFloat; else if (complex_element_type->isFloatingType()) @@ -1344,7 +1342,7 @@ ClangASTType::GetTypeInfo (ClangASTType *pointee_or_element_clang_type) const case clang::Type::IncompleteArray: case clang::Type::VariableArray: if (pointee_or_element_clang_type) - pointee_or_element_clang_type->SetClangType(m_ast, cast(qual_type.getTypePtr())->getElementType()); + pointee_or_element_clang_type->SetClangType(m_ast, llvm::cast(qual_type.getTypePtr())->getElementType()); return eTypeHasChildren | eTypeIsArray; case clang::Type::DependentName: return 0; @@ -1354,13 +1352,13 @@ ClangASTType::GetTypeInfo (ClangASTType *pointee_or_element_clang_type) const case clang::Type::Enum: if (pointee_or_element_clang_type) - pointee_or_element_clang_type->SetClangType(m_ast, cast(qual_type)->getDecl()->getIntegerType()); + pointee_or_element_clang_type->SetClangType(m_ast, llvm::cast(qual_type)->getDecl()->getIntegerType()); return eTypeIsEnumeration | eTypeHasValue; case clang::Type::Elaborated: - return ClangASTType (m_ast, cast(qual_type)->getNamedType()).GetTypeInfo (pointee_or_element_clang_type); + return ClangASTType (m_ast, llvm::cast(qual_type)->getNamedType()).GetTypeInfo (pointee_or_element_clang_type); case clang::Type::Paren: - return ClangASTType (m_ast, cast(qual_type)->desugar()).GetTypeInfo (pointee_or_element_clang_type); + return ClangASTType (m_ast, llvm::cast(qual_type)->desugar()).GetTypeInfo (pointee_or_element_clang_type); case clang::Type::FunctionProto: return eTypeIsFuncPrototype | eTypeHasValue; case clang::Type::FunctionNoProto: return eTypeIsFuncPrototype | eTypeHasValue; @@ -1369,7 +1367,7 @@ ClangASTType::GetTypeInfo (ClangASTType *pointee_or_element_clang_type) const case clang::Type::LValueReference: case clang::Type::RValueReference: if (pointee_or_element_clang_type) - pointee_or_element_clang_type->SetClangType(m_ast, cast(qual_type.getTypePtr())->getPointeeType()); + pointee_or_element_clang_type->SetClangType(m_ast, llvm::cast(qual_type.getTypePtr())->getPointeeType()); return eTypeHasChildren | eTypeIsReference | eTypeHasValue; case clang::Type::MemberPointer: return eTypeIsPointer | eTypeIsMember | eTypeHasValue; @@ -1398,7 +1396,7 @@ ClangASTType::GetTypeInfo (ClangASTType *pointee_or_element_clang_type) const case clang::Type::TemplateSpecialization: return eTypeIsTemplate; case clang::Type::Typedef: - return eTypeIsTypedef | ClangASTType (m_ast, cast(qual_type)->getDecl()->getUnderlyingType()).GetTypeInfo (pointee_or_element_clang_type); + return eTypeIsTypedef | ClangASTType (m_ast, llvm::cast(qual_type)->getDecl()->getUnderlyingType()).GetTypeInfo (pointee_or_element_clang_type); case clang::Type::TypeOfExpr: return 0; case clang::Type::TypeOf: return 0; case clang::Type::UnresolvedUsing: return 0; @@ -1407,7 +1405,7 @@ ClangASTType::GetTypeInfo (ClangASTType *pointee_or_element_clang_type) const case clang::Type::Vector: { uint32_t vector_type_flags = eTypeHasChildren | eTypeIsVector; - const VectorType *vector_type = dyn_cast(qual_type->getCanonicalTypeInternal()); + const clang::VectorType *vector_type = llvm::dyn_cast(qual_type->getCanonicalTypeInternal()); if (vector_type) { if (vector_type->isIntegerType()) @@ -1431,13 +1429,13 @@ ClangASTType::GetMinimumLanguage () return lldb::eLanguageTypeC; // If the type is a reference, then resolve it to what it refers to first: - QualType qual_type (GetCanonicalQualType().getNonReferenceType()); + clang::QualType qual_type (GetCanonicalQualType().getNonReferenceType()); if (qual_type->isAnyPointerType()) { if (qual_type->isObjCObjectPointerType()) return lldb::eLanguageTypeObjC; - QualType pointee_type (qual_type->getPointeeType()); + clang::QualType pointee_type (qual_type->getPointeeType()); if (pointee_type->getPointeeCXXRecordDecl() != nullptr) return lldb::eLanguageTypeC_plus_plus; if (pointee_type->isObjCObjectOrInterfaceType()) @@ -1458,51 +1456,51 @@ ClangASTType::GetMinimumLanguage () default: break; case clang::Type::Builtin: - switch (cast(qual_type)->getKind()) + switch (llvm::cast(qual_type)->getKind()) { default: - case BuiltinType::Void: - case BuiltinType::Bool: - case BuiltinType::Char_U: - case BuiltinType::UChar: - case BuiltinType::WChar_U: - case BuiltinType::Char16: - case BuiltinType::Char32: - case BuiltinType::UShort: - case BuiltinType::UInt: - case BuiltinType::ULong: - case BuiltinType::ULongLong: - case BuiltinType::UInt128: - case BuiltinType::Char_S: - case BuiltinType::SChar: - case BuiltinType::WChar_S: - case BuiltinType::Short: - case BuiltinType::Int: - case BuiltinType::Long: - case BuiltinType::LongLong: - case BuiltinType::Int128: - case BuiltinType::Float: - case BuiltinType::Double: - case BuiltinType::LongDouble: + case clang::BuiltinType::Void: + case clang::BuiltinType::Bool: + case clang::BuiltinType::Char_U: + case clang::BuiltinType::UChar: + case clang::BuiltinType::WChar_U: + case clang::BuiltinType::Char16: + case clang::BuiltinType::Char32: + case clang::BuiltinType::UShort: + case clang::BuiltinType::UInt: + case clang::BuiltinType::ULong: + case clang::BuiltinType::ULongLong: + case clang::BuiltinType::UInt128: + case clang::BuiltinType::Char_S: + case clang::BuiltinType::SChar: + case clang::BuiltinType::WChar_S: + case clang::BuiltinType::Short: + case clang::BuiltinType::Int: + case clang::BuiltinType::Long: + case clang::BuiltinType::LongLong: + case clang::BuiltinType::Int128: + case clang::BuiltinType::Float: + case clang::BuiltinType::Double: + case clang::BuiltinType::LongDouble: break; - case BuiltinType::NullPtr: + case clang::BuiltinType::NullPtr: return eLanguageTypeC_plus_plus; - case BuiltinType::ObjCId: - case BuiltinType::ObjCClass: - case BuiltinType::ObjCSel: + case clang::BuiltinType::ObjCId: + case clang::BuiltinType::ObjCClass: + case clang::BuiltinType::ObjCSel: return eLanguageTypeObjC; - case BuiltinType::Dependent: - case BuiltinType::Overload: - case BuiltinType::BoundMember: - case BuiltinType::UnknownAny: + case clang::BuiltinType::Dependent: + case clang::BuiltinType::Overload: + case clang::BuiltinType::BoundMember: + case clang::BuiltinType::UnknownAny: break; } break; case clang::Type::Typedef: - return ClangASTType(m_ast, cast(qual_type)->getDecl()->getUnderlyingType()).GetMinimumLanguage(); + return ClangASTType(m_ast, llvm::cast(qual_type)->getDecl()->getUnderlyingType()).GetMinimumLanguage(); } } return lldb::eLanguageTypeC; @@ -1514,7 +1512,7 @@ ClangASTType::GetTypeClass () const if (!IsValid()) return lldb::eTypeClassInvalid; - QualType qual_type(GetQualType()); + clang::QualType qual_type(GetQualType()); switch (qual_type->getTypeClass()) { @@ -1544,8 +1542,8 @@ ClangASTType::GetTypeClass () const case clang::Type::ObjCInterface: return lldb::eTypeClassObjCInterface; case clang::Type::Record: { - const RecordType *record_type = cast(qual_type.getTypePtr()); - const RecordDecl *record_decl = record_type->getDecl(); + const clang::RecordType *record_type = llvm::cast(qual_type.getTypePtr()); + const clang::RecordDecl *record_decl = record_type->getDecl(); if (record_decl->isUnion()) return lldb::eTypeClassUnion; else if (record_decl->isStruct()) @@ -1558,9 +1556,9 @@ ClangASTType::GetTypeClass () const case clang::Type::Typedef: return lldb::eTypeClassTypedef; case clang::Type::UnresolvedUsing: break; case clang::Type::Paren: - return ClangASTType(m_ast, cast(qual_type)->desugar()).GetTypeClass(); + return ClangASTType(m_ast, llvm::cast(qual_type)->desugar()).GetTypeClass(); case clang::Type::Elaborated: - return ClangASTType(m_ast, cast(qual_type)->getNamedType()).GetTypeClass(); + return ClangASTType(m_ast, llvm::cast(qual_type)->getNamedType()).GetTypeClass(); case clang::Type::Attributed: break; case clang::Type::TemplateTypeParm: break; @@ -1580,6 +1578,7 @@ ClangASTType::GetTypeClass () const // pointer type decayed from an array or function type. case clang::Type::Decayed: break; + case clang::Type::Adjusted: break; } // We don't know hot to display this type... return lldb::eTypeClassOther; @@ -1610,7 +1609,7 @@ ClangASTType::AddConstModifier () const { if (m_type) { - QualType result(GetQualType()); + clang::QualType result(GetQualType()); result.addConst(); return ClangASTType (m_ast, result); } @@ -1622,7 +1621,7 @@ ClangASTType::AddRestrictModifier () const { if (m_type) { - QualType result(GetQualType()); + clang::QualType result(GetQualType()); result.getQualifiers().setRestrict (true); return ClangASTType (m_ast, result); } @@ -1634,7 +1633,7 @@ ClangASTType::AddVolatileModifier () const { if (m_type) { - QualType result(GetQualType()); + clang::QualType result(GetQualType()); result.getQualifiers().setVolatile (true); return ClangASTType (m_ast, result); } @@ -1646,7 +1645,7 @@ ClangASTType::GetArrayElementType (uint64_t *stride) const { if (IsValid()) { - QualType qual_type(GetCanonicalQualType()); + clang::QualType qual_type(GetCanonicalQualType()); const clang::Type *array_elem_type = qual_type.getTypePtr()->getArrayElementTypeNoTypeQual(); @@ -1673,8 +1672,8 @@ ClangASTType::GetCanonicalType () const return ClangASTType(); } -static QualType -GetFullyUnqualifiedType_Impl (ASTContext *ast, QualType qual_type) +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())); @@ -1700,7 +1699,7 @@ ClangASTType::GetFunctionArgumentCount () const { if (IsValid()) { - const FunctionProtoType* func = dyn_cast(GetCanonicalQualType()); + const clang::FunctionProtoType* func = llvm::dyn_cast(GetCanonicalQualType()); if (func) return func->getNumParams(); } @@ -1712,7 +1711,7 @@ ClangASTType::GetFunctionArgumentTypeAtIndex (size_t idx) { if (IsValid()) { - const FunctionProtoType* func = dyn_cast(GetCanonicalQualType()); + const clang::FunctionProtoType* func = llvm::dyn_cast(GetCanonicalQualType()); if (func) { const uint32_t num_args = func->getNumParams(); @@ -1728,8 +1727,8 @@ ClangASTType::GetFunctionReturnType () const { if (IsValid()) { - QualType qual_type(GetCanonicalQualType()); - const FunctionProtoType* func = dyn_cast(qual_type.getTypePtr()); + clang::QualType qual_type(GetCanonicalQualType()); + const clang::FunctionProtoType* func = llvm::dyn_cast(qual_type.getTypePtr()); if (func) return ClangASTType(m_ast, func->getReturnType()); } @@ -1771,19 +1770,19 @@ ClangASTType::CreateTypedefType (const char *typedef_name, { if (IsValid() && typedef_name && typedef_name[0]) { - QualType qual_type (GetQualType()); + clang::QualType qual_type (GetQualType()); if (decl_ctx == nullptr) decl_ctx = m_ast->getTranslationUnitDecl(); - TypedefDecl *decl = TypedefDecl::Create (*m_ast, - decl_ctx, - SourceLocation(), - SourceLocation(), - &m_ast->Idents.get(typedef_name), - m_ast->getTrivialTypeSourceInfo(qual_type)); + clang::TypedefDecl *decl = clang::TypedefDecl::Create (*m_ast, + decl_ctx, + clang::SourceLocation(), + clang::SourceLocation(), + &m_ast->Idents.get(typedef_name), + m_ast->getTrivialTypeSourceInfo(qual_type)); - decl->setAccess(AS_public); // TODO respect proper access specifier + decl->setAccess(clang::AS_public); // TODO respect proper access specifier - // Get a uniqued QualType for the typedef decl type + // Get a uniqued clang::QualType for the typedef decl type return ClangASTType (m_ast, m_ast->getTypedefType (decl)); } return ClangASTType(); @@ -1795,7 +1794,7 @@ ClangASTType::GetPointeeType () const { if (m_type) { - QualType qual_type(GetQualType()); + clang::QualType qual_type(GetQualType()); return ClangASTType (m_ast, qual_type.getTypePtr()->getPointeeType()); } return ClangASTType(); @@ -1806,7 +1805,7 @@ ClangASTType::GetPointerType () const { if (IsValid()) { - QualType qual_type (GetQualType()); + clang::QualType qual_type (GetQualType()); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); switch (type_class) @@ -1827,7 +1826,7 @@ ClangASTType::GetTypedefedType () const { if (IsValid()) { - const TypedefType *typedef_type = dyn_cast(GetQualType()); + const clang::TypedefType *typedef_type = llvm::dyn_cast(GetQualType()); if (typedef_type) return ClangASTType (m_ast, typedef_type->getDecl()->getUnderlyingType()); } @@ -1839,7 +1838,7 @@ ClangASTType::RemoveFastQualifiers () const { if (m_type) { - QualType qual_type(GetQualType()); + clang::QualType qual_type(GetQualType()); qual_type.getQualifiers().removeFastQualifiers(); return ClangASTType (m_ast, qual_type); } @@ -1867,7 +1866,7 @@ ClangASTType::GetBitSize () const { if (GetCompleteType ()) { - QualType qual_type(GetCanonicalQualType()); + clang::QualType qual_type(GetCanonicalQualType()); const uint32_t bit_size = m_ast->getTypeSize (qual_type); if (bit_size == 0) { @@ -1903,7 +1902,7 @@ ClangASTType::GetEncoding (uint64_t &count) const return lldb::eEncodingInvalid; count = 1; - QualType qual_type(GetCanonicalQualType()); + clang::QualType qual_type(GetCanonicalQualType()); switch (qual_type->getTypeClass()) { @@ -1927,42 +1926,42 @@ ClangASTType::GetEncoding (uint64_t &count) const break; case clang::Type::Builtin: - switch (cast(qual_type)->getKind()) + switch (llvm::cast(qual_type)->getKind()) { default: assert(0 && "Unknown builtin type!"); - case BuiltinType::Void: + case clang::BuiltinType::Void: break; - case BuiltinType::Bool: - case BuiltinType::Char_S: - case BuiltinType::SChar: - case BuiltinType::WChar_S: - case BuiltinType::Char16: - case BuiltinType::Char32: - case BuiltinType::Short: - case BuiltinType::Int: - case BuiltinType::Long: - case BuiltinType::LongLong: - case BuiltinType::Int128: return lldb::eEncodingSint; + case clang::BuiltinType::Bool: + case clang::BuiltinType::Char_S: + case clang::BuiltinType::SChar: + case clang::BuiltinType::WChar_S: + case clang::BuiltinType::Char16: + case clang::BuiltinType::Char32: + case clang::BuiltinType::Short: + case clang::BuiltinType::Int: + case clang::BuiltinType::Long: + case clang::BuiltinType::LongLong: + case clang::BuiltinType::Int128: return lldb::eEncodingSint; - case BuiltinType::Char_U: - case BuiltinType::UChar: - case BuiltinType::WChar_U: - case BuiltinType::UShort: - case BuiltinType::UInt: - case BuiltinType::ULong: - case BuiltinType::ULongLong: - case BuiltinType::UInt128: return lldb::eEncodingUint; + case clang::BuiltinType::Char_U: + case clang::BuiltinType::UChar: + case clang::BuiltinType::WChar_U: + case clang::BuiltinType::UShort: + case clang::BuiltinType::UInt: + case clang::BuiltinType::ULong: + case clang::BuiltinType::ULongLong: + case clang::BuiltinType::UInt128: return lldb::eEncodingUint; - case BuiltinType::Float: - case BuiltinType::Double: - case BuiltinType::LongDouble: return lldb::eEncodingIEEE754; + case clang::BuiltinType::Float: + case clang::BuiltinType::Double: + case clang::BuiltinType::LongDouble: return lldb::eEncodingIEEE754; - case BuiltinType::ObjCClass: - case BuiltinType::ObjCId: - case BuiltinType::ObjCSel: return lldb::eEncodingUint; + case clang::BuiltinType::ObjCClass: + case clang::BuiltinType::ObjCId: + case clang::BuiltinType::ObjCSel: return lldb::eEncodingUint; - case BuiltinType::NullPtr: return lldb::eEncodingUint; + case clang::BuiltinType::NullPtr: return lldb::eEncodingUint; } break; // All pointer types are represented as unsigned integer encodings. @@ -1981,7 +1980,7 @@ ClangASTType::GetEncoding (uint64_t &count) const encoding = lldb::eEncodingIEEE754; else { - const ComplexType *complex_type = qual_type->getAsComplexIntegerType(); + const clang::ComplexType *complex_type = qual_type->getAsComplexIntegerType(); if (complex_type) encoding = ClangASTType(m_ast, complex_type->getElementType()).GetEncoding(count); else @@ -1995,13 +1994,13 @@ ClangASTType::GetEncoding (uint64_t &count) const case clang::Type::Record: break; case clang::Type::Enum: return lldb::eEncodingSint; case clang::Type::Typedef: - return ClangASTType(m_ast, cast(qual_type)->getDecl()->getUnderlyingType()).GetEncoding(count); + return ClangASTType(m_ast, llvm::cast(qual_type)->getDecl()->getUnderlyingType()).GetEncoding(count); case clang::Type::Elaborated: - return ClangASTType(m_ast, cast(qual_type)->getNamedType()).GetEncoding(count); + return ClangASTType(m_ast, llvm::cast(qual_type)->getNamedType()).GetEncoding(count); case clang::Type::Paren: - return ClangASTType(m_ast, cast(qual_type)->desugar()).GetEncoding(count); + return ClangASTType(m_ast, llvm::cast(qual_type)->desugar()).GetEncoding(count); case clang::Type::DependentSizedArray: case clang::Type::DependentSizedExtVector: @@ -2022,6 +2021,7 @@ ClangASTType::GetEncoding (uint64_t &count) const case clang::Type::Decltype: case clang::Type::TemplateSpecialization: case clang::Type::Atomic: + case clang::Type::Adjusted: break; // pointer type decayed from an array or function type. @@ -2038,7 +2038,7 @@ ClangASTType::GetFormat () const if (!IsValid()) return lldb::eFormatDefault; - QualType qual_type(GetCanonicalQualType()); + clang::QualType qual_type(GetCanonicalQualType()); switch (qual_type->getTypeClass()) { @@ -2061,54 +2061,54 @@ ClangASTType::GetFormat () const break; case clang::Type::Builtin: - switch (cast(qual_type)->getKind()) + switch (llvm::cast(qual_type)->getKind()) { //default: assert(0 && "Unknown builtin type!"); - case BuiltinType::UnknownAny: - case BuiltinType::Void: - case BuiltinType::BoundMember: + case clang::BuiltinType::UnknownAny: + case clang::BuiltinType::Void: + case clang::BuiltinType::BoundMember: break; - case BuiltinType::Bool: return lldb::eFormatBoolean; - case BuiltinType::Char_S: - case BuiltinType::SChar: - case BuiltinType::WChar_S: - case BuiltinType::Char_U: - case BuiltinType::UChar: - case BuiltinType::WChar_U: return lldb::eFormatChar; - case BuiltinType::Char16: return lldb::eFormatUnicode16; - case BuiltinType::Char32: return lldb::eFormatUnicode32; - case BuiltinType::UShort: return lldb::eFormatUnsigned; - case BuiltinType::Short: return lldb::eFormatDecimal; - case BuiltinType::UInt: return lldb::eFormatUnsigned; - case BuiltinType::Int: return lldb::eFormatDecimal; - case BuiltinType::ULong: return lldb::eFormatUnsigned; - case BuiltinType::Long: return lldb::eFormatDecimal; - case BuiltinType::ULongLong: return lldb::eFormatUnsigned; - case BuiltinType::LongLong: return lldb::eFormatDecimal; - case BuiltinType::UInt128: return lldb::eFormatUnsigned; - case BuiltinType::Int128: return lldb::eFormatDecimal; - case BuiltinType::Float: return lldb::eFormatFloat; - case BuiltinType::Double: return lldb::eFormatFloat; - case BuiltinType::LongDouble: return lldb::eFormatFloat; - case BuiltinType::NullPtr: - case BuiltinType::Overload: - case BuiltinType::Dependent: - case BuiltinType::ObjCId: - case BuiltinType::ObjCClass: - case BuiltinType::ObjCSel: - case BuiltinType::Half: - case BuiltinType::ARCUnbridgedCast: - case BuiltinType::PseudoObject: - case BuiltinType::BuiltinFn: - case BuiltinType::OCLEvent: - case BuiltinType::OCLImage1d: - case BuiltinType::OCLImage1dArray: - case BuiltinType::OCLImage1dBuffer: - case BuiltinType::OCLImage2d: - case BuiltinType::OCLImage2dArray: - case BuiltinType::OCLImage3d: - case BuiltinType::OCLSampler: + case clang::BuiltinType::Bool: return lldb::eFormatBoolean; + case clang::BuiltinType::Char_S: + case clang::BuiltinType::SChar: + case clang::BuiltinType::WChar_S: + case clang::BuiltinType::Char_U: + case clang::BuiltinType::UChar: + case clang::BuiltinType::WChar_U: return lldb::eFormatChar; + case clang::BuiltinType::Char16: return lldb::eFormatUnicode16; + case clang::BuiltinType::Char32: return lldb::eFormatUnicode32; + case clang::BuiltinType::UShort: return lldb::eFormatUnsigned; + case clang::BuiltinType::Short: return lldb::eFormatDecimal; + case clang::BuiltinType::UInt: return lldb::eFormatUnsigned; + case clang::BuiltinType::Int: return lldb::eFormatDecimal; + case clang::BuiltinType::ULong: return lldb::eFormatUnsigned; + case clang::BuiltinType::Long: return lldb::eFormatDecimal; + case clang::BuiltinType::ULongLong: return lldb::eFormatUnsigned; + case clang::BuiltinType::LongLong: return lldb::eFormatDecimal; + case clang::BuiltinType::UInt128: return lldb::eFormatUnsigned; + case clang::BuiltinType::Int128: return lldb::eFormatDecimal; + case clang::BuiltinType::Float: return lldb::eFormatFloat; + case clang::BuiltinType::Double: return lldb::eFormatFloat; + case clang::BuiltinType::LongDouble: return lldb::eFormatFloat; + case clang::BuiltinType::NullPtr: + case clang::BuiltinType::Overload: + case clang::BuiltinType::Dependent: + case clang::BuiltinType::ObjCId: + case clang::BuiltinType::ObjCClass: + case clang::BuiltinType::ObjCSel: + case clang::BuiltinType::Half: + case clang::BuiltinType::ARCUnbridgedCast: + case clang::BuiltinType::PseudoObject: + case clang::BuiltinType::BuiltinFn: + case clang::BuiltinType::OCLEvent: + case clang::BuiltinType::OCLImage1d: + case clang::BuiltinType::OCLImage1dArray: + case clang::BuiltinType::OCLImage1dBuffer: + case clang::BuiltinType::OCLImage2d: + case clang::BuiltinType::OCLImage2dArray: + case clang::BuiltinType::OCLImage3d: + case clang::BuiltinType::OCLSampler: return lldb::eFormatHex; } break; @@ -2129,13 +2129,13 @@ ClangASTType::GetFormat () const case clang::Type::Record: break; case clang::Type::Enum: return lldb::eFormatEnum; case clang::Type::Typedef: - return ClangASTType (m_ast, cast(qual_type)->getDecl()->getUnderlyingType()).GetFormat(); + return ClangASTType (m_ast, llvm::cast(qual_type)->getDecl()->getUnderlyingType()).GetFormat(); case clang::Type::Auto: - return ClangASTType (m_ast, cast(qual_type)->desugar()).GetFormat(); + return ClangASTType (m_ast, llvm::cast(qual_type)->desugar()).GetFormat(); case clang::Type::Paren: - return ClangASTType (m_ast, cast(qual_type)->desugar()).GetFormat(); + return ClangASTType (m_ast, llvm::cast(qual_type)->desugar()).GetFormat(); case clang::Type::Elaborated: - return ClangASTType (m_ast, cast(qual_type)->getNamedType()).GetFormat(); + return ClangASTType (m_ast, llvm::cast(qual_type)->getNamedType()).GetFormat(); case clang::Type::DependentSizedArray: case clang::Type::DependentSizedExtVector: case clang::Type::UnresolvedUsing: @@ -2154,6 +2154,7 @@ ClangASTType::GetFormat () const case clang::Type::Decltype: case clang::Type::TemplateSpecialization: case clang::Type::Atomic: + case clang::Type::Adjusted: break; // pointer type decayed from an array or function type. @@ -2165,7 +2166,7 @@ ClangASTType::GetFormat () const } static bool -ObjCDeclHasIVars (ObjCInterfaceDecl *class_interface_decl, bool check_superclass) +ObjCDeclHasIVars (clang::ObjCInterfaceDecl *class_interface_decl, bool check_superclass) { while (class_interface_decl) { @@ -2187,15 +2188,15 @@ ClangASTType::GetNumChildren (bool omit_empty_base_classes) const return 0; uint32_t num_children = 0; - QualType qual_type(GetQualType()); + clang::QualType qual_type(GetQualType()); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); switch (type_class) { case clang::Type::Builtin: - switch (cast(qual_type)->getKind()) + switch (llvm::cast(qual_type)->getKind()) { - case BuiltinType::ObjCId: // child is Class - case BuiltinType::ObjCClass: // child is Class + case clang::BuiltinType::ObjCId: // child is Class + case clang::BuiltinType::ObjCClass: // child is Class num_children = 1; break; @@ -2209,10 +2210,10 @@ ClangASTType::GetNumChildren (bool omit_empty_base_classes) const case clang::Type::Record: if (GetCompleteQualType (m_ast, qual_type)) { - const RecordType *record_type = cast(qual_type.getTypePtr()); - const RecordDecl *record_decl = record_type->getDecl(); + const clang::RecordType *record_type = llvm::cast(qual_type.getTypePtr()); + const clang::RecordDecl *record_decl = record_type->getDecl(); assert(record_decl); - const CXXRecordDecl *cxx_record_decl = dyn_cast(record_decl); + const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast(record_decl); if (cxx_record_decl) { if (omit_empty_base_classes) @@ -2221,12 +2222,12 @@ ClangASTType::GetNumChildren (bool omit_empty_base_classes) const // base classes contain any fields. This can help // limit the noise in variable views by not having to // show base classes that contain no members. - CXXRecordDecl::base_class_const_iterator base_class, base_class_end; + clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end; for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); base_class != base_class_end; ++base_class) { - const CXXRecordDecl *base_class_decl = cast(base_class->getType()->getAs()->getDecl()); + const clang::CXXRecordDecl *base_class_decl = llvm::cast(base_class->getType()->getAs()->getDecl()); // Skip empty base classes if (ClangASTContext::RecordHasFields(base_class_decl) == false) @@ -2242,7 +2243,7 @@ ClangASTType::GetNumChildren (bool omit_empty_base_classes) const } } - RecordDecl::field_iterator field, field_end; + clang::RecordDecl::field_iterator field, field_end; for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field) ++num_children; } @@ -2252,16 +2253,16 @@ ClangASTType::GetNumChildren (bool omit_empty_base_classes) const case clang::Type::ObjCInterface: if (GetCompleteQualType (m_ast, qual_type)) { - const ObjCObjectType *objc_class_type = dyn_cast(qual_type.getTypePtr()); + const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast(qual_type.getTypePtr()); assert (objc_class_type); if (objc_class_type) { - ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); + clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); if (class_interface_decl) { - ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); + clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); if (superclass_interface_decl) { if (omit_empty_base_classes) @@ -2281,8 +2282,8 @@ ClangASTType::GetNumChildren (bool omit_empty_base_classes) const case clang::Type::ObjCObjectPointer: { - const ObjCObjectPointerType *pointer_type = cast(qual_type.getTypePtr()); - QualType pointee_type = pointer_type->getPointeeType(); + const clang::ObjCObjectPointerType *pointer_type = llvm::cast(qual_type.getTypePtr()); + clang::QualType pointee_type = pointer_type->getPointeeType(); uint32_t num_pointee_children = ClangASTType (m_ast,pointee_type).GetNumChildren (omit_empty_base_classes); // If this type points to a simple type, then it has 1 child if (num_pointee_children == 0) @@ -2294,17 +2295,17 @@ ClangASTType::GetNumChildren (bool omit_empty_base_classes) const case clang::Type::Vector: case clang::Type::ExtVector: - num_children = cast(qual_type.getTypePtr())->getNumElements(); + num_children = llvm::cast(qual_type.getTypePtr())->getNumElements(); break; case clang::Type::ConstantArray: - num_children = cast(qual_type.getTypePtr())->getSize().getLimitedValue(); + num_children = llvm::cast(qual_type.getTypePtr())->getSize().getLimitedValue(); break; case clang::Type::Pointer: { - const PointerType *pointer_type = cast(qual_type.getTypePtr()); - QualType pointee_type (pointer_type->getPointeeType()); + const clang::PointerType *pointer_type = llvm::cast(qual_type.getTypePtr()); + clang::QualType pointee_type (pointer_type->getPointeeType()); uint32_t num_pointee_children = ClangASTType (m_ast,pointee_type).GetNumChildren (omit_empty_base_classes); if (num_pointee_children == 0) { @@ -2320,8 +2321,8 @@ ClangASTType::GetNumChildren (bool omit_empty_base_classes) const case clang::Type::LValueReference: case clang::Type::RValueReference: { - const ReferenceType *reference_type = cast(qual_type.getTypePtr()); - QualType pointee_type = reference_type->getPointeeType(); + const clang::ReferenceType *reference_type = llvm::cast(qual_type.getTypePtr()); + clang::QualType pointee_type = reference_type->getPointeeType(); uint32_t num_pointee_children = ClangASTType (m_ast, pointee_type).GetNumChildren (omit_empty_base_classes); // If this type points to a simple type, then it has 1 child if (num_pointee_children == 0) @@ -2333,15 +2334,15 @@ ClangASTType::GetNumChildren (bool omit_empty_base_classes) const case clang::Type::Typedef: - num_children = ClangASTType (m_ast, cast(qual_type)->getDecl()->getUnderlyingType()).GetNumChildren (omit_empty_base_classes); + num_children = ClangASTType (m_ast, llvm::cast(qual_type)->getDecl()->getUnderlyingType()).GetNumChildren (omit_empty_base_classes); break; case clang::Type::Elaborated: - num_children = ClangASTType (m_ast, cast(qual_type)->getNamedType()).GetNumChildren (omit_empty_base_classes); + num_children = ClangASTType (m_ast, llvm::cast(qual_type)->getNamedType()).GetNumChildren (omit_empty_base_classes); break; case clang::Type::Paren: - num_children = ClangASTType (m_ast, cast(qual_type)->desugar()).GetNumChildren (omit_empty_base_classes); + num_children = ClangASTType (m_ast, llvm::cast(qual_type)->desugar()).GetNumChildren (omit_empty_base_classes); break; default: break; @@ -2354,11 +2355,11 @@ ClangASTType::GetBasicTypeEnumeration () const { if (IsValid()) { - QualType qual_type(GetQualType()); + clang::QualType qual_type(GetQualType()); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); if (type_class == clang::Type::Builtin) { - switch (cast(qual_type)->getKind()) + switch (llvm::cast(qual_type)->getKind()) { case clang::BuiltinType::Void: return eBasicTypeVoid; case clang::BuiltinType::Bool: return eBasicTypeBool; @@ -2422,14 +2423,14 @@ ClangASTType::GetNumDirectBaseClasses () const return 0; uint32_t count = 0; - QualType qual_type(GetCanonicalQualType()); + clang::QualType qual_type(GetCanonicalQualType()); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); switch (type_class) { case clang::Type::Record: if (GetCompleteType()) { - const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); + const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); if (cxx_record_decl) count = cxx_record_decl->getNumBases(); } @@ -2442,10 +2443,10 @@ ClangASTType::GetNumDirectBaseClasses () const case clang::Type::ObjCObject: if (GetCompleteType()) { - const ObjCObjectType *objc_class_type = qual_type->getAsObjCQualifiedInterfaceType(); + const clang::ObjCObjectType *objc_class_type = qual_type->getAsObjCQualifiedInterfaceType(); if (objc_class_type) { - ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); + clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); if (class_interface_decl && class_interface_decl->getSuperClass()) count = 1; @@ -2455,10 +2456,10 @@ ClangASTType::GetNumDirectBaseClasses () const case clang::Type::ObjCInterface: if (GetCompleteType()) { - const ObjCInterfaceType *objc_interface_type = qual_type->getAs(); + const clang::ObjCInterfaceType *objc_interface_type = qual_type->getAs(); if (objc_interface_type) { - ObjCInterfaceDecl *class_interface_decl = objc_interface_type->getInterface(); + clang::ObjCInterfaceDecl *class_interface_decl = objc_interface_type->getInterface(); if (class_interface_decl && class_interface_decl->getSuperClass()) count = 1; @@ -2468,15 +2469,15 @@ ClangASTType::GetNumDirectBaseClasses () const case clang::Type::Typedef: - count = ClangASTType (m_ast, cast(qual_type)->getDecl()->getUnderlyingType()).GetNumDirectBaseClasses (); + count = ClangASTType (m_ast, llvm::cast(qual_type)->getDecl()->getUnderlyingType()).GetNumDirectBaseClasses (); break; case clang::Type::Elaborated: - count = ClangASTType (m_ast, cast(qual_type)->getNamedType()).GetNumDirectBaseClasses (); + count = ClangASTType (m_ast, llvm::cast(qual_type)->getNamedType()).GetNumDirectBaseClasses (); break; case clang::Type::Paren: - return ClangASTType (m_ast, cast(qual_type)->desugar()).GetNumDirectBaseClasses (); + return ClangASTType (m_ast, llvm::cast(qual_type)->desugar()).GetNumDirectBaseClasses (); default: break; @@ -2491,29 +2492,29 @@ ClangASTType::GetNumVirtualBaseClasses () const return 0; uint32_t count = 0; - QualType qual_type(GetCanonicalQualType()); + clang::QualType qual_type(GetCanonicalQualType()); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); switch (type_class) { case clang::Type::Record: if (GetCompleteType()) { - const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); + const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); if (cxx_record_decl) count = cxx_record_decl->getNumVBases(); } break; case clang::Type::Typedef: - count = ClangASTType (m_ast, cast(qual_type)->getDecl()->getUnderlyingType()).GetNumVirtualBaseClasses(); + count = ClangASTType (m_ast, llvm::cast(qual_type)->getDecl()->getUnderlyingType()).GetNumVirtualBaseClasses(); break; case clang::Type::Elaborated: - count = ClangASTType (m_ast, cast(qual_type)->getNamedType()).GetNumVirtualBaseClasses(); + count = ClangASTType (m_ast, llvm::cast(qual_type)->getNamedType()).GetNumVirtualBaseClasses(); break; case clang::Type::Paren: - count = ClangASTType (m_ast, cast(qual_type)->desugar()).GetNumVirtualBaseClasses(); + count = ClangASTType (m_ast, llvm::cast(qual_type)->desugar()).GetNumVirtualBaseClasses(); break; default: @@ -2529,21 +2530,21 @@ ClangASTType::GetNumFields () const return 0; uint32_t count = 0; - QualType qual_type(GetCanonicalQualType()); + clang::QualType qual_type(GetCanonicalQualType()); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); switch (type_class) { case clang::Type::Record: if (GetCompleteType()) { - const RecordType *record_type = dyn_cast(qual_type.getTypePtr()); + const clang::RecordType *record_type = llvm::dyn_cast(qual_type.getTypePtr()); if (record_type) { - RecordDecl *record_decl = record_type->getDecl(); + clang::RecordDecl *record_decl = record_type->getDecl(); if (record_decl) { uint32_t field_idx = 0; - RecordDecl::field_iterator field, field_end; + clang::RecordDecl::field_iterator field, field_end; for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field) ++field_idx; count = field_idx; @@ -2553,24 +2554,24 @@ ClangASTType::GetNumFields () const break; case clang::Type::Typedef: - count = ClangASTType (m_ast, cast(qual_type)->getDecl()->getUnderlyingType()).GetNumFields(); + count = ClangASTType (m_ast, llvm::cast(qual_type)->getDecl()->getUnderlyingType()).GetNumFields(); break; case clang::Type::Elaborated: - count = ClangASTType (m_ast, cast(qual_type)->getNamedType()).GetNumFields(); + count = ClangASTType (m_ast, llvm::cast(qual_type)->getNamedType()).GetNumFields(); break; case clang::Type::Paren: - count = ClangASTType (m_ast, cast(qual_type)->desugar()).GetNumFields(); + count = ClangASTType (m_ast, llvm::cast(qual_type)->desugar()).GetNumFields(); break; case clang::Type::ObjCObjectPointer: if (GetCompleteType()) { - const ObjCObjectPointerType *objc_class_type = qual_type->getAsObjCInterfacePointerType(); + const clang::ObjCObjectPointerType *objc_class_type = qual_type->getAsObjCInterfacePointerType(); if (objc_class_type) { - ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterfaceDecl(); + clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterfaceDecl(); if (class_interface_decl) count = class_interface_decl->ivar_size(); @@ -2582,10 +2583,10 @@ ClangASTType::GetNumFields () const case clang::Type::ObjCInterface: if (GetCompleteType()) { - const ObjCObjectType *objc_class_type = dyn_cast(qual_type.getTypePtr()); + const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast(qual_type.getTypePtr()); if (objc_class_type) { - ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); + clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); if (class_interface_decl) count = class_interface_decl->ivar_size(); @@ -2605,18 +2606,18 @@ ClangASTType::GetDirectBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr) c if (!IsValid()) return ClangASTType(); - QualType qual_type(GetCanonicalQualType()); + clang::QualType qual_type(GetCanonicalQualType()); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); switch (type_class) { case clang::Type::Record: if (GetCompleteType()) { - const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); + const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); if (cxx_record_decl) { uint32_t curr_idx = 0; - CXXRecordDecl::base_class_const_iterator base_class, base_class_end; + clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end; for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); base_class != base_class_end; ++base_class, ++curr_idx) @@ -2625,8 +2626,8 @@ ClangASTType::GetDirectBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr) c { if (bit_offset_ptr) { - const ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(cxx_record_decl); - const CXXRecordDecl *base_class_decl = cast(base_class->getType()->getAs()->getDecl()); + const clang::ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(cxx_record_decl); + const clang::CXXRecordDecl *base_class_decl = llvm::cast(base_class->getType()->getAs()->getDecl()); if (base_class->isVirtual()) *bit_offset_ptr = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8; else @@ -2645,14 +2646,14 @@ ClangASTType::GetDirectBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr) c case clang::Type::ObjCObject: if (idx == 0 && GetCompleteType()) { - const ObjCObjectType *objc_class_type = qual_type->getAsObjCQualifiedInterfaceType(); + const clang::ObjCObjectType *objc_class_type = qual_type->getAsObjCQualifiedInterfaceType(); if (objc_class_type) { - ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); + clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); if (class_interface_decl) { - ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); + clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); if (superclass_interface_decl) { if (bit_offset_ptr) @@ -2666,14 +2667,14 @@ ClangASTType::GetDirectBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr) c case clang::Type::ObjCInterface: if (idx == 0 && GetCompleteType()) { - const ObjCObjectType *objc_interface_type = qual_type->getAs(); + const clang::ObjCObjectType *objc_interface_type = qual_type->getAs(); if (objc_interface_type) { - ObjCInterfaceDecl *class_interface_decl = objc_interface_type->getInterface(); + clang::ObjCInterfaceDecl *class_interface_decl = objc_interface_type->getInterface(); if (class_interface_decl) { - ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); + clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); if (superclass_interface_decl) { if (bit_offset_ptr) @@ -2687,13 +2688,13 @@ ClangASTType::GetDirectBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr) c case clang::Type::Typedef: - return ClangASTType (m_ast, cast(qual_type)->getDecl()->getUnderlyingType()).GetDirectBaseClassAtIndex (idx, bit_offset_ptr); + return ClangASTType (m_ast, llvm::cast(qual_type)->getDecl()->getUnderlyingType()).GetDirectBaseClassAtIndex (idx, bit_offset_ptr); case clang::Type::Elaborated: - return ClangASTType (m_ast, cast(qual_type)->getNamedType()).GetDirectBaseClassAtIndex (idx, bit_offset_ptr); + return ClangASTType (m_ast, llvm::cast(qual_type)->getNamedType()).GetDirectBaseClassAtIndex (idx, bit_offset_ptr); case clang::Type::Paren: - return ClangASTType (m_ast, cast(qual_type)->desugar()).GetDirectBaseClassAtIndex (idx, bit_offset_ptr); + return ClangASTType (m_ast, llvm::cast(qual_type)->desugar()).GetDirectBaseClassAtIndex (idx, bit_offset_ptr); default: break; @@ -2707,18 +2708,18 @@ ClangASTType::GetVirtualBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr) if (!IsValid()) return ClangASTType(); - QualType qual_type(GetCanonicalQualType()); + clang::QualType qual_type(GetCanonicalQualType()); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); switch (type_class) { case clang::Type::Record: if (GetCompleteType()) { - const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); + const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); if (cxx_record_decl) { uint32_t curr_idx = 0; - CXXRecordDecl::base_class_const_iterator base_class, base_class_end; + clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end; for (base_class = cxx_record_decl->vbases_begin(), base_class_end = cxx_record_decl->vbases_end(); base_class != base_class_end; ++base_class, ++curr_idx) @@ -2727,8 +2728,8 @@ ClangASTType::GetVirtualBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr) { if (bit_offset_ptr) { - const ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(cxx_record_decl); - const CXXRecordDecl *base_class_decl = cast(base_class->getType()->getAs()->getDecl()); + const clang::ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(cxx_record_decl); + const clang::CXXRecordDecl *base_class_decl = llvm::cast(base_class->getType()->getAs()->getDecl()); *bit_offset_ptr = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8; } @@ -2740,13 +2741,13 @@ ClangASTType::GetVirtualBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr) break; case clang::Type::Typedef: - return ClangASTType (m_ast, cast(qual_type)->getDecl()->getUnderlyingType()).GetVirtualBaseClassAtIndex (idx, bit_offset_ptr); + return ClangASTType (m_ast, llvm::cast(qual_type)->getDecl()->getUnderlyingType()).GetVirtualBaseClassAtIndex (idx, bit_offset_ptr); case clang::Type::Elaborated: - return ClangASTType (m_ast, cast(qual_type)->getNamedType()).GetVirtualBaseClassAtIndex (idx, bit_offset_ptr); + return ClangASTType (m_ast, llvm::cast(qual_type)->getNamedType()).GetVirtualBaseClassAtIndex (idx, bit_offset_ptr); case clang::Type::Paren: - return ClangASTType (m_ast, cast(qual_type)->desugar()).GetVirtualBaseClassAtIndex (idx, bit_offset_ptr); + return ClangASTType (m_ast, llvm::cast(qual_type)->desugar()).GetVirtualBaseClassAtIndex (idx, bit_offset_ptr); default: break; @@ -2756,7 +2757,7 @@ ClangASTType::GetVirtualBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr) static clang_type_t GetObjCFieldAtIndex (clang::ASTContext *ast, - ObjCInterfaceDecl *class_interface_decl, + clang::ObjCInterfaceDecl *class_interface_decl, size_t idx, std::string& name, uint64_t *bit_offset_ptr, @@ -2767,22 +2768,22 @@ GetObjCFieldAtIndex (clang::ASTContext *ast, { if (idx < (class_interface_decl->ivar_size())) { - ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end(); + clang::ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end(); uint32_t ivar_idx = 0; for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++ivar_idx) { if (ivar_idx == idx) { - const ObjCIvarDecl* ivar_decl = *ivar_pos; + const clang::ObjCIvarDecl* ivar_decl = *ivar_pos; - QualType ivar_qual_type(ivar_decl->getType()); + clang::QualType ivar_qual_type(ivar_decl->getType()); name.assign(ivar_decl->getNameAsString()); if (bit_offset_ptr) { - const ASTRecordLayout &interface_layout = ast->getASTObjCInterfaceLayout(class_interface_decl); + const clang::ASTRecordLayout &interface_layout = ast->getASTObjCInterfaceLayout(class_interface_decl); *bit_offset_ptr = interface_layout.getFieldOffset (ivar_idx); } @@ -2794,7 +2795,7 @@ GetObjCFieldAtIndex (clang::ASTContext *ast, if (is_bitfield && ast) { - Expr *bitfield_bit_size_expr = ivar_pos->getBitWidth(); + clang::Expr *bitfield_bit_size_expr = ivar_pos->getBitWidth(); llvm::APSInt bitfield_apsint; if (bitfield_bit_size_expr && bitfield_bit_size_expr->EvaluateAsInt(bitfield_apsint, *ast)) { @@ -2823,17 +2824,17 @@ ClangASTType::GetFieldAtIndex (size_t idx, if (!IsValid()) return ClangASTType(); - QualType qual_type(GetCanonicalQualType()); + clang::QualType qual_type(GetCanonicalQualType()); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); switch (type_class) { case clang::Type::Record: if (GetCompleteType()) { - const RecordType *record_type = cast(qual_type.getTypePtr()); - const RecordDecl *record_decl = record_type->getDecl(); + const clang::RecordType *record_type = llvm::cast(qual_type.getTypePtr()); + const clang::RecordDecl *record_decl = record_type->getDecl(); uint32_t field_idx = 0; - RecordDecl::field_iterator field, field_end; + clang::RecordDecl::field_iterator field, field_end; for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx) { if (idx == field_idx) @@ -2846,7 +2847,7 @@ ClangASTType::GetFieldAtIndex (size_t idx, // alignment (field_type_info.second) from the AST context. if (bit_offset_ptr) { - const ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(record_decl); + const clang::ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(record_decl); *bit_offset_ptr = record_layout.getFieldOffset (field_idx); } @@ -2858,7 +2859,7 @@ ClangASTType::GetFieldAtIndex (size_t idx, if (is_bitfield) { - Expr *bitfield_bit_size_expr = field->getBitWidth(); + clang::Expr *bitfield_bit_size_expr = field->getBitWidth(); llvm::APSInt bitfield_apsint; if (bitfield_bit_size_expr && bitfield_bit_size_expr->EvaluateAsInt(bitfield_apsint, *m_ast)) { @@ -2878,10 +2879,10 @@ ClangASTType::GetFieldAtIndex (size_t idx, case clang::Type::ObjCObjectPointer: if (GetCompleteType()) { - const ObjCObjectPointerType *objc_class_type = qual_type->getAsObjCInterfacePointerType(); + const clang::ObjCObjectPointerType *objc_class_type = qual_type->getAsObjCInterfacePointerType(); if (objc_class_type) { - ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterfaceDecl(); + clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterfaceDecl(); return ClangASTType (m_ast, GetObjCFieldAtIndex(m_ast, class_interface_decl, idx, name, bit_offset_ptr, bitfield_bit_size_ptr, is_bitfield_ptr)); } } @@ -2891,11 +2892,11 @@ ClangASTType::GetFieldAtIndex (size_t idx, case clang::Type::ObjCInterface: if (GetCompleteType()) { - const ObjCObjectType *objc_class_type = dyn_cast(qual_type.getTypePtr()); + const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast(qual_type.getTypePtr()); assert (objc_class_type); if (objc_class_type) { - ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); + clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); return ClangASTType (m_ast, GetObjCFieldAtIndex(m_ast, class_interface_decl, idx, name, bit_offset_ptr, bitfield_bit_size_ptr, is_bitfield_ptr)); } } @@ -2903,7 +2904,7 @@ ClangASTType::GetFieldAtIndex (size_t idx, case clang::Type::Typedef: - return ClangASTType (m_ast, cast(qual_type)->getDecl()->getUnderlyingType()). + return ClangASTType (m_ast, llvm::cast(qual_type)->getDecl()->getUnderlyingType()). GetFieldAtIndex (idx, name, bit_offset_ptr, @@ -2911,7 +2912,7 @@ ClangASTType::GetFieldAtIndex (size_t idx, is_bitfield_ptr); case clang::Type::Elaborated: - return ClangASTType (m_ast, cast(qual_type)->getNamedType()). + return ClangASTType (m_ast, llvm::cast(qual_type)->getNamedType()). GetFieldAtIndex (idx, name, bit_offset_ptr, @@ -2919,7 +2920,7 @@ ClangASTType::GetFieldAtIndex (size_t idx, is_bitfield_ptr); case clang::Type::Paren: - return ClangASTType (m_ast, cast(qual_type)->desugar()). + return ClangASTType (m_ast, llvm::cast(qual_type)->desugar()). GetFieldAtIndex (idx, name, bit_offset_ptr, @@ -2965,12 +2966,12 @@ ClangASTType::GetNumPointeeChildren () const if (!IsValid()) return 0; - QualType qual_type(GetCanonicalQualType()); + clang::QualType qual_type(GetCanonicalQualType()); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); switch (type_class) { case clang::Type::Builtin: - switch (cast(qual_type)->getKind()) + switch (llvm::cast(qual_type)->getKind()) { case clang::BuiltinType::UnknownAny: case clang::BuiltinType::Void: @@ -3036,9 +3037,9 @@ ClangASTType::GetNumPointeeChildren () const case clang::Type::FunctionProto: return 0; // When we function pointers, they have no children... case clang::Type::FunctionNoProto: return 0; // When we function pointers, they have no children... case clang::Type::UnresolvedUsing: return 0; - case clang::Type::Paren: return ClangASTType (m_ast, cast(qual_type)->desugar()).GetNumPointeeChildren (); - case clang::Type::Typedef: return ClangASTType (m_ast, cast(qual_type)->getDecl()->getUnderlyingType()).GetNumPointeeChildren (); - case clang::Type::Elaborated: return ClangASTType (m_ast, cast(qual_type)->getNamedType()).GetNumPointeeChildren (); + case clang::Type::Paren: return ClangASTType (m_ast, llvm::cast(qual_type)->desugar()).GetNumPointeeChildren (); + case clang::Type::Typedef: return ClangASTType (m_ast, llvm::cast(qual_type)->getDecl()->getUnderlyingType()).GetNumPointeeChildren (); + case clang::Type::Elaborated: return ClangASTType (m_ast, llvm::cast(qual_type)->getNamedType()).GetNumPointeeChildren (); case clang::Type::TypeOfExpr: return 0; case clang::Type::TypeOf: return 0; case clang::Type::Decltype: return 0; @@ -3078,7 +3079,7 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx, if (!IsValid()) return ClangASTType(); - QualType parent_qual_type(GetCanonicalQualType()); + clang::QualType parent_qual_type(GetCanonicalQualType()); const clang::Type::TypeClass parent_type_class = parent_qual_type->getTypeClass(); child_bitfield_bit_size = 0; child_bitfield_bit_offset = 0; @@ -3091,7 +3092,7 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx, case clang::Type::Builtin: if (idx_is_valid) { - switch (cast(parent_qual_type)->getKind()) + switch (llvm::cast(parent_qual_type)->getKind()) { case clang::BuiltinType::ObjCId: case clang::BuiltinType::ObjCClass: @@ -3108,27 +3109,27 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx, case clang::Type::Record: if (idx_is_valid && GetCompleteType()) { - const RecordType *record_type = cast(parent_qual_type.getTypePtr()); - const RecordDecl *record_decl = record_type->getDecl(); + const clang::RecordType *record_type = llvm::cast(parent_qual_type.getTypePtr()); + const clang::RecordDecl *record_decl = record_type->getDecl(); assert(record_decl); - const ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(record_decl); + const clang::ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(record_decl); uint32_t child_idx = 0; - const CXXRecordDecl *cxx_record_decl = dyn_cast(record_decl); + const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast(record_decl); if (cxx_record_decl) { // We might have base classes to print out first - CXXRecordDecl::base_class_const_iterator base_class, base_class_end; + clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end; for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); base_class != base_class_end; ++base_class) { - const CXXRecordDecl *base_class_decl = nullptr; + const clang::CXXRecordDecl *base_class_decl = nullptr; // Skip empty base classes if (omit_empty_base_classes) { - base_class_decl = cast(base_class->getType()->getAs()->getDecl()); + base_class_decl = llvm::cast(base_class->getType()->getAs()->getDecl()); if (ClangASTContext::RecordHasFields(base_class_decl) == false) continue; } @@ -3136,7 +3137,7 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx, if (idx == child_idx) { if (base_class_decl == nullptr) - base_class_decl = cast(base_class->getType()->getAs()->getDecl()); + base_class_decl = llvm::cast(base_class->getType()->getAs()->getDecl()); if (base_class->isVirtual()) @@ -3163,7 +3164,7 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx, } // Make sure index is in range... uint32_t field_idx = 0; - RecordDecl::field_iterator field, field_end; + clang::RecordDecl::field_iterator field, field_end; for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx, ++child_idx) { if (idx == child_idx) @@ -3194,18 +3195,18 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx, case clang::Type::ObjCInterface: if (idx_is_valid && GetCompleteType()) { - const ObjCObjectType *objc_class_type = dyn_cast(parent_qual_type.getTypePtr()); + const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast(parent_qual_type.getTypePtr()); assert (objc_class_type); if (objc_class_type) { uint32_t child_idx = 0; - ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); + clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); if (class_interface_decl) { - const ASTRecordLayout &interface_layout = m_ast->getASTObjCInterfaceLayout(class_interface_decl); - ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); + const clang::ASTRecordLayout &interface_layout = m_ast->getASTObjCInterfaceLayout(class_interface_decl); + clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); if (superclass_interface_decl) { if (omit_empty_base_classes) @@ -3215,7 +3216,7 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx, { if (idx == 0) { - QualType ivar_qual_type(m_ast->getObjCInterfaceType(superclass_interface_decl)); + clang::QualType ivar_qual_type(m_ast->getObjCInterfaceType(superclass_interface_decl)); child_name.assign(superclass_interface_decl->getNameAsString().c_str()); @@ -3240,15 +3241,15 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx, if (idx < (child_idx + class_interface_decl->ivar_size())) { - ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end(); + clang::ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end(); for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos) { if (child_idx == idx) { - ObjCIvarDecl* ivar_decl = *ivar_pos; + clang::ObjCIvarDecl* ivar_decl = *ivar_pos; - QualType ivar_qual_type(ivar_decl->getType()); + clang::QualType ivar_qual_type(ivar_decl->getType()); child_name.assign(ivar_decl->getNameAsString().c_str()); @@ -3352,7 +3353,7 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx, case clang::Type::ExtVector: if (idx_is_valid) { - const VectorType *array = cast(parent_qual_type.getTypePtr()); + const clang::VectorType *array = llvm::cast(parent_qual_type.getTypePtr()); if (array) { ClangASTType element_type (m_ast, array->getElementType()); @@ -3373,7 +3374,7 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx, case clang::Type::IncompleteArray: if (ignore_array_bounds || idx_is_valid) { - const ArrayType *array = cast(parent_qual_type.getTypePtr()); + const clang::ArrayType *array = llvm::cast(parent_qual_type.getTypePtr()); if (array) { ClangASTType element_type (m_ast, array->getElementType()); @@ -3443,7 +3444,7 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx, case clang::Type::RValueReference: if (idx_is_valid) { - const ReferenceType *reference_type = cast(parent_qual_type.getTypePtr()); + const clang::ReferenceType *reference_type = llvm::cast(parent_qual_type.getTypePtr()); ClangASTType pointee_clang_type (m_ast, reference_type->getPointeeType()); if (transparent_pointers && pointee_clang_type.IsAggregateType ()) { @@ -3484,7 +3485,7 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx, case clang::Type::Typedef: { - ClangASTType typedefed_clang_type (m_ast, cast(parent_qual_type)->getDecl()->getUnderlyingType()); + ClangASTType typedefed_clang_type (m_ast, llvm::cast(parent_qual_type)->getDecl()->getUnderlyingType()); return typedefed_clang_type.GetChildClangTypeAtIndex (exe_ctx, parent_name, idx, @@ -3503,7 +3504,7 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx, case clang::Type::Elaborated: { - ClangASTType elaborated_clang_type (m_ast, cast(parent_qual_type)->getNamedType()); + ClangASTType elaborated_clang_type (m_ast, llvm::cast(parent_qual_type)->getNamedType()); return elaborated_clang_type.GetChildClangTypeAtIndex (exe_ctx, parent_name, idx, @@ -3545,7 +3546,7 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx, } static inline bool -BaseSpecifierIsEmpty (const CXXBaseSpecifier *b) +BaseSpecifierIsEmpty (const clang::CXXBaseSpecifier *b) { return ClangASTContext::RecordHasFields(b->getType()->getAsCXXRecordDecl()) == false; } @@ -3553,22 +3554,22 @@ BaseSpecifierIsEmpty (const CXXBaseSpecifier *b) static uint32_t GetIndexForRecordBase ( - const RecordDecl *record_decl, - const CXXBaseSpecifier *base_spec, + const clang::RecordDecl *record_decl, + const clang::CXXBaseSpecifier *base_spec, bool omit_empty_base_classes ) { uint32_t child_idx = 0; - const CXXRecordDecl *cxx_record_decl = dyn_cast(record_decl); + const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast(record_decl); // const char *super_name = record_decl->getNameAsCString(); - // const char *base_name = base_spec->getType()->getAs()->getDecl()->getNameAsCString(); + // const char *base_name = base_spec->getType()->getAs()->getDecl()->getNameAsCString(); // printf ("GetIndexForRecordChild (%s, %s)\n", super_name, base_name); // if (cxx_record_decl) { - CXXRecordDecl::base_class_const_iterator base_class, base_class_end; + clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end; for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); base_class != base_class_end; ++base_class) @@ -3581,7 +3582,7 @@ GetIndexForRecordBase // printf ("GetIndexForRecordChild (%s, %s) base[%u] = %s\n", super_name, base_name, // child_idx, - // base_class->getType()->getAs()->getDecl()->getNameAsCString()); + // base_class->getType()->getAs()->getDecl()->getNameAsCString()); // // if (base_class == base_spec) @@ -3595,14 +3596,14 @@ GetIndexForRecordBase static uint32_t -GetIndexForRecordChild (const RecordDecl *record_decl, - NamedDecl *canonical_decl, +GetIndexForRecordChild (const clang::RecordDecl *record_decl, + clang::NamedDecl *canonical_decl, bool omit_empty_base_classes) { - uint32_t child_idx = ClangASTContext::GetNumBaseClasses (dyn_cast(record_decl), + uint32_t child_idx = ClangASTContext::GetNumBaseClasses (llvm::dyn_cast(record_decl), omit_empty_base_classes); - RecordDecl::field_iterator field, field_end; + clang::RecordDecl::field_iterator field, field_end; for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++child_idx) @@ -3655,24 +3656,24 @@ ClangASTType::GetIndexOfChildMemberWithName (const char *name, { if (IsValid() && name && name[0]) { - QualType qual_type(GetCanonicalQualType()); + clang::QualType qual_type(GetCanonicalQualType()); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); switch (type_class) { case clang::Type::Record: if (GetCompleteType ()) { - const RecordType *record_type = cast(qual_type.getTypePtr()); - const RecordDecl *record_decl = record_type->getDecl(); + const clang::RecordType *record_type = llvm::cast(qual_type.getTypePtr()); + const clang::RecordDecl *record_decl = record_type->getDecl(); assert(record_decl); uint32_t child_idx = 0; - const CXXRecordDecl *cxx_record_decl = dyn_cast(record_decl); + const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast(record_decl); // Try and find a field that matches NAME - RecordDecl::field_iterator field, field_end; - StringRef name_sref(name); + clang::RecordDecl::field_iterator field, field_end; + llvm::StringRef name_sref(name); for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++child_idx) @@ -3697,27 +3698,27 @@ ClangASTType::GetIndexOfChildMemberWithName (const char *name, if (cxx_record_decl) { - const RecordDecl *parent_record_decl = cxx_record_decl; + const clang::RecordDecl *parent_record_decl = cxx_record_decl; //printf ("parent = %s\n", parent_record_decl->getNameAsCString()); //const Decl *root_cdecl = cxx_record_decl->getCanonicalDecl(); // Didn't find things easily, lets let clang do its thang... - IdentifierInfo & ident_ref = m_ast->Idents.get(name_sref); - DeclarationName decl_name(&ident_ref); + clang::IdentifierInfo & ident_ref = m_ast->Idents.get(name_sref); + clang::DeclarationName decl_name(&ident_ref); - CXXBasePaths paths; - if (cxx_record_decl->lookupInBases(CXXRecordDecl::FindOrdinaryMember, + clang::CXXBasePaths paths; + if (cxx_record_decl->lookupInBases(clang::CXXRecordDecl::FindOrdinaryMember, decl_name.getAsOpaquePtr(), paths)) { - CXXBasePaths::const_paths_iterator path, path_end = paths.end(); + clang::CXXBasePaths::const_paths_iterator path, path_end = paths.end(); for (path = paths.begin(); path != path_end; ++path) { const size_t num_path_elements = path->size(); for (size_t e=0; e(elem.Base->getType()->getAs()->getDecl()); + parent_record_decl = llvm::cast(elem.Base->getType()->getAs()->getDecl()); } } - for (NamedDecl *path_decl : path->Decls) + for (clang::NamedDecl *path_decl : path->Decls) { child_idx = GetIndexForRecordChild (parent_record_decl, path_decl, omit_empty_base_classes); if (child_idx == UINT32_MAX) @@ -3756,22 +3757,22 @@ ClangASTType::GetIndexOfChildMemberWithName (const char *name, case clang::Type::ObjCInterface: if (GetCompleteType ()) { - StringRef name_sref(name); - const ObjCObjectType *objc_class_type = dyn_cast(qual_type.getTypePtr()); + llvm::StringRef name_sref(name); + const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast(qual_type.getTypePtr()); assert (objc_class_type); if (objc_class_type) { uint32_t child_idx = 0; - ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); + clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); if (class_interface_decl) { - ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end(); - ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); + clang::ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end(); + clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++child_idx) { - const ObjCIvarDecl* ivar_decl = *ivar_pos; + const clang::ObjCIvarDecl* ivar_decl = *ivar_pos; if (ivar_decl->getName().equals (name_sref)) { @@ -3813,7 +3814,7 @@ ClangASTType::GetIndexOfChildMemberWithName (const char *name, case clang::Type::ObjCObjectPointer: { - ClangASTType objc_object_clang_type (m_ast, cast(qual_type.getTypePtr())->getPointeeType()); + ClangASTType objc_object_clang_type (m_ast, llvm::cast(qual_type.getTypePtr())->getPointeeType()); return objc_object_clang_type.GetIndexOfChildMemberWithName (name, omit_empty_base_classes, child_indexes); @@ -3823,7 +3824,7 @@ ClangASTType::GetIndexOfChildMemberWithName (const char *name, case clang::Type::ConstantArray: { - // const ConstantArrayType *array = cast(parent_qual_type.getTypePtr()); + // const clang::ConstantArrayType *array = llvm::cast(parent_qual_type.getTypePtr()); // const uint64_t element_count = array->getSize().getLimitedValue(); // // if (idx < element_count) @@ -3844,8 +3845,8 @@ ClangASTType::GetIndexOfChildMemberWithName (const char *name, // case clang::Type::MemberPointerType: // { - // MemberPointerType *mem_ptr_type = cast(qual_type.getTypePtr()); - // QualType pointee_type = mem_ptr_type->getPointeeType(); + // MemberPointerType *mem_ptr_type = llvm::cast(qual_type.getTypePtr()); + // clang::QualType pointee_type = mem_ptr_type->getPointeeType(); // // if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr())) // { @@ -3859,8 +3860,8 @@ ClangASTType::GetIndexOfChildMemberWithName (const char *name, case clang::Type::LValueReference: case clang::Type::RValueReference: { - const ReferenceType *reference_type = cast(qual_type.getTypePtr()); - QualType pointee_type(reference_type->getPointeeType()); + const clang::ReferenceType *reference_type = llvm::cast(qual_type.getTypePtr()); + clang::QualType pointee_type(reference_type->getPointeeType()); ClangASTType pointee_clang_type (m_ast, pointee_type); if (pointee_clang_type.IsAggregateType ()) @@ -3886,17 +3887,17 @@ ClangASTType::GetIndexOfChildMemberWithName (const char *name, break; case clang::Type::Typedef: - return ClangASTType (m_ast, cast(qual_type)->getDecl()->getUnderlyingType()).GetIndexOfChildMemberWithName (name, + return ClangASTType (m_ast, llvm::cast(qual_type)->getDecl()->getUnderlyingType()).GetIndexOfChildMemberWithName (name, omit_empty_base_classes, child_indexes); case clang::Type::Elaborated: - return ClangASTType (m_ast, cast(qual_type)->getNamedType()).GetIndexOfChildMemberWithName (name, + return ClangASTType (m_ast, llvm::cast(qual_type)->getNamedType()).GetIndexOfChildMemberWithName (name, omit_empty_base_classes, child_indexes); case clang::Type::Paren: - return ClangASTType (m_ast, cast(qual_type)->desugar()).GetIndexOfChildMemberWithName (name, + return ClangASTType (m_ast, llvm::cast(qual_type)->desugar()).GetIndexOfChildMemberWithName (name, omit_empty_base_classes, child_indexes); @@ -3917,7 +3918,7 @@ ClangASTType::GetIndexOfChildWithName (const char *name, bool omit_empty_base_cl { if (IsValid() && name && name[0]) { - QualType qual_type(GetCanonicalQualType()); + clang::QualType qual_type(GetCanonicalQualType()); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); @@ -3926,23 +3927,23 @@ ClangASTType::GetIndexOfChildWithName (const char *name, bool omit_empty_base_cl case clang::Type::Record: if (GetCompleteType ()) { - const RecordType *record_type = cast(qual_type.getTypePtr()); - const RecordDecl *record_decl = record_type->getDecl(); + const clang::RecordType *record_type = llvm::cast(qual_type.getTypePtr()); + const clang::RecordDecl *record_decl = record_type->getDecl(); assert(record_decl); uint32_t child_idx = 0; - const CXXRecordDecl *cxx_record_decl = dyn_cast(record_decl); + const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast(record_decl); if (cxx_record_decl) { - CXXRecordDecl::base_class_const_iterator base_class, base_class_end; + clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end; for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); base_class != base_class_end; ++base_class) { // Skip empty base classes - CXXRecordDecl *base_class_decl = cast(base_class->getType()->getAs()->getDecl()); + clang::CXXRecordDecl *base_class_decl = llvm::cast(base_class->getType()->getAs()->getDecl()); if (omit_empty_base_classes && ClangASTContext::RecordHasFields(base_class_decl) == false) continue; @@ -3955,8 +3956,8 @@ ClangASTType::GetIndexOfChildWithName (const char *name, bool omit_empty_base_cl } // Try and find a field that matches NAME - RecordDecl::field_iterator field, field_end; - StringRef name_sref(name); + clang::RecordDecl::field_iterator field, field_end; + llvm::StringRef name_sref(name); for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++child_idx) @@ -3972,22 +3973,22 @@ ClangASTType::GetIndexOfChildWithName (const char *name, bool omit_empty_base_cl case clang::Type::ObjCInterface: if (GetCompleteType()) { - StringRef name_sref(name); - const ObjCObjectType *objc_class_type = dyn_cast(qual_type.getTypePtr()); + llvm::StringRef name_sref(name); + const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast(qual_type.getTypePtr()); assert (objc_class_type); if (objc_class_type) { uint32_t child_idx = 0; - ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); + clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); if (class_interface_decl) { - ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end(); - ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); + clang::ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end(); + clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++child_idx) { - const ObjCIvarDecl* ivar_decl = *ivar_pos; + const clang::ObjCIvarDecl* ivar_decl = *ivar_pos; if (ivar_decl->getName().equals (name_sref)) { @@ -4011,14 +4012,14 @@ ClangASTType::GetIndexOfChildWithName (const char *name, bool omit_empty_base_cl case clang::Type::ObjCObjectPointer: { - ClangASTType pointee_clang_type (m_ast, cast(qual_type.getTypePtr())->getPointeeType()); + ClangASTType pointee_clang_type (m_ast, llvm::cast(qual_type.getTypePtr())->getPointeeType()); return pointee_clang_type.GetIndexOfChildWithName (name, omit_empty_base_classes); } break; case clang::Type::ConstantArray: { - // const ConstantArrayType *array = cast(parent_qual_type.getTypePtr()); + // const clang::ConstantArrayType *array = llvm::cast(parent_qual_type.getTypePtr()); // const uint64_t element_count = array->getSize().getLimitedValue(); // // if (idx < element_count) @@ -4039,8 +4040,8 @@ ClangASTType::GetIndexOfChildWithName (const char *name, bool omit_empty_base_cl // case clang::Type::MemberPointerType: // { - // MemberPointerType *mem_ptr_type = cast(qual_type.getTypePtr()); - // QualType pointee_type = mem_ptr_type->getPointeeType(); + // MemberPointerType *mem_ptr_type = llvm::cast(qual_type.getTypePtr()); + // clang::QualType pointee_type = mem_ptr_type->getPointeeType(); // // if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr())) // { @@ -4054,7 +4055,7 @@ ClangASTType::GetIndexOfChildWithName (const char *name, bool omit_empty_base_cl case clang::Type::LValueReference: case clang::Type::RValueReference: { - const ReferenceType *reference_type = cast(qual_type.getTypePtr()); + const clang::ReferenceType *reference_type = llvm::cast(qual_type.getTypePtr()); ClangASTType pointee_type (m_ast, reference_type->getPointeeType()); if (pointee_type.IsAggregateType ()) @@ -4066,7 +4067,7 @@ ClangASTType::GetIndexOfChildWithName (const char *name, bool omit_empty_base_cl case clang::Type::Pointer: { - const PointerType *pointer_type = cast(qual_type.getTypePtr()); + const clang::PointerType *pointer_type = llvm::cast(qual_type.getTypePtr()); ClangASTType pointee_type (m_ast, pointer_type->getPointeeType()); if (pointee_type.IsAggregateType ()) @@ -4095,13 +4096,13 @@ ClangASTType::GetIndexOfChildWithName (const char *name, bool omit_empty_base_cl break; case clang::Type::Elaborated: - return ClangASTType (m_ast, cast(qual_type)->getNamedType()).GetIndexOfChildWithName (name, omit_empty_base_classes); + return ClangASTType (m_ast, llvm::cast(qual_type)->getNamedType()).GetIndexOfChildWithName (name, omit_empty_base_classes); case clang::Type::Paren: - return ClangASTType (m_ast, cast(qual_type)->desugar()).GetIndexOfChildWithName (name, omit_empty_base_classes); + return ClangASTType (m_ast, llvm::cast(qual_type)->desugar()).GetIndexOfChildWithName (name, omit_empty_base_classes); case clang::Type::Typedef: - return ClangASTType (m_ast, cast(qual_type)->getDecl()->getUnderlyingType()).GetIndexOfChildWithName (name, omit_empty_base_classes); + return ClangASTType (m_ast, llvm::cast(qual_type)->getDecl()->getUnderlyingType()).GetIndexOfChildWithName (name, omit_empty_base_classes); default: break; @@ -4116,7 +4117,7 @@ ClangASTType::GetNumTemplateArguments () const { if (IsValid()) { - QualType qual_type (GetCanonicalQualType()); + clang::QualType qual_type (GetCanonicalQualType()); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); switch (type_class) @@ -4124,10 +4125,10 @@ ClangASTType::GetNumTemplateArguments () const case clang::Type::Record: if (GetCompleteType ()) { - const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); + const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); if (cxx_record_decl) { - const ClassTemplateSpecializationDecl *template_decl = dyn_cast(cxx_record_decl); + const clang::ClassTemplateSpecializationDecl *template_decl = llvm::dyn_cast(cxx_record_decl); if (template_decl) return template_decl->getTemplateArgs().size(); } @@ -4135,13 +4136,13 @@ ClangASTType::GetNumTemplateArguments () const break; case clang::Type::Typedef: - return ClangASTType (m_ast, cast(qual_type)->getDecl()->getUnderlyingType()).GetNumTemplateArguments(); + return ClangASTType (m_ast, llvm::cast(qual_type)->getDecl()->getUnderlyingType()).GetNumTemplateArguments(); case clang::Type::Elaborated: - return ClangASTType (m_ast, cast(qual_type)->getNamedType()).GetNumTemplateArguments(); + return ClangASTType (m_ast, llvm::cast(qual_type)->getNamedType()).GetNumTemplateArguments(); case clang::Type::Paren: - return ClangASTType (m_ast, cast(qual_type)->desugar()).GetNumTemplateArguments(); + return ClangASTType (m_ast, llvm::cast(qual_type)->desugar()).GetNumTemplateArguments(); default: break; @@ -4155,7 +4156,7 @@ ClangASTType::GetTemplateArgument (size_t arg_idx, lldb::TemplateArgumentKind &k { if (IsValid()) { - QualType qual_type (GetCanonicalQualType()); + clang::QualType qual_type (GetCanonicalQualType()); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); switch (type_class) @@ -4163,13 +4164,13 @@ ClangASTType::GetTemplateArgument (size_t arg_idx, lldb::TemplateArgumentKind &k case clang::Type::Record: if (GetCompleteType ()) { - const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); + const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); if (cxx_record_decl) { - const ClassTemplateSpecializationDecl *template_decl = dyn_cast(cxx_record_decl); + const clang::ClassTemplateSpecializationDecl *template_decl = llvm::dyn_cast(cxx_record_decl); if (template_decl && arg_idx < template_decl->getTemplateArgs().size()) { - const TemplateArgument &template_arg = template_decl->getTemplateArgs()[arg_idx]; + const clang::TemplateArgument &template_arg = template_decl->getTemplateArgs()[arg_idx]; switch (template_arg.getKind()) { case clang::TemplateArgument::Null: @@ -4205,7 +4206,7 @@ ClangASTType::GetTemplateArgument (size_t arg_idx, lldb::TemplateArgumentKind &k return ClangASTType(); default: - assert (!"Unhandled TemplateArgument::ArgKind"); + assert (!"Unhandled clang::TemplateArgument::ArgKind"); break; } } @@ -4214,13 +4215,13 @@ ClangASTType::GetTemplateArgument (size_t arg_idx, lldb::TemplateArgumentKind &k break; case clang::Type::Typedef: - return ClangASTType (m_ast, cast(qual_type)->getDecl()->getUnderlyingType()).GetTemplateArgument (arg_idx, kind); + return ClangASTType (m_ast, llvm::cast(qual_type)->getDecl()->getUnderlyingType()).GetTemplateArgument (arg_idx, kind); case clang::Type::Elaborated: - return ClangASTType (m_ast, cast(qual_type)->getNamedType()).GetTemplateArgument (arg_idx, kind); + return ClangASTType (m_ast, llvm::cast(qual_type)->getNamedType()).GetTemplateArgument (arg_idx, kind); case clang::Type::Paren: - return ClangASTType (m_ast, cast(qual_type)->desugar()).GetTemplateArgument (arg_idx, kind); + return ClangASTType (m_ast, llvm::cast(qual_type)->desugar()).GetTemplateArgument (arg_idx, kind); default: break; @@ -4231,7 +4232,7 @@ ClangASTType::GetTemplateArgument (size_t arg_idx, lldb::TemplateArgumentKind &k } static bool -IsOperator (const char *name, OverloadedOperatorKind &op_kind) +IsOperator (const char *name, clang::OverloadedOperatorKind &op_kind) { if (name == nullptr || name[0] == '\0') return false; @@ -4259,7 +4260,7 @@ IsOperator (const char *name, OverloadedOperatorKind &op_kind) // This is an operator, set the overloaded operator kind to invalid // in case this is a conversion operator... - op_kind = NUM_OVERLOADED_OPERATORS; + op_kind = clang::NUM_OVERLOADED_OPERATORS; switch (post_op_name[0]) { @@ -4271,175 +4272,175 @@ IsOperator (const char *name, OverloadedOperatorKind &op_kind) if (no_space) return false; if (strcmp (post_op_name, "new") == 0) - op_kind = OO_New; + op_kind = clang::OO_New; else if (strcmp (post_op_name, "new[]") == 0) - op_kind = OO_Array_New; + op_kind = clang::OO_Array_New; break; case 'd': if (no_space) return false; if (strcmp (post_op_name, "delete") == 0) - op_kind = OO_Delete; + op_kind = clang::OO_Delete; else if (strcmp (post_op_name, "delete[]") == 0) - op_kind = OO_Array_Delete; + op_kind = clang::OO_Array_Delete; break; case '+': if (post_op_name[1] == '\0') - op_kind = OO_Plus; + op_kind = clang::OO_Plus; else if (post_op_name[2] == '\0') { if (post_op_name[1] == '=') - op_kind = OO_PlusEqual; + op_kind = clang::OO_PlusEqual; else if (post_op_name[1] == '+') - op_kind = OO_PlusPlus; + op_kind = clang::OO_PlusPlus; } break; case '-': if (post_op_name[1] == '\0') - op_kind = OO_Minus; + op_kind = clang::OO_Minus; else if (post_op_name[2] == '\0') { switch (post_op_name[1]) { - case '=': op_kind = OO_MinusEqual; break; - case '-': op_kind = OO_MinusMinus; break; - case '>': op_kind = OO_Arrow; break; + case '=': op_kind = clang::OO_MinusEqual; break; + case '-': op_kind = clang::OO_MinusMinus; break; + case '>': op_kind = clang::OO_Arrow; break; } } else if (post_op_name[3] == '\0') { if (post_op_name[2] == '*') - op_kind = OO_ArrowStar; break; + op_kind = clang::OO_ArrowStar; break; } break; case '*': if (post_op_name[1] == '\0') - op_kind = OO_Star; + op_kind = clang::OO_Star; else if (post_op_name[1] == '=' && post_op_name[2] == '\0') - op_kind = OO_StarEqual; + op_kind = clang::OO_StarEqual; break; case '/': if (post_op_name[1] == '\0') - op_kind = OO_Slash; + op_kind = clang::OO_Slash; else if (post_op_name[1] == '=' && post_op_name[2] == '\0') - op_kind = OO_SlashEqual; + op_kind = clang::OO_SlashEqual; break; case '%': if (post_op_name[1] == '\0') - op_kind = OO_Percent; + op_kind = clang::OO_Percent; else if (post_op_name[1] == '=' && post_op_name[2] == '\0') - op_kind = OO_PercentEqual; + op_kind = clang::OO_PercentEqual; break; case '^': if (post_op_name[1] == '\0') - op_kind = OO_Caret; + op_kind = clang::OO_Caret; else if (post_op_name[1] == '=' && post_op_name[2] == '\0') - op_kind = OO_CaretEqual; + op_kind = clang::OO_CaretEqual; break; case '&': if (post_op_name[1] == '\0') - op_kind = OO_Amp; + op_kind = clang::OO_Amp; else if (post_op_name[2] == '\0') { switch (post_op_name[1]) { - case '=': op_kind = OO_AmpEqual; break; - case '&': op_kind = OO_AmpAmp; break; + case '=': op_kind = clang::OO_AmpEqual; break; + case '&': op_kind = clang::OO_AmpAmp; break; } } break; case '|': if (post_op_name[1] == '\0') - op_kind = OO_Pipe; + op_kind = clang::OO_Pipe; else if (post_op_name[2] == '\0') { switch (post_op_name[1]) { - case '=': op_kind = OO_PipeEqual; break; - case '|': op_kind = OO_PipePipe; break; + case '=': op_kind = clang::OO_PipeEqual; break; + case '|': op_kind = clang::OO_PipePipe; break; } } break; case '~': if (post_op_name[1] == '\0') - op_kind = OO_Tilde; + op_kind = clang::OO_Tilde; break; case '!': if (post_op_name[1] == '\0') - op_kind = OO_Exclaim; + op_kind = clang::OO_Exclaim; else if (post_op_name[1] == '=' && post_op_name[2] == '\0') - op_kind = OO_ExclaimEqual; + op_kind = clang::OO_ExclaimEqual; break; case '=': if (post_op_name[1] == '\0') - op_kind = OO_Equal; + op_kind = clang::OO_Equal; else if (post_op_name[1] == '=' && post_op_name[2] == '\0') - op_kind = OO_EqualEqual; + op_kind = clang::OO_EqualEqual; break; case '<': if (post_op_name[1] == '\0') - op_kind = OO_Less; + op_kind = clang::OO_Less; else if (post_op_name[2] == '\0') { switch (post_op_name[1]) { - case '<': op_kind = OO_LessLess; break; - case '=': op_kind = OO_LessEqual; break; + case '<': op_kind = clang::OO_LessLess; break; + case '=': op_kind = clang::OO_LessEqual; break; } } else if (post_op_name[3] == '\0') { if (post_op_name[2] == '=') - op_kind = OO_LessLessEqual; + op_kind = clang::OO_LessLessEqual; } break; case '>': if (post_op_name[1] == '\0') - op_kind = OO_Greater; + op_kind = clang::OO_Greater; else if (post_op_name[2] == '\0') { switch (post_op_name[1]) { - case '>': op_kind = OO_GreaterGreater; break; - case '=': op_kind = OO_GreaterEqual; break; + case '>': op_kind = clang::OO_GreaterGreater; break; + case '=': op_kind = clang::OO_GreaterEqual; break; } } else if (post_op_name[1] == '>' && post_op_name[2] == '=' && post_op_name[3] == '\0') { - op_kind = OO_GreaterGreaterEqual; + op_kind = clang::OO_GreaterGreaterEqual; } break; case ',': if (post_op_name[1] == '\0') - op_kind = OO_Comma; + op_kind = clang::OO_Comma; break; case '(': if (post_op_name[1] == ')' && post_op_name[2] == '\0') - op_kind = OO_Call; + op_kind = clang::OO_Call; break; case '[': if (post_op_name[1] == ']' && post_op_name[2] == '\0') - op_kind = OO_Subscript; + op_kind = clang::OO_Subscript; break; } @@ -4449,7 +4450,7 @@ IsOperator (const char *name, OverloadedOperatorKind &op_kind) clang::RecordDecl * ClangASTType::GetAsRecordDecl () const { - const RecordType *record_type = dyn_cast(GetCanonicalQualType()); + const clang::RecordType *record_type = llvm::dyn_cast(GetCanonicalQualType()); if (record_type) return record_type->getDecl(); return nullptr; @@ -4461,10 +4462,10 @@ ClangASTType::GetAsCXXRecordDecl () const return GetCanonicalQualType()->getAsCXXRecordDecl(); } -ObjCInterfaceDecl * +clang::ObjCInterfaceDecl * ClangASTType::GetAsObjCInterfaceDecl () const { - const ObjCObjectType *objc_class_type = dyn_cast(GetCanonicalQualType()); + const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast(GetCanonicalQualType()); if (objc_class_type) return objc_class_type->getInterface(); return nullptr; @@ -4479,35 +4480,35 @@ ClangASTType::AddFieldToRecordType (const char *name, if (!IsValid() || !field_clang_type.IsValid()) return nullptr; - FieldDecl *field = nullptr; + clang::FieldDecl *field = nullptr; clang::Expr *bit_width = nullptr; if (bitfield_bit_size != 0) { - APInt bitfield_bit_size_apint(m_ast->getTypeSize(m_ast->IntTy), bitfield_bit_size); - bit_width = new (*m_ast)IntegerLiteral (*m_ast, bitfield_bit_size_apint, m_ast->IntTy, SourceLocation()); + llvm::APInt bitfield_bit_size_apint(m_ast->getTypeSize(m_ast->IntTy), bitfield_bit_size); + bit_width = new (*m_ast)clang::IntegerLiteral (*m_ast, bitfield_bit_size_apint, m_ast->IntTy, clang::SourceLocation()); } - RecordDecl *record_decl = GetAsRecordDecl (); + clang::RecordDecl *record_decl = GetAsRecordDecl (); if (record_decl) { - field = FieldDecl::Create (*m_ast, - record_decl, - SourceLocation(), - SourceLocation(), - name ? &m_ast->Idents.get(name) : nullptr, // Identifier - field_clang_type.GetQualType(), // Field type - nullptr, // TInfo * - bit_width, // BitWidth - false, // Mutable - ICIS_NoInit); // HasInit + field = clang::FieldDecl::Create (*m_ast, + record_decl, + clang::SourceLocation(), + clang::SourceLocation(), + name ? &m_ast->Idents.get(name) : nullptr, // Identifier + field_clang_type.GetQualType(), // Field type + nullptr, // TInfo * + bit_width, // BitWidth + false, // Mutable + clang::ICIS_NoInit); // HasInit if (!name) { // Determine whether this field corresponds to an anonymous // struct or union. - if (const TagType *TagT = field->getType()->getAs()) { - if (RecordDecl *Rec = dyn_cast(TagT->getDecl())) + if (const clang::TagType *TagT = field->getType()->getAs()) { + if (clang::RecordDecl *Rec = llvm::dyn_cast(TagT->getDecl())) if (!Rec->getDeclName()) { Rec->setAnonymousStructOrUnion(true); field->setImplicit(); @@ -4529,7 +4530,7 @@ ClangASTType::AddFieldToRecordType (const char *name, } else { - ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl (); + clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl (); if (class_interface_decl) { @@ -4537,10 +4538,10 @@ ClangASTType::AddFieldToRecordType (const char *name, field_clang_type.GetCompleteType(); - field = ObjCIvarDecl::Create (*m_ast, + field = clang::ObjCIvarDecl::Create (*m_ast, class_interface_decl, - SourceLocation(), - SourceLocation(), + clang::SourceLocation(), + clang::SourceLocation(), name ? &m_ast->Idents.get(name) : nullptr, // Identifier field_clang_type.GetQualType(), // Field type nullptr, // TypeSourceInfo * @@ -4564,49 +4565,49 @@ ClangASTType::AddFieldToRecordType (const char *name, void ClangASTType::BuildIndirectFields () { - RecordDecl *record_decl = GetAsRecordDecl(); + clang::RecordDecl *record_decl = GetAsRecordDecl(); if (!record_decl) return; - typedef llvm::SmallVector IndirectFieldVector; + typedef llvm::SmallVector IndirectFieldVector; IndirectFieldVector indirect_fields; - RecordDecl::field_iterator field_pos; - RecordDecl::field_iterator field_end_pos = record_decl->field_end(); - RecordDecl::field_iterator last_field_pos = field_end_pos; + clang::RecordDecl::field_iterator field_pos; + clang::RecordDecl::field_iterator field_end_pos = record_decl->field_end(); + clang::RecordDecl::field_iterator last_field_pos = field_end_pos; for (field_pos = record_decl->field_begin(); field_pos != field_end_pos; last_field_pos = field_pos++) { if (field_pos->isAnonymousStructOrUnion()) { - QualType field_qual_type = field_pos->getType(); + clang::QualType field_qual_type = field_pos->getType(); - const RecordType *field_record_type = field_qual_type->getAs(); + const clang::RecordType *field_record_type = field_qual_type->getAs(); if (!field_record_type) continue; - RecordDecl *field_record_decl = field_record_type->getDecl(); + clang::RecordDecl *field_record_decl = field_record_type->getDecl(); if (!field_record_decl) continue; - for (RecordDecl::decl_iterator di = field_record_decl->decls_begin(), de = field_record_decl->decls_end(); + for (clang::RecordDecl::decl_iterator di = field_record_decl->decls_begin(), de = field_record_decl->decls_end(); di != de; ++di) { - if (FieldDecl *nested_field_decl = dyn_cast(*di)) + if (clang::FieldDecl *nested_field_decl = llvm::dyn_cast(*di)) { - NamedDecl **chain = new (*m_ast) NamedDecl*[2]; + clang::NamedDecl **chain = new (*m_ast) clang::NamedDecl*[2]; chain[0] = *field_pos; chain[1] = nested_field_decl; - IndirectFieldDecl *indirect_field = IndirectFieldDecl::Create(*m_ast, - record_decl, - SourceLocation(), - nested_field_decl->getIdentifier(), - nested_field_decl->getType(), - chain, - 2); + clang::IndirectFieldDecl *indirect_field = clang::IndirectFieldDecl::Create(*m_ast, + record_decl, + clang::SourceLocation(), + nested_field_decl->getIdentifier(), + nested_field_decl->getType(), + chain, + 2); indirect_field->setImplicit(); @@ -4615,14 +4616,14 @@ ClangASTType::BuildIndirectFields () indirect_fields.push_back(indirect_field); } - else if (IndirectFieldDecl *nested_indirect_field_decl = dyn_cast(*di)) + else if (clang::IndirectFieldDecl *nested_indirect_field_decl = llvm::dyn_cast(*di)) { int nested_chain_size = nested_indirect_field_decl->getChainingSize(); - NamedDecl **chain = new (*m_ast) NamedDecl*[nested_chain_size + 1]; + clang::NamedDecl **chain = new (*m_ast) clang::NamedDecl*[nested_chain_size + 1]; chain[0] = *field_pos; int chain_index = 1; - for (IndirectFieldDecl::chain_iterator nci = nested_indirect_field_decl->chain_begin(), + for (clang::IndirectFieldDecl::chain_iterator nci = nested_indirect_field_decl->chain_begin(), nce = nested_indirect_field_decl->chain_end(); nci < nce; ++nci) @@ -4631,13 +4632,13 @@ ClangASTType::BuildIndirectFields () chain_index++; } - IndirectFieldDecl *indirect_field = IndirectFieldDecl::Create(*m_ast, - record_decl, - SourceLocation(), - nested_indirect_field_decl->getIdentifier(), - nested_indirect_field_decl->getType(), - chain, - nested_chain_size + 1); + clang::IndirectFieldDecl *indirect_field = clang::IndirectFieldDecl::Create(*m_ast, + record_decl, + clang::SourceLocation(), + nested_indirect_field_decl->getIdentifier(), + nested_indirect_field_decl->getType(), + chain, + nested_chain_size + 1); indirect_field->setImplicit(); @@ -4676,17 +4677,17 @@ ClangASTType::AddVariableToRecordType (const char *name, if (!IsValid() || !var_type.IsValid()) return nullptr; - RecordDecl *record_decl = GetAsRecordDecl (); + clang::RecordDecl *record_decl = GetAsRecordDecl (); if (record_decl) { - var_decl = VarDecl::Create (*m_ast, // ASTContext & - record_decl, // DeclContext * - SourceLocation(), // SourceLocation StartLoc - SourceLocation(), // SourceLocation IdLoc - name ? &m_ast->Idents.get(name) : nullptr, // IdentifierInfo * - var_type.GetQualType(), // Variable QualType - nullptr, // TypeSourceInfo * - SC_Static); // StorageClass + var_decl = clang::VarDecl::Create (*m_ast, // ASTContext & + record_decl, // DeclContext * + clang::SourceLocation(), // clang::SourceLocation StartLoc + clang::SourceLocation(), // clang::SourceLocation IdLoc + name ? &m_ast->Idents.get(name) : nullptr, // clang::IdentifierInfo * + var_type.GetQualType(), // Variable clang::QualType + nullptr, // TypeSourceInfo * + clang::SC_Static); // StorageClass if (var_decl) { var_decl->setAccess(ClangASTContext::ConvertAccessTypeToAccessSpecifier (access)); @@ -4701,7 +4702,7 @@ ClangASTType::AddVariableToRecordType (const char *name, } -CXXMethodDecl * +clang::CXXMethodDecl * ClangASTType::AddMethodToCXXRecordType (const char *name, const ClangASTType &method_clang_type, lldb::AccessType access, @@ -4715,71 +4716,71 @@ ClangASTType::AddMethodToCXXRecordType (const char *name, if (!IsValid() || !method_clang_type.IsValid() || name == nullptr || name[0] == '\0') return nullptr; - QualType record_qual_type(GetCanonicalQualType()); + clang::QualType record_qual_type(GetCanonicalQualType()); - CXXRecordDecl *cxx_record_decl = record_qual_type->getAsCXXRecordDecl(); + clang::CXXRecordDecl *cxx_record_decl = record_qual_type->getAsCXXRecordDecl(); if (cxx_record_decl == nullptr) return nullptr; - QualType method_qual_type (method_clang_type.GetQualType()); + clang::QualType method_qual_type (method_clang_type.GetQualType()); - CXXMethodDecl *cxx_method_decl = nullptr; + clang::CXXMethodDecl *cxx_method_decl = nullptr; - DeclarationName decl_name (&m_ast->Idents.get(name)); + clang::DeclarationName decl_name (&m_ast->Idents.get(name)); - const clang::FunctionType *function_type = dyn_cast(method_qual_type.getTypePtr()); + const clang::FunctionType *function_type = llvm::dyn_cast(method_qual_type.getTypePtr()); if (function_type == nullptr) return nullptr; - const FunctionProtoType *method_function_prototype (dyn_cast(function_type)); + const clang::FunctionProtoType *method_function_prototype (llvm::dyn_cast(function_type)); if (!method_function_prototype) return nullptr; unsigned int num_params = method_function_prototype->getNumParams(); - CXXDestructorDecl *cxx_dtor_decl(nullptr); - CXXConstructorDecl *cxx_ctor_decl(nullptr); + clang::CXXDestructorDecl *cxx_dtor_decl(nullptr); + clang::CXXConstructorDecl *cxx_ctor_decl(nullptr); if (is_artificial) return nullptr; // skip everything artificial if (name[0] == '~') { - cxx_dtor_decl = CXXDestructorDecl::Create (*m_ast, - cxx_record_decl, - SourceLocation(), - DeclarationNameInfo (m_ast->DeclarationNames.getCXXDestructorName (m_ast->getCanonicalType (record_qual_type)), SourceLocation()), - method_qual_type, - nullptr, - is_inline, - is_artificial); + cxx_dtor_decl = clang::CXXDestructorDecl::Create (*m_ast, + cxx_record_decl, + clang::SourceLocation(), + clang::DeclarationNameInfo (m_ast->DeclarationNames.getCXXDestructorName (m_ast->getCanonicalType (record_qual_type)), clang::SourceLocation()), + method_qual_type, + nullptr, + is_inline, + is_artificial); cxx_method_decl = cxx_dtor_decl; } else if (decl_name == cxx_record_decl->getDeclName()) { - cxx_ctor_decl = CXXConstructorDecl::Create (*m_ast, - cxx_record_decl, - SourceLocation(), - DeclarationNameInfo (m_ast->DeclarationNames.getCXXConstructorName (m_ast->getCanonicalType (record_qual_type)), SourceLocation()), - method_qual_type, - nullptr, // TypeSourceInfo * - is_explicit, - is_inline, - is_artificial, - false /*is_constexpr*/); + cxx_ctor_decl = clang::CXXConstructorDecl::Create (*m_ast, + cxx_record_decl, + clang::SourceLocation(), + clang::DeclarationNameInfo (m_ast->DeclarationNames.getCXXConstructorName (m_ast->getCanonicalType (record_qual_type)), clang::SourceLocation()), + method_qual_type, + nullptr, // TypeSourceInfo * + is_explicit, + is_inline, + is_artificial, + false /*is_constexpr*/); cxx_method_decl = cxx_ctor_decl; } else { - clang::StorageClass SC = is_static ? SC_Static : SC_None; - OverloadedOperatorKind op_kind = NUM_OVERLOADED_OPERATORS; + clang::StorageClass SC = is_static ? clang::SC_Static : clang::SC_None; + clang::OverloadedOperatorKind op_kind = clang::NUM_OVERLOADED_OPERATORS; if (IsOperator (name, op_kind)) { - if (op_kind != NUM_OVERLOADED_OPERATORS) + if (op_kind != clang::NUM_OVERLOADED_OPERATORS) { // Check the number of operator parameters. Sometimes we have // seen bad DWARF that doesn't correctly describe operators and @@ -4788,49 +4789,49 @@ ClangASTType::AddMethodToCXXRecordType (const char *name, // acceptable. if (!ClangASTContext::CheckOverloadedOperatorKindParameterCount (op_kind, num_params)) return nullptr; - cxx_method_decl = CXXMethodDecl::Create (*m_ast, - cxx_record_decl, - SourceLocation(), - DeclarationNameInfo (m_ast->DeclarationNames.getCXXOperatorName (op_kind), SourceLocation()), - method_qual_type, - nullptr, // TypeSourceInfo * - SC, - is_inline, - false /*is_constexpr*/, - SourceLocation()); + cxx_method_decl = clang::CXXMethodDecl::Create (*m_ast, + cxx_record_decl, + clang::SourceLocation(), + clang::DeclarationNameInfo (m_ast->DeclarationNames.getCXXOperatorName (op_kind), clang::SourceLocation()), + method_qual_type, + nullptr, // TypeSourceInfo * + SC, + is_inline, + false /*is_constexpr*/, + clang::SourceLocation()); } else if (num_params == 0) { // Conversion operators don't take params... - cxx_method_decl = CXXConversionDecl::Create (*m_ast, - cxx_record_decl, - SourceLocation(), - DeclarationNameInfo (m_ast->DeclarationNames.getCXXConversionFunctionName (m_ast->getCanonicalType (function_type->getReturnType())), SourceLocation()), - method_qual_type, - nullptr, // TypeSourceInfo * - is_inline, - is_explicit, - false /*is_constexpr*/, - SourceLocation()); + cxx_method_decl = clang::CXXConversionDecl::Create (*m_ast, + cxx_record_decl, + clang::SourceLocation(), + clang::DeclarationNameInfo (m_ast->DeclarationNames.getCXXConversionFunctionName (m_ast->getCanonicalType (function_type->getReturnType())), clang::SourceLocation()), + method_qual_type, + nullptr, // TypeSourceInfo * + is_inline, + is_explicit, + false /*is_constexpr*/, + clang::SourceLocation()); } } if (cxx_method_decl == nullptr) { - cxx_method_decl = CXXMethodDecl::Create (*m_ast, - cxx_record_decl, - SourceLocation(), - DeclarationNameInfo (decl_name, SourceLocation()), - method_qual_type, - nullptr, // TypeSourceInfo * - SC, - is_inline, - false /*is_constexpr*/, - SourceLocation()); + cxx_method_decl = clang::CXXMethodDecl::Create (*m_ast, + cxx_record_decl, + clang::SourceLocation(), + clang::DeclarationNameInfo (decl_name, clang::SourceLocation()), + method_qual_type, + nullptr, // TypeSourceInfo * + SC, + is_inline, + false /*is_constexpr*/, + clang::SourceLocation()); } } - AccessSpecifier access_specifier = ClangASTContext::ConvertAccessTypeToAccessSpecifier (access); + clang::AccessSpecifier access_specifier = ClangASTContext::ConvertAccessTypeToAccessSpecifier (access); cxx_method_decl->setAccess (access_specifier); cxx_method_decl->setVirtualAsWritten (is_virtual); @@ -4840,24 +4841,24 @@ ClangASTType::AddMethodToCXXRecordType (const char *name, // Populate the method decl with parameter decls - llvm::SmallVector params; + llvm::SmallVector params; for (unsigned param_index = 0; param_index < num_params; ++param_index) { - params.push_back (ParmVarDecl::Create (*m_ast, - cxx_method_decl, - SourceLocation(), - SourceLocation(), - nullptr, // anonymous - method_function_prototype->getParamType(param_index), - nullptr, - SC_None, - nullptr)); + params.push_back (clang::ParmVarDecl::Create (*m_ast, + cxx_method_decl, + clang::SourceLocation(), + clang::SourceLocation(), + nullptr, // anonymous + method_function_prototype->getParamType(param_index), + nullptr, + clang::SC_None, + nullptr)); } - cxx_method_decl->setParams (ArrayRef(params)); + cxx_method_decl->setParams (llvm::ArrayRef(params)); cxx_record_decl->addDecl (cxx_method_decl); @@ -4913,21 +4914,21 @@ ClangASTType::AddMethodToCXXRecordType (const char *name, #pragma mark C++ Base Classes -CXXBaseSpecifier * +clang::CXXBaseSpecifier * ClangASTType::CreateBaseClassSpecifier (AccessType access, bool is_virtual, bool base_of_class) { if (IsValid()) - return new CXXBaseSpecifier (SourceRange(), - is_virtual, - base_of_class, - ClangASTContext::ConvertAccessTypeToAccessSpecifier (access), - m_ast->getTrivialTypeSourceInfo (GetQualType()), - SourceLocation()); + return new clang::CXXBaseSpecifier (clang::SourceRange(), + is_virtual, + base_of_class, + ClangASTContext::ConvertAccessTypeToAccessSpecifier (access), + m_ast->getTrivialTypeSourceInfo (GetQualType()), + clang::SourceLocation()); return nullptr; } void -ClangASTType::DeleteBaseClassSpecifiers (CXXBaseSpecifier **base_classes, unsigned num_base_classes) +ClangASTType::DeleteBaseClassSpecifiers (clang::CXXBaseSpecifier **base_classes, unsigned num_base_classes) { for (unsigned i=0; isetBases(base_classes, num_base_classes); @@ -4957,8 +4958,8 @@ ClangASTType::SetObjCSuperClass (const ClangASTType &superclass_clang_type) { if (IsValid() && superclass_clang_type.IsValid()) { - ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl (); - ObjCInterfaceDecl *super_interface_decl = superclass_clang_type.GetAsObjCInterfaceDecl (); + clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl (); + clang::ObjCInterfaceDecl *super_interface_decl = superclass_clang_type.GetAsObjCInterfaceDecl (); if (class_interface_decl && super_interface_decl) { class_interface_decl->setSuperClass(super_interface_decl); @@ -4971,7 +4972,7 @@ ClangASTType::SetObjCSuperClass (const ClangASTType &superclass_clang_type) bool ClangASTType::AddObjCClassProperty (const char *property_name, const ClangASTType &property_clang_type, - ObjCIvarDecl *ivar_decl, + clang::ObjCIvarDecl *ivar_decl, const char *property_setter_name, const char *property_getter_name, uint32_t property_attributes, @@ -4980,7 +4981,7 @@ ClangASTType::AddObjCClassProperty (const char *property_name, if (!IsValid() || !property_clang_type.IsValid() || property_name == nullptr || property_name[0] == '\0') return false; - ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl (); + clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl (); if (class_interface_decl) { @@ -4999,13 +5000,13 @@ ClangASTType::AddObjCClassProperty (const char *property_name, else prop_type_source = m_ast->getTrivialTypeSourceInfo (property_clang_type.GetQualType()); - ObjCPropertyDecl *property_decl = ObjCPropertyDecl::Create (*m_ast, - class_interface_decl, - SourceLocation(), // Source Location - &m_ast->Idents.get(property_name), - SourceLocation(), //Source Location for AT - SourceLocation(), //Source location for ( - prop_type_source); + clang::ObjCPropertyDecl *property_decl = clang::ObjCPropertyDecl::Create (*m_ast, + class_interface_decl, + clang::SourceLocation(), // Source Location + &m_ast->Idents.get(property_name), + clang::SourceLocation(), //Source Location for AT + clang::SourceLocation(), //Source location for ( + prop_type_source); if (property_decl) { @@ -5014,7 +5015,7 @@ ClangASTType::AddObjCClassProperty (const char *property_name, class_interface_decl->addDecl (property_decl); - Selector setter_sel, getter_sel; + clang::Selector setter_sel, getter_sel; if (property_setter_name != nullptr) { @@ -5069,75 +5070,75 @@ ClangASTType::AddObjCClassProperty (const char *property_name, const bool isSynthesized = false; const bool isImplicitlyDeclared = true; const bool isDefined = false; - const ObjCMethodDecl::ImplementationControl impControl = ObjCMethodDecl::None; + const clang::ObjCMethodDecl::ImplementationControl impControl = clang::ObjCMethodDecl::None; const bool HasRelatedResultType = false; - ObjCMethodDecl *getter = ObjCMethodDecl::Create (*m_ast, - SourceLocation(), - SourceLocation(), - getter_sel, - property_clang_type_to_access.GetQualType(), - nullptr, - class_interface_decl, - isInstance, - isVariadic, - isSynthesized, - isImplicitlyDeclared, - isDefined, - impControl, - HasRelatedResultType); + clang::ObjCMethodDecl *getter = clang::ObjCMethodDecl::Create (*m_ast, + clang::SourceLocation(), + clang::SourceLocation(), + getter_sel, + property_clang_type_to_access.GetQualType(), + nullptr, + class_interface_decl, + isInstance, + isVariadic, + isSynthesized, + isImplicitlyDeclared, + isDefined, + impControl, + HasRelatedResultType); if (getter && metadata) ClangASTContext::SetMetadata(m_ast, getter, *metadata); - getter->setMethodParams(*m_ast, ArrayRef(), ArrayRef()); + getter->setMethodParams(*m_ast, llvm::ArrayRef(), llvm::ArrayRef()); class_interface_decl->addDecl(getter); } if (!setter_sel.isNull() && !class_interface_decl->lookupInstanceMethod(setter_sel)) { - QualType result_type = m_ast->VoidTy; + clang::QualType result_type = m_ast->VoidTy; const bool isInstance = true; const bool isVariadic = false; const bool isSynthesized = false; const bool isImplicitlyDeclared = true; const bool isDefined = false; - const ObjCMethodDecl::ImplementationControl impControl = ObjCMethodDecl::None; + const clang::ObjCMethodDecl::ImplementationControl impControl = clang::ObjCMethodDecl::None; const bool HasRelatedResultType = false; - ObjCMethodDecl *setter = ObjCMethodDecl::Create (*m_ast, - SourceLocation(), - SourceLocation(), - setter_sel, - result_type, - nullptr, - class_interface_decl, - isInstance, - isVariadic, - isSynthesized, - isImplicitlyDeclared, - isDefined, - impControl, - HasRelatedResultType); + clang::ObjCMethodDecl *setter = clang::ObjCMethodDecl::Create (*m_ast, + clang::SourceLocation(), + clang::SourceLocation(), + setter_sel, + result_type, + nullptr, + class_interface_decl, + isInstance, + isVariadic, + isSynthesized, + isImplicitlyDeclared, + isDefined, + impControl, + HasRelatedResultType); if (setter && metadata) ClangASTContext::SetMetadata(m_ast, setter, *metadata); - llvm::SmallVector params; + llvm::SmallVector params; - params.push_back (ParmVarDecl::Create (*m_ast, - setter, - SourceLocation(), - SourceLocation(), - nullptr, // anonymous - property_clang_type_to_access.GetQualType(), - nullptr, - SC_Auto, - nullptr)); + params.push_back (clang::ParmVarDecl::Create (*m_ast, + setter, + clang::SourceLocation(), + clang::SourceLocation(), + nullptr, // anonymous + property_clang_type_to_access.GetQualType(), + nullptr, + clang::SC_Auto, + nullptr)); - setter->setMethodParams(*m_ast, ArrayRef(params), ArrayRef()); + setter->setMethodParams(*m_ast, llvm::ArrayRef(params), llvm::ArrayRef()); class_interface_decl->addDecl(setter); } @@ -5152,14 +5153,14 @@ ClangASTType::AddObjCClassProperty (const char *property_name, bool ClangASTType::IsObjCClassTypeAndHasIVars (bool check_superclass) const { - ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl (); + clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl (); if (class_interface_decl) return ObjCDeclHasIVars (class_interface_decl, check_superclass); return false; } -ObjCMethodDecl * +clang::ObjCMethodDecl * ClangASTType::AddMethodToObjCObjectType (const char *name, // the full symbol name as seen in the symbol table ("-[NString stringWithCString:]") const ClangASTType &method_clang_type, lldb::AccessType access, @@ -5168,7 +5169,7 @@ ClangASTType::AddMethodToObjCObjectType (const char *name, // the full symbol n if (!IsValid() || !method_clang_type.IsValid()) return nullptr; - ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl(); + clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl(); if (class_interface_decl == nullptr) return nullptr; @@ -5178,7 +5179,7 @@ ClangASTType::AddMethodToObjCObjectType (const char *name, // the full symbol n return nullptr; selector_start++; - llvm::SmallVector selector_idents; + llvm::SmallVector selector_idents; size_t len = 0; const char *start; @@ -5193,7 +5194,7 @@ ClangASTType::AddMethodToObjCObjectType (const char *name, // the full symbol n bool has_arg = (start[len] == ':'); if (has_arg) ++num_selectors_with_args; - selector_idents.push_back (&m_ast->Idents.get (StringRef (start, len))); + selector_idents.push_back (&m_ast->Idents.get (llvm::StringRef (start, len))); if (has_arg) len += 1; } @@ -5205,7 +5206,7 @@ ClangASTType::AddMethodToObjCObjectType (const char *name, // the full symbol n clang::Selector method_selector = m_ast->Selectors.getSelector (num_selectors_with_args ? selector_idents.size() : 0, selector_idents.data()); - QualType method_qual_type (method_clang_type.GetQualType()); + clang::QualType method_qual_type (method_clang_type.GetQualType()); // Populate the method decl with parameter decls const clang::Type *method_type(method_qual_type.getTypePtr()); @@ -5213,7 +5214,7 @@ ClangASTType::AddMethodToObjCObjectType (const char *name, // the full symbol n if (method_type == nullptr) return nullptr; - const FunctionProtoType *method_function_prototype (dyn_cast(method_type)); + const clang::FunctionProtoType *method_function_prototype (llvm::dyn_cast(method_type)); if (!method_function_prototype) return nullptr; @@ -5222,27 +5223,27 @@ ClangASTType::AddMethodToObjCObjectType (const char *name, // the full symbol n bool is_variadic = false; bool is_synthesized = false; bool is_defined = false; - ObjCMethodDecl::ImplementationControl imp_control = ObjCMethodDecl::None; + clang::ObjCMethodDecl::ImplementationControl imp_control = clang::ObjCMethodDecl::None; const unsigned num_args = method_function_prototype->getNumParams(); if (num_args != num_selectors_with_args) return nullptr; // some debug information is corrupt. We are not going to deal with it. - ObjCMethodDecl *objc_method_decl = ObjCMethodDecl::Create (*m_ast, - SourceLocation(), // beginLoc, - SourceLocation(), // endLoc, - method_selector, - method_function_prototype->getReturnType(), - nullptr, // TypeSourceInfo *ResultTInfo, - GetDeclContextForType (), - name[0] == '-', - is_variadic, - is_synthesized, - true, // is_implicitly_declared; we force this to true because we don't have source locations - is_defined, - imp_control, - false /*has_related_result_type*/); + clang::ObjCMethodDecl *objc_method_decl = clang::ObjCMethodDecl::Create (*m_ast, + clang::SourceLocation(), // beginLoc, + clang::SourceLocation(), // endLoc, + method_selector, + method_function_prototype->getReturnType(), + nullptr, // TypeSourceInfo *ResultTInfo, + GetDeclContextForType (), + name[0] == '-', + is_variadic, + is_synthesized, + true, // is_implicitly_declared; we force this to true because we don't have source locations + is_defined, + imp_control, + false /*has_related_result_type*/); if (objc_method_decl == nullptr) @@ -5250,22 +5251,22 @@ ClangASTType::AddMethodToObjCObjectType (const char *name, // the full symbol n if (num_args > 0) { - llvm::SmallVector params; + llvm::SmallVector params; for (unsigned param_index = 0; param_index < num_args; ++param_index) { - params.push_back (ParmVarDecl::Create (*m_ast, - objc_method_decl, - SourceLocation(), - SourceLocation(), - nullptr, // anonymous - method_function_prototype->getParamType(param_index), - nullptr, - SC_Auto, - nullptr)); + params.push_back (clang::ParmVarDecl::Create (*m_ast, + objc_method_decl, + clang::SourceLocation(), + clang::SourceLocation(), + nullptr, // anonymous + method_function_prototype->getParamType(param_index), + nullptr, + clang::SC_Auto, + nullptr)); } - objc_method_decl->setMethodParams(*m_ast, ArrayRef(params), ArrayRef()); + objc_method_decl->setMethodParams(*m_ast, llvm::ArrayRef(params), llvm::ArrayRef()); } class_interface_decl->addDecl (objc_method_decl); @@ -5284,7 +5285,7 @@ ClangASTType::GetDeclContextForType () const if (!IsValid()) return nullptr; - QualType qual_type(GetCanonicalQualType()); + clang::QualType qual_type(GetCanonicalQualType()); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); switch (type_class) { @@ -5306,13 +5307,13 @@ ClangASTType::GetDeclContextForType () const case clang::Type::MemberPointer: break; case clang::Type::Complex: break; case clang::Type::ObjCObject: break; - case clang::Type::ObjCInterface: return cast(qual_type.getTypePtr())->getInterface(); - case clang::Type::ObjCObjectPointer: return ClangASTType (m_ast, cast(qual_type.getTypePtr())->getPointeeType()).GetDeclContextForType(); - case clang::Type::Record: return cast(qual_type)->getDecl(); - case clang::Type::Enum: return cast(qual_type)->getDecl(); - case clang::Type::Typedef: return ClangASTType (m_ast, cast(qual_type)->getDecl()->getUnderlyingType()).GetDeclContextForType(); - case clang::Type::Elaborated: return ClangASTType (m_ast, cast(qual_type)->getNamedType()).GetDeclContextForType(); - case clang::Type::Paren: return ClangASTType (m_ast, cast(qual_type)->desugar()).GetDeclContextForType(); + case clang::Type::ObjCInterface: return llvm::cast(qual_type.getTypePtr())->getInterface(); + case clang::Type::ObjCObjectPointer: return ClangASTType (m_ast, llvm::cast(qual_type.getTypePtr())->getPointeeType()).GetDeclContextForType(); + case clang::Type::Record: return llvm::cast(qual_type)->getDecl(); + case clang::Type::Enum: return llvm::cast(qual_type)->getDecl(); + case clang::Type::Typedef: return ClangASTType (m_ast, llvm::cast(qual_type)->getDecl()->getUnderlyingType()).GetDeclContextForType(); + case clang::Type::Elaborated: return ClangASTType (m_ast, llvm::cast(qual_type)->getNamedType()).GetDeclContextForType(); + case clang::Type::Paren: return ClangASTType (m_ast, llvm::cast(qual_type)->desugar()).GetDeclContextForType(); case clang::Type::TypeOfExpr: break; case clang::Type::TypeOf: break; case clang::Type::Decltype: break; @@ -5329,6 +5330,7 @@ ClangASTType::GetDeclContextForType () const case clang::Type::InjectedClassName: break; case clang::Type::DependentName: break; case clang::Type::Atomic: break; + case clang::Type::Adjusted: break; // pointer type decayed from an array or function type. case clang::Type::Decayed: break; @@ -5344,18 +5346,18 @@ ClangASTType::SetDefaultAccessForRecordFields (int default_accessibility, { if (IsValid()) { - RecordDecl *record_decl = GetAsRecordDecl(); + clang::RecordDecl *record_decl = GetAsRecordDecl(); if (record_decl) { uint32_t field_idx; - RecordDecl::field_iterator field, field_end; + clang::RecordDecl::field_iterator field, field_end; for (field = record_decl->field_begin(), field_end = record_decl->field_end(), field_idx = 0; field != field_end; ++field, ++field_idx) { // If no accessibility was assigned, assign the correct one if (field_idx < num_assigned_accessibilities && assigned_accessibilities[field_idx] == clang::AS_none) - field->setAccess ((AccessSpecifier)default_accessibility); + field->setAccess ((clang::AccessSpecifier)default_accessibility); } return true; } @@ -5370,14 +5372,14 @@ ClangASTType::SetHasExternalStorage (bool has_extern) if (!IsValid()) return false; - QualType qual_type (GetCanonicalQualType()); + clang::QualType qual_type (GetCanonicalQualType()); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); switch (type_class) { case clang::Type::Record: { - CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); + clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); if (cxx_record_decl) { cxx_record_decl->setHasExternalLexicalStorage (has_extern); @@ -5389,7 +5391,7 @@ ClangASTType::SetHasExternalStorage (bool has_extern) case clang::Type::Enum: { - EnumDecl *enum_decl = cast(qual_type)->getDecl(); + clang::EnumDecl *enum_decl = llvm::cast(qual_type)->getDecl(); if (enum_decl) { enum_decl->setHasExternalLexicalStorage (has_extern); @@ -5402,11 +5404,11 @@ ClangASTType::SetHasExternalStorage (bool has_extern) case clang::Type::ObjCObject: case clang::Type::ObjCInterface: { - const ObjCObjectType *objc_class_type = dyn_cast(qual_type.getTypePtr()); + const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast(qual_type.getTypePtr()); assert (objc_class_type); if (objc_class_type) { - ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); + clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); if (class_interface_decl) { @@ -5419,13 +5421,13 @@ ClangASTType::SetHasExternalStorage (bool has_extern) break; case clang::Type::Typedef: - return ClangASTType (m_ast, cast(qual_type)->getDecl()->getUnderlyingType()).SetHasExternalStorage (has_extern); + return ClangASTType (m_ast, llvm::cast(qual_type)->getDecl()->getUnderlyingType()).SetHasExternalStorage (has_extern); case clang::Type::Elaborated: - return ClangASTType (m_ast, cast(qual_type)->getNamedType()).SetHasExternalStorage (has_extern); + return ClangASTType (m_ast, llvm::cast(qual_type)->getNamedType()).SetHasExternalStorage (has_extern); case clang::Type::Paren: - return ClangASTType (m_ast, cast(qual_type)->desugar()).SetHasExternalStorage (has_extern); + return ClangASTType (m_ast, llvm::cast(qual_type)->desugar()).SetHasExternalStorage (has_extern); default: break; @@ -5438,17 +5440,17 @@ ClangASTType::SetTagTypeKind (int kind) const { if (IsValid()) { - QualType tag_qual_type(GetQualType()); + clang::QualType tag_qual_type(GetQualType()); const clang::Type *clang_type = tag_qual_type.getTypePtr(); if (clang_type) { - const TagType *tag_type = dyn_cast(clang_type); + const clang::TagType *tag_type = llvm::dyn_cast(clang_type); if (tag_type) { - TagDecl *tag_decl = dyn_cast(tag_type->getDecl()); + clang::TagDecl *tag_decl = llvm::dyn_cast(tag_type->getDecl()); if (tag_decl) { - tag_decl->setTagKind ((TagDecl::TagKind)kind); + tag_decl->setTagKind ((clang::TagDecl::TagKind)kind); return true; } } @@ -5465,14 +5467,14 @@ ClangASTType::StartTagDeclarationDefinition () { if (IsValid()) { - QualType qual_type (GetQualType()); + clang::QualType qual_type (GetQualType()); const clang::Type *t = qual_type.getTypePtr(); if (t) { - const TagType *tag_type = dyn_cast(t); + const clang::TagType *tag_type = llvm::dyn_cast(t); if (tag_type) { - TagDecl *tag_decl = tag_type->getDecl(); + clang::TagDecl *tag_decl = tag_type->getDecl(); if (tag_decl) { tag_decl->startDefinition(); @@ -5480,10 +5482,10 @@ ClangASTType::StartTagDeclarationDefinition () } } - const ObjCObjectType *object_type = dyn_cast(t); + const clang::ObjCObjectType *object_type = llvm::dyn_cast(t); if (object_type) { - ObjCInterfaceDecl *interface_decl = object_type->getInterface(); + clang::ObjCInterfaceDecl *interface_decl = object_type->getInterface(); if (interface_decl) { interface_decl->startDefinition(); @@ -5500,9 +5502,9 @@ ClangASTType::CompleteTagDeclarationDefinition () { if (IsValid()) { - QualType qual_type (GetQualType()); + clang::QualType qual_type (GetQualType()); - CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); + clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); if (cxx_record_decl) { @@ -5511,11 +5513,11 @@ ClangASTType::CompleteTagDeclarationDefinition () return true; } - const EnumType *enum_type = dyn_cast(qual_type.getTypePtr()); + const clang::EnumType *enum_type = llvm::dyn_cast(qual_type.getTypePtr()); if (enum_type) { - EnumDecl *enum_decl = enum_type->getDecl(); + clang::EnumDecl *enum_decl = enum_type->getDecl(); if (enum_decl) { @@ -5524,7 +5526,7 @@ ClangASTType::CompleteTagDeclarationDefinition () unsigned NumPositiveBits = 1; unsigned NumNegativeBits = 0; - QualType promotion_qual_type; + clang::QualType promotion_qual_type; // If the enum integer type is less than an integer in bit width, // then we must promote it to an integer size. if (m_ast->getTypeSize(enum_decl->getIntegerType()) < m_ast->getTypeSize(m_ast->IntTy)) @@ -5560,27 +5562,27 @@ ClangASTType::AddEnumerationValueToEnumerationType (const ClangASTType &enumerat { if (IsValid() && enumerator_clang_type.IsValid() && name && name[0]) { - QualType enum_qual_type (GetCanonicalQualType()); + clang::QualType enum_qual_type (GetCanonicalQualType()); bool is_signed = false; enumerator_clang_type.IsIntegerType (is_signed); const clang::Type *clang_type = enum_qual_type.getTypePtr(); if (clang_type) { - const EnumType *enum_type = dyn_cast(clang_type); + const clang::EnumType *enum_type = llvm::dyn_cast(clang_type); if (enum_type) { llvm::APSInt enum_llvm_apsint(enum_value_bit_size, is_signed); enum_llvm_apsint = enum_value; - EnumConstantDecl *enumerator_decl = - EnumConstantDecl::Create (*m_ast, - enum_type->getDecl(), - SourceLocation(), - name ? &m_ast->Idents.get(name) : nullptr, // Identifier - enumerator_clang_type.GetQualType(), - nullptr, - enum_llvm_apsint); + clang::EnumConstantDecl *enumerator_decl = + clang::EnumConstantDecl::Create (*m_ast, + enum_type->getDecl(), + clang::SourceLocation(), + name ? &m_ast->Idents.get(name) : nullptr, // Identifier + enumerator_clang_type.GetQualType(), + nullptr, + enum_llvm_apsint); if (enumerator_decl) { @@ -5602,14 +5604,14 @@ ClangASTType::AddEnumerationValueToEnumerationType (const ClangASTType &enumerat ClangASTType ClangASTType::GetEnumerationIntegerType () const { - QualType enum_qual_type (GetCanonicalQualType()); + clang::QualType enum_qual_type (GetCanonicalQualType()); const clang::Type *clang_type = enum_qual_type.getTypePtr(); if (clang_type) { - const EnumType *enum_type = dyn_cast(clang_type); + const clang::EnumType *enum_type = llvm::dyn_cast(clang_type); if (enum_type) { - EnumDecl *enum_decl = enum_type->getDecl(); + clang::EnumDecl *enum_decl = enum_type->getDecl(); if (enum_decl) return ClangASTType (m_ast, enum_decl->getIntegerType()); } @@ -5634,7 +5636,7 @@ ClangASTType::ConvertStringToFloatValue (const char *s, uint8_t *dst, size_t dst { if (IsValid()) { - QualType qual_type (GetCanonicalQualType()); + clang::QualType qual_type (GetCanonicalQualType()); uint32_t count = 0; bool is_complex = false; if (IsFloatingPointType (count, is_complex)) @@ -5643,8 +5645,8 @@ ClangASTType::ConvertStringToFloatValue (const char *s, uint8_t *dst, size_t dst if (count != 1) return false; - StringRef s_sref(s); - APFloat ap_float(m_ast->getFloatTypeSemantics(qual_type), s_sref); + llvm::StringRef s_sref(s); + llvm::APFloat ap_float(m_ast->getFloatTypeSemantics(qual_type), s_sref); const uint64_t bit_size = m_ast->getTypeSize (qual_type); const uint64_t byte_size = bit_size / 8; @@ -5692,30 +5694,30 @@ ClangASTType::DumpValue (ExecutionContext *exe_ctx, if (!IsValid()) return; - QualType qual_type(GetQualType()); + clang::QualType qual_type(GetQualType()); switch (qual_type->getTypeClass()) { case clang::Type::Record: if (GetCompleteType ()) { - const RecordType *record_type = cast(qual_type.getTypePtr()); - const RecordDecl *record_decl = record_type->getDecl(); + const clang::RecordType *record_type = llvm::cast(qual_type.getTypePtr()); + const clang::RecordDecl *record_decl = record_type->getDecl(); assert(record_decl); uint32_t field_bit_offset = 0; uint32_t field_byte_offset = 0; - const ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(record_decl); + const clang::ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(record_decl); uint32_t child_idx = 0; - const CXXRecordDecl *cxx_record_decl = dyn_cast(record_decl); + const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast(record_decl); if (cxx_record_decl) { // We might have base classes to print out first - CXXRecordDecl::base_class_const_iterator base_class, base_class_end; + clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end; for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); base_class != base_class_end; ++base_class) { - const CXXRecordDecl *base_class_decl = cast(base_class->getType()->getAs()->getDecl()); + const clang::CXXRecordDecl *base_class_decl = llvm::cast(base_class->getType()->getAs()->getDecl()); // Skip empty base classes if (verbose == false && ClangASTContext::RecordHasFields(base_class_decl) == false) @@ -5732,7 +5734,7 @@ ClangASTType::DumpValue (ExecutionContext *exe_ctx, else s->PutChar(','); - QualType base_class_qual_type = base_class->getType(); + clang::QualType base_class_qual_type = base_class->getType(); std::string base_class_type_name(base_class_qual_type.getAsString()); // Indent and print the base class type name @@ -5759,7 +5761,7 @@ ClangASTType::DumpValue (ExecutionContext *exe_ctx, } } uint32_t field_idx = 0; - RecordDecl::field_iterator field, field_end; + clang::RecordDecl::field_iterator field, field_end; for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx, ++child_idx) { // Print the starting squiggly bracket (if this is the @@ -5773,7 +5775,7 @@ ClangASTType::DumpValue (ExecutionContext *exe_ctx, // Indent s->Printf("\n%*s", depth + DEPTH_INCREMENT, ""); - QualType field_type = field->getType(); + clang::QualType field_type = field->getType(); // Print the member type if requested // Figure out the type byte size (field_type_info.first) and // alignment (field_type_info.second) from the AST context. @@ -5824,10 +5826,10 @@ ClangASTType::DumpValue (ExecutionContext *exe_ctx, case clang::Type::Enum: if (GetCompleteType ()) { - const EnumType *enum_type = cast(qual_type.getTypePtr()); - const EnumDecl *enum_decl = enum_type->getDecl(); + const clang::EnumType *enum_type = llvm::cast(qual_type.getTypePtr()); + const clang::EnumDecl *enum_decl = enum_type->getDecl(); assert(enum_decl); - EnumDecl::enumerator_iterator enum_pos, enum_end_pos; + clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos; lldb::offset_t offset = data_byte_offset; const int64_t enum_value = data.GetMaxU64Bitfield(&offset, data_byte_size, bitfield_bit_size, bitfield_bit_offset); for (enum_pos = enum_decl->enumerator_begin(), enum_end_pos = enum_decl->enumerator_end(); enum_pos != enum_end_pos; ++enum_pos) @@ -5846,9 +5848,9 @@ ClangASTType::DumpValue (ExecutionContext *exe_ctx, case clang::Type::ConstantArray: { - const ConstantArrayType *array = cast(qual_type.getTypePtr()); + const clang::ConstantArrayType *array = llvm::cast(qual_type.getTypePtr()); bool is_array_of_characters = false; - QualType element_qual_type = array->getElementType(); + clang::QualType element_qual_type = array->getElementType(); const clang::Type *canonical_type = element_qual_type->getCanonicalTypeInternal().getTypePtr(); if (canonical_type) @@ -5915,7 +5917,7 @@ ClangASTType::DumpValue (ExecutionContext *exe_ctx, case clang::Type::Typedef: { - QualType typedef_qual_type = cast(qual_type)->getDecl()->getUnderlyingType(); + clang::QualType typedef_qual_type = llvm::cast(qual_type)->getDecl()->getUnderlyingType(); ClangASTType typedef_clang_type (m_ast, typedef_qual_type); lldb::Format typedef_format = typedef_clang_type.GetFormat(); @@ -5939,7 +5941,7 @@ ClangASTType::DumpValue (ExecutionContext *exe_ctx, case clang::Type::Elaborated: { - QualType elaborated_qual_type = cast(qual_type)->getNamedType(); + clang::QualType elaborated_qual_type = llvm::cast(qual_type)->getNamedType(); ClangASTType elaborated_clang_type (m_ast, elaborated_qual_type); lldb::Format elaborated_format = elaborated_clang_type.GetFormat(); std::pair elaborated_type_info = m_ast->getTypeInfo(elaborated_qual_type); @@ -5962,7 +5964,7 @@ ClangASTType::DumpValue (ExecutionContext *exe_ctx, case clang::Type::Paren: { - QualType desugar_qual_type = cast(qual_type)->desugar(); + clang::QualType desugar_qual_type = llvm::cast(qual_type)->desugar(); ClangASTType desugar_clang_type (m_ast, desugar_qual_type); lldb::Format desugar_format = desugar_clang_type.GetFormat(); @@ -6023,14 +6025,14 @@ ClangASTType::DumpTypeValue (Stream *s, } else { - QualType qual_type(GetQualType()); + clang::QualType qual_type(GetQualType()); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); switch (type_class) { case clang::Type::Typedef: { - QualType typedef_qual_type = cast(qual_type)->getDecl()->getUnderlyingType(); + clang::QualType typedef_qual_type = llvm::cast(qual_type)->getDecl()->getUnderlyingType(); ClangASTType typedef_clang_type (m_ast, typedef_qual_type); if (format == eFormatDefault) format = typedef_clang_type.GetFormat(); @@ -6053,10 +6055,10 @@ ClangASTType::DumpTypeValue (Stream *s, // its enumeration string value, else just display it as requested. if ((format == eFormatEnum || format == eFormatDefault) && GetCompleteType ()) { - const EnumType *enum_type = cast(qual_type.getTypePtr()); - const EnumDecl *enum_decl = enum_type->getDecl(); + const clang::EnumType *enum_type = llvm::cast(qual_type.getTypePtr()); + const clang::EnumDecl *enum_decl = enum_type->getDecl(); assert(enum_decl); - EnumDecl::enumerator_iterator enum_pos, enum_end_pos; + clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos; const bool is_signed = qual_type->isSignedIntegerOrEnumerationType(); lldb::offset_t offset = byte_offset; if (is_signed) @@ -6232,10 +6234,10 @@ ClangASTType::DumpTypeDescription (Stream *s) const { if (IsValid()) { - QualType qual_type(GetQualType()); + clang::QualType qual_type(GetQualType()); - SmallVector buf; - raw_svector_ostream llvm_ostrm (buf); + llvm::SmallVector buf; + llvm::raw_svector_ostream llvm_ostrm (buf); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); switch (type_class) @@ -6245,14 +6247,14 @@ ClangASTType::DumpTypeDescription (Stream *s) const { GetCompleteType (); - const ObjCObjectType *objc_class_type = dyn_cast(qual_type.getTypePtr()); + const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast(qual_type.getTypePtr()); assert (objc_class_type); if (objc_class_type) { - ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); + clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); if (class_interface_decl) { - PrintingPolicy policy = m_ast->getPrintingPolicy(); + clang::PrintingPolicy policy = m_ast->getPrintingPolicy(); class_interface_decl->print(llvm_ostrm, policy, s->GetIndentLevel()); } } @@ -6261,10 +6263,10 @@ ClangASTType::DumpTypeDescription (Stream *s) const case clang::Type::Typedef: { - const TypedefType *typedef_type = qual_type->getAs(); + const clang::TypedefType *typedef_type = qual_type->getAs(); if (typedef_type) { - const TypedefNameDecl *typedef_decl = typedef_type->getDecl(); + const clang::TypedefNameDecl *typedef_decl = typedef_type->getDecl(); std::string clang_typedef_name (typedef_decl->getQualifiedNameAsString()); if (!clang_typedef_name.empty()) { @@ -6276,20 +6278,20 @@ ClangASTType::DumpTypeDescription (Stream *s) const break; case clang::Type::Elaborated: - ClangASTType (m_ast, cast(qual_type)->getNamedType()).DumpTypeDescription(s); + ClangASTType (m_ast, llvm::cast(qual_type)->getNamedType()).DumpTypeDescription(s); return; case clang::Type::Paren: - ClangASTType (m_ast, cast(qual_type)->desugar()).DumpTypeDescription(s); + ClangASTType (m_ast, llvm::cast(qual_type)->desugar()).DumpTypeDescription(s); return; case clang::Type::Record: { GetCompleteType (); - const RecordType *record_type = cast(qual_type.getTypePtr()); - const RecordDecl *record_decl = record_type->getDecl(); - const CXXRecordDecl *cxx_record_decl = dyn_cast(record_decl); + const clang::RecordType *record_type = llvm::cast(qual_type.getTypePtr()); + const clang::RecordDecl *record_decl = record_type->getDecl(); + const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast(record_decl); if (cxx_record_decl) cxx_record_decl->print(llvm_ostrm, m_ast->getPrintingPolicy(), s->GetIndentLevel()); @@ -6300,10 +6302,10 @@ ClangASTType::DumpTypeDescription (Stream *s) const default: { - const TagType *tag_type = dyn_cast(qual_type.getTypePtr()); + const clang::TagType *tag_type = llvm::dyn_cast(qual_type.getTypePtr()); if (tag_type) { - TagDecl *tag_decl = tag_type->getDecl(); + clang::TagDecl *tag_decl = tag_type->getDecl(); if (tag_decl) tag_decl->print(llvm_ostrm, 0); } @@ -6629,11 +6631,11 @@ ClangASTType::WriteToMemory (lldb_private::ExecutionContext *exe_ctx, } -//CXXRecordDecl * +//clang::CXXRecordDecl * //ClangASTType::GetAsCXXRecordDecl (lldb::clang_type_t opaque_clang_qual_type) //{ // if (opaque_clang_qual_type) -// return QualType::getFromOpaquePtr(opaque_clang_qual_type)->getAsCXXRecordDecl(); +// return clang::QualType::getFromOpaquePtr(opaque_clang_qual_type)->getAsCXXRecordDecl(); // return NULL; //}