[clang] [clang-tools-extra] [clang] improve class type sugar preservation in pointers to members (PR #130537)
Matheus Izvekov via cfe-commits
cfe-commits at lists.llvm.org
Mon Mar 10 09:26:36 PDT 2025
https://github.com/mizvekov updated https://github.com/llvm/llvm-project/pull/130537
>From 94e604f2b5c2d48cf23f456820f919d2b4541dbf Mon Sep 17 00:00:00 2001
From: Matheus Izvekov <mizvekov at gmail.com>
Date: Wed, 5 Mar 2025 10:37:54 -0300
Subject: [PATCH] [clang] preserve class type sugar when taking pointer to
member
This changes the MemberPointerType representation to use
a NestedNameSpecifier instead of a Type to represent the base
class.
Since the qualifiers are always parsed as nested names, there
was an impedance mismatch when converting these back and
forth into types, and this led to issues in preserving
sugar.
The nested names are indeed a better match for these,
as the differences which a QualType can represent cannot be
expressed syntatically, and they represent the use case more
exactly, being either dependent or referring to a CXXRecord,
unqualified.
This patch also makes the MemberPointerType able to represent
sugar for a {up/downcast}cast conversion of the base class,
although for now the underlying type is canonical, as preserving
the sugar up to that point requires further work.
As usual, includes a few drive-by fixes in order to make use
of the improvements.
---
...arePointerToMemberVirtualFunctionCheck.cpp | 5 +-
.../clang-tidy/modernize/UseNullptrCheck.cpp | 3 +-
.../clang-tidy/utils/ExceptionAnalyzer.cpp | 8 +-
.../clangd/unittests/FindTargetTests.cpp | 2 +-
clang/docs/ReleaseNotes.rst | 1 +
clang/include/clang/AST/ASTContext.h | 7 +-
clang/include/clang/AST/ASTNodeTraverser.h | 7 +-
clang/include/clang/AST/CanonicalType.h | 4 +-
clang/include/clang/AST/RecursiveASTVisitor.h | 9 +-
clang/include/clang/AST/Type.h | 28 +-
clang/include/clang/AST/TypeLoc.h | 32 +-
clang/include/clang/AST/TypeProperties.td | 9 +-
.../clang/Basic/DiagnosticSemaKinds.td | 6 +-
clang/include/clang/Sema/Sema.h | 39 +-
clang/lib/AST/ASTContext.cpp | 194 +++++++--
clang/lib/AST/ASTImporter.cpp | 14 +-
clang/lib/AST/ASTStructuralEquivalence.cpp | 4 +-
clang/lib/AST/ByteCode/Compiler.cpp | 10 +-
clang/lib/AST/ExprConstant.cpp | 5 +-
clang/lib/AST/ItaniumMangle.cpp | 11 +-
clang/lib/AST/MicrosoftMangle.cpp | 10 +-
clang/lib/AST/NestedNameSpecifier.cpp | 1 +
clang/lib/AST/ODRHash.cpp | 2 +-
clang/lib/AST/QualTypeNames.cpp | 7 +-
clang/lib/AST/Type.cpp | 51 ++-
clang/lib/AST/TypePrinter.cpp | 4 +-
clang/lib/CodeGen/CGCXXABI.cpp | 7 +-
clang/lib/CodeGen/CGClass.cpp | 7 +-
clang/lib/CodeGen/CGDebugInfo.cpp | 3 +-
clang/lib/CodeGen/CGExprCXX.cpp | 8 +-
clang/lib/CodeGen/CGPointerAuth.cpp | 4 +-
clang/lib/CodeGen/CGVTables.cpp | 5 +-
clang/lib/CodeGen/CodeGenModule.cpp | 2 +-
clang/lib/CodeGen/CodeGenTypes.cpp | 2 +-
clang/lib/CodeGen/ItaniumCXXABI.cpp | 21 +-
clang/lib/CodeGen/MicrosoftCXXABI.cpp | 7 +-
clang/lib/Sema/SemaAccess.cpp | 45 ++-
clang/lib/Sema/SemaCast.cpp | 82 +---
clang/lib/Sema/SemaDeclCXX.cpp | 48 ++-
clang/lib/Sema/SemaExpr.cpp | 10 +-
clang/lib/Sema/SemaExprCXX.cpp | 54 ++-
clang/lib/Sema/SemaLookup.cpp | 7 +-
clang/lib/Sema/SemaOpenMP.cpp | 5 +-
clang/lib/Sema/SemaOverload.cpp | 194 +++++----
clang/lib/Sema/SemaStmt.cpp | 3 +-
clang/lib/Sema/SemaTemplate.cpp | 8 +-
clang/lib/Sema/SemaTemplateDeduction.cpp | 21 +-
clang/lib/Sema/SemaType.cpp | 122 +-----
clang/lib/Sema/TreeTransform.h | 59 ++-
clang/lib/Serialization/ASTReader.cpp | 2 +-
clang/lib/Serialization/ASTWriter.cpp | 2 +-
.../Serialization/TemplateArgumentHasher.cpp | 4 +-
...dump-template-json-win32-mangler-crash.cpp | 4 +-
clang/test/AST/ast-dump-templates.cpp | 238 +++++++++++
clang/test/AST/ast-dump-types-json.cpp | 382 ++++++++++++++++--
clang/test/AST/attr-print-emit.cpp | 2 +-
.../cxx-uninitialized-object-ptr-ref.cpp | 10 +-
clang/test/CXX/class.access/p6.cpp | 4 +-
clang/test/CXX/drs/cwg0xx.cpp | 12 +-
clang/test/CXX/drs/cwg13xx.cpp | 4 +-
clang/test/CXX/drs/cwg26xx.cpp | 6 +-
clang/test/CXX/drs/cwg2xx.cpp | 4 +-
clang/test/CXX/drs/cwg4xx.cpp | 2 +-
clang/test/CXX/drs/cwg7xx.cpp | 3 +-
.../CXX/temp/temp.arg/temp.arg.nontype/p1.cpp | 2 +-
.../CXX/temp/temp.arg/temp.arg.nontype/p5.cpp | 6 +-
clang/test/Index/print-type.cpp | 2 +-
.../SemaCXX/addr-of-overloaded-function.cpp | 26 +-
.../SemaCXX/builtin-ptrtomember-ambig.cpp | 4 +-
clang/test/SemaCXX/calling-conv-compat.cpp | 42 +-
.../SemaCXX/err_init_conversion_failed.cpp | 2 +-
clang/test/SemaCXX/member-pointer.cpp | 17 +-
clang/test/SemaCXX/sugar-common-types.cpp | 4 +-
.../SemaOpenACC/combined-construct-if-ast.cpp | 4 +-
.../combined-construct-num_workers-ast.cpp | 4 +-
.../compute-construct-clause-ast.cpp | 4 +-
.../compute-construct-intexpr-clause-ast.cpp | 4 +-
.../SemaOpenACC/data-construct-if-ast.cpp | 4 +-
.../instantiate-member-pointers.cpp | 3 +-
clang/tools/libclang/CXType.cpp | 4 +-
.../ASTMatchers/ASTMatchersTraversalTest.cpp | 8 +-
81 files changed, 1356 insertions(+), 660 deletions(-)
diff --git a/clang-tools-extra/clang-tidy/bugprone/ComparePointerToMemberVirtualFunctionCheck.cpp b/clang-tools-extra/clang-tidy/bugprone/ComparePointerToMemberVirtualFunctionCheck.cpp
index 9d1d92b989bf1..a8a9e6bdcdff8 100644
--- a/clang-tools-extra/clang-tidy/bugprone/ComparePointerToMemberVirtualFunctionCheck.cpp
+++ b/clang-tools-extra/clang-tidy/bugprone/ComparePointerToMemberVirtualFunctionCheck.cpp
@@ -70,10 +70,7 @@ void ComparePointerToMemberVirtualFunctionCheck::check(
// compare with variable which type is pointer to member function.
llvm::SmallVector<SourceLocation, 12U> SameSignatureVirtualMethods{};
const auto *MPT = cast<MemberPointerType>(DRE->getType().getCanonicalType());
- const Type *T = MPT->getClass();
- if (T == nullptr)
- return;
- const CXXRecordDecl *RD = T->getAsCXXRecordDecl();
+ const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl();
if (RD == nullptr)
return;
diff --git a/clang-tools-extra/clang-tidy/modernize/UseNullptrCheck.cpp b/clang-tools-extra/clang-tidy/modernize/UseNullptrCheck.cpp
index 108717e151b57..a6b00be75abf8 100644
--- a/clang-tools-extra/clang-tidy/modernize/UseNullptrCheck.cpp
+++ b/clang-tools-extra/clang-tidy/modernize/UseNullptrCheck.cpp
@@ -493,8 +493,7 @@ UseNullptrCheck::UseNullptrCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context),
NullMacrosStr(Options.get("NullMacros", "NULL")),
IgnoredTypes(utils::options::parseStringList(Options.get(
- "IgnoredTypes",
- "std::_CmpUnspecifiedParam::;^std::__cmp_cat::__unspec"))) {
+ "IgnoredTypes", "_CmpUnspecifiedParam;^std::__cmp_cat::__unspec"))) {
StringRef(NullMacrosStr).split(NullMacros, ",");
}
diff --git a/clang-tools-extra/clang-tidy/utils/ExceptionAnalyzer.cpp b/clang-tools-extra/clang-tidy/utils/ExceptionAnalyzer.cpp
index 0fea7946a59f9..bc49fa856bafc 100644
--- a/clang-tools-extra/clang-tidy/utils/ExceptionAnalyzer.cpp
+++ b/clang-tools-extra/clang-tidy/utils/ExceptionAnalyzer.cpp
@@ -178,7 +178,9 @@ bool isFunctionPointerConvertible(QualType From, QualType To) {
// Note: converting Derived::* to Base::* is a different kind of conversion,
// called Pointer-to-member conversion.
- return FromMember->getClass() == ToMember->getClass() &&
+ return FromMember->getQualifier() == ToMember->getQualifier() &&
+ FromMember->getMostRecentCXXRecordDecl() ==
+ ToMember->getMostRecentCXXRecordDecl() &&
FromMember->getPointeeType() == ToMember->getPointeeType();
}
@@ -219,8 +221,8 @@ bool isQualificationConvertiblePointer(QualType From, QualType To,
if (P1->isMemberPointerType())
return P2->isMemberPointerType() &&
- P1->getAs<MemberPointerType>()->getClass() ==
- P2->getAs<MemberPointerType>()->getClass();
+ P1->getAs<MemberPointerType>()->getMostRecentCXXRecordDecl() ==
+ P2->getAs<MemberPointerType>()->getMostRecentCXXRecordDecl();
if (P1->isConstantArrayType())
return P2->isConstantArrayType() &&
diff --git a/clang-tools-extra/clangd/unittests/FindTargetTests.cpp b/clang-tools-extra/clangd/unittests/FindTargetTests.cpp
index fc54f89f4941e..602f61d9ecb41 100644
--- a/clang-tools-extra/clangd/unittests/FindTargetTests.cpp
+++ b/clang-tools-extra/clangd/unittests/FindTargetTests.cpp
@@ -1489,7 +1489,7 @@ TEST_F(FindExplicitReferencesTest, AllRefsInFoo) {
"4: targets = {a}\n"
"5: targets = {a::b}, qualifier = 'a::'\n"
"6: targets = {a::b::S}\n"
- "7: targets = {a::b::S::type}, qualifier = 'struct S::'\n"
+ "7: targets = {a::b::S::type}, qualifier = 'S::'\n"
"8: targets = {y}, decl\n"},
{R"cpp(
void foo() {
diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst
index edb05ca54caf0..d820eef8a1809 100644
--- a/clang/docs/ReleaseNotes.rst
+++ b/clang/docs/ReleaseNotes.rst
@@ -230,6 +230,7 @@ Improvements to Clang's diagnostics
under the subgroup ``-Wunsafe-buffer-usage-in-libc-call``.
- Diagnostics on chained comparisons (``a < b < c``) are now an error by default. This can be disabled with
``-Wno-error=parentheses``.
+- Better preservation of member pointer type sugar.
- The ``-Wshift-bool`` warning has been added to warn about shifting a boolean. (#GH28334)
- Fixed diagnostics adding a trailing ``::`` when printing some source code
constructs, like base classes.
diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h
index f9a12260a6590..af8c49e99a7ce 100644
--- a/clang/include/clang/AST/ASTContext.h
+++ b/clang/include/clang/AST/ASTContext.h
@@ -1558,10 +1558,9 @@ class ASTContext : public RefCountedBase<ASTContext> {
QualType getRValueReferenceType(QualType T) const;
/// Return the uniqued reference to the type for a member pointer to
- /// the specified type in the specified class.
- ///
- /// The class \p Cls is a \c Type because it could be a dependent name.
- QualType getMemberPointerType(QualType T, const Type *Cls) const;
+ /// the specified type in the specified nested name.
+ QualType getMemberPointerType(QualType T, NestedNameSpecifier *Qualifier,
+ const CXXRecordDecl *Cls) const;
/// Return a non-unique reference to the type for a variable array of
/// the specified element type.
diff --git a/clang/include/clang/AST/ASTNodeTraverser.h b/clang/include/clang/AST/ASTNodeTraverser.h
index 3bc0bdff2bdd1..f557555e96e59 100644
--- a/clang/include/clang/AST/ASTNodeTraverser.h
+++ b/clang/include/clang/AST/ASTNodeTraverser.h
@@ -393,7 +393,9 @@ class ASTNodeTraverser
Visit(T->getPointeeType());
}
void VisitMemberPointerType(const MemberPointerType *T) {
- Visit(T->getClass());
+ // FIXME: Provide a NestedNameSpecifier visitor.
+ Visit(T->getQualifier()->getAsType());
+ Visit(T->getMostRecentCXXRecordDecl());
Visit(T->getPointeeType());
}
void VisitArrayType(const ArrayType *T) { Visit(T->getElementType()); }
@@ -485,7 +487,8 @@ class ASTNodeTraverser
}
}
void VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
- Visit(TL.getClassTInfo()->getTypeLoc());
+ // FIXME: Provide NestedNamespecifierLoc visitor.
+ Visit(TL.getQualifierLoc().getTypeLoc());
}
void VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
Visit(TL.getSizeExpr());
diff --git a/clang/include/clang/AST/CanonicalType.h b/clang/include/clang/AST/CanonicalType.h
index 6699284d215bd..35db68971e029 100644
--- a/clang/include/clang/AST/CanonicalType.h
+++ b/clang/include/clang/AST/CanonicalType.h
@@ -453,7 +453,9 @@ template<>
struct CanProxyAdaptor<MemberPointerType>
: public CanProxyBase<MemberPointerType> {
LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getPointeeType)
- LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(const Type *, getClass)
+ LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(NestedNameSpecifier *, getQualifier)
+ LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(const CXXRecordDecl *,
+ getMostRecentCXXRecordDecl)
};
// CanProxyAdaptors for arrays are intentionally unimplemented because
diff --git a/clang/include/clang/AST/RecursiveASTVisitor.h b/clang/include/clang/AST/RecursiveASTVisitor.h
index 5ca3e435f033b..67025eb7a5a38 100644
--- a/clang/include/clang/AST/RecursiveASTVisitor.h
+++ b/clang/include/clang/AST/RecursiveASTVisitor.h
@@ -1004,7 +1004,8 @@ DEF_TRAVERSE_TYPE(RValueReferenceType,
{ TRY_TO(TraverseType(T->getPointeeType())); })
DEF_TRAVERSE_TYPE(MemberPointerType, {
- TRY_TO(TraverseType(QualType(T->getClass(), 0)));
+ TRY_TO(TraverseNestedNameSpecifier(T->getQualifier()));
+ TRY_TO(TraverseDecl(T->getMostRecentCXXRecordDecl()));
TRY_TO(TraverseType(T->getPointeeType()));
})
@@ -1269,10 +1270,10 @@ DEF_TRAVERSE_TYPELOC(RValueReferenceType,
// We traverse this in the type case as well, but how is it not reached through
// the pointee type?
DEF_TRAVERSE_TYPELOC(MemberPointerType, {
- if (auto *TSI = TL.getClassTInfo())
- TRY_TO(TraverseTypeLoc(TSI->getTypeLoc()));
+ if (NestedNameSpecifierLoc QL = TL.getQualifierLoc())
+ TRY_TO(TraverseNestedNameSpecifierLoc(QL));
else
- TRY_TO(TraverseType(QualType(TL.getTypePtr()->getClass(), 0)));
+ TRY_TO(TraverseNestedNameSpecifier(TL.getTypePtr()->getQualifier()));
TRY_TO(TraverseTypeLoc(TL.getPointeeLoc()));
})
diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h
index ef59bd1621fb8..84f40025b07fc 100644
--- a/clang/include/clang/AST/Type.h
+++ b/clang/include/clang/AST/Type.h
@@ -3524,14 +3524,16 @@ class MemberPointerType : public Type, public llvm::FoldingSetNode {
QualType PointeeType;
/// The class of which the pointee is a member. Must ultimately be a
- /// RecordType, but could be a typedef or a template parameter too.
- const Type *Class;
+ /// CXXRecordType, but could be a typedef or a template parameter too.
+ NestedNameSpecifier *Qualifier;
- MemberPointerType(QualType Pointee, const Type *Cls, QualType CanonicalPtr)
+ MemberPointerType(QualType Pointee, NestedNameSpecifier *Qualifier,
+ QualType CanonicalPtr)
: Type(MemberPointer, CanonicalPtr,
- (Cls->getDependence() & ~TypeDependence::VariablyModified) |
+ (toTypeDependence(Qualifier->getDependence()) &
+ ~TypeDependence::VariablyModified) |
Pointee->getDependence()),
- PointeeType(Pointee), Class(Cls) {}
+ PointeeType(Pointee), Qualifier(Qualifier) {}
public:
QualType getPointeeType() const { return PointeeType; }
@@ -3548,21 +3550,21 @@ class MemberPointerType : public Type, public llvm::FoldingSetNode {
return !PointeeType->isFunctionProtoType();
}
- const Type *getClass() const { return Class; }
+ NestedNameSpecifier *getQualifier() const { return Qualifier; }
CXXRecordDecl *getMostRecentCXXRecordDecl() const;
- bool isSugared() const { return false; }
- QualType desugar() const { return QualType(this, 0); }
+ bool isSugared() const;
+ QualType desugar() const {
+ return isSugared() ? getCanonicalTypeInternal() : QualType(this, 0);
+ }
void Profile(llvm::FoldingSetNodeID &ID) {
- Profile(ID, getPointeeType(), getClass());
+ Profile(ID, getPointeeType(), getQualifier(), getMostRecentCXXRecordDecl());
}
static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee,
- const Type *Class) {
- ID.AddPointer(Pointee.getAsOpaquePtr());
- ID.AddPointer(Class);
- }
+ const NestedNameSpecifier *Qualifier,
+ const CXXRecordDecl *Cls);
static bool classof(const Type *T) {
return T->getTypeClass() == MemberPointer;
diff --git a/clang/include/clang/AST/TypeLoc.h b/clang/include/clang/AST/TypeLoc.h
index a55a38335ef6a..0fca6e522e03b 100644
--- a/clang/include/clang/AST/TypeLoc.h
+++ b/clang/include/clang/AST/TypeLoc.h
@@ -1355,7 +1355,7 @@ class BlockPointerTypeLoc : public PointerLikeTypeLoc<BlockPointerTypeLoc,
};
struct MemberPointerLocInfo : public PointerLikeLocInfo {
- TypeSourceInfo *ClassTInfo;
+ void *QualifierData;
};
/// Wrapper for source info for member pointers.
@@ -1371,28 +1371,32 @@ class MemberPointerTypeLoc : public PointerLikeTypeLoc<MemberPointerTypeLoc,
setSigilLoc(Loc);
}
- const Type *getClass() const {
- return getTypePtr()->getClass();
- }
-
- TypeSourceInfo *getClassTInfo() const {
- return getLocalData()->ClassTInfo;
+ NestedNameSpecifierLoc getQualifierLoc() const {
+ return NestedNameSpecifierLoc(getTypePtr()->getQualifier(),
+ getLocalData()->QualifierData);
}
- void setClassTInfo(TypeSourceInfo* TI) {
- getLocalData()->ClassTInfo = TI;
+ void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc) {
+ assert(QualifierLoc.getNestedNameSpecifier() ==
+ getTypePtr()->getQualifier() &&
+ "Inconsistent nested-name-specifier pointer");
+ getLocalData()->QualifierData = QualifierLoc.getOpaqueData();
}
void initializeLocal(ASTContext &Context, SourceLocation Loc) {
setSigilLoc(Loc);
- setClassTInfo(nullptr);
+ if (auto *Qualifier = getTypePtr()->getQualifier()) {
+ NestedNameSpecifierLocBuilder Builder;
+ Builder.MakeTrivial(Context, Qualifier, Loc);
+ setQualifierLoc(Builder.getWithLocInContext(Context));
+ } else
+ getLocalData()->QualifierData = nullptr;
}
SourceRange getLocalSourceRange() const {
- if (TypeSourceInfo *TI = getClassTInfo())
- return SourceRange(TI->getTypeLoc().getBeginLoc(), getStarLoc());
- else
- return SourceRange(getStarLoc());
+ if (NestedNameSpecifierLoc QL = getQualifierLoc())
+ return SourceRange(QL.getBeginLoc(), getStarLoc());
+ return SourceRange(getStarLoc());
}
};
diff --git a/clang/include/clang/AST/TypeProperties.td b/clang/include/clang/AST/TypeProperties.td
index 6f1a76bd18fb5..27f71bf5cc62f 100644
--- a/clang/include/clang/AST/TypeProperties.td
+++ b/clang/include/clang/AST/TypeProperties.td
@@ -100,12 +100,15 @@ let Class = MemberPointerType in {
def : Property<"pointeeType", QualType> {
let Read = [{ node->getPointeeType() }];
}
- def : Property<"baseType", QualType> {
- let Read = [{ QualType(node->getClass(), 0) }];
+ def : Property<"Qualifier", NestedNameSpecifier> {
+ let Read = [{ node->getQualifier() }];
+ }
+ def : Property<"Cls", DeclRef> {
+ let Read = [{ node->getMostRecentCXXRecordDecl() }];
}
def : Creator<[{
- return ctx.getMemberPointerType(pointeeType, baseType.getTypePtr());
+ return ctx.getMemberPointerType(pointeeType, Qualifier, cast_or_null<CXXRecordDecl>(Cls));
}]>;
}
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index b73ac2933b1ca..5d1806920eb73 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -7047,10 +7047,8 @@ def err_illegal_decl_mempointer_to_reference : Error<
"'%0' declared as a member pointer to a reference of type %1">;
def err_illegal_decl_mempointer_to_void : Error<
"'%0' declared as a member pointer to void">;
-def err_illegal_decl_mempointer_in_nonclass : Error<
- "'%0' does not point into a class">;
-def err_mempointer_in_nonclass_type : Error<
- "member pointer refers into non-class type %0">;
+def err_illegal_decl_mempointer_in_nonclass
+ : Error<"'%0' does not point into a class">;
def err_reference_to_void : Error<"cannot form a reference to 'void'">;
def err_nonfunction_block_type : Error<
"block pointer to non-function type is invalid">;
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index 9a312e1c55f60..f3c66668a2044 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -1348,6 +1348,12 @@ class Sema final : public SemaBase {
unsigned DiagID, bool ForceCheck = false,
bool ForceUnprivileged = false);
+ AccessResult CheckBaseClassAccess(
+ SourceLocation AccessLoc, CXXRecordDecl *Base, CXXRecordDecl *Derived,
+ const CXXBasePath &Path, unsigned DiagID,
+ llvm::function_ref<void(PartialDiagnostic &PD)> SetupPDiag,
+ bool ForceCheck = false, bool ForceUnprivileged = false);
+
/// Checks access to all the declarations in the given result set.
void CheckLookupAccess(const LookupResult &R);
@@ -5740,10 +5746,11 @@ class Sema final : public SemaBase {
/// Determine whether the type \p Derived is a C++ class that is
/// derived from the type \p Base.
+ bool IsDerivedFrom(SourceLocation Loc, CXXRecordDecl *Derived,
+ CXXRecordDecl *Base, CXXBasePaths &Paths);
+ bool IsDerivedFrom(SourceLocation Loc, CXXRecordDecl *Derived,
+ CXXRecordDecl *Base);
bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base);
-
- /// Determine whether the type \p Derived is a C++ class that is
- /// derived from the type \p Base.
bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base,
CXXBasePaths &Paths);
@@ -10026,15 +10033,24 @@ class Sema final : public SemaBase {
bool InOverloadResolution,
QualType &ConvertedType);
+ enum class CheckMemberPointerConversionResult {
+ Success,
+ DifferentPointee,
+ NotDerived,
+ Ambiguous,
+ Virtual,
+ Inaccessible
+ };
+ enum class CheckMemberPointerConversionDirection : bool { Downcast, Upcast };
/// CheckMemberPointerConversion - Check the member pointer conversion from
/// the expression From to the type ToType. This routine checks for ambiguous
/// or virtual or inaccessible base-to-derived member pointer conversions for
- /// which IsMemberPointerConversion has already returned true. It returns true
- /// and produces a diagnostic if there was an error, or returns false
- /// otherwise.
- bool CheckMemberPointerConversion(Expr *From, QualType ToType, CastKind &Kind,
- CXXCastPath &BasePath,
- bool IgnoreBaseAccess);
+ /// which IsMemberPointerConversion has already returned true. It produces a
+ // diagnostic if there was an error.
+ CheckMemberPointerConversionResult CheckMemberPointerConversion(
+ QualType FromType, const MemberPointerType *ToPtrType, CastKind &Kind,
+ CXXCastPath &BasePath, SourceLocation CheckLoc, SourceRange OpRange,
+ bool IgnoreBaseAccess, CheckMemberPointerConversionDirection Direction);
/// IsQualificationConversion - Determines whether the conversion from
/// an rvalue of type FromType to ToType is a qualification conversion
@@ -14845,8 +14861,9 @@ class Sema final : public SemaBase {
///
/// \returns a member pointer type, if successful, or a NULL type if there was
/// an error.
- QualType BuildMemberPointerType(QualType T, QualType Class,
- SourceLocation Loc, DeclarationName Entity);
+ QualType BuildMemberPointerType(QualType T, NestedNameSpecifier *Qualifier,
+ CXXRecordDecl *Cls, SourceLocation Loc,
+ DeclarationName Entity);
/// Build a block pointer type.
///
diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp
index fce1c34897da7..a98e749e025fc 100644
--- a/clang/lib/AST/ASTContext.cpp
+++ b/clang/lib/AST/ASTContext.cpp
@@ -3321,7 +3321,8 @@ static void encodeTypeForFunctionPointerAuth(const ASTContext &Ctx,
case Type::MemberPointer: {
OS << "M";
const auto *MPT = T->castAs<MemberPointerType>();
- encodeTypeForFunctionPointerAuth(Ctx, OS, QualType(MPT->getClass(), 0));
+ encodeTypeForFunctionPointerAuth(
+ Ctx, OS, QualType(MPT->getQualifier()->getAsType(), 0));
encodeTypeForFunctionPointerAuth(Ctx, OS, MPT->getPointeeType());
return;
}
@@ -3510,7 +3511,8 @@ uint16_t ASTContext::getPointerAuthTypeDiscriminator(QualType T) {
if (PointeeType->castAs<FunctionProtoType>()->getExceptionSpecType() !=
EST_None) {
QualType FT = getFunctionTypeWithExceptionSpec(PointeeType, EST_None);
- T = getMemberPointerType(FT, MPT->getClass());
+ T = getMemberPointerType(FT, MPT->getQualifier(),
+ MPT->getMostRecentCXXRecordDecl());
}
}
std::unique_ptr<MangleContext> MC(createMangleContext());
@@ -4024,32 +4026,50 @@ QualType ASTContext::getRValueReferenceType(QualType T) const {
return QualType(New, 0);
}
-/// getMemberPointerType - Return the uniqued reference to the type for a
-/// member pointer to the specified type, in the specified class.
-QualType ASTContext::getMemberPointerType(QualType T, const Type *Cls) const {
+QualType ASTContext::getMemberPointerType(QualType T,
+ NestedNameSpecifier *Qualifier,
+ const CXXRecordDecl *Cls) const {
+ if (!Qualifier) {
+ assert(Cls && "At least one of Qualifier or Cls must be provided");
+ Qualifier = NestedNameSpecifier::Create(*this, /*Prefix=*/nullptr,
+ /*Template=*/false,
+ getTypeDeclType(Cls).getTypePtr());
+ } else if (!Cls) {
+ Cls = Qualifier->getAsRecordDecl();
+ }
// Unique pointers, to guarantee there is only one pointer of a particular
// structure.
llvm::FoldingSetNodeID ID;
- MemberPointerType::Profile(ID, T, Cls);
+ MemberPointerType::Profile(ID, T, Qualifier, Cls);
void *InsertPos = nullptr;
if (MemberPointerType *PT =
MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
return QualType(PT, 0);
+ NestedNameSpecifier *CanonicalQualifier = [&] {
+ if (!Cls)
+ return getCanonicalNestedNameSpecifier(Qualifier);
+ NestedNameSpecifier *R = NestedNameSpecifier::Create(
+ *this, /*Prefix=*/nullptr, /*Template=*/false,
+ Cls->getCanonicalDecl()->getTypeForDecl());
+ assert(R == getCanonicalNestedNameSpecifier(R));
+ return R;
+ }();
// If the pointee or class type isn't canonical, this won't be a canonical
// type either, so fill in the canonical type field.
QualType Canonical;
- if (!T.isCanonical() || !Cls->isCanonicalUnqualified()) {
- Canonical = getMemberPointerType(getCanonicalType(T),getCanonicalType(Cls));
-
+ if (!T.isCanonical() || Qualifier != CanonicalQualifier) {
+ Canonical =
+ getMemberPointerType(getCanonicalType(T), CanonicalQualifier, Cls);
+ assert(!cast<MemberPointerType>(Canonical)->isSugared());
// Get the new insert position for the node we care about.
- MemberPointerType *NewIP =
- MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
- assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
+ [[maybe_unused]] MemberPointerType *NewIP =
+ MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
+ assert(!NewIP && "Shouldn't be in the map!");
}
auto *New = new (*this, alignof(MemberPointerType))
- MemberPointerType(T, Cls, Canonical);
+ MemberPointerType(T, Qualifier, Canonical);
Types.push_back(New);
MemberPointerTypes.InsertNode(New, InsertPos);
return QualType(New, 0);
@@ -6811,11 +6831,16 @@ bool ASTContext::UnwrapSimilarTypes(QualType &T1, QualType &T2,
return true;
}
- const auto *T1MPType = T1->getAs<MemberPointerType>();
- const auto *T2MPType = T2->getAs<MemberPointerType>();
- if (T1MPType && T2MPType &&
- hasSameUnqualifiedType(QualType(T1MPType->getClass(), 0),
- QualType(T2MPType->getClass(), 0))) {
+ if (const auto *T1MPType = T1->getAs<MemberPointerType>(),
+ *T2MPType = T2->getAs<MemberPointerType>();
+ T1MPType && T2MPType) {
+ if (auto *RD1 = T1MPType->getMostRecentCXXRecordDecl(),
+ *RD2 = T2MPType->getMostRecentCXXRecordDecl();
+ RD1 != RD2 && RD1->getCanonicalDecl() != RD2->getCanonicalDecl())
+ return false;
+ if (getCanonicalNestedNameSpecifier(T1MPType->getQualifier()) !=
+ getCanonicalNestedNameSpecifier(T2MPType->getQualifier()))
+ return false;
T1 = T1MPType->getPointeeType();
T2 = T2MPType->getPointeeType();
return true;
@@ -13461,13 +13486,112 @@ static ElaboratedTypeKeyword getCommonTypeKeyword(const T *X, const T *Y) {
: ElaboratedTypeKeyword::None;
}
+static NestedNameSpecifier *getCommonNNS(ASTContext &Ctx,
+ NestedNameSpecifier *X,
+ NestedNameSpecifier *Y, bool Sugar) {
+ if (X == Y)
+ return X;
+
+ NestedNameSpecifier *Canon = Ctx.getCanonicalNestedNameSpecifier(X);
+ if (Canon != Ctx.getCanonicalNestedNameSpecifier(Y)) {
+ if (Sugar)
+ return nullptr;
+ llvm_unreachable("Should be the same NestedNameSpecifier");
+ }
+
+ NestedNameSpecifier *R;
+ switch (auto KX = X->getKind(), KY = Y->getKind(); KX) {
+ case NestedNameSpecifier::SpecifierKind::Identifier: {
+ assert(KY == NestedNameSpecifier::SpecifierKind::Identifier);
+ IdentifierInfo *II = X->getAsIdentifier();
+ assert(II == Y->getAsIdentifier());
+ NestedNameSpecifier *P =
+ ::getCommonNNS(Ctx, X->getPrefix(), Y->getPrefix(), /*Sugar=*/false);
+ R = NestedNameSpecifier::Create(Ctx, P, II);
+ break;
+ }
+ case NestedNameSpecifier::SpecifierKind::Namespace:
+ case NestedNameSpecifier::SpecifierKind::NamespaceAlias: {
+ assert(KY == NestedNameSpecifier::SpecifierKind::Namespace ||
+ KY == NestedNameSpecifier::SpecifierKind::NamespaceAlias);
+ NestedNameSpecifier *P = ::getCommonNNS(Ctx, X->getPrefix(), Y->getPrefix(),
+ /*Sugar=*/true);
+ NamespaceAliasDecl *AX = X->getAsNamespaceAlias(),
+ *AY = Y->getAsNamespaceAlias();
+ if (declaresSameEntity(AX, AY)) {
+ R = NestedNameSpecifier::Create(Ctx, P, ::getCommonDeclChecked(AX, AY));
+ break;
+ }
+ NamespaceDecl *NX = AX ? AX->getNamespace() : X->getAsNamespace(),
+ *NY = AY ? AY->getNamespace() : Y->getAsNamespace();
+ R = NestedNameSpecifier::Create(Ctx, P, ::getCommonDeclChecked(NX, NY));
+ break;
+ }
+ case NestedNameSpecifier::SpecifierKind::TypeSpec:
+ case NestedNameSpecifier::SpecifierKind::TypeSpecWithTemplate: {
+ assert(KY == NestedNameSpecifier::SpecifierKind::TypeSpec ||
+ KY == NestedNameSpecifier::SpecifierKind::TypeSpecWithTemplate);
+ bool Template =
+ KX == NestedNameSpecifier::SpecifierKind::TypeSpecWithTemplate &&
+ KY == NestedNameSpecifier::SpecifierKind::TypeSpecWithTemplate;
+
+ const Type *TX = X->getAsType(), *TY = Y->getAsType();
+ if (TX == TY) {
+ NestedNameSpecifier *P =
+ ::getCommonNNS(Ctx, X->getPrefix(), Y->getPrefix(),
+ /*Sugar=*/true);
+ R = NestedNameSpecifier::Create(Ctx, P, Template, TX);
+ break;
+ }
+ // TODO: Try to salvage the original prefix.
+ // If getCommonSugaredType removed any top level sugar, the original prefix
+ // is not applicable anymore.
+ NestedNameSpecifier *P = nullptr;
+ const Type *T = Ctx.getCommonSugaredType(QualType(X->getAsType(), 0),
+ QualType(Y->getAsType(), 0),
+ /*Unqualified=*/true)
+ .getTypePtr();
+ switch (T->getTypeClass()) {
+ case Type::Elaborated: {
+ auto *ET = cast<ElaboratedType>(T);
+ R = NestedNameSpecifier::Create(Ctx, ET->getQualifier(), Template,
+ ET->getNamedType().getTypePtr());
+ break;
+ }
+ case Type::DependentName: {
+ auto *DN = cast<DependentNameType>(T);
+ R = NestedNameSpecifier::Create(Ctx, DN->getQualifier(),
+ DN->getIdentifier());
+ break;
+ }
+ case Type::DependentTemplateSpecialization: {
+ auto *DTST = cast<DependentTemplateSpecializationType>(T);
+ T = Ctx.getDependentTemplateSpecializationType(
+ DTST->getKeyword(), /*NNS=*/nullptr, DTST->getIdentifier(),
+ DTST->template_arguments())
+ .getTypePtr();
+ P = DTST->getQualifier();
+ R = NestedNameSpecifier::Create(Ctx, DTST->getQualifier(), Template, T);
+ break;
+ }
+ default:
+ R = NestedNameSpecifier::Create(Ctx, P, Template, T);
+ break;
+ }
+ break;
+ }
+ case NestedNameSpecifier::SpecifierKind::Global:
+ case NestedNameSpecifier::SpecifierKind::Super:
+ return X;
+ }
+ assert(Ctx.getCanonicalNestedNameSpecifier(R) == Canon);
+ return R;
+}
+
template <class T>
static NestedNameSpecifier *getCommonNNS(ASTContext &Ctx, const T *X,
- const T *Y) {
- // FIXME: Try to keep the common NNS sugar.
- return X->getQualifier() == Y->getQualifier()
- ? X->getQualifier()
- : Ctx.getCanonicalNestedNameSpecifier(X->getQualifier());
+ const T *Y, bool Sugar) {
+ return ::getCommonNNS(Ctx, X->getQualifier(), Y->getQualifier(), Sugar);
}
template <class T>
@@ -13714,11 +13838,11 @@ static QualType getCommonNonSugarTypeNode(ASTContext &Ctx, const Type *X,
case Type::MemberPointer: {
const auto *PX = cast<MemberPointerType>(X),
*PY = cast<MemberPointerType>(Y);
- return Ctx.getMemberPointerType(
- getCommonPointeeType(Ctx, PX, PY),
- Ctx.getCommonSugaredType(QualType(PX->getClass(), 0),
- QualType(PY->getClass(), 0))
- .getTypePtr());
+ assert(declaresSameEntity(PX->getMostRecentCXXRecordDecl(),
+ PY->getMostRecentCXXRecordDecl()));
+ return Ctx.getMemberPointerType(getCommonPointeeType(Ctx, PX, PY),
+ getCommonNNS(Ctx, PX, PY, /*Sugar=*/false),
+ PX->getMostRecentCXXRecordDecl());
}
case Type::LValueReference: {
const auto *PX = cast<LValueReferenceType>(X),
@@ -13877,9 +14001,10 @@ static QualType getCommonNonSugarTypeNode(ASTContext &Ctx, const Type *X,
const auto *NX = cast<DependentNameType>(X),
*NY = cast<DependentNameType>(Y);
assert(NX->getIdentifier() == NY->getIdentifier());
- return Ctx.getDependentNameType(
- getCommonTypeKeyword(NX, NY), getCommonNNS(Ctx, NX, NY),
- NX->getIdentifier(), NX->getCanonicalTypeInternal());
+ return Ctx.getDependentNameType(getCommonTypeKeyword(NX, NY),
+ getCommonNNS(Ctx, NX, NY, /*Sugar=*/false),
+ NX->getIdentifier(),
+ NX->getCanonicalTypeInternal());
}
case Type::DependentTemplateSpecialization: {
const auto *TX = cast<DependentTemplateSpecializationType>(X),
@@ -13888,8 +14013,8 @@ static QualType getCommonNonSugarTypeNode(ASTContext &Ctx, const Type *X,
auto As = getCommonTemplateArguments(Ctx, TX->template_arguments(),
TY->template_arguments());
return Ctx.getDependentTemplateSpecializationType(
- getCommonTypeKeyword(TX, TY), getCommonNNS(Ctx, TX, TY),
- TX->getIdentifier(), As);
+ getCommonTypeKeyword(TX, TY),
+ getCommonNNS(Ctx, TX, TY, /*Sugar=*/false), TX->getIdentifier(), As);
}
case Type::UnaryTransform: {
const auto *TX = cast<UnaryTransformType>(X),
@@ -14046,7 +14171,8 @@ static QualType getCommonSugarTypeNode(ASTContext &Ctx, const Type *X,
case Type::Elaborated: {
const auto *EX = cast<ElaboratedType>(X), *EY = cast<ElaboratedType>(Y);
return Ctx.getElaboratedType(
- ::getCommonTypeKeyword(EX, EY), ::getCommonNNS(Ctx, EX, EY),
+ ::getCommonTypeKeyword(EX, EY),
+ ::getCommonNNS(Ctx, EX, EY, /*Sugar=*/true),
Ctx.getQualifiedType(Underlying),
::getCommonDecl(EX->getOwnedTagDecl(), EY->getOwnedTagDecl()));
}
diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp
index 82180486f3c7c..7737a8d9fcbc4 100644
--- a/clang/lib/AST/ASTImporter.cpp
+++ b/clang/lib/AST/ASTImporter.cpp
@@ -1244,12 +1244,16 @@ ASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) {
if (!ToPointeeTypeOrErr)
return ToPointeeTypeOrErr.takeError();
- ExpectedTypePtr ClassTypeOrErr = import(T->getClass());
- if (!ClassTypeOrErr)
- return ClassTypeOrErr.takeError();
+ auto QualifierOrErr = import(T->getQualifier());
+ if (!QualifierOrErr)
+ return QualifierOrErr.takeError();
- return Importer.getToContext().getMemberPointerType(*ToPointeeTypeOrErr,
- *ClassTypeOrErr);
+ auto ClsOrErr = import(T->getMostRecentCXXRecordDecl());
+ if (!ClsOrErr)
+ return ClsOrErr.takeError();
+
+ return Importer.getToContext().getMemberPointerType(
+ *ToPointeeTypeOrErr, *QualifierOrErr, *ClsOrErr);
}
ExpectedType
diff --git a/clang/lib/AST/ASTStructuralEquivalence.cpp b/clang/lib/AST/ASTStructuralEquivalence.cpp
index b74f67f0a9fed..abbab03a6eceb 100644
--- a/clang/lib/AST/ASTStructuralEquivalence.cpp
+++ b/clang/lib/AST/ASTStructuralEquivalence.cpp
@@ -894,8 +894,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
if (!IsStructurallyEquivalent(Context, MemPtr1->getPointeeType(),
MemPtr2->getPointeeType()))
return false;
- if (!IsStructurallyEquivalent(Context, QualType(MemPtr1->getClass(), 0),
- QualType(MemPtr2->getClass(), 0)))
+ if (!IsStructurallyEquivalent(Context, MemPtr1->getQualifier(),
+ MemPtr2->getQualifier()))
return false;
break;
}
diff --git a/clang/lib/AST/ByteCode/Compiler.cpp b/clang/lib/AST/ByteCode/Compiler.cpp
index 13b8a3b47add6..53772de2f7520 100644
--- a/clang/lib/AST/ByteCode/Compiler.cpp
+++ b/clang/lib/AST/ByteCode/Compiler.cpp
@@ -238,8 +238,9 @@ bool Compiler<Emitter>::VisitCastExpr(const CastExpr *CE) {
const auto *FromMP = SubExpr->getType()->getAs<MemberPointerType>();
const auto *ToMP = CE->getType()->getAs<MemberPointerType>();
- unsigned DerivedOffset = collectBaseOffset(QualType(ToMP->getClass(), 0),
- QualType(FromMP->getClass(), 0));
+ unsigned DerivedOffset =
+ Ctx.collectBaseOffset(ToMP->getMostRecentCXXRecordDecl(),
+ FromMP->getMostRecentCXXRecordDecl());
if (!this->delegate(SubExpr))
return false;
@@ -253,8 +254,9 @@ bool Compiler<Emitter>::VisitCastExpr(const CastExpr *CE) {
const auto *FromMP = SubExpr->getType()->getAs<MemberPointerType>();
const auto *ToMP = CE->getType()->getAs<MemberPointerType>();
- unsigned DerivedOffset = collectBaseOffset(QualType(FromMP->getClass(), 0),
- QualType(ToMP->getClass(), 0));
+ unsigned DerivedOffset =
+ Ctx.collectBaseOffset(FromMP->getMostRecentCXXRecordDecl(),
+ ToMP->getMostRecentCXXRecordDecl());
if (!this->delegate(SubExpr))
return false;
diff --git a/clang/lib/AST/ExprConstant.cpp b/clang/lib/AST/ExprConstant.cpp
index 4649cd79371f4..d6bdfc754fa80 100644
--- a/clang/lib/AST/ExprConstant.cpp
+++ b/clang/lib/AST/ExprConstant.cpp
@@ -10517,8 +10517,9 @@ bool MemberPointerExprEvaluator::VisitCastExpr(const CastExpr *E) {
if (!Result.castToDerived(Derived))
return Error(E);
}
- const Type *FinalTy = E->getType()->castAs<MemberPointerType>()->getClass();
- if (!Result.castToDerived(FinalTy->getAsCXXRecordDecl()))
+ if (!Result.castToDerived(E->getType()
+ ->castAs<MemberPointerType>()
+ ->getMostRecentCXXRecordDecl()))
return Error(E);
return true;
}
diff --git a/clang/lib/AST/ItaniumMangle.cpp b/clang/lib/AST/ItaniumMangle.cpp
index b80dd1c86092f..af32071edaa27 100644
--- a/clang/lib/AST/ItaniumMangle.cpp
+++ b/clang/lib/AST/ItaniumMangle.cpp
@@ -3828,7 +3828,16 @@ void CXXNameMangler::mangleType(const IncompleteArrayType *T) {
// <pointer-to-member-type> ::= M <class type> <member type>
void CXXNameMangler::mangleType(const MemberPointerType *T) {
Out << 'M';
- mangleType(QualType(T->getClass(), 0));
+ if (auto *RD = T->getMostRecentCXXRecordDecl()) {
+ mangleCXXRecordDecl(RD);
+ } else {
+ NestedNameSpecifier *NNS = T->getQualifier();
+ if (auto *II = NNS->getAsIdentifier())
+ mangleType(getASTContext().getDependentNameType(
+ ElaboratedTypeKeyword::None, NNS->getPrefix(), II));
+ else
+ mangleType(QualType(NNS->getAsType(), 0));
+ }
QualType PointeeType = T->getPointeeType();
if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(PointeeType)) {
mangleType(FPT);
diff --git a/clang/lib/AST/MicrosoftMangle.cpp b/clang/lib/AST/MicrosoftMangle.cpp
index 6e2be2557d0a7..7e964124a9fec 100644
--- a/clang/lib/AST/MicrosoftMangle.cpp
+++ b/clang/lib/AST/MicrosoftMangle.cpp
@@ -695,7 +695,7 @@ void MicrosoftCXXNameMangler::mangleVariableEncoding(const VarDecl *VD) {
mangleQualifiers(MPT->getPointeeType().getQualifiers(), true);
// Member pointers are suffixed with a back reference to the member
// pointer's class name.
- mangleName(MPT->getClass()->getAsCXXRecordDecl());
+ mangleName(MPT->getMostRecentCXXRecordDecl());
} else
mangleQualifiers(Ty->getPointeeType().getQualifiers(), false);
} else if (const ArrayType *AT = getASTContext().getAsArrayType(Ty)) {
@@ -3335,11 +3335,11 @@ void MicrosoftCXXNameMangler::mangleType(const MemberPointerType *T,
manglePointerExtQualifiers(Quals, PointeeType);
if (const FunctionProtoType *FPT = PointeeType->getAs<FunctionProtoType>()) {
Out << '8';
- mangleName(T->getClass()->castAs<RecordType>()->getDecl());
+ mangleName(T->getMostRecentCXXRecordDecl());
mangleFunctionType(FPT, nullptr, true);
} else {
mangleQualifiers(PointeeType.getQualifiers(), true);
- mangleName(T->getClass()->castAs<RecordType>()->getDecl());
+ mangleName(T->getMostRecentCXXRecordDecl());
mangleType(PointeeType, Range, QMM_Drop);
}
}
@@ -4313,11 +4313,11 @@ void MicrosoftCXXNameMangler::mangleAutoReturnType(const MemberPointerType *T,
manglePointerExtQualifiers(Quals, PointeeType);
if (const FunctionProtoType *FPT = PointeeType->getAs<FunctionProtoType>()) {
Out << '8';
- mangleName(T->getClass()->castAs<RecordType>()->getDecl());
+ mangleName(T->getMostRecentCXXRecordDecl());
mangleFunctionType(FPT, nullptr, true);
} else {
mangleQualifiers(PointeeType.getQualifiers(), true);
- mangleName(T->getClass()->castAs<RecordType>()->getDecl());
+ mangleName(T->getMostRecentCXXRecordDecl());
mangleAutoReturnType(PointeeType, QMM_Drop);
}
}
diff --git a/clang/lib/AST/NestedNameSpecifier.cpp b/clang/lib/AST/NestedNameSpecifier.cpp
index 593f2fcc0159c..a256a87695afc 100644
--- a/clang/lib/AST/NestedNameSpecifier.cpp
+++ b/clang/lib/AST/NestedNameSpecifier.cpp
@@ -297,6 +297,7 @@ void NestedNameSpecifier::print(raw_ostream &OS, const PrintingPolicy &Policy,
PrintingPolicy InnerPolicy(Policy);
InnerPolicy.SuppressScope = true;
+ InnerPolicy.SuppressTagKeyword = true;
// Nested-name-specifiers are intended to contain minimally-qualified
// types. An actual ElaboratedType will not occur, since we'll store
diff --git a/clang/lib/AST/ODRHash.cpp b/clang/lib/AST/ODRHash.cpp
index 7c5c287e6c15b..4c428cce32475 100644
--- a/clang/lib/AST/ODRHash.cpp
+++ b/clang/lib/AST/ODRHash.cpp
@@ -1076,7 +1076,7 @@ class ODRTypeVisitor : public TypeVisitor<ODRTypeVisitor> {
void VisitMemberPointerType(const MemberPointerType *T) {
AddQualType(T->getPointeeType());
- AddType(T->getClass());
+ AddNestedNameSpecifier(T->getQualifier());
VisitType(T);
}
diff --git a/clang/lib/AST/QualTypeNames.cpp b/clang/lib/AST/QualTypeNames.cpp
index e4d2a6937f6eb..3c814b777f8ab 100644
--- a/clang/lib/AST/QualTypeNames.cpp
+++ b/clang/lib/AST/QualTypeNames.cpp
@@ -391,9 +391,10 @@ QualType getFullyQualifiedType(QualType QT, const ASTContext &Ctx,
Qualifiers Quals = QT.getQualifiers();
// Fully qualify the pointee and class types.
QT = getFullyQualifiedType(QT->getPointeeType(), Ctx, WithGlobalNsPrefix);
- QualType Class = getFullyQualifiedType(QualType(MPT->getClass(), 0), Ctx,
- WithGlobalNsPrefix);
- QT = Ctx.getMemberPointerType(QT, Class.getTypePtr());
+ NestedNameSpecifier *Qualifier = getFullyQualifiedNestedNameSpecifier(
+ Ctx, MPT->getQualifier(), WithGlobalNsPrefix);
+ QT = Ctx.getMemberPointerType(QT, Qualifier,
+ MPT->getMostRecentCXXRecordDecl());
// Add back the qualifiers.
QT = Ctx.getQualifiedType(QT, Quals);
return QT;
diff --git a/clang/lib/AST/Type.cpp b/clang/lib/AST/Type.cpp
index 2fd7f5800594a..9ed2aeaae0e5e 100644
--- a/clang/lib/AST/Type.cpp
+++ b/clang/lib/AST/Type.cpp
@@ -1062,7 +1062,8 @@ struct SimpleTransformVisitor : public TypeVisitor<Derived, QualType> {
if (pointeeType.getAsOpaquePtr() == T->getPointeeType().getAsOpaquePtr())
return QualType(T, 0);
- return Ctx.getMemberPointerType(pointeeType, T->getClass());
+ return Ctx.getMemberPointerType(pointeeType, T->getQualifier(),
+ T->getMostRecentCXXRecordDecl());
}
QualType VisitConstantArrayType(const ConstantArrayType *T) {
@@ -2440,19 +2441,17 @@ bool Type::isIncompleteType(NamedDecl **Def) const {
// Member pointers in the MS ABI have special behavior in
// RequireCompleteType: they attach a MSInheritanceAttr to the CXXRecordDecl
// to indicate which inheritance model to use.
- auto *MPTy = cast<MemberPointerType>(CanonicalType);
- const Type *ClassTy = MPTy->getClass();
+ // The inheritance attribute might only be present on the most recent
+ // CXXRecordDecl.
+ const CXXRecordDecl *RD =
+ cast<MemberPointerType>(CanonicalType)->getMostRecentCXXRecordDecl();
// Member pointers with dependent class types don't get special treatment.
- if (ClassTy->isDependentType())
+ if (!RD)
return false;
- const CXXRecordDecl *RD = ClassTy->getAsCXXRecordDecl();
ASTContext &Context = RD->getASTContext();
// Member pointers not in the MS ABI don't get special treatment.
if (!Context.getTargetInfo().getCXXABI().isMicrosoft())
return false;
- // The inheritance attribute might only be present on the most recent
- // CXXRecordDecl, use that one.
- RD = RD->getMostRecentNonInjectedDecl();
// Nothing interesting to do if the inheritance attribute is already set.
if (RD->hasAttr<MSInheritanceAttr>())
return false;
@@ -4617,8 +4616,15 @@ static CachedProperties computeCachedProperties(const Type *T) {
return Cache::get(cast<ReferenceType>(T)->getPointeeType());
case Type::MemberPointer: {
const auto *MPT = cast<MemberPointerType>(T);
- return merge(Cache::get(MPT->getClass()),
- Cache::get(MPT->getPointeeType()));
+ CachedProperties Cls = [&] {
+ if (auto *RD = MPT->getMostRecentCXXRecordDecl())
+ return Cache::get(QualType(RD->getTypeForDecl(), 0));
+ if (const Type *T = MPT->getQualifier()->getAsType())
+ return Cache::get(T);
+ // Treat as a dependent type.
+ return CachedProperties(Linkage::External, false);
+ }();
+ return merge(Cls, Cache::get(MPT->getPointeeType()));
}
case Type::ConstantArray:
case Type::IncompleteArray:
@@ -4707,7 +4713,8 @@ LinkageInfo LinkageComputer::computeTypeLinkageInfo(const Type *T) {
return computeTypeLinkageInfo(cast<ReferenceType>(T)->getPointeeType());
case Type::MemberPointer: {
const auto *MPT = cast<MemberPointerType>(T);
- LinkageInfo LV = computeTypeLinkageInfo(MPT->getClass());
+ LinkageInfo LV =
+ getDeclLinkageAndVisibility(MPT->getMostRecentCXXRecordDecl());
LV.merge(computeTypeLinkageInfo(MPT->getPointeeType()));
return LV;
}
@@ -5172,8 +5179,28 @@ QualType::DestructionKind QualType::isDestructedTypeImpl(QualType type) {
return DK_none;
}
+bool MemberPointerType::isSugared() const {
+ CXXRecordDecl *D1 = getMostRecentCXXRecordDecl(),
+ *D2 = getQualifier()->getAsRecordDecl();
+ return D1 != D2 && D1->getCanonicalDecl() != D2->getCanonicalDecl();
+}
+
+void MemberPointerType::Profile(llvm::FoldingSetNodeID &ID, QualType Pointee,
+ const NestedNameSpecifier *Qualifier,
+ const CXXRecordDecl *Cls) {
+ ID.AddPointer(Pointee.getAsOpaquePtr());
+ ID.AddPointer(Qualifier);
+ if (Cls)
+ ID.AddPointer(Cls->getCanonicalDecl());
+}
+
CXXRecordDecl *MemberPointerType::getMostRecentCXXRecordDecl() const {
- return getClass()->getAsCXXRecordDecl()->getMostRecentNonInjectedDecl();
+ auto *RD = dyn_cast<MemberPointerType>(getCanonicalTypeInternal())
+ ->getQualifier()
+ ->getAsRecordDecl();
+ if (!RD)
+ return nullptr;
+ return RD->getMostRecentNonInjectedDecl();
}
void clang::FixedPointValueToString(SmallVectorImpl<char> &Str,
diff --git a/clang/lib/AST/TypePrinter.cpp b/clang/lib/AST/TypePrinter.cpp
index dfd1959bbdcb0..3982ca3b50604 100644
--- a/clang/lib/AST/TypePrinter.cpp
+++ b/clang/lib/AST/TypePrinter.cpp
@@ -505,9 +505,9 @@ void TypePrinter::printMemberPointerBefore(const MemberPointerType *T,
PrintingPolicy InnerPolicy(Policy);
InnerPolicy.IncludeTagDefinition = false;
- TypePrinter(InnerPolicy).print(QualType(T->getClass(), 0), OS, StringRef());
+ T->getQualifier()->print(OS, InnerPolicy);
- OS << "::*";
+ OS << "*";
}
void TypePrinter::printMemberPointerAfter(const MemberPointerType *T,
diff --git a/clang/lib/CodeGen/CGCXXABI.cpp b/clang/lib/CodeGen/CGCXXABI.cpp
index e109fd0c443f6..9f77fbec21380 100644
--- a/clang/lib/CodeGen/CGCXXABI.cpp
+++ b/clang/lib/CodeGen/CGCXXABI.cpp
@@ -50,8 +50,7 @@ CGCallee CGCXXABI::EmitLoadOfMemberFunctionPointer(
llvm::Value *MemPtr, const MemberPointerType *MPT) {
ErrorUnsupportedABI(CGF, "calls through member pointers");
- const auto *RD =
- cast<CXXRecordDecl>(MPT->getClass()->castAs<RecordType>()->getDecl());
+ const auto *RD = MPT->getMostRecentCXXRecordDecl();
ThisPtrForCall =
CGF.getAsNaturalPointerTo(This, CGF.getContext().getRecordType(RD));
const FunctionProtoType *FPT =
@@ -108,7 +107,7 @@ CGCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) {
llvm::Constant *CGCXXABI::EmitMemberFunctionPointer(const CXXMethodDecl *MD) {
return GetBogusMemberPointer(CGM.getContext().getMemberPointerType(
- MD->getType(), MD->getParent()->getTypeForDecl()));
+ MD->getType(), /*Qualifier=*/nullptr, MD->getParent()));
}
llvm::Constant *CGCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT,
@@ -308,7 +307,7 @@ llvm::Constant *CGCXXABI::getMemberPointerAdjustment(const CastExpr *E) {
derivedType = E->getType();
const CXXRecordDecl *derivedClass =
- derivedType->castAs<MemberPointerType>()->getClass()->getAsCXXRecordDecl();
+ derivedType->castAs<MemberPointerType>()->getMostRecentCXXRecordDecl();
return CGM.GetNonVirtualBaseClassOffset(derivedClass,
E->path_begin(),
diff --git a/clang/lib/CodeGen/CGClass.cpp b/clang/lib/CodeGen/CGClass.cpp
index e54fd543f217b..f508930cc9f2b 100644
--- a/clang/lib/CodeGen/CGClass.cpp
+++ b/clang/lib/CodeGen/CGClass.cpp
@@ -161,10 +161,9 @@ CodeGenFunction::EmitCXXMemberDataPointerAddress(const Expr *E, Address base,
QualType memberType = memberPtrType->getPointeeType();
CharUnits memberAlign =
CGM.getNaturalTypeAlignment(memberType, BaseInfo, TBAAInfo);
- memberAlign =
- CGM.getDynamicOffsetAlignment(base.getAlignment(),
- memberPtrType->getClass()->getAsCXXRecordDecl(),
- memberAlign);
+ memberAlign = CGM.getDynamicOffsetAlignment(
+ base.getAlignment(), memberPtrType->getMostRecentCXXRecordDecl(),
+ memberAlign);
return Address(ptr, ConvertTypeForMem(memberPtrType->getPointeeType()),
memberAlign);
}
diff --git a/clang/lib/CodeGen/CGDebugInfo.cpp b/clang/lib/CodeGen/CGDebugInfo.cpp
index 0e6daa42ee7bf..f55101b03aefb 100644
--- a/clang/lib/CodeGen/CGDebugInfo.cpp
+++ b/clang/lib/CodeGen/CGDebugInfo.cpp
@@ -3491,7 +3491,8 @@ llvm::DIType *CGDebugInfo::CreateType(const MemberPointerType *Ty,
}
}
- llvm::DIType *ClassType = getOrCreateType(QualType(Ty->getClass(), 0), U);
+ llvm::DIType *ClassType = getOrCreateType(
+ QualType(Ty->getMostRecentCXXRecordDecl()->getTypeForDecl(), 0), U);
if (Ty->isMemberDataPointerType())
return DBuilder.createMemberPointerType(
getOrCreateType(Ty->getPointeeType(), U), ClassType, Size, /*Align=*/0,
diff --git a/clang/lib/CodeGen/CGExprCXX.cpp b/clang/lib/CodeGen/CGExprCXX.cpp
index d4e14f4574b87..5c11c0bceade7 100644
--- a/clang/lib/CodeGen/CGExprCXX.cpp
+++ b/clang/lib/CodeGen/CGExprCXX.cpp
@@ -453,8 +453,7 @@ CodeGenFunction::EmitCXXMemberPointerCallExpr(const CXXMemberCallExpr *E,
const auto *MPT = MemFnExpr->getType()->castAs<MemberPointerType>();
const auto *FPT = MPT->getPointeeType()->castAs<FunctionProtoType>();
- const auto *RD =
- cast<CXXRecordDecl>(MPT->getClass()->castAs<RecordType>()->getDecl());
+ const auto *RD = MPT->getMostRecentCXXRecordDecl();
// Emit the 'this' pointer.
Address This = Address::invalid();
@@ -463,8 +462,9 @@ CodeGenFunction::EmitCXXMemberPointerCallExpr(const CXXMemberCallExpr *E,
else
This = EmitLValue(BaseExpr, KnownNonNull).getAddress();
- EmitTypeCheck(TCK_MemberCall, E->getExprLoc(), This.emitRawPointer(*this),
- QualType(MPT->getClass(), 0));
+ EmitTypeCheck(
+ TCK_MemberCall, E->getExprLoc(), This.emitRawPointer(*this),
+ QualType(MPT->getMostRecentCXXRecordDecl()->getTypeForDecl(), 0));
// Get the member function pointer.
llvm::Value *MemFnPtr = EmitScalarExpr(MemFnExpr);
diff --git a/clang/lib/CodeGen/CGPointerAuth.cpp b/clang/lib/CodeGen/CGPointerAuth.cpp
index 0c63b9d6bb7e7..4b032306ead72 100644
--- a/clang/lib/CodeGen/CGPointerAuth.cpp
+++ b/clang/lib/CodeGen/CGPointerAuth.cpp
@@ -394,8 +394,8 @@ llvm::Constant *CodeGenModule::getMemberFunctionPointer(llvm::Constant *Pointer,
llvm::Constant *CodeGenModule::getMemberFunctionPointer(const FunctionDecl *FD,
llvm::Type *Ty) {
QualType FT = FD->getType();
- FT = getContext().getMemberPointerType(
- FT, cast<CXXMethodDecl>(FD)->getParent()->getTypeForDecl());
+ FT = getContext().getMemberPointerType(FT, /*Qualifier=*/nullptr,
+ cast<CXXMethodDecl>(FD)->getParent());
return getMemberFunctionPointer(getRawFunctionPointer(FD, Ty), FT);
}
diff --git a/clang/lib/CodeGen/CGVTables.cpp b/clang/lib/CodeGen/CGVTables.cpp
index 66d75efa0a9a0..dcd1fa77fa834 100644
--- a/clang/lib/CodeGen/CGVTables.cpp
+++ b/clang/lib/CodeGen/CGVTables.cpp
@@ -1401,9 +1401,8 @@ void CodeGenModule::EmitVTableTypeMetadata(const CXXRecordDecl *RD,
if (Comps[I].getKind() != VTableComponent::CK_FunctionPointer)
continue;
llvm::Metadata *MD = CreateMetadataIdentifierForVirtualMemPtrType(
- Context.getMemberPointerType(
- Comps[I].getFunctionDecl()->getType(),
- Context.getRecordType(AP.Base).getTypePtr()));
+ Context.getMemberPointerType(Comps[I].getFunctionDecl()->getType(),
+ /*Qualifier=*/nullptr, AP.Base));
VTable->addTypeMetadata((ComponentWidth * I).getQuantity(), MD);
}
}
diff --git a/clang/lib/CodeGen/CodeGenModule.cpp b/clang/lib/CodeGen/CodeGenModule.cpp
index 1f6321a5908e6..9f8407e9a3fd7 100644
--- a/clang/lib/CodeGen/CodeGenModule.cpp
+++ b/clang/lib/CodeGen/CodeGenModule.cpp
@@ -2667,7 +2667,7 @@ void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D,
for (const CXXRecordDecl *Base : getMostBaseClasses(MD->getParent())) {
llvm::Metadata *Id =
CreateMetadataIdentifierForType(Context.getMemberPointerType(
- MD->getType(), Context.getRecordType(Base).getTypePtr()));
+ MD->getType(), /*Qualifier=*/nullptr, Base));
F->addTypeMetadata(0, Id);
}
}
diff --git a/clang/lib/CodeGen/CodeGenTypes.cpp b/clang/lib/CodeGen/CodeGenTypes.cpp
index bd625052cb5ed..1c4b0751cdc9e 100644
--- a/clang/lib/CodeGen/CodeGenTypes.cpp
+++ b/clang/lib/CodeGen/CodeGenTypes.cpp
@@ -722,7 +722,7 @@ llvm::Type *CodeGenTypes::ConvertType(QualType T) {
case Type::MemberPointer: {
auto *MPTy = cast<MemberPointerType>(Ty);
if (!getCXXABI().isMemberPointerConvertible(MPTy)) {
- auto *C = MPTy->getClass();
+ auto *C = MPTy->getMostRecentCXXRecordDecl()->getTypeForDecl();
auto Insertion = RecordsWithOpaqueMemberPointers.insert({C, nullptr});
if (Insertion.second)
Insertion.first->second = llvm::StructType::create(getLLVMContext());
diff --git a/clang/lib/CodeGen/ItaniumCXXABI.cpp b/clang/lib/CodeGen/ItaniumCXXABI.cpp
index b145da0f0ec09..38e3a63ebfb11 100644
--- a/clang/lib/CodeGen/ItaniumCXXABI.cpp
+++ b/clang/lib/CodeGen/ItaniumCXXABI.cpp
@@ -632,8 +632,7 @@ CGCallee ItaniumCXXABI::EmitLoadOfMemberFunctionPointer(
const FunctionProtoType *FPT =
MPT->getPointeeType()->castAs<FunctionProtoType>();
- auto *RD =
- cast<CXXRecordDecl>(MPT->getClass()->castAs<RecordType>()->getDecl());
+ auto *RD = MPT->getMostRecentCXXRecordDecl();
llvm::Constant *ptrdiff_1 = llvm::ConstantInt::get(CGM.PtrDiffTy, 1);
@@ -802,7 +801,7 @@ CGCallee ItaniumCXXABI::EmitLoadOfMemberFunctionPointer(
// Check the function pointer if CFI on member function pointers is enabled.
if (ShouldEmitCFICheck) {
- CXXRecordDecl *RD = MPT->getClass()->getAsCXXRecordDecl();
+ CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl();
if (RD->hasDefinition()) {
CodeGenFunction::SanitizerScope SanScope(&CGF);
@@ -815,9 +814,9 @@ CGCallee ItaniumCXXABI::EmitLoadOfMemberFunctionPointer(
llvm::Value *Bit = Builder.getFalse();
for (const CXXRecordDecl *Base : CGM.getMostBaseClasses(RD)) {
llvm::Metadata *MD = CGM.CreateMetadataIdentifierForType(
- getContext().getMemberPointerType(
- MPT->getPointeeType(),
- getContext().getRecordType(Base).getTypePtr()));
+ getContext().getMemberPointerType(MPT->getPointeeType(),
+ /*Qualifier=*/nullptr,
+ Base->getCanonicalDecl()));
llvm::Value *TypeId =
llvm::MetadataAsValue::get(CGF.getLLVMContext(), MD);
@@ -1225,7 +1224,7 @@ llvm::Constant *ItaniumCXXABI::EmitMemberPointer(const APValue &MP,
if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(MPD)) {
llvm::Constant *Src = BuildMemberPointer(MD, ThisAdjustment);
QualType SrcType = getContext().getMemberPointerType(
- MD->getType(), MD->getParent()->getTypeForDecl());
+ MD->getType(), /*Qualifier=*/nullptr, MD->getParent());
return pointerAuthResignMemberFunctionPointer(Src, MPType, SrcType, CGM);
}
@@ -3803,7 +3802,8 @@ static bool ContainsIncompleteClassType(QualType Ty) {
if (const MemberPointerType *MemberPointerTy =
dyn_cast<MemberPointerType>(Ty)) {
// Check if the class type is incomplete.
- const RecordType *ClassType = cast<RecordType>(MemberPointerTy->getClass());
+ const auto *ClassType = cast<RecordType>(
+ MemberPointerTy->getMostRecentCXXRecordDecl()->getTypeForDecl());
if (IsIncompleteClassType(ClassType))
return true;
@@ -4542,7 +4542,8 @@ ItaniumRTTIBuilder::BuildPointerToMemberTypeInfo(const MemberPointerType *Ty) {
// attributes of the type pointed to.
unsigned Flags = extractPBaseFlags(CGM.getContext(), PointeeTy);
- const RecordType *ClassType = cast<RecordType>(Ty->getClass());
+ const auto *ClassType =
+ cast<RecordType>(Ty->getMostRecentCXXRecordDecl()->getTypeForDecl());
if (IsIncompleteClassType(ClassType))
Flags |= PTI_ContainingClassIncomplete;
@@ -5138,7 +5139,7 @@ ItaniumCXXABI::getSignedVirtualMemberFunctionPointer(const CXXMethodDecl *MD) {
.getDecl());
llvm::Constant *thunk = getOrCreateVirtualFunctionPointerThunk(origMD);
QualType funcType = CGM.getContext().getMemberPointerType(
- MD->getType(), MD->getParent()->getTypeForDecl());
+ MD->getType(), /*Qualifier=*/nullptr, MD->getParent());
return CGM.getMemberFunctionPointer(thunk, funcType);
}
diff --git a/clang/lib/CodeGen/MicrosoftCXXABI.cpp b/clang/lib/CodeGen/MicrosoftCXXABI.cpp
index 4b55fc3f17bd7..464d4370284fb 100644
--- a/clang/lib/CodeGen/MicrosoftCXXABI.cpp
+++ b/clang/lib/CodeGen/MicrosoftCXXABI.cpp
@@ -2937,9 +2937,9 @@ llvm::Constant *MicrosoftCXXABI::EmitMemberPointer(const APValue &MP,
if (!MemberPointerPath.empty()) {
const CXXRecordDecl *SrcRD = cast<CXXRecordDecl>(MPD->getDeclContext());
- const Type *SrcRecTy = Ctx.getTypeDeclType(SrcRD).getTypePtr();
const MemberPointerType *SrcTy =
- Ctx.getMemberPointerType(DstTy->getPointeeType(), SrcRecTy)
+ Ctx.getMemberPointerType(DstTy->getPointeeType(), /*Qualifier=*/nullptr,
+ SrcRD)
->castAs<MemberPointerType>();
bool DerivedMember = MP.isMemberPointerToDerivedMember();
@@ -3954,7 +3954,8 @@ static QualType decomposeTypeForEH(ASTContext &Context, QualType T,
// for "int A::*" and separately storing the const qualifier.
if (const auto *MPTy = T->getAs<MemberPointerType>())
T = Context.getMemberPointerType(PointeeType.getUnqualifiedType(),
- MPTy->getClass());
+ MPTy->getQualifier(),
+ MPTy->getMostRecentCXXRecordDecl());
// Pointer types like "const int * const *" are represented by having RTTI
// for "const int **" and separately storing the const qualifier.
diff --git a/clang/lib/Sema/SemaAccess.cpp b/clang/lib/Sema/SemaAccess.cpp
index f79d9a758e7af..fca29e847d9d0 100644
--- a/clang/lib/Sema/SemaAccess.cpp
+++ b/clang/lib/Sema/SemaAccess.cpp
@@ -1873,40 +1873,47 @@ Sema::AccessResult Sema::CheckAddressOfMemberAccess(Expr *OvlExpr,
return CheckAccess(*this, Ovl->getNameLoc(), Entity);
}
-Sema::AccessResult Sema::CheckBaseClassAccess(SourceLocation AccessLoc,
- QualType Base,
- QualType Derived,
- const CXXBasePath &Path,
- unsigned DiagID,
- bool ForceCheck,
- bool ForceUnprivileged) {
+Sema::AccessResult Sema::CheckBaseClassAccess(
+ SourceLocation AccessLoc, CXXRecordDecl *Base, CXXRecordDecl *Derived,
+ const CXXBasePath &Path, unsigned DiagID,
+ llvm::function_ref<void(PartialDiagnostic &)> SetupPDiag, bool ForceCheck,
+ bool ForceUnprivileged) {
if (!ForceCheck && !getLangOpts().AccessControl)
return AR_accessible;
if (Path.Access == AS_public)
return AR_accessible;
- CXXRecordDecl *BaseD, *DerivedD;
- BaseD = cast<CXXRecordDecl>(Base->castAs<RecordType>()->getDecl());
- DerivedD = cast<CXXRecordDecl>(Derived->castAs<RecordType>()->getDecl());
-
- AccessTarget Entity(Context, AccessTarget::Base, BaseD, DerivedD,
- Path.Access);
+ AccessTarget Entity(Context, AccessTarget::Base, Base, Derived, Path.Access);
if (DiagID)
- Entity.setDiag(DiagID) << Derived << Base;
+ SetupPDiag(Entity.setDiag(DiagID));
if (ForceUnprivileged) {
- switch (CheckEffectiveAccess(*this, EffectiveContext(),
- AccessLoc, Entity)) {
- case ::AR_accessible: return Sema::AR_accessible;
- case ::AR_inaccessible: return Sema::AR_inaccessible;
- case ::AR_dependent: return Sema::AR_dependent;
+ switch (
+ CheckEffectiveAccess(*this, EffectiveContext(), AccessLoc, Entity)) {
+ case ::AR_accessible:
+ return Sema::AR_accessible;
+ case ::AR_inaccessible:
+ return Sema::AR_inaccessible;
+ case ::AR_dependent:
+ return Sema::AR_dependent;
}
llvm_unreachable("unexpected result from CheckEffectiveAccess");
}
return CheckAccess(*this, AccessLoc, Entity);
}
+Sema::AccessResult Sema::CheckBaseClassAccess(SourceLocation AccessLoc,
+ QualType Base, QualType Derived,
+ const CXXBasePath &Path,
+ unsigned DiagID, bool ForceCheck,
+ bool ForceUnprivileged) {
+ return CheckBaseClassAccess(
+ AccessLoc, Base->getAsCXXRecordDecl(), Derived->getAsCXXRecordDecl(),
+ Path, DiagID, [&](PartialDiagnostic &PD) { PD << Derived << Base; },
+ ForceCheck, ForceUnprivileged);
+}
+
void Sema::CheckLookupAccess(const LookupResult &R) {
assert(getLangOpts().AccessControl
&& "performing access check without access control");
diff --git a/clang/lib/Sema/SemaCast.cpp b/clang/lib/Sema/SemaCast.cpp
index 89e8082ee80e7..109c4dc72587f 100644
--- a/clang/lib/Sema/SemaCast.cpp
+++ b/clang/lib/Sema/SemaCast.cpp
@@ -1788,78 +1788,31 @@ TryStaticMemberPointerUpcast(Sema &Self, ExprResult &SrcExpr, QualType SrcType,
= Self.ResolveAddressOfOverloadedFunction(SrcExpr.get(), DestType, false,
FoundOverload)) {
CXXMethodDecl *M = cast<CXXMethodDecl>(Fn);
- SrcType = Self.Context.getMemberPointerType(Fn->getType(),
- Self.Context.getTypeDeclType(M->getParent()).getTypePtr());
+ SrcType = Self.Context.getMemberPointerType(
+ Fn->getType(), /*Qualifier=*/nullptr, M->getParent());
WasOverloadedFunction = true;
}
}
- const MemberPointerType *SrcMemPtr = SrcType->getAs<MemberPointerType>();
- if (!SrcMemPtr) {
- msg = diag::err_bad_static_cast_member_pointer_nonmp;
- return TC_NotApplicable;
- }
-
- // Lock down the inheritance model right now in MS ABI, whether or not the
- // pointee types are the same.
- if (Self.Context.getTargetInfo().getCXXABI().isMicrosoft()) {
- (void)Self.isCompleteType(OpRange.getBegin(), SrcType);
- (void)Self.isCompleteType(OpRange.getBegin(), DestType);
- }
-
- // T == T, modulo cv
- if (!Self.Context.hasSameUnqualifiedType(SrcMemPtr->getPointeeType(),
- DestMemPtr->getPointeeType()))
- return TC_NotApplicable;
-
- // B base of D
- QualType SrcClass(SrcMemPtr->getClass(), 0);
- QualType DestClass(DestMemPtr->getClass(), 0);
- CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
- /*DetectVirtual=*/true);
- if (!Self.IsDerivedFrom(OpRange.getBegin(), SrcClass, DestClass, Paths))
+ switch (Self.CheckMemberPointerConversion(
+ SrcType, DestMemPtr, Kind, BasePath, OpRange.getBegin(), OpRange, CStyle,
+ Sema::CheckMemberPointerConversionDirection::Upcast)) {
+ case Sema::CheckMemberPointerConversionResult::Success:
+ if (Kind == CK_NullToMemberPointer) {
+ msg = diag::err_bad_static_cast_member_pointer_nonmp;
+ return TC_NotApplicable;
+ }
+ break;
+ case Sema::CheckMemberPointerConversionResult::DifferentPointee:
+ case Sema::CheckMemberPointerConversionResult::NotDerived:
return TC_NotApplicable;
-
- // B is a base of D. But is it an allowed base? If not, it's a hard error.
- if (Paths.isAmbiguous(Self.Context.getCanonicalType(DestClass))) {
- Paths.clear();
- Paths.setRecordingPaths(true);
- bool StillOkay =
- Self.IsDerivedFrom(OpRange.getBegin(), SrcClass, DestClass, Paths);
- assert(StillOkay);
- (void)StillOkay;
- std::string PathDisplayStr = Self.getAmbiguousPathsDisplayString(Paths);
- Self.Diag(OpRange.getBegin(), diag::err_ambiguous_memptr_conv)
- << 1 << SrcClass << DestClass << PathDisplayStr << OpRange;
- msg = 0;
- return TC_Failed;
- }
-
- if (const RecordType *VBase = Paths.getDetectedVirtual()) {
- Self.Diag(OpRange.getBegin(), diag::err_memptr_conv_via_virtual)
- << SrcClass << DestClass << QualType(VBase, 0) << OpRange;
+ case Sema::CheckMemberPointerConversionResult::Ambiguous:
+ case Sema::CheckMemberPointerConversionResult::Virtual:
+ case Sema::CheckMemberPointerConversionResult::Inaccessible:
msg = 0;
return TC_Failed;
}
- if (!CStyle) {
- switch (Self.CheckBaseClassAccess(OpRange.getBegin(),
- DestClass, SrcClass,
- Paths.front(),
- diag::err_upcast_to_inaccessible_base)) {
- case Sema::AR_accessible:
- case Sema::AR_delayed:
- case Sema::AR_dependent:
- // Optimistically assume that the delayed and dependent cases
- // will work out.
- break;
-
- case Sema::AR_inaccessible:
- msg = 0;
- return TC_Failed;
- }
- }
-
if (WasOverloadedFunction) {
// Resolve the address of the overloaded function again, this time
// allowing complaints if something goes wrong.
@@ -1878,9 +1831,6 @@ TryStaticMemberPointerUpcast(Sema &Self, ExprResult &SrcExpr, QualType SrcType,
return TC_Failed;
}
}
-
- Self.BuildBasePathArray(Paths, BasePath);
- Kind = CK_DerivedToBaseMemberPointer;
return TC_Success;
}
diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp
index 1edbe62f1c79a..f01ef9115b3e5 100644
--- a/clang/lib/Sema/SemaDeclCXX.cpp
+++ b/clang/lib/Sema/SemaDeclCXX.cpp
@@ -2997,48 +2997,46 @@ void Sema::ActOnBaseSpecifiers(Decl *ClassDecl,
AttachBaseSpecifiers(cast<CXXRecordDecl>(ClassDecl), Bases);
}
-bool Sema::IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base) {
+bool Sema::IsDerivedFrom(SourceLocation Loc, CXXRecordDecl *Derived,
+ CXXRecordDecl *Base, CXXBasePaths &Paths) {
if (!getLangOpts().CPlusPlus)
return false;
- CXXRecordDecl *DerivedRD = Derived->getAsCXXRecordDecl();
- if (!DerivedRD)
- return false;
-
- CXXRecordDecl *BaseRD = Base->getAsCXXRecordDecl();
- if (!BaseRD)
+ if (!Base || !Derived)
return false;
// If either the base or the derived type is invalid, don't try to
// check whether one is derived from the other.
- if (BaseRD->isInvalidDecl() || DerivedRD->isInvalidDecl())
+ if (Base->isInvalidDecl() || Derived->isInvalidDecl())
return false;
// FIXME: In a modules build, do we need the entire path to be visible for us
// to be able to use the inheritance relationship?
- if (!isCompleteType(Loc, Derived) && !DerivedRD->isBeingDefined())
+ if (!isCompleteType(Loc, Context.getTypeDeclType(Derived)) &&
+ !Derived->isBeingDefined())
return false;
- return DerivedRD->isDerivedFrom(BaseRD);
+ return Derived->isDerivedFrom(Base, Paths);
}
-bool Sema::IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base,
- CXXBasePaths &Paths) {
- if (!getLangOpts().CPlusPlus)
- return false;
-
- CXXRecordDecl *DerivedRD = Derived->getAsCXXRecordDecl();
- if (!DerivedRD)
- return false;
-
- CXXRecordDecl *BaseRD = Base->getAsCXXRecordDecl();
- if (!BaseRD)
- return false;
+bool Sema::IsDerivedFrom(SourceLocation Loc, CXXRecordDecl *Derived,
+ CXXRecordDecl *Base) {
+ CXXBasePaths Paths(/*FindAmbiguities=*/false, /*RecordPaths=*/false,
+ /*DetectVirtual=*/false);
+ return IsDerivedFrom(Loc, Derived, Base, Paths);
+}
- if (!isCompleteType(Loc, Derived) && !DerivedRD->isBeingDefined())
- return false;
+bool Sema::IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base) {
+ CXXBasePaths Paths(/*FindAmbiguities=*/false, /*RecordPaths=*/false,
+ /*DetectVirtual=*/false);
+ return IsDerivedFrom(Loc, Derived->getAsCXXRecordDecl(),
+ Base->getAsCXXRecordDecl(), Paths);
+}
- return DerivedRD->isDerivedFrom(BaseRD, Paths);
+bool Sema::IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base,
+ CXXBasePaths &Paths) {
+ return IsDerivedFrom(Loc, Derived->getAsCXXRecordDecl(),
+ Base->getAsCXXRecordDecl(), Paths);
}
static void BuildBasePathArray(const CXXBasePath &Path,
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
index a36a2f563739e..79e2d6d5768bb 100644
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -14293,9 +14293,8 @@ QualType Sema::CheckAddressOfOperand(ExprResult &OrigOp, SourceLocation OpLoc) {
CXXMethodDecl *MD = cast<CXXMethodDecl>(DRE->getDecl());
CheckUseOfCXXMethodAsAddressOfOperand(OpLoc, OrigOp.get(), MD);
-
QualType MPTy = Context.getMemberPointerType(
- op->getType(), Context.getTypeDeclType(MD->getParent()).getTypePtr());
+ op->getType(), DRE->getQualifier(), MD->getParent());
if (getLangOpts().PointerAuthCalls && MD->isVirtual() &&
!isUnevaluatedContext() && !MPTy->isDependentType()) {
@@ -14383,8 +14382,8 @@ QualType Sema::CheckAddressOfOperand(ExprResult &OrigOp, SourceLocation OpLoc) {
// of some class C [...] and if E is a qualified-id, E is
// not the un-parenthesized operand of the unary & operator [...]
// the id-expression is transformed into a class member access expression.
- if (isa<DeclRefExpr>(op) && cast<DeclRefExpr>(op)->getQualifier() &&
- !isa<ParenExpr>(OrigOp.get())) {
+ if (auto *DRE = dyn_cast<DeclRefExpr>(op);
+ DRE && DRE->getQualifier() && !isa<ParenExpr>(OrigOp.get())) {
DeclContext *Ctx = dcl->getDeclContext();
if (Ctx && Ctx->isRecord()) {
if (dcl->getType()->isReferenceType()) {
@@ -14398,8 +14397,7 @@ QualType Sema::CheckAddressOfOperand(ExprResult &OrigOp, SourceLocation OpLoc) {
Ctx = Ctx->getParent();
QualType MPTy = Context.getMemberPointerType(
- op->getType(),
- Context.getTypeDeclType(cast<RecordDecl>(Ctx)).getTypePtr());
+ op->getType(), DRE->getQualifier(), cast<CXXRecordDecl>(Ctx));
// Under the MS ABI, lock down the inheritance model now.
if (Context.getTargetInfo().getCXXABI().isMicrosoft())
(void)isCompleteType(OpLoc, MPTy);
diff --git a/clang/lib/Sema/SemaExprCXX.cpp b/clang/lib/Sema/SemaExprCXX.cpp
index 34219e0235a74..7facef48b63df 100644
--- a/clang/lib/Sema/SemaExprCXX.cpp
+++ b/clang/lib/Sema/SemaExprCXX.cpp
@@ -4666,18 +4666,29 @@ Sema::PerformImplicitConversion(Expr *From, QualType ToType,
case ICK_Pointer_Member: {
CastKind Kind;
CXXCastPath BasePath;
- if (CheckMemberPointerConversion(From, ToType, Kind, BasePath, CStyle))
+ switch (CheckMemberPointerConversion(
+ From->getType(), ToType->castAs<MemberPointerType>(), Kind, BasePath,
+ From->getExprLoc(), From->getSourceRange(), CStyle,
+ CheckMemberPointerConversionDirection::Downcast)) {
+ case CheckMemberPointerConversionResult::Success:
+ assert(Kind != CK_NullToMemberPointer ||
+ From->isNullPointerConstant(Context,
+ Expr::NPC_ValueDependentIsNull) &&
+ "Expr must be null pointer constant!");
+ break;
+ case CheckMemberPointerConversionResult::Inaccessible:
+ break;
+ case CheckMemberPointerConversionResult::DifferentPointee:
+ llvm_unreachable("unexpected result");
+ case CheckMemberPointerConversionResult::NotDerived:
+ llvm_unreachable("Should not have been called if derivation isn't OK.");
+ case CheckMemberPointerConversionResult::Ambiguous:
+ case CheckMemberPointerConversionResult::Virtual:
return ExprError();
+ }
if (CheckExceptionSpecCompatibility(From, ToType))
return ExprError();
- // We may not have been able to figure out what this member pointer resolved
- // to up until this exact point. Attempt to lock-in it's inheritance model.
- if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
- (void)isCompleteType(From->getExprLoc(), From->getType());
- (void)isCompleteType(From->getExprLoc(), ToType);
- }
-
From =
ImpCastExprToType(From, ToType, Kind, VK_PRValue, &BasePath, CCK).get();
break;
@@ -6476,7 +6487,8 @@ QualType Sema::CheckPointerToMemberOperands(ExprResult &LHS, ExprResult &RHS,
return QualType();
}
- QualType Class(MemPtr->getClass(), 0);
+ QualType Class =
+ Context.getTypeDeclType(MemPtr->getMostRecentCXXRecordDecl());
// Note: C++ [expr.mptr.oper]p2-3 says that the class type into which the
// member pointer points must be completely-defined. However, there is no
@@ -7314,6 +7326,7 @@ QualType Sema::FindCompositePointerType(SourceLocation Loc,
Qualifiers Quals;
/// The class for a pointer-to-member; a constant array type with a bound
/// (if any) for an array.
+ /// FIXME: Store Qualifier for pointer-to-member.
const Type *ClassOrBound;
Step(Kind K, const Type *ClassOrBound = nullptr)
@@ -7324,7 +7337,8 @@ QualType Sema::FindCompositePointerType(SourceLocation Loc,
case Pointer:
return Ctx.getPointerType(T);
case MemberPointer:
- return Ctx.getMemberPointerType(T, ClassOrBound);
+ return Ctx.getMemberPointerType(T, /*Qualifier=*/nullptr,
+ ClassOrBound->getAsCXXRecordDecl());
case ObjCPointer:
return Ctx.getObjCObjectPointerType(T);
case Array:
@@ -7478,18 +7492,20 @@ QualType Sema::FindCompositePointerType(SourceLocation Loc,
// (Note that the only kinds of reference-relatedness in scope here are
// "same type or derived from".) At any other level, the class must
// exactly match.
- const Type *Class = nullptr;
- QualType Cls1(MemPtr1->getClass(), 0);
- QualType Cls2(MemPtr2->getClass(), 0);
- if (Context.hasSameType(Cls1, Cls2))
- Class = MemPtr1->getClass();
+ CXXRecordDecl *Cls = nullptr,
+ *Cls1 = MemPtr1->getMostRecentCXXRecordDecl(),
+ *Cls2 = MemPtr2->getMostRecentCXXRecordDecl();
+ if (declaresSameEntity(Cls1, Cls2))
+ Cls = Cls1;
else if (Steps.empty())
- Class = IsDerivedFrom(Loc, Cls1, Cls2) ? MemPtr1->getClass() :
- IsDerivedFrom(Loc, Cls2, Cls1) ? MemPtr2->getClass() : nullptr;
- if (!Class)
+ Cls = IsDerivedFrom(Loc, Cls1, Cls2) ? Cls1
+ : IsDerivedFrom(Loc, Cls2, Cls1) ? Cls2
+ : nullptr;
+ if (!Cls)
return QualType();
- Steps.emplace_back(Step::MemberPointer, Class);
+ Steps.emplace_back(Step::MemberPointer,
+ Context.getTypeDeclType(Cls).getTypePtr());
continue;
}
diff --git a/clang/lib/Sema/SemaLookup.cpp b/clang/lib/Sema/SemaLookup.cpp
index aecf8ed1b4e4d..59dc6df5fbe9f 100644
--- a/clang/lib/Sema/SemaLookup.cpp
+++ b/clang/lib/Sema/SemaLookup.cpp
@@ -3210,11 +3210,8 @@ addAssociatedClassesAndNamespaces(AssociatedLookup &Result, QualType Ty) {
// X.
case Type::MemberPointer: {
const MemberPointerType *MemberPtr = cast<MemberPointerType>(T);
-
- // Queue up the class type into which this points.
- Queue.push_back(MemberPtr->getClass());
-
- // And directly continue with the pointee type.
+ addAssociatedClassesAndNamespaces(
+ Result, MemberPtr->getMostRecentCXXRecordDecl());
T = MemberPtr->getPointeeType().getTypePtr();
continue;
}
diff --git a/clang/lib/Sema/SemaOpenMP.cpp b/clang/lib/Sema/SemaOpenMP.cpp
index 616296027d811..8caf098bbceed 100644
--- a/clang/lib/Sema/SemaOpenMP.cpp
+++ b/clang/lib/Sema/SemaOpenMP.cpp
@@ -7366,9 +7366,8 @@ SemaOpenMP::checkOpenMPDeclareVariantFunction(SemaOpenMP::DeclGroupPtrTy DG,
QualType FnPtrType;
auto *Method = dyn_cast<CXXMethodDecl>(FD);
if (Method && !Method->isStatic()) {
- const Type *ClassType =
- Context.getTypeDeclType(Method->getParent()).getTypePtr();
- FnPtrType = Context.getMemberPointerType(AdjustedFnType, ClassType);
+ FnPtrType = Context.getMemberPointerType(
+ AdjustedFnType, /*Qualifier=*/nullptr, Method->getParent());
ExprResult ER;
{
// Build addr_of unary op to correctly handle type checks for member
diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp
index d3c0534b4dd0b..1a97492795d36 100644
--- a/clang/lib/Sema/SemaOverload.cpp
+++ b/clang/lib/Sema/SemaOverload.cpp
@@ -1897,7 +1897,8 @@ bool Sema::IsFunctionConversion(QualType FromType, QualType ToType,
auto ToMPT = CanTo.castAs<MemberPointerType>();
auto FromMPT = CanFrom.castAs<MemberPointerType>();
// A function pointer conversion cannot change the class of the function.
- if (ToMPT->getClass() != FromMPT->getClass())
+ if (!declaresSameEntity(ToMPT->getMostRecentCXXRecordDecl(),
+ FromMPT->getMostRecentCXXRecordDecl()))
return false;
CanTo = ToMPT->getPointeeType();
CanFrom = FromMPT->getPointeeType();
@@ -2242,9 +2243,8 @@ static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
assert(cast<UnaryOperator>(From->IgnoreParens())->getOpcode()
== UO_AddrOf &&
"Non-address-of operator on non-static member address");
- const Type *ClassType
- = S.Context.getTypeDeclType(Method->getParent()).getTypePtr();
- FromType = S.Context.getMemberPointerType(FromType, ClassType);
+ FromType = S.Context.getMemberPointerType(
+ FromType, /*Qualifier=*/nullptr, Method->getParent());
} else if (isa<UnaryOperator>(From->IgnoreParens())) {
assert(cast<UnaryOperator>(From->IgnoreParens())->getOpcode() ==
UO_AddrOf &&
@@ -3290,9 +3290,10 @@ void Sema::HandleFunctionTypeMismatch(PartialDiagnostic &PDiag,
if (FromType->isMemberPointerType() && ToType->isMemberPointerType()) {
const auto *FromMember = FromType->castAs<MemberPointerType>(),
*ToMember = ToType->castAs<MemberPointerType>();
- if (!Context.hasSameType(FromMember->getClass(), ToMember->getClass())) {
- PDiag << ft_different_class << QualType(ToMember->getClass(), 0)
- << QualType(FromMember->getClass(), 0);
+ if (!declaresSameEntity(FromMember->getMostRecentCXXRecordDecl(),
+ ToMember->getMostRecentCXXRecordDecl())) {
+ PDiag << ft_different_class << ToMember->getMostRecentCXXRecordDecl()
+ << FromMember->getMostRecentCXXRecordDecl();
return;
}
FromType = FromMember->getPointeeType();
@@ -3533,77 +3534,116 @@ bool Sema::IsMemberPointerConversion(Expr *From, QualType FromType,
// A pointer to member of B can be converted to a pointer to member of D,
// where D is derived from B (C++ 4.11p2).
- QualType FromClass(FromTypePtr->getClass(), 0);
- QualType ToClass(ToTypePtr->getClass(), 0);
+ CXXRecordDecl *FromClass = FromTypePtr->getMostRecentCXXRecordDecl();
+ CXXRecordDecl *ToClass = ToTypePtr->getMostRecentCXXRecordDecl();
- if (!Context.hasSameUnqualifiedType(FromClass, ToClass) &&
+ if (!declaresSameEntity(FromClass, ToClass) &&
IsDerivedFrom(From->getBeginLoc(), ToClass, FromClass)) {
- ConvertedType = Context.getMemberPointerType(FromTypePtr->getPointeeType(),
- ToClass.getTypePtr());
+ ConvertedType = Context.getMemberPointerType(
+ FromTypePtr->getPointeeType(), FromTypePtr->getQualifier(), ToClass);
return true;
}
return false;
}
-bool Sema::CheckMemberPointerConversion(Expr *From, QualType ToType,
- CastKind &Kind,
- CXXCastPath &BasePath,
- bool IgnoreBaseAccess) {
- QualType FromType = From->getType();
+Sema::CheckMemberPointerConversionResult Sema::CheckMemberPointerConversion(
+ QualType FromType, const MemberPointerType *ToPtrType, CastKind &Kind,
+ CXXCastPath &BasePath, SourceLocation CheckLoc, SourceRange OpRange,
+ bool IgnoreBaseAccess, CheckMemberPointerConversionDirection Direction) {
const MemberPointerType *FromPtrType = FromType->getAs<MemberPointerType>();
if (!FromPtrType) {
// This must be a null pointer to member pointer conversion
- assert(From->isNullPointerConstant(Context,
- Expr::NPC_ValueDependentIsNull) &&
- "Expr must be null pointer constant!");
Kind = CK_NullToMemberPointer;
- return false;
+ return CheckMemberPointerConversionResult::Success;
}
- const MemberPointerType *ToPtrType = ToType->getAs<MemberPointerType>();
- assert(ToPtrType && "No member pointer cast has a target type "
- "that is not a member pointer.");
+ // Lock down the inheritance model right now in MS ABI, whether or not the
+ // pointee types are the same.
+ if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
+ (void)isCompleteType(CheckLoc, FromType);
+ (void)isCompleteType(CheckLoc, QualType(ToPtrType, 0));
+ }
- QualType FromClass = QualType(FromPtrType->getClass(), 0);
- QualType ToClass = QualType(ToPtrType->getClass(), 0);
+ // T == T, modulo cv
+ if (Direction == CheckMemberPointerConversionDirection::Upcast &&
+ !Context.hasSameUnqualifiedType(FromPtrType->getPointeeType(),
+ ToPtrType->getPointeeType()))
+ return CheckMemberPointerConversionResult::DifferentPointee;
- // FIXME: What about dependent types?
- assert(FromClass->isRecordType() && "Pointer into non-class.");
- assert(ToClass->isRecordType() && "Pointer into non-class.");
+ CXXRecordDecl *FromClass = FromPtrType->getMostRecentCXXRecordDecl(),
+ *ToClass = ToPtrType->getMostRecentCXXRecordDecl();
+
+ auto DiagCls = [](PartialDiagnostic &PD, NestedNameSpecifier *Qual,
+ const CXXRecordDecl *Cls) {
+ if (declaresSameEntity(Qual->getAsRecordDecl(), Cls))
+ PD << Qual;
+ else
+ PD << QualType(Cls->getTypeForDecl(), 0);
+ };
+ auto DiagFromTo = [&](PartialDiagnostic &PD) -> PartialDiagnostic & {
+ DiagCls(PD, FromPtrType->getQualifier(), FromClass);
+ DiagCls(PD, ToPtrType->getQualifier(), ToClass);
+ return PD;
+ };
+
+ CXXRecordDecl *Base = FromClass, *Derived = ToClass;
+ if (Direction == CheckMemberPointerConversionDirection::Upcast)
+ std::swap(Base, Derived);
CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
/*DetectVirtual=*/true);
- bool DerivationOkay =
- IsDerivedFrom(From->getBeginLoc(), ToClass, FromClass, Paths);
- assert(DerivationOkay &&
- "Should not have been called if derivation isn't OK.");
- (void)DerivationOkay;
-
- if (Paths.isAmbiguous(Context.getCanonicalType(FromClass).
- getUnqualifiedType())) {
- std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
- Diag(From->getExprLoc(), diag::err_ambiguous_memptr_conv)
- << 0 << FromClass << ToClass << PathDisplayStr << From->getSourceRange();
- return true;
+ if (!IsDerivedFrom(OpRange.getBegin(), Derived, Base, Paths))
+ return CheckMemberPointerConversionResult::NotDerived;
+
+ if (Paths.isAmbiguous(
+ Base->getTypeForDecl()->getCanonicalTypeUnqualified())) {
+ PartialDiagnostic PD = PDiag(diag::err_ambiguous_memptr_conv);
+ PD << int(Direction);
+ DiagFromTo(PD) << getAmbiguousPathsDisplayString(Paths) << OpRange;
+ Diag(CheckLoc, PD);
+ return CheckMemberPointerConversionResult::Ambiguous;
}
if (const RecordType *VBase = Paths.getDetectedVirtual()) {
- Diag(From->getExprLoc(), diag::err_memptr_conv_via_virtual)
- << FromClass << ToClass << QualType(VBase, 0)
- << From->getSourceRange();
- return true;
+ PartialDiagnostic PD = PDiag(diag::err_memptr_conv_via_virtual);
+ DiagFromTo(PD) << QualType(VBase, 0) << OpRange;
+ Diag(CheckLoc, PD);
+ return CheckMemberPointerConversionResult::Virtual;
}
- if (!IgnoreBaseAccess)
- CheckBaseClassAccess(From->getExprLoc(), FromClass, ToClass,
- Paths.front(),
- diag::err_downcast_from_inaccessible_base);
-
// Must be a base to derived member conversion.
BuildBasePathArray(Paths, BasePath);
- Kind = CK_BaseToDerivedMemberPointer;
- return false;
+ Kind = Direction == CheckMemberPointerConversionDirection::Upcast
+ ? CK_DerivedToBaseMemberPointer
+ : CK_BaseToDerivedMemberPointer;
+
+ if (!IgnoreBaseAccess)
+ switch (CheckBaseClassAccess(
+ CheckLoc, Base, Derived, Paths.front(),
+ Direction == CheckMemberPointerConversionDirection::Upcast
+ ? diag::err_upcast_to_inaccessible_base
+ : diag::err_downcast_from_inaccessible_base,
+ [&](PartialDiagnostic &PD) {
+ NestedNameSpecifier *BaseQual = FromPtrType->getQualifier(),
+ *DerivedQual = ToPtrType->getQualifier();
+ if (Direction == CheckMemberPointerConversionDirection::Upcast)
+ std::swap(BaseQual, DerivedQual);
+ DiagCls(PD, DerivedQual, Derived);
+ DiagCls(PD, BaseQual, Base);
+ })) {
+ case Sema::AR_accessible:
+ case Sema::AR_delayed:
+ case Sema::AR_dependent:
+ // Optimistically assume that the delayed and dependent cases
+ // will work out.
+ break;
+
+ case Sema::AR_inaccessible:
+ return CheckMemberPointerConversionResult::Inaccessible;
+ }
+
+ return CheckMemberPointerConversionResult::Success;
}
/// Determine whether the lifetime conversion between the two given
@@ -4876,10 +4916,18 @@ CompareDerivedToBaseConversions(Sema &S, SourceLocation Loc,
const auto *ToMemPointer1 = ToType1->castAs<MemberPointerType>();
const auto *FromMemPointer2 = FromType2->castAs<MemberPointerType>();
const auto *ToMemPointer2 = ToType2->castAs<MemberPointerType>();
- const Type *FromPointeeType1 = FromMemPointer1->getClass();
- const Type *ToPointeeType1 = ToMemPointer1->getClass();
- const Type *FromPointeeType2 = FromMemPointer2->getClass();
- const Type *ToPointeeType2 = ToMemPointer2->getClass();
+ const Type *FromPointeeType1 =
+ S.Context.getTypeDeclType(FromMemPointer1->getMostRecentCXXRecordDecl())
+ .getTypePtr();
+ const Type *ToPointeeType1 =
+ S.Context.getTypeDeclType(ToMemPointer1->getMostRecentCXXRecordDecl())
+ .getTypePtr();
+ const Type *FromPointeeType2 =
+ S.Context.getTypeDeclType(FromMemPointer2->getMostRecentCXXRecordDecl())
+ .getTypePtr();
+ const Type *ToPointeeType2 =
+ S.Context.getTypeDeclType(ToMemPointer2->getMostRecentCXXRecordDecl())
+ .getTypePtr();
QualType FromPointee1 = QualType(FromPointeeType1, 0).getUnqualifiedType();
QualType ToPointee1 = QualType(ToPointeeType1, 0).getUnqualifiedType();
QualType FromPointee2 = QualType(FromPointeeType2, 0).getUnqualifiedType();
@@ -8717,7 +8765,7 @@ BuiltinCandidateTypeSet::AddMemberPointerWithMoreQualifiedTypeVariants(
// and those shouldn't have qualifier variants anyway.
if (PointeeTy->isArrayType())
return true;
- const Type *ClassTy = PointerTy->getClass();
+ CXXRecordDecl *Cls = PointerTy->getMostRecentCXXRecordDecl();
// Iterate through all strict supersets of the pointee type's CVR
// qualifiers.
@@ -8727,7 +8775,7 @@ BuiltinCandidateTypeSet::AddMemberPointerWithMoreQualifiedTypeVariants(
QualType QPointeeTy = Context.getCVRQualifiedType(PointeeTy, CVR);
MemberPointerTypes.insert(
- Context.getMemberPointerType(QPointeeTy, ClassTy));
+ Context.getMemberPointerType(QPointeeTy, /*Qualifier=*/nullptr, Cls));
}
return true;
@@ -8860,20 +8908,18 @@ static void AddBuiltinAssignmentOperatorCandidates(Sema &S,
/// if any, found in visible type conversion functions found in ArgExpr's type.
static Qualifiers CollectVRQualifiers(ASTContext &Context, Expr* ArgExpr) {
Qualifiers VRQuals;
- const RecordType *TyRec;
+ CXXRecordDecl *ClassDecl;
if (const MemberPointerType *RHSMPType =
- ArgExpr->getType()->getAs<MemberPointerType>())
- TyRec = RHSMPType->getClass()->getAs<RecordType>();
+ ArgExpr->getType()->getAs<MemberPointerType>())
+ ClassDecl = RHSMPType->getMostRecentCXXRecordDecl();
else
- TyRec = ArgExpr->getType()->getAs<RecordType>();
- if (!TyRec) {
+ ClassDecl = ArgExpr->getType()->getAsCXXRecordDecl();
+ if (!ClassDecl) {
// Just to be safe, assume the worst case.
VRQuals.addVolatile();
VRQuals.addRestrict();
return VRQuals;
}
-
- CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(TyRec->getDecl());
if (!ClassDecl->hasDefinition())
return VRQuals;
@@ -9866,9 +9912,10 @@ class BuiltinOperatorOverloadBuilder {
continue;
for (QualType MemPtrTy : CandidateTypes[1].member_pointer_types()) {
const MemberPointerType *mptr = cast<MemberPointerType>(MemPtrTy);
- QualType C2 = QualType(mptr->getClass(), 0);
- C2 = C2.getUnqualifiedType();
- if (C1 != C2 && !S.IsDerivedFrom(CandidateSet.getLocation(), C1, C2))
+ CXXRecordDecl *D1 = C1->getAsCXXRecordDecl(),
+ *D2 = mptr->getMostRecentCXXRecordDecl();
+ if (!declaresSameEntity(D1, D2) &&
+ !S.IsDerivedFrom(CandidateSet.getLocation(), D1, D2))
break;
QualType ParamTypes[2] = {PtrTy, MemPtrTy};
// build CV12 T&
@@ -16422,16 +16469,17 @@ ExprResult Sema::FixOverloadedFunctionReference(Expr *E, DeclAccessPair Found,
assert(isa<DeclRefExpr>(SubExpr.get()) &&
"fixed to something other than a decl ref");
- assert(cast<DeclRefExpr>(SubExpr.get())->getQualifier() &&
+ NestedNameSpecifier *Qualifier =
+ cast<DeclRefExpr>(SubExpr.get())->getQualifier();
+ assert(Qualifier &&
"fixed to a member ref with no nested name qualifier");
// We have taken the address of a pointer to member
// function. Perform the computation here so that we get the
// appropriate pointer to member type.
- QualType ClassType
- = Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext()));
- QualType MemPtrType
- = Context.getMemberPointerType(Fn->getType(), ClassType.getTypePtr());
+ QualType MemPtrType = Context.getMemberPointerType(
+ Fn->getType(), Qualifier,
+ cast<CXXRecordDecl>(Method->getDeclContext()));
// Under the MS ABI, lock down the inheritance model now.
if (Context.getTargetInfo().getCXXABI().isMicrosoft())
(void)isCompleteType(UnOp->getOperatorLoc(), MemPtrType);
diff --git a/clang/lib/Sema/SemaStmt.cpp b/clang/lib/Sema/SemaStmt.cpp
index 944e3300c83fc..44378363a8270 100644
--- a/clang/lib/Sema/SemaStmt.cpp
+++ b/clang/lib/Sema/SemaStmt.cpp
@@ -803,7 +803,8 @@ bool Sema::checkMustTailAttr(const Stmt *St, const Attr &MTA) {
// Call is: obj->*method_ptr or obj.*method_ptr
const auto *MPT =
CalleeBinOp->getRHS()->getType()->castAs<MemberPointerType>();
- CalleeType.This = QualType(MPT->getClass(), 0);
+ CalleeType.This =
+ Context.getTypeDeclType(MPT->getMostRecentCXXRecordDecl());
CalleeType.Func = MPT->getPointeeType()->castAs<FunctionProtoType>();
CalleeType.MemberType = FuncType::ft_pointer_to_member;
} else if (isa<CXXPseudoDestructorExpr>(CalleeExpr)) {
diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp
index 290862d9a773d..53cc8614e2887 100644
--- a/clang/lib/Sema/SemaTemplate.cpp
+++ b/clang/lib/Sema/SemaTemplate.cpp
@@ -5921,8 +5921,12 @@ bool UnnamedLocalNoLinkageFinder::VisitRValueReferenceType(
}
bool UnnamedLocalNoLinkageFinder::VisitMemberPointerType(
- const MemberPointerType* T) {
- return Visit(T->getPointeeType()) || Visit(QualType(T->getClass(), 0));
+ const MemberPointerType *T) {
+ if (Visit(T->getPointeeType()))
+ return true;
+ if (auto *RD = T->getMostRecentCXXRecordDecl())
+ return VisitTagDecl(RD);
+ return VisitNestedNameSpecifier(T->getQualifier());
}
bool UnnamedLocalNoLinkageFinder::VisitConstantArrayType(
diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp
index e6ec4a7178e81..c3bec6bdebbcf 100644
--- a/clang/lib/Sema/SemaTemplateDeduction.cpp
+++ b/clang/lib/Sema/SemaTemplateDeduction.cpp
@@ -2127,9 +2127,19 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
/*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
+ const Type *QP = MPP->getQualifier()->getAsType(),
+ *QA = MPA->getQualifier()->getAsType();
+ CXXRecordDecl *ClsP = MPP->getMostRecentCXXRecordDecl(),
+ *ClsA = MPA->getMostRecentCXXRecordDecl();
+ // FIXME: Don't drop the rest of the prefixes here.
+ QualType P = !ClsP || declaresSameEntity(QP->getAsCXXRecordDecl(), ClsP)
+ ? QualType(QP, 0)
+ : S.Context.getTypeDeclType(ClsP);
+ QualType A = !ClsA || declaresSameEntity(QA->getAsCXXRecordDecl(), ClsA)
+ ? QualType(QA, 0)
+ : S.Context.getTypeDeclType(ClsA);
return DeduceTemplateArgumentsByTypeMatch(
- S, TemplateParams, QualType(MPP->getClass(), 0),
- QualType(MPA->getClass(), 0), Info, Deduced, SubTDF,
+ S, TemplateParams, P, A, Info, Deduced, SubTDF,
degradeCallPartialOrderingKind(POK),
/*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
}
@@ -4211,8 +4221,8 @@ static QualType GetTypeOfFunction(Sema &S, const OverloadExpr::FindResult &R,
if (!R.HasFormOfMemberPointer)
return {};
- return S.Context.getMemberPointerType(Fn->getType(),
- S.Context.getTypeDeclType(Method->getParent()).getTypePtr());
+ return S.Context.getMemberPointerType(
+ Fn->getType(), /*Qualifier=*/nullptr, Method->getParent());
}
if (!R.IsAddressOfOperand) return Fn->getType();
@@ -6833,7 +6843,8 @@ MarkUsedTemplateParameters(ASTContext &Ctx, QualType T,
const MemberPointerType *MemPtr = cast<MemberPointerType>(T.getTypePtr());
MarkUsedTemplateParameters(Ctx, MemPtr->getPointeeType(), OnlyDeduced,
Depth, Used);
- MarkUsedTemplateParameters(Ctx, QualType(MemPtr->getClass(), 0),
+ MarkUsedTemplateParameters(Ctx,
+ QualType(MemPtr->getQualifier()->getAsType(), 0),
OnlyDeduced, Depth, Used);
break;
}
diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp
index 11943c0b53591..39717386b0d08 100644
--- a/clang/lib/Sema/SemaType.cpp
+++ b/clang/lib/Sema/SemaType.cpp
@@ -2086,7 +2086,7 @@ QualType Sema::BuildArrayType(QualType T, ArraySizeModifier ASM,
// an inheritance model, even if it's inside an unused typedef.
if (Context.getTargetInfo().getCXXABI().isMicrosoft())
if (const MemberPointerType *MPTy = T->getAs<MemberPointerType>())
- if (!MPTy->getClass()->isDependentType())
+ if (!MPTy->getQualifier()->isDependent())
(void)isCompleteType(Loc, T);
} else {
@@ -2685,8 +2685,9 @@ QualType Sema::BuildFunctionType(QualType T,
return Context.getFunctionType(T, ParamTypes, EPI);
}
-QualType Sema::BuildMemberPointerType(QualType T, QualType Class,
- SourceLocation Loc,
+QualType Sema::BuildMemberPointerType(QualType T,
+ NestedNameSpecifier *Qualifier,
+ CXXRecordDecl *Cls, SourceLocation Loc,
DeclarationName Entity) {
// Verify that we're not building a pointer to pointer to function with
// exception specification.
@@ -2709,11 +2710,6 @@ QualType Sema::BuildMemberPointerType(QualType T, QualType Class,
return QualType();
}
- if (!Class->isDependentType() && !Class->isRecordType()) {
- Diag(Loc, diag::err_mempointer_in_nonclass_type) << Class;
- return QualType();
- }
-
if (T->isFunctionType() && getLangOpts().OpenCL &&
!getOpenCLOptions().isAvailableOption("__cl_clang_function_pointers",
getLangOpts())) {
@@ -2734,7 +2730,7 @@ QualType Sema::BuildMemberPointerType(QualType T, QualType Class,
if (T->isFunctionType())
adjustMemberFunctionCC(T, /*HasThisPointer=*/true, IsCtorOrDtor, Loc);
- return Context.getMemberPointerType(T, Class.getTypePtr());
+ return Context.getMemberPointerType(T, Qualifier, Cls);
}
QualType Sema::BuildBlockPointerType(QualType T,
@@ -5338,7 +5334,6 @@ static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state,
case DeclaratorChunk::MemberPointer: {
// The scope spec must refer to a class, or be dependent.
CXXScopeSpec &SS = DeclType.Mem.Scope();
- QualType ClsType;
// Handle pointer nullability.
inferPointerNullability(SimplePointerKind::MemberPointer, DeclType.Loc,
@@ -5348,56 +5343,22 @@ static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state,
if (SS.isInvalid()) {
// Avoid emitting extra errors if we already errored on the scope.
D.setInvalidType(true);
- } else if (S.isDependentScopeSpecifier(SS) ||
- isa_and_nonnull<CXXRecordDecl>(S.computeDeclContext(SS))) {
- NestedNameSpecifier *NNS = SS.getScopeRep();
- NestedNameSpecifier *NNSPrefix = NNS->getPrefix();
- switch (NNS->getKind()) {
- case NestedNameSpecifier::Identifier:
- ClsType = Context.getDependentNameType(
- ElaboratedTypeKeyword::None, NNSPrefix, NNS->getAsIdentifier());
- break;
-
- case NestedNameSpecifier::Namespace:
- case NestedNameSpecifier::NamespaceAlias:
- case NestedNameSpecifier::Global:
- case NestedNameSpecifier::Super:
- llvm_unreachable("Nested-name-specifier must name a type");
-
- case NestedNameSpecifier::TypeSpec:
- case NestedNameSpecifier::TypeSpecWithTemplate:
- const Type *NNSType = NNS->getAsType();
- ClsType = QualType(NNSType, 0);
- // Note: if the NNS has a prefix and ClsType is a nondependent
- // TemplateSpecializationType or a RecordType, then the NNS prefix is
- // NOT included in ClsType; hence we wrap ClsType into an
- // ElaboratedType. NOTE: in particular, no wrap occurs if ClsType
- // already is an Elaborated, DependentName, or
- // DependentTemplateSpecialization.
- if (isa<DependentTemplateSpecializationType>(NNSType)) {
- // FIXME: Rebuild DependentTemplateSpecializationType, adding the
- // Prefix.
- } else if (isa<TemplateSpecializationType, RecordType>(NNSType)) {
- // Either the dependent case (TemplateSpecializationType), or the
- // non-dependent one (RecordType).
- ClsType = Context.getElaboratedType(ElaboratedTypeKeyword::None,
- NNSPrefix, ClsType);
- }
- break;
- }
+ AreDeclaratorChunksValid = false;
+ } else if (auto *RD =
+ dyn_cast_or_null<CXXRecordDecl>(S.computeDeclContext(SS));
+ RD || S.isDependentScopeSpecifier(SS)) {
+ T = S.BuildMemberPointerType(T, SS.getScopeRep(), RD, DeclType.Loc,
+ D.getIdentifier());
} else {
S.Diag(DeclType.Mem.Scope().getBeginLoc(),
diag::err_illegal_decl_mempointer_in_nonclass)
<< (D.getIdentifier() ? D.getIdentifier()->getName() : "type name")
<< DeclType.Mem.Scope().getRange();
D.setInvalidType(true);
- }
-
- if (!ClsType.isNull())
- T = S.BuildMemberPointerType(T, ClsType, DeclType.Loc,
- D.getIdentifier());
- else
AreDeclaratorChunksValid = false;
+ // FIXME: Maybe we could model these as as a MemberPointerType with a
+ // non-dependent, non-class qualifier anyway.
+ }
if (T.isNull()) {
T = Context.IntTy;
@@ -6184,48 +6145,8 @@ namespace {
}
void VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
assert(Chunk.Kind == DeclaratorChunk::MemberPointer);
- const CXXScopeSpec& SS = Chunk.Mem.Scope();
- NestedNameSpecifierLoc NNSLoc = SS.getWithLocInContext(Context);
-
- const Type* ClsTy = TL.getClass();
- QualType ClsQT = QualType(ClsTy, 0);
- TypeSourceInfo *ClsTInfo = Context.CreateTypeSourceInfo(ClsQT, 0);
- // Now copy source location info into the type loc component.
- TypeLoc ClsTL = ClsTInfo->getTypeLoc();
- switch (NNSLoc.getNestedNameSpecifier()->getKind()) {
- case NestedNameSpecifier::Identifier:
- assert(isa<DependentNameType>(ClsTy) && "Unexpected TypeLoc");
- {
- DependentNameTypeLoc DNTLoc = ClsTL.castAs<DependentNameTypeLoc>();
- DNTLoc.setElaboratedKeywordLoc(SourceLocation());
- DNTLoc.setQualifierLoc(NNSLoc.getPrefix());
- DNTLoc.setNameLoc(NNSLoc.getLocalBeginLoc());
- }
- break;
-
- case NestedNameSpecifier::TypeSpec:
- case NestedNameSpecifier::TypeSpecWithTemplate:
- if (isa<ElaboratedType>(ClsTy)) {
- ElaboratedTypeLoc ETLoc = ClsTL.castAs<ElaboratedTypeLoc>();
- ETLoc.setElaboratedKeywordLoc(SourceLocation());
- ETLoc.setQualifierLoc(NNSLoc.getPrefix());
- TypeLoc NamedTL = ETLoc.getNamedTypeLoc();
- NamedTL.initializeFullCopy(NNSLoc.getTypeLoc());
- } else {
- ClsTL.initializeFullCopy(NNSLoc.getTypeLoc());
- }
- break;
-
- case NestedNameSpecifier::Namespace:
- case NestedNameSpecifier::NamespaceAlias:
- case NestedNameSpecifier::Global:
- case NestedNameSpecifier::Super:
- llvm_unreachable("Nested-name-specifier must name a type");
- }
-
- // Finally fill in MemberPointerLocInfo fields.
TL.setStarLoc(Chunk.Mem.StarLoc);
- TL.setClassTInfo(ClsTInfo);
+ TL.setQualifierLoc(Chunk.Mem.Scope().getWithLocInContext(Context));
}
void VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
assert(Chunk.Kind == DeclaratorChunk::Reference);
@@ -7054,7 +6975,8 @@ namespace {
case MemberPointer: {
const MemberPointerType *OldMPT = cast<MemberPointerType>(Old);
QualType New = wrap(C, OldMPT->getPointeeType(), I);
- return C.getMemberPointerType(New, OldMPT->getClass());
+ return C.getMemberPointerType(New, OldMPT->getQualifier(),
+ OldMPT->getMostRecentCXXRecordDecl());
}
case Reference: {
@@ -9333,17 +9255,17 @@ bool Sema::RequireCompleteTypeImpl(SourceLocation Loc, QualType T,
// "Can't ask whether a dependent type is complete");
if (const MemberPointerType *MPTy = T->getAs<MemberPointerType>()) {
- if (!MPTy->getClass()->isDependentType()) {
+ if (!MPTy->getQualifier()->isDependent()) {
+ QualType T = Context.getTypeDeclType(MPTy->getMostRecentCXXRecordDecl());
if (getLangOpts().CompleteMemberPointers &&
- !MPTy->getClass()->getAsCXXRecordDecl()->isBeingDefined() &&
- RequireCompleteType(Loc, QualType(MPTy->getClass(), 0), Kind,
- diag::err_memptr_incomplete))
+ !MPTy->getMostRecentCXXRecordDecl()->isBeingDefined() &&
+ RequireCompleteType(Loc, T, Kind, diag::err_memptr_incomplete))
return true;
// We lock in the inheritance model once somebody has asked us to ensure
// that a pointer-to-member type is complete.
if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
- (void)isCompleteType(Loc, QualType(MPTy->getClass(), 0));
+ (void)isCompleteType(Loc, T);
assignInheritanceModel(*this, MPTy->getMostRecentCXXRecordDecl());
}
}
diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h
index f532cea245e54..ee093303837b7 100644
--- a/clang/lib/Sema/TreeTransform.h
+++ b/clang/lib/Sema/TreeTransform.h
@@ -859,12 +859,13 @@ class TreeTransform {
SourceLocation Sigil);
/// Build a new member pointer type given the pointee type and the
- /// class type it refers into.
+ /// qualifier it refers into.
///
/// By default, performs semantic analysis when building the member pointer
/// type. Subclasses may override this routine to provide different behavior.
- QualType RebuildMemberPointerType(QualType PointeeType, QualType ClassType,
- SourceLocation Sigil);
+ QualType RebuildMemberPointerType(QualType PointeeType,
+ NestedNameSpecifier *Qualifier,
+ CXXRecordDecl *Cls, SourceLocation Sigil);
QualType RebuildObjCTypeParamType(const ObjCTypeParamDecl *Decl,
SourceLocation ProtocolLAngleLoc,
@@ -5607,31 +5608,30 @@ TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB,
if (PointeeType.isNull())
return QualType();
- TypeSourceInfo* OldClsTInfo = TL.getClassTInfo();
- TypeSourceInfo *NewClsTInfo = nullptr;
- if (OldClsTInfo) {
- NewClsTInfo = getDerived().TransformType(OldClsTInfo);
- if (!NewClsTInfo)
- return QualType();
- }
-
const MemberPointerType *T = TL.getTypePtr();
- QualType OldClsType = QualType(T->getClass(), 0);
- QualType NewClsType;
- if (NewClsTInfo)
- NewClsType = NewClsTInfo->getType();
- else {
- NewClsType = getDerived().TransformType(OldClsType);
- if (NewClsType.isNull())
+
+ NestedNameSpecifierLoc OldQualifierLoc = TL.getQualifierLoc();
+ NestedNameSpecifierLoc NewQualifierLoc =
+ getDerived().TransformNestedNameSpecifierLoc(OldQualifierLoc);
+ if (!NewQualifierLoc)
+ return QualType();
+
+ CXXRecordDecl *OldCls = T->getMostRecentCXXRecordDecl(), *NewCls = nullptr;
+ if (OldCls) {
+ NewCls = cast_or_null<CXXRecordDecl>(
+ getDerived().TransformDecl(TL.getStarLoc(), OldCls));
+ if (!NewCls)
return QualType();
}
QualType Result = TL.getType();
- if (getDerived().AlwaysRebuild() ||
- PointeeType != T->getPointeeType() ||
- NewClsType != OldClsType) {
- Result = getDerived().RebuildMemberPointerType(PointeeType, NewClsType,
- TL.getStarLoc());
+ if (getDerived().AlwaysRebuild() || PointeeType != T->getPointeeType() ||
+ NewQualifierLoc.getNestedNameSpecifier() !=
+ OldQualifierLoc.getNestedNameSpecifier() ||
+ NewCls != OldCls) {
+ Result = getDerived().RebuildMemberPointerType(
+ PointeeType, NewQualifierLoc.getNestedNameSpecifier(), NewCls,
+ TL.getStarLoc());
if (Result.isNull())
return QualType();
}
@@ -5646,7 +5646,7 @@ TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB,
MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(Result);
NewTL.setSigilLoc(TL.getSigilLoc());
- NewTL.setClassTInfo(NewClsTInfo);
+ NewTL.setQualifierLoc(NewQualifierLoc);
return Result;
}
@@ -17011,12 +17011,11 @@ TreeTransform<Derived>::RebuildReferenceType(QualType ReferentType,
Sigil, getDerived().getBaseEntity());
}
-template<typename Derived>
-QualType
-TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType,
- QualType ClassType,
- SourceLocation Sigil) {
- return SemaRef.BuildMemberPointerType(PointeeType, ClassType, Sigil,
+template <typename Derived>
+QualType TreeTransform<Derived>::RebuildMemberPointerType(
+ QualType PointeeType, NestedNameSpecifier *Qualifier, CXXRecordDecl *Cls,
+ SourceLocation Sigil) {
+ return SemaRef.BuildMemberPointerType(PointeeType, Qualifier, Cls, Sigil,
getDerived().getBaseEntity());
}
diff --git a/clang/lib/Serialization/ASTReader.cpp b/clang/lib/Serialization/ASTReader.cpp
index 590c7b4e40bff..b6749dfe0e271 100644
--- a/clang/lib/Serialization/ASTReader.cpp
+++ b/clang/lib/Serialization/ASTReader.cpp
@@ -7099,7 +7099,7 @@ void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
TL.setStarLoc(readSourceLocation());
- TL.setClassTInfo(GetTypeSourceInfo());
+ TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
}
void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
diff --git a/clang/lib/Serialization/ASTWriter.cpp b/clang/lib/Serialization/ASTWriter.cpp
index d7328ccc8f6c6..0b83c63f8eb26 100644
--- a/clang/lib/Serialization/ASTWriter.cpp
+++ b/clang/lib/Serialization/ASTWriter.cpp
@@ -408,7 +408,7 @@ void TypeLocWriter::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
void TypeLocWriter::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
addSourceLocation(TL.getStarLoc());
- Record.AddTypeSourceInfo(TL.getClassTInfo());
+ Record.AddNestedNameSpecifierLoc(TL.getQualifierLoc());
}
void TypeLocWriter::VisitArrayTypeLoc(ArrayTypeLoc TL) {
diff --git a/clang/lib/Serialization/TemplateArgumentHasher.cpp b/clang/lib/Serialization/TemplateArgumentHasher.cpp
index 598f098f526d0..3c7177b83ba52 100644
--- a/clang/lib/Serialization/TemplateArgumentHasher.cpp
+++ b/clang/lib/Serialization/TemplateArgumentHasher.cpp
@@ -317,7 +317,9 @@ class TypeVisitorHelper : public TypeVisitor<TypeVisitorHelper> {
void VisitMemberPointerType(const MemberPointerType *T) {
AddQualType(T->getPointeeType());
- AddType(T->getClass());
+ AddType(T->getQualifier()->getAsType());
+ if (auto *RD = T->getMostRecentCXXRecordDecl())
+ AddDecl(RD->getCanonicalDecl());
}
void VisitPackExpansionType(const PackExpansionType *T) {
diff --git a/clang/test/AST/ast-dump-template-json-win32-mangler-crash.cpp b/clang/test/AST/ast-dump-template-json-win32-mangler-crash.cpp
index 5ac55d269dce4..9f0d3efb6277e 100644
--- a/clang/test/AST/ast-dump-template-json-win32-mangler-crash.cpp
+++ b/clang/test/AST/ast-dump-template-json-win32-mangler-crash.cpp
@@ -2452,6 +2452,9 @@ int main()
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: {
+// CHECK-NEXT: "id": "0x0"
+// CHECK-NEXT: },
+// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "TemplateTypeParmType",
// CHECK-NEXT: "type": {
@@ -3225,4 +3228,3 @@ int main()
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
-
diff --git a/clang/test/AST/ast-dump-templates.cpp b/clang/test/AST/ast-dump-templates.cpp
index 2728dc151c3c5..0e0fa73871bb7 100644
--- a/clang/test/AST/ast-dump-templates.cpp
+++ b/clang/test/AST/ast-dump-templates.cpp
@@ -146,6 +146,18 @@ struct pr126341<{1, 2}>;
// DUMP: `-TemplateArgument structural value '1+2i'
} // namespace test8
+namespace TestMemberPointerPartialSpec {
+ template <class> struct A;
+ template <class T1, class T2> struct A<T1 T2::*>;
+// DUMP-LABEL: NamespaceDecl {{.+}} TestMemberPointerPartialSpec{{$}}
+// DUMP: ClassTemplatePartialSpecializationDecl {{.*}} struct A
+// DUMP-NEXT: |-TemplateArgument type 'type-parameter-0-0 type-parameter-0-1::*'
+// DUMP-NEXT: | `-MemberPointerType {{.+}} 'type-parameter-0-0 type-parameter-0-1::*' dependent
+// DUMP-NEXT: | |-TemplateTypeParmType {{.+}} 'type-parameter-0-1' dependent depth 0 index 1
+// DUMP-NEXT: | |-<<<NULL>>>
+// DUMP-NEXT: | `-TemplateTypeParmType {{.+}} 'type-parameter-0-0' dependent depth 0 index 0
+} // namespace TestMemberPointerPartialSpec
+
// NOTE: CHECK lines have been autogenerated by gen_ast_dump_json_test.py
@@ -6316,6 +6328,232 @@ struct pr126341<{1, 2}>;
// JSON-NEXT: ]
// JSON-NEXT: }
// JSON-NEXT: ]
+// JSON-NEXT: },
+// JSON-NEXT: {
+// JSON-NEXT: "id": "0x{{.*}}",
+// JSON-NEXT: "kind": "NamespaceDecl",
+// JSON-NEXT: "loc": {
+// JSON-NEXT: "offset": 4680,
+// JSON-NEXT: "line": 149,
+// JSON-NEXT: "col": 11,
+// JSON-NEXT: "tokLen": 28
+// JSON-NEXT: },
+// JSON-NEXT: "range": {
+// JSON-NEXT: "begin": {
+// JSON-NEXT: "offset": 4670,
+// JSON-NEXT: "col": 1,
+// JSON-NEXT: "tokLen": 9
+// JSON-NEXT: },
+// JSON-NEXT: "end": {
+// JSON-NEXT: "offset": 5335,
+// JSON-NEXT: "line": 159,
+// JSON-NEXT: "col": 1,
+// JSON-NEXT: "tokLen": 1
+// JSON-NEXT: }
+// JSON-NEXT: },
+// JSON-NEXT: "name": "TestMemberPointerPartialSpec",
+// JSON-NEXT: "inner": [
+// JSON-NEXT: {
+// JSON-NEXT: "id": "0x{{.*}}",
+// JSON-NEXT: "kind": "ClassTemplateDecl",
+// JSON-NEXT: "loc": {
+// JSON-NEXT: "offset": 4737,
+// JSON-NEXT: "line": 150,
+// JSON-NEXT: "col": 27,
+// JSON-NEXT: "tokLen": 1
+// JSON-NEXT: },
+// JSON-NEXT: "range": {
+// JSON-NEXT: "begin": {
+// JSON-NEXT: "offset": 4713,
+// JSON-NEXT: "col": 3,
+// JSON-NEXT: "tokLen": 8
+// JSON-NEXT: },
+// JSON-NEXT: "end": {
+// JSON-NEXT: "offset": 4737,
+// JSON-NEXT: "col": 27,
+// JSON-NEXT: "tokLen": 1
+// JSON-NEXT: }
+// JSON-NEXT: },
+// JSON-NEXT: "name": "A",
+// JSON-NEXT: "inner": [
+// JSON-NEXT: {
+// JSON-NEXT: "id": "0x{{.*}}",
+// JSON-NEXT: "kind": "TemplateTypeParmDecl",
+// JSON-NEXT: "loc": {
+// JSON-NEXT: "offset": 4728,
+// JSON-NEXT: "col": 18,
+// JSON-NEXT: "tokLen": 1
+// JSON-NEXT: },
+// JSON-NEXT: "range": {
+// JSON-NEXT: "begin": {
+// JSON-NEXT: "offset": 4723,
+// JSON-NEXT: "col": 13,
+// JSON-NEXT: "tokLen": 5
+// JSON-NEXT: },
+// JSON-NEXT: "end": {
+// JSON-NEXT: "offset": 4723,
+// JSON-NEXT: "col": 13,
+// JSON-NEXT: "tokLen": 5
+// JSON-NEXT: }
+// JSON-NEXT: },
+// JSON-NEXT: "tagUsed": "class",
+// JSON-NEXT: "depth": 0,
+// JSON-NEXT: "index": 0
+// JSON-NEXT: },
+// JSON-NEXT: {
+// JSON-NEXT: "id": "0x{{.*}}",
+// JSON-NEXT: "kind": "CXXRecordDecl",
+// JSON-NEXT: "loc": {
+// JSON-NEXT: "offset": 4737,
+// JSON-NEXT: "col": 27,
+// JSON-NEXT: "tokLen": 1
+// JSON-NEXT: },
+// JSON-NEXT: "range": {
+// JSON-NEXT: "begin": {
+// JSON-NEXT: "offset": 4730,
+// JSON-NEXT: "col": 20,
+// JSON-NEXT: "tokLen": 6
+// JSON-NEXT: },
+// JSON-NEXT: "end": {
+// JSON-NEXT: "offset": 4737,
+// JSON-NEXT: "col": 27,
+// JSON-NEXT: "tokLen": 1
+// JSON-NEXT: }
+// JSON-NEXT: },
+// JSON-NEXT: "name": "A",
+// JSON-NEXT: "tagUsed": "struct"
+// JSON-NEXT: }
+// JSON-NEXT: ]
+// JSON-NEXT: },
+// JSON-NEXT: {
+// JSON-NEXT: "id": "0x{{.*}}",
+// JSON-NEXT: "kind": "ClassTemplatePartialSpecializationDecl",
+// JSON-NEXT: "loc": {
+// JSON-NEXT: "offset": 4779,
+// JSON-NEXT: "line": 151,
+// JSON-NEXT: "col": 40,
+// JSON-NEXT: "tokLen": 1
+// JSON-NEXT: },
+// JSON-NEXT: "range": {
+// JSON-NEXT: "begin": {
+// JSON-NEXT: "offset": 4742,
+// JSON-NEXT: "col": 3,
+// JSON-NEXT: "tokLen": 8
+// JSON-NEXT: },
+// JSON-NEXT: "end": {
+// JSON-NEXT: "offset": 4789,
+// JSON-NEXT: "col": 50,
+// JSON-NEXT: "tokLen": 1
+// JSON-NEXT: }
+// JSON-NEXT: },
+// JSON-NEXT: "name": "A",
+// JSON-NEXT: "tagUsed": "struct",
+// JSON-NEXT: "inner": [
+// JSON-NEXT: {
+// JSON-NEXT: "kind": "TemplateArgument",
+// JSON-NEXT: "type": {
+// JSON-NEXT: "qualType": "type-parameter-0-0 type-parameter-0-1::*"
+// JSON-NEXT: },
+// JSON-NEXT: "inner": [
+// JSON-NEXT: {
+// JSON-NEXT: "id": "0x{{.*}}",
+// JSON-NEXT: "kind": "MemberPointerType",
+// JSON-NEXT: "type": {
+// JSON-NEXT: "qualType": "type-parameter-0-0 type-parameter-0-1::*"
+// JSON-NEXT: },
+// JSON-NEXT: "isDependent": true,
+// JSON-NEXT: "isInstantiationDependent": true,
+// JSON-NEXT: "isData": true,
+// JSON-NEXT: "inner": [
+// JSON-NEXT: {
+// JSON-NEXT: "id": "0x{{.*}}",
+// JSON-NEXT: "kind": "TemplateTypeParmType",
+// JSON-NEXT: "type": {
+// JSON-NEXT: "qualType": "type-parameter-0-1"
+// JSON-NEXT: },
+// JSON-NEXT: "isDependent": true,
+// JSON-NEXT: "isInstantiationDependent": true,
+// JSON-NEXT: "depth": 0,
+// JSON-NEXT: "index": 1,
+// JSON-NEXT: "decl": {
+// JSON-NEXT: "id": "0x0"
+// JSON-NEXT: }
+// JSON-NEXT: },
+// JSON-NEXT: {
+// JSON-NEXT: "id": "0x0"
+// JSON-NEXT: },
+// JSON-NEXT: {
+// JSON-NEXT: "id": "0x{{.*}}",
+// JSON-NEXT: "kind": "TemplateTypeParmType",
+// JSON-NEXT: "type": {
+// JSON-NEXT: "qualType": "type-parameter-0-0"
+// JSON-NEXT: },
+// JSON-NEXT: "isDependent": true,
+// JSON-NEXT: "isInstantiationDependent": true,
+// JSON-NEXT: "depth": 0,
+// JSON-NEXT: "index": 0,
+// JSON-NEXT: "decl": {
+// JSON-NEXT: "id": "0x0"
+// JSON-NEXT: }
+// JSON-NEXT: }
+// JSON-NEXT: ]
+// JSON-NEXT: }
+// JSON-NEXT: ]
+// JSON-NEXT: },
+// JSON-NEXT: {
+// JSON-NEXT: "id": "0x{{.*}}",
+// JSON-NEXT: "kind": "TemplateTypeParmDecl",
+// JSON-NEXT: "loc": {
+// JSON-NEXT: "offset": 4758,
+// JSON-NEXT: "col": 19,
+// JSON-NEXT: "tokLen": 2
+// JSON-NEXT: },
+// JSON-NEXT: "range": {
+// JSON-NEXT: "begin": {
+// JSON-NEXT: "offset": 4752,
+// JSON-NEXT: "col": 13,
+// JSON-NEXT: "tokLen": 5
+// JSON-NEXT: },
+// JSON-NEXT: "end": {
+// JSON-NEXT: "offset": 4758,
+// JSON-NEXT: "col": 19,
+// JSON-NEXT: "tokLen": 2
+// JSON-NEXT: }
+// JSON-NEXT: },
+// JSON-NEXT: "isReferenced": true,
+// JSON-NEXT: "name": "T1",
+// JSON-NEXT: "tagUsed": "class",
+// JSON-NEXT: "depth": 0,
+// JSON-NEXT: "index": 0
+// JSON-NEXT: },
+// JSON-NEXT: {
+// JSON-NEXT: "id": "0x{{.*}}",
+// JSON-NEXT: "kind": "TemplateTypeParmDecl",
+// JSON-NEXT: "loc": {
+// JSON-NEXT: "offset": 4768,
+// JSON-NEXT: "col": 29,
+// JSON-NEXT: "tokLen": 2
+// JSON-NEXT: },
+// JSON-NEXT: "range": {
+// JSON-NEXT: "begin": {
+// JSON-NEXT: "offset": 4762,
+// JSON-NEXT: "col": 23,
+// JSON-NEXT: "tokLen": 5
+// JSON-NEXT: },
+// JSON-NEXT: "end": {
+// JSON-NEXT: "offset": 4768,
+// JSON-NEXT: "col": 29,
+// JSON-NEXT: "tokLen": 2
+// JSON-NEXT: }
+// JSON-NEXT: },
+// JSON-NEXT: "name": "T2",
+// JSON-NEXT: "tagUsed": "class",
+// JSON-NEXT: "depth": 0,
+// JSON-NEXT: "index": 1
+// JSON-NEXT: }
+// JSON-NEXT: ]
+// JSON-NEXT: }
+// JSON-NEXT: ]
// JSON-NEXT: }
// JSON-NEXT: ]
// JSON-NEXT: }
diff --git a/clang/test/AST/ast-dump-types-json.cpp b/clang/test/AST/ast-dump-types-json.cpp
index fa1fb53df0e85..67379ac318e05 100644
--- a/clang/test/AST/ast-dump-types-json.cpp
+++ b/clang/test/AST/ast-dump-types-json.cpp
@@ -27,10 +27,11 @@ using ::TestUsingShadowDeclType;
// NOTE: CHECK lines have been autogenerated by gen_ast_dump_json_test.py
+
// CHECK-NOT: {{^}}Dumping
// CHECK: "kind": "TypedefDecl",
// CHECK-NEXT: "loc": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 204,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 12,
// CHECK-NEXT: "col": 18,
@@ -38,12 +39,12 @@ using ::TestUsingShadowDeclType;
// CHECK-NEXT: },
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 187,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 7
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 204,
// CHECK-NEXT: "col": 18,
// CHECK-NEXT: "tokLen": 19
// CHECK-NEXT: }
@@ -78,10 +79,11 @@ using ::TestUsingShadowDeclType;
// CHECK-NEXT: ]
// CHECK-NEXT: }
+
// CHECK-NOT: {{^}}Dumping
// CHECK: "kind": "TypedefDecl",
// CHECK-NEXT: "loc": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 239,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 13,
// CHECK-NEXT: "col": 15,
@@ -89,12 +91,12 @@ using ::TestUsingShadowDeclType;
// CHECK-NEXT: },
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 225,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 7
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 239,
// CHECK-NEXT: "col": 15,
// CHECK-NEXT: "tokLen": 19
// CHECK-NEXT: }
@@ -129,10 +131,11 @@ using ::TestUsingShadowDeclType;
// CHECK-NEXT: ]
// CHECK-NEXT: }
+
// CHECK-NOT: {{^}}Dumping
// CHECK: "kind": "TypedefDecl",
// CHECK-NEXT: "loc": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 319,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 16,
// CHECK-NEXT: "col": 22,
@@ -140,12 +143,12 @@ using ::TestUsingShadowDeclType;
// CHECK-NEXT: },
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 298,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 7
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 319,
// CHECK-NEXT: "col": 22,
// CHECK-NEXT: "tokLen": 22
// CHECK-NEXT: }
@@ -212,10 +215,11 @@ using ::TestUsingShadowDeclType;
// CHECK-NEXT: ]
// CHECK-NEXT: }
+
// CHECK-NOT: {{^}}Dumping
// CHECK: "kind": "TypedefDecl",
// CHECK-NEXT: "loc": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 366,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 18,
// CHECK-NEXT: "col": 20,
@@ -223,12 +227,12 @@ using ::TestUsingShadowDeclType;
// CHECK-NEXT: },
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 347,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 7
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 397,
// CHECK-NEXT: "col": 51,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
@@ -248,21 +252,164 @@ using ::TestUsingShadowDeclType;
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
-// CHECK-NEXT: "kind": "ElaboratedType",
+// CHECK-NEXT: "kind": "RecordType",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "T"
// CHECK-NEXT: },
+// CHECK-NEXT: "decl": {
+// CHECK-NEXT: "id": "0x{{.*}}",
+// CHECK-NEXT: "kind": "CXXRecordDecl",
+// CHECK-NEXT: "name": "T"
+// CHECK-NEXT: }
+// CHECK-NEXT: },
+// CHECK-NEXT: {
+// CHECK-NEXT: "id": "0x{{.*}}",
+// CHECK-NEXT: "kind": "CXXRecordDecl",
+// CHECK-NEXT: "loc": {
+// CHECK-NEXT: "offset": 158,
+// CHECK-NEXT: "line": 7,
+// CHECK-NEXT: "col": 8,
+// CHECK-NEXT: "tokLen": 1
+// CHECK-NEXT: },
+// CHECK-NEXT: "range": {
+// CHECK-NEXT: "begin": {
+// CHECK-NEXT: "offset": 151,
+// CHECK-NEXT: "col": 1,
+// CHECK-NEXT: "tokLen": 6
+// CHECK-NEXT: },
+// CHECK-NEXT: "end": {
+// CHECK-NEXT: "offset": 183,
+// CHECK-NEXT: "line": 10,
+// CHECK-NEXT: "col": 1,
+// CHECK-NEXT: "tokLen": 1
+// CHECK-NEXT: }
+// CHECK-NEXT: },
+// CHECK-NEXT: "name": "T",
+// CHECK-NEXT: "tagUsed": "struct",
+// CHECK-NEXT: "completeDefinition": true,
+// CHECK-NEXT: "definitionData": {
+// CHECK-NEXT: "canPassInRegisters": true,
+// CHECK-NEXT: "copyAssign": {
+// CHECK-NEXT: "hasConstParam": true,
+// CHECK-NEXT: "implicitHasConstParam": true,
+// CHECK-NEXT: "needsImplicit": true,
+// CHECK-NEXT: "simple": true,
+// CHECK-NEXT: "trivial": true
+// CHECK-NEXT: },
+// CHECK-NEXT: "copyCtor": {
+// CHECK-NEXT: "hasConstParam": true,
+// CHECK-NEXT: "implicitHasConstParam": true,
+// CHECK-NEXT: "needsImplicit": true,
+// CHECK-NEXT: "simple": true,
+// CHECK-NEXT: "trivial": true
+// CHECK-NEXT: },
+// CHECK-NEXT: "defaultCtor": {
+// CHECK-NEXT: "exists": true,
+// CHECK-NEXT: "needsImplicit": true,
+// CHECK-NEXT: "trivial": true
+// CHECK-NEXT: },
+// CHECK-NEXT: "dtor": {
+// CHECK-NEXT: "irrelevant": true,
+// CHECK-NEXT: "needsImplicit": true,
+// CHECK-NEXT: "simple": true,
+// CHECK-NEXT: "trivial": true
+// CHECK-NEXT: },
+// CHECK-NEXT: "isAggregate": true,
+// CHECK-NEXT: "isLiteral": true,
+// CHECK-NEXT: "isPOD": true,
+// CHECK-NEXT: "isStandardLayout": true,
+// CHECK-NEXT: "isTrivial": true,
+// CHECK-NEXT: "isTriviallyCopyable": true,
+// CHECK-NEXT: "moveAssign": {
+// CHECK-NEXT: "exists": true,
+// CHECK-NEXT: "needsImplicit": true,
+// CHECK-NEXT: "simple": true,
+// CHECK-NEXT: "trivial": true
+// CHECK-NEXT: },
+// CHECK-NEXT: "moveCtor": {
+// CHECK-NEXT: "exists": true,
+// CHECK-NEXT: "needsImplicit": true,
+// CHECK-NEXT: "simple": true,
+// CHECK-NEXT: "trivial": true
+// CHECK-NEXT: }
+// CHECK-NEXT: },
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
-// CHECK-NEXT: "kind": "RecordType",
+// CHECK-NEXT: "kind": "CXXRecordDecl",
+// CHECK-NEXT: "loc": {
+// CHECK-NEXT: "offset": 158,
+// CHECK-NEXT: "line": 7,
+// CHECK-NEXT: "col": 8,
+// CHECK-NEXT: "tokLen": 1
+// CHECK-NEXT: },
+// CHECK-NEXT: "range": {
+// CHECK-NEXT: "begin": {
+// CHECK-NEXT: "offset": 151,
+// CHECK-NEXT: "col": 1,
+// CHECK-NEXT: "tokLen": 6
+// CHECK-NEXT: },
+// CHECK-NEXT: "end": {
+// CHECK-NEXT: "offset": 158,
+// CHECK-NEXT: "col": 8,
+// CHECK-NEXT: "tokLen": 1
+// CHECK-NEXT: }
+// CHECK-NEXT: },
+// CHECK-NEXT: "isImplicit": true,
+// CHECK-NEXT: "name": "T",
+// CHECK-NEXT: "tagUsed": "struct"
+// CHECK-NEXT: },
+// CHECK-NEXT: {
+// CHECK-NEXT: "id": "0x{{.*}}",
+// CHECK-NEXT: "kind": "FieldDecl",
+// CHECK-NEXT: "loc": {
+// CHECK-NEXT: "offset": 168,
+// CHECK-NEXT: "line": 8,
+// CHECK-NEXT: "col": 7,
+// CHECK-NEXT: "tokLen": 1
+// CHECK-NEXT: },
+// CHECK-NEXT: "range": {
+// CHECK-NEXT: "begin": {
+// CHECK-NEXT: "offset": 164,
+// CHECK-NEXT: "col": 3,
+// CHECK-NEXT: "tokLen": 3
+// CHECK-NEXT: },
+// CHECK-NEXT: "end": {
+// CHECK-NEXT: "offset": 168,
+// CHECK-NEXT: "col": 7,
+// CHECK-NEXT: "tokLen": 1
+// CHECK-NEXT: }
+// CHECK-NEXT: },
+// CHECK-NEXT: "name": "I",
// CHECK-NEXT: "type": {
-// CHECK-NEXT: "qualType": "T"
+// CHECK-NEXT: "qualType": "int"
+// CHECK-NEXT: }
+// CHECK-NEXT: },
+// CHECK-NEXT: {
+// CHECK-NEXT: "id": "0x{{.*}}",
+// CHECK-NEXT: "kind": "CXXMethodDecl",
+// CHECK-NEXT: "loc": {
+// CHECK-NEXT: "offset": 178,
+// CHECK-NEXT: "line": 9,
+// CHECK-NEXT: "col": 8,
+// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
-// CHECK-NEXT: "decl": {
-// CHECK-NEXT: "id": "0x{{.*}}",
-// CHECK-NEXT: "kind": "CXXRecordDecl",
-// CHECK-NEXT: "name": "T"
+// CHECK-NEXT: "range": {
+// CHECK-NEXT: "begin": {
+// CHECK-NEXT: "offset": 173,
+// CHECK-NEXT: "col": 3,
+// CHECK-NEXT: "tokLen": 4
+// CHECK-NEXT: },
+// CHECK-NEXT: "end": {
+// CHECK-NEXT: "offset": 180,
+// CHECK-NEXT: "col": 10,
+// CHECK-NEXT: "tokLen": 1
+// CHECK-NEXT: }
+// CHECK-NEXT: },
+// CHECK-NEXT: "name": "F",
+// CHECK-NEXT: "mangledName": "_ZN1T1FEv",
+// CHECK-NEXT: "type": {
+// CHECK-NEXT: "qualType": "void ()"
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: ]
@@ -298,10 +445,11 @@ using ::TestUsingShadowDeclType;
// CHECK-NEXT: ]
// CHECK-NEXT: }
+
// CHECK-NOT: {{^}}Dumping
// CHECK: "kind": "TypedefDecl",
// CHECK-NEXT: "loc": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 416,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 19,
// CHECK-NEXT: "col": 17,
@@ -309,12 +457,12 @@ using ::TestUsingShadowDeclType;
// CHECK-NEXT: },
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 400,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 7
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 416,
// CHECK-NEXT: "col": 17,
// CHECK-NEXT: "tokLen": 25
// CHECK-NEXT: }
@@ -334,21 +482,164 @@ using ::TestUsingShadowDeclType;
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
-// CHECK-NEXT: "kind": "ElaboratedType",
+// CHECK-NEXT: "kind": "RecordType",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "T"
// CHECK-NEXT: },
+// CHECK-NEXT: "decl": {
+// CHECK-NEXT: "id": "0x{{.*}}",
+// CHECK-NEXT: "kind": "CXXRecordDecl",
+// CHECK-NEXT: "name": "T"
+// CHECK-NEXT: }
+// CHECK-NEXT: },
+// CHECK-NEXT: {
+// CHECK-NEXT: "id": "0x{{.*}}",
+// CHECK-NEXT: "kind": "CXXRecordDecl",
+// CHECK-NEXT: "loc": {
+// CHECK-NEXT: "offset": 158,
+// CHECK-NEXT: "line": 7,
+// CHECK-NEXT: "col": 8,
+// CHECK-NEXT: "tokLen": 1
+// CHECK-NEXT: },
+// CHECK-NEXT: "range": {
+// CHECK-NEXT: "begin": {
+// CHECK-NEXT: "offset": 151,
+// CHECK-NEXT: "col": 1,
+// CHECK-NEXT: "tokLen": 6
+// CHECK-NEXT: },
+// CHECK-NEXT: "end": {
+// CHECK-NEXT: "offset": 183,
+// CHECK-NEXT: "line": 10,
+// CHECK-NEXT: "col": 1,
+// CHECK-NEXT: "tokLen": 1
+// CHECK-NEXT: }
+// CHECK-NEXT: },
+// CHECK-NEXT: "name": "T",
+// CHECK-NEXT: "tagUsed": "struct",
+// CHECK-NEXT: "completeDefinition": true,
+// CHECK-NEXT: "definitionData": {
+// CHECK-NEXT: "canPassInRegisters": true,
+// CHECK-NEXT: "copyAssign": {
+// CHECK-NEXT: "hasConstParam": true,
+// CHECK-NEXT: "implicitHasConstParam": true,
+// CHECK-NEXT: "needsImplicit": true,
+// CHECK-NEXT: "simple": true,
+// CHECK-NEXT: "trivial": true
+// CHECK-NEXT: },
+// CHECK-NEXT: "copyCtor": {
+// CHECK-NEXT: "hasConstParam": true,
+// CHECK-NEXT: "implicitHasConstParam": true,
+// CHECK-NEXT: "needsImplicit": true,
+// CHECK-NEXT: "simple": true,
+// CHECK-NEXT: "trivial": true
+// CHECK-NEXT: },
+// CHECK-NEXT: "defaultCtor": {
+// CHECK-NEXT: "exists": true,
+// CHECK-NEXT: "needsImplicit": true,
+// CHECK-NEXT: "trivial": true
+// CHECK-NEXT: },
+// CHECK-NEXT: "dtor": {
+// CHECK-NEXT: "irrelevant": true,
+// CHECK-NEXT: "needsImplicit": true,
+// CHECK-NEXT: "simple": true,
+// CHECK-NEXT: "trivial": true
+// CHECK-NEXT: },
+// CHECK-NEXT: "isAggregate": true,
+// CHECK-NEXT: "isLiteral": true,
+// CHECK-NEXT: "isPOD": true,
+// CHECK-NEXT: "isStandardLayout": true,
+// CHECK-NEXT: "isTrivial": true,
+// CHECK-NEXT: "isTriviallyCopyable": true,
+// CHECK-NEXT: "moveAssign": {
+// CHECK-NEXT: "exists": true,
+// CHECK-NEXT: "needsImplicit": true,
+// CHECK-NEXT: "simple": true,
+// CHECK-NEXT: "trivial": true
+// CHECK-NEXT: },
+// CHECK-NEXT: "moveCtor": {
+// CHECK-NEXT: "exists": true,
+// CHECK-NEXT: "needsImplicit": true,
+// CHECK-NEXT: "simple": true,
+// CHECK-NEXT: "trivial": true
+// CHECK-NEXT: }
+// CHECK-NEXT: },
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
-// CHECK-NEXT: "kind": "RecordType",
+// CHECK-NEXT: "kind": "CXXRecordDecl",
+// CHECK-NEXT: "loc": {
+// CHECK-NEXT: "offset": 158,
+// CHECK-NEXT: "line": 7,
+// CHECK-NEXT: "col": 8,
+// CHECK-NEXT: "tokLen": 1
+// CHECK-NEXT: },
+// CHECK-NEXT: "range": {
+// CHECK-NEXT: "begin": {
+// CHECK-NEXT: "offset": 151,
+// CHECK-NEXT: "col": 1,
+// CHECK-NEXT: "tokLen": 6
+// CHECK-NEXT: },
+// CHECK-NEXT: "end": {
+// CHECK-NEXT: "offset": 158,
+// CHECK-NEXT: "col": 8,
+// CHECK-NEXT: "tokLen": 1
+// CHECK-NEXT: }
+// CHECK-NEXT: },
+// CHECK-NEXT: "isImplicit": true,
+// CHECK-NEXT: "name": "T",
+// CHECK-NEXT: "tagUsed": "struct"
+// CHECK-NEXT: },
+// CHECK-NEXT: {
+// CHECK-NEXT: "id": "0x{{.*}}",
+// CHECK-NEXT: "kind": "FieldDecl",
+// CHECK-NEXT: "loc": {
+// CHECK-NEXT: "offset": 168,
+// CHECK-NEXT: "line": 8,
+// CHECK-NEXT: "col": 7,
+// CHECK-NEXT: "tokLen": 1
+// CHECK-NEXT: },
+// CHECK-NEXT: "range": {
+// CHECK-NEXT: "begin": {
+// CHECK-NEXT: "offset": 164,
+// CHECK-NEXT: "col": 3,
+// CHECK-NEXT: "tokLen": 3
+// CHECK-NEXT: },
+// CHECK-NEXT: "end": {
+// CHECK-NEXT: "offset": 168,
+// CHECK-NEXT: "col": 7,
+// CHECK-NEXT: "tokLen": 1
+// CHECK-NEXT: }
+// CHECK-NEXT: },
+// CHECK-NEXT: "name": "I",
// CHECK-NEXT: "type": {
-// CHECK-NEXT: "qualType": "T"
+// CHECK-NEXT: "qualType": "int"
+// CHECK-NEXT: }
+// CHECK-NEXT: },
+// CHECK-NEXT: {
+// CHECK-NEXT: "id": "0x{{.*}}",
+// CHECK-NEXT: "kind": "CXXMethodDecl",
+// CHECK-NEXT: "loc": {
+// CHECK-NEXT: "offset": 178,
+// CHECK-NEXT: "line": 9,
+// CHECK-NEXT: "col": 8,
+// CHECK-NEXT: "tokLen": 1
+// CHECK-NEXT: },
+// CHECK-NEXT: "range": {
+// CHECK-NEXT: "begin": {
+// CHECK-NEXT: "offset": 173,
+// CHECK-NEXT: "col": 3,
+// CHECK-NEXT: "tokLen": 4
+// CHECK-NEXT: },
+// CHECK-NEXT: "end": {
+// CHECK-NEXT: "offset": 180,
+// CHECK-NEXT: "col": 10,
+// CHECK-NEXT: "tokLen": 1
+// CHECK-NEXT: }
// CHECK-NEXT: },
-// CHECK-NEXT: "decl": {
-// CHECK-NEXT: "id": "0x{{.*}}",
-// CHECK-NEXT: "kind": "CXXRecordDecl",
-// CHECK-NEXT: "name": "T"
+// CHECK-NEXT: "name": "F",
+// CHECK-NEXT: "mangledName": "_ZN1T1FEv",
+// CHECK-NEXT: "type": {
+// CHECK-NEXT: "qualType": "void ()"
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: ]
@@ -365,10 +656,11 @@ using ::TestUsingShadowDeclType;
// CHECK-NEXT: ]
// CHECK-NEXT: }
+
// CHECK-NOT: {{^}}Dumping
// CHECK: "kind": "TypedefDecl",
// CHECK-NEXT: "loc": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 456,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 21,
// CHECK-NEXT: "col": 13,
@@ -376,12 +668,12 @@ using ::TestUsingShadowDeclType;
// CHECK-NEXT: },
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 444,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 7
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 490,
// CHECK-NEXT: "col": 47,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
@@ -437,10 +729,11 @@ using ::TestUsingShadowDeclType;
// CHECK-NEXT: ]
// CHECK-NEXT: }
+
// CHECK-NOT: {{^}}Dumping
// CHECK: "kind": "TypedefDecl",
// CHECK-NEXT: "loc": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 506,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 23,
// CHECK-NEXT: "col": 13,
@@ -448,12 +741,12 @@ using ::TestUsingShadowDeclType;
// CHECK-NEXT: },
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 494,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 7
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 506,
// CHECK-NEXT: "col": 13,
// CHECK-NEXT: "tokLen": 23
// CHECK-NEXT: }
@@ -473,10 +766,11 @@ using ::TestUsingShadowDeclType;
// CHECK-NEXT: ]
// CHECK-NEXT: }
+
// CHECK-NOT: {{^}}Dumping
// CHECK: "kind": "NamespaceDecl",
// CHECK-NEXT: "loc": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 541,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 24,
// CHECK-NEXT: "col": 11,
@@ -484,12 +778,12 @@ using ::TestUsingShadowDeclType;
// CHECK-NEXT: },
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 531,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 9
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 609,
// CHECK-NEXT: "line": 26,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 1
@@ -501,19 +795,19 @@ using ::TestUsingShadowDeclType;
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "UsingDecl",
// CHECK-NEXT: "loc": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 584,
// CHECK-NEXT: "line": 25,
// CHECK-NEXT: "col": 9,
// CHECK-NEXT: "tokLen": 23
// CHECK-NEXT: },
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 576,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 5
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 584,
// CHECK-NEXT: "col": 9,
// CHECK-NEXT: "tokLen": 23
// CHECK-NEXT: }
@@ -524,18 +818,18 @@ using ::TestUsingShadowDeclType;
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "UsingShadowDecl",
// CHECK-NEXT: "loc": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 584,
// CHECK-NEXT: "col": 9,
// CHECK-NEXT: "tokLen": 23
// CHECK-NEXT: },
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 584,
// CHECK-NEXT: "col": 9,
// CHECK-NEXT: "tokLen": 23
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
-// CHECK-NEXT: "offset": {{[0-9]+}},
+// CHECK-NEXT: "offset": 584,
// CHECK-NEXT: "col": 9,
// CHECK-NEXT: "tokLen": 23
// CHECK-NEXT: }
diff --git a/clang/test/AST/attr-print-emit.cpp b/clang/test/AST/attr-print-emit.cpp
index 77826f8f9af09..66dbc50ecfd3c 100644
--- a/clang/test/AST/attr-print-emit.cpp
+++ b/clang/test/AST/attr-print-emit.cpp
@@ -1,5 +1,5 @@
// RUN: %clang_cc1 %s -ast-print | FileCheck %s
-// RUN: %clang -emit-ast -o %t.ast %s
+// RUN: %clang_cc1 -emit-pch -o %t.ast %s
// RUN: %clang_cc1 %t.ast -ast-print | FileCheck %s
// CHECK: void *aa() __attribute__((assume_aligned(64)));
diff --git a/clang/test/Analysis/cxx-uninitialized-object-ptr-ref.cpp b/clang/test/Analysis/cxx-uninitialized-object-ptr-ref.cpp
index f46a2c9bc368f..d0eb9e80d6395 100644
--- a/clang/test/Analysis/cxx-uninitialized-object-ptr-ref.cpp
+++ b/clang/test/Analysis/cxx-uninitialized-object-ptr-ref.cpp
@@ -430,8 +430,8 @@ void fIntDynTypedVoidPointerTest1() {
struct RecordDynTypedVoidPointerTest {
struct RecordType {
- int x; // expected-note{{uninitialized field 'static_cast<struct RecordDynTypedVoidPointerTest::RecordType *>(this->vptr)->x'}}
- int y; // expected-note{{uninitialized field 'static_cast<struct RecordDynTypedVoidPointerTest::RecordType *>(this->vptr)->y'}}
+ int x; // expected-note{{uninitialized field 'static_cast<RecordDynTypedVoidPointerTest::RecordType *>(this->vptr)->x'}}
+ int y; // expected-note{{uninitialized field 'static_cast<RecordDynTypedVoidPointerTest::RecordType *>(this->vptr)->y'}}
};
void *vptr;
@@ -447,9 +447,9 @@ void fRecordDynTypedVoidPointerTest() {
struct NestedNonVoidDynTypedVoidPointerTest {
struct RecordType {
- int x; // expected-note{{uninitialized field 'static_cast<struct NestedNonVoidDynTypedVoidPointerTest::RecordType *>(this->vptr)->x'}}
- int y; // expected-note{{uninitialized field 'static_cast<struct NestedNonVoidDynTypedVoidPointerTest::RecordType *>(this->vptr)->y'}}
- void *vptr; // expected-note{{uninitialized pointee 'static_cast<char *>(static_cast<struct NestedNonVoidDynTypedVoidPointerTest::RecordType *>(this->vptr)->vptr)'}}
+ int x; // expected-note{{uninitialized field 'static_cast<NestedNonVoidDynTypedVoidPointerTest::RecordType *>(this->vptr)->x'}}
+ int y; // expected-note{{uninitialized field 'static_cast<NestedNonVoidDynTypedVoidPointerTest::RecordType *>(this->vptr)->y'}}
+ void *vptr; // expected-note{{uninitialized pointee 'static_cast<char *>(static_cast<NestedNonVoidDynTypedVoidPointerTest::RecordType *>(this->vptr)->vptr)'}}
};
void *vptr;
diff --git a/clang/test/CXX/class.access/p6.cpp b/clang/test/CXX/class.access/p6.cpp
index 510aaa208982f..6f266728faa6b 100644
--- a/clang/test/CXX/class.access/p6.cpp
+++ b/clang/test/CXX/class.access/p6.cpp
@@ -113,7 +113,7 @@ namespace test4 {
};
template <class U> void foo(U &, typename U::type) {}
-
+
void test() {
A<int> a;
foo(a, 0);
@@ -176,7 +176,7 @@ namespace test8 {
};
void test(A &a) {
- if (a) return; // expected-error-re {{'operator void *(test8::A::*)(){{( __attribute__\(\(thiscall\)\))?}} const' is a private member of 'test8::A'}}
+ if (a) return; // expected-error-re {{'operator void *(A::*)(){{( __attribute__\(\(thiscall\)\))?}} const' is a private member of 'test8::A'}}
}
}
diff --git a/clang/test/CXX/drs/cwg0xx.cpp b/clang/test/CXX/drs/cwg0xx.cpp
index 282e71bbf3bda..4d4e2f64ff643 100644
--- a/clang/test/CXX/drs/cwg0xx.cpp
+++ b/clang/test/CXX/drs/cwg0xx.cpp
@@ -859,7 +859,7 @@ namespace cwg54 { // cwg54: 2.8
// expected-error at -1 {{cannot cast 'struct B' to its private base class 'A'}}
// expected-note@#cwg54-B {{declared private here}}
int A::*smab = static_cast<int A::*>(&B::b);
- // expected-error at -1 {{cannot cast 'cwg54::B' to its private base class 'A'}}
+ // expected-error at -1 {{cannot cast 'B' to its private base class 'A'}}
// expected-note@#cwg54-B {{declared private here}}
B &sba = static_cast<B&>(a);
// expected-error at -1 {{cannot cast private base class 'cwg54::A' to 'cwg54::B'}}
@@ -868,19 +868,19 @@ namespace cwg54 { // cwg54: 2.8
// expected-error at -1 {{cannot cast private base class 'cwg54::A' to 'cwg54::B'}}
// expected-note@#cwg54-B {{declared private here}}
int B::*smba = static_cast<int B::*>(&A::a);
- // expected-error at -1 {{cannot cast private base class 'cwg54::A' to 'B'}}
+ // expected-error at -1 {{cannot cast private base class 'A' to 'B'}}
// expected-note@#cwg54-B {{declared private here}}
V &svb = static_cast<V&>(b);
V *spvb = static_cast<V*>(&b);
int V::*smvb = static_cast<int V::*>(&B::b);
- // expected-error at -1 {{conversion from pointer to member of class 'cwg54::B' to pointer to member of class 'V' via virtual base 'cwg54::V' is not allowed}}
+ // expected-error at -1 {{conversion from pointer to member of class 'B' to pointer to member of class 'V' via virtual base 'cwg54::V' is not allowed}}
B &sbv = static_cast<B&>(v);
// expected-error at -1 {{cannot cast 'struct V' to 'B &' via virtual base 'cwg54::V'}}
B *spbv = static_cast<B*>(&v);
// expected-error at -1 {{cannot cast 'cwg54::V *' to 'B *' via virtual base 'cwg54::V'}}
int B::*smbv = static_cast<int B::*>(&V::v);
- // expected-error at -1 {{conversion from pointer to member of class 'cwg54::V' to pointer to member of class 'B' via virtual base 'cwg54::V' is not allowed}}
+ // expected-error at -1 {{conversion from pointer to member of class 'V' to pointer to member of class 'B' via virtual base 'cwg54::V' is not allowed}}
A &cab = (A&)(b);
A *cpab = (A*)(&b);
@@ -892,13 +892,13 @@ namespace cwg54 { // cwg54: 2.8
V &cvb = (V&)(b);
V *cpvb = (V*)(&b);
int V::*cmvb = (int V::*)(&B::b);
- // expected-error at -1 {{conversion from pointer to member of class 'cwg54::B' to pointer to member of class 'V' via virtual base 'cwg54::V' is not allowed}}
+ // expected-error at -1 {{conversion from pointer to member of class 'B' to pointer to member of class 'V' via virtual base 'cwg54::V' is not allowed}}
B &cbv = (B&)(v);
// expected-error at -1 {{cannot cast 'struct V' to 'B &' via virtual base 'cwg54::V'}}
B *cpbv = (B*)(&v);
// expected-error at -1 {{cannot cast 'cwg54::V *' to 'B *' via virtual base 'cwg54::V'}}
int B::*cmbv = (int B::*)(&V::v);
- // expected-error at -1 {{conversion from pointer to member of class 'cwg54::V' to pointer to member of class 'B' via virtual base 'cwg54::V' is not allowed}}
+ // expected-error at -1 {{conversion from pointer to member of class 'V' to pointer to member of class 'B' via virtual base 'cwg54::V' is not allowed}}
} // namespace cwg54
namespace cwg55 { // cwg55: 2.7
diff --git a/clang/test/CXX/drs/cwg13xx.cpp b/clang/test/CXX/drs/cwg13xx.cpp
index 9c72fefb5b65c..92b9f3a1bb357 100644
--- a/clang/test/CXX/drs/cwg13xx.cpp
+++ b/clang/test/CXX/drs/cwg13xx.cpp
@@ -204,7 +204,7 @@ namespace cwg1330 { // cwg1330: 4 c++11
// since-cxx17-note at -2 {{use 'noexcept(false)' instead}}
void (A::*af2)() throw() = &A::f;
// cxx98-14-error at -1 {{target exception specification is not superset of source}}
- // since-cxx17-error at -2 {{cannot initialize a variable of type 'void (A::*)() throw()' with an rvalue of type 'void (cwg1330::A::*)() throw(T)': different exception specifications}}
+ // since-cxx17-error at -2 {{cannot initialize a variable of type 'void (A::*)() throw()' with an rvalue of type 'void (A::*)() throw(T)': different exception specifications}}
#if __cplusplus >= 201103L
static_assert(noexcept(A().g()), "");
@@ -252,7 +252,7 @@ namespace cwg1330 { // cwg1330: 4 c++11
void (B<P>::*bpf3)() = &B<P>::f;
void (B<P>::*bpf4)() throw() = &B<P>::f;
// cxx98-14-error at -1 {{target exception specification is not superset of source}}
- // since-cxx17-error at -2 {{cannot initialize a variable of type 'void (B<P>::*)() throw()' with an rvalue of type 'void (cwg1330::B<cwg1330::P>::*)() throw(T, typename P::type)': different exception specifications}}
+ // since-cxx17-error at -2 {{cannot initialize a variable of type 'void (B<P>::*)() throw()' with an rvalue of type 'void (B<P>::*)() throw(T, typename P::type)': different exception specifications}}
#if __cplusplus >= 201103L
static_assert(noexcept(B<P>().g()), "");
diff --git a/clang/test/CXX/drs/cwg26xx.cpp b/clang/test/CXX/drs/cwg26xx.cpp
index a817a1ba3e31d..3eb70583b6026 100644
--- a/clang/test/CXX/drs/cwg26xx.cpp
+++ b/clang/test/CXX/drs/cwg26xx.cpp
@@ -142,8 +142,8 @@ struct foo {
void f() {
foo fooable; // #cwg2628-fooable
- // since-cxx20-error@#cwg2628-fooable {{call to deleted}}
- // since-cxx20-note@#cwg2628-ctor {{marked deleted here}}
+ // since-cxx20-error@#cwg2628-fooable {{call to deleted}}
+ // since-cxx20-note@#cwg2628-ctor {{marked deleted here}}
}
#endif
} // namespace cwg2628
@@ -336,7 +336,7 @@ struct S{
void test() {
(&S::f)(1);
- // since-cxx23-error at -1 {{called object type 'void (cwg2687::S::*)(int)' is not a function or function pointer}}
+ // since-cxx23-error at -1 {{called object type 'void (S::*)(int)' is not a function or function pointer}}
(&S::g)(1);
(&S::h)(S(), 1);
}
diff --git a/clang/test/CXX/drs/cwg2xx.cpp b/clang/test/CXX/drs/cwg2xx.cpp
index 4f383aacd4532..b621318a9ce41 100644
--- a/clang/test/CXX/drs/cwg2xx.cpp
+++ b/clang/test/CXX/drs/cwg2xx.cpp
@@ -98,8 +98,8 @@ template <class T> class Templ { // #cwg203-ex3-Templ
void foo() { Templ<Derived> x(&Derived::func); }
// expected-error at -1 {{no matching constructor for initialization of 'Templ<Derived>'}}
-// expected-note@#cwg203-ex3-Templ {{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'int (cwg203::ex3::Base::*)() const' to 'const Templ<Derived>' for 1st argument}}
-// since-cxx11-note@#cwg203-ex3-Templ {{candidate constructor (the implicit move constructor) not viable: no known conversion from 'int (cwg203::ex3::Base::*)() const' to 'Templ<Derived>' for 1st argument}}
+// expected-note@#cwg203-ex3-Templ {{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'int (Derived::*)() const' (aka 'int (Base::*)() const') to 'const Templ<Derived>' for 1st argument}}
+// since-cxx11-note@#cwg203-ex3-Templ {{candidate constructor (the implicit move constructor) not viable: no known conversion from 'int (Derived::*)() const' (aka 'int (Base::*)() const') to 'Templ<Derived>' for 1st argument}}
// expected-note@#cwg203-ex3-Templ-ctor {{candidate template ignored: could not match 'cwg203::ex3::Derived' against 'cwg203::ex3::Base'}}
} // namespace ex3
diff --git a/clang/test/CXX/drs/cwg4xx.cpp b/clang/test/CXX/drs/cwg4xx.cpp
index d76c6012b9195..d0bed9ddd5680 100644
--- a/clang/test/CXX/drs/cwg4xx.cpp
+++ b/clang/test/CXX/drs/cwg4xx.cpp
@@ -1176,7 +1176,7 @@ namespace cwg480 { // cwg480: 2.7
extern int D::*c;
int A::*d = static_cast<int A::*>(c);
- // expected-error at -1 {{conversion from pointer to member of class 'cwg480::D' to pointer to member of class 'A' via virtual base 'cwg480::B' is not allowed}}
+ // expected-error at -1 {{conversion from pointer to member of class 'D' to pointer to member of class 'A' via virtual base 'cwg480::B' is not allowed}}
D *e;
A *f = e;
diff --git a/clang/test/CXX/drs/cwg7xx.cpp b/clang/test/CXX/drs/cwg7xx.cpp
index a8ab2e2207167..9ff01f316e3d1 100644
--- a/clang/test/CXX/drs/cwg7xx.cpp
+++ b/clang/test/CXX/drs/cwg7xx.cpp
@@ -348,6 +348,5 @@ struct X {
};
struct Y : X {};
B Y::*pm = &X::d;
-// expected-error at -1 {{cannot initialize a variable of type 'B Y::*' with an rvalue of type 'D cwg794::X::*': different classes ('Y' vs 'cwg794::X')}}
-// FIXME: why diagnostic says just `Y` and not `cwg794::Y`, like `cwg794::X`?
+// expected-error at -1 {{cannot initialize a variable of type 'B Y::*' with an rvalue of type 'D X::*': different classes ('Y' vs 'X')}}
} // namespace cwg794
diff --git a/clang/test/CXX/temp/temp.arg/temp.arg.nontype/p1.cpp b/clang/test/CXX/temp/temp.arg/temp.arg.nontype/p1.cpp
index 629000d88acc3..73c7c75e2e0c6 100644
--- a/clang/test/CXX/temp/temp.arg/temp.arg.nontype/p1.cpp
+++ b/clang/test/CXX/temp/temp.arg/temp.arg.nontype/p1.cpp
@@ -169,7 +169,7 @@ namespace addr_of_obj_or_func {
struct Local { static int f() {} }; // precxx17-note {{here}}
X1<&Local::f> x1_no_linkage; // precxx17-error {{non-type template argument refers to function 'f' that does not have linkage}} cxx17-error {{value of type 'int (*)()' is not implicitly convertible to 'int (*)(int)'}}
- X0<&S::NonStaticMember> x0_non_static; // precxx17-error {{non-static data member}} cxx17-error {{value of type 'int addr_of_obj_or_func::S::*' is not implicitly convertible to 'int *'}}
+ X0<&S::NonStaticMember> x0_non_static; // precxx17-error {{non-static data member}} cxx17-error {{value of type 'int S::*' is not implicitly convertible to 'int *'}}
}
}
diff --git a/clang/test/CXX/temp/temp.arg/temp.arg.nontype/p5.cpp b/clang/test/CXX/temp/temp.arg/temp.arg.nontype/p5.cpp
index 034ad49d0715c..bf8f1af4b3ae6 100644
--- a/clang/test/CXX/temp/temp.arg/temp.arg.nontype/p5.cpp
+++ b/clang/test/CXX/temp/temp.arg/temp.arg.nontype/p5.cpp
@@ -223,7 +223,7 @@ namespace pointer_to_member_function {
template<int (Y::*)(int)> struct X0 {}; // expected-note 0-1{{template parameter is declared here}}
X0<&Y::f> x0a;
X0<&Y::g> x0b;
- X0<&Y::h> x0c; // expected-error-re{{type 'float (pointer_to_member_function::Y::*)(float){{( __attribute__\(\(thiscall\)\))?}}' {{.*}} convert{{.*}} 'int (Y::*)(int){{( __attribute__\(\(thiscall\)\))?}}'}}
+ X0<&Y::h> x0c; // expected-error-re{{type 'float (Y::*)(float){{( __attribute__\(\(thiscall\)\))?}}' {{.*}} convert{{.*}} 'int (Y::*)(int){{( __attribute__\(\(thiscall\)\))?}}'}}
}
// -- For a non-type template-parameter of type pointer to data member,
@@ -238,9 +238,9 @@ namespace pointer_to_member_data {
X0<&Y::y> x0a;
X0<&Y::x> x0b;
#if __cplusplus <= 201402L
- // expected-error at -2 {{non-type template argument of type 'int pointer_to_member_data::X::*' cannot be converted to a value of type 'int Y::*'}}
+ // expected-error at -2 {{non-type template argument of type 'int Y::*' (aka 'int X::*') cannot be converted to a value of type 'int Y::*'}}
#else
- // expected-error at -4 {{conversion from 'int pointer_to_member_data::X::*' to 'int Y::*' is not allowed in a converted constant expression}}
+ // expected-error at -4 {{conversion from 'int Y::*' (aka 'int X::*') to 'int Y::*' is not allowed in a converted constant expression}}
#endif
// Test qualification conversions
diff --git a/clang/test/Index/print-type.cpp b/clang/test/Index/print-type.cpp
index 35bf511303332..141895d1dd2b2 100644
--- a/clang/test/Index/print-type.cpp
+++ b/clang/test/Index/print-type.cpp
@@ -163,7 +163,7 @@ inline namespace InlineNS {}
// CHECK: DeclRefExpr=i:44:14 [type=int] [typekind=Int] [isPOD=1]
// CHECK: StructDecl=Blob:46:8 (Definition) [type=Blob] [typekind=Record] [isPOD=1] [nbFields=2]
// CHECK: FieldDecl=i:47:7 (Definition) [type=int] [typekind=Int] [isPOD=1]
-// CHECK: VarDecl=member_pointer:50:12 (Definition) [type=int Blob::*] [typekind=MemberPointer] [canonicaltype=int Blob::*] [canonicaltypekind=MemberPointer] [isPOD=1]
+// CHECK: VarDecl=member_pointer:50:12 (Definition) [type=int Blob::*] [typekind=MemberPointer] [isPOD=1] [pointeetype=int] [pointeekind=Int] [isAnonRecDecl=0]
// CHECK: FunctionDecl=elaboratedNamespaceType:52:42 [type=NS::Type (const NS::Type)] [typekind=FunctionProto] [canonicaltype=NS::Type (NS::Type)] [canonicaltypekind=FunctionProto] [resulttype=NS::Type] [resulttypekind=Elaborated] [args= [const NS::Type] [Elaborated]] [isPOD=0]
// CHECK: NamespaceRef=NS:52:11 [type=] [typekind=Invalid] [isPOD=0]
// CHECK: TypeRef=struct NS::Type:52:23 [type=NS::Type] [typekind=Record] [isPOD=1]
diff --git a/clang/test/SemaCXX/addr-of-overloaded-function.cpp b/clang/test/SemaCXX/addr-of-overloaded-function.cpp
index 99f5ba613938d..5568bec2b7910 100644
--- a/clang/test/SemaCXX/addr-of-overloaded-function.cpp
+++ b/clang/test/SemaCXX/addr-of-overloaded-function.cpp
@@ -1,6 +1,6 @@
-// RUN: %clang_cc1 -fsyntax-only -verify %s
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
int f(double); // expected-note{{candidate function}}
int f(int); // expected-note{{candidate function}}
@@ -139,7 +139,7 @@ namespace PR8196 {
template <typename T> struct mcdata {
typedef int result_type;
};
- template <class T>
+ template <class T>
typename mcdata<T>::result_type wrap_mean(mcdata<T> const&);
void add_property(double(*)(mcdata<double> const &)); // expected-note{{candidate function not viable: no overload of 'wrap_mean' matching}}
void f() {
@@ -204,7 +204,7 @@ namespace test1 {
double foo(int x, float y) {return 0;} // expected-note {{candidate function has different number of parameters (expected 1 but has 2)}}
double foo(float x) {return 0;} // expected-note {{candidate function has type mismatch at 1st parameter (expected 'int' but has 'float')}}
double foo(int x) {return 0;} // expected-note {{candidate function has different return type ('int' expected but has 'double')}}
-
+
int (*ptr)(int) = &foo; // expected-error {{address of overloaded function 'foo' does not match required type 'int (int)'}}
struct Qualifiers {
@@ -221,20 +221,20 @@ namespace test1 {
void QualifierTest() {
void (Qualifiers::*X)();
- X = &Qualifiers::C; // expected-error-re {{assigning to 'void (Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} const': different qualifiers (unqualified vs 'const')}}
- X = &Qualifiers::V; // expected-error-re{{assigning to 'void (Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} volatile': different qualifiers (unqualified vs 'volatile')}}
- X = &Qualifiers::R; // expected-error-re{{assigning to 'void (Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} __restrict': different qualifiers (unqualified vs '__restrict')}}
- X = &Qualifiers::CV; // expected-error-re{{assigning to 'void (Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} const volatile': different qualifiers (unqualified vs 'const volatile')}}
- X = &Qualifiers::CR; // expected-error-re{{assigning to 'void (Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} const __restrict': different qualifiers (unqualified vs 'const __restrict')}}
- X = &Qualifiers::VR; // expected-error-re{{assigning to 'void (Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} volatile __restrict': different qualifiers (unqualified vs 'volatile __restrict')}}
- X = &Qualifiers::CVR; // expected-error-re{{assigning to 'void (Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} const volatile __restrict': different qualifiers (unqualified vs 'const volatile __restrict')}}
+ X = &Qualifiers::C; // expected-error-re {{assigning to 'void (Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} const': different qualifiers (unqualified vs 'const')}}
+ X = &Qualifiers::V; // expected-error-re{{assigning to 'void (Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} volatile': different qualifiers (unqualified vs 'volatile')}}
+ X = &Qualifiers::R; // expected-error-re{{assigning to 'void (Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} __restrict': different qualifiers (unqualified vs '__restrict')}}
+ X = &Qualifiers::CV; // expected-error-re{{assigning to 'void (Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} const volatile': different qualifiers (unqualified vs 'const volatile')}}
+ X = &Qualifiers::CR; // expected-error-re{{assigning to 'void (Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} const __restrict': different qualifiers (unqualified vs 'const __restrict')}}
+ X = &Qualifiers::VR; // expected-error-re{{assigning to 'void (Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} volatile __restrict': different qualifiers (unqualified vs 'volatile __restrict')}}
+ X = &Qualifiers::CVR; // expected-error-re{{assigning to 'void (Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} const volatile __restrict': different qualifiers (unqualified vs 'const volatile __restrict')}}
}
struct Dummy {
void N() {};
};
- void (Qualifiers::*X)() = &Dummy::N; // expected-error-re{{cannot initialize a variable of type 'void (Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' with an rvalue of type 'void (test1::Dummy::*)(){{( __attribute__\(\(thiscall\)\))?}}': different classes ('Qualifiers' vs 'test1::Dummy')}}
+ void (Qualifiers::*X)() = &Dummy::N; // expected-error-re{{cannot initialize a variable of type 'void (Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' with an rvalue of type 'void (Dummy::*)(){{( __attribute__\(\(thiscall\)\))?}}': different classes ('Qualifiers' vs 'Dummy')}}
}
template <typename T> class PR16561 {
diff --git a/clang/test/SemaCXX/builtin-ptrtomember-ambig.cpp b/clang/test/SemaCXX/builtin-ptrtomember-ambig.cpp
index 4330c0cc48aa5..e84c65196dfa0 100644
--- a/clang/test/SemaCXX/builtin-ptrtomember-ambig.cpp
+++ b/clang/test/SemaCXX/builtin-ptrtomember-ambig.cpp
@@ -18,7 +18,7 @@ struct C : B {
void foo(C c, int A::* pmf) {
int i = c->*pmf; // expected-error {{use of overloaded operator '->*' is ambiguous}} \
- // expected-note {{built-in candidate operator->*(const struct A *, int struct A::*)}} \
- // expected-note {{built-in candidate operator->*(struct A *, int struct A::*)}}
+ // expected-note {{built-in candidate operator->*(const struct A *, int A::*)}} \
+ // expected-note {{built-in candidate operator->*(struct A *, int A::*)}}
}
diff --git a/clang/test/SemaCXX/calling-conv-compat.cpp b/clang/test/SemaCXX/calling-conv-compat.cpp
index 5a51e34b1478c..9bb448ffef225 100644
--- a/clang/test/SemaCXX/calling-conv-compat.cpp
+++ b/clang/test/SemaCXX/calling-conv-compat.cpp
@@ -183,31 +183,31 @@ typedef void ( C::*memb_c_default)();
typedef void (__cdecl C::*memb_c_cdecl)();
typedef void (__thiscall C::*memb_c_thiscall)();
-// expected-note at +1 {{candidate function not viable: no known conversion from 'void (NonVariadic::A::*)() __attribute__((cdecl))' to 'memb_a_default' (aka 'void (A::*)() __attribute__((thiscall))') for 1st argument}}
+// expected-note at +1 {{candidate function not viable: no known conversion from 'void (A::*)() __attribute__((cdecl))' to 'memb_a_default' (aka 'void (A::*)() __attribute__((thiscall))') for 1st argument}}
void cb_memb_a_default(memb_a_default ptr);
-// expected-note at +2 {{candidate function not viable: no known conversion from 'void (NonVariadic::A::*)() __attribute__((thiscall))' to 'memb_a_cdecl' (aka 'void (A::*)() __attribute__((cdecl))') for 1st argument}}
-// expected-note at +1 {{candidate function not viable: no known conversion from 'void (NonVariadic::A::*)() __attribute__((thiscall))' to 'memb_a_cdecl' (aka 'void (A::*)() __attribute__((cdecl))') for 1st argument}}
+// expected-note at +2 {{candidate function not viable: no known conversion from 'void (A::*)() __attribute__((thiscall))' to 'memb_a_cdecl' (aka 'void (A::*)() __attribute__((cdecl))') for 1st argument}}
+// expected-note at +1 {{candidate function not viable: no known conversion from 'void (A::*)() __attribute__((thiscall))' to 'memb_a_cdecl' (aka 'void (A::*)() __attribute__((cdecl))') for 1st argument}}
void cb_memb_a_cdecl(memb_a_cdecl ptr);
-// expected-note at +1 {{candidate function not viable: no known conversion from 'void (NonVariadic::A::*)() __attribute__((cdecl))' to 'memb_a_thiscall' (aka 'void (A::*)() __attribute__((thiscall))') for 1st argument}}
+// expected-note at +1 {{candidate function not viable: no known conversion from 'void (A::*)() __attribute__((cdecl))' to 'memb_a_thiscall' (aka 'void (A::*)() __attribute__((thiscall))') for 1st argument}}
void cb_memb_a_thiscall(memb_a_thiscall ptr);
-// expected-note at +1 {{candidate function not viable: no known conversion from 'void (NonVariadic::A::*)() __attribute__((cdecl))' to 'memb_b_default' (aka 'void (B::*)() __attribute__((thiscall))') for 1st argument}}
+// expected-note at +1 {{candidate function not viable: no known conversion from 'void (A::*)() __attribute__((cdecl))' to 'memb_b_default' (aka 'void (B::*)() __attribute__((thiscall))') for 1st argument}}
void cb_memb_b_default(memb_b_default ptr);
-// expected-note at +2 {{candidate function not viable: no known conversion from 'void (NonVariadic::A::*)() __attribute__((thiscall))' to 'memb_b_cdecl' (aka 'void (B::*)() __attribute__((cdecl))') for 1st argument}}
-// expected-note at +1 {{candidate function not viable: no known conversion from 'void (NonVariadic::A::*)() __attribute__((thiscall))' to 'memb_b_cdecl' (aka 'void (B::*)() __attribute__((cdecl))') for 1st argument}}
+// expected-note at +2 {{candidate function not viable: no known conversion from 'void (A::*)() __attribute__((thiscall))' to 'memb_b_cdecl' (aka 'void (B::*)() __attribute__((cdecl))') for 1st argument}}
+// expected-note at +1 {{candidate function not viable: no known conversion from 'void (A::*)() __attribute__((thiscall))' to 'memb_b_cdecl' (aka 'void (B::*)() __attribute__((cdecl))') for 1st argument}}
void cb_memb_b_cdecl(memb_b_cdecl ptr);
-// expected-note at +1 {{candidate function not viable: no known conversion from 'void (NonVariadic::A::*)() __attribute__((cdecl))' to 'memb_b_thiscall' (aka 'void (B::*)() __attribute__((thiscall))') for 1st argument}}
+// expected-note at +1 {{candidate function not viable: no known conversion from 'void (A::*)() __attribute__((cdecl))' to 'memb_b_thiscall' (aka 'void (B::*)() __attribute__((thiscall))') for 1st argument}}
void cb_memb_b_thiscall(memb_b_thiscall ptr);
-// expected-note at +3 {{candidate function not viable: no known conversion from 'void (NonVariadic::A::*)() __attribute__((thiscall))' to 'memb_c_default' (aka 'void (C::*)() __attribute__((thiscall))') for 1st argument}}
-// expected-note at +2 {{candidate function not viable: no known conversion from 'void (NonVariadic::A::*)() __attribute__((cdecl))' to 'memb_c_default' (aka 'void (C::*)() __attribute__((thiscall))') for 1st argument}}
-// expected-note at +1 {{candidate function not viable: no known conversion from 'void (NonVariadic::A::*)() __attribute__((thiscall))' to 'memb_c_default' (aka 'void (C::*)() __attribute__((thiscall))') for 1st argument}}
+// expected-note at +3 {{candidate function not viable: no known conversion from 'void (A::*)() __attribute__((thiscall))' to 'memb_c_default' (aka 'void (C::*)() __attribute__((thiscall))') for 1st argument}}
+// expected-note at +2 {{candidate function not viable: no known conversion from 'void (A::*)() __attribute__((cdecl))' to 'memb_c_default' (aka 'void (C::*)() __attribute__((thiscall))') for 1st argument}}
+// expected-note at +1 {{candidate function not viable: no known conversion from 'void (A::*)() __attribute__((thiscall))' to 'memb_c_default' (aka 'void (C::*)() __attribute__((thiscall))') for 1st argument}}
void cb_memb_c_default(memb_c_default ptr);
-// expected-note at +3 {{candidate function not viable: no known conversion from 'void (NonVariadic::A::*)() __attribute__((thiscall))' to 'memb_c_cdecl' (aka 'void (C::*)() __attribute__((cdecl))') for 1st argument}}
-// expected-note at +2 {{candidate function not viable: no known conversion from 'void (NonVariadic::A::*)() __attribute__((cdecl))' to 'memb_c_cdecl' (aka 'void (C::*)() __attribute__((cdecl))') for 1st argument}}
-// expected-note at +1 {{candidate function not viable: no known conversion from 'void (NonVariadic::A::*)() __attribute__((thiscall))' to 'memb_c_cdecl' (aka 'void (C::*)() __attribute__((cdecl))') for 1st argument}}
+// expected-note at +3 {{candidate function not viable: no known conversion from 'void (A::*)() __attribute__((thiscall))' to 'memb_c_cdecl' (aka 'void (C::*)() __attribute__((cdecl))') for 1st argument}}
+// expected-note at +2 {{candidate function not viable: no known conversion from 'void (A::*)() __attribute__((cdecl))' to 'memb_c_cdecl' (aka 'void (C::*)() __attribute__((cdecl))') for 1st argument}}
+// expected-note at +1 {{candidate function not viable: no known conversion from 'void (A::*)() __attribute__((thiscall))' to 'memb_c_cdecl' (aka 'void (C::*)() __attribute__((cdecl))') for 1st argument}}
void cb_memb_c_cdecl(memb_c_cdecl ptr);
-// expected-note at +3 {{candidate function not viable: no known conversion from 'void (NonVariadic::A::*)() __attribute__((thiscall))' to 'memb_c_thiscall' (aka 'void (C::*)() __attribute__((thiscall))') for 1st argument}}
-// expected-note at +2 {{candidate function not viable: no known conversion from 'void (NonVariadic::A::*)() __attribute__((cdecl))' to 'memb_c_thiscall' (aka 'void (C::*)() __attribute__((thiscall))') for 1st argument}}
-// expected-note at +1 {{candidate function not viable: no known conversion from 'void (NonVariadic::A::*)() __attribute__((thiscall))' to 'memb_c_thiscall' (aka 'void (C::*)() __attribute__((thiscall))') for 1st argument}}
+// expected-note at +3 {{candidate function not viable: no known conversion from 'void (A::*)() __attribute__((thiscall))' to 'memb_c_thiscall' (aka 'void (C::*)() __attribute__((thiscall))') for 1st argument}}
+// expected-note at +2 {{candidate function not viable: no known conversion from 'void (A::*)() __attribute__((cdecl))' to 'memb_c_thiscall' (aka 'void (C::*)() __attribute__((thiscall))') for 1st argument}}
+// expected-note at +1 {{candidate function not viable: no known conversion from 'void (A::*)() __attribute__((thiscall))' to 'memb_c_thiscall' (aka 'void (C::*)() __attribute__((thiscall))') for 1st argument}}
void cb_memb_c_thiscall(memb_c_thiscall ptr);
void call_member() {
@@ -279,11 +279,11 @@ void cb_memb_a_default(memb_a_default ptr);
void cb_memb_a_cdecl(memb_a_cdecl ptr);
void cb_memb_b_default(memb_b_default ptr);
void cb_memb_b_cdecl(memb_b_cdecl ptr);
-// expected-note at +2 {{candidate function not viable: no known conversion from 'void (Variadic::A::*)(int, ...)' to 'memb_c_default' (aka 'void (C::*)(int, ...)') for 1st argument}}
-// expected-note at +1 {{candidate function not viable: no known conversion from 'void (Variadic::A::*)(int, ...) __attribute__((cdecl))' to 'memb_c_default' (aka 'void (C::*)(int, ...)') for 1st argument}}
+// expected-note at +2 {{candidate function not viable: no known conversion from 'void (A::*)(int, ...)' to 'memb_c_default' (aka 'void (C::*)(int, ...)') for 1st argument}}
+// expected-note at +1 {{candidate function not viable: no known conversion from 'void (A::*)(int, ...) __attribute__((cdecl))' to 'memb_c_default' (aka 'void (C::*)(int, ...)') for 1st argument}}
void cb_memb_c_default(memb_c_default ptr);
-// expected-note at +2 {{candidate function not viable: no known conversion from 'void (Variadic::A::*)(int, ...)' to 'memb_c_cdecl' (aka 'void (C::*)(int, ...) __attribute__((cdecl))') for 1st argument}}
-// expected-note at +1 {{candidate function not viable: no known conversion from 'void (Variadic::A::*)(int, ...) __attribute__((cdecl))' to 'memb_c_cdecl' (aka 'void (C::*)(int, ...) __attribute__((cdecl))') for 1st argument}}
+// expected-note at +2 {{candidate function not viable: no known conversion from 'void (A::*)(int, ...)' to 'memb_c_cdecl' (aka 'void (C::*)(int, ...) __attribute__((cdecl))') for 1st argument}}
+// expected-note at +1 {{candidate function not viable: no known conversion from 'void (A::*)(int, ...) __attribute__((cdecl))' to 'memb_c_cdecl' (aka 'void (C::*)(int, ...) __attribute__((cdecl))') for 1st argument}}
void cb_memb_c_cdecl(memb_c_cdecl ptr);
void call_member() {
diff --git a/clang/test/SemaCXX/err_init_conversion_failed.cpp b/clang/test/SemaCXX/err_init_conversion_failed.cpp
index e31f215b4528c..f1949c079ecb6 100644
--- a/clang/test/SemaCXX/err_init_conversion_failed.cpp
+++ b/clang/test/SemaCXX/err_init_conversion_failed.cpp
@@ -56,6 +56,6 @@ template <class P> struct S2 {
void test_15() {
S2<S> X = {&S::foo};
- // expected-error-re at -1{{cannot initialize a member subobject of type 'void (template_test::S::*)(const int &){{( __attribute__\(\(thiscall\)\))?}}' with an rvalue of type 'void (template_test::S::*)(int){{( __attribute__\(\(thiscall\)\))?}}': type mismatch at 1st parameter ('const int &' vs 'int')}}
+ // expected-error-re at -1{{cannot initialize a member subobject of type 'void (S::*)(const int &){{( __attribute__\(\(thiscall\)\))?}}' with an rvalue of type 'void (S::*)(int){{( __attribute__\(\(thiscall\)\))?}}': type mismatch at 1st parameter ('const int &' vs 'int')}}
}
}
diff --git a/clang/test/SemaCXX/member-pointer.cpp b/clang/test/SemaCXX/member-pointer.cpp
index ec27d7abeadb8..81a3a3f2df315 100644
--- a/clang/test/SemaCXX/member-pointer.cpp
+++ b/clang/test/SemaCXX/member-pointer.cpp
@@ -48,7 +48,7 @@ void f() {
// Conversion to member of base.
pdi1 = pdid; // expected-error {{assigning to 'int A::*' from incompatible type 'int D::*'}}
-
+
// Comparisons
int (A::*pf2)(int, int);
int (D::*pf3)(int, int) = 0;
@@ -107,7 +107,7 @@ void h() {
int i = phm->*pi;
(void)&(hm.*pi);
(void)&(phm->*pi);
- (void)&((&hm)->*pi);
+ (void)&((&hm)->*pi);
void (HasMembers::*pf)() = &HasMembers::f;
(hm.*pf)();
@@ -205,7 +205,7 @@ namespace rdar8358512 {
static void stat();
static void stat(int);
-
+
template <typename T> struct Test0 {
void test() {
bind(&nonstat); // expected-error {{no matching function for call}}
@@ -296,7 +296,7 @@ namespace PR9973 {
{ call(u); } // expected-note{{in instantiation of}}
};
- template<class R, class T>
+ template<class R, class T>
dm<R, T> mem_fn(R T::*) ;
struct test
@@ -324,3 +324,12 @@ namespace test8 {
.**(int A::**) 0; // expected-warning {{indirection of non-volatile null pointer will be deleted}} expected-note {{consider}}
}
}
+
+namespace test9 {
+ struct FOO BAR;
+ // expected-error at -1 {{variable has incomplete type 'struct FOO'}}
+ // expected-note at -2 {{forward declaration of 'test9::FOO'}}
+ // expected-note at -3 {{'BAR' declared here}}
+ struct C { int BAR::*mp; };
+ // expected-error at -1 {{'BAR' is not a class, namespace, or enumeration}}
+} // namespace test9
diff --git a/clang/test/SemaCXX/sugar-common-types.cpp b/clang/test/SemaCXX/sugar-common-types.cpp
index 39a762127811f..3c4de0e2abd5e 100644
--- a/clang/test/SemaCXX/sugar-common-types.cpp
+++ b/clang/test/SemaCXX/sugar-common-types.cpp
@@ -44,7 +44,7 @@ template <class T> struct S1 {
};
N t10 = 0 ? S1<X1>() : S1<Y1>(); // expected-error {{from 'S1<B1>' (aka 'S1<int>')}}
-N t11 = 0 ? S1<X1>::S2<X2>() : S1<Y1>::S2<Y2>(); // expected-error {{from 'S1<int>::S2<B2>' (aka 'S2<void>')}}
+N t11 = 0 ? S1<X1>::S2<X2>() : S1<Y1>::S2<Y2>(); // expected-error {{from 'S1<B1>::S2<B2>' (aka 'S2<void>')}}
template <class T> using Al = S1<T>;
@@ -88,7 +88,7 @@ N t19 = 0 ? (__underlying_type(EnumsX::X)){} : (__underlying_type(EnumsY::Y)){};
// expected-error at -1 {{rvalue of type 'B1' (aka 'int')}}
N t20 = 0 ? (__underlying_type(EnumsX::X)){} : (__underlying_type(EnumsY::X)){};
-// expected-error at -1 {{rvalue of type '__underlying_type(Enums::X)' (aka 'int')}}
+// expected-error at -1 {{rvalue of type '__underlying_type(EnumsB::X)' (aka 'int')}}
using QX = const SB1 *;
using QY = const ::SB1 *;
diff --git a/clang/test/SemaOpenACC/combined-construct-if-ast.cpp b/clang/test/SemaOpenACC/combined-construct-if-ast.cpp
index f0796409d942d..96c465d368960 100644
--- a/clang/test/SemaOpenACC/combined-construct-if-ast.cpp
+++ b/clang/test/SemaOpenACC/combined-construct-if-ast.cpp
@@ -88,7 +88,7 @@ void TemplFunc() {
// CHECK-NEXT: DeclRefExpr{{.*}} 'const float' lvalue Var{{.*}} 'SomeFloat' 'const float'
// CHECK-NEXT: NestedNameSpecifier TypeSpec 'InstTy'
// CHECK-NEXT: ImplicitCastExpr{{.*}} 'float' <IntegralToFloating>
- // CHECK-NEXT: CXXFunctionalCastExpr{{.*}}'typename InstTy::IntTy':'int' functional cast to typename struct InstTy::IntTy <NoOp>
+ // CHECK-NEXT: CXXFunctionalCastExpr{{.*}}'typename InstTy::IntTy':'int' functional cast to typename InstTy::IntTy <NoOp>
// CHECK-NEXT: InitListExpr {{.*}}'typename InstTy::IntTy':'int'
// CHECK-NEXT: ForStmt
// CHECK: NullStmt
@@ -96,7 +96,7 @@ void TemplFunc() {
// CHECK-NEXT: OpenACCCombinedConstruct{{.*}}serial loop
// CHECK-NEXT: if clause
// CHECK-NEXT: ImplicitCastExpr{{.*}}'bool' <IntegralToBoolean>
- // CHECK-NEXT: CXXFunctionalCastExpr{{.*}}'typename InstTy::IntTy':'int' functional cast to typename struct InstTy::IntTy <NoOp>
+ // CHECK-NEXT: CXXFunctionalCastExpr{{.*}}'typename InstTy::IntTy':'int' functional cast to typename InstTy::IntTy <NoOp>
// CHECK-NEXT: InitListExpr {{.*}}'typename InstTy::IntTy':'int'
// CHECK-NEXT: ForStmt
// CHECK: NullStmt
diff --git a/clang/test/SemaOpenACC/combined-construct-num_workers-ast.cpp b/clang/test/SemaOpenACC/combined-construct-num_workers-ast.cpp
index 8aa361c7b037c..a04fcdd3903df 100644
--- a/clang/test/SemaOpenACC/combined-construct-num_workers-ast.cpp
+++ b/clang/test/SemaOpenACC/combined-construct-num_workers-ast.cpp
@@ -204,14 +204,14 @@ void TemplUses(T t, U u) {
// CHECK-NEXT: OpenACCCombinedConstruct{{.*}} kernels loop
// CHECK-NEXT: num_workers clause
- // CHECK-NEXT: CXXFunctionalCastExpr{{.*}} 'typename HasInt::IntTy':'int' functional cast to typename struct HasInt::IntTy <NoOp>
+ // CHECK-NEXT: CXXFunctionalCastExpr{{.*}} 'typename HasInt::IntTy':'int' functional cast to typename HasInt::IntTy <NoOp>
// CHECK-NEXT: InitListExpr{{.*}}'typename HasInt::IntTy':'int'
// CHECK-NEXT: ForStmt
// CHECK: NullStmt
// CHECK-NEXT: OpenACCCombinedConstruct{{.*}} parallel loop
// CHECK-NEXT: num_workers clause
- // CHECK-NEXT: CXXFunctionalCastExpr{{.*}} 'typename HasInt::ShortTy':'short' functional cast to typename struct HasInt::ShortTy <NoOp>
+ // CHECK-NEXT: CXXFunctionalCastExpr{{.*}} 'typename HasInt::ShortTy':'short' functional cast to typename HasInt::ShortTy <NoOp>
// CHECK-NEXT: InitListExpr{{.*}}'typename HasInt::ShortTy':'short'
// CHECK-NEXT: ForStmt
// CHECK: NullStmt
diff --git a/clang/test/SemaOpenACC/compute-construct-clause-ast.cpp b/clang/test/SemaOpenACC/compute-construct-clause-ast.cpp
index 58c12b828439d..babff53d2f1d2 100644
--- a/clang/test/SemaOpenACC/compute-construct-clause-ast.cpp
+++ b/clang/test/SemaOpenACC/compute-construct-clause-ast.cpp
@@ -356,7 +356,7 @@ void TemplFunc() {
// CHECK-NEXT: DeclRefExpr{{.*}} 'const float' lvalue Var{{.*}} 'SomeFloat' 'const float'
// CHECK-NEXT: NestedNameSpecifier TypeSpec 'InstTy'
// CHECK-NEXT: ImplicitCastExpr{{.*}} 'float' <IntegralToFloating>
- // CHECK-NEXT: CXXFunctionalCastExpr{{.*}}'typename InstTy::IntTy':'int' functional cast to typename struct InstTy::IntTy <NoOp>
+ // CHECK-NEXT: CXXFunctionalCastExpr{{.*}}'typename InstTy::IntTy':'int' functional cast to typename InstTy::IntTy <NoOp>
// CHECK-NEXT: InitListExpr {{.*}}'typename InstTy::IntTy':'int'
// CHECK-NEXT: WhileStmt
// CHECK-NEXT: CXXBoolLiteralExpr
@@ -365,7 +365,7 @@ void TemplFunc() {
// CHECK-NEXT: OpenACCComputeConstruct{{.*}}serial
// CHECK-NEXT: if clause
// CHECK-NEXT: ImplicitCastExpr{{.*}}'bool' <IntegralToBoolean>
- // CHECK-NEXT: CXXFunctionalCastExpr{{.*}}'typename InstTy::IntTy':'int' functional cast to typename struct InstTy::IntTy <NoOp>
+ // CHECK-NEXT: CXXFunctionalCastExpr{{.*}}'typename InstTy::IntTy':'int' functional cast to typename InstTy::IntTy <NoOp>
// CHECK-NEXT: InitListExpr {{.*}}'typename InstTy::IntTy':'int'
// CHECK-NEXT: WhileStmt
// CHECK-NEXT: CXXBoolLiteralExpr
diff --git a/clang/test/SemaOpenACC/compute-construct-intexpr-clause-ast.cpp b/clang/test/SemaOpenACC/compute-construct-intexpr-clause-ast.cpp
index 2c48fc3ef7746..baf7aa62c5f7f 100644
--- a/clang/test/SemaOpenACC/compute-construct-intexpr-clause-ast.cpp
+++ b/clang/test/SemaOpenACC/compute-construct-intexpr-clause-ast.cpp
@@ -506,7 +506,7 @@ void TemplUses(T t, U u) {
// CHECK-NEXT: OpenACCComputeConstruct{{.*}}kernels
// CHECK-NEXT: num_workers clause
- // CHECK-NEXT: CXXFunctionalCastExpr{{.*}} 'typename HasInt::IntTy':'int' functional cast to typename struct HasInt::IntTy <NoOp>
+ // CHECK-NEXT: CXXFunctionalCastExpr{{.*}} 'typename HasInt::IntTy':'int' functional cast to typename HasInt::IntTy <NoOp>
// CHECK-NEXT: InitListExpr{{.*}}'typename HasInt::IntTy':'int'
// CHECK-NEXT: WhileStmt
// CHECK-NEXT: CXXBoolLiteralExpr
@@ -514,7 +514,7 @@ void TemplUses(T t, U u) {
// CHECK-NEXT: OpenACCComputeConstruct{{.*}}parallel
// CHECK-NEXT: num_workers clause
- // CHECK-NEXT: CXXFunctionalCastExpr{{.*}} 'typename HasInt::ShortTy':'short' functional cast to typename struct HasInt::ShortTy <NoOp>
+ // CHECK-NEXT: CXXFunctionalCastExpr{{.*}} 'typename HasInt::ShortTy':'short' functional cast to typename HasInt::ShortTy <NoOp>
// CHECK-NEXT: InitListExpr{{.*}}'typename HasInt::ShortTy':'short'
// CHECK-NEXT: WhileStmt
// CHECK-NEXT: CXXBoolLiteralExpr
diff --git a/clang/test/SemaOpenACC/data-construct-if-ast.cpp b/clang/test/SemaOpenACC/data-construct-if-ast.cpp
index 9ceee4e1c0749..533a97d34030b 100644
--- a/clang/test/SemaOpenACC/data-construct-if-ast.cpp
+++ b/clang/test/SemaOpenACC/data-construct-if-ast.cpp
@@ -94,7 +94,7 @@ void TemplFunc() {
// CHECK-NEXT: DeclRefExpr{{.*}} 'const float' lvalue Var{{.*}} 'SomeFloat' 'const float'
// CHECK-NEXT: NestedNameSpecifier TypeSpec 'InstTy'
// CHECK-NEXT: ImplicitCastExpr{{.*}} 'float' <IntegralToFloating>
- // CHECK-NEXT: CXXFunctionalCastExpr{{.*}}'typename InstTy::IntTy':'int' functional cast to typename struct InstTy::IntTy <NoOp>
+ // CHECK-NEXT: CXXFunctionalCastExpr{{.*}}'typename InstTy::IntTy':'int' functional cast to typename InstTy::IntTy <NoOp>
// CHECK-NEXT: InitListExpr {{.*}}'typename InstTy::IntTy':'int'
// CHECK-NEXT: NullStmt
@@ -103,7 +103,7 @@ void TemplFunc() {
// CHECK-NEXT: DeclRefExpr{{.*}}'Global' 'int'
// CHECK-NEXT: if clause
// CHECK-NEXT: ImplicitCastExpr{{.*}}'bool' <IntegralToBoolean>
- // CHECK-NEXT: CXXFunctionalCastExpr{{.*}}'typename InstTy::IntTy':'int' functional cast to typename struct InstTy::IntTy <NoOp>
+ // CHECK-NEXT: CXXFunctionalCastExpr{{.*}}'typename InstTy::IntTy':'int' functional cast to typename InstTy::IntTy <NoOp>
// CHECK-NEXT: InitListExpr {{.*}}'typename InstTy::IntTy':'int'
// CHECK-NEXT: NullStmt
diff --git a/clang/test/SemaTemplate/instantiate-member-pointers.cpp b/clang/test/SemaTemplate/instantiate-member-pointers.cpp
index 4757870d13b70..8b6c2eff0a252 100644
--- a/clang/test/SemaTemplate/instantiate-member-pointers.cpp
+++ b/clang/test/SemaTemplate/instantiate-member-pointers.cpp
@@ -5,7 +5,8 @@ struct Y {
template<typename T>
struct X1 {
- int f(T* ptr, int T::*pm) { // expected-error{{member pointer}}
+ int f(T* ptr, int T::*pm) {
+ // expected-error at -1 {{type 'int' cannot be used prior to '::' because it has no members}}
return ptr->*pm;
}
};
diff --git a/clang/tools/libclang/CXType.cpp b/clang/tools/libclang/CXType.cpp
index f4227fd030734..2c9ef282b8abc 100644
--- a/clang/tools/libclang/CXType.cpp
+++ b/clang/tools/libclang/CXType.cpp
@@ -966,12 +966,14 @@ long long clang_Type_getAlignOf(CXType T) {
}
CXType clang_Type_getClassType(CXType CT) {
+ ASTContext &Ctx = cxtu::getASTUnit(GetTU(CT))->getASTContext();
QualType ET = QualType();
QualType T = GetQualType(CT);
const Type *TP = T.getTypePtrOrNull();
if (TP && TP->getTypeClass() == Type::MemberPointer) {
- ET = QualType(cast<MemberPointerType> (TP)->getClass(), 0);
+ ET = Ctx.getTypeDeclType(
+ cast<MemberPointerType>(TP)->getMostRecentCXXRecordDecl());
}
return MakeCXType(ET, GetTU(CT));
}
diff --git a/clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp b/clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp
index 068cf66771027..74844167d5e5a 100644
--- a/clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp
+++ b/clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp
@@ -5760,10 +5760,10 @@ TEST(ElaboratedTypeNarrowing, namesType) {
TEST(NNS, BindsNestedNameSpecifiers) {
EXPECT_TRUE(matchAndVerifyResultTrue(
- "namespace ns { struct E { struct B {}; }; } ns::E::B b;",
- nestedNameSpecifier(specifiesType(asString("struct ns::E"))).bind("nns"),
- std::make_unique<VerifyIdIsBoundTo<NestedNameSpecifier>>(
- "nns", "ns::struct E::")));
+ "namespace ns { struct E { struct B {}; }; } ns::E::B b;",
+ nestedNameSpecifier(specifiesType(asString("struct ns::E"))).bind("nns"),
+ std::make_unique<VerifyIdIsBoundTo<NestedNameSpecifier>>("nns",
+ "ns::E::")));
}
TEST(NNS, BindsNestedNameSpecifierLocs) {
More information about the cfe-commits
mailing list