Disallow narrowing conversions to bool in noexcept specififers.

[cor3ntin]

Summary

Completes the support for P1401R5

[cor3ntin]

Rebase

[cor3ntin]

Fix cxx_status

[aaron.ballman]

clang/lib/Sema/SemaOverload.cpp

5644

This function is checking converted constant expressions which was not touched by p1401r5, and it looks like this will break anything attempting to to contextual conversion constant expressions of type bool per http://eel.is/c++draft/expr.const#10 because it's removing the attempt to contextually convert to bool here.

5644

Also, I don't think P1401 was applied as a DR (but we should double check!) so I'd expect some checks for the language standard to gate the behavior. If P1401 was applied as a DR, then we should add some tests to clang/test/CXX with the proper DR markings so that our DR status page gets updated.

clang/test/SemaCXX/cxx2a-explicit-bool.cpp

731

Curiously, these tests already have this behavior without this patch applied: https://godbolt.org/z/13PojdWEe

[cor3ntin]

It turns out that explicit was doing the right thing (as outlined in P1401),
but noexcept was not.

I've reworked the handling of noexcept so that noexcept and explicit specifier
use the same code paths, as they have the same expected behavior and wording.
This also make sure their diagnostics are consistent.

[cor3ntin]

clang/lib/Sema/SemaOverload.cpp

5644

It's in the air http://lists.isocpp.org/ext/2021/06/16918.php - Bur Richard took the decision to consider it as a DR
However the changes this patch intends to fix pertaining to preexisting wording, and clang was non-conforming.
P1401 merely put this non-conformity to light.

[cor3ntin]

Fix tests

[cor3ntin]

Remove whitespace only change

[aaron.ballman]

clang/lib/Sema/SemaExceptionSpec.cpp

81

You should just get rid of this parameter entirely if it's no longer going to be used.

clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp

879

Was there a reason this test needed to change?

clang/www/cxx_status.html

1299

We're on Clang 14 now.

[cor3ntin]

clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp

879

yup, 2 is not convertible to bool here. I use 0+1 to keep the kind of expression the same

[aaron.ballman]

clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp

879

I kinda figured that was the case, thanks for confirming!

[cor3ntin]

• Update the release version to Clang 14 in cxx_status
• Remove unused parameter
• Remove WS only changes

[aaron.ballman]

LGTM!

[aaron.ballman]

I've committed on your behalf in 3c8e94bc20e5829ab5167d21d242b6b624dd934e, thank you for the fix!

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_typecheck_converted_constant_expression : Error<
   "value of type %0 is not implicitly convertible to %1">;
 def err_typecheck_converted_constant_expression_disallowed : Error<
   "conversion from %0 to %1 is not allowed in a converted constant expression">;
 def err_typecheck_converted_constant_expression_indirect : Error<
   "conversion from %0 to %1 in converted constant expression would "
   "bind reference to a temporary">;
 def err_expr_not_cce : Error<
   "%select{case value|enumerator value|non-type template argument|"
-  "array size|explicit specifier argument}0 "
+  "array size|explicit specifier argument|noexcept specifier argument}0 "
   "is not a constant expression">;
 def ext_cce_narrowing : ExtWarn<
   "%select{case value|enumerator value|non-type template argument|"
-  "array size|explicit specifier argument}0 "
+  "array size|explicit specifier argument|noexcept specifier argument}0 "
   "%select{cannot be narrowed from type %2 to %3|"
   "evaluates to %2, which cannot be narrowed to type %3}1">,
   InGroup<CXX11Narrowing>, DefaultError, SFINAEFailure;
 def err_ice_not_integral : Error<
   "%select{integer|integral}1 constant expression must have "
   "%select{integer|integral or unscoped enumeration}1 type, not %0">;
 def err_ice_incomplete_type : Error<
   "integral constant expression has incomplete class type %0">;

clang/include/clang/Sema/Sema.h

public:
   /// (when permitted) if not.
   void checkInitializerLifetime(const InitializedEntity &Entity, Expr *Init);
 
   ExprResult PerformContextuallyConvertToBool(Expr *From);
   ExprResult PerformContextuallyConvertToObjCPointer(Expr *From);
 
   /// Contexts in which a converted constant expression is required.
   enum CCEKind {
-    CCEK_CaseValue,   ///< Expression in a case label.
-    CCEK_Enumerator,  ///< Enumerator value with fixed underlying type.
-    CCEK_TemplateArg, ///< Value of a non-type template parameter.
-    CCEK_ArrayBound,  ///< Array bound in array declarator or new-expression.
-    CCEK_ExplicitBool ///< Condition in an explicit(bool) specifier.
+    CCEK_CaseValue,    ///< Expression in a case label.
+    CCEK_Enumerator,   ///< Enumerator value with fixed underlying type.
+    CCEK_TemplateArg,  ///< Value of a non-type template parameter.
+    CCEK_ArrayBound,   ///< Array bound in array declarator or new-expression.
+    CCEK_ExplicitBool, ///< Condition in an explicit(bool) specifier.
+    CCEK_Noexcept      ///< Condition in a noexcept(bool) specifier.
   };
   ExprResult CheckConvertedConstantExpression(Expr *From, QualType T,
                                               llvm::APSInt &Value, CCEKind CCE);
   ExprResult CheckConvertedConstantExpression(Expr *From, QualType T,
                                               APValue &Value, CCEKind CCE,
                                               NamedDecl *Dest = nullptr);
 
   /// Abstract base class used to perform a contextual implicit
public:
   };
 
   /// Evaluate the implicit exception specification for a defaulted
   /// special member function.
   void EvaluateImplicitExceptionSpec(SourceLocation Loc, FunctionDecl *FD);
 
   /// Check the given noexcept-specifier, convert its expression, and compute
   /// the appropriate ExceptionSpecificationType.
-  ExprResult ActOnNoexceptSpec(SourceLocation NoexceptLoc, Expr *NoexceptExpr,
+  ExprResult ActOnNoexceptSpec(Expr *NoexceptExpr,
                                ExceptionSpecificationType &EST);
 
   /// Check the given exception-specification and update the
   /// exception specification information with the results.
   void checkExceptionSpecification(bool IsTopLevel,
                                    ExceptionSpecificationType EST,
                                    ArrayRef<ParsedType> DynamicExceptions,
                                    ArrayRef<SourceRange> DynamicExceptionRanges,

clang/lib/Parse/ParseDeclCXX.cpp

Parser::tryParseExceptionSpecification(bool Delayed,
   SourceLocation KeywordLoc = ConsumeToken();
   if (Tok.is(tok::l_paren)) {
     // There is an argument.
     BalancedDelimiterTracker T(*this, tok::l_paren);
     T.consumeOpen();
     NoexceptExpr = ParseConstantExpression();
     T.consumeClose();
     if (!NoexceptExpr.isInvalid()) {
-      NoexceptExpr = Actions.ActOnNoexceptSpec(KeywordLoc, NoexceptExpr.get(),
+      NoexceptExpr = Actions.ActOnNoexceptSpec(NoexceptExpr.get(),
                                                NoexceptType);
       NoexceptRange = SourceRange(KeywordLoc, T.getCloseLocation());
     } else {
       NoexceptType = EST_BasicNoexcept;
     }
   } else {
     // There is no argument.
     NoexceptType = EST_BasicNoexcept;

clang/lib/Sema/SemaExceptionSpec.cpp

return llvm::StringSwitch<bool>(RD->getIdentifier()->getName())
       .Case("array", true)
       .Case("pair", IsInStd)
       .Case("priority_queue", IsInStd)
       .Case("stack", IsInStd)
       .Case("queue", IsInStd)
       .Default(false);
 }
 
-ExprResult Sema::ActOnNoexceptSpec(SourceLocation NoexceptLoc,
-                                   Expr *NoexceptExpr,
+ExprResult Sema::ActOnNoexceptSpec(Expr *NoexceptExpr,
                                    ExceptionSpecificationType &EST) {
-  // FIXME: This is bogus, a noexcept expression is not a condition.
-  ExprResult Converted = CheckBooleanCondition(NoexceptLoc, NoexceptExpr);
+
+  if (NoexceptExpr->isTypeDependent() ||
+      NoexceptExpr->containsUnexpandedParameterPack()) {
+    EST = EST_DependentNoexcept;
+    return NoexceptExpr;
+  }
+
+  llvm::APSInt Result;
+  ExprResult Converted = CheckConvertedConstantExpression(
+      NoexceptExpr, Context.BoolTy, Result, CCEK_Noexcept);
+
   if (Converted.isInvalid()) {
     EST = EST_NoexceptFalse;
-
     // Fill in an expression of 'false' as a fixup.
     auto *BoolExpr = new (Context)
         CXXBoolLiteralExpr(false, Context.BoolTy, NoexceptExpr->getBeginLoc());
     llvm::APSInt Value{1};
     Value = 0;
     return ConstantExpr::Create(Context, BoolExpr, APValue{Value});
   }
 
   if (Converted.get()->isValueDependent()) {
     EST = EST_DependentNoexcept;
     return Converted;
   }
 
-  llvm::APSInt Result;
-  Converted = VerifyIntegerConstantExpression(
-      Converted.get(), &Result, diag::err_noexcept_needs_constant_expression);
   if (!Converted.isInvalid())
     EST = !Result ? EST_NoexceptFalse : EST_NoexceptTrue;
   return Converted;
 }
 
 /// CheckSpecifiedExceptionType - Check if the given type is valid in an
 /// exception specification. Incomplete types, or pointers to incomplete types
 /// other than void are not allowed.

clang/lib/Sema/SemaOverload.cpp

if (checkPlaceholderForOverload(S, From))
     return ExprError();
 
   // C++1z [expr.const]p3:
   //  A converted constant expression of type T is an expression,
   //  implicitly converted to type T, where the converted
   //  expression is a constant expression and the implicit conversion
   //  sequence contains only [... list of conversions ...].
   ImplicitConversionSequence ICS =
-      CCE == Sema::CCEK_ExplicitBool
+      (CCE == Sema::CCEK_ExplicitBool || CCE == Sema::CCEK_Noexcept)
           ? TryContextuallyConvertToBool(S, From)
           : TryCopyInitialization(S, From, T,
                                   /*SuppressUserConversions=*/false,
                                   /*InOverloadResolution=*/false,
                                   /*AllowObjCWritebackConversion=*/false,
                                   /*AllowExplicit=*/false);
   StandardConversionSequence *SCS = nullptr;
   switch (ICS.getKind()) {
   case ImplicitConversionSequence::StandardConversion:
     SCS = &ICS.Standard;
     break;
   case ImplicitConversionSequence::UserDefinedConversion:
     if (T->isRecordType())
       SCS = &ICS.UserDefined.Before;

clang/lib/Sema/TreeTransform.h

bool TreeTransform<Derived>::TransformExceptionSpec(
   if (isComputedNoexcept(ESI.Type)) {
     EnterExpressionEvaluationContext Unevaluated(
         getSema(), Sema::ExpressionEvaluationContext::ConstantEvaluated);
     ExprResult NoexceptExpr = getDerived().TransformExpr(ESI.NoexceptExpr);
     if (NoexceptExpr.isInvalid())
       return true;
 
     ExceptionSpecificationType EST = ESI.Type;
     NoexceptExpr =
-        getSema().ActOnNoexceptSpec(Loc, NoexceptExpr.get(), EST);
+        getSema().ActOnNoexceptSpec(NoexceptExpr.get(), EST);
     if (NoexceptExpr.isInvalid())
       return true;
 
     if (ESI.NoexceptExpr != NoexceptExpr.get() || EST != ESI.Type)
       Changed = true;
     ESI.NoexceptExpr = NoexceptExpr.get();
     ESI.Type = EST;
   }

clang/test/CXX/except/except.spec/p1.cpp

 }
 
 // Sema tests, noexcept specification
 
 namespace noex {
 
   struct A {};
 
-  void g1() noexcept(A()); // expected-error {{not contextually convertible}}
-  void g2(bool b) noexcept(b); // expected-error {{argument to noexcept specifier must be a constant expression}} expected-note {{function parameter 'b' with unknown value}} expected-note {{here}}
-
+  void g1() noexcept(A());     // expected-error {{value of type 'noex::A' is not implicitly convertible to 'bool'}}
+  void g2(bool b) noexcept(b); // expected-error {{noexcept specifier argument is not a constant expression}} expected-note {{function parameter 'b' with unknown value}} expected-note {{here}}
 }
 
 namespace noexcept_unevaluated {
   template<typename T> bool f(T) {
     T* x = 1;
   }
 
   template<typename T>
   void g(T x) noexcept((sizeof(T) == sizeof(int)) || noexcept(f(x))) { }
 
   void h() {
     g(1);
   }
 }
 
 namespace PR11084 {
-  template<int X> struct A { 
-    static int f() noexcept(1/X) { return 10; }  // expected-error{{argument to noexcept specifier must be a constant expression}} expected-note{{division by zero}}
-  };
+template <int X> struct A {
+  static int f() noexcept(1 / X) { return 10; } // expected-error{{noexcept specifier argument is not a constant expression}} expected-note{{division by zero}}
 
   template<int X> void f() {
-    int (*p)() noexcept(1/X); // expected-error{{argument to noexcept specifier must be a constant expression}} expected-note{{division by zero}}
+    int (*p)() noexcept(1 / X); // expected-error{{noexcept specifier argument is not a constant expression}} expected-note{{division by zero}}
   };
 
   void g() {
     A<0>::f(); // expected-note{{in instantiation of exception specification for 'f'}}
     f<0>(); // expected-note{{in instantiation of function template specialization}}
   }
 }
 
 namespace FuncTmplNoexceptError {
   int a = 0;
-  // expected-error@+1{{argument to noexcept specifier must be a constant expression}}
+  // expected-error@+1{{noexcept specifier argument is not a constant expression}}
   template <class T> T f() noexcept(a++){ return {};}
   void g(){
     f<int>();
   }
 };

clang/test/SemaCXX/cxx0x-noexcept-expression.cpp

void vla(bool b) {
   static_assert(!noexcept(static_cast<int(*)[b ? 41 : 42]>(0)), "");
   static_assert(!noexcept(static_cast<int(*)[b ? throw : 42]>(0)), "");
   static_assert(!noexcept(reinterpret_cast<int(*)[b ? throw : 42]>(0)), "");
   static_assert(!noexcept((int(*)[b ? throw : 42])0), "");
   static_assert(!noexcept((int(*)[b ? throw : 42]){0}), "");
 }
 
 struct pr_44514 {
-  // expected-error@+1{{value of type 'void' is not contextually convertible to 'bool'}}
+  // expected-error@+1{{value of type 'void' is not implicitly convertible to 'bool'}}
   void foo(void) const &noexcept(f());
 };
+
+namespace P1401 {
+const int *ptr = nullptr;
+void f() noexcept(sizeof(char[2])); // expected-error {{noexcept specifier argument evaluates to 2, which cannot be narrowed to type 'bool'}}
+void g() noexcept(sizeof(char));
+void h() noexcept(ptr);     // expected-error {{conversion from 'const int *' to 'bool' is not allowed in a converted constant expression}}
+void i() noexcept(nullptr); // expected-error {{conversion from 'nullptr_t' to 'bool' is not allowed in a converted constant expression}}
+void j() noexcept(0);
+void k() noexcept(1);
+void l() noexcept(2); // expected-error {{noexcept specifier argument evaluates to 2, which cannot be narrowed to type 'bool'}}
+} // namespace P1401

clang/test/SemaCXX/cxx2a-explicit-bool.cpp

 
 template <size_t N>
 Str::Str(char const(&str)[N]) { }
 
 Str a = "short";
 Str b = "not so short";// expected-error {{no viable conversion}}
 
 }
+
+namespace P1401 {
+
+const int *ptr;
+
+struct S {
+  explicit(sizeof(char[2])) S(char); // expected-error {{explicit specifier argument evaluates to 2, which cannot be narrowed to type 'bool'}}
+  explicit(ptr) S(long);             // expected-error {{conversion from 'const int *' to 'bool' is not allowed in a converted constant expression}}
+  explicit(nullptr) S(int);          // expected-error {{conversion from 'nullptr_t' to 'bool' is not allowed in a converted constant expression}}
+  explicit(42L) S(int, int);         // expected-error {{explicit specifier argument evaluates to 42, which cannot be narrowed to type 'bool'}}
+  explicit(sizeof(char)) S();
+  explicit(0) S(char, char);
+  explicit(1L) S(char, char, char);
+};
+} // namespace P1401

clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp

TEST_P(ASTMatchersTest, Matcher_NoexceptExpression) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   StatementMatcher NoExcept = cxxNoexceptExpr();
   EXPECT_TRUE(matches("void foo(); bool bar = noexcept(foo());", NoExcept));
   EXPECT_TRUE(
       matches("void foo() noexcept; bool bar = noexcept(foo());", NoExcept));
   EXPECT_TRUE(notMatches("void foo() noexcept;", NoExcept));
-  EXPECT_TRUE(notMatches("void foo() noexcept(1+1);", NoExcept));
+  EXPECT_TRUE(notMatches("void foo() noexcept(0+1);", NoExcept));
   EXPECT_TRUE(matches("void foo() noexcept(noexcept(1+1));", NoExcept));
 }
 
 TEST_P(ASTMatchersTest, Matcher_DefaultArgument) {
   if (!GetParam().isCXX()) {
     return;
   }
   StatementMatcher Arg = cxxDefaultArgExpr();

clang/www/cxx_status.html

</tr>
     <tr>
       <td>Allow duplicate attributes</td>
       <td><a href="https://wg21.link/P2156R1">P2156R1</a></td>
       <td class="unreleased" align="center">Clang 13</td>
     </tr>
     <tr>
       <td>Narrowing contextual conversions to bool</td>
       <td><a href="https://wg21.link/P1401R5">P1401R5</a></td>
-      <td class="partial" align="center">Clang 13</td>
+      <td class="unreleased" align="center">Clang 14</td>
     </tr>
     <tr>
       <td>Trimming whitespaces before line splicing</td>
       <td><a href="https://wg21.link/P2223R2">P2223R2</a></td>
       <td class="full" align="center">Yes</td>
     </tr>
     <tr>
       <td>Make declaration order layout mandated</td>