Implement pointer to member handling in static_cast.
Fix a stupid mistake in UnwrapSimilarPointers that made any two member pointers compatible as long as the pointee was the same.
Make a few style corrections as suggested by Chris.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@63215 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/Sema/SemaInherit.cpp b/lib/Sema/SemaInherit.cpp
index b5bd893..307c527 100644
--- a/lib/Sema/SemaInherit.cpp
+++ b/lib/Sema/SemaInherit.cpp
@@ -218,9 +218,9 @@
BasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/false,
/*DetectVirtual=*/false);
bool DerivationOkay = IsDerivedFrom(Derived, Base, Paths);
- assert(DerivationOkay && "Can only be used with a derived-to-base conversion");
- if (!DerivationOkay)
- return true;
+ assert(DerivationOkay &&
+ "Can only be used with a derived-to-base conversion");
+ (void)DerivationOkay;
if (!Paths.isAmbiguous(Context.getCanonicalType(Base).getUnqualifiedType()))
return false;
@@ -235,8 +235,7 @@
Paths.setRecordingPaths(true);
bool StillOkay = IsDerivedFrom(Derived, Base, Paths);
assert(StillOkay && "Can only be used with a derived-to-base conversion");
- if (!StillOkay)
- return true;
+ (void)StillOkay;
// Build up a textual representation of the ambiguous paths, e.g.,
// D -> B -> A, that will be used to illustrate the ambiguous
diff --git a/lib/Sema/SemaNamedCast.cpp b/lib/Sema/SemaNamedCast.cpp
index e88a3b2..cac76b6 100644
--- a/lib/Sema/SemaNamedCast.cpp
+++ b/lib/Sema/SemaNamedCast.cpp
@@ -44,6 +44,8 @@
Sema &Self, Expr *SrcExpr, QualType DestType, const SourceRange &OpRange);
static TryStaticCastResult TryStaticPointerDowncast(
Sema &Self, QualType SrcType, QualType DestType, const SourceRange &OpRange);
+static TryStaticCastResult TryStaticMemberPointerUpcast(
+ Sema &Self, QualType SrcType, QualType DestType, const SourceRange &OpRange);
static TryStaticCastResult TryStaticDowncast(Sema &Self, QualType SrcType,
QualType DestType,
const SourceRange &OpRange,
@@ -479,10 +481,13 @@
return;
}
- // Reverse member pointer conversion. C++ 5.11 specifies member pointer
+ // Reverse member pointer conversion. C++ 4.11 specifies member pointer
// conversion. C++ 5.2.9p9 has additional information.
// DR54's access restrictions apply here also.
- // FIXME: Don't have member pointers yet.
+ if (TryStaticMemberPointerUpcast(Self, SrcType, DestType, OpRange)
+ > TSC_NotApplicable) {
+ return;
+ }
// Reverse pointer conversion to void*. C++ 4.10.p2 specifies conversion to
// void*. C++ 5.2.9p10 specifies additional restrictions, which really is
@@ -655,6 +660,64 @@
return TSC_Success;
}
+/// TryStaticMemberPointerUpcast - Tests whether a conversion according to
+/// C++ 5.2.9p9 is valid:
+///
+/// An rvalue of type "pointer to member of D of type cv1 T" can be
+/// converted to an rvalue of type "pointer to member of B of type cv2 T",
+/// where B is a base class of D [...].
+///
+TryStaticCastResult
+TryStaticMemberPointerUpcast(Sema &Self, QualType SrcType, QualType DestType,
+ const SourceRange &OpRange)
+{
+ const MemberPointerType *SrcMemPtr = SrcType->getAsMemberPointerType();
+ if (!SrcMemPtr)
+ return TSC_NotApplicable;
+ const MemberPointerType *DestMemPtr = DestType->getAsMemberPointerType();
+ if (!DestMemPtr)
+ return TSC_NotApplicable;
+
+ // T == T, modulo cv
+ if (Self.Context.getCanonicalType(
+ SrcMemPtr->getPointeeType().getUnqualifiedType()) !=
+ Self.Context.getCanonicalType(DestMemPtr->getPointeeType().
+ getUnqualifiedType()))
+ return TSC_NotApplicable;
+
+ // B base of D
+ QualType SrcClass(SrcMemPtr->getClass(), 0);
+ QualType DestClass(DestMemPtr->getClass(), 0);
+ BasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/false,
+ /*DetectVirtual=*/true);
+ if (!Self.IsDerivedFrom(SrcClass, DestClass, Paths)) {
+ return TSC_NotApplicable;
+ }
+
+ // B is a base of D. But is it an allowed base? If not, it's a hard error.
+ if (Paths.isAmbiguous(DestClass)) {
+ Paths.clear();
+ Paths.setRecordingPaths(true);
+ bool StillOkay = Self.IsDerivedFrom(SrcClass, DestClass, Paths);
+ assert(StillOkay);
+ StillOkay = StillOkay;
+ std::string PathDisplayStr = Self.getAmbiguousPathsDisplayString(Paths);
+ Self.Diag(OpRange.getBegin(), diag::err_ambiguous_memptr_conv)
+ << 1 << SrcClass << DestClass << PathDisplayStr << OpRange;
+ return TSC_Failed;
+ }
+
+ if (const CXXRecordType *VBase = Paths.getDetectedVirtual()) {
+ Self.Diag(OpRange.getBegin(), diag::err_memptr_conv_via_virtual)
+ << SrcClass << DestClass << QualType(VBase, 0) << OpRange;
+ return TSC_Failed;
+ }
+
+ // FIXME: Test accessibility.
+
+ return TSC_Success;
+}
+
/// TryStaticImplicitCast - Tests whether a conversion according to C++ 5.2.9p2
/// is valid:
///
diff --git a/lib/Sema/SemaOverload.cpp b/lib/Sema/SemaOverload.cpp
index b2ae90b..0f9f0cf 100644
--- a/lib/Sema/SemaOverload.cpp
+++ b/lib/Sema/SemaOverload.cpp
@@ -1087,51 +1087,50 @@
/// otherwise.
bool Sema::CheckMemberPointerConversion(Expr *From, QualType ToType) {
QualType FromType = From->getType();
+ const MemberPointerType *FromPtrType = FromType->getAsMemberPointerType();
+ if (!FromPtrType)
+ return false;
- if (const MemberPointerType *FromPtrType =
- FromType->getAsMemberPointerType()) {
- if (const MemberPointerType *ToPtrType =
- ToType->getAsMemberPointerType()) {
- QualType FromClass = QualType(FromPtrType->getClass(), 0);
- QualType ToClass = QualType(ToPtrType->getClass(), 0);
+ const MemberPointerType *ToPtrType = ToType->getAsMemberPointerType();
+ assert(ToPtrType && "No member pointer cast has a target type "
+ "that is not a member pointer.");
- // FIXME: What about dependent types?
- assert(FromClass->isRecordType() && "Pointer into non-class.");
- assert(ToClass->isRecordType() && "Pointer into non-class.");
+ QualType FromClass = QualType(FromPtrType->getClass(), 0);
+ QualType ToClass = QualType(ToPtrType->getClass(), 0);
- BasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/false,
- /*DetectVirtual=*/true);
- bool DerivationOkay = IsDerivedFrom(ToClass, FromClass, Paths);
- assert(DerivationOkay &&
- "Should not have been called if derivation isn't OK.");
- if (!DerivationOkay)
- return true;
+ // FIXME: What about dependent types?
+ assert(FromClass->isRecordType() && "Pointer into non-class.");
+ assert(ToClass->isRecordType() && "Pointer into non-class.");
- if (Paths.isAmbiguous(Context.getCanonicalType(FromClass).
- getUnqualifiedType())) {
- // Derivation is ambiguous. Redo the check to find the exact paths.
- Paths.clear();
- Paths.setRecordingPaths(true);
- bool StillOkay = IsDerivedFrom(ToClass, FromClass, Paths);
- assert(StillOkay && "Derivation changed due to quantum fluctuation.");
- if (!StillOkay)
- return true;
+ BasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/false,
+ /*DetectVirtual=*/true);
+ bool DerivationOkay = IsDerivedFrom(ToClass, FromClass, Paths);
+ assert(DerivationOkay &&
+ "Should not have been called if derivation isn't OK.");
+ (void)DerivationOkay;
- std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
- Diag(From->getExprLoc(),
- diag::err_ambiguous_base_to_derived_memptr_conv)
- << FromClass << ToClass << PathDisplayStr << From->getSourceRange();
- return true;
- }
+ if (Paths.isAmbiguous(Context.getCanonicalType(FromClass).
+ getUnqualifiedType())) {
+ // Derivation is ambiguous. Redo the check to find the exact paths.
+ Paths.clear();
+ Paths.setRecordingPaths(true);
+ bool StillOkay = IsDerivedFrom(ToClass, FromClass, Paths);
+ assert(StillOkay && "Derivation changed due to quantum fluctuation.");
+ (void)StillOkay;
- if (const CXXRecordType *VBase = Paths.getDetectedVirtual()) {
- Diag(From->getExprLoc(), diag::err_memptr_conv_via_virtual)
- << FromClass << ToClass << QualType(VBase, 0)
- << From->getSourceRange();
- return true;
- }
- }
+ std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
+ Diag(From->getExprLoc(), diag::err_ambiguous_memptr_conv)
+ << 0 << FromClass << ToClass << PathDisplayStr << From->getSourceRange();
+ return true;
}
+
+ if (const CXXRecordType *VBase = Paths.getDetectedVirtual()) {
+ Diag(From->getExprLoc(), diag::err_memptr_conv_via_virtual)
+ << FromClass << ToClass << QualType(VBase, 0)
+ << From->getSourceRange();
+ return true;
+ }
+
return false;
}
@@ -1148,7 +1147,7 @@
// qualification conversion.
if (FromType == ToType)
return false;
-
+
// (C++ 4.4p4):
// A conversion can add cv-qualifiers at levels other than the first
// in multi-level pointers, subject to the following rules: [...]
diff --git a/lib/Sema/SemaType.cpp b/lib/Sema/SemaType.cpp
index 60219fe..5d54f46 100644
--- a/lib/Sema/SemaType.cpp
+++ b/lib/Sema/SemaType.cpp
@@ -662,7 +662,9 @@
const MemberPointerType *T1MPType = T1->getAsMemberPointerType(),
*T2MPType = T2->getAsMemberPointerType();
- if (T1MPType && T2MPType) {
+ if (T1MPType && T2MPType &&
+ Context.getCanonicalType(T1MPType->getClass()) ==
+ Context.getCanonicalType(T2MPType->getClass())) {
T1 = T1MPType->getPointeeType();
T2 = T2MPType->getPointeeType();
return true;