Vendor import of clang trunk r126079:

http://llvm.org/svn/llvm-project/cfe/trunk@126079
author: dim <dim@FreeBSD.org> 2011-02-20 13:06:31 +0000
committer: dim <dim@FreeBSD.org> 2011-02-20 13:06:31 +0000
commit: 39fcc9a984e2820e4ea0fa2ac4abd17d9f3a31df (patch)
tree: a9243275843fbeaa590afc07ee888e006b8d54ea /test/CXX/dcl.decl/dcl.init
parent: 69b4eca4a4255ba43baa5c1d9bbdec3ec17f479e (diff)
download: FreeBSD-src-39fcc9a984e2820e4ea0fa2ac4abd17d9f3a31df.zip
FreeBSD-src-39fcc9a984e2820e4ea0fa2ac4abd17d9f3a31df.tar.gz
5 files changed, 189 insertions, 25 deletions
diff --git a/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-0x.cpp b/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-0x.cpp
new file mode 100644
index 0000000..7b0fb9c
--- /dev/null
+++ b/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-0x.cpp
@@ -0,0 +1,164 @@
+// RUN: %clang_cc1 -std=c++0x -fsyntax-only -verify -pedantic %s
+
+// Test the C++0x-specific reference initialization rules, e.g., the
+// rules for rvalue references.
+template<typename T> T prvalue();
+template<typename T> T&& xvalue();
+template<typename T> T& lvalue();
+
+struct Base { };
+struct Derived : Base { };
+
+struct HasArray {
+  int array[5];
+};
+
+int f(int);
+
+template<typename T>
+struct ConvertsTo {
+  operator T(); // expected-note 4{{candidate function}}
+};
+
+void test_rvalue_refs() {
+  // If the initializer expression...
+  //   - is an xvalue, class prvalue, array prvalue or function lvalue
+  //     and "cv1 T1" is reference-compatible with "cv2 T2", or
+
+  // xvalue case
+  Base&& base0 = xvalue<Base>();
+  Base&& base1 = xvalue<Derived>();
+  int&& int0 = xvalue<int>();
+
+  // class prvalue case
+  Base&& base2 = prvalue<Base>();
+  Base&& base3 = prvalue<Derived>();
+
+  // array prvalue case
+  int (&&array0)[5] = HasArray().array;
+
+  // function lvalue case
+  int (&&function0)(int) = f;
+
+  //   - has a class type (i.e., T2 is a class type), where T1 is not
+  //     reference-related to T2, and can be implicitly converted to
+  //     an xvalue, class prvalue, or function lvalue of type "cv3
+  //     T3", where "cv1 T1" is reference-compatible with "cv3 T3",
+
+  // xvalue
+  Base&& base4 = ConvertsTo<Base&&>();
+  Base&& base5 = ConvertsTo<Derived&&>();
+  int && int1 = ConvertsTo<int&&>();
+
+  // class prvalue
+  Base&& base6 = ConvertsTo<Base>();
+  Base&& base7 = ConvertsTo<Derived>();
+
+  // function lvalue
+  int (&&function1)(int) = ConvertsTo<int(&)(int)>();
+
+  // In the second case, if the reference is an rvalue reference and
+  // the second standard conversion sequence of the user-defined
+  // conversion sequence includes an lvalue-to-rvalue conversion, the
+  // program is ill-formed.
+  int &&int2 = ConvertsTo<int&>(); // expected-error{{no viable conversion from 'ConvertsTo<int &>' to 'int'}}
+  int &&int3 = ConvertsTo<float&>(); // expected-error{{no viable conversion from 'ConvertsTo<float &>' to 'int'}}
+}
+
+class NonCopyable {
+  NonCopyable(const NonCopyable&);
+};
+
+class NonCopyableDerived : public NonCopyable {
+  NonCopyableDerived(const NonCopyableDerived&);
+};
+
+// Make sure we get direct bindings with no copies.
+void test_direct_binding() {
+  NonCopyable &&nc0 = prvalue<NonCopyable>();
+  NonCopyable &&nc1 = prvalue<NonCopyableDerived>();
+  NonCopyable &&nc2 = xvalue<NonCopyable>();
+  NonCopyable &&nc3 = xvalue<NonCopyableDerived>();
+  const NonCopyable &nc4 = prvalue<NonCopyable>();
+  const NonCopyable &nc5 = prvalue<NonCopyableDerived>();
+  const NonCopyable &nc6 = xvalue<NonCopyable>();
+  const NonCopyable &nc7 = xvalue<NonCopyableDerived>();
+  NonCopyable &&nc8 = ConvertsTo<NonCopyable&&>();
+  NonCopyable &&nc9 = ConvertsTo<NonCopyableDerived&&>();
+  const NonCopyable &nc10 = ConvertsTo<NonCopyable&&>();
+  const NonCopyable &nc11 = ConvertsTo<NonCopyableDerived&&>();
+}
+
+namespace std_example_1 {
+  double d = 2.0; 
+  double& rd = d; 
+  const double& rcd = d;
+  struct A { }; 
+  struct B : A { 
+    operator int&();
+  } b;
+  A& ra = b; 
+  const A& rca = b; 
+  int& ir = B();
+}
+
+namespace std_example_2 {
+  double& rd2 = 2.0; // expected-error{{non-const lvalue reference to type 'double' cannot bind to a temporary of type 'double'}}
+  int i = 2; 
+  double& rd3 = i; // expected-error{{non-const lvalue reference to type 'double' cannot bind to a value of unrelated type 'int'}}
+  struct A { }; 
+  struct B : A { } b; 
+  extern B f(); 
+  const A& rca = f(); 
+  A&& rra = f();
+  struct X { 
+    operator B();  // expected-note{{candidate function}}
+    operator int&(); // expected-note{{candidate function}}
+  } x;
+  const A& r = x;
+  int&& rri = static_cast<int&&>(i);
+  B&& rrb = x;
+  int&& rri2 = X(); // expected-error{{no viable conversion from 'std_example_2::X' to 'int'}}
+
+  const double& rcd2 = 2;
+  double&& rrd = 2;
+  const volatile int cvi = 1; 
+  const int& r2 = cvi; // expected-error{{binding of reference to type 'const int' to a value of type 'const volatile int' drops qualifiers}}
+
+  double d;
+  double&& rrd2 = d; // expected-error{{rvalue reference to type 'double' cannot bind to lvalue of type 'double'}}
+  double&& rrd3 = i;
+}
+
+namespace argument_passing {
+  void base_rvalue_ref(Base&&);
+  void int_rvalue_ref(int&&); // expected-note 2{{passing argument to parameter here}}
+  void array_rvalue_ref(int (&&)[5]);
+  void function_rvalue_ref(int (&&)(int));
+
+  void test() {
+    base_rvalue_ref(xvalue<Base>());
+    base_rvalue_ref(xvalue<Derived>());
+    int_rvalue_ref(xvalue<int>());
+    
+    base_rvalue_ref(prvalue<Base>());
+    base_rvalue_ref(prvalue<Derived>());
+    
+    array_rvalue_ref(HasArray().array);
+    
+    function_rvalue_ref(f);
+    
+    base_rvalue_ref(ConvertsTo<Base&&>());
+    base_rvalue_ref(ConvertsTo<Derived&&>());
+    int_rvalue_ref(ConvertsTo<int&&>());
+    
+    base_rvalue_ref(ConvertsTo<Base>());
+    base_rvalue_ref(ConvertsTo<Derived>());
+
+    function_rvalue_ref(ConvertsTo<int(&)(int)>());
+    
+    int_rvalue_ref(ConvertsTo<int&>()); // expected-error{{no viable conversion from 'ConvertsTo<int &>' to 'int'}}
+    int_rvalue_ref(ConvertsTo<float&>()); // expected-error{{no viable conversion from 'ConvertsTo<float &>' to 'int'}}
+  }
+
+}
diff --git a/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-cxx03-extra-copy.cpp b/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-cxx03-extra-copy.cpp
index ae59598..8c65411 100644
--- a/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-cxx03-extra-copy.cpp
+++ b/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-cxx03-extra-copy.cpp
@@ -53,7 +53,7 @@ void g4(const X4<int>&);
 void g5(const X5&);
 
 void test() {
-  g1(X1()); // expected-warning{{no viable constructor copying parameter of type 'X1'; C++98 requires a copy constructor when binding a reference to a temporary [-Wbind-to-temporary-copy]}}
+  g1(X1());
   g2(X2()); // expected-warning{{C++98 requires an accessible copy constructor for class 'X2' when binding a reference to a temporary; was private [-Wbind-to-temporary-copy]}}
   g3(X3()); // expected-warning{{no viable constructor copying parameter of type 'X3'}}
   g4(X4<int>());
diff --git a/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-examples.cpp b/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-examples.cpp
index 9b39259..08d9639 100644
--- a/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-examples.cpp
+++ b/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-examples.cpp
@@ -6,8 +6,8 @@ void example0() {
   // CHECK: double &rd =
   // CHECK-NEXT: DeclRefExpr
   double &rd = d;
-  // CHECK: double const &rcd =
-  // CHECK-NEXT: ImplicitCastExpr{{.*}}'double const' <NoOp>
+  // CHECK: const double &rcd =
+  // CHECK-NEXT: ImplicitCastExpr{{.*}}'const double' lvalue <NoOp>
   const double &rcd = d;
 }
 
@@ -17,11 +17,11 @@ struct B : A { } b;
 // CHECK: example1
 void example1() {
   // CHECK: A &ra =
-  // CHECK: ImplicitCastExpr{{.*}}'struct A' <DerivedToBase (A)> lvalue
+  // CHECK: ImplicitCastExpr{{.*}}'struct A' lvalue <DerivedToBase (A)>
   A &ra = b;
-  // CHECK: A const &rca =
-  // CHECK: ImplicitCastExpr{{.*}}'struct A const' <NoOp>
-  // CHECK: ImplicitCastExpr{{.*}}'struct A' <DerivedToBase (A)>
+  // CHECK: const A &rca =
+  // CHECK: ImplicitCastExpr{{.*}}'const struct A' lvalue <NoOp>
+  // CHECK: ImplicitCastExpr{{.*}}'struct A' lvalue <DerivedToBase (A)>
   const A& rca = b;
 }
 
@@ -33,13 +33,13 @@ struct X {
 
 // CHECK: example2
 void example2() {
-  // CHECK: A const &rca =
-  // CHECK: ImplicitCastExpr{{.*}}'struct A const' <NoOp>
+  // CHECK: const A &rca =
+  // CHECK: ImplicitCastExpr{{.*}}'const struct A' <NoOp>
   // CHECK: ImplicitCastExpr{{.*}}'struct A' <DerivedToBase (A)>
   // CHECK: CallExpr{{.*}}B
   const A &rca = f(); 
-  // CHECK: A const &r =
-  // CHECK: ImplicitCastExpr{{.*}}'struct A const' <NoOp>
+  // CHECK: const A &r =
+  // CHECK: ImplicitCastExpr{{.*}}'const struct A' <NoOp>
   // CHECK: ImplicitCastExpr{{.*}}'struct A' <DerivedToBase (A)>
   // CHECK: CXXMemberCallExpr{{.*}}'struct B'
   const A& r = x;
@@ -47,7 +47,7 @@ void example2() {
 
 // CHECK: example3
 void example3() {
-  // CHECK: double const &rcd2 =
-  // CHECK: ImplicitCastExpr{{.*}}<IntegralToFloating>
+  // CHECK: const double &rcd2 =
+  // CHECK: ImplicitCastExpr{{.*}} <IntegralToFloating>
   const double& rcd2 = 2; 
 }
diff --git a/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-var.cpp b/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-var.cpp
index 6a039b9..fee5f96 100644
--- a/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-var.cpp
+++ b/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-var.cpp
@@ -1,6 +1,6 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
-struct Base { }; // expected-note{{candidate is the implicit copy constructor}}
+struct Base { };
 struct Derived : Base { }; // expected-note{{candidate constructor (the implicit copy constructor) not viable}}
 struct Unrelated { };
 struct Derived2 : Base { };
@@ -64,10 +64,10 @@ void bind_lvalue_quals(volatile Base b, volatile Derived d,
                        volatile const int ivc) {
   volatile Base &bvr1 = b;
   volatile Base &bvr2 = d;
-  volatile Base &bvr3 = bvc; // expected-error{{binding of reference to type 'Base volatile' to a value of type 'Base const volatile' drops qualifiers}}
-  volatile Base &bvr4 = dvc; // expected-error{{binding of reference to type 'Base volatile' to a value of type 'Derived const volatile' drops qualifiers}}
+  volatile Base &bvr3 = bvc; // expected-error{{binding of reference to type 'volatile Base' to a value of type 'const volatile Base' drops qualifiers}}
+  volatile Base &bvr4 = dvc; // expected-error{{binding of reference to type 'volatile Base' to a value of type 'const volatile Derived' drops qualifiers}}
   
-  volatile int &ir = ivc; // expected-error{{binding of reference to type 'int volatile' to a value of type 'int const volatile' drops qualifiers}}
+  volatile int &ir = ivc; // expected-error{{binding of reference to type 'volatile int' to a value of type 'const volatile int' drops qualifiers}}
 
   const volatile Base &bcvr1 = b;
   const volatile Base &bcvr2 = d;
@@ -76,15 +76,15 @@ void bind_lvalue_quals(volatile Base b, volatile Derived d,
 void bind_lvalue_to_rvalue() {
   Base &br1 = Base(); // expected-error{{non-const lvalue reference to type 'Base' cannot bind to a temporary of type 'Base'}}
   Base &br2 = Derived(); // expected-error{{non-const lvalue reference to type 'Base' cannot bind to a temporary of type 'Derived'}}
-  const volatile Base &br3 = Base(); // expected-error{{volatile lvalue reference to type 'Base const volatile' cannot bind to a temporary of type 'Base'}}
-  const volatile Base &br4 = Derived(); // expected-error{{volatile lvalue reference to type 'Base const volatile' cannot bind to a temporary of type 'Derived'}}
+  const volatile Base &br3 = Base(); // expected-error{{volatile lvalue reference to type 'const volatile Base' cannot bind to a temporary of type 'Base'}}
+  const volatile Base &br4 = Derived(); // expected-error{{volatile lvalue reference to type 'const volatile Base' cannot bind to a temporary of type 'Derived'}}
 
   int &ir = 17; // expected-error{{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
 }
 
 void bind_lvalue_to_unrelated(Unrelated ur) {
   Base &br1 = ur; // expected-error{{non-const lvalue reference to type 'Base' cannot bind to a value of unrelated type 'Unrelated'}}
-  const volatile Base &br2 = ur; // expected-error{{volatile lvalue reference to type 'Base const volatile' cannot bind to a value of unrelated type 'Unrelated'}}
+  const volatile Base &br2 = ur; // expected-error{{volatile lvalue reference to type 'const volatile Base' cannot bind to a value of unrelated type 'Unrelated'}}
 }
 
 void bind_lvalue_to_conv_lvalue() {
@@ -118,8 +118,8 @@ void bind_const_lvalue_to_rvalue() {
   const Base &br3 = create<const Base>();
   const Base &br4 = create<const Derived>();
 
-  const Base &br5 = create<const volatile Base>(); // expected-error{{binding of reference to type 'Base const' to a value of type 'Base const volatile' drops qualifiers}}
-  const Base &br6 = create<const volatile Derived>(); // expected-error{{binding of reference to type 'Base const' to a value of type 'Derived const volatile' drops qualifiers}}
+  const Base &br5 = create<const volatile Base>(); // expected-error{{binding of reference to type 'const Base' to a value of type 'const volatile Base' drops qualifiers}}
+  const Base &br6 = create<const volatile Derived>(); // expected-error{{binding of reference to type 'const Base' to a value of type 'const volatile Derived' drops qualifiers}}
 
   const int &ir = create<int>();
 }
@@ -131,5 +131,5 @@ void bind_const_lvalue_to_class_conv_temporary() {
 }
 void bind_lvalue_to_conv_rvalue_ambig(ConvertibleToBothDerived both) {
   const Derived &dr1 = both;
-  const Base &br1 = both; // expected-error{{reference initialization of type 'Base const &' with initializer of type 'ConvertibleToBothDerived' is ambiguous}}
+  const Base &br1 = both; // expected-error{{reference initialization of type 'const Base &' with initializer of type 'ConvertibleToBothDerived' is ambiguous}}
 }
diff --git a/test/CXX/dcl.decl/dcl.init/p6.cpp b/test/CXX/dcl.decl/dcl.init/p6.cpp
index c542dac..da6f5b5 100644
--- a/test/CXX/dcl.decl/dcl.init/p6.cpp
+++ b/test/CXX/dcl.decl/dcl.init/p6.cpp
@@ -10,7 +10,7 @@ struct NoUserDefault : public MakeNonPOD { };
 struct HasUserDefault { HasUserDefault(); };
 
 void test_const_default_init() {
-  const NoUserDefault x1; // expected-error{{default initialization of an object of const type 'NoUserDefault const' requires a user-provided default constructor}}
+  const NoUserDefault x1; // expected-error{{default initialization of an object of const type 'const NoUserDefault' requires a user-provided default constructor}}
   const HasUserDefault x2;
-  const int x3; // expected-error{{default initialization of an object of const type 'int const'}}
+  const int x3; // expected-error{{default initialization of an object of const type 'const int'}}
 }
author	dim <dim@FreeBSD.org>	2011-02-20 13:06:31 +0000
committer	dim <dim@FreeBSD.org>	2011-02-20 13:06:31 +0000
commit	39fcc9a984e2820e4ea0fa2ac4abd17d9f3a31df (patch)
tree	a9243275843fbeaa590afc07ee888e006b8d54ea /test/CXX/dcl.decl/dcl.init
parent	69b4eca4a4255ba43baa5c1d9bbdec3ec17f479e (diff)
download	FreeBSD-src-39fcc9a984e2820e4ea0fa2ac4abd17d9f3a31df.zip FreeBSD-src-39fcc9a984e2820e4ea0fa2ac4abd17d9f3a31df.tar.gz