Switch Clang's default C++ language target to C++14

[t.p.northover]

Summary

Hi all,

So, I've finally managed to run all the tests I wanted and get this out for review. Sorry it's taken so long. This patch switches Clang's default C++ target to C++14 across all platforms and updates the test-suite to pass.

I've managed to test Linux, macOS and iOS on both the regression tests and the test-suite (minus externals on Linux because it's my home machine). There's a separate patch for the test-suite which I'll attach to a follow-up message here.

I think most of the test changes are pretty straightforward and fall into a few broad categories:

• Changes to how the operands for "operator new" are promoted and otherwise wrangled in C++14. Slightly different CodeGen but essentially fine.
• Some tests explicitly testing C++ mode differences left the C++98 line without a -std=... argument, I added it.
• OpenMP CodeGen changes. As far as I can tell both are correct, but the tests are essentially unreadable so I gave up trying to adapt the output and just set it to C++98 mode.

I'm happy to rework anything people think needs changing.

[Hahnfeld]

clang/lib/Frontend/CompilerInvocation.cpp

1732–1733

This comment should be removed.

[probinson]

+rjmccall for the codegen bits.

clang/test/SemaCXX/new-array-size-conv.cpp

1

I think the intent here was "whatever the current default is" and not specifically gnu++98, because the next line explicitly specifies c++98. So, unless this test fails miserably for C++14 (which I wouldn't expect) I think it should be adapted to whatever gets reported for that dialect.

[t.p.northover]

clang/test/SemaCXX/new-array-size-conv.cpp

1

The original commit of this file (r107229 from Doug Gregor) called out the fact that what's being tested is a GNU and C++0x extension.

I think that implies that the 3 run lines really *should* test gnu++98, c++98 and c++11.

[rsmith]

clang/test/CodeGenCXX/new-overflow.cpp

95

The changes in this file are a regression; C++14 requires us to check whether the array bound prior to promotion is negative. Can you file a bug on that?

clang/test/CodeGenCXX/vtable-available-externally.cpp

2–3

Why does this one need a -std= flag?

clang/test/Parser/cxx1z-nested-namespace-definition.cpp

1–4

I think these two should also be -std=c++98, right?

clang/test/SemaCXX/unknown-type-name.cpp

98–101

Huh, we should probably have a -Wvexing-parse warning for this. Can you file a bug?

109–110

Maybe delete this (incorrect in C++14) FIXME?

[t.p.northover]

Thanks Richard. I'll file the bugs tomorrow for the issues you suggest. Do you see either of them blocking the change to C++14 as a default? On a scale of "no", "no but I want a commitment to fix them" and "yes" sort of thing.

Tonight I've just got one comment that may or may not be useful context before I give you a proper answer tomorrow:

clang/test/CodeGenCXX/vtable-available-externally.cpp

2–3

It's a bit late here so I'll just give the proximal cause this evening in case that makes it obvious to you. I'll dig deeper tomorrow if not.

In this particular case (without the std flag) on the -O2 run line the "vtable for Test11::D" does not get marked "available_externally".

The diff on line 1 is definitely unneeded.

clang/test/Parser/cxx1z-nested-namespace-definition.cpp

1–4

Probably; I'll convince myself of that fact tomorrow.

clang/test/SemaCXX/unknown-type-name.cpp

109–110

Sounds sensible.

[rsmith]

In D40948#948843, @t.p.northover wrote:

Thanks Richard. I'll file the bugs tomorrow for the issues you suggest. Do you see either of them blocking the change to C++14 as a default? On a scale of "no", "no but I want a commitment to fix them" and "yes" sort of thing.

I don't think these should block the change of default. The new-expression one is actually a missing C++14 feature -- we're supposed to be generating a call to a new ABI entry point in the negative-array-bound case to throw a std::bad_array_new_length (we missed it because it's a feature added by a core issue rather than by a paper as I recall). I see no problem with shipping a Clang 6 that doesn't implement the full feature, including throwing the new exception. I'm not entirely happy about shipping Clang 6 without fixing the negative-bound check, since that means we'll generate code that is less hardened against certain common attacks by default, but I don't think I would be release-blocker-level unhappy.

clang/test/CodeGenCXX/vtable-available-externally.cpp

2–3

See comment below.

275

To make this test work in C++11 onwards, you need to add a virtual move assignment operator here:

virtual D& operator=(D&&);

[t.p.northover]

Updating with tentative fixes to review comments.

[t.p.northover]

clang/test/CodeGenCXX/new-overflow.cpp

95

I've filed https://llvm.org/PR35573. Not quite sure what to do about this test until it's fixed though. Add a second RUN line to check both variants and then XFAIL it?

clang/test/CodeGenCXX/vtable-available-externally.cpp

275

That didn't quite work. The issue appears to be that D has both of those implicitly defined in C++14 mode, but only the move assignment operator is used below. Speculative VTable emission requires all of them to be used.

So adding a "d = d;" line to the second g function fixes the test. Does that sound sane to you, or am I missing the point?

clang/test/SemaCXX/unknown-type-name.cpp

98–101

I've filed https://llvm.org/PR35576. You may want to sanity check it though, I was pretty light on the detail because I wasn't sure of the exact diagnostic being proposed.

[filcab]

clang/lib/Frontend/CompilerInvocation.cpp

1733

Why are you changing the PS4 default too?

[t.p.northover]

clang/lib/Frontend/CompilerInvocation.cpp

1733

Paul Robinson indicated that it was feasible back in March: http://lists.llvm.org/pipermail/cfe-dev/2017-March/052986.html. If that's changed I'd be happy to put it back to C++11, but he's one of the main people (rightly) bugging me about this so I'd be slightly surprised.

I also notice the comment crept back in. Bother.

[filcab]

clang/lib/Frontend/CompilerInvocation.cpp

1733

Sounds good, then. If Paul is happy with that change, I don't see a problem there (assuming you do get rid of the comment for good :-) ).

Thank you,

Filipe

[probinson]

clang/lib/Frontend/CompilerInvocation.cpp

1733

Yes, PS4 product management is happy to move forward.

[rsmith]

LGTM with the PS4 comment removed. Thank you!

Please also update the documentation and the release notes.

clang/test/CodeGenCXX/vtable-available-externally.cpp

275

This sounds like a good approach, thanks.

[t.p.northover]

Thanks Richard, and all other reviewers. I committed this as r320250, with a couple of sanitizer test fixes as r320251 and r320284 (thanks Ahmed!).

clang/lib/Frontend/CompilerInvocation.cpp

case InputKind::C:
       else
         LangStd = LangStandard::lang_gnu11;
       break;
     case InputKind::ObjC:
       LangStd = LangStandard::lang_gnu11;
       break;
     case InputKind::CXX:
     case InputKind::ObjCXX:
       // The PS4 uses C++11 as the default C++ standard.
-      if (T.isPS4())
-        LangStd = LangStandard::lang_gnucxx11;
-      else
-        LangStd = LangStandard::lang_gnucxx98;
+      LangStd = LangStandard::lang_gnucxx14;
       break;
     case InputKind::RenderScript:
       LangStd = LangStandard::lang_c99;
       break;
     }
   }
 
   const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);

clang/test/CodeGenCXX/new-overflow.cpp

-// RUN: %clang_cc1 -triple i386-unknown-unknown %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -triple i386-unknown-unknown %s -std=c++98 -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -triple i386-unknown-unknown %s  -emit-llvm -o - | FileCheck %s
 
+// This test fails at the moment because we drop the overflow checks in C++14
+// mode, which is a bug. See https://llvm.org/PR35573
+// XFAIL: *
+
 // rdar://problem/9246208
 
 // Basic test.
 namespace test0 {
   struct A {
     A();
     int x;
   };
namespace test4 {
   };
 
   typedef A elt;
 
   // CHECK:    define [[A:%.*]]* @_ZN5test44testEs(i16 signext
   // CHECK:      [[N:%.*]] = sext i16 {{%.*}} to i32
   // CHECK-NEXT: [[T0:%.*]] = icmp slt i32 [[N]], 0
   // CHECK-NEXT: [[T1:%.*]] = select i1 [[T0]], i32 -1, i32 [[N]]
   // CHECK-NEXT: call i8* @_Znaj(i32 [[T1]])
   // CHECK:      getelementptr inbounds {{.*}}, i32 [[N]]
   elt *test(short s) {
     return new elt[s];
   }
 }
 
 // test4 with no sext required.
 namespace test5 {

clang/test/CodeGenCXX/new.cpp

void test1b(void *p) {
     new (p, true) A[5];
   }
 
   // TODO: it's okay if all these size calculations get dropped.
   // FIXME: maybe we should try to throw on overflow?
   // CHECK-LABEL:    define void @_ZN6test155test2EPvi(
   // CHECK:      [[N:%.*]] = load i32, i32*
   // CHECK-NEXT: [[T0:%.*]] = sext i32 [[N]] to i64
-  // CHECK-NEXT: [[T1:%.*]] = icmp slt i64 [[T0]], 0
-  // CHECK-NEXT: [[T2:%.*]] = select i1 [[T1]], i64 -1, i64 [[T0]]
   // CHECK-NEXT: [[P:%.*]] = load i8*, i8**
   // CHECK:      [[BEGIN:%.*]] = bitcast i8* [[P]] to [[A:%.*]]*
   // CHECK-NEXT: [[ISEMPTY:%.*]] = icmp eq i64 [[T0]], 0
   // CHECK-NEXT: br i1 [[ISEMPTY]],
   // CHECK:      [[END:%.*]] = getelementptr inbounds [[A]], [[A]]* [[BEGIN]], i64 [[T0]]
   // CHECK-NEXT: br label
   // CHECK:      [[CUR:%.*]] = phi [[A]]* [ [[BEGIN]],
   // CHECK-NEXT: call void @_ZN6test151AC1Ev([[A]]* [[CUR]])

clang/test/CodeGenCXX/vtable-available-externally.cpp

 // RUN: %clang_cc1 %s -I%S -triple=x86_64-apple-darwin10 -emit-llvm -o %t
 // RUN: %clang_cc1 %s -I%S -triple=x86_64-apple-darwin10 -O2 -disable-llvm-passes -emit-llvm -o %t.opt
 // RUN: FileCheck --check-prefix=CHECK-TEST1 %s < %t
 // RUN: FileCheck --check-prefix=CHECK-TEST2 %s < %t
 // RUN: FileCheck --check-prefix=CHECK-TEST5 %s < %t
 // RUN: FileCheck --check-prefix=CHECK-TEST8 %s < %t.opt
 // RUN: FileCheck --check-prefix=CHECK-TEST9 %s < %t.opt
 // RUN: FileCheck --check-prefix=CHECK-TEST10 %s < %t.opt
 // RUN: FileCheck --check-prefix=CHECK-TEST11 %s < %t.opt
 // RUN: FileCheck --check-prefix=CHECK-TEST12 %s < %t.opt
 // RUN: FileCheck --check-prefix=CHECK-TEST13 %s < %t.opt

 
 }  // Test10
 
 namespace Test11 {
 struct D;
 // Can emit C's vtable available_externally.
 // CHECK-TEST11: @_ZTVN6Test111CE = available_externally unnamed_addr constant
 struct C {
   virtual D& operator=(const D&);
 };
 
 // Can emit D's vtable available_externally.
 // CHECK-TEST11: @_ZTVN6Test111DE = available_externally unnamed_addr constant
 struct D : C {
   virtual void key();
 };
 D f();
 
 void g(D& a) {
   C c;
   c = a;
   a.key();
   a.key();
 }
 void g() {
   D d;
   d = f();
+  d = d;
   g(d);
 }
 }  // Test 11
 
 namespace Test12 {
 
 // CHECK-TEST12: @_ZTVN6Test121AE = external unnamed_addr constant
 struct A {

clang/test/Lexer/cxx-features.cpp

 // RUN: %clang_cc1 -std=c++98 -fcxx-exceptions -verify %s
 // RUN: %clang_cc1 -std=c++11 -fcxx-exceptions -verify %s
 // RUN: %clang_cc1 -std=c++1y -fcxx-exceptions -fsized-deallocation -verify %s
 // RUN: %clang_cc1 -std=c++14 -fcxx-exceptions -fsized-deallocation -verify %s
 // RUN: %clang_cc1 -std=c++1z -fcxx-exceptions -fsized-deallocation -verify %s
 // RUN: %clang_cc1 -std=c++1z -fcxx-exceptions -fsized-deallocation -fconcepts-ts -DCONCEPTS_TS=1 -verify %s
-// RUN: %clang_cc1 -fno-rtti -fno-threadsafe-statics -verify %s -DNO_EXCEPTIONS -DNO_RTTI -DNO_THREADSAFE_STATICS
-// RUN: %clang_cc1 -fcoroutines-ts -DNO_EXCEPTIONS -DCOROUTINES -verify %s
+// RUN: %clang_cc1 -fno-rtti -fno-threadsafe-statics -verify %s -DNO_EXCEPTIONS -DNO_RTTI -DNO_THREADSAFE_STATICS -fsized-deallocation
+// RUN: %clang_cc1 -fcoroutines-ts -DNO_EXCEPTIONS -DCOROUTINES -verify -fsized-deallocation %s
 
 // expected-no-diagnostics
 
 // FIXME using `defined` in a macro has undefined behavior.
 #if __cplusplus < 201103L
 #define check(macro, cxx98, cxx11, cxx14, cxx1z) cxx98 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx98
 #elif __cplusplus < 201402L
 #define check(macro, cxx98, cxx11, cxx14, cxx1z) cxx11 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx11

clang/test/Lexer/half-literal.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -pedantic %s
-float a = 1.0h; // expected-error{{invalid suffix 'h' on floating constant}}
+float a = 1.0h; // expected-error{{no matching literal operator for call to 'operator""h' with argument of type 'long double' or 'const char *', and no matching literal operator template}}
 float b = 1.0H; // expected-error{{invalid suffix 'H' on floating constant}}
 
 _Float16 c = 1.f166; // expected-error{{invalid suffix 'f166' on floating constant}}
 _Float16 d = 1.f1;   // expected-error{{invalid suffix 'f1' on floating constant}}

clang/test/OpenMP/taskloop_reduction_codegen.cpp

-// RUN: %clang_cc1 -fopenmp -x c++ %s -verify -debug-info-kind=limited -emit-llvm -o - -triple powerpc64le-unknown-linux-gnu | FileCheck %s
+// RUN: %clang_cc1 -fopenmp -x c++ %s -verify -debug-info-kind=limited -emit-llvm -o - -triple powerpc64le-unknown-linux-gnu -std=c++98 | FileCheck %s
 // expected-no-diagnostics
 
 struct S {
   float a;
   S() : a(0.0f) {}
   ~S() {}
 };
 

clang/test/OpenMP/taskloop_simd_reduction_codegen.cpp

-// RUN: %clang_cc1 -fopenmp -x c++ %s -verify -debug-info-kind=limited -emit-llvm -o - -triple powerpc64le-unknown-linux-gnu | FileCheck %s
+// RUN: %clang_cc1 -fopenmp -x c++ %s -verify -debug-info-kind=limited -emit-llvm -o - -triple powerpc64le-unknown-linux-gnu -std=c++98 | FileCheck %s
 // expected-no-diagnostics
 
 struct S {
   float a;
   S() : a(0.0f) {}
   ~S() {}
 };
 

clang/test/Parser/cxx1z-nested-namespace-definition.cpp

 // RUN: cp %s %t
-// RUN: %clang_cc1 -fsyntax-only -verify %s
-// RUN: not %clang_cc1 -x c++ -fixit %t -Werror -DFIXIT
-// RUN: %clang_cc1 -x c++ %t -DFIXIT
+// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++98
+// RUN: not %clang_cc1 -std=c++98 -x c++ -fixit %t -Werror -DFIXIT
+// RUN: %clang_cc1 -std=c++98 -x c++ %t -DFIXIT
 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++17 -Wc++14-compat
 
 namespace foo1::foo2::foo3 {
 #if __cplusplus <= 201400L
 // expected-warning@-2 {{nested namespace definition is a C++17 extension; define each namespace separately}}
 #else
 // expected-warning@-4 {{nested namespace definition is incompatible with C++ standards before C++17}}
 #endif

clang/test/SemaCXX/new-array-size-conv.cpp

-// RUN: %clang_cc1 -fsyntax-only -pedantic -verify %s
+// RUN: %clang_cc1 -fsyntax-only -pedantic -verify -std=gnu++98 %s
 // RUN: %clang_cc1 -fsyntax-only -pedantic -verify -std=c++98 %s
 // RUN: %clang_cc1 -fsyntax-only -pedantic -verify -std=c++11 %s
 
 struct ValueInt
 {
   ValueInt(int v = 0) : ValueLength(v) {}
   operator int () const { return ValueLength; } // expected-note 3{{conversion to integral type 'int' declared here}}
 private:

clang/test/SemaCXX/new-delete.cpp

 {
   int i = 1; // expected-note 2{{here}}
   (void)new; // expected-error {{expected a type}}
   (void)new 4; // expected-error {{expected a type}}
   (void)new () int; // expected-error {{expected expression}}
   (void)new int[1.1];
 #if __cplusplus <= 199711L
   // expected-error@-2 {{array size expression must have integral or enumeration type, not 'double'}}
-#else
+#elif __cplusplus <= 201103L
   // expected-error@-4 {{array size expression must have integral or unscoped enumeration type, not 'double'}}
+#else
+  // expected-warning@-6 {{implicit conversion from 'double' to 'unsigned int' changes value from 1.1 to 1}}
 #endif
 
-  (void)new int[1][i]; // expected-error {{only the first dimension}} expected-note {{read of non-const variable 'i' is not allowed in a constant expression}}
-  (void)new (int[1][i]); // expected-error {{only the first dimension}} expected-note {{read of non-const variable 'i' is not allowed in a constant expression}}
+  (void)new int[1][i];  // expected-note {{read of non-const variable 'i' is not allowed in a constant expression}}
+  (void)new (int[1][i]); // expected-note {{read of non-const variable 'i' is not allowed in a constant expression}}
+#if __cplusplus <= 201103L
+  // expected-error@-3 {{only the first dimension}}
+  // expected-error@-3 {{only the first dimension}}
+#else
+  // expected-error@-6 {{array size is not a constant expression}}
+  // expected-error@-6 {{array size is not a constant expression}}
+#endif
   (void)new (int[i]); // expected-warning {{when type is in parentheses}}
   (void)new int(*(S*)0); // expected-error {{no viable conversion from 'S' to 'int'}}
   (void)new int(1, 2); // expected-error {{excess elements in scalar initializer}}
   (void)new S(1); // expected-error {{no matching constructor}}
   (void)new S(1, 1); // expected-error {{call to constructor of 'S' is ambiguous}}
   (void)new const int; // expected-error {{default initialization of an object of const type 'const int'}}
   (void)new float*(ip); // expected-error {{cannot initialize a new value of type 'float *' with an lvalue of type 'int *'}}
   // Undefined, but clang should reject it directly.
-  (void)new int[-1]; // expected-error {{array size is negative}}
+  (void)new int[-1];
+#if __cplusplus <= 201103L
+  // expected-error@-2 {{array size is negative}}
+#else
+  // expected-error@-4 {{array is too large}}
+#endif
   (void)new int[2000000000]; // expected-error {{array is too large}}
   (void)new int[*(S*)0];
 #if __cplusplus <= 199711L
   // expected-error@-2 {{array size expression must have integral or enumeration type, not 'S'}}
-#else
+#elif __cplusplus <= 201103L
   // expected-error@-4 {{array size expression must have integral or unscoped enumeration type, not 'S'}}
+#else
+  // expected-error@-6 {{converting 'S' to incompatible type}}
 #endif
 
   (void)::S::new int; // expected-error {{expected unqualified-id}}
   (void)new (0, 0) int; // expected-error {{no matching function for call to 'operator new'}}
   (void)new (0L) int; // expected-error {{call to 'operator new' is ambiguous}}
   // This must fail, because the member version shouldn't be found.
   (void)::new ((S*)0) U; // expected-error {{no matching function for call to 'operator new'}}
   // This must fail, because any member version hides all global versions.

clang/test/SemaCXX/unknown-type-name.cpp

 A<T>::m(T::value, 0); // ok
 
 template<typename T> int A<T>::h(T::type, int) {} // expected-error{{missing 'typename'}}
 template<typename T> int A<T>::h(T::type x, char) {} // expected-error{{missing 'typename'}}
 
 template<typename T> int h(T::type, int); // expected-error{{missing 'typename'}}
 template<typename T> int h(T::type x, char); // expected-error{{missing 'typename'}}
 
-template<typename T> int junk1(T::junk); // expected-warning{{variable templates are a C++14 extension}}
+template<typename T> int junk1(T::junk);
+#if __cplusplus <= 201103L
+// expected-warning@-2 {{variable templates are a C++14 extension}}
+#endif
 template<typename T> int junk2(T::junk) throw(); // expected-error{{missing 'typename'}}
 template<typename T> int junk3(T::junk) = delete; // expected-error{{missing 'typename'}}
 #if __cplusplus <= 199711L
 //expected-warning@-2 {{deleted function definitions are a C++11 extension}}
 #endif
 
 template<typename T> int junk4(T::junk j); // expected-error{{missing 'typename'}}
 
-// FIXME: We can tell this was intended to be a function because it does not
-//        have a dependent nested name specifier.
-template<typename T> int i(T::type, int()); // expected-warning{{variable templates are a C++14 extension}}
+template<typename T> int i(T::type, int());
+#if __cplusplus <= 201103L
+// expected-warning@-2 {{variable templates are a C++14 extension}}
+#endif
+
 
 // FIXME: We know which type specifier should have been specified here. Provide
 //        a fix-it to add 'typename A<T>::type'
 template<typename T>
 A<T>::g() { } // expected-error{{requires a type specifier}}

clang/test/SemaTemplate/class-template-decl.cpp

 public:
   template<typename T> class C;
 };
 
 void f() {
   template<typename T> class X; // expected-error{{expression}}
 }
 
-template<typename T> class X1 var; // expected-warning{{variable templates are a C++14 extension}} \
-                                   // expected-error {{variable has incomplete type 'class X1'}} \
+template<typename T> class X1 var; // expected-error {{variable has incomplete type 'class X1'}} \
                                    // expected-note {{forward declaration of 'X1'}}
 
 namespace M {
 }
 
 template<typename T> class M::C3 { }; // expected-error{{out-of-line definition of 'C3' does not match any declaration in namespace 'M'}}
 
 namespace PR8001 {

clang/test/SemaTemplate/explicit-instantiation.cpp

namespace PR10086 {
   int func() {
     foobar(5);
   }
 }
 
 namespace undefined_static_data_member {
   template<typename T> struct A {
     static int a; // expected-note {{here}}
-    template<typename U> static int b; // expected-note {{here}} expected-warning {{extension}}
+    template<typename U> static int b; // expected-note {{here}} expected-warning 0+ {{extension}}
   };
   struct B {
-    template<typename U> static int c; // expected-note {{here}} expected-warning {{extension}}
+    template<typename U> static int c; // expected-note {{here}} expected-warning 0+ {{extension}}
   };
 
   template int A<int>::a; // expected-error {{explicit instantiation of undefined static data member 'a' of class template 'undefined_static_data_member::A<int>'}}
   template int A<int>::b<int>; // expected-error {{explicit instantiation of undefined variable template 'undefined_static_data_member::A<int>::b<int>'}}
   template int B::c<int>; // expected-error {{explicit instantiation of undefined variable template 'undefined_static_data_member::B::c<int>'}}
 
 
   template<typename T> struct C {
     static int a;
-    template<typename U> static int b; // expected-warning {{extension}}
+    template<typename U> static int b; // expected-warning 0+ {{extension}}
   };
   struct D {
-    template<typename U> static int c; // expected-warning {{extension}}
+    template<typename U> static int c; // expected-warning 0+ {{extension}}
   };
   template<typename T> int C<T>::a;
-  template<typename T> template<typename U> int C<T>::b; // expected-warning {{extension}}
-  template<typename U> int D::c; // expected-warning {{extension}}
+  template<typename T> template<typename U> int C<T>::b; // expected-warning 0+ {{extension}}
+  template<typename U> int D::c; // expected-warning 0+ {{extension}}
 
   template int C<int>::a;
   template int C<int>::b<int>;
   template int D::c<int>;
 }
 
 // expected-note@+1 3-4 {{explicit instantiation refers here}}
 template <class T> void Foo(T i) throw(T) { throw i; }