[clang] CWG 2082 and 2346: loosen the restrictions on parameters and local variables in default arguments.

[riccibruno]

Summary

This patch implements the resolution of CWG 2082 and CWG 2346.

The resolution of CWG 2082 changed [dcl.fct.default]p7 and p9 to allow a parameter
or local variable to appear in a default argument if not in a potentially-evaluated expression.

The resolution of CWG 2346 changed [dcl.fct.default]p7 to allow a local variable
to appear in a default argument if not odr-used.

An issue remains after this patch (see the FIXME in test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p7.cpp).
This is addressed by the next patch.

[rsmith]

clang/lib/Sema/SemaDeclCXX.cpp

98

I think this is an oversight, and we should probably allow all non-odr-use mentions here. I'll take this to the committee to check. But let's go with the rule as written for now.

114

Do we perform this check after finishing the full-expression and properly setting the 'non-odr-use' bits? Oh, I see, that's what the follow-up change is about :)

[erichkeane]

This looks like the right interpretation of the standard/implementation to me. But please do not commit on this accept for another day or two to give the rest a chance to look.

[rsmith]

clang/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p9.cpp

9

I'd like to see an example like:

void f5(int x, int y = ((void)x, 0));

to demonstrate that we're checking for potentially-evaluated mentions, not odr-uses, here. ((void)x is not an odr-use, but is potentially-evaluated.)

[riccibruno]

Add the example in clang/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p9.cpp as requested.

clang/lib/Sema/SemaDeclCXX.cpp

 }
 
 /// VisitDeclRefExpr - Visit a reference to a declaration, to
 /// determine whether this declaration can be used in the default
 /// argument expression.
 bool CheckDefaultArgumentVisitor::VisitDeclRefExpr(const DeclRefExpr *DRE) {
   const NamedDecl *Decl = DRE->getDecl();
   if (const auto *Param = dyn_cast<ParmVarDecl>(Decl)) {
-    // C++ [dcl.fct.default]p9
-    //   Default arguments are evaluated each time the function is
-    //   called. The order of evaluation of function arguments is
-    //   unspecified. Consequently, parameters of a function shall not
-    //   be used in default argument expressions, even if they are not
-    //   evaluated. Parameters of a function declared before a default
-    //   argument expression are in scope and can hide namespace and
-    //   class member names.
+    // C++ [dcl.fct.default]p9:
+    //   [...] parameters of a function shall not be used in default
+    //   argument expressions, even if they are not evaluated. [...]
+    //
+    // C++17 [dcl.fct.default]p9 (by CWG 2082):
+    //   [...] A parameter shall not appear as a potentially-evaluated
+    //   expression in a default argument. [...]
+    //
+    if (DRE->isNonOdrUse() != NOUR_Unevaluated)
       return S.Diag(DRE->getBeginLoc(),
                     diag::err_param_default_argument_references_param)
              << Param->getDeclName() << DefaultArg->getSourceRange();
   } else if (const auto *VDecl = dyn_cast<VarDecl>(Decl)) {
-    // C++ [dcl.fct.default]p7
+    // C++ [dcl.fct.default]p7:
     //   Local variables shall not be used in default argument
     //   expressions.
-    if (VDecl->isLocalVarDecl())
+    //
+    // C++17 [dcl.fct.default]p7 (by CWG 2082):
+    //   A local variable shall not appear as a potentially-evaluated
+    //   expression in a default argument.
+    //
+    // C++20 [dcl.fct.default]p7 (DR as part of P0588R1, see also CWG 2346):
+    //   Note: A local variable cannot be odr-used (6.3) in a default argument.
+    //
+    if (VDecl->isLocalVarDecl() && !DRE->isNonOdrUse())
       return S.Diag(DRE->getBeginLoc(),
                     diag::err_param_default_argument_references_local)
              << VDecl->getDeclName() << DefaultArg->getSourceRange();
   }
 
   return false;
 }
 

clang/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p7.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
-void h()
-{
-  int i;
-  extern void h2(int x = sizeof(i)); // expected-error {{default argument references local variable 'i' of enclosing function}}
+void h() {
+  int i1 = 0;
+  extern void h1(int x = i1);
+  // expected-error@-1 {{default argument references local variable 'i1' of enclosing function}}
+
+  const int i2 = 0;
+  extern void h2a(int x = i2); // FIXME: ok, not odr-use
+  // expected-error@-1 {{default argument references local variable 'i2' of enclosing function}}
+  extern void h2b(int x = i2 + 0); // ok, not odr-use
+
+  const int i3 = 0;
+  extern void h3(const int *x = &i3);
+  // expected-error@-1 {{default argument references local variable 'i3' of enclosing function}}
+
+  const int i4 = 0;
+  extern void h4(int x = sizeof(i4));         // ok, not odr-use
+  extern void h5(int x = decltype(i4 + 4)()); // ok, not odr-use
 }

clang/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p8.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 class A { 
   void f(A* p = this) { }  // expected-error{{invalid use of 'this'}}
+
+  void test();
 };
+
+void A::test() {
+  void g(int = this); // expected-error {{default argument references 'this'}}
+}

clang/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p9.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+void h() {
+  void f1(int x, int y = sizeof(x));      // ok
+  void f2(int x, int y = decltype(x)());  // ok
+  void f3(int x, int y = x);
+  // expected-error@-1 {{default argument references parameter 'x'}}
+  void f4(int x, int y = x + 0);
+  // expected-error@-1 {{default argument references parameter 'x'}}
+  void f5(int x, int y = ((void)x, 0));
+  // expected-error@-1 {{default argument references parameter 'x'}}
+}

clang/test/CXX/drs/dr20xx.cpp

 #endif
 
 #if __cplusplus > 201703L
     static constinit int h = h; // expected-error {{constant initializer}} expected-note {{outside its lifetime}} expected-note {{'constinit'}}
 #endif
   }
 }
 
+namespace dr2082 { // dr2082: 11
+  void test1(int x, int = sizeof(x)); // ok
+#if __cplusplus >= 201103L
+  void test2(int x, int = decltype(x){}); // ok
+#endif
+}
+
 namespace dr2083 { // dr2083: partial
 #if __cplusplus >= 201103L
   void non_const_mem_ptr() {
     struct A {
       int x;
       int y;
     };
     constexpr A a = {1, 2};

clang/test/CXX/drs/dr23xx.cpp

 // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2>&1
 // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2>&1 | FileCheck %s
 // RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2>&1 | FileCheck %s
 // RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2>&1 | FileCheck %s
 // RUN: %clang_cc1 -std=c++2a %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2>&1 | FileCheck %s
 
+namespace dr2346 { // dr2346: 11
+  void test() {
+    const int i2 = 0;
+    extern void h2b(int x = i2 + 0); // ok, not odr-use
+  }
+}
+
 namespace dr2352 { // dr2352: 10
   int **p;
   const int *const *const &f1() { return p; }
   int *const *const &f2() { return p; }
   int **const &f3() { return p; }
 
   const int **const &f4() { return p; } // expected-error {{reference to type 'const int **const' could not bind to an lvalue of type 'int **'}}
   const int *const *&f5() { return p; } // expected-error {{binding reference of type 'const int *const *' to value of type 'int **' not permitted due to incompatible qualifiers}}