Implement DR1458: Taking the address of an object of incomplete class type is
not a constant expression, because we can't tell whether the complete class type
will have an overloaded operator&.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@150066 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/include/clang/Basic/DiagnosticASTKinds.td b/include/clang/Basic/DiagnosticASTKinds.td
index 9e4b63c..978df36 100644
--- a/include/clang/Basic/DiagnosticASTKinds.td
+++ b/include/clang/Basic/DiagnosticASTKinds.td
@@ -55,6 +55,9 @@
"specifiers (%1 vs %3) has unspecified value">;
def note_constexpr_compare_virtual_mem_ptr : Note<
"comparison of pointer to virtual member function %0 has unspecified value">;
+def note_constexpr_addr_of_incomplete : Note<
+ "cannot take address of object of incomplete class type %0 "
+ "in a constant expression">;
def note_constexpr_past_end : Note<
"dereferenced pointer past the end of %select{|subobject of }0"
"%select{temporary|%2}1 is not a constant expression">;
diff --git a/lib/AST/ExprConstant.cpp b/lib/AST/ExprConstant.cpp
index 4104067..48e0c6f 100644
--- a/lib/AST/ExprConstant.cpp
+++ b/lib/AST/ExprConstant.cpp
@@ -2937,6 +2937,18 @@
}
bool PointerExprEvaluator::VisitUnaryAddrOf(const UnaryOperator *E) {
+ QualType SrcTy = E->getSubExpr()->getType();
+ // In C++, taking the address of an object of incomplete class type has
+ // undefined behavior if the complete class type has an overloaded operator&.
+ // DR1458 makes such expressions non-constant.
+ if (Info.getLangOpts().CPlusPlus &&
+ SrcTy->isRecordType() && SrcTy->isIncompleteType()) {
+ const RecordType *RT = SrcTy->getAs<RecordType>();
+ Info.CCEDiag(E->getExprLoc(), diag::note_constexpr_addr_of_incomplete, 1)
+ << SrcTy;
+ Info.Note(RT->getDecl()->getLocation(), diag::note_forward_declaration)
+ << RT->getDecl();
+ }
return EvaluateLValue(E->getSubExpr(), Result, Info);
}
diff --git a/test/CXX/expr/expr.const/p2-0x.cpp b/test/CXX/expr/expr.const/p2-0x.cpp
index 71dc2f7..43d683a 100644
--- a/test/CXX/expr/expr.const/p2-0x.cpp
+++ b/test/CXX/expr/expr.const/p2-0x.cpp
@@ -109,6 +109,22 @@
};
}
+// DR1458: taking the address of an object of incomplete class type
+namespace IncompleteClassTypeAddr {
+ struct S; // expected-note {{forward}}
+ extern S s;
+ constexpr S *p = &s; // expected-error {{constant expression}} expected-note {{cannot take address of object of incomplete class type 'IncompleteClassTypeAddr::S' in a constant expression}}
+
+ extern S sArr[];
+ constexpr S (*p2)[] = &sArr; // ok
+
+ struct S {
+ constexpr S *operator&() { return nullptr; }
+ };
+ constexpr S *q = &s;
+ static_assert(!q, "");
+}
+
// - an operation that would have undefined behavior [Note: including, for
// example, signed integer overflow (Clause 5 [expr]), certain pointer
// arithmetic (5.7 [expr.add]), division by zero (5.6 [expr.mul]), or certain
diff --git a/test/SemaCXX/constant-expression-cxx11.cpp b/test/SemaCXX/constant-expression-cxx11.cpp
index 763c416..ccbc8c1 100644
--- a/test/SemaCXX/constant-expression-cxx11.cpp
+++ b/test/SemaCXX/constant-expression-cxx11.cpp
@@ -299,6 +299,7 @@
constexpr S* sptr = &s;
constexpr bool dyncast = sptr == dynamic_cast<S*>(sptr); // expected-error {{constant expression}} expected-note {{dynamic_cast}}
+struct U {};
struct Str {
int a : dynamic_cast<S*>(sptr) == dynamic_cast<S*>(sptr); // \
expected-warning {{not an integral constant expression}} \
@@ -315,7 +316,7 @@
int e : (Str*)(sptr) == (Str*)(sptr); // \
expected-warning {{not an integral constant expression}} \
expected-note {{cast which performs the conversions of a reinterpret_cast is not allowed in a constant expression}}
- int f : &(Str&)(*sptr) == &(Str&)(*sptr); // \
+ int f : &(U&)(*sptr) == &(U&)(*sptr); // \
expected-warning {{not an integral constant expression}} \
expected-note {{cast which performs the conversions of a reinterpret_cast is not allowed in a constant expression}}
int g : (S*)(void*)(sptr) == sptr; // \
