C++11: noexcept should check whether the expression is a constant expression

[ismailp]

Summary

This is an attempt to fix PR15481.

noexcept operator currently ignores whether given call is a constant expression. The patch adds a check whether given call expression is a constant expression. If so, canCalleeThrow returns CT_Cannot.

[rsmith]

Generally speaking, I'd prefer for us to implement the resolution of core issue 1351 rather than patching up our implementation of the broken C++11 rules. However, even the core issue 1351 rules are broken when the callee is a function pointer...

lib/Sema/SemaExceptionSpec.cpp

825–831

This is not right. We should try to evaluate the call even if we can't resolve it to a particular declaration.

850–851

Likewise, this should attempt evaluation (although it's not clear to me how this could happen...).

864–867

Please reverse the order of these checks; FT->isNothrow will typically be a much cheaper test.

[ismailp]

I have read the resolution for the issue 1351, and I was curious about aligning this with the removal of dynamic exception specifications as well. Could you please confirm whether I understood this part correctly; given the example in issue 1351, in the move constructor declaration, "noexcept" is represented with an empty set:
B(B&&, int = (throw Y(), 0)) throw(Y) noexcept;
The union of set of potential exceptions is: {Y} U {Y} U {} = {Y};
Likewise, if it was:
B(B&&, int = (throw Y(), 0)) throw(Z) noexcept;
The union of set of potential exceptions: {Y} U {Z} U {} = {Y, Z}

Could you please explain the purpose of having throw(E) and noexcept on the same declarator? I understand throw(E) and noexcept(false) would be compatible.

lib/Sema/SemaExceptionSpec.cpp

static CanThrowResult canSubExprsThrow(Sema &S, const Expr *CE) {
   for (Expr::child_range I = E->children(); I && R != CT_Can; ++I)
     R = mergeCanThrow(R, S.canThrow(cast<Expr>(*I)));
   return R;
 }
 
 static CanThrowResult canCalleeThrow(Sema &S, const Expr *E,
                                            const Decl *D,
                                            bool NullThrows = true) {
   if (!D)
     return NullThrows ? CT_Can : CT_Cannot;
 
   // See if we can get a function type from the decl somehow.
   const ValueDecl *VD = dyn_cast<ValueDecl>(D);
   if (!VD) // If we have no clue what we're calling, assume the worst.
     return CT_Can;
 
   // As an extension, we assume that __attribute__((nothrow)) functions don't
   // throw.
   if (isa<FunctionDecl>(D) && D->hasAttr<NoThrowAttr>())
     return CT_Cannot;
 
   QualType T = VD->getType();
   const FunctionProtoType *FT;
   if ((FT = T->getAs<FunctionProtoType>())) {
   } else if (const PointerType *PT = T->getAs<PointerType>())
     FT = PT->getPointeeType()->getAs<FunctionProtoType>();
   else if (const ReferenceType *RT = T->getAs<ReferenceType>())
     FT = RT->getPointeeType()->getAs<FunctionProtoType>();
   else if (const MemberPointerType *MT = T->getAs<MemberPointerType>())
     FT = MT->getPointeeType()->getAs<FunctionProtoType>();
   else if (const BlockPointerType *BT = T->getAs<BlockPointerType>())
     FT = BT->getPointeeType()->getAs<FunctionProtoType>();
 
   if (!FT)
     return CT_Can;
 
   FT = S.ResolveExceptionSpec(E->getLocStart(), FT);
   if (!FT)
     return CT_Can;
 
+  // C++11: [expr.unary.noexcept]p3:
+  // The result of the noexcept operator is false if in a potentially-evaluated
+  // context the expression would contain:
+  // — a potentially evaluated call to a function, member function, function
+  //   pointer, or member function pointer that does not have a non-throwing
+  //   exception-specification (15.4), unless the call is a constant
+  //   expression (5.19),
+  if (isa<CallExpr>(E) && E->isCXX11ConstantExpr(S.getASTContext()))
+    return CT_Cannot;
+
   return FT->isNothrow(S.Context) ? CT_Cannot : CT_Can;
 }
 
 static CanThrowResult canDynamicCastThrow(const CXXDynamicCastExpr *DC) {
   if (DC->isTypeDependent())
     return CT_Dependent;
 
   if (!DC->getTypeAsWritten()->isReferenceType())
     return CT_Cannot;

test/CXX/expr/expr.unary/expr.unary.noexcept/sema.cpp

 
 void nospec();
 void allspec() throw(...);
 void intspec() throw(int);
 void emptyspec() throw();
 void nothrowattr() __attribute__((nothrow));
 void noexcept_true() noexcept;
 void noexcept_false() noexcept(false);
+constexpr int constant_expression(bool f) throw(int)
+{ return f ? 0 : throw 42; }
 
 void call() {
   N(nospec());
   N(allspec());
   N(intspec());
   P(emptyspec());
   P(nothrowattr());
   P(noexcept_true());
   N(noexcept_false());
+  P(constant_expression(true));
+  N(constant_expression(false));
 }
 
 void (*pnospec)();
 void (*pallspec)() throw(...);
 void (*pintspec)() throw(int);
 void (*pemptyspec)() throw();
 
 void callptr() {