[clang][NFC] Prepare C++ DR suite for better test isolation

[Endill]

Summary

This patch mechanically modifies existing DR status notation to incorporate //--- notation used by split-file utility.

This is a part of a bigger transition. Example could be seen in [[ a diff: https://gist.github.com/Endilll/1d8035d42bdf0dc73eaaf8a8c343bf8c/revisions. The idea is to split drNxx.cpp files into bunch of small files before feeding them into compiler. This would prevent cases like [[ https://godbolt.org/z/Pd88e1dr9 | this one ]], which is a reduced example of what I encountered while working on D148433.

I go into more details in the related Discourse thread.

[aaron.ballman]

The changes LGTM (verified off-list that the regenerated HTML is identical before and after this change), but let's not land this until we've gotten farther along the review process with the related changes to split-file and the diagnostic verifier (just in case those reviews cause us to change direction for some reason).

[Endill]

In D151426#4371730, @aaron.ballman wrote:

The changes LGTM (verified off-list that the regenerated HTML is identical before and after this change),

I've run make_cxx_dr_status on top of this patch, and learned that the patch didn't change anything in cxx_dr_status.html, and that it has been written resilient enough to happily digest the new notation of status comments.

but let's not land this until we've gotten farther along the review process with the related changes to split-file and the diagnostic verifier (just in case those reviews cause us to change direction for some reason).

I don't mind being cautious here. Even though initial feedback on every of them doesn't seem to reject the direction we've been pushing towards. Here are the patches we're waiting for:

• https://reviews.llvm.org/D150856
• https://reviews.llvm.org/D150990
• https://reviews.llvm.org/D151320

clang/test/CXX/drs/dr0xx.cpp

 // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -Wno-bind-to-temporary-copy
 // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
 // RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
 // RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
 // RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
 // RUN: %clang_cc1 -std=c++23 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
 
-namespace dr1 { // dr1: no
+//--- dr1: no
+namespace dr1 {
   namespace X { extern "C" void dr1_f(int a = 1); }
   namespace Y { extern "C" void dr1_f(int a = 1); }
   using X::dr1_f; using Y::dr1_f;
   void g() {
     dr1_f(0);
     // FIXME: This should be rejected, due to the ambiguous default argument.
     dr1_f();
   }
void k() {
     using dr1::i;
     void i(int = 1);
     i(0);
     // FIXME: This should be rejected, due to the ambiguous default argument.
     i();
   }
 }
 
-namespace dr3 { // dr3: yes
+//--- dr3: yes
+namespace dr3 {
   template<typename T> struct A {};
   template<typename T> void f(T) { A<T> a; } // expected-note {{implicit instantiation}}
   template void f(int);
   template<> struct A<int> {}; // expected-error {{explicit specialization of 'dr3::A<int>' after instantiation}}
 }
 
-namespace dr4 { // dr4: yes
+//--- dr4: yes
+namespace dr4 {
   extern "C" {
     static void dr4_f(int) {}
     static void dr4_f(float) {}
     void dr4_g(int) {} // expected-note {{previous}}
     void dr4_g(float) {} // expected-error {{conflicting types}}
   }
 }
 
-namespace dr5 { // dr5: yes
+//--- dr5: yes
+namespace dr5 {
   struct A {} a;
   struct B {
     B(const A&);
     B(const B&);
   };
   const volatile B b = a;
 
   struct C { C(C&); };
   struct D : C {};
   struct E { operator D&(); } e;
   const C c = e;
 }
 
-namespace dr7 { // dr7: yes
+//--- dr7: yes
+namespace dr7 {
   class A { public: ~A(); };
   class B : virtual private A {}; // expected-note 2 {{declared private here}}
   class C : public B {} c; // expected-error 2 {{inherited virtual base class 'A' has private destructor}} \
                            // expected-note {{implicit default constructor for 'dr7::C' first required here}} \
                            // expected-note {{implicit destructor for 'dr7::C' first required here}}
   class VeryDerivedC : public B, virtual public A {} vdc;
 
   class X { ~X(); }; // expected-note {{here}}
   class Y : X { ~Y() {} }; // expected-error {{private destructor}}
 
   namespace PR16370 { // This regressed the first time DR7 was fixed.
     struct S1 { virtual ~S1(); };
     struct S2 : S1 {};
     struct S3 : S2 {};
     struct S4 : virtual S2 {};
     struct S5 : S3, S4 {
       S5();
       ~S5();
     };
     S5::S5() {}
   }
 }
 
-namespace dr8 { // dr8: dup 45
+//--- dr8: dup 45
+namespace dr8 {
   class A {
     struct U;
     static const int k = 5;
     void f();
     template<typename, int, void (A::*)()> struct T;
 
     T<U, k, &A::f> *g();
   };
   A::T<A::U, A::k, &A::f> *A::g() { return 0; }
 }
 
-namespace dr9 { // dr9: yes
+//--- dr9: yes
+namespace dr9 {
   struct B {
   protected:
     int m; // expected-note {{here}}
     friend int R1();
   };
   struct N : protected B { // expected-note {{protected}}
     friend int R2();
   } n;
   int R1() { return n.m; } // expected-error {{protected member}}
   int R2() { return n.m; }
 }
 
-namespace dr10 { // dr10: dup 45
+//--- dr10: dup 45
+namespace dr10 {
   class A {
     struct B {
       A::B *p;
     };
   };
 }
 
-namespace dr11 { // dr11: yes
+//--- dr11: yes
+namespace dr11 {
   template<typename T> struct A : T {
     using typename T::U;
     U u;
   };
   template<typename T> struct B : T {
     using T::V;
     V v; // expected-error {{unknown type name}}
   };
   struct X { typedef int U; };
   A<X> ax;
 }
 
-namespace dr12 { // dr12: sup 239
+//--- dr12: sup 239
+namespace dr12 {
   enum E { e };
   E &f(E, E = e);
   void g() {
     int &f(int, E = e);
     // Under DR12, these call two different functions.
     // Under DR239, they call the same function.
     int &b = f(e);
     int &c = f(1);
   }
 }
 
-namespace dr13 { // dr13: no
+//--- dr13: no
+namespace dr13 {
   extern "C" void f(int);
   void g(char);
 
   template<typename T> struct A {
     A(void (*fp)(T));
   };
   template<typename T> int h(void (T));
 
   A<int> a1(f); // FIXME: We should reject this.
   A<char> a2(g);
   int a3 = h(f); // FIXME: We should reject this.
   int a4 = h(g);
 }
 
-namespace dr14 { // dr14: yes
+//--- dr14: yes
+namespace dr14 {
   namespace X { extern "C" int dr14_f(); }
   namespace Y { extern "C" int dr14_f(); }
   using namespace X;
   using namespace Y;
   int k = dr14_f();
 
   class C {
     int k;
     friend int Y::dr14_f();
   } c;
   namespace Z {
     extern "C" int dr14_f() { return c.k; }
   }
 
   namespace X { typedef int T; typedef int U; } // expected-note {{candidate}}
   namespace Y { typedef int T; typedef long U; } // expected-note {{candidate}}
   T t; // ok, same type both times
   U u; // expected-error {{ambiguous}}
 }
 
-namespace dr15 { // dr15: yes
+//--- dr15: yes
+namespace dr15 {
   template<typename T> void f(int); // expected-note {{previous}}
   template<typename T> void f(int = 0); // expected-error {{default arguments cannot be added}}
 }
 
-namespace dr16 { // dr16: yes
+//--- dr16: yes
+namespace dr16 {
   class A { // expected-note {{here}}
     void f(); // expected-note {{here}}
     friend class C;
   };
   class B : A {}; // expected-note 3{{here}}
   class C : B {
     void g() {
       f(); // expected-error {{private member}}
       A::f(); // expected-error {{private member}} expected-error {{private base}}
     }
   };
 }
 
-namespace dr17 { // dr17: yes
+//--- dr17: yes
+namespace dr17 {
   class A {
     int n;
     int f();
     struct C;
   };
   struct B : A {} b;
   int A::f() { return b.n; }
   struct A::C : A {
     int g() { return n; }
   };
 }
 
 // dr18: sup 577
 
-namespace dr19 { // dr19: yes
+//--- dr19: yes
+namespace dr19 {
   struct A {
     int n; // expected-note {{here}}
   };
   struct B : protected A { // expected-note {{here}}
   };
   struct C : B {} c;
   struct D : B {
     int get1() { return c.n; } // expected-error {{protected member}}
     int get2() { return ((A&)c).n; } // ok, A is an accessible base of B from here
   };
 }
 
-namespace dr20 { // dr20: yes
+//--- dr20: yes
+namespace dr20 {
   class X {
   public:
     X();
   private:
     X(const X&); // expected-note {{here}}
   };
   X &f();
   X x = f(); // expected-error {{private}}
 }
 
-namespace dr21 { // dr21: yes
+//--- dr21: yes
+namespace dr21 {
   template<typename T> struct A;
   struct X {
     template<typename T = int> friend struct A; // expected-error {{default template argument not permitted on a friend template}}
     template<typename T = int> friend struct B; // expected-error {{default template argument not permitted on a friend template}}
   };
 }
 
-namespace dr22 { // dr22: sup 481
+//--- dr22: sup 481
+namespace dr22 {
   template<typename dr22_T = dr22_T> struct X; // expected-error {{unknown type name 'dr22_T'}}
   typedef int T;
   template<typename T = T> struct Y;
 }
 
-namespace dr23 { // dr23: yes
+//--- dr23: yes
+namespace dr23 {
   template<typename T> void f(T, T); // expected-note {{candidate}}
   template<typename T> void f(T, int); // expected-note {{candidate}}
   void g() { f(0, 0); } // expected-error {{ambiguous}}
 }
 
 // dr24: na
 
-namespace dr25 { // dr25: yes
+//--- dr25: yes
+namespace dr25 {
   struct A {
     void f() throw(int); // expected-error 0-1{{ISO C++17 does not allow}} expected-note 0-1{{use 'noexcept}}
   };
   void (A::*f)() throw (int); // expected-error 0-1{{ISO C++17 does not allow}} expected-note 0-1{{use 'noexcept}}
   void (A::*g)() throw () = f;
 #if __cplusplus <= 201402L
   // expected-error@-2 {{is not superset of source}}
 #else
#if __cplusplus <= 201402L
   // expected-error@-2 {{is not superset of source}}
 #else
   // expected-error@-4 {{different exception specifications}}
 #endif
     j = &A::f;
   }
 }
 
-namespace dr26 { // dr26: yes
+//--- dr26: yes
+namespace dr26 {
   struct A { A(A, const A & = A()); }; // expected-error {{must pass its first argument by reference}}
   struct B {
     B();
     // FIXME: In C++98, we diagnose this twice.
     B(const B &, B = B());
 #if __cplusplus <= 201402L
     // expected-error@-2 1+{{recursive evaluation of default argument}} expected-note@-2 1+{{used here}}
 #endif
   };
   struct C {
     static C &f();
     C(const C &, C = f()); // expected-error {{recursive evaluation of default argument}} expected-note {{used here}}
   };
 }
 
-namespace dr27 { // dr27: yes
+//--- dr27: yes
+namespace dr27 {
   enum E { e } n;
   E &m = true ? n : n;
 }
 
 // dr28: na lib
 
-namespace dr29 { // dr29: 3.4
+//--- dr29: 3.4
+namespace dr29 {
   void dr29_f0(); // expected-note {{here}}
   void g0() { void dr29_f0(); }
   extern "C++" void g0_cxx() { void dr29_f0(); }
   extern "C" void g0_c() { void dr29_f0(); } // expected-error {{different language linkage}}
 
   extern "C" void dr29_f1(); // expected-note {{here}}
   void g1() { void dr29_f1(); }
   extern "C" void g1_c() { void dr29_f1(); }
namespace dr29 {
 
   extern "C++" void g8();
   extern "C" void dr29_f8(); // expected-note {{here}}
   extern "C++" void g8() {
     void dr29_f8(); // expected-error {{different language linkage}}
   }
 }
 
-namespace dr30 { // dr30: sup 468 c++11
+//--- dr30: sup 468 c++11
+namespace dr30 {
   struct A {
     template<int> static int f();
   } a, *p = &a;
   int x = A::template f<0>();
   int y = a.template f<0>();
   int z = p->template f<0>();
 #if __cplusplus < 201103L
   // FIXME: It's not clear whether DR468 applies to C++98 too.
   // expected-error@-5 {{'template' keyword outside of a template}}
   // expected-error@-5 {{'template' keyword outside of a template}}
   // expected-error@-5 {{'template' keyword outside of a template}}
 #endif
 }
 
-namespace dr31 { // dr31: yes
+//--- dr31: yes
+namespace dr31 {
   class X {
   private:
     void operator delete(void*); // expected-note {{here}}
   };
   // We would call X::operator delete if X() threw (even though it can't,
   // and even though we allocated the X using ::operator delete).
   X *p = new X; // expected-error {{private}}
 }
 
 // dr32: na
 
-namespace dr33 { // dr33: yes
+//--- dr33: yes
+namespace dr33 {
   namespace X { struct S; void f(void (*)(S)); } // expected-note {{candidate}}
   namespace Y { struct T; void f(void (*)(T)); } // expected-note {{candidate}}
   void g(X::S);
   template<typename Z> Z g(Y::T);
   void h() { f(&g); } // expected-error {{ambiguous}}
 
   template<typename T> void t(X::S);
   template<typename T, typename U = void> void u(X::S); // expected-error 0-1{{default template argument}}
namespace member {
     int m = Q() + X().f<int>; // ok
     int n = Q() + (&(X().f<int>)); // ok
   }
 }
 
 // dr34: na
 // dr35: dup 178
 
-namespace dr36 { // dr36: yes
+//--- dr36: yes
+namespace dr36 {
 namespace example1 {
   namespace A {
     int i;
   }
   
   namespace A1 {
     using A::i;
     using A::i;
struct G : E<T> {
     using E<T>::k; // expected-note {{previous using declaration}}
     using E<T>::k; // expected-error {{redeclaration of using declaration}}
   };
 }
 }
 
 // dr37: sup 475
 
-namespace dr38 { // dr38: yes
+//--- dr38: yes
+namespace dr38 {
   template<typename T> struct X {};
   template<typename T> X<T> operator+(X<T> a, X<T> b) { return a; }
   template X<int> operator+<int>(X<int>, X<int>);
 }
 
-namespace dr39 { // dr39: no
+//--- dr39: no
+namespace dr39 {
   namespace example1 {
     struct A { int &f(int); };
     struct B : A {
       using A::f;
       float &f(float);
     } b;
     int &r = b.f(0);
   }

 #if __cplusplus >= 201103L
     decltype(D::n) n; // expected-error {{found in multiple base}}
 #endif
   }
 }
 
 // dr40: na
 
-namespace dr41 { // dr41: yes
+//--- dr41: yes
+namespace dr41 {
   struct S f(S);
 }
 
-namespace dr42 { // dr42: yes
+//--- dr42: yes
+namespace dr42 {
   struct A { static const int k = 0; };
   struct B : A { static const int k = A::k; };
 }
 
 // dr43: na
 
-namespace dr44 { // dr44: sup 727
+//--- dr44: sup 727
+namespace dr44 {
   struct A {
     template<int> void f();
     template<> void f<0>();
   };
 }
 
-namespace dr45 { // dr45: yes
+//--- dr45: yes
+namespace dr45 {
   class A {
     class B {};
     class C : B {};
     C c;
   };
 }
 
-namespace dr46 { // dr46: yes
+//--- dr46: yes
+namespace dr46 {
   template<typename> struct A { template<typename> struct B {}; };
   template template struct A<int>::B<int>; // expected-error {{expected unqualified-id}}
 }
 
-namespace dr47 { // dr47: sup 329
+//--- dr47: sup 329
+namespace dr47 {
   template<typename T> struct A {
     friend void f() { T t; } // expected-error {{redefinition}} expected-note {{previous}}
   };
   A<int> a;
   A<float> b; // expected-note {{instantiation of}}
 
   void f();
   void g() { f(); }
 }
 
-namespace dr48 { // dr48: yes
+//--- dr48: yes
+namespace dr48 {
   namespace {
     struct S {
       static const int m = 0;
       static const int n = 0;
       static const int o = 0;
     };
   }
   int a = S::m;
   // FIXME: We should produce a 'has internal linkage but is not defined'
   // diagnostic for 'S::n'.
   const int &b = S::n;
   const int S::o;
   const int &c = S::o;
 }
 
-namespace dr49 { // dr49: yes
+//--- dr49: yes
+namespace dr49 {
   template<int*> struct A {}; // expected-note 0-2{{here}}
   int k;
 #if __has_feature(cxx_constexpr)
   constexpr
 #endif
   int *const p = &k; // expected-note 0-2{{here}}
   A<&k> a;
   A<p> b;
#if __cplusplus < 201103L
   // expected-error@-2 {{must have its address taken}}
 #else
   // expected-error@-4 {{constant expression}}
   // expected-note@-5 {{read of non-constexpr}}
   // expected-note@-7 {{declared here}}
 #endif
 }
 
-namespace dr50 { // dr50: yes
+//--- dr50: yes
+namespace dr50 {
   struct X; // expected-note {{forward}}
   extern X *p;
   X *q = (X*)p;
   X *r = static_cast<X*>(p);
   X *s = const_cast<X*>(p);
   X *t = reinterpret_cast<X*>(p);
   X *u = dynamic_cast<X*>(p); // expected-error {{incomplete}}
 }
 
-namespace dr51 { // dr51: yes
+//--- dr51: yes
+namespace dr51 {
   struct A {};
   struct B : A {};
   struct S {
     operator A&();
     operator B&();
   } s;
   A &a = s;
 }
 
-namespace dr52 { // dr52: yes
+//--- dr52: yes
+namespace dr52 {
   struct A { int n; }; // expected-note {{here}}
   struct B : private A {} b; // expected-note 2{{private}}
   // FIXME: This first diagnostic is very strangely worded, and seems to be bogus.
   int k = b.A::n; // expected-error {{'A' is a private member of 'dr52::A'}}
   // expected-error@-1 {{cannot cast 'struct B' to its private base}}
 }
 
-namespace dr53 { // dr53: yes
+//--- dr53: yes
+namespace dr53 {
   int n = 0;
   enum E { e } x = static_cast<E>(n);
 }
 
-namespace dr54 { // dr54: yes
+//--- dr54: yes
+namespace dr54 {
   struct A { int a; } a;
   struct V { int v; } v;
   struct B : private A, virtual V { int b; } b; // expected-note 6{{private here}}
 
   A &sab = static_cast<A&>(b); // expected-error {{private base}}
   A *spab = static_cast<A*>(&b); // expected-error {{private base}}
   int A::*smab = static_cast<int A::*>(&B::b); // expected-error {{private base}}
   B &sba = static_cast<B&>(a); // expected-error {{private base}}
namespace dr54 {
   V &cvb = (V&)(b);
   V *cpvb = (V*)(&b);
   int V::*cmvb = (int V::*)(&B::b); // expected-error {{virtual base}}
   B &cbv = (B&)(v); // expected-error {{virtual base}}
   B *cpbv = (B*)(&v); // expected-error {{virtual base}}
   int B::*cmbv = (int B::*)(&V::v); // expected-error {{virtual base}}
 }
 
-namespace dr55 { // dr55: yes
+//--- dr55: yes
+namespace dr55 {
   enum E { e = 5 };
   int test[(e + 1 == 6) ? 1 : -1];
 }
 
-namespace dr56 { // dr56: yes
+//--- dr56: yes
+namespace dr56 {
   struct A {
     typedef int T; // expected-note {{previous}}
     typedef int T; // expected-error {{redefinition}}
   };
   struct B {
     struct X;
     typedef X X; // expected-note {{previous}}
     typedef X X; // expected-error {{redefinition}}
   };
 }
 
-namespace dr58 { // dr58: yes
+//--- dr58: yes
+namespace dr58 {
   // FIXME: Ideally, we should have a CodeGen test for this.
 #if __cplusplus >= 201103L
   enum E1 { E1_0 = 0, E1_1 = 1 };
   enum E2 { E2_0 = 0, E2_m1 = -1 };
   struct X { E1 e1 : 1; E2 e2 : 1; };
   static_assert(X{E1_1, E2_m1}.e1 == 1, "");
   static_assert(X{E1_1, E2_m1}.e2 == -1, "");
 #endif
 }
 
-namespace dr59 { // dr59: yes
+//--- dr59: yes
+namespace dr59 {
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdeprecated-volatile"
   template<typename T> struct convert_to { operator T() const; };
   struct A {}; // expected-note 5+{{candidate}}
   struct B : A {}; // expected-note 0+{{candidate}}
 
   A a1 = convert_to<A>();
   A a2 = convert_to<A&>();
#endif
   int n1 = convert_to<int>();
   int n2 = convert_to<int&>();
   int n3 = convert_to<const int>();
   int n4 = convert_to<const volatile int>();
   int n5 = convert_to<const volatile int&>();
 #pragma clang diagnostic pop
 }
 
-namespace dr60 { // dr60: yes
+//--- dr60: yes
+namespace dr60 {
   void f(int &);
   int &f(...);
   const int k = 0;
   int &n = f(k);
 }
 
-namespace dr61 { // dr61: yes
+//--- dr61: yes
+namespace dr61 {
   struct X {
     static void f();
   } x;
   struct Y {
     static void f();
     static void f(int);
   } y;
   // This is (presumably) valid, because x.f does not refer to an overloaded
   // function name.
   void (*p)() = &x.f;
   void (*q)() = &y.f; // expected-error {{cannot create a non-constant pointer to member function}}
   void (*r)() = y.f; // expected-error {{cannot create a non-constant pointer to member function}}
 }
 
-namespace dr62 { // dr62: yes
+//--- dr62: yes
+namespace dr62 {
   struct A {
     struct { int n; } b;
   };
   template<typename T> struct X {};
   template<typename T> T get() { return get<T>(); }
   template<typename T> int take(T) { return 0; }
 
   X<A> x1;
#if __cplusplus < 201103L
   // expected-error@-7 {{uses local type}}
   // expected-error@-7 {{uses local type}}
   // expected-error@-7 {{uses local type}}
   // expected-error@-7 {{uses local type}}
 #endif
   }
 }
 
-namespace dr63 { // dr63: yes
+//--- dr63: yes
+namespace dr63 {
   template<typename T> struct S { typename T::error e; };
   extern S<int> *p;
   void *q = p;
 }
 
-namespace dr64 { // dr64: yes
+//--- dr64: yes
+namespace dr64 {
   template<class T> void f(T);
   template<class T> void f(T*);
   template<> void f(int*);
   template<> void f<int>(int*);
   template<> void f(int);
 }
 
 // dr65: na
 
-namespace dr66 { // dr66: no
+//--- dr66: no
+namespace dr66 {
   namespace X {
     int f(int n); // expected-note 2{{candidate}}
   }
   using X::f;
   namespace X {
     int f(int n = 0);
     int f(int, int);
   }
   // FIXME: The first two calls here should be accepted.
   int a = f(); // expected-error {{no matching function}}
   int b = f(1);
   int c = f(1, 2); // expected-error {{no matching function}}
 }
 
 // dr67: na
 
-namespace dr68 { // dr68: yes
+//--- dr68: yes
+namespace dr68 {
   template<typename T> struct X {};
   struct ::dr68::X<int> x1;
   struct ::dr68::template X<int> x2;
 #if __cplusplus < 201103L
   // expected-error@-2 {{'template' keyword outside of a template}}
 #endif
   struct Y {
     friend struct X<int>;
     friend struct ::dr68::X<char>;
     friend struct ::dr68::template X<double>;
 #if __cplusplus < 201103L
   // expected-error@-2 {{'template' keyword outside of a template}}
 #endif
   };
   template<typename>
   struct Z {
     friend struct ::dr68::template X<double>;
     friend typename ::dr68::X<double>;
 #if __cplusplus < 201103L
   // expected-error@-2 {{C++11 extension}}
 #endif
   };
 }
 
-namespace dr69 { // dr69: yes
+//--- dr69: yes
+namespace dr69 {
   template<typename T> static void f() {} // #dr69-f
   // FIXME: Should we warn here?
   inline void g() { f<int>(); }
   extern template void f<char>(); // expected-error {{explicit instantiation declaration of 'f' with internal linkage}}
 #if __cplusplus < 201103L
   // expected-error@-2 {{C++11 extension}}
 #endif
   template<void(*)()> struct Q {};
   Q<&f<int> > q;
 #if __cplusplus < 201103L
   // expected-error@-2 {{internal linkage}} expected-note@#dr69-f {{here}}
 #endif
 }
 
-namespace dr70 { // dr70: yes
+//--- dr70: yes
+namespace dr70 {
   template<int> struct A {};
   template<int I, int J> int f(int (&)[I + J], A<I>, A<J>);
   int arr[7];
   int k = f(arr, A<3>(), A<4>());
 }
 
 // dr71: na
 // dr72: dup 69
 
 #if __cplusplus >= 201103L
-namespace dr73 { // dr73: sup 1652
+//--- dr73: sup 1652
+namespace dr73 {
   int a, b;
   static_assert(&a + 1 != &b, ""); // expected-error {{not an integral constant expression}}
   // expected-note@-1 {{comparison against pointer '&a + 1' that points past the end of a complete object}}
 }
 #endif
 
-namespace dr74 { // dr74: yes
+//--- dr74: yes
+namespace dr74 {
   enum E { k = 5 };
   int (*p)[k] = new int[k][k];
 }
 
-namespace dr75 { // dr75: yes
+//--- dr75: yes
+namespace dr75 {
   struct S {
     static int n = 0; // expected-error {{non-const}}
   };
 }
 
-namespace dr76 { // dr76: yes
+//--- dr76: yes
+namespace dr76 {
   const volatile int n = 1;
   int arr[n]; // expected-error +{{variable length array}} expected-note {{read of volatile}}
 }
 
-namespace dr77 { // dr77: yes
+//--- dr77: yes
+namespace dr77 {
   struct A {
     struct B {};
     friend struct B;
   };
 }
 
-namespace dr78 { // dr78: sup ????
+//--- dr78: sup ????
+namespace dr78 {
   // Under DR78, this is valid, because 'k' has static storage duration, so is
   // zero-initialized.
   const int k; // expected-error {{default initialization of an object of const}}
 }
 
 // dr79: na
 
-namespace dr80 { // dr80: yes
+//--- dr80: yes
+namespace dr80 {
   struct A {
     int A;
   };
   struct B {
     static int B; // expected-error {{same name as its class}}
   };
   struct C {
     int C; // expected-error {{same name as its class}}
     C();
   };
   struct D {
     D();
     int D; // expected-error {{same name as its class}}
   };
 }
 
 // dr81: na
 // dr82: dup 48
 
-namespace dr83 { // dr83: yes
+//--- dr83: yes
+namespace dr83 {
   int &f(const char*);
   char &f(char *);
   int &k = f("foo");
 }
 
-namespace dr84 { // dr84: yes
+//--- dr84: yes
+namespace dr84 {
   struct B;
   struct A { operator B() const; };
   struct C {};
   struct B {
     B(B&); // expected-note 0-1{{candidate}}
     B(C); // expected-note 0-1{{no known conversion from 'B' to 'C'}}
     operator C() const;
   };
   A a;
   // Cannot use B(C) / operator C() pair to construct the B from the B temporary
   // here. In C++17, we initialize the B object directly using 'A::operator B()'.
   B b = a;
 #if __cplusplus <= 201402L
   // expected-error@-2 {{no viable}}
 #endif
 }
 
-namespace dr85 { // dr85: yes
+//--- dr85: yes
+namespace dr85 {
   struct A {
     struct B;
     struct B {}; // expected-note{{previous declaration is here}}
     struct B; // expected-error{{class member cannot be redeclared}}
 
     union U;
     union U {}; // expected-note{{previous declaration is here}}
     union U; // expected-error{{class member cannot be redeclared}}
#endif
   struct C {
     struct B {}; // expected-note{{previous declaration is here}}
     struct B; // expected-error{{class member cannot be redeclared}}
   };
 }
 
 // dr86: dup 446
 
-namespace dr87 { // dr87: no
+//--- dr87: no
+namespace dr87 {
   // FIXME: Superseded by dr1975
   template<typename T> struct X {};
   // FIXME: This is invalid.
   X<void() throw()> x;
   // This is valid under dr87 but not under dr1975.
   X<void(void() throw())> y;
 }
 
-namespace dr88 { // dr88: yes
+//--- dr88: yes
+namespace dr88 {
   template<typename T> struct S {
     static const int a = 1; // expected-note {{previous}}
     static const int b;
   };
   template<> const int S<int>::a = 4; // expected-error {{already has an initializer}}
   template<> const int S<int>::b = 4;
 }
 
 // dr89: na
 
-namespace dr90 { // dr90: yes
+//--- dr90: yes
+namespace dr90 {
   struct A {
     template<typename T> friend void dr90_f(T);
   };
   struct B : A {
     template<typename T> friend void dr90_g(T);
     struct C {};
     union D {};
   };
void test() {
     dr90_g(B());
     dr90_g(B::C());
     dr90_g(B::D());
     dr90_g(E());
     dr90_g(F()); // expected-error {{undeclared identifier}}
   }
 }
 
-namespace dr91 { // dr91: yes
+//--- dr91: yes
+namespace dr91 {
   union U { friend int f(U); };
   int k = f(U());
 }
 
-namespace dr92 { // dr92: 4 c++17
+//--- dr92: 4 c++17
+namespace dr92 {
   void f() throw(int, float); // expected-error 0-1{{ISO C++17 does not allow}} expected-note 0-1{{use 'noexcept}}
   void (*p)() throw(int) = &f; // expected-error 0-1{{ISO C++17 does not allow}} expected-note 0-1{{use 'noexcept}}
 #if __cplusplus <= 201402L
   // expected-error@-2 {{target exception specification is not superset of source}}
 #else
   // expected-warning@-4 {{target exception specification is not superset of source}}
 #endif
   void (*q)() throw(int); // expected-error 0-1{{ISO C++17 does not allow}} expected-note 0-1{{use 'noexcept}}

 #endif
 
   template<void() throw(int)> struct Y {}; // expected-error 0-1{{ISO C++17 does not allow}} expected-note 0-1{{use 'noexcept}}
   Y<&h> yp; // ok
 }
 
 // dr93: na
 
-namespace dr94 { // dr94: yes
+//--- dr94: yes
+namespace dr94 {
   struct A { static const int n = 5; };
   int arr[A::n];
 }
 
-namespace dr95 { // dr95: yes
+//--- dr95: yes
+namespace dr95 {
   struct A;
   struct B;
   namespace N {
     class C {
       friend struct A;
       friend struct B;
       static void f(); // expected-note {{here}}
     };
     struct A *p; // dr95::A, not dr95::N::A.
   }
   A *q = N::p; // ok, same type
   struct B { void f() { N::C::f(); } }; // expected-error {{private}}
 }
 
-namespace dr96 { // dr96: no
+//--- dr96: no
+namespace dr96 {
   struct A {
     void f(int);
     template<typename T> int f(T);
     template<typename T> struct S {};
   } a;
   template<template<typename> class X> struct B {};
 
   template<typename T>
   void test() {
     int k1 = a.template f<int>(0);
     // FIXME: This is ill-formed, because 'f' is not a template-id and does not
     // name a class template.
     // FIXME: What about alias templates?
     int k2 = a.template f(1);
     A::template S<int> s;
     B<A::template S> b;
   }
 }
 
-namespace dr97 { // dr97: yes
+//--- dr97: yes
+namespace dr97 {
   struct A {
     static const int a = false;
     static const int b = !a;
   };
 }
 
-namespace dr98 { // dr98: yes
+//--- dr98: yes
+namespace dr98 {
   void test(int n) {
     switch (n) {
       try { // expected-note 2{{bypasses}}
         case 0: // expected-error {{cannot jump}}
         x:
           throw n;
       } catch (...) { // expected-note 2{{bypasses}}
         case 1: // expected-error {{cannot jump}}
         y:
           throw n;
       }
       case 2:
         goto x; // expected-error {{cannot jump}}
       case 3:
         goto y; // expected-error {{cannot jump}}
     }
   }
 }
 
-namespace dr99 { // dr99: sup 214
+//--- dr99: sup 214
+namespace dr99 {
   template<typename T> void f(T&);
   template<typename T> int &f(const T&);
   const int n = 0;
   int &r = f(n);
 }

clang/test/CXX/drs/dr10xx.cpp

 // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++23 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 
 namespace std {
   __extension__ typedef __SIZE_TYPE__ size_t;
 
   template<typename T> struct initializer_list {
     const T *p; size_t n;
     initializer_list(const T *p, size_t n);
   };
 }
 
-namespace dr1004 { // dr1004: 5
+//--- dr1004: 5
+namespace dr1004 {
   template<typename> struct A {};
   template<typename> struct B1 {};
   template<template<typename> class> struct B2 {};
   template<typename X> void f(); // expected-note {{[with X = dr1004::A<int>]}}
   template<template<typename> class X> void f(); // expected-note {{[with X = dr1004::A]}}
   template<template<typename> class X> void g(); // expected-note {{[with X = dr1004::A]}}
   template<typename X> void g(); // expected-note {{[with X = dr1004::A<int>]}}
   struct C : A<int> {
     B1<A> b1a;
     B2<A> b2a;
     void h() {
       f<A>(); // expected-error {{ambiguous}}
       g<A>(); // expected-error {{ambiguous}}
     }
   };
 
   // This example (from the standard) is actually ill-formed, because
   // name lookup of "T::template A" names the constructor.
   template<class T, template<class> class U = T::template A> struct Third { }; // expected-error {{is a constructor name}}
   Third<A<int> > t; // expected-note {{in instantiation of default argument}}
 }
 
-namespace dr1042 { // dr1042: 3.5
+//--- dr1042: 3.5
+namespace dr1042 {
 #if __cplusplus >= 201402L
   // C++14 added an attribute that we can test the semantics of.
   using foo [[deprecated]] = int; // expected-note {{'foo' has been explicitly marked deprecated here}}
   foo f = 12; // expected-warning {{'foo' is deprecated}}
 #elif __cplusplus >= 201103L
   // C++11 did not have any attributes that could be applied to an alias
   // declaration, so the best we can test is that we accept an empty attribute
   // list in this mode.
   using foo [[]] = int;
 #endif
 }
 
-namespace dr1048 { // dr1048: 3.6
+//--- dr1048: 3.6
+namespace dr1048 {
   struct A {};
   const A f();
   A g();
   typedef const A CA;
 #if __cplusplus >= 201103L
   // ok: we deduce non-const A in each case.
   A &&a = [] (int n) {
     while (1) switch (n) {
       case 0: return f();
       case 1: return g();
       case 2: return A();
       case 3: return CA();
     }
   } (0);
 #endif
 }
 
-namespace dr1054 { // dr1054: no
+//--- dr1054: no
+namespace dr1054 {
   // FIXME: Test is incomplete.
   struct A {} volatile a;
   void f() {
     // FIXME: This is wrong: an lvalue-to-rvalue conversion is applied here,
     // which copy-initializes a temporary from 'a'. Therefore this is
     // ill-formed because A does not have a volatile copy constructor.
     // (We might want to track this aspect under dr1383 instead?)
     a; // expected-warning {{assign into a variable to force a volatile load}}
   }
 }
 
-namespace dr1070 { // dr1070: 3.5
+//--- dr1070: 3.5
+namespace dr1070 {
 #if __cplusplus >= 201103L
   struct A {
     A(std::initializer_list<int>);
   };
   struct B {
     int i;
     A a;
   };

clang/test/CXX/drs/dr11xx.cpp

 // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++2a %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 
-namespace dr1111 { // dr1111: yes
+//--- dr1111: yes
+namespace dr1111 {
 namespace example1 {
 template <typename> struct set;
 
 struct X {
   template <typename T> void set(const T &value);
 };
 void foo() {
   X x;

 
 void baz() {
   N::A a;
   a.operator A();
 }
 } // namespace example2
 } // namespace dr1111
 
-namespace dr1113 { // dr1113: partial
+//--- dr1113: partial
+namespace dr1113 {
   namespace named {
     extern int a; // expected-note {{previous}}
     static int a; // expected-error {{static declaration of 'a' follows non-static}}
   }
   namespace {
     extern int a;
     static int a; // ok, both declarations have internal linkage
     int b = a;

clang/test/CXX/drs/dr12xx.cpp

 // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++23 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 
 // dr1200: na
 
-namespace dr1213 { // dr1213: 7
+//--- dr1213: 7
+namespace dr1213 {
 #if __cplusplus >= 201103L
   using T = int[3];
   int &&r = T{}[1];
 
   using T = decltype((T{}));
   using U = decltype((T{}[2]));
   using U = int &&;
 
   // Same thing but in a case where we consider overloaded operator[].
   struct ConvertsToInt {
     operator int();
   };
   struct X { int array[1]; };
   using U = decltype(X().array[ConvertsToInt()]);
 
   // We apply the same rule to vector subscripting.
   typedef int V4Int __attribute__((__vector_size__(sizeof(int) * 4)));
   typedef int EV4Int __attribute__((__ext_vector_type__(4)));
   using U = decltype(V4Int()[0]);
   using U = decltype(EV4Int()[0]);
 #endif
 }
 
 #if __cplusplus >= 201103L
-namespace dr1223 { // dr1227: yes open
+//--- dr1227: yes open
+namespace dr1223 {
 struct M;
 template <typename T>
 struct V;
 struct S {
   S* operator()();
   int N;
   int M;
 #if __cplusplus > 202002L
void g() {
     static_assert(sizeof(B ()->C[1] == sizeof(int)), "");
     sizeof(auto () -> C[1]); // expected-error{{function cannot return array type 'C[1]'}}
 }
 
 }
 #endif
 
 #if __cplusplus >= 201103L
-namespace dr1227 { // dr1227: yes
+//--- dr1227: yes
+namespace dr1227 {
 template <class T> struct A { using X = typename T::X; }; // expected-error {{type 'int' cannot be used prior to '::' because it has no members}}
 template <class T> typename T::X f(typename A<T>::X);
 template <class T> void f(...) { }
 template <class T> auto g(typename A<T>::X) -> typename T::X; // expected-note {{in instantiation of template class 'dr1227::A<int>' requested here}}
 template <class T> void g(...) { }
 
 void h() {
   f<int>(0); // OK, substituting return type causes deduction to fail
   g<int>(0); // expected-note {{while substituting explicitly-specified template arguments into function template 'g'}}
 }
 }
 #endif
 
-namespace dr1250 { // dr1250: 3.9
+//--- dr1250: 3.9
+namespace dr1250 {
 struct Incomplete;
 
 struct Base {
   virtual const Incomplete *meow() = 0;
 };
 
 struct Derived : Base {
   virtual Incomplete *meow();
 };
 }
 
-namespace dr1265 { // dr1265: 5
+//--- dr1265: 5
+namespace dr1265 {
 #if __cplusplus >= 201103L
   auto a = 0, b() -> int; // expected-error {{declaration with trailing return type must be the only declaration in its group}}
   auto b() -> int, d = 0; // expected-error {{declaration with trailing return type must be the only declaration in its group}}
   auto e() -> int, f() -> int; // expected-error {{declaration with trailing return type must be the only declaration in its group}}
 #endif
 
 #if __cplusplus >= 201402L
   auto g(), h = 0; // expected-error {{function with deduced return type must be the only declaration in its group}}
   auto i = 0, j(); // expected-error {{function with deduced return type must be the only declaration in its group}}
   auto k(), l(); // expected-error {{function with deduced return type must be the only declaration in its group}}
 #endif
 }
 
 // dr1291: na
 
-namespace dr1295 { // dr1295: 4
+//--- dr1295: 4
+namespace dr1295 {
   struct X {
     unsigned bitfield : 4;
   };
 
   X x = {1};
 
   unsigned const &r1 = static_cast<X &&>(x).bitfield; // expected-error 0-1{{C++11}}
   unsigned const &r2 = static_cast<unsigned &&>(x.bitfield); // expected-error 0-1{{C++11}}

clang/test/CXX/drs/dr13xx.cpp

 // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 
 __extension__ typedef __SIZE_TYPE__ size_t;
 
 namespace std {
   template<typename T> struct initializer_list {
     const T *ptr;
     size_t n;
     initializer_list(const T*, size_t);
   };
 }
 
 #if __cplusplus >= 201103L
-namespace dr1305 { // dr1305: yes
+//--- dr1305: yes
+namespace dr1305 {
 struct Incomplete; // expected-note {{forward declaration of 'dr1305::Incomplete'}}
 struct Complete {};
 
 int incomplete = alignof(Incomplete(&)[]); // expected-error {{invalid application of 'alignof' to an incomplete type 'Incomplete'}}
 int complete = alignof(Complete(&)[]);
 }
 #endif
 
-namespace dr1307 { // dr1307: 14
+//--- dr1307: 14
+namespace dr1307 {
 #if __cplusplus >= 201103L
 void f(int const (&)[2]);
 void f(int const (&)[3]);
 
 void caller() {
   // This should not be ambiguous, the 2nd overload is better.
   f({1, 2, 3});
 }
 #endif // __cplusplus >= 201103L
 } // namespace dr1307
 
-namespace dr1310 { // dr1310: 5
+//--- dr1310: 5
+namespace dr1310 {
   struct S {} * sp = new S::S; // expected-error {{qualified reference to 'S' is a constructor name}}
   void f() {
     S::S(a); // expected-error {{qualified reference to 'S' is a constructor name}}
   }
   struct T { int n; typedef int U; typedef T V; };
   int k = T().T::T::n;
   T::V v;
 
void wt_test_good() {
     (void)w.W::template W<int>::n;
     (void)w.template W<int>::W::n;
     (void)w.template W<int>::template W<int>::n;
   }
   template void wt_test<W<int> >(); // expected-note {{instantiation of}}
   template void wt_test_good<W<int> >();
 }
 
-namespace dr1315 { // dr1315: partial
+//--- dr1315: partial
+namespace dr1315 {
   template <int I, int J> struct A {};
   template <int I> // expected-note {{non-deducible template parameter 'I'}}
     struct A<I + 5, I * 2> {}; // expected-error {{contains a template parameter that cannot be deduced}}
   template <int I> struct A<I, I> {};
 
   template <int I, int J, int K> struct B;
   template <int I, int K> struct B<I, I * 2, K> {}; // expected-note {{matches}}
   B<1, 2, 3> b1;
namespace dr1315 {
   // fails the "more specialized than the primary template" test because the
   // dependent type of T::value is not the same as 'int'.
   // A core issue will be opened to decide what is supposed to happen here.
   template <typename T, int I> struct C;
   template <typename T> struct C<T, T::value>;
   // expected-error@-1 {{type of specialized non-type template argument depends on a template parameter of the partial specialization}}
 }
 
-namespace dr1330 { // dr1330: 4 c++11
+//--- dr1330: 4 c++11
+namespace dr1330 {
   // exception-specifications are parsed in a context where the class is complete.
   struct A {
     void f() throw(T) {} // expected-error 0-1{{C++17}} expected-note 0-1{{noexcept}}
     struct T {};
 
 #if __cplusplus >= 201103L
     void g() noexcept(&a == b) {}
     static int a;
#endif
   void f(D &d) { d = d; } // ok
 
   struct E : C<int> {}; // expected-note {{in instantiation of}}
 #if __cplusplus >= 201103L
   E e; // expected-note {{needed here}}
 #endif
 }
 
-namespace dr1346 { // dr1346: 3.5
+//--- dr1346: 3.5
+namespace dr1346 {
   auto a(1); // expected-error 0-1{{extension}}
   auto b(1, 2); // expected-error {{multiple expressions}} expected-error 0-1{{extension}}
 #if __cplusplus >= 201103L
   auto c({}); // expected-error {{parenthesized initializer list}}
   auto d({1}); // expected-error {{parenthesized initializer list}}
   auto e({1, 2}); // expected-error {{parenthesized initializer list}}
 #endif
   template<typename...Ts> void f(Ts ...ts) { // expected-error 0-1{{extension}}
#if __cplusplus >= 201103L
     [c({})] {} (); // expected-error {{parenthesized initializer list}} expected-error 0-1{{extension}}
     [d({1})] {} (); // expected-error {{parenthesized initializer list}} expected-error 0-1{{extension}}
     [e({1, 2})] {} (); // expected-error {{parenthesized initializer list}} expected-error 0-1{{extension}}
 #endif
   }
 #endif
 }
 
-namespace dr1347 { // dr1347: yes
+//--- dr1347: yes
+namespace dr1347 {
   auto x = 5, *y = &x; // expected-error 0-1{{extension}}
   auto z = y, *q = y; // expected-error {{'auto' deduced as 'int *' in declaration of 'z' and deduced as 'int' in declaration of 'q'}} expected-error 0-1{{extension}}
 #if __cplusplus >= 201103L
   auto a = 5, b = {1, 2}; // expected-error {{'auto' deduced as 'int' in declaration of 'a' and deduced as 'std::initializer_list<int>' in declaration of 'b'}}
   auto (*fp)(int) -> int, i = 0; // expected-error {{declaration with trailing return type must be the only declaration in its group}}
 #endif
 }
 
-namespace dr1358 { // dr1358: yes
+//--- dr1358: yes
+namespace dr1358 {
 #if __cplusplus >= 201103L
   struct Lit { constexpr operator int() const { return 0; } };
   struct NonLit { NonLit(); operator int(); }; // expected-note 2{{no constexpr constructors}}
   struct NonConstexprConv { constexpr operator int() const; };
   struct Virt { virtual int f(int) const; };
 
   template<typename T, typename U, typename V> struct A : V {
     int member;
#if __cplusplus >= 201103L
   struct B : Virt {
     int member;
     constexpr B(NonLit u) : member(u) {} // expected-error {{not a literal type}}
     constexpr NonLit f(NonLit u) const { return NonLit(); } // expected-error {{not a literal type}}
   };
 #endif
 }
 
-namespace dr1359 { // dr1359: 3.5
+//--- dr1359: 3.5
+namespace dr1359 {
 #if __cplusplus >= 201103L
   union A { constexpr A() = default; };
   union B { constexpr B() = default; int a; }; // expected-error {{not constexpr}} expected-note 2{{candidate}}
   union C { constexpr C() = default; int a, b; }; // expected-error {{not constexpr}} expected-note 2{{candidate}}
   struct X { constexpr X() = default; union {}; }; // expected-error {{does not declare anything}}
   struct Y { constexpr Y() = default; union { int a; }; }; // expected-error {{not constexpr}} expected-note 2{{candidate}}
 
   constexpr A a = A();
   constexpr B b = B(); // expected-error {{no matching}}
   constexpr C c = C(); // expected-error {{no matching}}
   constexpr X x = X();
   constexpr Y y = Y(); // expected-error {{no matching}}
 #endif
 }
 
-namespace dr1388 { // dr1388: 4
+//--- dr1388: 4
+namespace dr1388 {
   template<typename A, typename ...T> void f(T..., A); // expected-note 1+{{candidate}} expected-error 0-1{{C++11}}
   template<typename ...T> void g(T..., int); // expected-note 1+{{candidate}} expected-error 0-1{{C++11}}
   template<typename ...T, typename A> void h(T..., A); // expected-note 1+{{candidate}} expected-error 0-1{{C++11}}
 
   void test_f() {
     f(0); // ok, trailing parameter pack deduced to empty
     f(0, 0); // expected-error {{no matching}}
     f<int>(0);
void g(pair<int, char> a, pair<long, char> b, tuple<char, char> c) {
     f_pair_2<int, long>(a, b, 0);
     f_pair_3<int, long>(a, b, c);
     f_pair_3<int, long>(a, b, tuple<char>()); // expected-error {{no match}}
     f_pair_4<int, long>(a, b, 0, 0L);
     f_pair_4<int, long>(a, b, 0, 0L, "foo"); // expected-error {{no match}}
   }
 }
 
-namespace dr1391 { // dr1391: partial
+//--- dr1391: partial
+namespace dr1391 {
   struct A {}; struct B : A {};
   template<typename T> struct C { C(int); typename T::error error; }; // expected-error 2{{'::'}}
   template<typename T> struct D {};
 
   // No deduction is performed for parameters with no deducible template-parameters, therefore types do not need to match.
   template<typename T> void a(T, int T::*);
   void test_a(int A::*p) { a(A(), p); } // ok, type of second parameter does not need to match
 
namespace partial_ordering {
     // According to DR1391, this is ambiguous!
     template<typename T> int c(int);
     template<typename T> int c(T);
     int test_c1 = c(0); // ok
     int test_c2 = c<int>(0); // FIXME: apparently ambiguous
   }
 }
 
-namespace dr1394 { // dr1394: 15
+//--- dr1394: 15
+namespace dr1394 {
 #if __cplusplus >= 201103L
 struct Incomplete;
 Incomplete f(Incomplete) = delete; // well-formed
 #endif
 }
 
-namespace dr1395 { // dr1395: 16
+//--- dr1395: 16
+namespace dr1395 {
 #if __cplusplus >= 201103L
   template <typename T, typename... U> void f(T, U...);
   template <typename T> void f(T);
   void h(int i) {
     // This is made ambiguous by dr692, but made valid again by dr1395.
     f(&i);
   }
 #endif
 }
 
-namespace dr1399 { // dr1399: dup 1388
+//--- dr1399: dup 1388
+namespace dr1399 {
   template<typename ...T> void f(T..., int, T...) {} // expected-note {{candidate}} expected-error 0-1{{C++11}}
   void g() {
     f(0);
     f<int>(0, 0, 0);
     f(0, 0, 0); // expected-error {{no match}}
   }
 }

clang/test/CXX/drs/dr14xx.cpp

 // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++2a %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 
-namespace dr1413 { // dr1413: 12
+//--- dr1413: 12
+namespace dr1413 {
   template<int> struct Check {
     typedef int type;
   };
   template<typename T> struct A : T {
     static const int a = 1;
     static const int b;
     static void c();
     void d();
 
     void f() {
       Check<true ? 0 : A::unknown_spec>::type *var1; // expected-error {{undeclared identifier 'var1'}}
       Check<true ? 0 : a>::type *var2; // ok, variable declaration  expected-note 0+{{here}}
       Check<true ? 0 : b>::type *var3; // expected-error {{undeclared identifier 'var3'}}
       Check<true ? 0 : ((void)c, 0)>::type *var4; // expected-error {{undeclared identifier 'var4'}}
       // value-dependent because of the implied type-dependent 'this->', not because of 'd'
       Check<true ? 0 : (d(), 0)>::type *var5; // expected-error {{undeclared identifier 'var5'}}
       // value-dependent because of the value-dependent '&' operator, not because of 'A::d'
       Check<true ? 0 : (&A::d(), 0)>::type *var5; // expected-error {{undeclared identifier 'var5'}}
     }
   };
 }
 
-namespace dr1423 { // dr1423: 11
+//--- dr1423: 11
+namespace dr1423 {
 #if __cplusplus >= 201103L
   bool b1 = nullptr; // expected-error {{cannot initialize}}
   bool b2(nullptr); // expected-warning {{implicit conversion of nullptr constant to 'bool'}}
   bool b3 = {nullptr}; // expected-error {{cannot initialize}}
   bool b4{nullptr}; // expected-warning {{implicit conversion of nullptr constant to 'bool'}}
 #endif
 }
 
 // dr1425: na abi
 
-namespace dr1432 { // dr1432: 16
+//--- dr1432: 16
+namespace dr1432 {
 #if __cplusplus >= 201103L
   template<typename T> T declval();
 
   template <class... T>
   struct common_type;
 
   template <class T, class U>
   struct common_type<T, U> {
    typedef decltype(true ? declval<T>() : declval<U>()) type;
   };
 
   template <class T, class U, class... V>
   struct common_type<T, U, V...> {
    typedef typename common_type<typename common_type<T, U>::type, V...>::type type;
   };
 
   template struct common_type<int, double>;
 #endif
 }
 
-namespace dr1443 { // dr1443: yes
+//--- dr1443: yes
+namespace dr1443 {
 struct A {
   int i;
   A() { void foo(int=i); } // expected-error {{default argument references 'this'}}
 };
 }
 
-namespace dr1460 { // dr1460: 3.5
+//--- dr1460: 3.5
+namespace dr1460 {
 #if __cplusplus >= 201103L
   namespace DRExample {
     union A {
       union {}; // expected-error {{does not declare anything}}
       union {}; // expected-error {{does not declare anything}}
       constexpr A() {}
     };
     constexpr A a = A();

 #endif
     f({uR"(abc)"});   // expected-error {{call to deleted function 'f'}}
     f({(UR"(abc)")}); // expected-error {{call to deleted function 'f'}}
   }
   } // namespace StringLiterals
 #endif
 } // dr1467
 
-namespace dr1479 { // dr1479: yes
+//--- dr1479: yes
+namespace dr1479 {
   int operator"" _a(const char*, std::size_t = 0); // expected-error {{literal operator cannot have a default argument}}
 }
 
-namespace dr1482 { // dr1482: yes
-                   // NB: sup 2516, test reused there
+//--- dr1482: yes
+namespace dr1482 {
 #if __cplusplus >= 201103L
 template <typename T> struct S {
   typedef char I;
 };
 enum E2 : S<E2>::I { e };
 // expected-error@-1 {{use of undeclared identifier 'E2'}}
 #endif
 } // namespace dr1482
 
 namespace dr1490 {  // dr1490: 3.7 c++11
   // List-initialization from a string literal
 
   char s[4]{"abc"};                   // Ok
   std::initializer_list<char>{"abc"}; // expected-error {{expected unqualified-id}}}
 } // dr1490
 
-namespace dr1495 { // dr1495: 4
+//--- dr1495: 4
+namespace dr1495 {
   // Deduction succeeds in both directions.
   template<typename T, typename U> struct A {}; // expected-note {{template is declared here}}
   template<typename T, typename U> struct A<U, T> {}; // expected-error {{class template partial specialization is not more specialized}}
 
   // Primary template is more specialized.
   template<typename, typename...> struct B {}; // expected-note {{template is declared here}}
   template<typename ...Ts> struct B<Ts...> {}; // expected-error {{not more specialized}}
 
#if __cplusplus >= 201402L
   template<typename ...Ts> int b<Ts...>; // expected-error {{not more specialized}}
 
   // Deduction fails in both directions.
   template<int, typename, typename ...> int c; // expected-note {{template is declared here}}
   template<typename ...Ts> int c<0, Ts...>; // expected-error {{not more specialized}}
 #endif
 }
 
-namespace dr1496 { // dr1496: no
+//--- dr1496: no
+namespace dr1496 {
 #if __cplusplus >= 201103L
 struct A {
     A() = delete;
 };
 // FIXME: 'A' should not be trivial because the class lacks at least one
 // default constructor which is not deleted.
 static_assert(__is_trivial(A), "");
 #endif
 }
 
 #endif

clang/test/CXX/drs/dr15xx.cpp

 // RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify=expected -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify=expected -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify=expected,cxx14_17 -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-unknown %s -verify=expected,cxx17 -fexceptions -fcxx-exceptions -pedantic-errors
 
-namespace dr1512 { // dr1512: 4
+//--- dr1512: 4
+namespace dr1512 {
   void f(char *p) {
     if (p > 0) {} // expected-error {{ordered comparison between pointer and zero}}
 #if __cplusplus >= 201103L
     if (p > nullptr) {} // expected-error {{invalid operands}}
 #endif
   }
   bool g(int **x, const int **y) {
     return x < y;
void test_overload() {
     void(Wrap<nullptr_t>() < Wrap<int*>()); // expected-error {{invalid operands to binary expression ('Wrap<nullptr_t>' (aka 'Wrap<std::nullptr_t>') and 'Wrap<int *>')}}
     void(Wrap<nullptr_t>() > Wrap<int*>()); // expected-error {{invalid operands}}
     void(Wrap<nullptr_t>() <= Wrap<int*>()); // expected-error {{invalid operands}}
     void(Wrap<nullptr_t>() >= Wrap<int*>()); // expected-error {{invalid operands}}
   }
 #endif
 }
 
-namespace dr1514 { // dr1514: 11
+//--- dr1514: 11
+namespace dr1514 {
 #if __cplusplus >= 201103L
   struct S {
     enum E : int {}; // expected-note {{previous}}
     enum E : int {}; // expected-error {{redefinition}}
   };
   S::E se; // OK, complete type, not zero-width bitfield.
 
   // The behavior in other contexts is superseded by DR1966.
 #endif
 }
 
-namespace dr1518 { // dr1518: 4
+//--- dr1518: 4
+namespace dr1518 {
 #if __cplusplus >= 201103L
 struct Z0 { // expected-note 0+ {{candidate}}
   explicit Z0() = default; // expected-note 0+ {{here}}
 };
 struct Z { // expected-note 0+ {{candidate}}
   explicit Z(); // expected-note 0+ {{here}}
   explicit Z(int); // expected-note {{not a candidate}}
   explicit Z(int, int); // expected-note 0+ {{here}}
void test() {
     g<B>(); // expected-note {{instantiation of}}
     g<C>(); // expected-note {{instantiation of}}
     g<D>(); // expected-note {{instantiation of}}
   }
 }
 #endif                      // __cplusplus >= 201103L
 }
 
-namespace dr1550 { // dr1550: yes
+//--- dr1550: yes
+namespace dr1550 {
   int f(bool b, int n) {
     return (b ? (throw 0) : n) + (b ? n : (throw 0));
   }
 }
 
-namespace dr1558 { // dr1558: 12
+//--- dr1558: 12
+namespace dr1558 {
 #if __cplusplus >= 201103L
   template<class T, class...> using first_of = T;
   template<class T> first_of<void, typename T::type> f(int); // expected-note {{'int' cannot be used prior to '::'}}
   template<class T> void f(...) = delete; // expected-note {{deleted}}
 
   struct X { typedef void type; };
   void test() {
     f<X>(0);
     f<int>(0); // expected-error {{deleted}}
   }
 #endif
 }
 
-namespace dr1560 { // dr1560: 3.5
+//--- dr1560: 3.5
+namespace dr1560 {
   void f(bool b, int n) {
     (b ? throw 0 : n) = (b ? n : throw 0) = 0;
   }
   class X { X(const X&); };
   const X &get();
   const X &x = true ? get() : throw 0;
 }
 
-namespace dr1563 { // dr1563: yes
+//--- dr1563: yes
+namespace dr1563 {
 #if __cplusplus >= 201103L
   double bar(double) { return 0.0; }
   float bar(float) { return 0.0f; }
 
   using fun = double(double);
   fun &foo{bar}; // ok
 #endif
 }
 
-namespace dr1573 { // dr1573: 3.9
+//--- dr1573: 3.9
+namespace dr1573 {
 #if __cplusplus >= 201103L
   // ellipsis is inherited (p0136r1 supersedes this part).
   struct A { A(); A(int, char, ...); };
   struct B : A { using A::A; };
   B b(1, 'x', 4.0, "hello"); // ok
 
   // inherited constructor is effectively constexpr if the user-written constructor would be
   struct C { C(); constexpr C(int) {} };
namespace std {
   template<typename T> struct basic_string {
     basic_string(const T* x) {}
     ~basic_string() {};
   };
   typedef basic_string<char> string;
 
 } // std
 
-namespace dr1579 { // dr1579: 3.9
+//--- dr1579: 3.9
+namespace dr1579 {
 template<class T>
 struct GenericMoveOnly {
   GenericMoveOnly();
   template<class U> GenericMoveOnly(const GenericMoveOnly<U> &) = delete; // expected-note 5 {{marked deleted here}}
   GenericMoveOnly(const int &) = delete; // expected-note 2 {{marked deleted here}}
   template<class U> GenericMoveOnly(GenericMoveOnly<U> &&);
   GenericMoveOnly(int &&);
 };

clang/test/CXX/drs/dr16xx.cpp

template<typename E> class initializer_list {
     size_t size;
 
   public:
     initializer_list();
   };
 } // std
 #endif
 
-namespace dr1601 { // dr1601: 10
+//--- dr1601: 10
+namespace dr1601 {
 enum E : char { e };
 #if __cplusplus < 201103L
     // expected-error@-2 {{enumeration types with a fixed underlying type are a C++11 extension}}
 #endif
 void f(char);
 void f(int);
 void g() {
   f(e);
 }
 } // namespace dr1601
 
-namespace dr1611 { // dr1611: dup 1658
+//--- dr1611: dup 1658
+namespace dr1611 {
   struct A { A(int); };
   struct B : virtual A { virtual void f() = 0; };
   struct C : B { C() : A(0) {} void f(); };
   C c;
 }
 
 namespace dr1631 {  // dr1631: 3.7
 #if __cplusplus >= 201103L
namespace with_error {
     
     void test() {
       f({0}, {{1}});        // expected-error{{call to 'f' is ambiguous}}
     }
   }
 #endif
 }
 
-namespace dr1638 { // dr1638: yes
+//--- dr1638: yes
+namespace dr1638 {
 #if __cplusplus >= 201103L
   template<typename T> struct A {
     enum class E; // expected-note {{previous}}
     enum class F : T; // expected-note 2{{previous}}
   };
 
   template<> enum class A<int>::E;
   template<> enum class A<int>::E {};
#if __cplusplus >= 201103L
   enum class A<unsigned>::E *e; // expected-error {{must use 'enum' not 'enum class'}}
 
   struct B {
     friend enum class A<unsigned>::E; // expected-error {{must use 'enum' not 'enum class'}}
   };
 #endif
 }
 
-namespace dr1645 { // dr1645: 3.9
+//--- dr1645: 3.9
+namespace dr1645 {
 #if __cplusplus >= 201103L
   struct A {
     constexpr A(int, float = 0); // expected-note {{candidate}}
     explicit A(int, int = 0); // expected-note 2{{candidate}}
     A(int, int, int = 0) = delete; // expected-note {{candidate}}
   };
 
   struct B : A {
     using A::A; // expected-note 4{{inherited here}}
   };
 
   constexpr B a(0); // expected-error {{ambiguous}}
   constexpr B b(0, 0); // expected-error {{ambiguous}}
 #endif
 }
 
-namespace dr1652 { // dr1652: 3.6
+//--- dr1652: 3.6
+namespace dr1652 {
   int a, b;
   int arr[&a + 1 == &b ? 1 : 2]; // expected-error 2{{variable length array}}
                                  // expected-note@-1 {{points past the end}}
 }
 
-namespace dr1653 { // dr1653: 4 c++17
+//--- dr1653: 4 c++17
+namespace dr1653 {
   void f(bool b) {
     ++b;
     b++;
 #if __cplusplus <= 201402L
     // expected-warning@-3 {{deprecated}} expected-warning@-2 {{deprecated}}
 #else
     // expected-error@-5 {{incrementing expression of type bool}} expected-error@-4 {{incrementing expression of type bool}}
 #endif
     --b; // expected-error {{cannot decrement expression of type bool}}
     b--; // expected-error {{cannot decrement expression of type bool}}
     b += 1; // ok
     b -= 1; // ok
   }
 }
 
-namespace dr1658 { // dr1658: 5
+//--- dr1658: 5
+namespace dr1658 {
   namespace DefCtor {
     class A { A(); }; // expected-note 0-2{{here}}
     class B { ~B(); }; // expected-note 0-2{{here}}
 
     // The stars align! An abstract class does not construct its virtual bases.
     struct C : virtual A { C(); virtual void foo() = 0; };
     C::C() = default; // ok, not deleted, expected-error 0-1{{extension}}
     struct D : virtual B { D(); virtual void foo() = 0; };
#else
     F::F(const F&) = default; // expected-error {{would delete}} expected-note@-5{{inaccessible copy constructor}}
     F::F(F&&) = default; // expected-error {{would delete}} expected-note@-6{{inaccessible move constructor}}
 #endif
   }
 
   // assignment case is superseded by dr2180
 }
 
-namespace dr1672 { // dr1672: 7
+//--- dr1672: 7
+namespace dr1672 {
   struct Empty {};
   struct A : Empty {};
   struct B { Empty e; };
   struct C : A { B b; int n; };
   struct D : A { int n; B b; };
 
   static_assert(!__is_standard_layout(C), "");
   static_assert(__is_standard_layout(D), "");
 
   struct E { B b; int n; };
   struct F { int n; B b; };
   union G { B b; int n; };
   union H { int n; B b; };
 
   struct X {};
   template<typename T> struct Y : X, A { T t; };
 
   static_assert(!__is_standard_layout(Y<E>), "");
   static_assert(__is_standard_layout(Y<F>), "");
   static_assert(!__is_standard_layout(Y<G>), "");
   static_assert(!__is_standard_layout(Y<H>), "");
   static_assert(!__is_standard_layout(Y<X>), "");
 }
 
-namespace dr1684 { // dr1684: 3.6
+//--- dr1684: 3.6
+namespace dr1684 {
 #if __cplusplus >= 201103L
   struct NonLiteral { // expected-note {{because}}
     NonLiteral();
     constexpr int f() { return 0; } // expected-warning 0-1{{will not be implicitly 'const'}}
   };
   constexpr int f(NonLiteral &) { return 0; }
   constexpr int f(NonLiteral) { return 0; } // expected-error {{not a literal type}}
 #endif
 }
 
-namespace dr1687 { // dr1687: 7
+//--- dr1687: 7
+namespace dr1687 {
   template<typename T> struct To {
     operator T(); // expected-note 2{{first operand was implicitly converted to type 'int *'}}
     // expected-note@-1 {{second operand was implicitly converted to type 'double'}}
 #if __cplusplus > 201703L
     // expected-note@-3 2{{operand was implicitly converted to type 'dr1687::E}}
 #endif
   };
 
   int *a = To<int*>() + 100.0; // expected-error {{invalid operands to binary expression ('To<int *>' and 'double')}}
   int *b = To<int*>() + To<double>(); // expected-error {{invalid operands to binary expression ('To<int *>' and 'To<double>')}}
 
 #if __cplusplus > 201703L
   enum E1 {};
   enum E2 {};
   auto c = To<E1>() <=> To<E2>(); // expected-error {{invalid operands to binary expression ('To<E1>' and 'To<E2>')}}
 #endif
 }
 
-namespace dr1690 { // dr1690: 9
+//--- dr1690: 9
+namespace dr1690 {
   // See also the various tests in "CXX/basic/basic.lookup/basic.lookup.argdep".
 #if __cplusplus >= 201103L
   namespace N {
     static auto lambda = []() { struct S {} s; return s; };
     void f(decltype(lambda()));
   }
 
   void test() {
     auto s = N::lambda();
     f(s); // ok
   }
 #endif
 }
 
-namespace dr1691 { // dr1691: 9
+//--- dr1691: 9
+namespace dr1691 {
 #if __cplusplus >= 201103L
   namespace N {
     namespace M {
       enum E : int;
       void f(E);
     }
     enum M::E : int {};
     void g(M::E); // expected-note {{declared here}}
   }
   void test() {
     N::M::E e;
     f(e); // ok
     g(e); // expected-error {{use of undeclared}}
   }
 #endif
 }
 
-namespace dr1692 { // dr1692: 9
+//--- dr1692: 9
+namespace dr1692 {
   namespace N {
     struct A {
       struct B {
         struct C {};
       };
     };
     void f(A::B::C);
   }
   void test() {
     N::A::B::C c;
     f(c); // ok
   }
 }
 
-namespace dr1696 { // dr1696: 7
+//--- dr1696: 7
+namespace dr1696 {
   namespace std_examples {
 #if __cplusplus >= 201402L
     extern struct A a;
     struct A {
       const A &x = { A{a, a} };
       const A &y = { A{} }; // expected-error {{default member initializer for 'y' needed within definition of enclosing class 'A' outside of member functions}} expected-note {{here}}
     };
     A a{a, a};

clang/test/CXX/drs/dr177x.cpp

 // RUN: %clang_cc1 -std=c++98 %s -fexceptions -fcxx-exceptions -pedantic-errors -ast-dump | FileCheck %s
 // RUN: %clang_cc1 -std=c++11 %s -fexceptions -fcxx-exceptions -pedantic-errors -ast-dump | FileCheck %s --check-prefixes=CHECK,CXX11
 // RUN: %clang_cc1 -std=c++14 %s -fexceptions -fcxx-exceptions -pedantic-errors -ast-dump | FileCheck %s --check-prefixes=CHECK,CXX11,CXX14
 // RUN: %clang_cc1 -std=c++1z %s -fexceptions -fcxx-exceptions -pedantic-errors -ast-dump | FileCheck %s --check-prefixes=CHECK,CXX11,CXX14
 // RUN: %clang_cc1 -std=c++1z %s -fexceptions -fcxx-exceptions -pedantic-errors -triple i386-windows-pc -ast-dump | FileCheck %s --check-prefixes=CHECK,CXX11,CXX14
 
-namespace dr1772 { // dr1772: 14
+//--- dr1772: 14
+namespace dr1772 {
   // __func__ in a lambda should name operator(), not the containing function.
   // CHECK: NamespaceDecl{{.+}}dr1772
 #if __cplusplus >= 201103L
   auto x = []() { __func__; };
   // CXX11: LambdaExpr
   // CXX11: CXXRecordDecl
   // CXX11: CXXMethodDecl{{.+}} operator() 'void () {{.*}}const'
   // CXX11-NEXT: CompoundStmt
#if __cplusplus >= 201103L
   // CXX11: CXXMethodDecl{{.+}} operator() 'void () {{.*}}const'
   // CXX11-NEXT: CompoundStmt
   // CXX11-NEXT: PredefinedExpr{{.+}} 'const char[11]' lvalue __func__
   // CXX11-NEXT: StringLiteral{{.+}} 'const char[11]' lvalue "operator()"
   }
 #endif // __cplusplus >= 201103L
 }
 
-namespace dr1779 { // dr1779: 14
+//--- dr1779: 14
+namespace dr1779 {
   // __func__ in a function template, member function template, or generic
   //  lambda should have a dependent type.
   // CHECK: NamespaceDecl{{.+}}dr1779
 
   template<typename T>
   void FuncTemplate() {
     __func__;
     // CHECK: FunctionDecl{{.+}} FuncTemplate

clang/test/CXX/drs/dr17xx.cpp

 // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++1z %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 
-namespace dr1715 { // dr1715: 3.9
+//--- dr1715: 3.9
+namespace dr1715 {
 #if __cplusplus >= 201103L
   struct B {
     template<class T> B(T, typename T::Q);
   };
 
   class S {
     using Q = int;
     template<class T> friend B::B(T, typename T::Q);
   };
 
   struct D : B {
     using B::B;
   };
   struct E : B { // expected-note 2{{candidate}}
     template<class T> E(T t, typename T::Q q) : B(t, q) {} // expected-note {{'Q' is a private member}}
   };
 
   B b(S(), 1);
   D d(S(), 2);
   E e(S(), 3); // expected-error {{no match}}
 #endif
 }
 
-namespace dr1722 { // dr1722: 9
+//--- dr1722: 9
+namespace dr1722 {
 #if __cplusplus >= 201103L
 void f() {
   const auto lambda = [](int x) { return x + 1; };
   // Without the DR applied, this static_assert would fail.
   static_assert(
       noexcept((int (*)(int))(lambda)),
       "Lambda-to-function-pointer conversion is expected to be noexcept");
 }
 #endif
 } // namespace dr1722
 
-namespace dr1734 { // dr1734: no
+//--- dr1734: no
+namespace dr1734 {
 #if __cplusplus >= 201103L
 struct A {
     A(const A&) = delete;
 };
 // FIXME: 'A' should not be trivially copyable because the class lacks at least
 // one non-deleted copy constructor, move constructor, copy assignment
 // operator, or move assignment operator.
 static_assert(__is_trivially_copyable(A), "");
 #endif
 }
 
-namespace dr1736 { // dr1736: 3.9
+//--- dr1736: 3.9
+namespace dr1736 {
 #if __cplusplus >= 201103L
 struct S {
   template <class T> S(T t) {
     struct L : S {
       using S::S;
     };
     typename T::type value; // expected-error {{no member}}
     L l(value); // expected-note {{instantiation of}}
   }
 };
 struct Q { typedef int type; } q;
 S s(q); // expected-note {{instantiation of}}
 #endif
 }
 
-namespace dr1753 { // dr1753: 11
+//--- dr1753: 11
+namespace dr1753 {
   typedef int T;
   struct A { typedef int T; };
   namespace B { typedef int T; }
 
   void f(T n) {
     n.~T();
     n.T::~T();
 
namespace dr1753 {
   #if __cplusplus >= 201103L
     n.decltype(n)::~T(); // expected-error {{not a class, namespace, or enumeration}}
     n.T::~decltype(n)(); // expected-error {{expected a class name after '~'}}
     n.~decltype(n)(); // OK
   #endif
   }
 }
 
-namespace dr1756 { // dr1756: 3.7
+//--- dr1756: 3.7
+namespace dr1756 {
 #if __cplusplus >= 201103L
   // Direct-list-initialization of a non-class object
   
   int a{0};
   
   struct X { operator int(); } x;
   int b{x};
 #endif
 }
 
-namespace dr1758 { // dr1758: 3.7
+//--- dr1758: 3.7
+namespace dr1758 {
 #if __cplusplus >= 201103L
   // Explicit conversion in copy/move list initialization
 
   struct X { X(); };
   struct Y { explicit operator X(); } y;
   X x{y};
 
   struct A {
     A() {}
     A(const A &) {}
   };
   struct B {
     operator A() { return A(); }
   } b;
   A a{b};
 #endif
 }
 
-namespace dr1762 { // dr1762: 14
+//--- dr1762: 14
+namespace dr1762 {
 #if __cplusplus >= 201103L
   float operator ""_E(const char *);
   // expected-error@+2 {{invalid suffix on literal; C++11 requires a space between literal and identifier}}
   // expected-warning@+1 {{user-defined literal suffixes not starting with '_' are reserved; no literal will invoke this operator}}
   float operator ""E(const char *);
 #endif
 }
 
-namespace dr1778 { // dr1778: 9
+//--- dr1778: 9
+namespace dr1778 {
   // Superseded by P1286R2.
 #if __cplusplus >= 201103L
   struct A { A() noexcept(true) = default; };
   struct B { B() noexcept(false) = default; };
   static_assert(noexcept(A()), "");
   static_assert(!noexcept(B()), "");
 
   struct C { A a; C() noexcept(false) = default; };
   struct D { B b; D() noexcept(true) = default; };
   static_assert(!noexcept(C()), "");
   static_assert(noexcept(D()), "");
 #endif
 }

clang/test/CXX/drs/dr18xx.cpp

 // RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++23 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
 
 #if __cplusplus < 201103L
 // expected-error@+1 {{variadic macro}}
 #define static_assert(...) __extension__ _Static_assert(__VA_ARGS__)
 #endif
 
-namespace dr1813 { // dr1813: 7
+//--- dr1813: 7
+namespace dr1813 {
   struct B { int i; };
   struct C : B {};
   struct D : C {};
   struct E : D { char : 4; };
 
   static_assert(__is_standard_layout(B), "");
   static_assert(__is_standard_layout(C), "");
   static_assert(__is_standard_layout(D), "");
   static_assert(!__is_standard_layout(E), "");
 
   struct Q {};
   struct S : Q {};
   struct T : Q {};
   struct U : S, T {};
 
   static_assert(__is_standard_layout(Q), "");
   static_assert(__is_standard_layout(S), "");
   static_assert(__is_standard_layout(T), "");
   static_assert(!__is_standard_layout(U), "");
 }
 
-namespace dr1814 { // dr1814: yes
+//--- dr1814: yes
+namespace dr1814 {
 #if __cplusplus >= 201103L
   void test() {
     auto lam = [](int x = 42) { return x; };
   }
 #endif
 }
 
-namespace dr1815 { // dr1815: no
+//--- dr1815: no
+namespace dr1815 {
 #if __cplusplus >= 201402L
   // FIXME: needs codegen test
   struct A { int &&r = 0; }; // expected-note {{default member init}}
   A a = {}; // FIXME expected-warning {{not supported}}
 
   struct B { int &&r = 0; }; // expected-error {{binds to a temporary}} expected-note {{default member init}}
   B b; // expected-note {{here}}
 #endif
 }
 
-namespace dr1821 { // dr1821: yes
+//--- dr1821: yes
+namespace dr1821 {
 struct A {
   template <typename> struct B {
     void f();
   };
   template <typename T> void B<T>::f(){};
   // expected-error@-1 {{non-friend class member 'f' cannot have a qualified name}}
 
   struct C {
     void f();
   };
   void C::f() {}
   // expected-error@-1 {{non-friend class member 'f' cannot have a qualified name}}
 };
 } // namespace dr1821
 
-namespace dr1822 { // dr1822: yes
+//--- dr1822: yes
+namespace dr1822 {
 #if __cplusplus >= 201103L
   int a;
   auto x = [] (int a) {
 #pragma clang __debug dump a // CHECK: ParmVarDecl
   };
 #endif
 }
 
-namespace dr1837 { // dr1837: 3.3
+//--- dr1837: 3.3
+namespace dr1837 {
 #if __cplusplus >= 201103L
   template <typename T>
   struct Fish { static const bool value = true; };
 
   struct Other {
     int p();
     auto q() -> decltype(p()) *;
   };
bool b = [] {
       struct Local {
         static_assert(sizeof(this->f()) == sizeof(int), "");
       };
     };
   };
 #endif
 }
 
-namespace dr1872 { // dr1872: 9
+//--- dr1872: 9
+namespace dr1872 {
 #if __cplusplus >= 201103L
   template<typename T> struct A : T {
     constexpr int f() const { return 0; }
   };
   struct X {};
   struct Y { virtual int f() const; };
   struct Z : virtual X {};
 
#if __cplusplus <= 201703L
   // expected-error@-2 {{constant expression}} expected-note@-2 {{call to virtual function}}
 #else
   static_assert(y == 0);
 #endif
   constexpr int z = A<Z>().f(); // expected-error {{constant expression}} expected-note {{non-literal type}}
 #endif
 }
 
-namespace dr1881 { // dr1881: 7
+//--- dr1881: 7
+namespace dr1881 {
   struct A { int a : 4; };
   struct B : A { int b : 3; };
   static_assert(__is_standard_layout(A), "");
   static_assert(!__is_standard_layout(B), "");
 
   struct C { int : 0; };
   struct D : C { int : 0; };
   static_assert(__is_standard_layout(C), "");
#if __cplusplus <= 201703L
   // expected-error@-3 {{copy assignment operator is implicitly deleted}}
   // expected-error@-3 {{copy assignment operator is implicitly deleted}}
 #endif
   b = b; // expected-error {{copy assignment operator is implicitly deleted}}
   b = static_cast<B&&>(b); // expected-error {{copy assignment operator is implicitly deleted}}
 #endif
 }
 
-namespace dr1894 { // dr1894: 3.8
-                   // NB: reusing part of dr407 test
+//--- dr1894: 3.8
+namespace dr1894 { 
 namespace A {
   struct S {};
 }
 namespace B {
   typedef int S;
 }
 namespace E {
   typedef A::S S;

clang/test/CXX/drs/dr19xx.cpp

 // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++1z %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 
 namespace std { struct type_info; }
 
-namespace dr1902 { // dr1902: 3.7
+//--- dr1902: 3.7
+namespace dr1902 {
   struct A {};
   struct B {
     B(A);
 #if __cplusplus >= 201103L
         // expected-note@-2 {{candidate}}
 #endif
 
     B() = delete;
namespace X {
     using A::a;
     using A::b;
     using A::c;
     using A::d;
     struct a *p;
   }
 }
 
-namespace dr1909 { // dr1909: yes
+//--- dr1909: yes
+namespace dr1909 {
   struct A {
     template<typename T> struct A {}; // expected-error {{member 'A' has the same name as its class}}
   };
   struct B {
     template<typename T> void B() {} // expected-error {{constructor cannot have a return type}}
   };
   struct C {
     template<typename T> static int C; // expected-error {{member 'C' has the same name as its class}} expected-error 0-1{{extension}}
   };
   struct D {
     template<typename T> using D = int; // expected-error {{member 'D' has the same name as its class}} expected-error 0-1{{extension}}
   };
 }
 
-namespace dr1940 { // dr1940: yes
+//--- dr1940: yes
+namespace dr1940 {
 #if __cplusplus >= 201103L
 static union {
   static_assert(true, "");  // ok
   static_assert(false, ""); // expected-error {{static assertion failed}}
   int not_empty;
 };
 #endif
 }
 
-namespace dr1941 { // dr1941: 3.9
+//--- dr1941: 3.9
+namespace dr1941 {
 #if __cplusplus >= 201402L
 template<typename X>
 struct base {
   template<typename T>
   base(T a, T b, decltype(void(*T()), 0) = 0) {
     while (a != b) (void)*a++;
   }
 
struct iter {
   friend bool operator!=(iter, iter);
 } it, end;
 
 derived d1(it, end);
 derived d2(42, 9);
 #endif
 }
 
-namespace dr1947 { // dr1947: yes
+//--- dr1947: yes
+namespace dr1947 {
 #if __cplusplus >= 201402L
 unsigned o = 0'01;  // ok
 unsigned b = 0b'01; // expected-error {{invalid digit 'b' in octal constant}}
 unsigned x = 0x'01; // expected-error {{invalid suffix 'x'01' on integer constant}}
 #endif
 }
 
 #if __cplusplus >= 201103L
 // dr1948: yes
 // FIXME: This diagnostic could be improved.
 void *operator new(__SIZE_TYPE__) noexcept { return nullptr; } // expected-error{{exception specification in declaration does not match previous declaration}}
 #endif
 
-namespace dr1959 { // dr1959: 3.9
+//--- dr1959: 3.9
+namespace dr1959 {
 #if __cplusplus >= 201103L
   struct b;
   struct c;
   struct a {
     a() = default;
     a(const a &) = delete; // expected-note {{deleted}}
     a(const b &) = delete; // not inherited
     a(c &&) = delete; // expected-note {{not viable}}
#if __cplusplus >= 201103L
   };
   // FIXME: As a resolution to an open DR against P0136R0, we disallow
   // use of inherited constructors to construct from a single argument
   // where the base class is reference-related to the argument type.
   c q(static_cast<c&&>(q));
 #endif
 }
 
-namespace dr1960 { // dr1960: no
+//--- dr1960: no
+namespace dr1960 {
 struct A {
 void f() {}
 protected:
 void g() {}
 };
 
 struct B: A {
 private:
 using A::f;
 using A::g;
 };
 
 struct C : B {
 // FIXME: both declarations are ill-formed, because A::f and A::g
 // are not accessible.
 using A::f;
 using A::g;
 };
 }
 
-namespace dr1966 { // dr1966: 11
+//--- dr1966: 11
+namespace dr1966 {
 #if __cplusplus >= 201103L
   struct A {
     enum E : int {1}; // expected-error {{expected identifier}} (not bit-field)
   };
   auto *p1 = new enum E : int; // expected-error {{only permitted as a standalone declaration}}
   auto *p2 = new enum F : int {}; // expected-error {{cannot be defined in a type specifier}}
   auto *p3 = true ? new enum G : int {}; // expected-error {{forward reference}} expected-error {{incomplete}} expected-note {{declaration}}
   auto h() -> enum E : int {}; // expected-error {{only permitted as a standalone declaration}}
 
   enum X : enum Y : int {} {}; // expected-error {{cannot be defined in a type specifier}}
   struct Q {
     enum X : enum Y : int {} {}; // expected-error +{{}}
   };
 #endif
 }
 
-namespace dr1968 { // dr1968: no
+//--- dr1968: no
+namespace dr1968 {
 #if __cplusplus >= 201103L
   // FIXME: According to DR1968, both of these should be considered
   // non-constant.
   static_assert(&typeid(int) == &typeid(int), "");
 
   constexpr const std::type_info *f() { return &typeid(int); }
   static_assert(f() == f(), "");
 #endif
 }
 
-namespace dr1991 { // dr1991: 3.9
+//--- dr1991: 3.9
+namespace dr1991 {
 #if __cplusplus >= 201103L
   struct A {
     A(int, int) = delete;
   };
 
   struct B : A {
     using A::A;
     B(int, int, int = 0);

clang/test/CXX/drs/dr1xx.cpp

 // RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++23 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 
-namespace dr100 { // dr100: yes
+//--- dr100: yes
+namespace dr100 {
   template<const char (*)[4]> struct A {}; // expected-note 0-1{{declared here}}
   template<const char (&)[4]> struct B {}; // expected-note 0-1{{declared here}}
   template<const char *> struct C {}; // expected-note 0-1{{declared here}}
   template<const char &> struct D {}; // expected-note 0-1{{declared here}}
   A<&"foo"> a; // #100a
   B<"bar"> b; // #100b
   C<"baz"> c; // #100c
   D<*"quux"> d; // #100d
 #if __cplusplus < 201703L
   // expected-error@#100a {{does not refer to any declaration}}
   // expected-error@#100b {{does not refer to any declaration}}
   // expected-error@#100c {{does not refer to any declaration}}
   // expected-error@#100d {{does not refer to any declaration}}
 #else
   // expected-error@#100a {{pointer to string literal is not allowed in a template argument}}
   // expected-error@#100b {{reference to string literal is not allowed in a template argument}}
   // expected-error@#100c {{pointer to subobject of string literal is not allowed in a template argument}}
   // expected-error@#100d {{reference to subobject of string literal is not allowed in a template argument}}
 #endif
 }
 
-namespace dr101 { // dr101: 3.5
+//--- dr101: 3.5
+namespace dr101 {
   extern "C" void dr101_f();
   typedef unsigned size_t;
   namespace X {
     extern "C" void dr101_f();
     typedef unsigned size_t;
   }
   using X::dr101_f;
   using X::size_t;
   extern "C" void dr101_f();
   typedef unsigned size_t;
 }
 
-namespace dr102 { // dr102: yes
+//--- dr102: yes
+namespace dr102 {
   namespace A {
     template<typename T> T f(T a, T b) { return a + b; } // expected-error {{neither visible in the template definition nor found by argument-dependent lookup}}
   }
   namespace B {
     struct S {};
   }
   B::S operator+(B::S, B::S); // expected-note {{should be declared prior to the call site or in namespace 'dr102::B'}}
   template B::S A::f(B::S, B::S); // expected-note {{in instantiation of}}
 }
 
 // dr103: na
 // dr104: na lib
 // dr105: na
 
-namespace dr106 { // dr106: sup 540
+//--- dr106: sup 540
+namespace dr106 {
   typedef int &r1;
   typedef r1 &r1;
   typedef const r1 r1; // expected-warning {{has no effect}}
   typedef const r1 &r1; // expected-warning {{has no effect}}
 
   typedef const int &r2;
   typedef r2 &r2;
   typedef const r2 r2; // expected-warning {{has no effect}}
   typedef const r2 &r2; // expected-warning {{has no effect}}
 }
 
-namespace dr107 { // dr107: yes
+//--- dr107: yes
+namespace dr107 {
   struct S {};
   extern "C" S operator+(S, S) { return S(); }
 }
 
-namespace dr108 { // dr108: yes
+//--- dr108: yes
+namespace dr108 {
   template<typename T> struct A {
     struct B { typedef int X; };
     B::X x;
 #if __cplusplus <= 201703L
     // expected-error@-2 {{implicit 'typename' is a C++20 extension}}
 #endif
     struct C : B { X x; }; // expected-error {{unknown type name}}
   };
   template<> struct A<int>::B { int X; };
 }
 
-namespace dr109 { // dr109: yes
+//--- dr109: yes
+namespace dr109 {
   struct A { template<typename T> void f(T); };
   template<typename T> struct B : T {
     using T::template f; // expected-error {{'template' keyword not permitted here}}
     using T::template f<int>; // expected-error {{'template' keyword not permitted here}} expected-error {{using declaration cannot refer to a template specialization}}
     // FIXME: We shouldn't suggest using the 'template' keyword in a location where it's not valid.
     using T::f<int>; // expected-error {{use 'template' keyword}} expected-error {{using declaration cannot refer to a template specialization}}
     void g() { this->f<int>(123); } // expected-error {{use 'template' keyword}}
   };
 }
 
-namespace dr111 { // dr111: dup 535
+//--- dr111: dup 535
+namespace dr111 {
   struct A { A(); A(volatile A&, int = 0); A(A&, const char * = "foo"); };
   struct B : A { B(); }; // expected-note +{{would lose const qualifier}} expected-note {{requires 0 arguments}}
   const B b1;
   B b2(b1); // expected-error {{no matching constructor}}
 }
 
-namespace dr112 { // dr112: yes
+//--- dr112: yes
+namespace dr112 {
   struct T { int n; };
   typedef T Arr[1];
 
   const T a1[1] = {};
   volatile T a2[1] = {};
   const Arr a3 = {};
   volatile Arr a4 = {};
   template<const volatile T*> struct X {};
   X<a1> x1;
   X<a2> x2;
   X<a3> x3;
   X<a4> x4;
 #if __cplusplus < 201103L
   // expected-error@-5 {{internal linkage}} expected-note@-10 {{here}}
   // expected-error@-4 {{internal linkage}} expected-note@-9 {{here}}
 #else
   // FIXME: Test this somehow.
 #endif
 }
 
-namespace dr113 { // dr113: yes
+//--- dr113: yes
+namespace dr113 {
   extern void (*p)();
   void f() {
     no_such_function(); // expected-error {{undeclared}}
     p();
   }
   void g();
   void (*p)() = &g;
 }
 
-namespace dr114 { // dr114: yes
+//--- dr114: yes
+namespace dr114 {
   struct A {
     virtual void f(int) = 0; // expected-note {{unimplemented}}
   };
   struct B : A {
     template<typename T> void f(T);
     void g() { f(0); }
   } b; // expected-error {{abstract}}
 }
 
-namespace dr115 { // dr115: yes
+//--- dr115: yes
+namespace dr115 {
   template<typename T> int f(T); // expected-note +{{}}
   template<typename T> int g(T); // expected-note +{{}}
   template<typename T> int g(T, int); // expected-note +{{}}
 
   int k1 = f(&f); // expected-error {{no match}}
   int k2 = f(&f<int>);
   int k3 = f(&g<int>); // expected-error {{no match}}
 
void k() {
     (void)&with_default; // expected-error {{overloaded function}}
     (void)&with_default<>;
     &with_default; // expected-error {{overloaded function}}
     &with_default<>; // expected-warning {{unused}}
   }
 #endif
 }
 
-namespace dr116 { // dr116: yes
+//--- dr116: yes
+namespace dr116 {
   template<int> struct A {};
   template<int N> void f(A<N>) {} // expected-note {{previous}}
   template<int M> void f(A<M>) {} // expected-error {{redefinition}}
   template<typename T> void f(A<sizeof(T)>) {} // expected-note {{previous}}
   template<typename U> void f(A<sizeof(U)>) {} // expected-error {{redefinition}}
 }
 
 // dr117: na
 // dr118 is in its own file.
 // dr119: na
 // dr120: na
 
-namespace dr121 { // dr121: yes
+//--- dr121: yes
+namespace dr121 {
   struct X {
     template<typename T> struct Y {};
   };
   template<typename T> struct Z {
     X::Y<T> x;
     T::Y<T> y; // expected-error +{{}}
   };
   Z<X> z;
 }
 
-namespace dr122 { // dr122: yes
+//--- dr122: yes
+namespace dr122 {
   template<typename T> void f();
   void g() { f<int>(); }
 }
 
 // dr123: na
 // dr124: dup 201
 
 // dr125: yes
 struct dr125_A { struct dr125_B {}; }; // expected-note {{here}}
 dr125_A::dr125_B dr125_C();
 namespace dr125_B { dr125_A dr125_C(); }
 namespace dr125 {
   struct X {
     friend dr125_A::dr125_B (::dr125_C)(); // ok
     friend dr125_A (::dr125_B::dr125_C)(); // ok
     friend dr125_A::dr125_B::dr125_C(); // expected-error {{did you mean the constructor name 'dr125_B'?}}
     // expected-error@-1 {{missing exception specification}}
   };
 }
 
-namespace dr126 { // dr126: partial
+//--- dr126: partial
+namespace dr126 {
   // FIXME: We do not yet generate correct code for this change:
   // eg:
   //   catch (void*&) should catch void* but not int*
   //   catch (void*) and catch (void*const&) should catch both
   // Likewise:
   //   catch (Base *&) should catch Base* but not Derived*
   //   catch (Base *) should catch both
   // In each case, we emit the same code for both catches.
#endif
     virtual void y() throw(int*); // ok
     virtual void z() throw(long); // expected-error {{more lax}}
   };
 #else
   void f() throw(int); // expected-error {{ISO C++17 does not allow}} expected-note {{use 'noexcept}}
 #endif
 }
 
-namespace dr127 { // dr127: yes
+//--- dr127: yes
+namespace dr127 {
   __extension__ typedef __decltype(sizeof(0)) size_t;
   template<typename T> struct A {
     A() { throw 0; }
     void *operator new(size_t, const char * = 0);
     void operator delete(void *, const char *) { T::error; } // expected-error 2{{no members}}
     void operator delete(void *) { T::error; }
   };
   A<void> *p = new A<void>; // expected-note {{instantiat}}
   A<int> *q = new ("") A<int>; // expected-note {{instantiat}}
 }
 
-namespace dr128 { // dr128: yes
+//--- dr128: yes
+namespace dr128 {
   enum E1 { e1 } x = e1;
   enum E2 { e2 } y = static_cast<E2>(x), z = static_cast<E2>(e1);
 }
 
 // dr129: dup 616
 // dr130: na
 
-namespace dr131 { // dr131: sup P1949
+//--- dr131: sup P1949
+namespace dr131 {
   const char *a_with_\u0e8c = "\u0e8c";
   const char *b_with_\u0e8d = "\u0e8d";
   const char *c_with_\u0e8e = "\u0e8e";
 }
 
-namespace dr132 { // dr132: no
+//--- dr132: no
+namespace dr132 {
   void f() {
     extern struct {} x; // ok
     extern struct S {} y; // FIXME: This is invalid.
   }
   static enum { E } e;
 }
 
 // dr133: dup 87
 // dr134: na
 
-namespace dr135 { // dr135: yes
+//--- dr135: yes
+namespace dr135 {
   struct A {
     A f(A a) { return a; }
     friend A g(A a) { return a; }
     static A h(A a) { return a; }
   };
 }
 
-namespace dr136 { // dr136: 3.4
+//--- dr136: 3.4
+namespace dr136 {
   void f(int, int, int = 0); // expected-note {{previous declaration is here}}
   void g(int, int, int); // expected-note {{previous declaration is here}}
   struct A {
     friend void f(int, int = 0, int); // expected-error {{friend declaration specifying a default argument must be the only declaration}}
     friend void g(int, int, int = 0); // expected-error {{friend declaration specifying a default argument must be the only declaration}}
     friend void h(int, int, int = 0); // expected-error {{friend declaration specifying a default argument must be a definition}}
     friend void i(int, int, int = 0) {} // expected-note {{previous declaration is here}}
     friend void j(int, int, int = 0) {}
namespace dr136 {
   struct B {
     void f(int); // expected-note {{previous declaration is here}}
   };
   struct C {
     friend void B::f(int = 0); // expected-error {{friend declaration specifying a default argument must be the only declaration}}
   };
 }
 
-namespace dr137 { // dr137: yes
+//--- dr137: yes
+namespace dr137 {
   extern void *p;
   extern const void *cp;
   extern volatile void *vp;
   extern const volatile void *cvp;
   int *q = static_cast<int*>(p);
   int *qc = static_cast<int*>(cp); // expected-error {{casts away qualifiers}}
   int *qv = static_cast<int*>(vp); // expected-error {{casts away qualifiers}}
   int *qcv = static_cast<int*>(cvp); // expected-error {{casts away qualifiers}}
   const int *cq = static_cast<const int*>(p);
   const int *cqc = static_cast<const int*>(cp);
   const int *cqv = static_cast<const int*>(vp); // expected-error {{casts away qualifiers}}
   const int *cqcv = static_cast<const int*>(cvp); // expected-error {{casts away qualifiers}}
   const volatile int *cvq = static_cast<const volatile int*>(p);
   const volatile int *cvqc = static_cast<const volatile int*>(cp);
   const volatile int *cvqv = static_cast<const volatile int*>(vp);
   const volatile int *cvqcv = static_cast<const volatile int*>(cvp);
 }
 
-namespace dr139 { // dr139: yes
+//--- dr139: yes
+namespace dr139 {
   namespace example1 {
     typedef int f; // expected-note {{previous}}
     struct A {
       friend void f(A &); // expected-error {{different kind of symbol}}
     };
   }
 
   namespace example2 {
     typedef int f;
     namespace N {
       struct A {
         friend void f(A &);
         operator int();
         void g(A a) { int i = f(a); } // ok, f is typedef not friend function
       };
     }
   }
 }
 
-namespace dr140 { // dr140: yes
+//--- dr140: yes
+namespace dr140 {
   void f(int *const) {} // expected-note {{previous}}
   void f(int[3]) {} // expected-error {{redefinition}}
   void g(const int);
   void g(int n) { n = 2; }
 }
 
-namespace dr141 { // dr141: yes
+//--- dr141: yes
+namespace dr141 {
   template<typename T> void f();
   template<typename T> struct S { int n; }; // expected-note {{'::dr141::S<int>::n' declared here}}
   struct A : S<int> {
     template<typename T> void f();
     template<typename T> struct S {};
   } a;
   struct B : S<int> {} b;
   void g() {
#endif
   };
   void h() { C<B>().h(); } // ok
   struct X {
     template<typename T> void S();
   };
   void i() { C<X>().i(); } // ok!!
 }
 
-namespace dr142 { // dr142: yes
+//--- dr142: yes
+namespace dr142 {
   class B { // expected-note +{{here}}
   public:
     int mi; // expected-note +{{here}}
     static int si; // expected-note +{{here}}
   };
   class D : private B { // expected-note +{{here}}
   };
   class DD : public D {
void DD::f() {
     B *bp1_old = this; // expected-error {{private member}} expected-error {{private base class}}
     dr142::B *bp1 = this; // expected-error {{private base class}}
     B *bp2_old = (B*)this; // expected-error 2{{private member}}
     dr142::B *bp2 = (dr142::B*)this;
     bp2->mi = 3;
   }
 }
 
-namespace dr143 { // dr143: yes
+//--- dr143: yes
+namespace dr143 {
   namespace A { struct X; }
   namespace B { void f(A::X); }
   namespace A {
     struct X { friend void B::f(X); };
   }
   void g(A::X x) {
     f(x); // expected-error {{undeclared identifier 'f'}}
   }
 }
 
-namespace dr145 { // dr145: yes
+//--- dr145: yes
+namespace dr145 {
   void f(bool b) {
 #if __cplusplus <= 201402L
     ++b; // expected-warning {{deprecated}}
     b++; // expected-warning {{deprecated}}
 #else
     ++b; // expected-error {{increment}}
     b++; // expected-error {{increment}}
 #endif
   }
 }
 
-namespace dr147 { // dr147: yes
+//--- dr147: yes
+namespace dr147 {
   namespace example1 {
     template<typename> struct A {
       template<typename T> A(T);
     };
     // Per core issue 1435, this is ill-formed because A<int>::A<int> does not
     // name the injected-class-name. (A<int>::A does, though.)
     template<> template<> A<int>::A<int>(int) {} // expected-error {{out-of-line constructor for 'A' cannot have template arguments}}
     template<> template<> A<float>::A(float) {}
   }
   namespace example2 {
     struct A { A(); };
     struct B : A { B(); };
     A::A a1; // expected-error {{is a constructor}}
     B::A a2;
   }
   namespace example3 {
     template<typename> struct A {
       template<typename T> A(T);
       static A a;
     };
     template<> A<int>::A<int>(A<int>::a); // expected-error {{is a constructor}}
   }
 }
 
-namespace dr148 { // dr148: yes
+//--- dr148: yes
+namespace dr148 {
   struct A { int A::*p; };
   int check1[__is_pod(int(A::*)) ? 1 : -1];
   int check2[__is_pod(A) ? 1 : -1];
 }
 
 // dr149: na
 
-namespace dr151 { // dr151: yes
+//--- dr151: yes
+namespace dr151 {
   struct X {};
   typedef int X::*p;
 #if __cplusplus < 201103L
 #define fold(x) (__builtin_constant_p(0) ? (x) : (x))
 #else
 #define fold
 #endif
   int check[fold(p() == 0) ? 1 : -1];
 #undef fold
 }
 
-namespace dr152 { // dr152: yes
+//--- dr152: yes
+namespace dr152 {
   struct A {
     A(); // expected-note 0-2{{not viable}}
     explicit A(const A&); // expected-note 1-2{{not a candidate}}
   };
   A a1 = A();
 #if __cplusplus <= 201402L
   // expected-error@-2 {{no matching constructor}}
 #endif
   A a2((A()));
 
   A &f();
   A a3 = f(); // expected-error {{no matching constructor}}
   A a4(f());
 }
 
 // dr153: na
 
-namespace dr154 { // dr154: yes
+//--- dr154: yes
+namespace dr154 {
   union { int a; }; // expected-error {{must be declared 'static'}}
   namespace {
     union { int b; };
   }
   static union { int c; };
 }
 
-namespace dr155 { // dr155: dup 632
+//--- dr155: dup 632
+namespace dr155 {
   struct S { int n; } s = { { 1 } }; // expected-warning {{braces around scalar initializer}}
 }
 
 // dr158 is in its own file.
 
-namespace dr159 { // dr159: 3.5
+//--- dr159: 3.5
+namespace dr159 {
   namespace X { void f(); }
   void f();
   void dr159::f() {} // expected-warning {{extra qualification}}
   void dr159::X::f() {}
 }
 
 // dr160: na
 
-namespace dr161 { // dr161: yes
+//--- dr161: yes
+namespace dr161 {
   class A {
   protected:
     struct B { int n; } b; // expected-note 2{{here}}
     static B bs;
     void f(); // expected-note {{here}}
     static void sf();
   };
   struct C : A {};
void g(C c) {
       D::f();
       A::sf();
       C::sf();
       D::sf();
     }
   };
 }
 
-namespace dr162 { // dr162: no
+//--- dr162: no
+namespace dr162 {
   struct A {
     char &f(char);
     static int &f(int);
 
     void g() {
       int &a = (&A::f)(0); // FIXME: expected-error {{could not be resolved}}
       char &b = (&A::f)('0'); // expected-error {{could not be resolved}}
     }
   };
 
   int &c = (&A::f)(0); // FIXME: expected-error {{could not be resolved}}
   char &d = (&A::f)('0'); // expected-error {{could not be resolved}}
 }
 
 // dr163: na
 
-namespace dr164 { // dr164: yes
+//--- dr164: yes
+namespace dr164 {
   void f(int);
   template <class T> int g(T t) { return f(t); }
 
   enum E { e };
   int f(E);
 
   int k = g(e);
 }
 
-namespace dr165 { // dr165: no
+//--- dr165: no
+namespace dr165 {
   namespace N {
     struct A { friend struct B; };
     void f() { void g(); }
   }
   // FIXME: dr1477 says this is ok, dr165 says it's ill-formed
   struct N::B {};
   // FIXME: dr165 says this is ill-formed, but the argument in dr1477 says it's ok
   void N::g() {}
 }
 
-namespace dr166 { // dr166: yes
+//--- dr166: yes
+namespace dr166 {
   namespace A { class X; }
 
   template<typename T> int f(T t) { return t.n; }
   int g(A::X);
   template<typename T> int h(T t) { return t.n; } // expected-error {{private}}
   int i(A::X);
 
   namespace A {
namespace dr166 {
   template int f(A::X);
   int g(A::X x) { return x.n; }
   template int h(A::X); // expected-note {{instantiation}}
   int i(A::X x) { return x.n; } // expected-error {{private}}
 }
 
 // dr167: sup 1012
 
-namespace dr168 { // dr168: no
+//--- dr168: no
+namespace dr168 {
   extern "C" typedef int (*p)();
   extern "C++" typedef int (*q)();
   struct S {
     static int f();
   };
   p a = &S::f; // FIXME: this should fail.
   q b = &S::f;
 }
 
-namespace dr169 { // dr169: yes
+//--- dr169: yes
+namespace dr169 {
   template<typename> struct A { int n; };
   struct B {
     template<typename> struct C;
     template<typename> void f();
     template<typename> static int n; // expected-error 0-1{{extension}}
   };
   struct D : A<int>, B {
     using A<int>::n;
     using B::C<int>; // expected-error {{using declaration cannot refer to a template specialization}}
     using B::f<int>; // expected-error {{using declaration cannot refer to a template specialization}}
     using B::n<int>; // expected-error {{using declaration cannot refer to a template specialization}}
   };
 }
 
 namespace { // dr171: yes
   int dr171a;
 }
 int dr171b; // expected-note {{here}}
 namespace dr171 {
   extern "C" void dr171a();
   extern "C" void dr171b(); // expected-error {{conflicts}}
 }
 
-namespace dr172 { // dr172: yes
+//--- dr172: yes
+namespace dr172 {
   enum { zero };
   int check1[-1 < zero ? 1 : -1];
 
   enum { x = -1, y = (unsigned int)-1 };
   int check2[sizeof(x) > sizeof(int) ? 1 : -1];
 
   enum { a = (unsigned int)-1 / 2 };
   int check3a[sizeof(a) == sizeof(int) ? 1 : -1];
namespace dr172 {
   int check7a[sizeof(e) == sizeof(long) ? 1 : -1]; // expected-error 0-1{{extension}}
   int check7b[-e < 0 ? 1 : -1];
 
   enum { f = (unsigned long long)-1 / 2 + 1 }; // expected-error 0-1{{extension}}
   int check8a[sizeof(f) == sizeof(unsigned long) ? 1 : -1]; // expected-error 0-1{{extension}}
   int check8b[-f > 0 ? 1 : -1];
 }
 
-namespace dr173 { // dr173: yes
+//--- dr173: yes
+namespace dr173 {
   int check[('0' + 1 == '1' && '0' + 2 == '2' && '0' + 3 == '3' &&
              '0' + 4 == '4' && '0' + 5 == '5' && '0' + 6 == '6' &&
              '0' + 7 == '7' && '0' + 8 == '8' && '0' + 9 == '9') ? 1 : -1];
 }
 
 // dr174: sup 1012
 
-namespace dr175 { // dr175: yes
+//--- dr175: yes
+namespace dr175 {
   struct A {}; // expected-note {{here}}
   struct B : private A {}; // expected-note {{constrained by private inheritance}}
   struct C : B {
     A a; // expected-error {{private}}
     dr175::A b;
   };
 }
 
-namespace dr176 { // dr176: yes
+//--- dr176: yes
+namespace dr176 {
   template<typename T> class Y;
   template<> class Y<int> {
     void f() {
       typedef Y A; // expected-note {{here}}
       typedef Y<char> A; // expected-error {{different types ('Y<char>' vs 'Y<int>')}}
     }
   };
 
namespace dr176 {
   template<typename T> class X { // expected-note {{here}}
     X *p1;
     X<T> *p2;
     X<int> *p3;
     dr176::X *p4; // expected-error {{requires template arguments}}
   };
 }
 
-namespace dr177 { // dr177: yes
+//--- dr177: yes
+namespace dr177 {
   struct B {};
   struct A {
     A(A &); // expected-note 0-1{{not viable: expects an lvalue}}
     A(const B &); // expected-note 0-1{{not viable: no known conversion from 'A' to}}
   };
   B b;
   A a = b;
 #if __cplusplus <= 201402L
   // expected-error@-2 {{no viable constructor copying variable}}
 #endif
 
   struct C { C(C&); }; // expected-note {{not viable: expects an lvalue for 1st argument}}
   struct D : C {};
   struct E { operator D(); };
   E e;
   C c = e; // expected-error {{no viable constructor copying variable of type 'D'}}
 }
 
-namespace dr178 { // dr178: yes
+//--- dr178: yes
+namespace dr178 {
   int check[int() == 0 ? 1 : -1];
 #if __cplusplus >= 201103L
   static_assert(int{} == 0, "");
   struct S { int a, b; };
   static_assert(S{1}.b == 0, "");
   struct T { constexpr T() : n() {} int n; };
   static_assert(T().n == 0, "");
   struct U : S { constexpr U() : S() {} };
   static_assert(U().b == 0, "");
 #endif
 }
 
-namespace dr179 { // dr179: yes
+//--- dr179: yes
+namespace dr179 {
   void f();
   int n = &f - &f; // expected-error {{arithmetic on pointers to the function type 'void ()'}}
 }
 
-namespace dr180 { // dr180: yes
+//--- dr180: yes
+namespace dr180 {
   template<typename T> struct X : T, T::some_base {
     X() : T::some_type_that_might_be_T(), T::some_base() {}
     friend class T::some_class;
     void f() {
       enum T::some_enum e;
     }
   };
 }
 
-namespace dr181 { // dr181: yes
+//--- dr181: yes
+namespace dr181 {
   namespace X {
     template <template X<class T> > struct A { }; // expected-error +{{}}
     template <template X<class T> > void f(A<X>) { } // expected-error +{{}}
   }
 
   namespace Y {
     template <template <class T> class X> struct A { };
     template <template <class T> class X> void f(A<X>) { }
   }
 }
 
-namespace dr182 { // dr182: yes
+//--- dr182: yes
+namespace dr182 {
   template <class T> struct C {
     void f();
     void g();
   };
 
   template <class T> void C<T>::f() {}
   template <class T> void C<T>::g() {}
 
   class A {
     class B {};
     void f();
   };
 
   template void C<A::B>::f();
   template <> void C<A::B>::g();
 
   void A::f() {
     C<B> cb;
     cb.f();
   }
 }
 
-namespace dr183 { // dr183: sup 382
+//--- dr183: sup 382
+namespace dr183 {
   template<typename T> struct A {};
   template<typename T> struct B {
     typedef int X;
   };
   template<> struct A<int> {
 #if __cplusplus <= 199711
     typename B<int>::X x; // expected-error {{'typename' occurs outside of a template}}
 #else
     typename B<int>::X x;
 #endif
   };
 }
 
-namespace dr184 { // dr184: yes
+//--- dr184: yes
+namespace dr184 {
   template<typename T = float> struct B {};
 
   template<template<typename TT = float> class T> struct A {
     void f();
     void g();
   };
 
   template<template<typename TT> class T> void A<T>::f() { // expected-note {{here}}
     T<> t; // expected-error {{too few template arguments}}
   }
 
   template<template<typename TT = char> class T> void A<T>::g() {
     T<> t;
     typedef T<> X;
     typedef T<char> X;
   }
 
   void h() { A<B>().g(); }
 }
 
 // dr185 FIXME: add codegen test
 
-namespace dr187 { // dr187: sup 481
+//--- dr187: sup 481
+namespace dr187 {
   const int Z = 1;
   template<int X = Z, int Z = X> struct A;
   typedef A<> T;
   typedef A<1, 1> T;
 }
 
-namespace dr188 { // dr188: yes
+//--- dr188: yes
+namespace dr188 {
   char c[10];
   int check[sizeof(0, c) == 10 ? 1 : -1];
 }
 
 // dr190 FIXME: add codegen test for tbaa
 
 int dr191_j;
-namespace dr191 { // dr191: yes
+//--- dr191: yes
+namespace dr191 {
   namespace example1 {
     struct outer {
       static int i;
       struct inner {
         void f() {
           struct local {
             void g() {
               i = 5;
struct S {
         };
       }
     };
   }
 }
 
 // dr193 FIXME: add codegen test
 
-namespace dr194 { // dr194: yes
+//--- dr194: yes
+namespace dr194 {
   struct A {
     A();
     void A(); // expected-error {{constructor cannot have a return type}}
   };
   struct B {
     void B(); // expected-error {{constructor cannot have a return type}}
     B();
   };
   struct C {
     inline explicit C(int) {}
   };
 }
 
-namespace dr195 { // dr195: yes
+//--- dr195: yes
+namespace dr195 {
   void f();
   int *p = (int*)&f; // expected-error 0-1{{extension}}
   void (*q)() = (void(*)())&p; // expected-error 0-1{{extension}}
 }
 
-namespace dr197 { // dr197: yes
+//--- dr197: yes
+namespace dr197 {
   char &f(char);
 
   template <class T> void g(T t) {
     char &a = f(1);
     char &b = f(T(1)); // expected-error {{unrelated type 'int'}}
     char &c = f(t); // expected-error {{unrelated type 'int'}}
   }
 
   void f(int);
 
   enum E { e };
   int &f(E);
 
   void h() {
     g('a');
     g(2);
     g(e); // expected-note {{in instantiation of}}
   }
 }
 
-namespace dr198 { // dr198: yes
+//--- dr198: yes
+namespace dr198 {
   struct A {
     int n;
     struct B {
       int m[sizeof(n)];
 #if __cplusplus < 201103L
       // expected-error@-2 {{invalid use of non-static data member}}
 #endif
       int f() { return n; }

clang/test/CXX/drs/dr20xx.cpp

 // RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors \
 // RUN:            -Wno-variadic-macros -Wno-c11-extensions
 // RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++23 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 
 #if __cplusplus < 201103L
 #define static_assert(...) _Static_assert(__VA_ARGS__)
 #endif
 
-namespace dr2007 { // dr2007: 3.4
+//--- dr2007: 3.4
+namespace dr2007 {
 template<typename T> struct A { typename T::error e; };
 template<typename T> struct B { };
 B<A<void> > b1;
 B<A<void> > b2 = b1;
 int a = b2[0]; // expected-error {{does not provide a subscript operator}}
 int b = __builtin_addressof(b2)->foo; // expected-error {{no member}}
 }
 
 // dr2009: na
 
-namespace dr2026 { // dr2026: 11
+//--- dr2026: 11
+namespace dr2026 {
   template<int> struct X {};
 
   const int a = a + 1; // expected-warning {{uninitialized}} expected-note {{here}} expected-note 0-1{{outside its lifetime}}
   X<a> xa; // expected-error {{constant expression}} expected-note {{initializer of 'a'}}
 
 #if __cplusplus >= 201103L
   constexpr int b = b; // expected-error {{constant expression}} expected-note {{outside its lifetime}}
   [[clang::require_constant_initialization]] int c = c; // expected-error {{constant initializer}} expected-note {{attribute}}

 #endif
 
 #if __cplusplus > 201703L
     static constinit int h = h; // expected-error {{constant initializer}} expected-note {{outside its lifetime}} expected-note {{'constinit'}}
 #endif
   }
 }
 
-namespace dr2061 { // dr2061: yes
+//--- dr2061: yes
+namespace dr2061 {
 #if __cplusplus >= 201103L
   namespace A {
     inline namespace b {
       namespace C {
         // 'f' is the example from the DR.  'S' is an example where if we didn't
         // properly handle the two being the same, we would get an incomplete
         // type error during attempted instantiation.
         template<typename T> void f();
#if __cplusplus >= 201103L
 
   void use() {
     A::C::f<int>();
     A::C::S<int> s;
   }
 #endif // C++11
 }
 
-namespace dr2076 { // dr2076: 13
+//--- dr2076: 13
+namespace dr2076 {
 #if __cplusplus >= 201103L
   namespace std_example {
     struct A { A(int); };
     struct B { B(A); };
     B b{{0}};
 
     struct Params { int a; int b; };
     struct Foo {
void func(const string &arg) {
     bar(arg);
     bar({arg});
     bar({{arg}}); // expected-error {{no matching function}}
     bar({{{arg}}}); // expected-error {{no matching function}}
   }
 #endif
 }
 
-namespace dr2082 { // dr2082: 11
+//--- dr2082: 11
+namespace dr2082 {
   void test1(int x, int = sizeof(x)); // ok
 #if __cplusplus >= 201103L
   void test2(int x, int = decltype(x){}); // ok
 #endif
 }
 
-namespace dr2083 { // dr2083: partial
+//--- dr2083: partial
+namespace dr2083 {
 #if __cplusplus >= 201103L
   void non_const_mem_ptr() {
     struct A {
       int x;
       int y;
     };
     constexpr A a = {1, 2};
     struct B {
void f() {
         constexpr int foo() const { return b.b; }
       };
       static_assert(Q().foo() == 42, "");
     }
   }
 #endif
 }
 
-namespace dr2094 { // dr2094: 5
+//--- dr2094: 5
+namespace dr2094 {
   struct A { int n; };
   struct B { volatile int n; };
   static_assert(__is_trivially_copyable(volatile int), "");
   static_assert(__is_trivially_copyable(const volatile int), "");
   static_assert(__is_trivially_copyable(const volatile int[]), "");
   static_assert(__is_trivially_copyable(A), "");
   static_assert(__is_trivially_copyable(volatile A), "");
   static_assert(__is_trivially_copyable(const volatile A), "");

clang/test/CXX/drs/dr21xx.cpp

 // RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++23 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
 
 #if __cplusplus < 201103L
 // expected-error@+1 {{variadic macro}}
 #define static_assert(...) __extension__ _Static_assert(__VA_ARGS__)
 #endif
 
-namespace dr2100 { // dr2100: 12
+//--- dr2100: 12
+namespace dr2100 {
   template<const int *P, bool = true> struct X {};
   template<typename T> struct A {
     static const int n = 1;
     int f() {
       return X<&n>::n; // ok, value-dependent
     }
     int g() {
       static const int n = 2;
int g() {
       return Y<n>::declared_later; // expected-error {{no member named 'declared_later'}}
     }
   };
   template<int N> struct Y<N> {
     static const int declared_later = 0;
   };
 }
 
-namespace dr2103 { // dr2103: yes
+//--- dr2103: yes
+namespace dr2103 {
   void f() {
     int a;
     int &r = a; // expected-note {{here}}
     struct Inner {
       void f() {
         int &s = r; // expected-error {{enclosing function}}
         (void)s;
       }
     };
   }
 }
 
-namespace dr2120 { // dr2120: 7
+//--- dr2120: 7
+namespace dr2120 {
   struct A {};
   struct B : A {};
   struct C { A a; };
   struct D { C c[5]; };
   struct E : B { D d; };
   static_assert(__is_standard_layout(B), "");
   static_assert(__is_standard_layout(D), "");
   static_assert(!__is_standard_layout(E), "");
 }
 
-namespace dr2126 { // dr2126: 12
+//--- dr2126: 12
+namespace dr2126 {
 #if __cplusplus >= 201103L
   struct A { int n; };
 
   const A &a = {1};              // const temporary
   A &b = (A &)(const A &)A{1};   // const temporary
   A &&c = (A &&)(const A &)A{1}; // const temporary
 
   A &&d = {1};                   // non-const temporary expected-note {{here}}
#if __cplusplus >= 201103L
   static_assert(g.n == 1, "");
   static_assert(h.n == 1, ""); // expected-error {{constant}} expected-note {{read of temporary}}
   static_assert(i.a.n == 1, ""); // expected-error {{constant}} expected-note {{read of non-constexpr variable}}
   static_assert(j.a.n == 1, ""); // expected-error {{constant}} expected-note {{read of temporary}}
   static_assert(k.a.n == 1, "");
 #endif
 }
 
-namespace dr2140 { // dr2140: 9
+//--- dr2140: 9
+namespace dr2140 {
 #if __cplusplus >= 201103L
   union U { int a; decltype(nullptr) b; };
   constexpr int *test(U u) {
     return u.b;
   }
   static_assert(!test({123}), "u.b should be valid even when b is inactive");
 #endif
 }
 
-namespace dr2157 { // dr2157: 11
+//--- dr2157: 11
+namespace dr2157 {
 #if __cplusplus >= 201103L
   enum E : int;
   struct X {
     enum dr2157::E : int(); // expected-error {{only allows ':' in member enumeration declaration to introduce a fixed underlying type}}
   };
 #endif
 }
 
 // dr2165: na
 
-namespace dr2170 { // dr2170: 9
+//--- dr2170: 9
+namespace dr2170 {
 #if __cplusplus >= 201103L
   void f() {
     constexpr int arr[3] = {1, 2, 3}; // expected-note {{here}}
     struct S {
       int get(int n) { return arr[n]; }
       const int &get_ref(int n) { return arr[n]; } // expected-error {{enclosing function}}
       // FIXME: expected-warning@-1 {{reference to stack}}
     };
   }
 #endif
 }
 
-namespace dr2171 { // dr2171: 15
+//--- dr2171: 15
+namespace dr2171 {
 #if __cplusplus >= 201103L
 
 struct NonConstCopy {
   NonConstCopy(NonConstCopy &) = default;
   NonConstCopy &operator=(NonConstCopy &) = default;
 };
 
 static_assert(__has_trivial_copy(NonConstCopy), "");

 static_assert(__is_trivially_assignable(NonConstCopy &&, NonConstCopy &), "");
 static_assert(!__is_trivially_assignable(NonConstCopy &&, const NonConstCopy &), "");
 static_assert(!__is_trivially_assignable(NonConstCopy &&, NonConstCopy), "");
 static_assert(!__is_trivially_assignable(NonConstCopy &&, NonConstCopy &&), "");
 
 #endif
 } // namespace dr2171
 
-namespace dr2180 { // dr2180: yes
+//--- dr2180: yes
+namespace dr2180 {
   class A {
     A &operator=(const A &); // expected-note 0-2{{here}}
     A &operator=(A &&); // expected-note 0-2{{here}} expected-error 0-1{{extension}}
   };
 
   struct B : virtual A {
     B &operator=(const B &);
     B &operator=(B &&); // expected-error 0-1{{extension}}
     virtual void foo() = 0;
   };
 #if __cplusplus < 201103L
   B &B::operator=(const B&) = default; // expected-error {{private member}} expected-error {{extension}} expected-note {{here}}
   B &B::operator=(B&&) = default; // expected-error {{private member}} expected-error 2{{extension}} expected-note {{here}}
 #else
   B &B::operator=(const B&) = default; // expected-error {{would delete}} expected-note@-9{{inaccessible copy assignment}}
   B &B::operator=(B&&) = default; // expected-error {{would delete}} expected-note@-10{{inaccessible move assignment}}
 #endif
 }
 
-namespace dr2199 { // dr2199: 3.8
-                   // NB: reusing part of dr407 test
+//--- dr2199: 3.8
+namespace dr2199 {
 namespace A {
   struct S {};
 }
 namespace B {
   typedef int S;
 }
 namespace E {
   typedef A::S S;

clang/test/CXX/drs/dr22xx.cpp

 // RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++1z -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 
 #if __cplusplus >= 201103L
-namespace dr2211 { // dr2211: 8
+//--- dr2211: 8
+namespace dr2211 {
 void f() {
   int a;
   auto f = [a](int a) { (void)a; }; // expected-error {{a lambda parameter cannot shadow an explicitly captured entity}}
   // expected-note@-1{{variable 'a' is explicitly captured here}}
   auto g = [=](int a) { (void)a; };
 }
 }
 #endif
 
-namespace dr2213 { // dr2213: yes
+//--- dr2213: yes
+namespace dr2213 {
 template <typename T, typename U>
 struct A;
 
 template <typename U>
 struct A<int, U>;
 } // namespace dr2213
 
-namespace dr2229 { // dr2229: 7
+//--- dr2229: 7
+namespace dr2229 {
 struct AnonBitfieldQualifiers {
   const unsigned : 1; // expected-error {{anonymous bit-field cannot have qualifiers}}
   volatile unsigned : 1; // expected-error {{anonymous bit-field cannot have qualifiers}}
   const volatile unsigned : 1; // expected-error {{anonymous bit-field cannot have qualifiers}}
 
   unsigned : 1;
   const unsigned i1 : 1;
   volatile unsigned i2 : 1;
   const volatile unsigned i3 : 1;
 };
 }
 
-namespace dr2233 { // dr2233: 11
+//--- dr2233: 11
+namespace dr2233 {
 #if __cplusplus >= 201103L
 template <typename... T>
 void f(int i = 0, T... args) {}
 
 template <typename... T>
 void g(int i = 0, T... args, T... args2) {}
 
 template <typename... T>
template <typename... T> void f() {
     void g(int, int = 0);
     g();
   }
   void h() { f<int>(); }
 }
 #endif
 } // namespace dr2233
 
-namespace dr2292 { // dr2292: 9
+//--- dr2292: 9
+namespace dr2292 {
 #if __cplusplus >= 201103L
   template<typename T> using id = T;
   void test(int *p) {
     p->template id<int>::~id<int>();
   }
 #endif
 }

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++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2>&1 | FileCheck %s
 // RUN: %clang_cc1 -std=c++23 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2>&1 | FileCheck %s
 
 #if __cplusplus >= 201103L
-namespace dr2303 { // dr2303: 12
+//--- dr2303: 12
+namespace dr2303 {
 template <typename... T>
 struct A;
 template <>
 struct A<> {};
 template <typename T, typename... Ts>
 struct A<T, Ts...> : A<Ts...> {};
 struct B : A<int, int> {};
 struct C : A<int, int>, A<int> {}; // expected-warning {{direct base 'A<int>' is inaccessible}}
void g() {
   f(F{}); // expected-error {{ambiguous conversion from derived class}}
 }
 } //namespace dr2303
 #endif
 
 // dr2331: na
 
 #if __cplusplus >= 201103L
-namespace dr2338 { // dr2338: 12
+//--- dr2338: 12
+namespace dr2338 {
 namespace B {
 enum E : bool { Zero, One };
 static_assert((int)(E)2 == 1, "");
 } // namespace B
 namespace D {
 enum class E : bool { Zero, One };
 static_assert((int)(E)2 == 1, "");
 } // namespace D
 } // namespace dr2338
 #endif
 
-namespace dr2346 { // dr2346: 11
+//--- dr2346: 11
+namespace dr2346 {
   void test() {
     const int i2 = 0;
     extern void h2b(int x = i2 + 0); // ok, not odr-use
   }
 }
 
-namespace dr2352 { // dr2352: 10
+//--- dr2352: 10
+namespace dr2352 {
   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}}
 
#endif
 
   // No temporary is created here.
   int *const *const &check_f = f(p);
 #if __cplusplus >= 201103L
   static_assert(&p == &check_f, "");
 #endif
 }
 
-namespace dr2353 { // dr2353: 9
+//--- dr2353: 9
+namespace dr2353 {
   struct X {
     static const int n = 0;
   };
 
   // CHECK: FunctionDecl {{.*}} use
   int use(X x) {
     // CHECK: MemberExpr {{.*}} .n
     // CHECK-NOT: non_odr_use
int not_use_2(X *x) {
     // CHECK: MemberExpr {{.*}} ->n {{.*}} non_odr_use_constant
     // CHECK: DeclRefExpr {{.*}} 'x'
     return x->n;
   }
 #pragma clang __debug dump not_use_2
 }
 
 #if __cplusplus >= 201402L
-namespace dr2358 { // dr2358: 16
+//--- dr2358: 16
+namespace dr2358 {
   void f2() {
     int i = 1;
     void g1(int = [xxx=1] { return xxx; }());  // OK
     void g2(int = [xxx=i] { return xxx; }());  // expected-error {{default argument references local variable 'i' of enclosing function}}
   }
 }
 #endif
 
-namespace dr2370 { // dr2370: no
+//--- dr2370: no
+namespace dr2370 {
 namespace N {
 typedef int type;
 void g(type);
 void h(type);
 } // namespace N
 class C {
   typedef N::type N_type;
   // FIXME: `type` should be searched for in N
   // friend void N::g(type);
   friend void N::h(N_type);
 };
 } // namespace dr2370
 
 #if __cplusplus >= 201707L
 // Otherwise, if the qualified-id std::tuple_size<E> names a complete class
 // type **with a member value**, the expression std::tuple_size<E>::value shall
 // be a well-formed integral constant expression
-namespace dr2386 { // dr2386: 9
+//--- dr2386: 9
+namespace dr2386 {
 struct Bad1 { int a, b; };
 struct Bad2 { int a, b; };
 } // namespace dr2386
 namespace std {
 template <typename T> struct tuple_size;
 template <> struct std::tuple_size<dr2386::Bad1> {};
 template <> struct std::tuple_size<dr2386::Bad2> {
   static const int value = 42;
 };
 } // namespace std
 namespace dr2386 {
 void no_value() { auto [x, y] = Bad1(); }
 void wrong_value() { auto [x, y] = Bad2(); } // expected-error {{decomposes into 42 elements}}
 } // namespace dr2386
 #endif
 
 // dr2385: na
 
-namespace dr2387 { // dr2387: 9
+//--- dr2387: 9
+namespace dr2387 {
 #if __cplusplus >= 201402L
   template<int> int a = 0;
   extern template int a<0>; // ok
 
   template<int> static int b = 0;
   extern template int b<0>; // expected-error {{internal linkage}}
 
   template<int> const int c = 0;
   extern template const int c<0>; // ok, has external linkage despite 'const'
 
   template<typename T> T d = 0;
   extern template int d<int>;
   extern template const int d<const int>;
 #endif
 }
 
-namespace dr2394 { // dr2394: 15
+//--- dr2394: 15
+namespace dr2394 {
 
 struct A {};
 const A a;
 
 // Now allowed to default-init B.
 struct B { const A a; };
 B b;
 
 }
 
-namespace dr2396 { // dr2396: no
+//--- dr2396: no
+namespace dr2396 {
   struct A {
     struct B;
     operator B B::*();
   };
   struct B;
 
   // FIXME: per P1787 "Calling a conversion function" example, all of the
   // examples below are well-formed, with B resolving to A::B, but currently
   // it's been resolved to dr2396::B. 
 
   // void f(A a) { a.operator B B::*(); }            
   // void g(A a) { a.operator decltype(B()) B::*(); }
   // void g2(A a) { a.operator B decltype(B())::*(); }
 }
 
 #if __cplusplus >= 201103L
-namespace dr2397 { // dr2397: 17
+//--- dr2397: 17
+namespace dr2397 {
   void foo() {
     int a[5];
 
     auto (&b)[5] = a;
     auto (*c)[5] = &a;
   }
 } // namespace dr2397
 #endif

clang/test/CXX/drs/dr25xx.cpp

 // RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-unknown %s -verify
 
-namespace dr2516 { // dr2516: yes
-                   // NB: reusing 1482 test
+//--- dr2516: yes
+namespace dr2516 {
 #if __cplusplus >= 201103L
 template <typename T> struct S {
   typedef char I;
 };
 enum E2 : S<E2>::I { e };
 // expected-error@-1 {{use of undeclared identifier 'E2'}}
 #endif
 } // namespace dr2516
 
-namespace dr2518 { // dr2518: 17
+//--- dr2518: 17
+namespace dr2518 {
 
 template <class T>
 void f(T t) {
   if constexpr (sizeof(T) != sizeof(int)) {
     static_assert(false, "must be int-sized"); // expected-error {{must be int-size}}
   }
 }
 
int test_specialization() {
   S<int> s1;
   S<float> s2;
   S<double> s3; // expected-note {{in instantiation of template class 'dr2518::S<double>' requested here}}
 }
 
 }
 
 
-namespace dr2565 { // dr2565: 16 open
+//--- dr2565: 16 open
+namespace dr2565 {
   template<typename T>
     concept C = requires (typename T::type x) {
       x + 1;
     };
   static_assert(!C<int>);
 
   // Variant of this as reported in GH57487.
   template<bool B> struct bool_constant

clang/test/CXX/drs/dr26xx.cpp

 // RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-unknown %s -verify
 
-namespace dr2621 { // dr2621: yes
+//--- dr2621: yes
+namespace dr2621 {
 enum class E { a };
 namespace One {
 using E_t = E;
 using enum E_t; // typedef ok
 auto v = a;
 }
 namespace Two {
 using dr2621::E;
 int E; // we see this
 using enum E; // expected-error {{unknown type name E}}
 }
 }
 
-namespace dr2628 { // dr2628: no open
-                   // this was reverted for the 16.x release
-                   // due to regressions, see the issue for more details:
-                   // https://github.com/llvm/llvm-project/issues/60777
-
+//--- dr2628: no open
+namespace dr2628 {
 template <bool A = false, bool B = false>
 struct foo {
   // The expected notes below should be removed when dr2628 is fully implemented again
   constexpr foo() requires (!A && !B) = delete; // expected-note {{candidate function [with A = false, B = false]}} #DR2628_CTOR
   constexpr foo() requires (A || B) = delete; // expected-note {{candidate function [with A = false, B = false]}}
 };
 
 void f() {
   // The FIXME's below should be the expected errors when dr2628 is
   // fully implemented again.
   // FIXME-expected-error {{call to deleted}}
   foo fooable; // expected-error {{ambiguous deduction for template arguments of 'foo'}}
   // FIXME-expected-note@#DR2628_CTOR {{marked deleted here}}
 }
 
 }
 
-namespace dr2631 { // dr2631: 16
+//--- dr2631: 16
+namespace dr2631 {
   constexpr int g();
   consteval int f() {
     return g();
   }
   int k(int x = f()) {
     return x;
   }
   constexpr int g() {
     return 42;
   }
   int test() {
     return k();
   }
 }
 
-namespace dr2635 { // dr2635: 16
+//--- dr2635: 16
+namespace dr2635 {
 template<typename T>
 concept UnaryC = true;
 template<typename T, typename U>
 concept BinaryC = true;
 
 struct S{ int i, j; };
 S get_S();
 
void TemplUse() {
   UnaryC auto [a, b] = get_T<T>();
   // expected-error@+1{{decomposition declaration cannot be declared with constrained 'auto'}}
   BinaryC<T> auto [c, d] = get_T<T>();
 }
 }
 
   // dr2636: na
 
-namespace dr2640 { // dr2640: 16
+//--- dr2640: 16
+namespace dr2640 {
 
 int \N{Λ} = 0; //expected-error {{'Λ' is not a valid Unicode character name}} \
                //expected-error {{expected unqualified-id}}
 const char* emoji = "\N{🤡}"; // expected-error {{'🤡' is not a valid Unicode character name}} \
                               // expected-note 5{{did you mean}}
 
 #define z(x) 0
 #define dr2640_a z(
 int x = dr2640_a\N{abc}); // expected-error {{'abc' is not a valid Unicode character name}}
 int y = dr2640_a\N{LOTUS}); // expected-error {{character <U+1FAB7> not allowed in an identifier}} \
                      // expected-error {{use of undeclared identifier 'dr2640_a🪷'}} \
                      // expected-error {{extraneous ')' before ';'}}
 }
 
   // dr2642: na
 
-namespace dr2644 { // dr2644: yes
+//--- dr2644: yes
+namespace dr2644 {
 
 auto z = [a = 42](int a) { // expected-error {{a lambda parameter cannot shadow an explicitly captured entity}} \
                            // expected-note {{variable 'a' is explicitly captured here}}
      return 1;
 };
 
 }
 
-namespace dr2650 { // dr2650: yes
+//--- dr2650: yes
+namespace dr2650 {
 template <class T, T> struct S {};
 template <class T> int f(S<T, T{}>*); // expected-note {{type 'X' of non-type template parameter is not a structural type}}
 class X {
   int m;
 };
 int i0 = f<X>(0);   //expected-error {{no matching function for call to 'f'}}
 }
 
-namespace dr2654 { // dr2654: 16
+//--- dr2654: 16
+namespace dr2654 {
 void f() {
     int neck, tail;
     volatile int brachiosaur;
     brachiosaur += neck;                // OK
     brachiosaur -= neck;                // OK
     brachiosaur |= neck;                // OK
 }
 }

clang/test/CXX/drs/dr2xx.cpp

 // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++23 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 
 // PR13819 -- __SIZE_TYPE__ is incompatible.
 typedef __SIZE_TYPE__ size_t; // expected-error 0-1 {{extension}}
 
 #if __cplusplus < 201103L
 #define fold(x) (__builtin_constant_p(x) ? (x) : (x))
 #else
 #define fold
 #endif
 
-namespace dr200 { // dr200: dup 214
+//--- dr200: dup 214
+namespace dr200 {
   template <class T> T f(int);
   template <class T, class U> T f(U) = delete; // expected-error 0-1{{extension}}
 
   void g() {
     f<int>(1);
   }
 }
 
 // dr201 FIXME: write codegen test
 
-namespace dr202 { // dr202: yes
+//--- dr202: yes
+namespace dr202 {
   template<typename T> T f();
   template<int (*g)()> struct X {
     int arr[fold(g == &f<int>) ? 1 : -1];
   };
   template struct X<f>;
 }
 
 // FIXME (export) dr204: no
 
-namespace dr206 { // dr206: yes
+//--- dr206: yes
+namespace dr206 {
   struct S; // expected-note 2{{declaration}}
   template<typename T> struct Q { S s; }; // expected-error {{incomplete}}
   template<typename T> void f() { S s; } // expected-error {{incomplete}}
 }
 
-namespace dr207 { // dr207: yes
+//--- dr207: yes
+namespace dr207 {
   class A {
   protected:
     static void f() {}
   };
   class B : A {
   public:
     using A::f;
     void g() {
       A::f();
       f();
     }
   };
 }
 
 // dr208 FIXME: write codegen test
 
-namespace dr209 { // dr209: yes
+//--- dr209: yes
+namespace dr209 {
   class A {
     void f(); // expected-note {{here}}
   };
   class B {
     friend void A::f(); // expected-error {{private}}
   };
 }
 
 // dr210 FIXME: write codegen test
 
-namespace dr211 { // dr211: yes
+//--- dr211: yes
+namespace dr211 {
   struct A {
     A() try {
       throw 0;
     } catch (...) {
       return; // expected-error {{return in the catch of a function try block of a constructor}}
     }
   };
 }
 
-namespace dr213 { // dr213: yes
+//--- dr213: yes
+namespace dr213 {
   template <class T> struct A : T {
     void h(T t) {
       char &r1 = f(t);
       int &r2 = g(t); // expected-error {{explicit qualification required to use member 'g' from dependent base class}}
     }
   };
   struct B {
     int &f(B);
     int &g(B); // expected-note {{here}}
   };
   char &f(B);
 
   template void A<B>::h(B); // expected-note {{instantiation}}
 }
 
-namespace dr214 { // dr214: yes
+//--- dr214: yes
+namespace dr214 {
   template<typename T, typename U> T checked_cast(U from) { U::error; }
   template<typename T, typename U> T checked_cast(U *from);
   class C {};
   void foo(int *arg) { checked_cast<const C *>(arg); }
 
   template<typename T> T f(int);
   template<typename T, typename U> T f(U) { T::error; }
   void g() {
     f<int>(1);
   }
 }
 
-namespace dr215 { // dr215: yes
+//--- dr215: yes
+namespace dr215 {
   template<typename T> class X {
     friend void T::foo();
     int n;
   };
   struct Y {
     void foo() { (void)+X<Y>().n; }
   };
 }
 
-namespace dr216 { // dr216: no
+//--- dr216: no
+namespace dr216 {
   // FIXME: Should reject this: 'f' has linkage but its type does not,
   // and 'f' is odr-used but not defined in this TU.
   typedef enum { e } *E;
   void f(E);
   void g(E e) { f(e); }
 
   struct S {
     // FIXME: Should reject this: 'f' has linkage but its type does not,
     // and 'f' is odr-used but not defined in this TU.
     typedef enum { e } *E;
     void f(E);
   };
   void g(S s, S::E e) { s.f(e); }
 }
 
-namespace dr217 { // dr217: yes
+//--- dr217: yes
+namespace dr217 {
   template<typename T> struct S {
     void f(int);
   };
   template<typename T> void S<T>::f(int = 0) {} // expected-error {{default arguments cannot be added}}
 }
 
-namespace dr218 { // dr218: yes
-                  // NB: also dup 405
+//--- dr218: yes
+namespace dr218 {
   namespace A {
     struct S {};
     void f(S);
   }
   namespace B {
     struct S {};
     void f(S);
   }
namespace G {
     template<typename A, typename B> struct C {};
   }
   void testG(G::C<G::X::A, G::Y::B> gc) { f(gc); }
 }
 
 // dr219: na
 // dr220: na
 
-namespace dr221 { // dr221: yes
+//--- dr221: yes
+namespace dr221 {
   struct A { // expected-note 2-4{{candidate}}
     A &operator=(int&); // expected-note 2{{candidate}}
     A &operator+=(int&);
     static A &operator=(A&, double&); // expected-error {{cannot be a static member}}
     static A &operator+=(A&, double&); // expected-error {{cannot be a static member}}
     friend A &operator=(A&, char&); // expected-error {{must be a non-static member function}}
     friend A &operator+=(A&, char&);
   };
   A &operator=(A&, float&); // expected-error {{must be a non-static member function}}
   A &operator+=(A&, float&);
 
   void test(A a, int n, char c, float f) {
     a = n;
     a += n;
     a = c; // expected-error {{no viable}}
     a += c;
     a = f; // expected-error {{no viable}}
     a += f;
   }
 }
 
-namespace dr222 { // dr222: dup 637
+//--- dr222: dup 637
+namespace dr222 {
   void f(int a, int b, int c, int *x) {
 #pragma clang diagnostic push
 #pragma clang diagnostic warning "-Wunsequenced"
     void((a += b) += c);
     void((a += b) + (a += c)); // expected-warning {{multiple unsequenced modifications to 'a'}}
 
     x[a++] = a;
 #if __cplusplus < 201703L
     // expected-warning@-2 {{unsequenced modification and access to 'a'}}
 #endif
 
     a = b = 0; // ok, read and write of 'b' are sequenced
 
     a = (b = a++);
 #if __cplusplus < 201703L
     // expected-warning@-2 {{multiple unsequenced modifications to 'a'}}
 #endif
     a = (b = ++a);
 #pragma clang diagnostic pop
   }
 }
 
 // dr223: na
 
-namespace dr224 { // dr224: 16
+//--- dr224: 16
+namespace dr224 {
   namespace example1 {
     template <class T> class A {
       typedef int type;
       A::type a;
       A<T>::type b;
       A<T*>::type c;
 #if __cplusplus <= 201703L
       // expected-error@-2 {{implicit 'typename' is a C++20 extension}}
#endif
   }
 }
 
 // dr225: yes
 template<typename T> void dr225_f(T t) { dr225_g(t); } // expected-error {{call to function 'dr225_g' that is neither visible in the template definition nor found by argument-dependent lookup}}
 void dr225_g(int); // expected-note {{should be declared prior to the call site}}
 template void dr225_f(int); // expected-note {{in instantiation of}}
 
-namespace dr226 { // dr226: no
+//--- dr226: no
+namespace dr226 {
   template<typename T = void> void f() {}
 #if __cplusplus < 201103L
   // expected-error@-2 {{extension}}
   // FIXME: This appears to be wrong: default arguments for function templates
   // are listed as a defect (in c++98) not an extension. EDG accepts them in
   // strict c++98 mode.
 #endif
   template<typename T> struct S {

 
 void dr227(bool b) { // dr227: yes
   if (b)
     int n;
   else
     int n;
 }
 
-namespace dr228 { // dr228: yes
+//--- dr228: yes
+namespace dr228 {
   template <class T> struct X {
     void f();
   };
   template <class T> struct Y {
     void g(X<T> x) { x.template X<T>::f(); }
   };
 }
 
-namespace dr229 { // dr229: yes
+//--- dr229: yes
+namespace dr229 {
   template<typename T> void f();
   template<typename T> void f<T*>() {} // expected-error {{function template partial specialization}}
   template<> void f<int>() {}
 }
 
-namespace dr230 { // dr230: yes
+//--- dr230: yes
+namespace dr230 {
   struct S {
     S() { f(); } // expected-warning {{call to pure virtual member function}}
     virtual void f() = 0; // expected-note {{declared here}}
   };
 }
 
-namespace dr231 { // dr231: yes
+//--- dr231: yes
+namespace dr231 {
   namespace outer {
     namespace inner {
       int i; // expected-note {{here}}
     }
     void f() { using namespace inner; }
     int j = i; // expected-error {{undeclared identifier 'i'; did you mean 'inner::i'?}}
   }
 }
 
 // dr234: na
 // dr235: na
 
-namespace dr236 { // dr236: yes
+//--- dr236: yes
+namespace dr236 {
   void *p = int();
 #if __cplusplus < 201103L
   // expected-warning@-2 {{null pointer}}
 #else
   // expected-error@-4 {{cannot initialize}}
 #endif
 }
 
-namespace dr237 { // dr237: dup 470
+//--- dr237: dup 470
+namespace dr237 {
   template<typename T> struct A { void f() { T::error; } };
   template<typename T> struct B : A<T> {};
   template struct B<int>; // ok
 }
 
-namespace dr239 { // dr239: yes
+//--- dr239: yes
+namespace dr239 {
   namespace NS {
     class T {};
     void f(T);
     float &g(T, int);
   }
   NS::T parm;
   int &g(NS::T, float);
   int main() {
     f(parm);
     float &r = g(parm, 1);
     extern int &g(NS::T, float);
     int &s = g(parm, 1);
   }
 }
 
 // dr240: dup 616
 
-namespace dr241 { // dr241: yes
+//--- dr241: yes
+namespace dr241 {
   namespace A {
     struct B {};
     template <int X> void f(); // expected-note 3{{candidate}}
     template <int X> void g(B);
   }
   namespace C {
     template <class T> void f(T t); // expected-note 2{{candidate}}
     template <class T> void g(T t); // expected-note {{candidate}}
   }
   void h(A::B b) {
     f<3>(b); // expected-error 0-1{{C++20 extension}} expected-error {{no matching}}
     g<3>(b); // expected-error 0-1{{C++20 extension}}
     A::f<3>(b); // expected-error {{no matching}}
     A::g<3>(b);
     C::f<3>(b); // expected-error {{no matching}}
     C::g<3>(b); // expected-error {{no matching}}
     using C::f;
     using C::g;
     f<3>(b); // expected-error {{no matching}}
     g<3>(b);
   }
 }
 
-namespace dr243 { // dr243: yes
+//--- dr243: yes
+namespace dr243 {
   struct B;
   struct A {
     A(B); // expected-note {{candidate}}
   };
   struct B {
     operator A() = delete; // expected-error 0-1{{extension}} expected-note {{candidate}}
   } b;
   A a1(b);
   A a2 = b; // expected-error {{ambiguous}}
 }
 
-namespace dr244 { // dr244: 11
-                  // NB: this test is reused by dr399
+//--- dr244: 11
+namespace dr244 {
   struct B {}; // expected-note {{type 'dr244::B' found by destructor name lookup}}
   struct D : B {};
 
   D D_object;
   typedef B B_alias;
   B* B_ptr = &D_object;
 
   void f() {
template <typename U> void g(U *p) {
       p->T::~T();
       p->U::~T();
       p->::dr244::QualifiedLookupInScope::N::S<int>::Inner::~T(); // expected-error {{'T' does not refer to a type name}}
     }
     template void g(N::S<int>::Inner *);
   }
 }
 
-namespace dr245 { // dr245: yes
+//--- dr245: yes
+namespace dr245 {
   struct S {
     enum E {}; // expected-note {{here}}
     class E *p; // expected-error {{does not match previous declaration}}
   };
 }
 
-namespace dr246 { // dr246: yes
+//--- dr246: yes
+namespace dr246 {
   struct S {
     S() try { // expected-note {{try block}}
       throw 0;
 X: ;
     } catch (int) {
       goto X; // expected-error {{cannot jump}}
     }
   };
 }
 
-namespace dr247 { // dr247: yes
+//--- dr247: yes
+namespace dr247 {
   struct A {};
   struct B : A {
     void f();
     void f(int);
   };
   void (A::*f)() = (void (A::*)())&B::f;
 
   struct C {
namespace dr247 {
   };
   struct F : E {
     using E::f;
     void f(int);
   };
   void (F::*i)() = &F::f;
 }
 
-namespace dr248 { // dr248: sup P1949
+//--- dr248: sup P1949
+namespace dr248 {
   int \u040d\u040e = 0;
 }
 
-namespace dr249 { // dr249: yes
+//--- dr249: yes
+namespace dr249 {
   template<typename T> struct X { void f(); };
   template<typename T> void X<T>::f() {}
 }
 
-namespace dr250 { // dr250: yes
+//--- dr250: yes
+namespace dr250 {
   typedef void (*FPtr)(double x[]);
 
   template<int I> void f(double x[]);
   FPtr fp = &f<3>;
 
   template<int I = 3> void g(double x[]); // expected-error 0-1{{extension}}
   FPtr gp = &g<>;
 }
 
-namespace dr252 { // dr252: yes
+//--- dr252: yes
+namespace dr252 {
   struct A {
     void operator delete(void*); // expected-note {{found}}
   };
   struct B {
     void operator delete(void*); // expected-note {{found}}
   };
   struct C : A, B {
     virtual ~C();
namespace dr252 {
 
   struct G {
     void operator delete(void*, size_t);
     virtual ~G();
   };
   G::~G() {}
 }
 
-namespace dr254 { // dr254: yes
+//--- dr254: yes
+namespace dr254 {
   template<typename T> struct A {
     typedef typename T::type type; // ok even if this is a typedef-name, because
                                    // it's not an elaborated-type-specifier
     typedef struct T::type foo; // expected-error {{typedef 'type' cannot be referenced with a struct specifier}}
   };
   struct B { struct type {}; };
   struct C { typedef struct {} type; }; // expected-note {{here}}
   A<B>::type n;
   A<C>::type n; // expected-note {{instantiation of}}
 }
 
-namespace dr255 { // dr255: yes
+//--- dr255: yes
+namespace dr255 {
 struct S {
   void operator delete(void *){};
   void operator delete(void *, int){};
 };
 void f(S *p) { delete p; }
 } // namespace dr255
 
 // dr256: dup 624
 
-namespace dr257 { // dr257: yes
+//--- dr257: yes
+namespace dr257 {
   struct A { A(int); }; // expected-note {{here}}
   struct B : virtual A {
     B() {}
     virtual void f() = 0;
   };
   struct C : B {
     C() {}
   };
   struct D : B {
     D() {} // expected-error {{must explicitly initialize the base class 'A'}}
     void f();
   };
 }
 
-namespace dr258 { // dr258: yes
+//--- dr258: yes
+namespace dr258 {
   struct A {
     void f(const int);
     template<typename> void g(int);
     float &h() const;
   };
   struct B : A {
     using A::f;
     using A::g;
namespace dr258 {
   struct E {
     virtual void f() = 0; // expected-note {{unimplemented}}
   };
   struct F : E {
     void f() const {}
   } f; // expected-error {{abstract}}
 }
 
-namespace dr259 { // dr259: 4
+//--- dr259: 4
+namespace dr259 {
   template<typename T> struct A {};
   template struct A<int>; // expected-note {{previous}}
   template struct A<int>; // expected-error {{duplicate explicit instantiation}}
 
   template<> struct A<float>; // expected-note {{previous}}
   template struct A<float>; // expected-warning {{has no effect}}
 
   template struct A<char>; // expected-note {{here}}
   template<> struct A<char>; // expected-error {{explicit specialization of 'dr259::A<char>' after instantiation}}
 
   template<> struct A<double>;
   template<> struct A<double>;
   template<> struct A<double> {}; // expected-note {{here}}
   template<> struct A<double> {}; // expected-error {{redefinition}}
 
   template<typename T> struct B; // expected-note {{here}}
   template struct B<int>; // expected-error {{undefined}}
 
   template<> struct B<float>; // expected-note {{previous}}
   template struct B<float>; // expected-warning {{has no effect}}
 }
 
 // FIXME: When dr260 is resolved, also add tests for DR507.
 
-namespace dr261 { // dr261: no
+//--- dr261: no
+namespace dr261 {
 #pragma clang diagnostic push
 #pragma clang diagnostic warning "-Wused-but-marked-unused"
 
   // FIXME: This is ill-formed, with a diagnostic required, because operator new
   // and operator delete are inline and odr-used, but not defined in this
   // translation unit.
   // We're also missing the -Wused-but-marked-unused diagnostic here.
   struct A {
#pragma clang diagnostic warning "-Wused-but-marked-unused"
   struct D {
     inline void operator delete(void*) __attribute__((unused));
   };
   void h() { C::operator delete(0); } // expected-warning {{marked unused but was used}}
 
 #pragma clang diagnostic pop
 }
 
-namespace dr262 { // dr262: yes
+//--- dr262: yes
+namespace dr262 {
   int f(int = 0, ...);
   int k = f();
   int l = f(0);
   int m = f(0, 0);
 }
 
-namespace dr263 { // dr263: yes
+//--- dr263: yes
+namespace dr263 {
   struct X {};
   struct Y {
 #if __cplusplus < 201103L
     friend X::X() throw();
     friend X::~X() throw();
 #elif __cplusplus <= 201703L
     friend constexpr X::X() noexcept;
     friend X::~X();
 #else
     friend constexpr X::X() noexcept;
     friend constexpr X::~X();
 #endif
     Y::Y(); // expected-error {{extra qualification}}
     Y::~Y(); // expected-error {{extra qualification}}
   };
 }
 
 // dr265: dup 353
 // dr266: na
 // dr269: na
 // dr270: na
 
-namespace dr272 { // dr272: yes
+//--- dr272: yes
+namespace dr272 {
   struct X {
     void f() {
       this->~X();
       X::~X();
       ~X(); // expected-error {{unary expression}}
     }
   };
 }
 
 #include <stdarg.h>
 #include <stddef.h>
-namespace dr273 { // dr273: yes
+//--- dr273: yes
+namespace dr273 {
   struct A {
     int n;
   };
   void operator&(A);
   void f(A a, ...) {
     offsetof(A, n);
     va_list val;
     va_start(val, a);
     va_end(val);
   }
 }
 
 // dr274: na
 
-namespace dr275 { // dr275: no
+//--- dr275: no
+namespace dr275 {
   namespace N {
     template <class T> void f(T) {} // expected-note 1-4{{here}}
     template <class T> void g(T) {} // expected-note {{candidate}}
     template <> void f(int);
     template <> void f(char);
     template <> void f(double);
     template <> void g(char);
   }
#endif
 
   // FIXME: likewise, this should also be valid.
   template<typename T> void f(T) {} // expected-note {{candidate}}
   template void f(short); // expected-error {{ambiguous}}
 }
 
 // dr276: na
 
-namespace dr277 { // dr277: yes
+//--- dr277: yes
+namespace dr277 {
   typedef int *intp;
   int *p = intp();
   int a[fold(intp() ? -1 : 1)];
 }
 
-namespace dr280 { // dr280: yes
+//--- dr280: yes
+namespace dr280 {
   typedef void f0();
   typedef void f1(int);
   typedef void f2(int, int);
   typedef void f3(int, int, int);
   struct A {
     operator f1*(); // expected-note {{here}} expected-note {{candidate}}
     operator f2*();
   };
void g() {
     d(0, 0, 0); // expected-error {{private member of 'dr280::B'}}
     e(); // expected-error {{ambiguous}}
     e(0); // expected-error {{ambiguous}}
     e(0, 0); // expected-error {{ambiguous}}
     e(0, 0, 0); // expected-error {{ambiguous}}
   }
 }
 
-namespace dr281 { // dr281: no
+//--- dr281: no
+namespace dr281 {
   void a();
   inline void b();
 
   void d();
   inline void e();
 
   struct S {
     friend inline void a(); // FIXME: ill-formed
     friend inline void b();
     friend inline void c(); // FIXME: ill-formed
     friend inline void d() {}
     friend inline void e() {}
     friend inline void f() {}
   };
 }
 
-namespace dr283 { // dr283: yes
+//--- dr283: yes
+namespace dr283 {
   template<typename T> // expected-note 2{{here}}
   struct S {
     friend class T; // expected-error {{shadows}}
     class T; // expected-error {{shadows}}
   };
 }
 
-namespace dr284 { // dr284: no
+//--- dr284: no
+namespace dr284 {
   namespace A {
     struct X;
     enum Y {};
     class Z {};
   }
   namespace B {
     struct W;
     using A::X;
namespace dr284 {
   };
   struct D::V {}; // expected-error {{no struct named 'V'}}
   struct D::W {};
   struct D::X {}; // FIXME: ill-formed
   enum D::Y e2; // ok per dr417
   class D::Z z2; // ok per dr417
 }
 
-namespace dr285 { // dr285: yes
+//--- dr285: yes
+namespace dr285 {
   template<typename T> void f(T, int); // expected-note {{match}}
   template<typename T> void f(int, T); // expected-note {{match}}
   template<> void f<int>(int, int) {} // expected-error {{ambiguous}}
 }
 
-namespace dr286 { // dr286: yes
+//--- dr286: yes
+namespace dr286 {
   template<class T> struct A {
     class C {
       template<class T2> struct B {}; // expected-note {{here}}
     };
   };
 
   template<class T>
   template<class T2>
   struct A<T>::C::B<T2*> { };
 
   A<short>::C::B<int*> absip; // expected-error {{private}}
 }
 
 // dr288: na
 
-namespace dr289 { // dr289: yes
+//--- dr289: yes
+namespace dr289 {
   struct A; // expected-note {{forward}}
   struct B : A {}; // expected-error {{incomplete}}
 
   template<typename T> struct C { typename T::error error; }; // expected-error {{cannot be used prior to '::'}}
   struct D : C<int> {}; // expected-note {{instantiation}}
 }
 
 // dr290: na
 // dr291: dup 391
 // dr292 FIXME: write a codegen test
 
-namespace dr294 { // dr294: no
+//--- dr294: no
+namespace dr294 {
   void f() throw(int);
 #if __cplusplus > 201402L
     // expected-error@-2 {{ISO C++17 does not allow}} expected-note@-2 {{use 'noexcept}}
 #endif
   int main() {
     (void)static_cast<void (*)() throw()>(f); // FIXME: ill-formed in C++14 and before
 #if __cplusplus > 201402L
     // FIXME: expected-error@-2 {{not allowed}}
#endif
     void (*p)() throw() = f; // expected-error-re {{{{not superset|different exception specification}}}}
     void (*q)() throw(int) = f;
 #if __cplusplus > 201402L
     // expected-error@-2 {{ISO C++17 does not allow}} expected-note@-2 {{use 'noexcept}}
 #endif
   }
 }
 
-namespace dr295 { // dr295: 3.7
+//--- dr295: 3.7
+namespace dr295 {
   typedef int f();
   const f g; // expected-warning {{'const' qualifier on function type 'f' (aka 'int ()') has no effect}}
   f &r = g;
   template<typename T> struct X {
     const T &f;
   };
   X<f> x = {g};
 
   typedef int U();
   typedef const U U; // expected-warning {{'const' qualifier on function type 'U' (aka 'int ()') has no effect}}
 
   typedef int (*V)();
   typedef volatile U *V; // expected-warning {{'volatile' qualifier on function type 'U' (aka 'int ()') has no effect}}
 }
 
-namespace dr296 { // dr296: yes
+//--- dr296: yes
+namespace dr296 {
   struct A {
     static operator int() { return 0; } // expected-error {{static}}
   };
 }
 
-namespace dr298 { // dr298: yes
+//--- dr298: yes
+namespace dr298 {
   struct A {
     typedef int type;
     A();
     ~A();
   };
   typedef A B; // expected-note {{here}}
   typedef const A C; // expected-note {{here}}
 
namespace dr298 {
 
   struct F {
     ~F();
   };
   typedef const F G;
   G::~F() {} // ok
 }
 
-namespace dr299 { // dr299: yes c++11
+//--- dr299: yes c++11
+namespace dr299 {
   struct S {
     operator int();
   };
   struct T {
     operator int(); // expected-note {{}}
     operator unsigned short(); // expected-note {{}}
   };
   // FIXME: should this apply to c++98 mode?
   int *p = new int[S()]; // expected-error 0-1{{extension}}
   int *q = new int[T()]; // expected-error {{ambiguous}}
 }

clang/test/CXX/drs/dr3xx.cpp

 // RUN: %clang_cc1 -std=c++23 -verify=expected,cxx20_23,cxx23    -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++20 -verify=expected,cxx98_20,cxx20_23 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++17 -verify=expected,cxx98_17,cxx98_20 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++14 -verify=expected,cxx98_17,cxx98_20 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++11 -verify=expected,cxx98_17,cxx98_20 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++98 -verify=expected,cxx98_17,cxx98_20 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
 
-namespace dr300 { // dr300: yes
+//--- dr300: yes
+namespace dr300 {
   template<typename R, typename A> void f(R (&)(A)) {}
   int g(int);
   void h() { f(g); }
 }
 
-namespace dr301 { // dr301: yes
+//--- dr301: yes
+namespace dr301 {
   // see also dr38
   struct S;
   template<typename T> void operator+(T, T);
   void operator-(S, S);
 
   void f() {
     bool a = (void(*)(S, S))operator+<S> < // expected-warning {{ordered comparison of function pointers}}
              (void(*)(S, S))operator+<S>;
template<typename T> void f() {
     T::template operator+<int>(0); // ok
   }
 
   template<typename T> class operator&<T*> {}; // expected-error +{{}}
   template<typename T> class T::operator& {}; // expected-error +{{}}
   template<typename T> class S::operator&<T*> {}; // expected-error +{{}}
 }
 
-namespace dr302 { // dr302: yes
+//--- dr302: yes
+namespace dr302 {
   struct A { A(); ~A(); };
 #if __cplusplus < 201103L
   struct B { // expected-error {{implicit default constructor for 'dr302::B' must explicitly initialize the const member 'n'}}
     const int n; // expected-note {{declared here}}
     A a;
   } b = B(); // expected-note {{first required here}}
   // Trivial default constructor C::C() is not called here.
   struct C {
#else
   struct D {
     const int n = 0;
   } d = D();
 #endif
 }
 
 // dr303: na
 
-namespace dr304 { // dr304: yes
+//--- dr304: yes
+namespace dr304 {
   typedef int &a;
   int n = a(); // expected-error {{requires an initializer}}
 
   struct S { int &b; };
   int m = S().b;
 #if __cplusplus < 201103L
   // expected-error@-3 {{requires an initializer}}
   // expected-note@-3 {{in value-initialization}}
 #else
   // expected-error@-5 {{deleted}}
   // expected-note@-7 {{reference}}
 #endif
 }
 
-namespace dr305 { // dr305: no
+//--- dr305: no
+namespace dr305 {
   struct A {
     typedef A C;
   };
   void f(A *a) {
     struct A {};
     a->~A();
     a->~C();
   }
#if __cplusplus >= 201103L
   namespace Q {
     template<typename A> struct R {};
   }
   template<typename A> using R = Q::R<int>;
   void qr(Q::R<int> x) { x.~R<char>(); } // expected-error {{no member named}}
 #endif
 }
 
-namespace dr306 { // dr306: dup 39
+//--- dr306: dup 39
+namespace dr306 {
   struct A { struct B {}; };
   struct C { typedef A::B B; };
   struct D : A, A::B, C {};
   D::B b;
 
   struct X {}; // expected-note {{member type 'dr306::X' found}}
   template<typename T> struct Y { typedef T X; }; // expected-note {{member type 'const dr306::X' found}}
   template<typename T> struct Z : X, Y<T> {};
   Z<X>::X zx;
   Z<const X>::X zcx; // expected-error {{member 'X' found in multiple base classes of different types}}
 }
 
 // dr307: na
 
-namespace dr308 { // dr308: yes
+//--- dr308: yes
+namespace dr308 {
   // This is mostly an ABI library issue.
   struct A {};
   struct B : A {};
   struct C : A {};
   struct D : B, C {};
   void f() {
     // NB: the warning here is correct despite being the opposite of the
     // comments in the catch handlers. The "unreachable" comment is correct
void f() {
     } catch (const B&) { // expected-warning {{exception of type 'const B &' will be caught by earlier handler}}
       // get here instead
     }
   }
 }
 
 // dr309: dup 485
 
-namespace dr311 { // dr311: yes
+//--- dr311: yes
+namespace dr311 {
   namespace X { namespace Y {} }
   namespace X::Y {}
 #if __cplusplus <= 201402L
   // expected-error@-2 {{define each namespace separately}}
 #endif
   namespace X {
     namespace X::Y {}
 #if __cplusplus <= 201402L
   // expected-error@-2 {{define each namespace separately}}
 #endif
   }
   // FIXME: The diagnostics here are not very good.
   namespace ::dr311::X {} // expected-error 2+{{}} // expected-warning {{extra qual}}
 }
 
 // dr312: dup 616
 
-namespace dr313 { // dr313: dup 299 c++11
+//--- dr313: dup 299 c++11
+namespace dr313 {
   struct A { operator int() const; };
   int *p = new int[A()];
 #if __cplusplus < 201103L
   // FIXME: should this be available in c++98 mode? expected-error@-2 {{extension}}
 #endif
 }
 
 namespace dr314 { // FIXME 314: dup 1710
   template<typename T> struct A {
     template<typename U> struct B {};
   };
   template<typename T> struct C : public A<T>::template B<T> {
     C() : A<T>::template B<T>() {}
   };
 }
 
 // dr315: na
 // dr316: sup 1004
 
-namespace dr317 { // dr317: 3.5
+//--- dr317: 3.5
+namespace dr317 {
   void f() {} // expected-note {{previous}}
   inline void f(); // expected-error {{inline declaration of 'f' follows non-inline definition}}
 
   int g();
   int n = g();
   inline int g() { return 0; }
 
   int h();
   int m = h();
   int h() { return 0; } // expected-note {{previous}}
   inline int h(); // expected-error {{inline declaration of 'h' follows non-inline definition}}
 }
 
-namespace dr318 { // dr318: sup 1310
+//--- dr318: sup 1310
+namespace dr318 {
   struct A {};
   struct A::A a;
 }
 
-namespace dr319 { // dr319: no
+//--- dr319: no
+namespace dr319 {
   // FIXME: dup dr389
   // FIXME: We don't have a diagnostic for a name with linkage
   //        having a type without linkage.
   typedef struct {
     int i;
   } *ps;
   extern "C" void f(ps);
   void g(ps); // FIXME: ill-formed, type 'ps' has no linkage
void f() {
     X<C> xc;
   }
 #if __cplusplus < 201103L
   // expected-error@-12 {{uses local type 'A'}}
   // expected-error@-9 {{uses local type 'A'}}
 #endif
 }
 
-namespace dr320 { // dr320: yes
+//--- dr320: yes
+namespace dr320 {
 #if __cplusplus >= 201103L
   struct X {
     constexpr X() {}
     constexpr X(const X &x) : copies(x.copies + 1) {}
     unsigned copies = 0;
   };
   constexpr X f(X x) { return x; }
   constexpr unsigned g(X x) { return x.copies; }
   static_assert(f(X()).copies == g(X()) + 1, "expected one extra copy for return value");
 #endif
 }
 
-namespace dr321 { // dr321: dup 557
+//--- dr321: dup 557
+namespace dr321 {
   namespace N {
     template<int> struct A {
       template<int> struct B;
     };
     template<> template<> struct A<0>::B<0>;
     void f(A<0>::B<0>);
   }
   template<> template<> struct N::A<0>::B<0> {};
 
   template<typename T> void g(T t) { f(t); }
   template void g(N::A<0>::B<0>);
 
   namespace N {
     template<typename> struct I { friend bool operator==(const I&, const I&); };
   }
   N::I<int> i, j;
   bool x = i == j;
 }
 
-namespace dr322 { // dr322: yes
+//--- dr322: yes
+namespace dr322 {
   struct A {
     template<typename T> operator T&();
   } a;
   int &r = static_cast<int&>(a);
   int &s = a;
 }
 
 // dr323: no
 
-namespace dr324 { // dr324: yes
+//--- dr324: yes
+namespace dr324 {
   struct S { int n : 1; } s; // expected-note 3{{bit-field is declared here}}
   int &a = s.n; // expected-error {{non-const reference cannot bind to bit-field}}
   int *b = &s.n; // expected-error {{address of bit-field}}
   int &c = (s.n = 0); // expected-error {{non-const reference cannot bind to bit-field}}
   int *d = &(s.n = 0); // expected-error {{address of bit-field}}
   int &e = true ? s.n : s.n; // expected-error {{non-const reference cannot bind to bit-field}}
   int *f = &(true ? s.n : s.n); // expected-error {{address of bit-field}}
   int &g = (void(), s.n); // expected-error {{non-const reference cannot bind to bit-field}}
   int *h = &(void(), s.n); // expected-error {{address of bit-field}}
   int *i = &++s.n; // expected-error {{address of bit-field}}
 }
 
-namespace dr326 { // dr326: yes
+//--- dr326: yes
+namespace dr326 {
   struct S {};
   int test[__is_trivially_constructible(S, const S&) ? 1 : -1];
 }
 
-namespace dr327 { // dr327: dup 538
+//--- dr327: dup 538
+namespace dr327 {
   struct A;
   class A {};
 
   class B;
   struct B {};
 }
 
-namespace dr328 { // dr328: yes
+//--- dr328: yes
+namespace dr328 {
   struct A; // expected-note 3{{forward declaration}}
   struct B { A a; }; // expected-error {{incomplete}}
   template<typename> struct C { A a; }; // expected-error {{incomplete}}
   A *p = new A[0]; // expected-error {{incomplete}}
 }
 
-namespace dr329 { // dr329: 3.5
+//--- dr329: 3.5
+namespace dr329 {
   struct B {};
   template<typename T> struct A : B {
     friend void f(A a) { g(a); }
     friend void h(A a) { g(a); } // expected-error {{undeclared}}
     friend void i(B b) {} // expected-error {{redefinition}} expected-note {{previous}}
   };
   A<int> a;
   A<char> b; // expected-note {{instantiation}}
 
   void test() {
     h(a); // expected-note {{instantiation}}
   }
 }
 
-namespace dr330 { // dr330: 7
+//--- dr330: 7
+namespace dr330 {
   // Conversions between P and Q will be allowed by P0388.
   typedef int *(*P)[3];
   typedef const int *const (*Q)[3];
   typedef const int *Qinner[3];
   typedef Qinner const *Q2; // same as Q, but 'const' written outside the array type
   typedef const int *const (*R)[4];
   typedef const int *const (*S)[];
   typedef const int *(*T)[];
void f(A *a) {
       (void) reinterpret_cast<B1*>(a);
       (void) reinterpret_cast<B2*>(a); // expected-error {{casts away qualifiers}}
       (void) reinterpret_cast<B3*>(a); // expected-error {{casts away qualifiers}}
       (void) reinterpret_cast<B4*>(a);
     }
   }
 }
 
-namespace dr331 { // dr331: yes
+//--- dr331: yes
+namespace dr331 {
   struct A {
     A(volatile A&); // expected-note 2{{candidate}}
   } const a, b(a); // expected-error 2{{no matching constructor}}
 }
 
-namespace dr332 { // dr332: dup 577
+//--- dr332: dup 577
+namespace dr332 {
   void f(volatile void); // expected-error {{'void' as parameter must not have type qualifiers}}
   // cxx20_23-warning@-1 {{volatile-qualified parameter type 'volatile void' is deprecated}}
   void g(const void); // expected-error {{'void' as parameter must not have type qualifiers}}
   void h(int n, volatile void); // expected-error {{'void' must be the first and only parameter}}
   // cxx20_23-warning@-1 {{volatile-qualified parameter type 'volatile void' is deprecated}}
 }
 
-namespace dr333 { // dr333: yes
+//--- dr333: yes
+namespace dr333 {
   int n = 0;
   int f(int(n));
   int g((int(n)));
   int h = f(g);
 }
 
-namespace dr334 { // dr334: yes
+//--- dr334: yes
+namespace dr334 {
   template<typename T> void f() {
     T x;
     f((x, 123));
   }
   struct S {
     friend S operator,(S, int);
     friend void f(S);
   };
   template void f<S>();
 }
 
 // dr335: no
 
-namespace dr336 { // dr336: yes
+//--- dr336: yes
+namespace dr336 {
   namespace Pre {
     template<class T1> class A {
       template<class T2> class B {
         template<class T3> void mf1(T3);
         void mf2();
       };
     };
     template<> template<class X> class A<int>::B {};
template<> template<class X> class A<int>::B {
       template<class T> void mf1(T);
     };
     template<> template<> template<class T> void A<int>::B<double>::mf1(T t) {}
     // FIXME: This diagnostic isn't very good.
     template<class Y> template<> void A<Y>::B<double>::mf2() {} // expected-error {{does not refer into a class}}
   }
 }
 
-namespace dr337 { // dr337: yes
+//--- dr337: yes
+namespace dr337 {
   template<typename T> void f(T (*)[1]);
   template<typename T> int &f(...);
 
   struct A { virtual ~A() = 0; };
   int &r = f<A>(0);
 
   // FIXME: The language rules here are completely broken. We cannot determine
   // whether an incomplete type is abstract. See DR1640, which will probably
   // supersede this one and remove this rule.
   struct B;
   int &s = f<B>(0); // expected-error {{of type 'void'}}
   struct B { virtual ~B() = 0; };
 }
 
-namespace dr339 { // dr339: yes
+//--- dr339: yes
+namespace dr339 {
   template <int I> struct A { static const int value = I; };
 
   char xxx(int);
   char (&xxx(float))[2];
 
   template<class T> A<sizeof(xxx((T)0))> f(T) {} // expected-note {{candidate}}
 
   void test() {
namespace dr339 {
 
   template<typename T> A<sizeof(f(T()))> make_A();
 
   int a[conv_int<char>::value ? 1 : -1];
   bool b = conv_int2<char>(A<1>());
   A<1> c = make_A<char>();
 }
 
-namespace dr340 { // dr340: yes
+//--- dr340: yes
+namespace dr340 {
   struct A { A(int); };
   struct B { B(A, A, int); };
   int x, y;
   B b(A(x), A(y), 3);
 }
 
-namespace dr341 { // dr341: sup 1708
+//--- dr341: sup 1708
+namespace dr341 {
   namespace A {
     int n;
     extern "C" int &dr341_a = n; // expected-note {{previous}} expected-note {{declared with C language linkage here}}
   }
   namespace B {
     extern "C" int &dr341_a = dr341_a; // expected-error {{redefinition}}
   }
   extern "C" void dr341_b(); // expected-note {{declared with C language linkage here}}
template<typename T> struct A {
     template<typename U> struct B {};
   };
   // FIXME: In these contexts, the 'template' keyword is optional.
   template<typename T> struct C : public A<T>::B<T> { // expected-error {{use 'template'}}
     C() : A<T>::B<T>() {} // expected-error {{use 'template'}}
   };
 }
 
-namespace dr344 { // dr344: dup 1435
+//--- dr344: dup 1435
+namespace dr344 {
   struct A { inline virtual ~A(); };
   struct B { friend A::~A(); };
 }
 
-namespace dr345 { // dr345: yes
+//--- dr345: yes
+namespace dr345 {
   struct A {
     struct X {};
     int X; // expected-note {{here}}
   };
   struct B {
     struct X {};
   };
   template <class T> void f(T t) { typename T::X x; } // expected-error {{refers to non-type member 'X'}}
   void f(A a, B b) {
     f(b);
     f(a); // expected-note {{instantiation}}
   }
 }
 
 // dr346: na
 
-namespace dr347 { // dr347: yes
+//--- dr347: yes
+namespace dr347 {
   struct base {
     struct nested;
     static int n;
     static void f();
     void g();
   };
 
   struct derived : base {};
 
   struct derived::nested {}; // expected-error {{no struct named 'nested'}}
   int derived::n; // expected-error {{no member named 'n'}}
   void derived::f() {} // expected-error {{does not match any}}
   void derived::g() {} // expected-error {{does not match any}}
 }
 
 // dr348: na
 
-namespace dr349 { // dr349: no
+//--- dr349: no
+namespace dr349 {
   struct A {
     template <class T> operator T ***() {
       int ***p = 0;
       return p; // cxx98_20-error {{cannot initialize return object of type 'const int ***' with an lvalue of type 'int ***'}}
       // cxx23-error@-1 {{cannot initialize return object of type 'const int ***' with an rvalue of type 'int ***'}}
     }
   };
 
namespace dr349 {
 
   // FIXME: This is invalid.
   B b;
   const int *const *const *p2 = b;
 }
 
 // dr351: na
 
-namespace dr352 { // dr352: yes
+//--- dr352: yes
+namespace dr352 {
   namespace example1 {
     namespace A {
       enum E {};
       template<typename R, typename A> void foo(E, R (*)(A)); // expected-note 2{{couldn't infer template argument 'R'}}
     }
 
     template<typename T> void arg(T);
     template<typename T> int arg(T) = delete; // expected-note {{here}} expected-error 0-1{{extension}}
void h(A<1> a1, A<2> a2) {
       g<0>(a1);
       f(a1, a2);
     }
   }
 }
 
 // dr353 needs an IRGen test.
 
-namespace dr354 { // dr354: yes c++11
+//--- dr354: yes c++11
+namespace dr354 {
   // FIXME: Should we allow this in C++98 too?
   struct S {};
 
   template<int*> struct ptr {}; // expected-note 0-4{{here}}
   ptr<0> p0;
   ptr<(int*)0> p1;
   ptr<(float*)0> p2;
   ptr<(int S::*)0> p3;

 }
 
 struct dr355_S; // dr355: yes
 struct ::dr355_S {}; // expected-warning {{extra qualification}}
 namespace dr355 { struct ::dr355_S s; }
 
 // dr356: na
 
-namespace dr357 { // dr357: yes
+//--- dr357: yes
+namespace dr357 {
   template<typename T> struct A {
     void f() const; // expected-note {{const qualified}}
   };
   template<typename T> void A<T>::f() {} // expected-error {{does not match}}
 
   struct B {
     template<typename T> void f();
   };
   template<typename T> void B::f() const {} // expected-error {{does not match}}
 }
 
-namespace dr358 { // dr358: yes
+//--- dr358: yes
+namespace dr358 {
   extern "C" void dr358_f();
   namespace N {
     int var;
     extern "C" void dr358_f() { var = 10; }
   }
 }
 
-namespace dr359 { // dr359: yes
+//--- dr359: yes
+namespace dr359 {
   // Note, the example in the DR is wrong; it doesn't contain an anonymous
   // union.
   struct E {
     union {
       struct {
         int x;
       } s;
     } v;
union {
 
       union { // expected-error {{extension}}
         int u;
       };
     };
   };
 }
 
-namespace dr360 { // dr360: yes
+//--- dr360: yes
+namespace dr360 {
 struct A {
   int foo();
   int bar();
 
 protected:
   int baz();
 };
 
int main() {
   // expected-note@#dr360-bar-using-decl {{declared protected here}}
   int baz = B().baz();
 }
 } // namespace dr360
 
 // dr362: na
 // dr363: na
 
-namespace dr364 { // dr364: yes
+//--- dr364: yes
+namespace dr364 {
   struct S {
     static void f(int);
     void f(char);
   };
 
   void g() {
     S::f('a'); // expected-error {{call to non-static}}
     S::f(0);
   }
 }
 
 #if "foo" // expected-error {{invalid token}} dr366: yes
 #endif
 
-namespace dr367 { // dr367: yes
+//--- dr367: yes
+namespace dr367 {
   // FIXME: These diagnostics are terrible. Don't diagnose an ill-formed global
   // array as being a VLA!
   int a[true ? throw 0 : 4]; // expected-error 2{{variable length array}}
   int b[true ? 4 : throw 0];
   int c[true ? *new int : 4]; // expected-error 2{{variable length array}} expected-note {{read of uninitialized}}
   int d[true ? 4 : *new int];
 #if __cplusplus < 201103L
   // expected-error@-4 2{{variable length array}}
   // expected-error@-3 2{{variable length array}}
 #endif
 }
 
-namespace dr368 { // dr368: yes
+//--- dr368: yes
+namespace dr368 {
   template<typename T, T> struct S {}; // expected-note {{here}}
   template<typename T> int f(S<T, T()> *); // expected-error {{function type}}
   template<typename T> int g(S<T, (T())> *); // cxx98_17-note {{type 'X'}}
   // cxx20_23-note@-1 {{candidate function [with T = dr368::X]}}
   template<typename T> int g(S<T, true ? T() : T()> *); // cxx98_17-note {{type 'X'}}
   // cxx20_23-note@-1 {{candidate function [with T = dr368::X]}}
   struct X {};
   int n = g<X>(0); // cxx98_17-error {{no matching}}
   // cxx20_23-error@-1 {{call to 'g' is ambiguous}}
 }
 
 // dr370: na
 
-namespace dr372 { // dr372: no
+//--- dr372: no
+namespace dr372 {
   namespace example1 {
     template<typename T> struct X {
     protected:
       typedef T Type; // expected-note 2{{protected}}
     };
     template<typename T> struct Y {};
 
     // FIXME: These two are valid; deriving from T1<T> gives Z1 access to
namespace badwolf {
     protected:
       struct B; // expected-note {{here}}
     };
     struct A::B : A {};
     struct C : A::B {}; // expected-error {{protected}}
   }
 }
 
-namespace dr373 { // dr373: 5
+//--- dr373: 5
+namespace dr373 {
   namespace X { int dr373; }
   struct dr373 { // expected-note {{here}}
     void f() {
       using namespace dr373::X;
       int k = dr373; // expected-error {{does not refer to a value}}
 
       namespace Y = dr373::X;
       k = Y::dr373;
     }
   };
 
   struct A { struct B {}; }; // expected-note 2{{here}}
   namespace X = A::B;   // expected-error {{expected namespace name}}
   using namespace A::B; // expected-error {{expected namespace name}}
 }
 
-namespace dr374 { // dr374: yes
+//--- dr374: yes
+namespace dr374 {
   namespace N {
     template<typename T> void f();
     template<typename T> struct A { void f(); };
   }
   template<> void N::f<char>() {}
   template<> void N::A<char>::f() {}
   template<> struct N::A<int> {};
 }
 
 // dr375: dup 345
 // dr376: na
 
-namespace dr377 { // dr377: yes
+//--- dr377: yes
+namespace dr377 {
   enum E { // expected-error {{enumeration values exceed range of largest integer}}
     a = -__LONG_LONG_MAX__ - 1, // expected-error 0-1{{extension}}
     b = 2 * (unsigned long long)__LONG_LONG_MAX__ // expected-error 0-2{{extension}}
   };
 }
 
 // dr378: dup 276
 // dr379: na
 
-namespace dr381 { // dr381: yes
+//--- dr381: yes
+namespace dr381 {
   struct A {
     int a;
   };
   struct B : virtual A {};
   struct C : B {};
   struct D : B {};
   struct E : public C, public D {};
   struct F : public A {};
   void f() {
     E e;
     e.B::a = 0; // expected-error {{ambiguous conversion}}
     F f;
     f.A::a = 1;
   }
 }
 
-namespace dr382 { // dr382: yes c++11
+//--- dr382: yes c++11
+namespace dr382 {
   // FIXME: Should we allow this in C++98 mode?
   struct A { typedef int T; };
   typename A::T t;
   typename dr382::A a;
 #if __cplusplus < 201103L
   // expected-error@-3 {{occurs outside of a template}}
   // expected-error@-3 {{occurs outside of a template}}
 #endif
   typename A b; // expected-error {{expected a qualified name}}
 }
 
-namespace dr383 { // dr383: yes
+//--- dr383: yes
+namespace dr383 {
   struct A { A &operator=(const A&); };
   struct B { ~B(); };
   union C { C &operator=(const C&); };
   union D { ~D(); };
   int check[(__is_pod(A) || __is_pod(B) || __is_pod(C) || __is_pod(D)) ? -1 : 1];
 }
 
-namespace dr384 { // dr384: yes
+//--- dr384: yes
+namespace dr384 {
   namespace N1 {
     template<typename T> struct Base {};
     template<typename T> struct X {
       struct Y : public Base<T> {
         Y operator+(int) const;
       };
       Y f(unsigned i) { return Y() + i; }
     };
   }
 
   namespace N2 {
     struct Z {};
     template<typename T> int *operator+(T, unsigned);
   }
 
   int main() {
     N1::X<N2::Z> v;
     v.f(0);
   }
 }
 
-namespace dr385 { // dr385: yes
+//--- dr385: yes
+namespace dr385 {
   struct A { protected: void f(); };
   struct B : A { using A::f; };
   struct C : A { void g(B b) { b.f(); } };
   void h(B b) { b.f(); }
 
   struct D { int n; }; // expected-note {{member}}
   struct E : protected D {}; // expected-note {{protected}}
   struct F : E { friend int i(E); };
   int i(E e) { return e.n; } // expected-error {{protected member}}
 }
 
-namespace dr387 { // dr387: yes
+//--- dr387: yes
+namespace dr387 {
   namespace old {
     template<typename T> class number {
       number(int); // expected-note 2{{here}}
       friend number gcd(number &x, number &y) {}
     };
 
     void g() {
       number<double> a(3), b(4); // expected-error 2{{private}}
void g() {
       a = gcd(a, b);
       b = gcd(3, 4); // expected-error {{undeclared}}
     }
   }
 }
 
 // FIXME: dr388 needs codegen test
 
-namespace dr389 { // dr389: no
+//--- dr389: no
+namespace dr389 {
   struct S {
     typedef struct {} A;
     typedef enum {} B;
     typedef struct {} const C; // expected-note 0-2{{here}}
     typedef enum {} const D; // expected-note 0-1{{here}}
   };
   template<typename> struct T {};
 
#endif
   }
 
   void local() {
     // FIXME: This is ill-formed.
     extern WithoutLinkage1 withoutLinkageLocal;
   }
 }
 
-namespace dr390 { // dr390: yes
+//--- dr390: yes
+namespace dr390 {
   template<typename T>
   struct A {
     A() { f(); } // expected-warning {{call to pure virt}}
     virtual void f() = 0; // expected-note {{here}}
     virtual ~A() = 0;
   };
   template<typename T> A<T>::~A() { T::error; } // expected-error {{cannot be used prior to}}
   template<typename T> void A<T>::f() { T::error; } // ok, not odr-used
   struct B : A<int> { // expected-note 2{{in instantiation of}}
     void f() {}
   } b;
 }
 
-namespace dr391 { // dr391: yes c++11
+//--- dr391: yes c++11
+namespace dr391 {
   // FIXME: Should this apply to C++98 too?
   class A { A(const A&); }; // expected-note 0-1{{here}}
   A fa();
   const A &a = fa();
 #if __cplusplus < 201103L
   // expected-error@-2 {{C++98 requires an accessible copy constructor}}
 #endif
 
#endif
   };
   C<int> fc();
   const C<int> &c = fc();
 }
 
 // dr392 FIXME write codegen test
 // dr394: na
 
-namespace dr395 { // dr395: yes
+//--- dr395: yes
+namespace dr395 {
   struct S {
     template <typename T, int N>(&operator T())[N]; // expected-error {{cannot specify any part of a return type}}
     template <typename T, int N> operator(T (&)[N])(); // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error +{{}}
     template <typename T> operator T *() const { return 0; }
     template <typename T, typename U> operator T U::*() const { return 0; }
     template <typename T, typename U> operator T (U::*)()() const { return 0; } // expected-error +{{}}
   };
 
namespace dr395 {
 
   struct null2_t {
     template<class T, class U> using ptr_mem_fun_t = T (U::*)(); // expected-error 0-1{{extension}}
     template<class T, class U> operator ptr_mem_fun_t<T, U>() const { return 0; };
   } null2;
   int (S::*q)() = null2;
 }
 
-namespace dr396 { // dr396: yes
+//--- dr396: yes
+namespace dr396 {
   void f() {
     auto int a(); // expected-error {{storage class on function}}
     int (i); // expected-note {{previous}}
     auto int (i); // expected-error {{redefinition}}
 #if __cplusplus >= 201103L
   // expected-error@-4 {{'auto' storage class}} expected-error@-2 {{'auto' storage class}}
 #endif
   }
 }
 
 // dr397: sup 1823
 
-namespace dr398 { // dr398: yes
+//--- dr398: yes
+namespace dr398 {
   namespace example1 {
     struct S {
       static int const I = 42;
     };
     template <int N> struct X {};
     template <typename T> void f(X<T::I> *) {}
     template <typename T> void f(X<T::J> *) {}
     void foo() { f<S>(0); }
void test() {
       f<A>(0); // expected-error {{no matching function}}
       f<B>(0); // expected-error {{no matching function}}
       g<C>(0); // expected-error {{no matching function}}
       h<D>(0); // expected-error {{no matching function}}
     }
   }
 }
 
-namespace dr399 { // dr399: 11
-                  // NB: reuse dr244 test 
+//--- dr399: 11
+// NB: reusing dr244 test
+namespace dr399 { 
   struct B {}; // expected-note {{type 'dr399::B' found by destructor name lookup}}
   struct D : B {};
 
   D D_object;
   typedef B B_alias;
   B* B_ptr = &D_object;
 
   void f() {

clang/test/CXX/drs/dr4xx.cpp

 // RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %clang_cc1 -std=c++23 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 
 // FIXME: __SIZE_TYPE__ expands to 'long long' on some targets.
 __extension__ typedef __SIZE_TYPE__ size_t;
 
 namespace std { struct type_info; }
 
-namespace dr400 { // dr400: yes
+//--- dr400: yes
+namespace dr400 {
   struct A { int a; struct a {}; }; // expected-note 2{{conflicting}} expected-note {{ambiguous}}
   struct B { int a; struct a {}; }; // expected-note 2{{target}} expected-note {{ambiguous}}
   struct C : A, B { using A::a; struct a b; };
   struct D : A, B { using A::a; using B::a; struct a b; }; // expected-error 2{{conflicts}}
   struct E : A, B { struct a b; }; // expected-error {{found in multiple base classes}}
 }
 
-namespace dr401 { // dr401: yes
+//--- dr401: yes
+namespace dr401 {
   template<class T, class U = typename T::type> class A : public T {}; // expected-error {{protected}} expected-error 2{{private}}
 
   class B {
   protected:
     typedef int type; // expected-note {{protected}}
 #if __cplusplus == 199711L
     // expected-note@-2 {{protected}}
 #endif

 #if __cplusplus < 201103L
   // expected-error@-3 0-1{{extension}} expected-error@-3 {{protected}} expected-note@-3 {{instantiation}}
   // expected-note@-3 {{substituting}}
 #else
   // expected-error@-5 {{no matching}} expected-note@-6 {{protected}}
 #endif
 }
 
-namespace dr403 { // dr403: yes
+//--- dr403: yes
+namespace dr403 {
   namespace A {
     struct S {};
     int f(void*);
   }
   template<typename T> struct X {};
   typedef struct X<A::S>::X XS;
   XS *p;
   int k = f(p); // ok, finds A::f, even though type XS is a typedef-name
                 // referring to an elaborated-type-specifier naming a
                 // injected-class-name, which is about as far from a
                 // template-id as we can make it.
 }
 
 // dr404: na
 // (NB: also sup 594)
 
-namespace dr405 { // dr405: yes
-                  // NB: also dup 218
+//--- dr405: yes
+namespace dr405 {
   namespace A {
     struct S {};
     void f(S);
   }
   namespace B {
     struct S {};
     void f(S);
   }
namespace dr405 {
 
   namespace E {
     struct S {};
     struct f { f(S); };
   }
   void testE(E::S es) { f(es); } // expected-error {{undeclared identifier}}
 }
 
-namespace dr406 { // dr406: yes
+//--- dr406: yes
+namespace dr406 {
   typedef struct {
     static int n; // expected-error {{static data member 'n' not allowed in anonymous struct}}
   } A;
   typedef union {
     static int n; // expected-error {{static data member 'n' not allowed in anonymous union}}
   } B;
 }
 
-namespace dr407 { // dr407: 3.8
-                  // NB: reused by dr1894 and dr2199
+//--- dr407: 3.8
+namespace dr407 {
   struct S;
   typedef struct S S;
   void f() {
     struct S *p;
     {
       typedef struct S S; // expected-note {{here}}
       struct S *p; // expected-error {{typedef 'S' cannot be referenced with a struct specifier}}
     }
namespace UsingDir {
     namespace H {
       using namespace F;
       using namespace A;
       struct S s;
     }
   }
 }
 
-namespace dr408 { // dr408: 3.4
+//--- dr408: 3.4
+namespace dr408 {
   template<int N> void g() { int arr[N != 1 ? 1 : -1]; }
   template<> void g<2>() { }
 
   template<typename T> struct S {
     static int i[];
     void f();
   };
   template<typename T> int S<T>::i[] = { 1 };
namespace dr408 {
   template<typename T> int R<T>::arr[1];
   template<typename T> void R<T>::f() {
     int arr[sizeof(arr) != sizeof(int) ? 1 : -1];
   }
   template<> int R<int>::arr[2];
   template void R<int>::f();
 }
 
-namespace dr409 { // dr409: yes
+//--- dr409: yes
+namespace dr409 {
   template<typename T> struct A {
     typedef int B;
     B b1;
     A::B b2;
     A<T>::B b3;
     A<T*>::B b4;
 #if __cplusplus <= 201703L
     // expected-error@-2 {{implicit 'typename' is a C++20 extension}}
 #endif
   };
 }
 
-namespace dr410 { // dr410: no
+//--- dr410: no
+namespace dr410 {
   template<class T> void f(T);
   void g(int);
   namespace M {
     template<class T> void h(T);
     template<class T> void i(T);
     struct A {
       friend void f<>(int);
       friend void h<>(int);
namespace M {
     template<> void i(int) { A::z(); }
   }
   template<> void f(int) { M::A::z(); }
   void g(int) { M::A::z(); } // expected-error {{private}}
 }
 
 // dr412 is in its own file.
 
-namespace dr413 { // dr413: yes
+//--- dr413: yes
+namespace dr413 {
   struct S {
     int a;
     int : 17;
     int b;
   };
   S s = { 1, 2, 3 }; // expected-error {{excess elements}}
 
   struct E {};
   struct T { // expected-note {{here}}
     int a;
     E e;
     int b;
   };
   T t1 = { 1, {}, 2 };
   T t2 = { 1, 2 }; // expected-error {{aggregate with no elements requires explicit braces}}
 }
 
-namespace dr414 { // dr414: dup 305
+//--- dr414: dup 305
+namespace dr414 {
   struct X {};
   void f() {
     X x;
     struct X {};
     x.~X();
   }
 }
 
-namespace dr415 { // dr415: yes
+//--- dr415: yes
+namespace dr415 {
   template<typename T> void f(T, ...) { T::error; }
   void f(int, int);
   void g() { f(0, 0); } // ok
 }
 
-namespace dr416 { // dr416: yes
+//--- dr416: yes
+namespace dr416 {
   extern struct A a;
   int &operator+(const A&, const A&);
   int &k = a + a;
   struct A { float &operator+(A&); };
   float &f = a + a;
 }
 
-namespace dr417 { // dr417: no
+//--- dr417: no
+namespace dr417 {
   struct A;
   struct dr417::A {}; // expected-warning {{extra qualification}}
   struct B { struct X; };
   struct C : B {};
   struct C::X {}; // expected-error {{no struct named 'X' in 'dr417::C'}}
   struct B::X { struct Y; };
   struct C::X::Y {}; // ok!
   namespace N {
namespace dr417 {
   struct G;
   using N::H;
   namespace M {
     struct dr417::G {}; // expected-error {{namespace 'M' does not enclose}}
     struct dr417::H {}; // expected-error {{namespace 'M' does not enclose}}
   }
 }
 
-namespace dr418 { // dr418: no
+//--- dr418: no
+namespace dr418 {
 namespace example1 {
 void f1(int, int = 0);
 void f1(int = 0, int);
 
 void g() { f1(); }
 } // namespace example1
 
 namespace example2 {

 
 void use() {
   f(3);
   f(); // FIXME: this should fail
 }
 } // namespace example3
 } // namespace dr418
 
-namespace dr420 { // dr420: yes
+//--- dr420: yes
+namespace dr420 {
   template<typename T> struct ptr {
     T *operator->() const;
     T &operator*() const;
   };
   template<typename T, typename P> void test(P p) {
     p->~T();
     p->T::~T();
     (*p).~T();
void test4(int *p, ptr<int> q) {
     p->template id<int>::~id<int>(); // OK since dr2292
     q->template id<int>::~id<int>(); // OK since dr2292
     p->A::template id<int>::~id<int>();
     q->A::template id<int>::~id<int>();
   }
 #endif
 }
 
-namespace dr421 { // dr421: yes
+//--- dr421: yes
+namespace dr421 {
   struct X { X(); int n; int &r; };
   int *p = &X().n; // expected-error-re {{{{taking the address of a temporary|cannot take the address of an rvalue}}}}
   int *q = &X().r;
 }
 
-namespace dr422 { // dr422: yes
+//--- dr422: yes
+namespace dr422 {
   template<typename T, typename U> void f() {
     typedef T type; // expected-note {{prev}}
     typedef U type; // expected-error {{redef}}
   }
   template void f<int, int>();
   template void f<int, char>(); // expected-note {{instantiation}}
 }
 
-namespace dr423 { // dr423: yes
+//--- dr423: yes
+namespace dr423 {
   template<typename T> struct X { operator T&(); };
   void f(X<int> x) { x += 1; }
 }
 
-namespace dr424 { // dr424: yes
+//--- dr424: yes
+namespace dr424 {
   struct A {
     typedef int N; // expected-note {{previous}}
     typedef int N; // expected-error {{redefinition}}
 
     struct X;
     typedef X X; // expected-note {{previous}}
     struct X {};
 
     struct X *p;
     struct A::X *q;
     X *r;
 
     typedef X X; // expected-error {{redefinition}}
   };
   struct B {
     typedef int N;
   };
   struct C : B {
     typedef int N; // expected-note {{previous}}
     typedef int N; // expected-error {{redefinition}}
   };
 }
 
-namespace dr425 { // dr425: yes
+//--- dr425: yes
+namespace dr425 {
   struct A { template<typename T> operator T() const; } a;
   float f = 1.0f * a; // expected-error {{ambiguous}} expected-note 5+{{built-in candidate}}
 
   template<typename T> struct is_float;
   template<> struct is_float<float> { typedef void type; };
 
   struct B {
     template<typename T, typename U = typename is_float<T>::type> operator T() const; // expected-error 0-1{{extension}}
   } b;
   float g = 1.0f * b; // ok
 }
 
-namespace dr427 { // dr427: yes
+//--- dr427: yes
+namespace dr427 {
   struct B {};
   struct D : public B {
     D(B &) = delete; // expected-error 0-1{{extension}} expected-note {{deleted}}
   };
 
   extern D d1;
   B &b = d1;
   const D &d2 = static_cast<const D&>(b);
   const D &d3 = (const D&)b;
   const D &d4(b); // expected-error {{deleted}}
 }
 
-namespace dr428 { // dr428: yes
+//--- dr428: yes
+namespace dr428 {
   template<typename T> T make();
   extern struct X x; // expected-note 5{{forward declaration}}
   void f() {
     throw void(); // expected-error {{cannot throw}}
     throw make<void*>();
     throw make<const volatile void*>();
     throw x; // expected-error {{cannot throw}}
     throw make<X&>(); // expected-error {{cannot throw}}
     throw make<X*>(); // expected-error {{cannot throw}}
     throw make<const volatile X&>(); // expected-error {{cannot throw}}
     throw make<const volatile X*>(); // expected-error {{cannot throw}}
   }
 }
 
-namespace dr429 { // dr429: yes c++11
+//--- dr429: yes c++11
+namespace dr429 {
   // FIXME: This rule is obviously intended to apply to C++98 as well.
   struct A {
     static void *operator new(size_t, size_t);
     static void operator delete(void*, size_t);
   } *a = new (0) A;
 #if __cplusplus >= 201103L
   // expected-error@-2 {{'new' expression with placement arguments refers to non-placement 'operator delete'}}
   // expected-note@-4 {{here}}
 #endif
   struct B {
     static void *operator new(size_t, size_t);
     static void operator delete(void*);
     static void operator delete(void*, size_t);
   } *b = new (0) B; // ok, second delete is not a non-placement deallocation function
 }
 
-namespace dr430 { // dr430: yes c++11
+//--- dr430: yes c++11
+namespace dr430 {
   // resolved by n2239
   // FIXME: This should apply in C++98 too.
   void f(int n) {
     int a[] = { n++, n++, n++ };
 #if __cplusplus < 201103L
     // expected-warning@-2 {{multiple unsequenced modifications to 'n'}}
 #endif
   }
 }
 
-namespace dr431 { // dr431: yes
+//--- dr431: yes
+namespace dr431 {
   struct A {
     template<typename T> T *get();
     template<typename T> struct B {
       template<typename U> U *get();
     };
   };
 
   template<typename T> void f(A a) {
template<typename T> void f(A a) {
     b->A::B<T>::get<T>(); // expected-error {{use 'template'}}
     b->A::B<T>::template get<T>();
     A::B<T> *c = a.get<A::B<T> >();
     c->get<int>(); // expected-error {{use 'template'}}
     c->template get<int>();
   }
 }
 
-namespace dr432 { // dr432: yes
+//--- dr432: yes
+namespace dr432 {
   template<typename T> struct A {};
   template<typename T> struct B : A<B> {}; // expected-error {{requires template arguments}} expected-note {{declared}}
   template<typename T> struct C : A<C<T> > {};
 #if __cplusplus >= 201103L
   template<typename T> struct D : decltype(A<D>()) {}; // expected-error {{requires template arguments}} expected-note {{declared}}
 #endif
 }
 
-namespace dr433 { // dr433: yes
+//--- dr433: yes
+namespace dr433 {
   template<class T> struct S {
     void f(union U*);
   };
   U *p;
   template<class T> void S<T>::f(union U*) {}
 
   S<int> s;
 }
 
-namespace dr434 { // dr434: sup 2352
+//--- dr434: sup 2352
+namespace dr434 {
   void f() {
     const int ci = 0;
     int *pi = 0;
     const int *&rpci = pi; // expected-error {{incompatible qualifiers}}
     const int * const &rcpci = pi; // OK
     rpci = &ci;
     *pi = 1;
   }
 
 #if __cplusplus >= 201103L
   int *pi = 0;
   const int * const &rcpci = pi;
   static_assert(&rcpci == &pi, "");
 #endif
 }
 
 // dr435: na
 
-namespace dr436 { // dr436: yes
+//--- dr436: yes
+namespace dr436 {
   enum E { f }; // expected-note {{previous}}
   void f(); // expected-error {{redefinition}}
 }
 
-namespace dr437 { // dr437: sup 1308
+//--- dr437: sup 1308
+namespace dr437 {
   // This is superseded by 1308, which is in turn superseded by 1330,
   // which restores this rule.
   template<typename U> struct T : U {};
   struct S {
     void f() throw(S);
 #if __cplusplus > 201402L
     // expected-error@-2 {{ISO C++17 does not allow}} expected-note@-2 {{use 'noexcept}}
 #endif

 }
 
 // dr438 FIXME write a codegen test
 // dr439 FIXME write a codegen test
 // dr441 FIXME write a codegen test
 // dr442: sup 348
 // dr443: na
 
-namespace dr444 { // dr444: yes
+//--- dr444: yes
+namespace dr444 {
   struct D;
   struct B {                    // expected-note {{candidate function (the implicit copy}} expected-note 0-1 {{implicit move}}
     D &operator=(D &) = delete; // expected-error 0-1{{extension}} expected-note {{deleted}}
   };
   struct D : B { // expected-note {{candidate function (the implicit copy}} expected-note 0-1 {{implicit move}}
     using B::operator=;
   } extern d;
   void f() {
     d = d; // expected-error {{deleted}}
   }
 }
 
-namespace dr445 { // dr445: yes
+//--- dr445: yes
+namespace dr445 {
   class A { void f(); }; // expected-note {{private}}
   struct B {
     friend void A::f(); // expected-error {{private}}
   };
 }
 
-namespace dr446 { // dr446: yes
+//--- dr446: yes
+namespace dr446 {
   struct C;
   struct A {
     A();
     A(const A&) = delete; // expected-error 0-1{{extension}} expected-note +{{deleted}}
     A(const C&);
   };
   struct C : A {};
   void f(A a, bool b, C c) {

 #endif
     b ? A() : C();
 #if __cplusplus <= 201402L
     // expected-error@-2 {{deleted}}
 #endif
   }
 }
 
-namespace dr447 { // dr447: yes
+//--- dr447: yes
+namespace dr447 {
   struct A { int n; int a[4]; };
   template<int> struct U {
     typedef int type;
     template<typename V> static void h();
   };
   template<typename T> U<sizeof(T)> g(T);
   template<typename T, int N> void f(int n) {
     // ok, not type dependent
     g(__builtin_offsetof(A, n)).h<int>();
     g(__builtin_offsetof(T, n)).h<int>();
     // value dependent if first argument is a dependent type
     U<__builtin_offsetof(A, n)>::type a;
     U<__builtin_offsetof(T, n)>::type b; // expected-error +{{}} expected-warning 0+{{}}
     // as an extension, we allow the member-designator to include array indices
     g(__builtin_offsetof(A, a[0])).h<int>();
     g(__builtin_offsetof(A, a[N])).h<int>();
     U<__builtin_offsetof(A, a[0])>::type c;
     U<__builtin_offsetof(A, a[N])>::type d; // expected-error +{{}} expected-warning 0+{{}}
   }
 }
 
-namespace dr448 { // dr448: yes
+//--- dr448: yes
+namespace dr448 {
   template<typename T = int> void f(int); // expected-error 0-1{{extension}} expected-note {{no known conversion}}
   template<typename T> void g(T t) {
     f<T>(t); // expected-error {{neither visible in the template definition nor found by argument-dependent lookup}}
     dr448::f(t); // expected-error {{no matching function}}
   }
   template<typename T> void f(T); // expected-note {{should be declared prior to the call site}}
   namespace HideFromADL { struct X {}; }
   template void g(int); // ok
   template void g(HideFromADL::X); // expected-note {{instantiation of}}
 }
 
 // dr449: na
 
-namespace dr450 { // dr450: yes
+//--- dr450: yes
+namespace dr450 {
   typedef int A[3];
   void f1(const A &);
   void f2(A &); // expected-note +{{not viable}}
   struct S { A n; };
   void g() {
     f1(S().n);
     f2(S().n); // expected-error {{no match}}}
   }
 #if __cplusplus >= 201103L
   void h() {
     f1(A{});
     f2(A{}); // expected-error {{no match}}
   }
 #endif
 }
 
-namespace dr451 { // dr451: yes
+//--- dr451: yes
+namespace dr451 {
   const int a = 1 / 0; // expected-warning {{undefined}}
   const int b = 1 / 0; // expected-warning {{undefined}} expected-note {{here}} expected-note 0-1{{division by zero}}
   int arr[b]; // expected-error +{{variable length arr}} expected-note {{initializer of 'b' is not a constant}}
 }
 
-namespace dr452 { // dr452: yes
+//--- dr452: yes
+namespace dr452 {
   struct A {
     int a, b, c;
     A *p;
     int f();
     A() : a(f()), b(this->f() + a), c(this->a), p(this) {}
   };
 }
 
 // dr454 FIXME write a codegen test
 
-namespace dr456 { // dr456: yes
+//--- dr456: yes
+namespace dr456 {
   // sup 903 c++11
   const int null = 0;
   void *p = null;
 #if __cplusplus >= 201103L
   // expected-error@-2 {{cannot initialize}}
 #else
   // expected-warning@-4 {{null}}
 #endif
 
   const bool f = false;
   void *q = f;
 #if __cplusplus >= 201103L
   // expected-error@-2 {{cannot initialize}}
 #else
   // expected-warning@-4 {{null}}
 #endif
 }
 
-namespace dr457 { // dr457: yes
+//--- dr457: yes
+namespace dr457 {
   const int a = 1;
   const volatile int b = 1;
   int ax[a];
   int bx[b]; // expected-error +{{variable length array}} expected-note {{read of volatile}}
 
   enum E {
     ea = a,
     eb = b // expected-error {{constant}} expected-note {{read of volatile-qualified}}
   };
 }
 
-namespace dr458 { // dr458: 11
+//--- dr458: 11
+namespace dr458 {
   struct A {
     int T;
     int f();
     template<typename> int g();
   };
 
   template<typename> struct B : A {
     int f();
int B<T>::g() {
     return T;
   }
   template<typename U> template<typename T> // expected-note {{declared here}}
   int B<U>::h() {
     return T; // expected-error {{'T' does not refer to a value}}
   }
 }
 
-namespace dr460 { // dr460: yes
+//--- dr460: yes
+namespace dr460 {
   namespace X { namespace Q { int n; } }
   namespace Y {
     using X; // expected-error {{requires a qualified name}}
     using dr460::X; // expected-error {{cannot refer to a namespace}}
     using X::Q; // expected-error {{cannot refer to a namespace}}
   }
 }
 
 // dr461: na
 // dr462 FIXME write a codegen test
 // dr463: na
 // dr464: na
 // dr465: na
 
-namespace dr466 { // dr466: no
+//--- dr466: no
+namespace dr466 {
   typedef int I;
   typedef const int CI;
   typedef volatile int VI;
   void f(int *a, CI *b, VI *c) {
     a->~I();
     a->~CI();
     a->~VI();
     a->I::~I();
void f(int *a, CI *b, VI *c) {
     c->~CI();
     c->~VI();
     c->I::~I();
     c->CI::~CI();
     c->VI::~VI();
   }
 }
 
-namespace dr467 { // dr467: yes
+//--- dr467: yes
+namespace dr467 {
   int stuff();
 
   int f() {
     static bool done;
     if (done)
       goto later;
     static int k = stuff();
     done = true;
   later:
     return k;
   }
   int g() {
     goto later; // expected-error {{cannot jump}}
     int k = stuff(); // expected-note {{bypasses variable initialization}}
   later:
     return k;
   }
 }
 
-namespace dr468 { // dr468: yes c++11
+//--- dr468: yes c++11
+namespace dr468 {
   // FIXME: Should we allow this in C++98 too?
   template<typename> struct A {
     template<typename> struct B {
       static int C;
     };
   };
   int k = dr468::template A<int>::template B<char>::C;
 #if __cplusplus < 201103L
   // expected-error@-2 2{{'template' keyword outside of a template}}
 #endif
 }
 
-namespace dr469 { // dr469: no
+//--- dr469: no
+namespace dr469 {
   template<typename T> struct X; // expected-note {{here}}
   template<typename T> struct X<const T> {};
   X<int&> x; // expected-error {{undefined}}
 }
 
-namespace dr470 { // dr470: yes
+//--- dr470: yes
+namespace dr470 {
   template<typename T> struct A {
     struct B {};
   };
   template<typename T> struct C {
   };
 
   template struct A<int>; // expected-note {{previous}}
   template struct A<int>::B; // expected-error {{duplicate explicit instantiation}}
 
   // ok, instantiating C<char> doesn't instantiate base class members.
   template struct A<char>;
   template struct C<char>;
 }
 
-namespace dr471 { // dr471: yes
+//--- dr471: yes
+namespace dr471 {
   struct A { int n; };
   struct B : private virtual A {};
   struct C : protected virtual A {};
   struct D : B, C { int f() { return n; } };
   struct E : private virtual A {
     using A::n;
   };
   struct F : E, B { int f() { return n; } };
   struct G : virtual A {
   private:
     using A::n; // expected-note {{here}}
   };
   struct H : B, G { int f() { return n; } }; // expected-error {{private}}
 }
 
-namespace dr474 { // dr474: yes
+//--- dr474: yes
+namespace dr474 {
   namespace N {
     struct S {
       void f();
     };
   }
   void N::S::f() {
     void g(); // expected-note {{previous}}
   }
   int g();
   namespace N {
     int g(); // expected-error {{cannot be overloaded}}
   }
 }
 
 // dr475 FIXME write a codegen test
 
-namespace dr477 { // dr477: 3.5
+//--- dr477: 3.5
+namespace dr477 {
   struct A {
     explicit A();
     virtual void f();
   };
   struct B {
     friend explicit A::A(); // expected-error {{'explicit' is invalid in friend declarations}}
     friend virtual void A::f(); // expected-error {{'virtual' is invalid in friend declarations}}
   };
   explicit A::A() {} // expected-error {{can only be specified inside the class definition}}
   virtual void A::f() {} // expected-error {{can only be specified inside the class definition}}
 }
 
-namespace dr478 { // dr478: yes
+//--- dr478: yes
+namespace dr478 {
   struct A { virtual void f() = 0; }; // expected-note {{unimplemented}}
   void f(A *a);
   void f(A a[10]); // expected-error {{array of abstract class type}}
 }
 
-namespace dr479 { // dr479: yes
+//--- dr479: yes
+namespace dr479 {
   struct S {
     S();
   private:
     S(const S&); // expected-note +{{here}}
     ~S(); // expected-note +{{here}}
   };
   void f() {
     throw S();
try {
       g();
     } catch (S s) {
       // expected-error@-1 {{calling a private constructor}}
       // expected-error@-2 {{variable of type 'S' has private destructor}}
     }
   }
 }
 
-namespace dr480 { // dr480: yes
+//--- dr480: yes
+namespace dr480 {
   struct A { int n; };
   struct B : A {};
   struct C : virtual B {};
   struct D : C {};
 
   int A::*a = &A::n;
   int D::*b = a; // expected-error {{virtual base}}
 
   extern int D::*c;
   int A::*d = static_cast<int A::*>(c); // expected-error {{virtual base}}
 
   D *e;
   A *f = e;
   D *g = static_cast<D*>(f); // expected-error {{virtual base}}
 
   extern D &i;
   A &j = i;
   D &k = static_cast<D&>(j); // expected-error {{virtual base}}
 }
 
-namespace dr481 { // dr481: yes
+//--- dr481: yes
+namespace dr481 {
   template<class T, T U> class A { T *x; };
   T *x; // expected-error {{unknown type}}
 
   template<class T *U> class B { T *x; };
   T *y; // ok
 
   struct C {
     template<class T> void f(class D *p);
namespace dr481 {
   H *q;
 
   typedef int N;
   template<N X, typename N, template<N Y> class T> struct I;
   template<char*> struct J;
   I<123, char*, J> *j;
 }
 
-namespace dr482 { // dr482: 3.5
+//--- dr482: 3.5
+namespace dr482 {
   extern int a;
   void f();
 
   int dr482::a = 0; // expected-warning {{extra qualification}}
   void dr482::f() {} // expected-warning {{extra qualification}}
 
   inline namespace X { // expected-error 0-1{{C++11 feature}}
     extern int b;

 
 #if __cplusplus >= 201103L
     enum class C;
     enum class A::C {}; // expected-error {{extra qualification}}
 #endif
   };
 }
 
-namespace dr483 { // dr483: yes
+//--- dr483: yes
+namespace dr483 {
   namespace climits {
     int check1[__SCHAR_MAX__ >= 127 ? 1 : -1];
     int check2[__SHRT_MAX__ >= 32767 ? 1 : -1];
     int check3[__INT_MAX__ >= 32767 ? 1 : -1];
     int check4[__LONG_MAX__ >= 2147483647 ? 1 : -1];
     int check5[__LONG_LONG_MAX__ >= 9223372036854775807 ? 1 : -1];
 #if __cplusplus < 201103L
     // expected-error@-2 1+{{extension}}
 #endif
   }
   namespace cstdint {
     int check1[__PTRDIFF_WIDTH__ >= 16 ? 1 : -1];
     int check2[__SIG_ATOMIC_WIDTH__ >= 8 ? 1 : -1];
     int check3[__SIZE_WIDTH__ >= 16 ? 1 : -1];
     int check4[__WCHAR_WIDTH__ >= 8 ? 1 : -1];
     int check5[__WINT_WIDTH__ >= 16 ? 1 : -1];
   }
 }
 
-namespace dr484 { // dr484: yes
+//--- dr484: yes
+namespace dr484 {
   struct A {
     A();
     void f();
   };
   typedef const A CA;
   void CA::f() {
     this->~CA();
     this->CA::~A();
namespace dr484 {
   }
   struct N::DT {}; // expected-error {{conflicts with typedef}}
 
   typedef struct {
     S(); // expected-error {{a type specifier is required}}
   } S;
 }
 
-namespace dr485 { // dr485: yes
+//--- dr485: yes
+namespace dr485 {
   namespace N {
     struct S {};
     int operator+(S, S);
     template<typename T> int f(S);
   }
   template<typename T> int f();
 
   N::S s;
   int a = operator+(s, s);
   int b = f<int>(s);
 }
 
-namespace dr486 { // dr486: yes
+//--- dr486: yes
+namespace dr486 {
   template<typename T> T f(T *); // expected-note 2{{substitution failure}}
   int &f(...);
 
   void g();
   int n[10];
 
   void h() {
     int &a = f(&g);
     int &b = f(&n);
     f<void()>(&g); // expected-error {{no match}}
     f<int[10]>(&n); // expected-error {{no match}}
   }
 }
 
-namespace dr487 { // dr487: yes
+//--- dr487: yes
+namespace dr487 {
   enum E { e };
   int operator+(int, E); // expected-note 0-1{{here}}
   int i[4 + e]; // expected-error 2{{variable length array}} expected-note 0-1{{non-constexpr}}
 }
 
-namespace dr488 { // dr488: yes c++11
+//--- dr488: yes c++11
+namespace dr488 {
   template <typename T> void f(T);
   void f(int);
   void g() {
     // FIXME: It seems CWG thought this should be a SFINAE failure prior to
     // allowing local types as template arguments. In C++98, we should either
     // allow local types as template arguments or treat this as a SFINAE
     // failure.
     enum E { e };
     f(e);
 #if __cplusplus < 201103L
     // expected-error@-2 {{local type}}
 #endif
   }
 }
 
 // dr489: na
 
-namespace dr490 { // dr490: yes
+//--- dr490: yes
+namespace dr490 {
   template<typename T> struct X {};
 
   struct A {
     typedef int T;
     struct K {}; // expected-note {{declared}}
 
     int f(T);
     int g(T);
struct B {
     friend int A::k<U>();
 
     // A conversion-type-id in a conversion-function-id is always looked up in
     // the class of the conversion function first.
     friend A::operator X<T>();
   };
 }
 
-namespace dr491 { // dr491: dup 413
+//--- dr491: dup 413
+namespace dr491 {
   struct A {} a, b[3] = { a, {} };
   A c[2] = { a, {}, b[1] }; // expected-error {{excess elements}}
 }
 
 // dr492 FIXME write a codegen test
 
-namespace dr493 { // dr493: dup 976
+//--- dr493: dup 976
+namespace dr493 {
   struct X {
     template <class T> operator const T &() const;
   };
   void f() {
     if (X()) {
     }
   }
 }
 
-namespace dr494 { // dr494: dup 372
+//--- dr494: dup 372
+namespace dr494 {
   class A {
     class B {};
     friend class C;
   };
   class C : A::B {
     A::B x;
     class D : A::B {
       A::B y;
     };
   };
 }
 
-namespace dr495 { // dr495: 3.5
+//--- dr495: 3.5
+namespace dr495 {
   template<typename T>
   struct S {
     operator int() { return T::error; }
     template<typename U> operator U();
   };
   S<int> s;
   long n = s;
 
   template<typename T>
   struct S2 {
     template<typename U> operator U();
     operator int() { return T::error; }
   };
   S2<int> s2;
   long n2 = s2;
 }
 
-namespace dr496 { // dr496: sup 2094
+//--- dr496: sup 2094
+namespace dr496 {
   struct A { int n; };
   struct B { volatile int n; };
   int check1[ __is_trivially_copyable(const int) ? 1 : -1];
   // This checks the dr2094 behavior, not dr496
   int check2[ __is_trivially_copyable(volatile int) ? 1 : -1];
   int check3[ __is_trivially_constructible(A, const A&) ? 1 : -1];
   int check4[ __is_trivially_constructible(B, const B&) ? 1 : -1];
   int check5[ __is_trivially_assignable(A, const A&) ? 1 : -1];
   int check6[ __is_trivially_assignable(B, const B&) ? 1 : -1];
 }
 
-namespace dr497 { // dr497: sup 253
+//--- dr497: sup 253
+namespace dr497 {
   void before() {
     struct S {
       mutable int i;
     };
     const S cs;
     int S::*pm = &S::i;
     cs.*pm = 88; // expected-error {{not assignable}}
   }
 
   void after() {
     struct S {
       S() : i(0) {}
       mutable int i;
     };
     const S cs;
     int S::*pm = &S::i;
     cs.*pm = 88; // expected-error {{not assignable}}
   }
 }
 
-namespace dr499 { // dr499: yes
+//--- dr499: yes
+namespace dr499 {
   extern char str[];
   void f() { throw str; }
 }

clang/test/CXX/drs/dr5xx.cpp

 void *operator new(size_t); // expected-error 0-1{{missing exception spec}} expected-note{{candidate}}
 #if __cplusplus > 201402L
 namespace std {
   enum class align_val_t : size_t {};
 }
 void *operator new(size_t, std::align_val_t); // expected-note{{candidate}}
 #endif
 
-namespace dr500 { // dr500: dup 372
+//--- dr500: dup 372
+namespace dr500 {
   class D;
   class A {
     class B;
     class C;
     friend class D;
   };
   class A::B {};
   class A::C : public A::B {};
   class D : public A::B {};
 }
 
-namespace dr501 { // dr501: yes
+//--- dr501: yes
+namespace dr501 {
   struct A {
     friend void f() {}
     void g() {
       void (*p)() = &f; // expected-error {{undeclared identifier}}
     }
   };
 }
 
-namespace dr502 { // dr502: yes
+//--- dr502: yes
+namespace dr502 {
   struct Q {};
   template<typename T> struct A {
     enum E { e = 1 };
     void q1() { f(e); }
     void q2() { Q arr[sizeof(E)]; f(arr); }
     void q3() { Q arr[e]; f(arr); }
     void sanity() { Q arr[1]; f(arr); } // expected-error {{undeclared identifier 'f'}}
   };
   int f(A<int>::E);
   template<int N> int f(Q (&)[N]);
   template struct A<int>;
 }
 
-namespace dr505 { // dr505: yes
+//--- dr505: yes
+namespace dr505 {
   const char *exts = "\e\(\{\[\%"; // expected-error 5{{use of non-standard escape}}
   const char *unknown = "\Q"; // expected-error {{unknown escape sequence}}
 }
 
-namespace dr506 { // dr506: yes
+//--- dr506: yes
+namespace dr506 {
   struct NonPod { ~NonPod(); };
   void f(...);
   void g(NonPod np) { f(np); } // expected-error {{cannot pass}}
 }
 
 // FIXME: Add tests here once DR260 is resolved.
 // dr507: dup 260
 
 // dr508: na
 // dr509: na
 // dr510: na
 
-namespace dr512 { // dr512: yes
+//--- dr512: yes
+namespace dr512 {
   struct A {
     A(int);
   };
   union U { A a; };
 #if __cplusplus < 201103L
   // expected-error@-2 {{has a non-trivial default constructor}}
   // expected-note@-6 {{no default constructor}}
   // expected-note@-6 {{suppressed by user-declared constructor}}
 #endif
 }
 
 // dr513: na
 
-namespace dr514 { // dr514: yes
+//--- dr514: yes
+namespace dr514 {
   namespace A { extern int x, y; }
   int A::x = y;
 }
 
-namespace dr515 { // dr515: sup 1017
+//--- dr515: sup 1017
+namespace dr515 {
   // FIXME: dr1017 reverses the wording of dr515, but the current draft has
   // dr515's wording, with a different fix for dr1017.
 
   struct X { int n; };
   template<typename T> struct Y : T {
     int f() { return X::n; }
   };
   int k = Y<X>().f();
 
   struct A { int a; };
   struct B { void f() { int k = sizeof(A::a); } };
 #if __cplusplus < 201103L
   // expected-error@-2 {{invalid use of non-static data member}}
 #endif
 }
 
 // dr516: na
 
-namespace dr517 { // dr517: no
+//--- dr517: no
+namespace dr517 {
   // This is NDR, but we should diagnose it anyway.
   template<typename T> struct S {};
   template<typename T> int v = 0; // expected-error 0-1{{extension}}
 
   template struct S<int*>;
   template int v<int*>;
 
   S<char&> s;
   int k = v<char&>;
 
   // FIXME: These are both ill-formed.
   template<typename T> struct S<T*> {};
   template<typename T> int v<T*> = 0; // expected-error 0-1{{extension}}
 
   // FIXME: These are both ill-formed.
   template<typename T> struct S<T&> {};
   template<typename T> int v<T&> = 0; // expected-error 0-1{{extension}}
 }
 
-namespace dr518 { // dr518: yes c++11
+//--- dr518: yes c++11
+namespace dr518 {
   enum E { e, };
 #if __cplusplus < 201103L
   // expected-error@-2 {{C++11 extension}}
 #endif
 }
 
-namespace dr519 { // dr519: yes
+//--- dr519: yes
+namespace dr519 {
 // FIXME: Add a codegen test.
 #if __cplusplus >= 201103L
 #define fold(x) (__builtin_constant_p(x) ? (x) : (x))
   int test[fold((int*)(void*)0) ? -1 : 1];
 #undef fold
 #endif
 }
 
 // dr520: na
 
 // dr521: no
 // FIXME: The wording here is broken. It's not reasonable to expect a
 // diagnostic here. Once the relevant DR gets a number, mark this as a dup.
 
-namespace dr522 { // dr522: yes
+//--- dr522: yes
+namespace dr522 {
   struct S {};
   template<typename T> void b1(volatile T &);
   template<typename T> void b2(volatile T * const *);
   template<typename T> void b2(volatile T * const S::*);
   template<typename T> void b2(volatile T * const S::* const *);
   template<typename T> void b2a(volatile T *S::* const *); // expected-note {{candidate template ignored: deduced type 'volatile int *dr522::S::*const *' of 1st parameter does not match adjusted type 'int *dr522::S::**' of argument}}
 
   template<typename T> struct Base {};
void test(int n, const int cn, int **p, int *S::*pm) {
     b2(a);
     b2(am);
     b2a(am); // expected-error {{no matching function}}
     b3(d);
     b3(cd);
   }
 }
 
-namespace dr524 { // dr524: yes
+//--- dr524: yes
+namespace dr524 {
   template<typename T> void f(T a, T b) { operator+(a, b); } // expected-error {{call}}
 
   struct S {};
   void operator+(S, S);
   template void f(S, S);
 
   namespace N { struct S {}; }
   void operator+(N::S, N::S); // expected-note {{should be declared}}
   template void f(N::S, N::S); // expected-note {{instantiation}}
 }
 
-namespace dr525 { // dr525: yes
+//--- dr525: yes
+namespace dr525 {
   namespace before {
     // Note, the example was correct prior to the change; instantiation is
     // required for cases like this:
     template <class T> struct D { operator T*(); };
     void g(D<double> ppp) {
       delete ppp;
     }
   }
   namespace after {
     template <class T> struct D { typename T::error e; }; // expected-error {{prior to '::'}}
     void g(D<double> *ppp) {
       delete ppp; // expected-note {{instantiation of}}
     }
   }
 }
 
-namespace dr526 { // dr526: yes
+//--- dr526: yes
+namespace dr526 {
   template<int> struct S {};
   template<int N> void f1(S<N> s);
   template<int N> void f2(S<(N)> s); // expected-note {{couldn't infer}}
   template<int N> void f3(S<+N> s); // expected-note {{couldn't infer}}
   template<int N> void g1(int (&)[N]);
   template<int N> void g2(int (&)[(N)]); // expected-note {{couldn't infer}}
   template<int N> void g3(int (&)[+N]); // expected-note {{couldn't infer}}
 
template<int N> struct X {
     X<+N>::type v3;
 #if __cplusplus <= 201703L
     // expected-error@-3 {{implicit 'typename' is a C++20 extension}}
     // expected-error@-3 {{implicit 'typename' is a C++20 extension}}
 #endif
   };
 }
 
-namespace dr527 { // dr527: na
+//--- dr527: na
+namespace dr527 {
   // This DR is meaningless. It removes a required diagnostic from the case
   // where a not-externally-visible object is odr-used but not defined, which
   // requires a diagnostic for a different reason.
   extern struct { int x; } a; // FIXME: We should reject this, per dr389.
   static struct { int x; } b;
   extern "C" struct { int x; } c;
   namespace { extern struct { int x; } d; }
   typedef struct { int x; } *P;
   struct E { static P e; }; // FIXME: We should reject this, per dr389.
   namespace { struct F { static P f; }; }
 
   int ax = a.x, bx = b.x, cx = c.x, dx = d.x, ex = E::e->x, fx = F::f->x;
 }
 
-namespace dr530 { // dr530: yes
+//--- dr530: yes
+namespace dr530 {
   template<int*> struct S { enum { N = 1 }; };
   template<void(*)()> struct T { enum { N = 1 }; };
   int n;
   void f();
   int a[S<&n>::N];
   int b[T<&f>::N];
 }
 
-namespace dr531 { // dr531: partial
+//--- dr531: partial
+namespace dr531 {
   namespace good {
     template<typename T> struct A {
       void f(T) { T::error; }
       template<typename U> void g(T, U) { T::error; }
       struct B { typename T::error error; };
       template<typename U> struct C { typename T::error error; };
       static T n;
     };
#if __cplusplus <= 201703L
 
     template<> void A<int>::B<char>::f() {} // expected-error {{requires 'template<>'}}
     template<> template<typename V> void A<int>::B<char>::h() {} // expected-error {{should be empty}}
 #endif
   }
 }
 
 // PR8130
-namespace dr532 { // dr532: 3.5
+//--- dr532: 3.5
+namespace dr532 {
   struct A { };
 
   template<class T> struct B {
     template<class R> int &operator*(R&);
   };
 
   template<class T, class R> float &operator*(T&, R&);
   void test() {
     A a;
     B<A> b;
     int &ir = b * a;
   }
 }
 
 // dr533: na
 
-namespace dr534 { // dr534: yes
+//--- dr534: yes
+namespace dr534 {
   struct S {};
   template<typename T> void operator+(S, T);
   template<typename T> void operator+<T*>(S, T*) {} // expected-error {{function template partial spec}}
 }
 
-namespace dr535 { // dr535: yes
+//--- dr535: yes
+namespace dr535 {
   class X { private: X(const X&); };
   struct A {
     X x;
     template<typename T> A(T&);
   };
   struct B : A {
     X y;
     B(volatile A&);
#if __cplusplus >= 201103L
   (void) [](const) {}; // expected-error {{a type specifier is required}}
   (void) [](const n) {}; // expected-error {{unknown type name 'n'}}
   enum E : const {}; // expected-error {{expected a type}}
   using T = const; // expected-error {{expected a type}}
   auto f() -> const; // expected-error {{expected a type}}
 #endif
 }
 
-namespace dr540 { // dr540: yes
+//--- dr540: yes
+namespace dr540 {
   typedef int &a;
   typedef const a &a; // expected-warning {{has no effect}}
   typedef const int &b;
   typedef b &b;
   typedef const a &c; // expected-note {{previous}} expected-warning {{has no effect}}
   typedef const b &c; // expected-error {{different}} expected-warning {{has no effect}}
 }
 
-namespace dr541 { // dr541: yes
+//--- dr541: yes
+namespace dr541 {
   template<int> struct X { typedef int type; };
   template<typename T> struct S {
     int f(T);
 
     int g(int);
     T g(bool);
 
     int h();
     int h(T);
 
     void x() {
       // These are type-dependent expressions, even though we could
       // determine that all calls have type 'int'.
       X<sizeof(f(0))>::type a; // expected-error +{{}}
       X<sizeof(g(0))>::type b; // expected-error +{{}}
       X<sizeof(h(0))>::type b; // expected-error +{{}}
 
       typename X<sizeof(f(0))>::type a;
       typename X<sizeof(h(0))>::type b;
     }
   };
 }
 
-namespace dr542 { // dr542: yes
+//--- dr542: yes
+namespace dr542 {
 #if __cplusplus >= 201103L
   // In C++20 A and B are no longer aggregates and thus the constructor is
   // called, which fails.
   struct A { A() = delete; int n; };
   A a[32] = {}; // ok, constructor not called
 #if __cplusplus > 201703L
   // expected-error@-2 {{call to deleted constructor}}
   // expected-note@-3 {{in implicit initialization}}
   // expected-note@-5 {{marked deleted here}}
 #endif
 
   struct B {
     int n;
   private:
     B() = default;
   };
   B b[32] = {}; // ok, constructor not called
 #if __cplusplus > 201703L
   // expected-error@-2 {{calling a private constructor}}
   // expected-note@-5 {{declared private here}}
 #endif
 #endif
 }
 
-namespace dr543 { // dr543: yes
+//--- dr543: yes
+namespace dr543 {
   // In C++98+DR543, this is valid because value-initialization doesn't call a
   // trivial default constructor, so we never notice that defining the
   // constructor would be ill-formed.
   //
   // In C++11+DR543, this is ill-formed, because the default constructor is
   // deleted, and value-initialization *does* call a deleted default
   // constructor, even if it is trivial.
   struct A {
     const int n;
   };
   A a = A();
 #if __cplusplus >= 201103L
   // expected-error@-2 {{deleted}}
   // expected-note@-5 {{would not be initialized}}
 #endif
 }
 
-namespace dr544 { // dr544: yes
+//--- dr544: yes
+namespace dr544 {
   int *n;
 
   template<class T> struct A { int n; };
   template<class T> struct B : A<T> { int get(); };
   template<> int B<int>::get() { return n; }
   int k = B<int>().get();
 }
 
-namespace dr546 { // dr546: yes
+//--- dr546: yes
+namespace dr546 {
   template<typename T> struct A { void f(); };
   template struct A<int>;
   template<typename T> void A<T>::f() { T::error; }
 }
 
-namespace dr547 { // dr547: yes
+//--- dr547: yes
+namespace dr547 {
   template<typename T> struct X;
   template<typename T> struct X<T() const> {};
   template<typename T, typename C> X<T> f(T C::*) { return X<T>(); }
 
   struct S { void f() const; };
   X<void() const> x = f(&S::f);
 }
 
-namespace dr548 { // dr548: dup 482
+//--- dr548: dup 482
+namespace dr548 {
   template<typename T> struct S {};
   template<typename T> void f() {}
   template struct dr548::S<int>;
   template void dr548::f<int>();
 }
 
-namespace dr551 { // dr551: yes c++11
+//--- dr551: yes c++11
+namespace dr551 {
   // FIXME: This obviously should apply in C++98 mode too.
   template<typename T> void f() {}
   template inline void f<int>();
 #if __cplusplus >= 201103L
   // expected-error@-2 {{cannot be 'inline'}}
 #endif
 
   template<typename T> inline void g() {}
   template inline void g<int>();
 #if __cplusplus >= 201103L
   // expected-error@-2 {{cannot be 'inline'}}
 #endif
 
   template<typename T> struct X {
     void f() {}
   };
   template inline void X<int>::f();
 #if __cplusplus >= 201103L
   // expected-error@-2 {{cannot be 'inline'}}
 #endif
 }
 
-namespace dr552 { // dr552: yes
+//--- dr552: yes
+namespace dr552 {
   template<typename T, typename T::U> struct X {};
   struct Y { typedef int U; };
   X<Y, 0> x;
 }
 
 struct dr553_class {
   friend void *operator new(size_t, dr553_class);
 };
 namespace dr553 {
   dr553_class c;
   // Contrary to the apparent intention of the DR, operator new is not actually
   // looked up with a lookup mechanism that performs ADL; the standard says it
   // "is looked up in global scope", where it is not visible.
   void *p = new (c) int; // expected-error {{no matching function}}
 
   struct namespace_scope {
     friend void *operator new(size_t, namespace_scope); // expected-error {{cannot be declared inside a namespace}}
   };
 }
 
 // dr554: na
 // dr556: na
 
-namespace dr557 { // dr557: yes
+//--- dr557: yes
+namespace dr557 {
   template<typename T> struct S {
     friend void f(S<T> *);
     friend void g(S<S<T> > *);
   };
   void x(S<int> *p, S<S<int> > *q) {
     f(p);
     g(q);
   }
 }
 
-namespace dr558 { // dr558: yes
+//--- dr558: yes
+namespace dr558 {
   wchar_t a = L'\uD7FF';
   wchar_t b = L'\xD7FF';
   wchar_t c = L'\uD800'; // expected-error {{invalid universal character}}
   wchar_t d = L'\xD800';
   wchar_t e = L'\uDFFF'; // expected-error {{invalid universal character}}
   wchar_t f = L'\xDFFF';
   wchar_t g = L'\uE000';
   wchar_t h = L'\xE000';
 }
 
 template<typename> struct dr559 { typedef int T; dr559::T u; }; // dr559: yes
 
-namespace dr561 { // dr561: yes
+//--- dr561: yes
+namespace dr561 {
   template<typename T> void f(int);
   template<typename T> void g(T t) {
     f<T>(t);
   }
   namespace {
     struct S {};
     template<typename T> static void f(S);
   }
   void h(S s) {
     g(s);
   }
 }
 
 // dr562: na
 
-namespace dr564 { // dr564: yes
+//--- dr564: yes
+namespace dr564 {
   extern "C++" void f(int);
   void f(int); // ok
   extern "C++" { extern int n; }
   int n; // ok
 }
 
-namespace dr565 { // dr565: yes
+//--- dr565: yes
+namespace dr565 {
   namespace N {
     template<typename T> int f(T); // expected-note {{target}}
   }
   using N::f; // expected-note {{using}}
   template<typename T> int f(T*);
   template<typename T> void f(T);
   template<typename T, int = 0> int f(T); // expected-error 0-1{{extension}}
   template<typename T> int f(T, int = 0);
   template<typename T> int f(T); // expected-error {{conflicts with}}
 }
 
-namespace dr566 { // dr566: yes
+//--- dr566: yes
+namespace dr566 {
 #if __cplusplus >= 201103L
   int check[int(-3.99) == -3 ? 1 : -1];
 #endif
 }
 
 // dr567: na
 
-namespace dr568 { // dr568: yes c++11
+//--- dr568: yes c++11
+namespace dr568 {
   // FIXME: This is a DR issue against C++98, so should probably apply there
   // too.
   struct x { int y; };
   class trivial : x {
     x y;
   public:
     int n;
   };
#if __cplusplus < 201103L
     // expected-error@-2 {{cannot jump}}
     // expected-note@+2 {{non-POD}}
 #endif
     trivial t;
   x: ;
   }
 }
 
-namespace dr569 { // dr569: yes c++11
+//--- dr569: yes c++11
+namespace dr569 {
   // FIXME: This is a DR issue against C++98, so should probably apply there
   // too.
   ;;;;;
 #if __cplusplus < 201103L
   // expected-error@-2 {{C++11 extension}}
 #endif
 }
 
-namespace dr570 { // dr570: dup 633
+//--- dr570: dup 633
+namespace dr570 {
   int n;
   int &r = n; // expected-note {{previous}}
   int &r = n; // expected-error {{redefinition}}
 }
 
-namespace dr571 { // dr571 unknown
+//--- dr571 unknown
+namespace dr571 {
   // FIXME: Add a codegen test.
   typedef int &ir;
   int n;
   const ir r = n; // expected-warning {{has no effect}} FIXME: Test if this has internal linkage.
 }
 
-namespace dr572 { // dr572: yes
+//--- dr572: yes
+namespace dr572 {
   enum E { a = 1, b = 2 };
   int check[a + b == 3 ? 1 : -1];
 }
 
-namespace dr573 { // dr573: no
+//--- dr573: no
+namespace dr573 {
   void *a;
   int *b = reinterpret_cast<int*>(a);
   void (*c)() = reinterpret_cast<void(*)()>(a);
   void *d = reinterpret_cast<void*>(c);
 #if __cplusplus < 201103L
   // expected-error@-3 {{extension}}
   // expected-error@-3 {{extension}}
 #endif
   void f() { delete a; } // expected-error {{cannot delete}}
   int n = d - a; // expected-error {{arithmetic on pointers to void}}
   // FIXME: This is ill-formed.
   template<void*> struct S;
   template<int*> struct T;
 }
 
-namespace dr574 { // dr574: yes
+//--- dr574: yes
+namespace dr574 {
   struct A {
     A &operator=(const A&) const; // expected-note {{different qualifiers}}
   };
   struct B {
     B &operator=(const B&) volatile; // expected-note {{different qualifiers}}
   };
 #if __cplusplus >= 201103L
   struct C {

 #if __cplusplus >= 201103L
     // FIXME: We shouldn't produce the 'cannot overload' diagnostics here.
     friend C &C::operator=(const C&); // expected-error {{does not match}} expected-error {{cannot overload}}
     friend D &D::operator=(const D&); // expected-error {{does not match}} expected-error {{cannot overload}}
 #endif
   };
 }
 
-namespace dr575 { // dr575: yes
+//--- dr575: yes
+namespace dr575 {
   template<typename T, typename U = typename T::type> void a(T); void a(...); // expected-error 0-1{{extension}}
   template<typename T, typename T::type U = 0> void b(T); void b(...); // expected-error 0-1{{extension}}
   template<typename T, int U = T::value> void c(T); void c(...); // expected-error 0-1{{extension}}
   template<typename T> void d(T, int = T::value); void d(...); // expected-error {{cannot be used prior to '::'}}
   void x() {
     a(0);
     b(0);
     c(0);
     d(0); // expected-note {{in instantiation of default function argument}}
   }
 
   template<typename T = int&> void f(T* = 0); // expected-error 0-1{{extension}}
   template<typename T = int> void f(T = 0); // expected-error 0-1{{extension}}
   void g() { f<>(); }
 
   template<typename T> T &h(T *);
   template<typename T> T *h(T *);
   void *p = h((void*)0);
 }
 
-namespace dr576 { // dr576: yes
+//--- dr576: yes
+namespace dr576 {
   typedef void f() {} // expected-error {{function definition declared 'typedef'}}
   void f(typedef int n); // expected-error {{invalid storage class}}
   void f(char c) { typedef int n; }
 }
 
-namespace dr577 { // dr577: yes
+//--- dr577: yes
+namespace dr577 {
   typedef void V;
   typedef const void CV;
   void a(void);
   void b(const void); // expected-error {{qualifiers}}
   void c(V);
   void d(CV); // expected-error {{qualifiers}}
   void (*e)(void) = c;
   void (*f)(const void); // expected-error {{qualifiers}}
   void (*g)(V) = a;
   void (*h)(CV); // expected-error {{qualifiers}}
   template<typename T> void i(T); // expected-note 2{{requires 1 arg}}
   template<typename T> void j(void (*)(T)); // expected-note 2{{argument may not have 'void' type}}
   void k() {
     a();
     c();
     i<void>(); // expected-error {{no match}}
     i<const void>(); // expected-error {{no match}}
     j<void>(0); // expected-error {{no match}}
     j<const void>(0); // expected-error {{no match}}
   }
 }
 
-namespace dr580 { // dr580: partial
+//--- dr580: partial
+namespace dr580 {
   class C;
   struct A { static C c; };
   struct B { static C c; };
   class C {
     C(); // expected-note {{here}}
     ~C(); // expected-note {{here}}
 
     typedef int I; // expected-note 2{{here}}
namespace dr580 {
   template<C::I> void h() {} // expected-error {{private}}
 
   C A::c;
   C B::c; // expected-error 2{{private}}
 }
 
 // dr582: na
 
-namespace dr583 { // dr583: 4
+//--- dr583: 4
+namespace dr583 {
   // see n3624
   int *p;
   bool b1 = p < 0; // expected-error {{ordered comparison between pointer and zero}}
   bool b2 = p > 0; // expected-error {{ordered comparison between pointer and zero}}
   bool b3 = p <= 0; // expected-error {{ordered comparison between pointer and zero}}
   bool b4 = p >= 0; // expected-error {{ordered comparison between pointer and zero}}
 }
 
 // dr584: na
 
-namespace dr585 { // dr585: yes
+//--- dr585: yes
+namespace dr585 {
   template<typename> struct T;
   struct A {
     friend T;
 #if __cplusplus <= 201402L
     // expected-error@-2 {{a type specifier is required}} expected-error@-2 {{can only be classes or functions}}
 #else
     // expected-error@-4 {{use of class template 'T' requires template arguments; argument deduction not allowed in friend declaration}}
     // expected-note@-7 {{here}}
#else
     // expected-note@-6 {{here}}
 #endif
     template<typename U> friend T<U>; // expected-error {{must use an elaborated type}}
   };
 }
 
 // dr586: na
 
-namespace dr587 { // dr587: yes
+//--- dr587: yes
+namespace dr587 {
   template<typename T> void f(bool b, const T x, T y) {
     const T *p = &(b ? x : y);
   }
   struct S {};
   template void f(bool, const int, int);
   template void f(bool, const S, S);
 }
 
-namespace dr588 { // dr588: yes
+//--- dr588: yes
+namespace dr588 {
   struct A { int n; }; // expected-note {{ambiguous}}
   template<typename T> int f() {
     struct S : A, T { int f() { return n; } } s;
     int a = s.f();
     int b = s.n; // expected-error {{found in multiple}}
   }
   struct B { int n; }; // expected-note {{ambiguous}}
   int k = f<B>(); // expected-note {{here}}
 }
 
-namespace dr589 { // dr589: yes
+//--- dr589: yes
+namespace dr589 {
   struct B { };
   struct D : B { };
   D f();
   extern const B &b;
   bool a;
   const B *p = &(a ? f() : b); // expected-error {{temporary}}
   const B *q = &(a ? D() : b); // expected-error {{temporary}}
 }
 
-namespace dr590 { // dr590: yes
+//--- dr590: yes
+namespace dr590 {
   template<typename T> struct A {
     struct B {
       struct C {
         A<T>::B::C f(A<T>::B::C); // ok, no 'typename' required.
       };
     };
   };
   template<typename T> typename A<T>::B::C A<T>::B::C::f(A<T>::B::C) {}
 }
 
-namespace dr591 { // dr591: no
+//--- dr591: no
+namespace dr591 {
   template<typename T> struct A {
     typedef int M;
     struct B {
       typedef void M;
       struct C;
     };
   };
 
   template<typename T> struct A<T>::B::C : A<T> {
     // FIXME: Should find member of non-dependent base class A<T>.
     M m; // expected-error {{incomplete type 'M' (aka 'void'}}
   };
 }
 
 // dr592: na
 // dr593 needs an IRGen test.
 // dr594: na
 
-namespace dr595 { // dr595: dup 1330
+//--- dr595: dup 1330
+namespace dr595 {
   template<class T> struct X {
     void f() throw(T) {}
 #if __cplusplus > 201402L
     // expected-error@-2 {{ISO C++17 does not allow}} expected-note@-2 {{use 'noexcept}}
 #endif
   };
   struct S {
     X<S> xs;
   };
 }
 
 // dr597: na
 
-namespace dr598 { // dr598: yes
+//--- dr598: yes
+namespace dr598 {
   namespace N {
     void f(int);
     void f(char);
     // Not found by ADL.
     void g(void (*)(int));
     void h(void (*)(int));
 
     namespace M {
       struct S {};
       int &h(void (*)(S));
     }
     void i(M::S);
     void i();
   }
   int &g(void(*)(char));
   int &r = g(N::f);
   int &s = h(N::f); // expected-error {{undeclared}}
   int &t = h(N::i);
 }
 
-namespace dr599 { // dr599: partial
+//--- dr599: partial
+namespace dr599 {
   typedef int Fn();
   struct S { operator void*(); };
   struct T { operator Fn*(); };
   struct U { operator int*(); operator void*(); }; // expected-note 2{{conversion}}
   struct V { operator int*(); operator Fn*(); };
   void f(void *p, void (*q)(), S s, T t, U u, V v) {
     delete p; // expected-error {{cannot delete}}
     delete q; // expected-error {{cannot delete}}
     delete s; // expected-error {{cannot delete}}
     delete t; // expected-error {{cannot delete}}
     // FIXME: This is valid, but is rejected due to a non-conforming GNU
     // extension allowing deletion of pointers to void.
     delete u; // expected-error {{ambiguous}}
     delete v;
   }
 }

clang/test/CXX/drs/dr6xx.cpp

 // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -fno-spell-checking
 // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -fno-spell-checking
 // RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -fno-spell-checking
 // RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -fno-spell-checking
 // RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -fno-spell-checking
 // RUN: %clang_cc1 -std=c++23 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -fno-spell-checking
 
-namespace dr600 { // dr600: yes
+//--- dr600: yes
+namespace dr600 {
 struct S {
   void f(int);
 
 private:
   void f(double); // expected-note {{declared private here}}
 };
 
 void g(S *sp) {
   sp->f(2);
   // access control is applied after overload resolution
   sp->f(2.2); // expected-error {{is a private member}}
 }
 } // namespace dr600
 
 namespace std {
   struct type_info {};
   __extension__ typedef __SIZE_TYPE__ size_t;
 } // namespace std
 
-namespace dr601 { // dr601: yes
+//--- dr601: yes
+namespace dr601 {
 #if __cplusplus >= 201103L
 #define MAX __LLONG_MAX__
 #else
 #define MAX __LONG_MAX__
 #endif
 
 #if 0x8000 < -1
 #error 0x8000 should be signed

 
 #if __cplusplus >= 201103L && __LLONG_MAX__ == 0x7FFFFFFFFFFFFFFF
 static_assert(0x8000000000000000 < -1, "0x8000000000000000 should be unsigned"); // expected-error {{C11}}
 #endif
 
 #undef MAX
 }
 
-namespace dr602 { // dr602: yes
+//--- dr602: yes
+namespace dr602 {
   template<class T> struct A {
     template<class U> friend struct A;
   };
 
   template<class T> struct B {
     class C {
       template<class U> friend struct B;
       typedef int type;
     };
     typename C::type ct; // ok, befriended
   };
   B<int> b;
 }
 
-namespace dr603 { // dr603: yes
+//--- dr603: yes
+namespace dr603 {
   template<unsigned char> struct S {};
   typedef S<'\001'> S1;
   typedef S<(1ul << __CHAR_BIT__) + 1> S1;
 #if __cplusplus >= 201103L
   // expected-error@-2 {{cannot be narrowed}}
 #endif
 }
 
 // dr604: na
 // dr605 needs IRGen test
 
-namespace dr606 { // dr606: yes
+//--- dr606: yes
+namespace dr606 {
 #if __cplusplus >= 201103L
   template<typename T> struct S {};
   template<typename T> void f(S<T> &&); // expected-note {{expects an rvalue}}
   template<typename T> void g(T &&);
   template<typename T> void h(const T &&); // expected-note {{expects an rvalue}}
 
   void test(S<int> s) {
     f(s); // expected-error {{no match}}
     g(s);
     h(s); // expected-error {{no match}}
 
     g(test);
     h(test); // ok, an rvalue reference can bind to a function lvalue
   }
 #endif
 }
 
-namespace dr607 { // dr607: yes
+//--- dr607: yes
+namespace dr607 {
 namespace example1 {
 struct Y {};
 
 template <typename T> struct X : public virtual Y {};
 
 template <typename T> class A : public X<T> {
   template <typename S> A(S) : S() {}
 };
struct D : B {
   D();
 };
 } // namespace N
 
 N::D::D() : typedef_B(0) {}
 } // namespace example2
 } // namespace dr607
 
-namespace dr608 { // dr608: yes
+//--- dr608: yes
+namespace dr608 {
   struct A { virtual void f(); };
   struct B : A {};
   struct C : A { void f(); };
   struct D : B, C {};
 }
 
 int dr610[-0u == 0u ? 1 : -1]; // dr610: yes
 
-namespace dr611 { // dr611: yes
+//--- dr611: yes
+namespace dr611 {
   int k;
   struct S { int &r; } s = { k ? k : k };
 }
 
 // dr612: na
 
-namespace dr613 { // dr613: yes c++11
+//--- dr613: yes c++11
+namespace dr613 {
   // see also n2253
   struct A { int n; static void f(); };
   int f(int);
   struct B { virtual void f(); };
   B &g(int);
 
   int an1 = sizeof(A::n);
   int an2 = sizeof(A::n + 1); // valid per dr850

 #endif
     const std::type_info &an3 = typeid(g(n)); // expected-error {{static}}
   }
 }
 
 int dr614_a[(-1) / 2 == 0 ? 1 : -1]; // dr614: yes
 int dr614_b[(-1) % 2 == -1 ? 1 : -1];
 
-namespace dr615 { // dr615: yes
+//--- dr615: yes
+namespace dr615 {
   int f();
   static int n = f();
 }
 
-namespace dr616 { // dr616: 4
+//--- dr616: 4
+namespace dr616 {
 #if __cplusplus >= 201103L
   struct S { int n; } s;
   S f();
   using T = decltype((S().n));
   using T = decltype((static_cast<S&&>(s).n));
   using T = decltype((f().n));
   using T = decltype(S().*&S::n);
   using T = decltype(static_cast<S&&>(s).*&S::n);
   using T = decltype(f().*&S::n);
   using T = int&&;
 
   using U = decltype(S().n);
   using U = decltype(static_cast<S&&>(s).n);
   using U = int;
 #endif
 }
 
-namespace dr618 { // dr618: yes
+//--- dr618: yes
+namespace dr618 {
 #if (unsigned)-1 > 0
 #error wrong
 #endif
 }
 
-namespace dr619 { // dr619: yes
+//--- dr619: yes
+namespace dr619 {
   extern int x[10];
   struct S { static int x[10]; };
 
   int x[];
   _Static_assert(sizeof(x) == sizeof(int) * 10, ""); // expected-error {{C11}}
   extern int x[];
   _Static_assert(sizeof(x) == sizeof(int) * 10, ""); // expected-error {{C11}}
 
namespace dr621 {
   template<> int f<int>() {} // expected-error {{redefinition}}
 }
 
 // dr623: na
 // FIXME: Add documentation saying we allow invalid pointer values.
 
 // dr624 needs an IRGen check.
 
-namespace dr625 { // dr625: yes
+//--- dr625: yes
+namespace dr625 {
   template<typename T> struct A {};
   A<auto> x = A<int>(); // expected-error {{'auto' not allowed in template argument}} expected-error 0-1{{extension}}
   void f(int);
   void (*p)(auto) = f; // expected-error {{'auto' not allowed in function prototype}} expected-error 0-1{{extension}}
 }
 
-namespace dr626 { // dr626: yes
+//--- dr626: yes
+namespace dr626 {
 #define STR(x) #x
   char c[2] = STR(c); // ok, type matches
   wchar_t w[2] = STR(w); // expected-error {{initializing wide char array with non-wide string literal}}
 }
 
-namespace dr627 { // dr627: yes
+//--- dr627: yes
+namespace dr627 {
   void f() {
     true a = 0; // expected-error +{{}} expected-warning {{unused}}
   }
 }
 
 // dr628: na
 
-namespace dr629 { // dr629: yes
+//--- dr629: yes
+namespace dr629 {
   typedef int T;
   int n = 1;
   void f() {
     auto T = 2;
 #if __cplusplus < 201103L
     // expected-error@-2 {{expected unqualified-id}}
 #else
     // expected-note@-4 {{previous}}
 #endif
 
     auto T(n);
 #if __cplusplus >= 201103L
     // expected-error@-2 {{redefinition of 'T'}}
 #endif
   }
 }
 
-namespace dr630 { // dr630: yes
+//--- dr630: yes
+namespace dr630 {
 const bool MB_EQ_WC =
     ' ' == L' ' && '\t' == L'\t' && '\v' == L'\v' && '\r' == L'\r' &&
     '\n' == L'\n' && //
     'a' == L'a' && 'b' == L'b' && 'c' == L'c' && 'd' == L'd' && 'e' == L'e' &&
     'f' == L'f' && 'g' == L'g' && 'h' == L'h' && 'i' == L'i' && 'j' == L'j' &&
     'k' == L'k' && 'l' == L'l' && 'm' == L'm' && 'n' == L'n' && 'o' == L'o' &&
     'p' == L'p' && 'q' == L'q' && 'r' == L'r' && 's' == L's' && 't' == L't' &&
     'u' == L'u' && 'v' == L'v' && 'w' == L'w' && 'x' == L'x' && 'y' == L'y' &&

 #endif
 #else
 _Static_assert(MB_EQ_WC, "!__STDC_MB_MIGHT_NEQ_WC__ but some character differs"); // expected-error {{C11}}
 #endif
 }
 
 // dr631: na
 
-namespace dr632 { // dr632: yes
+//--- dr632: yes
+namespace dr632 {
   struct S { int n; } s = {{5}}; // expected-warning {{braces}}
 }
 
 // dr633: na
 // see also n2993
 
-namespace dr634 { // dr634: yes
+//--- dr634: yes
+namespace dr634 {
   struct S { S(); S(const S&); virtual void f(); ~S(); };
   int f(...);
   char f(int);
   template<typename T> int (&g(T))[sizeof f(T())];
   int (&a)[sizeof(int)] = g(S());
   int (&b)[1] = g(0);
   int k = f(S()); // expected-error {{cannot pass}}
 }
 
-namespace dr635 { // dr635: yes
+//--- dr635: yes
+namespace dr635 {
   template<typename T> struct A { A(); ~A(); };
   template<typename T> A<T>::A<T>() {} // expected-error {{cannot have template arguments}}
   template<typename T> A<T>::~A<T>() {}
 
   template<typename T> struct B { B(); ~B(); };
   template<typename T> B<T>::B() {}
   template<typename T> B<T>::~B() {}
 
   struct C { template<typename T> C(); C(); };
   template<typename T> C::C() {}
   C::C() {}
   template<> C::C<int>() {} // expected-error {{constructor name}} expected-error {{unqualified-id}}
   /*FIXME: needed for error recovery:*/;
 
   template<typename T> struct D { template<typename U> D(); D(); };
   template<typename T> D<T>::D() {} // expected-note {{previous}}
   template<typename T> template<typename U> D<T>::D() {}
   template<typename T> D<T>::D<T>() {} // expected-error {{redefinition}} expected-error {{cannot have template arg}}
 }
 
-namespace dr637 { // dr637: yes
+//--- dr637: yes
+namespace dr637 {
   void f(int i) {
     i = ++i + 1;
     i = i++ + 1;
 #if __cplusplus < 201703L
     // expected-warning@-2 {{unsequenced}}
 #endif
   }
 }
 
-namespace dr638 { // dr638: no
+//--- dr638: no
+namespace dr638 {
   template<typename T> struct A {
     struct B;
     void f();
     void g();
     struct C {
       void h();
     };
   };
template<> struct A<int> {
     int f() { X::type c; } // FIXME: private
     void g() { X::type d; } // ok
     struct D {
       void h() { X::type e; } // FIXME: private
     };
   };
 }
 
-namespace dr639 { // dr639: yes
+//--- dr639: yes
+namespace dr639 {
   void f(int i) {
     void((i = 0) + (i = 0)); // expected-warning {{unsequenced}}
   }
 }
 
-namespace dr641 { // dr641: yes
+//--- dr641: yes
+namespace dr641 {
   namespace std_example {
     struct abc;
 
     struct xyz {
       xyz(); // expected-note 0-1{{candidate}}
       xyz(xyz &); // expected-note 0-1{{candidate}}
 
       operator xyz &() = delete; // expected-error 0-1{{extension}} expected-warning {{will never be used}}
#endif
   void g(const A ca) {
     f(A()); // expected-error {{no match}}
     f(ca); // expected-error {{no match}}
     (void)A();
     (void)ca;
   }
 }
 
-namespace dr642 { // dr642: yes
+//--- dr642: yes
+namespace dr642 {
   void f() {
     const int i = 2;
     {
       char i[i];
       _Static_assert(sizeof(i) == 2, ""); // expected-error {{C11}}
     }
   }
 
   struct s { int a; };
   void g(int s) {
     struct s *p = new struct s;
     p->a = s;
   }
 }
 
 #if __cplusplus >= 201103L
-namespace dr643 { // dr643: yes
+//--- dr643: yes
+namespace dr643 {
   struct A {
     int x;
     auto f() -> decltype(this->x);
     auto f(A &a) -> decltype(a.x);
     auto g() -> decltype(x);
     auto h() -> decltype(this->y); // expected-error {{no member named 'y'}}
     auto h(A &a) -> decltype(a.y); // expected-error {{no member named 'y'}}
     auto i() -> decltype(y); // expected-error {{undeclared identifier 'y'}}
     int y;
   };
 }
 #endif
 
 #if __cplusplus >= 201103L
-namespace dr644 { // dr644: partial
+//--- dr644: partial
+namespace dr644 {
   struct A {
     A() = default;
     int x, y;
   };
   static_assert(__is_literal_type(A), "");
 
   struct B : A {};
   static_assert(__is_literal_type(B), "");

 }
 #endif
 
 // dr645 increases permission to optimize; it's not clear that it's possible to
 // test for this.
 // dr645: na
 
 #if __cplusplus >= 201103L
-namespace dr646 { // dr646: sup 981
+//--- dr646: sup 981
+namespace dr646 {
   struct A {
     constexpr A(const A&) = default; // ok
   };
 
   struct B {
     constexpr B() {}
     B(B&);
   };
   constexpr B b = {}; // ok
 }
 #endif
 
 #if __cplusplus >= 201103L
-namespace dr647 { // dr647: yes
+//--- dr647: yes
+namespace dr647 {
   // This is partially superseded by dr1358.
   struct A {
     constexpr virtual void f() const;
     constexpr virtual void g() const {}
 #if __cplusplus <= 201703L
     // expected-error@-2 {{virtual function cannot be constexpr}}
 #endif
   };
struct E {
     constexpr E(float f) // expected-error {{never produces a constant expression}}
         : n(get()),
           d(D(0) + f) {} // expected-note {{non-constexpr constructor}}
   };
 }
 #endif
 
 #if __cplusplus >= 201103L
-namespace dr648 { // dr648: yes
+//--- dr648: yes
+namespace dr648 {
   int f();
   constexpr int a = (true ? 1 : f());
   constexpr int b = false && f();
   constexpr int c = true || f();
 }
 #endif
 
 #if __cplusplus >= 201103L
-namespace dr649 { // dr649: yes
+//--- dr649: yes
+namespace dr649 {
 alignas(0x200000000) int n;       // expected-error {{requested alignment}}1
 struct alignas(0x200000000) X {}; // expected-error {{requested alignment}}
 struct Y {
   int n alignas(0x200000000); // expected-error {{requested alignment}}
 };
   struct alignas(256) Z {};
   // This part is superseded by dr2130 and eventually by aligned allocation support.
   auto *p = new Z;
 }
 #endif
 
 // dr650 FIXME: add codegen test
 
 #if __cplusplus >= 201103L
-namespace dr651 { // dr651: yes
+//--- dr651: yes
+namespace dr651 {
   struct X {
     virtual X &f();
   };
   struct Y : X {
     Y &f();
   };
   using T = decltype(((X&&)Y()).f());
   using T = X &;
 }
 #endif
 
 #if __cplusplus >= 201103L
-namespace dr652 { // dr652: yes
+//--- dr652: yes
+namespace dr652 {
   constexpr int n = 1.2 * 3.4;
   static_assert(n == 4, "");
 }
 #endif
 
 // dr653 FIXME: add codegen test
 
 #if __cplusplus >= 201103L
-namespace dr654 { // dr654: sup 1423
+//--- dr654: sup 1423
+namespace dr654 {
   void f() {
     if (nullptr) {} // expected-warning {{implicit conversion of nullptr constant to 'bool'}}
     bool b = nullptr; // expected-error {{cannot initialize a variable of type 'bool' with an rvalue of type 'std::nullptr_t'}}
     if (nullptr == 0) {}
     if (nullptr != 0) {}
     if (nullptr <= 0) {} // expected-error {{invalid operands}}
     if (nullptr == 1) {} // expected-error {{invalid operands}}
     if (!nullptr) {} // expected-warning {{implicit conversion of nullptr constant to 'bool'}}
     decltype(nullptr) n = 0;
     static_cast<int>(nullptr); // expected-error {{not allowed}}
     (void)static_cast<decltype(nullptr)>(0);
     static_cast<decltype(nullptr)>(1); // expected-error {{not allowed}}
     void(true ? nullptr : 0);
     void(true ? 0 : nullptr);
   }
 }
 #endif
 
-namespace dr655 { // dr655: yes
+//--- dr655: yes
+namespace dr655 {
   struct A { A(int); }; // expected-note 2-3{{not viable}}
                         // expected-note@-1 {{'dr655::A' declared here}}
   struct B : A {
     A a; // expected-note {{member is declared here}}
     B();
     B(int) : B() {} // expected-error 0-1 {{C++11}}
     B(int*) : A() {} // expected-error {{no matching constructor}}
                      // expected-error@-1 {{must explicitly initialize the member 'a'}}
   };
 }
 
-namespace dr656 { // dr656: yes
+//--- dr656: yes
+namespace dr656 {
   struct A { A(const A&) = delete; }; // expected-error 0-1 {{C++11}}
   struct B : A {};
   struct X { operator B(); } x;
   const A &r = x;
   struct Y : private A { // expected-note 2{{here}} expected-note 2{{candidate}}
     operator B() volatile;
   };
   extern Y y;
namespace dr656 {
   void f() {
     accept<const A&>(x);
     accept<const A&>(y); // expected-error {{private base class}}
     accept<const A&>(vy); // expected-error {{call to deleted}} expected-error {{no matching constructor}}
     accept<const D&>(c);
   }
 }
 
-namespace dr657 { // dr657: partial
+//--- dr657: partial
+namespace dr657 {
   struct Abs { virtual void x() = 0; };
   struct Der : public Abs { virtual void x(); };
 
   struct Cnvt { template<typename F> Cnvt(F); };
 
   void foo(Cnvt a);
   void foo(Abs &a);
   void f(Abs *a) { foo(*a); }
#endif
 
   // FIXME: We should reject this too.
   Cnvt2<Abs>::type err;
 }
 
 // dr658 FIXME: add codegen test
 
 #if __cplusplus >= 201103L
-namespace dr659 { // dr659: yes
+//--- dr659: yes
+namespace dr659 {
   static_assert(alignof(char) == alignof(char&), "");
   static_assert(alignof(int) == alignof(int&), "");
   int n = alignof(int(&)()); // expected-error {{application of 'alignof' to a function type}}
   struct A; // expected-note {{forward}}
   int m = alignof(A&); // expected-error {{application of 'alignof' to an incomplete type}}
 }
 #endif
 
 #if __cplusplus >= 201103L
-namespace dr660 { // dr660: yes
+//--- dr660: yes
+namespace dr660 {
   enum : int { a };
   enum class { b }; // expected-error {{requires a name}}
   auto x = a;
 
   struct X {
     enum : int { a };
     enum class { b }; // expected-error {{requires a name}}
   };
   auto y = X::a;
 }
 #endif
 
 // dr661 FIXME: add codegen test
 
-namespace dr662 { // dr662: yes
+//--- dr662: yes
+namespace dr662 {
   template <typename T> void f(T t) {
     T &tr = t;
     T *tp = &t; // expected-error {{pointer to a reference}}
 #if __cplusplus >= 201103L
     auto *ap = &t;
 #endif
   }
   void g(int n) { f<int&>(n); } // expected-note {{instantiation of}}
 }
 
-namespace dr663 { // dr663: sup P1949
+//--- dr663: sup P1949
+namespace dr663 {
   int ЍЎ = 123;
 }
 
 #if __cplusplus >= 201103L
-namespace dr664 { // dr664: yes
+//--- dr664: yes
+namespace dr664 {
   struct A { A(const A&) = delete; };
   A &&f(A &&a, int n) {
     if (n)
       return f(static_cast<A&&>(a), n - 1);
     return static_cast<A&&>(a);
   }
 }
 #endif
 
-namespace dr665 { // dr665: yes
+//--- dr665: yes
+namespace dr665 {
   struct A { virtual ~A(); };
   struct B : A {} *b;
   struct C : private A {} *c; // expected-note {{here}}
   struct D : B, C {} *d;
 
   struct VB : virtual A {} *vb;
   struct VC : private virtual A {} *vc; // expected-note {{here}}
   struct VD : VB, VC {} *vd;
 
   void f() {
     (void)dynamic_cast<A*>(b);
     (void)dynamic_cast<A*>(c); // expected-error {{private}}
     (void)dynamic_cast<A*>(d); // expected-error {{ambiguous}}
     (void)dynamic_cast<A*>(vb);
     (void)dynamic_cast<A*>(vc); // expected-error {{private}}, even though it could be valid at runtime
     (void)dynamic_cast<A*>(vd);
   }
 }
 
-namespace dr666 { // dr666: yes
+//--- dr666: yes
+namespace dr666 {
   struct P { friend P operator*(P, P); P(int); } p(0);
 
   template<int> int f();
   template<typename T> int f() {
     T::type *p = 0; // expected-error {{missing 'typename'}}
     int a(T::type); // expected-error {{missing 'typename'}}
     return f<T::type>(); // expected-error {{missing 'typename'}}
   }
   struct X { static const int type = 0; };
   struct Y { typedef int type; };
   int a = f<X>();
   int b = f<Y>(); // expected-note {{instantiation of}}
 }
 
 // Triviality is entirely different in C++98.
 #if __cplusplus >= 201103L
-namespace dr667 { // dr667: yes
+//--- dr667: yes
+namespace dr667 {
   struct A {
     A() = default; // expected-warning {{explicitly defaulted default constructor is implicitly deleted}} expected-note{{replace 'default'}}
     int &r; // expected-note {{because field 'r' of reference type 'int &' would not be initialized}}
   };
   static_assert(!__is_trivially_constructible(A), "");
 
   struct B { ~B() = delete; };
   union C { B b; };
   static_assert(!__is_trivially_destructible(C), "");
 
   struct D { D(const D&) = delete; };
   struct E : D {};
   static_assert(!__is_trivially_constructible(E, const E&), "");
 
   struct F { F &operator=(F&&) = delete; };
   struct G : F {};
   static_assert(!__is_trivially_assignable(G, G&&), "");
 }
 #endif
 
 // dr668 FIXME: add codegen test
 
 #if __cplusplus >= 201103L
-namespace dr669 { // dr669: yes
+//--- dr669: yes
+namespace dr669 {
   void f() {
     int n;
     using T = decltype(n);
     using T = int;
     using U = decltype((n));
     using U = int &;
 
     [=] {
struct X {
         using Y = decltype((n));
         using Y = const int&;
       }
     };
   }
 }
 #endif
 
-namespace dr671 { // dr671: yes
+//--- dr671: yes
+namespace dr671 {
   enum class E { e }; // expected-error 0-1 {{C++11}}
   E e = static_cast<E>(0);
   int n = static_cast<int>(E::e); // expected-error 0-1 {{C++11}}
   int m = static_cast<int>(e); // expected-error 0-1 {{C++11}}
 }
 
 // dr672 FIXME: add codegen test
 
-namespace dr673 { // dr673: yes
+//--- dr673: yes
+namespace dr673 {
   template<typename> struct X { static const int n = 0; };
 
   class A {
     friend class B *f();
     class C *f();
     void f(class D *);
     enum { e = X<struct E>::n };
     void g() { extern struct F *p; }
   };
   B *b;
   C *c;
   D *d;
   E *e;
   F *f; // expected-error {{unknown type name}}
 }
 
-namespace dr674 { // dr674: 8
+//--- dr674: 8
+namespace dr674 {
   template<typename T> int f(T);
 
   int g(int);
   template<typename T> int g(T);
 
   int h(int);
   template<typename T> int h(T);
 
namespace dr674 {
   template<typename T> int Y::h(T) { return Z().n; }
 
   // FIXME: Should the <> be required here?
   template int Y::f<>(int);
   template int Y::g<>(int); // expected-note {{in instantiation of}}
   template int Y::h<>(int);
 }
 
-namespace dr675 { // dr675: dup 739
+//--- dr675: dup 739
+namespace dr675 {
   template<typename T> struct A { T n : 1; };
 #if __cplusplus >= 201103L
   static_assert(A<char>{1}.n < 0, ""); // expected-warning {{implicit truncation from 'int' to a one-bit wide bit-field changes value from 1 to -1}}
   static_assert(A<int>{1}.n < 0, ""); // expected-warning {{implicit truncation from 'int' to a one-bit wide bit-field changes value from 1 to -1}}
   static_assert(A<long long>{1}.n < 0, ""); // expected-warning {{implicit truncation from 'int' to a one-bit wide bit-field changes value from 1 to -1}}
 #endif
 }
 
 // dr676: na
 
-namespace dr677 { // dr677: no
+//--- dr677: no
+namespace dr677 {
   struct A {
     void *operator new(std::size_t);
     void operator delete(void*) = delete; // expected-error 0-1{{C++11}} expected-note {{deleted}}
   };
   struct B {
     void *operator new(std::size_t);
     void operator delete(void*) = delete; // expected-error 0-1{{C++11}} expected-note 2{{deleted}}
     virtual ~B();
   };
   void f(A *p) { delete p; } // expected-error {{deleted}}
   // FIXME: This appears to be valid; we shouldn't even be looking up the 'operator delete' here.
   void f(B *p) { delete p; } // expected-error {{deleted}}
   B::~B() {} // expected-error {{deleted}}
 }
 
 // dr678 FIXME: check that the modules ODR check catches this
 
-namespace dr679 { // dr679: yes
+//--- dr679: yes
+namespace dr679 {
   struct X {};
   template<int> void operator+(X, X);
   template<> void operator+<0>(X, X) {} // expected-note {{previous}}
   template<> void operator+<0>(X, X) {} // expected-error {{redefinition}}
 }
 
 // dr680: na
 
 #if __cplusplus >= 201103L
-namespace dr681 { // dr681: partial
+//--- dr681: partial
+namespace dr681 {
   auto *a() -> int; // expected-error {{must specify return type 'auto', not 'auto *'}}
   auto (*b)() -> int;
   // FIXME: The errors here aren't great.
   auto (*c()) -> int; // expected-error {{expected function body}}
   auto ((*d)()) -> int; // expected-error {{expected ';'}} expected-error {{requires an initializer}}
 
   // FIXME: This is definitely wrong. This should be
   //   "function of () returning pointer to function of () returning int"
   // not a function with a deduced return type.
   auto (*e())() -> int; // expected-error 0-1{{C++14}}
 
   auto f() -> int (*)();
   auto g() -> auto (*)() -> int;
 }
 #endif
 
 #if __cplusplus >= 201103L
-namespace dr683 { // dr683: yes
+//--- dr683: yes
+namespace dr683 {
   struct A {
     A() = default;
     A(const A&) = default;
     A(A&);
   };
   static_assert(__is_trivially_constructible(A, const A&), "");
   static_assert(!__is_trivially_constructible(A, A&), "");
   static_assert(!__is_trivial(A), "");
 
   struct B : A {};
   static_assert(__is_trivially_constructible(B, const B&), "");
   static_assert(__is_trivially_constructible(B, B&), "");
   static_assert(__is_trivial(B), "");
 }
 #endif
 
 #if __cplusplus >= 201103L
-namespace dr684 { // dr684: sup 1454
+//--- dr684: sup 1454
+namespace dr684 {
   void f() {
     int a; // expected-note {{here}}
     constexpr int *p = &a; // expected-error {{constant expression}} expected-note {{pointer to 'a'}}
   }
 }
 #endif
 
-namespace dr685 { // dr685: yes
+//--- dr685: yes
+namespace dr685 {
   enum E : long { e };
 #if __cplusplus < 201103L
     // expected-error@-2 {{enumeration types with a fixed underlying type are a C++11 extension}}
 #endif
   void f(int);
   int f(long);
   int a = f(e);
 
#endif
   int d = j(g); // expected-error {{ambiguous}}
 
   // Valid per dr1601
   int k(short);
   void k(int);
   int x = k(g);
 }
 
-namespace dr686 { // dr686: yes
+//--- dr686: yes
+namespace dr686 {
   void f() {
     (void)dynamic_cast<struct A*>(0); // expected-error {{incomplete}} expected-note {{forward}}
     (void)dynamic_cast<struct A{}*>(0); // expected-error {{cannot be defined in a type specifier}}
     (void)typeid(struct B*);
     (void)typeid(struct B{}*); // expected-error {{cannot be defined in a type specifier}}
     (void)static_cast<struct C*>(0);
     (void)static_cast<struct C{}*>(0); // expected-error {{cannot be defined in a type specifier}}
     (void)reinterpret_cast<struct D*>(0);
#if __cplusplus < 201703L
     void g() throw(struct Q); // expected-error {{incomplete}} expected-note {{forward}}
     void h() throw(struct Q {}); // expected-error {{cannot be defined in a type specifier}}
 #endif
   }
   template<struct R *> struct X;
   template<struct R {} *> struct Y; // expected-error {{cannot be defined in a type specifier}}
 }
 
-namespace dr687 { // dr687 (9 c++20, but the issue is still considered open)
+//--- dr687 (9 c++20, but the issue is still considered open)
+namespace dr687 {
   template<typename T> void f(T a) {
     // This is valid in C++20.
     g<int>(a);
 #if __cplusplus <= 201703L
     // expected-error@-2 {{C++20 extension}}
 #endif
 
     // This is not.
     template g<int>(a); // expected-error {{expected expression}}
   }
 }
 
-namespace dr692 { // dr692: 16
+//--- dr692: 16
+namespace dr692 {
   // Also see dr1395.
 
   namespace temp_func_order_example2 {
     template <typename... T> struct A1 {}; // expected-error 0-1{{C++11}}
     template <typename U, typename... T> struct A2 {}; // expected-error 0-1{{C++11}}
     template <typename T1, typename... U> void e1(A1<T1, U...>) = delete; // expected-error 0-2{{C++11}}
     template <typename T1> void e1(A1<T1>);
     template <typename T1, typename... U> void e2(A2<T1, U...>) = delete; // expected-error 0-2{{C++11}}
namespace dr692 {
 
   namespace temp_deduct_type_example3 {
     template<class T, class... U> void f(T*, U...){} // expected-error 0-1{{C++11}}
     template<class T> void f(T){}
     template void f(int*);
   }
 }
 
-namespace dr696 { // dr696: yes
+//--- dr696: yes
+namespace dr696 {
   void f(const int*);
   void g() {
     const int N = 10; // expected-note 1+{{here}}
     struct A {
       void h() {
         int arr[N]; (void)arr;
         f(&N); // expected-error {{declared in enclosing}}
       }
     };
 #if __cplusplus >= 201103L
     (void) [] { int arr[N]; (void)arr; };
     (void)[] { f(&N); }; // expected-error {{cannot be implicitly captured}} expected-note {{here}} expected-note 2 {{capture 'N' by}} expected-note 2 {{default capture by}}
 #endif
   }
 }

clang/test/CXX/drs/dr7xx.cpp

 // RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++2a %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 
-namespace dr705 { // dr705: yes
+//--- dr705: yes
+namespace dr705 {
   namespace N {
     struct S {};
     void f(S); // expected-note {{declared here}}
   }
 
   void g() {
     N::S s;
     f(s);      // ok
     (f)(s);    // expected-error {{use of undeclared}}
   }
 }
 
-namespace dr712 { // dr712: partial
+//--- dr712: partial
+namespace dr712 {
   void use(int);
   void f() {
     const int a = 0; // expected-note 5{{here}}
     struct X {
       void g(bool cond) {
         use(a);
         use((a));
         use(cond ? a : a);
struct X {
         (void)a.n; // FIXME: expected-error {{declared in enclosing}}
         (void)(a.*&A::n); // FIXME: expected-error {{declared in enclosing}}
       }
     };
   }
 #endif
 }
 
-namespace dr727 { // dr727: partial
+//--- dr727: partial
+namespace dr727 {
   struct A {
     template<typename T> struct C; // expected-note 6{{here}}
     template<typename T> void f(); // expected-note {{here}}
     template<typename T> static int N; // expected-error 0-1{{C++14}} expected-note 6{{here}}
 
     template<> struct C<int>;
     template<> void f<int>();
     template<> static int N<int>;
template<typename T, typename U> struct Collision {
 
     template<typename> struct S2;
     template<> struct S2<T> {}; // expected-note {{previous}}
     template<> struct S2<U> {}; // expected-error {{redefinition}}
   };
   Collision<int, int> c; // expected-note {{in instantiation of}}
 }
 
-namespace dr777 { // dr777: 3.7
+//--- dr777: 3.7
+namespace dr777 {
 #if __cplusplus >= 201103L
 template <typename... T>
 void f(int i = 0, T ...args) {}
 void ff() { f(); }
 
 template <typename... T>
 void g(int i = 0, T ...args, T ...args2) {}
 
 template <typename... T>
 void h(int i = 0, T ...args, int j = 1) {}
 #endif
 }

clang/test/CXX/drs/dr9xx.cpp

 // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++23 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 
 namespace std {
   __extension__ typedef __SIZE_TYPE__ size_t;
 
   template<typename T> struct initializer_list {
     const T *p; size_t n;
     initializer_list(const T *p, size_t n);
   };
 }
 
-namespace dr948 { // dr948: 3.7
+//--- dr948: 3.7
+namespace dr948 {
 #if __cplusplus >= 201103L
   class A {
   public:
      constexpr A(int v) : v(v) { }
      constexpr operator int() const { return v; }
   private:
      int v;
   };
void f() {
      if (constexpr A i = 101) { }
      switch (constexpr A i = 2) { default: break; case 2: break; }
      for (; constexpr A i = 0; ) { }
      while (constexpr A i = 0) { }
   }
 #endif
 }
 
-namespace dr952 { // dr952: yes
+//--- dr952: yes
+namespace dr952 {
 namespace example1 {
 struct A {
   typedef int I; // #dr952-typedef-decl
 };
 struct B : private A { // #dr952-inheritance
 };
 struct C : B {
   void f() {
protected:
   static int x;
 };
 struct B : A {
   friend int get(B) { return x; }
 };
 } // namespace example2
 } // namespace dr952
 
-namespace dr974 { // dr974: yes
+//--- dr974: yes
+namespace dr974 {
 #if __cplusplus >= 201103L
   void test() {
     auto lam = [](int x = 42) { return x; };
   }
 #endif
 }
 
-namespace dr977 { // dr977: yes
+//--- dr977: yes
+namespace dr977 {
 enum E { e = E() };
 #ifndef _WIN32
 // expected-error@-2 {{invalid use of incomplete type 'E'}}
 // expected-note@-3 {{definition of 'dr977::E' is not complete until the closing '}'}}
 #endif
 #if __cplusplus >= 201103L
 enum E2 : int { e2 = E2() };
 enum struct E3 { e = static_cast<int>(E3()) };
 enum struct E4 : int { e = static_cast<int>(E4()) };
 #endif
 } // namespace dr977
 
-namespace dr990 { // dr990: 3.5
+//--- dr990: 3.5
+namespace dr990 {
 #if __cplusplus >= 201103L
   struct A { // expected-note 2{{candidate}}
     A(std::initializer_list<int>); // expected-note {{candidate}}
   };
   struct B {
     A a;
   };
   B b1 { };