2011-10-14 06:29:44 +08:00
// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 -Wsign-conversion %s
2009-04-17 01:51:27 +08:00
// C++ rules for ?: are a lot stricter than C rules, and have to take into
// account more conversion options.
2012-08-08 14:13:49 +08:00
// This test runs in C++11 mode for the contextual conversion of the condition.
2009-04-17 01:51:27 +08:00
struct ToBool { explicit operator bool ( ) ; } ;
struct B ;
2011-01-25 00:14:37 +08:00
struct A {
A ( ) ;
A ( const B & ) ; // expected-note 2 {{candidate constructor}}
} ;
2010-01-12 08:44:57 +08:00
struct B { operator A ( ) const ; } ; // expected-note 2 {{candidate function}}
2009-04-17 01:51:27 +08:00
struct I { operator int ( ) ; } ;
struct J { operator I ( ) ; } ;
struct K { operator double ( ) ; } ;
typedef void ( * vfn ) ( ) ;
struct F { operator vfn ( ) ; } ;
struct G { operator vfn ( ) ; } ;
struct Base {
int trick ( ) ;
A trick ( ) const ;
2009-04-18 00:30:52 +08:00
void fn1 ( ) ;
} ;
struct Derived : Base {
void fn2 ( ) ;
2009-04-17 01:51:27 +08:00
} ;
struct Convertible { operator Base & ( ) ; } ;
2010-02-10 17:31:12 +08:00
struct Priv : private Base { } ; // expected-note 4 {{declared private here}}
2009-04-17 01:51:27 +08:00
struct Mid : Base { } ;
struct Fin : Mid , Derived { } ;
2009-04-18 00:30:52 +08:00
typedef void ( Derived : : * DFnPtr ) ( ) ;
struct ToMemPtr { operator DFnPtr ( ) ; } ;
2009-04-17 01:51:27 +08:00
struct BadDerived ;
struct BadBase { operator BadDerived & ( ) ; } ;
struct BadDerived : BadBase { } ;
struct Fields {
int i1 , i2 , b1 : 3 , b2 : 3 ;
} ;
2009-04-20 05:15:26 +08:00
struct MixedFields {
int i ;
volatile int vi ;
const int ci ;
const volatile int cvi ;
} ;
struct MixedFieldsDerived : MixedFields {
} ;
2009-04-17 01:51:27 +08:00
enum Enum { EVal } ;
struct Ambig {
2010-01-12 08:44:57 +08:00
operator short ( ) ; // expected-note 2 {{candidate function}}
operator signed char ( ) ; // expected-note 2 {{candidate function}}
2009-04-17 01:51:27 +08:00
} ;
2012-09-11 06:05:41 +08:00
struct Abstract {
virtual ~ Abstract ( ) = 0 ; // expected-note {{unimplemented pure virtual method '~Abstract' in 'Abstract'}}
} ;
struct Derived1 : Abstract {
} ;
struct Derived2 : Abstract {
} ;
2009-04-17 01:51:27 +08:00
void test ( )
{
// This function tests C++0x 5.16
// p1 (contextually convert to bool)
int i1 = ToBool ( ) ? 0 : 1 ;
// p2 (one or both void, and throwing)
2014-01-27 12:19:56 +08:00
Fields flds ;
2009-04-17 01:51:27 +08:00
i1 ? throw 0 : throw 1 ;
i1 ? test ( ) : throw 1 ;
i1 ? throw 0 : test ( ) ;
i1 ? test ( ) : test ( ) ;
i1 = i1 ? throw 0 : 0 ;
i1 = i1 ? 0 : throw 0 ;
2013-06-02 16:40:42 +08:00
i1 = i1 ? ( throw 0 ) : 0 ;
i1 = i1 ? 0 : ( throw 0 ) ;
2009-04-17 01:51:27 +08:00
i1 ? 0 : test ( ) ; // expected-error {{right operand to ? is void, but left operand is of type 'int'}}
i1 ? test ( ) : 0 ; // expected-error {{left operand to ? is void, but right operand is of type 'int'}}
2014-01-27 12:19:56 +08:00
( i1 ? throw 0 : i1 ) = 0 ;
( i1 ? i1 : throw 0 ) = 0 ;
( i1 ? ( throw 0 ) : i1 ) = 0 ;
( i1 ? i1 : ( throw 0 ) ) = 0 ;
( i1 ? ( void ) ( throw 0 ) : i1 ) = 0 ; // expected-error {{left operand to ? is void, but right operand is of type 'int'}}
( i1 ? i1 : ( void ) ( throw 0 ) ) = 0 ; // expected-error {{right operand to ? is void, but left operand is of type 'int'}}
int & throwRef1 = ( i1 ? flds . i1 : throw 0 ) ;
int & throwRef2 = ( i1 ? throw 0 : flds . i1 ) ;
int & throwRef3 = ( i1 ? flds . b1 : throw 0 ) ; // expected-error {{non-const reference cannot bind to bit-field}}
int & throwRef4 = ( i1 ? throw 0 : flds . b1 ) ; // expected-error {{non-const reference cannot bind to bit-field}}
2009-04-17 01:51:27 +08:00
// p3 (one or both class type, convert to each other)
// b1 (lvalues)
Base base ;
Derived derived ;
Convertible conv ;
2009-04-18 00:30:52 +08:00
Base & bar1 = i1 ? base : derived ;
Base & bar2 = i1 ? derived : base ;
Base & bar3 = i1 ? base : conv ;
Base & bar4 = i1 ? conv : base ;
2009-04-17 01:51:27 +08:00
// these are ambiguous
BadBase bb ;
BadDerived bd ;
2010-03-10 19:27:22 +08:00
( void ) ( i1 ? bb : bd ) ; // expected-error {{conditional expression is ambiguous; 'BadBase' can be converted to 'BadDerived' and vice versa}}
2009-04-17 01:51:27 +08:00
( void ) ( i1 ? bd : bb ) ; // expected-error {{conditional expression is ambiguous}}
// curiously enough (and a defect?), these are not
// for rvalues, hierarchy takes precedence over other conversions
( void ) ( i1 ? BadBase ( ) : BadDerived ( ) ) ;
( void ) ( i1 ? BadDerived ( ) : BadBase ( ) ) ;
// b2.1 (hierarchy stuff)
Improve 0-argument -Wvexing-parse diagnostic by adding notes with fix-its:
- If the declarator is at the start of a line, and the previous line contained
another declarator and ended with a comma, then that comma was probably a
typo for a semicolon:
int n = 0, m = 1, l = 2, // k = 5;
myImportantFunctionCall(); // oops!
- If removing the parentheses would correctly initialize the object, then
produce a note suggesting that fix.
- Otherwise, if there is a simple initializer we can suggest which performs
value-initialization, then provide a note suggesting a correction to that
initializer.
Sema::Declarator now tracks the location of the comma prior to the declarator in
the declaration, if there is one, to facilitate providing the note. The code to
determine an appropriate initializer from the -Wuninitialized warning has been
factored out to allow use in both that and -Wvexing-parse.
llvm-svn: 148072
2012-01-13 07:53:29 +08:00
extern const Base constret ( ) ;
extern const Derived constder ( ) ;
2009-04-17 01:51:27 +08:00
// should use const overload
A a1 ( ( i1 ? constret ( ) : Base ( ) ) . trick ( ) ) ;
A a2 ( ( i1 ? Base ( ) : constret ( ) ) . trick ( ) ) ;
A a3 ( ( i1 ? constret ( ) : Derived ( ) ) . trick ( ) ) ;
A a4 ( ( i1 ? Derived ( ) : constret ( ) ) . trick ( ) ) ;
// should use non-const overload
i1 = ( i1 ? Base ( ) : Base ( ) ) . trick ( ) ;
i1 = ( i1 ? Base ( ) : Base ( ) ) . trick ( ) ;
i1 = ( i1 ? Base ( ) : Derived ( ) ) . trick ( ) ;
i1 = ( i1 ? Derived ( ) : Base ( ) ) . trick ( ) ;
// should fail: const lost
2010-09-05 08:17:29 +08:00
( void ) ( i1 ? Base ( ) : constder ( ) ) ; // expected-error {{incompatible operand types ('Base' and 'const Derived')}}
( void ) ( i1 ? constder ( ) : Base ( ) ) ; // expected-error {{incompatible operand types ('const Derived' and 'Base')}}
2009-04-20 05:53:20 +08:00
Priv priv ;
Fin fin ;
2010-02-10 17:31:12 +08:00
( void ) ( i1 ? Base ( ) : Priv ( ) ) ; // expected-error{{private base class}}
( void ) ( i1 ? Priv ( ) : Base ( ) ) ; // expected-error{{private base class}}
2010-03-10 19:27:22 +08:00
( void ) ( i1 ? Base ( ) : Fin ( ) ) ; // expected-error{{ambiguous conversion from derived class 'Fin' to base class 'Base':}}
( void ) ( i1 ? Fin ( ) : Base ( ) ) ; // expected-error{{ambiguous conversion from derived class 'Fin' to base class 'Base':}}
2010-02-10 17:31:12 +08:00
( void ) ( i1 ? base : priv ) ; // expected-error {{private base class}}
( void ) ( i1 ? priv : base ) ; // expected-error {{private base class}}
2010-03-10 19:27:22 +08:00
( void ) ( i1 ? base : fin ) ; // expected-error {{ambiguous conversion from derived class 'Fin' to base class 'Base':}}
( void ) ( i1 ? fin : base ) ; // expected-error {{ambiguous conversion from derived class 'Fin' to base class 'Base':}}
2009-04-17 01:51:27 +08:00
// b2.2 (non-hierarchy)
i1 = i1 ? I ( ) : i1 ;
i1 = i1 ? i1 : I ( ) ;
I i2 ( i1 ? I ( ) : J ( ) ) ;
I i3 ( i1 ? J ( ) : I ( ) ) ;
2018-04-06 23:14:32 +08:00
// "the type [it] would have if E2 were converted to an rvalue"
2009-04-17 01:51:27 +08:00
vfn pfn = i1 ? F ( ) : test ;
pfn = i1 ? test : F ( ) ;
2010-03-10 19:27:22 +08:00
( void ) ( i1 ? A ( ) : B ( ) ) ; // expected-error {{conversion from 'B' to 'A' is ambiguous}}
( void ) ( i1 ? B ( ) : A ( ) ) ; // expected-error {{conversion from 'B' to 'A' is ambiguous}}
( void ) ( i1 ? 1 : Ambig ( ) ) ; // expected-error {{conversion from 'Ambig' to 'int' is ambiguous}}
( void ) ( i1 ? Ambig ( ) : 1 ) ; // expected-error {{conversion from 'Ambig' to 'int' is ambiguous}}
2009-04-18 00:30:52 +08:00
// By the way, this isn't an lvalue:
2013-02-02 10:14:45 +08:00
& ( i1 ? i1 : i2 ) ; // expected-error {{cannot take the address of an rvalue}}
2009-04-17 01:51:27 +08:00
// p4 (lvalue, same type)
2009-04-18 00:30:52 +08:00
int & ir1 = i1 ? flds . i1 : flds . i2 ;
( i1 ? flds . b1 : flds . i2 ) = 0 ;
( i1 ? flds . i1 : flds . b2 ) = 0 ;
( i1 ? flds . b1 : flds . b2 ) = 0 ;
2009-04-17 01:51:27 +08:00
// p5 (conversion to built-in types)
// GCC 4.3 fails these
double d1 = i1 ? I ( ) : K ( ) ;
pfn = i1 ? F ( ) : G ( ) ;
2009-04-18 00:30:52 +08:00
DFnPtr pfm ;
2009-04-20 05:53:20 +08:00
pfm = i1 ? DFnPtr ( ) : & Base : : fn1 ;
pfm = i1 ? & Base : : fn1 : DFnPtr ( ) ;
2009-04-17 01:51:27 +08:00
// p6 (final conversions)
i1 = i1 ? i1 : ir1 ;
int * pi1 = i1 ? & i1 : 0 ;
pi1 = i1 ? 0 : & i1 ;
2010-03-20 02:53:26 +08:00
i1 = i1 ? i1 : EVal ;
i1 = i1 ? EVal : i1 ;
2009-04-17 01:51:27 +08:00
d1 = i1 ? ' c ' : 4.0 ;
d1 = i1 ? 4.0 : ' c ' ;
2009-04-20 03:26:31 +08:00
Base * pb = i1 ? ( Base * ) 0 : ( Derived * ) 0 ;
pb = i1 ? ( Derived * ) 0 : ( Base * ) 0 ;
2009-04-20 05:15:26 +08:00
pfm = i1 ? & Base : : fn1 : & Derived : : fn2 ;
pfm = i1 ? & Derived : : fn2 : & Base : : fn1 ;
pfm = i1 ? & Derived : : fn2 : 0 ;
pfm = i1 ? 0 : & Derived : : fn2 ;
const int ( MixedFieldsDerived : : * mp1 ) =
i1 ? & MixedFields : : ci : & MixedFieldsDerived : : i ;
const volatile int ( MixedFields : : * mp2 ) =
i1 ? & MixedFields : : ci : & MixedFields : : cvi ;
2009-08-25 01:42:35 +08:00
( void ) ( i1 ? & MixedFields : : ci : & MixedFields : : vi ) ;
2009-04-18 00:30:52 +08:00
// Conversion of primitives does not result in an lvalue.
2013-02-02 10:14:45 +08:00
& ( i1 ? i1 : d1 ) ; // expected-error {{cannot take the address of an rvalue}}
2009-04-18 00:30:52 +08:00
2009-09-15 07:15:26 +08:00
( void ) & ( i1 ? flds . b1 : flds . i1 ) ; // expected-error {{address of bit-field requested}}
( void ) & ( i1 ? flds . i1 : flds . b1 ) ; // expected-error {{address of bit-field requested}}
2009-11-05 17:23:39 +08:00
unsigned long test0 = 5 ;
2011-07-21 10:46:28 +08:00
test0 = test0 ? ( long ) test0 : test0 ; // expected-warning {{operand of ? changes signedness: 'long' to 'unsigned long'}}
test0 = test0 ? ( int ) test0 : test0 ; // expected-warning {{operand of ? changes signedness: 'int' to 'unsigned long'}}
test0 = test0 ? ( short ) test0 : test0 ; // expected-warning {{operand of ? changes signedness: 'short' to 'unsigned long'}}
test0 = test0 ? test0 : ( long ) test0 ; // expected-warning {{operand of ? changes signedness: 'long' to 'unsigned long'}}
test0 = test0 ? test0 : ( int ) test0 ; // expected-warning {{operand of ? changes signedness: 'int' to 'unsigned long'}}
test0 = test0 ? test0 : ( short ) test0 ; // expected-warning {{operand of ? changes signedness: 'short' to 'unsigned long'}}
2009-11-05 17:23:39 +08:00
test0 = test0 ? test0 : ( long ) 10 ;
test0 = test0 ? test0 : ( int ) 10 ;
test0 = test0 ? test0 : ( short ) 10 ;
test0 = test0 ? ( long ) 10 : test0 ;
test0 = test0 ? ( int ) 10 : test0 ;
test0 = test0 ? ( short ) 10 : test0 ;
2011-07-21 10:46:28 +08:00
int test1 ;
2009-11-05 17:23:39 +08:00
test0 = test0 ? EVal : test0 ;
2011-07-21 10:46:28 +08:00
test1 = test0 ? EVal : ( int ) test0 ;
test0 = test0 ? EVal : test1 ; // expected-warning {{operand of ? changes signedness: 'int' to 'unsigned long'}}
test0 = test0 ? test1 : EVal ; // expected-warning {{operand of ? changes signedness: 'int' to 'unsigned long'}}
test1 = test0 ? EVal : ( int ) test0 ;
test1 = test0 ? ( int ) test0 : EVal ;
2009-11-05 17:23:39 +08:00
2009-04-17 01:51:27 +08:00
// Note the thing that this does not test: since DR446, various situations
// *must* create a separate temporary copy of class objects. This can only
// be properly tested at runtime, though.
2012-09-11 06:05:41 +08:00
2014-01-27 12:19:56 +08:00
const Abstract & abstract1 = true ? static_cast < const Abstract & > ( Derived1 ( ) ) : Derived2 ( ) ; // expected-error {{allocating an object of abstract class type 'const Abstract'}}
const Abstract & abstract2 = true ? static_cast < const Abstract & > ( Derived1 ( ) ) : throw 3 ; // ok
2009-04-17 01:51:27 +08:00
}
2010-03-27 04:59:55 +08:00
namespace PR6595 {
2010-07-01 11:43:00 +08:00
struct OtherString {
OtherString ( ) ;
OtherString ( const char * ) ;
} ;
2010-03-27 04:59:55 +08:00
struct String {
String ( const char * ) ;
2010-07-01 11:43:00 +08:00
String ( const OtherString & ) ;
2010-03-27 04:59:55 +08:00
operator const char * ( ) const ;
} ;
2010-07-01 11:43:00 +08:00
void f ( bool Cond , String S , OtherString OS ) {
2010-03-27 04:59:55 +08:00
( void ) ( Cond ? S : " " ) ;
( void ) ( Cond ? " " : S ) ;
const char a [ 1 ] = { ' a ' } ;
( void ) ( Cond ? S : a ) ;
( void ) ( Cond ? a : S ) ;
2010-07-01 11:43:00 +08:00
( void ) ( Cond ? OS : S ) ;
2010-03-27 04:59:55 +08:00
}
}
Rework our handling of copy construction of temporaries, which was a
poor (and wrong) approximation of the actual rules governing when to
build a copy and when it can be elided.
The correct implementation is actually simpler than the
approximation. When we only enumerate constructors as part of
initialization (e.g., for direct initialization or when we're copying
from a class type or one of its derived classes), we don't create a
copy. When we enumerate all conversion functions, we do create a
copy. Before, we created some extra copies and missed some
others. The new test copy-initialization.cpp shows a case where we
missed creating a (required, non-elidable) copy as part of a
user-defined conversion, which resulted in a miscompile. This commit
also fixes PR6757, where the missing copy made us reject well-formed
code in the ternary operator.
This commit also cleans up our handling of copy elision in the case
where we create an extra copy of a temporary object, which became
necessary now that we produce the right copies. The code that seeks to
find the temporary object being copied has moved into
Expr::getTemporaryObject(); it used to have two different
not-quite-the-same implementations, one in Sema and one in CodeGen.
Note that we still do not attempt to perform the named return value
optimization, so we miss copy elisions for return values and throw
expressions.
llvm-svn: 100196
2010-04-03 02:24:57 +08:00
namespace PR6757 {
struct Foo1 {
Foo1 ( ) ;
Foo1 ( const Foo1 & ) ;
} ;
struct Foo2 { } ;
struct Foo3 {
2016-09-07 10:14:33 +08:00
Foo3 ( ) ; // expected-note{{requires 0 arguments}}
2010-04-18 06:01:05 +08:00
Foo3 ( Foo3 & ) ; // expected-note{{would lose const qualifier}}
Rework our handling of copy construction of temporaries, which was a
poor (and wrong) approximation of the actual rules governing when to
build a copy and when it can be elided.
The correct implementation is actually simpler than the
approximation. When we only enumerate constructors as part of
initialization (e.g., for direct initialization or when we're copying
from a class type or one of its derived classes), we don't create a
copy. When we enumerate all conversion functions, we do create a
copy. Before, we created some extra copies and missed some
others. The new test copy-initialization.cpp shows a case where we
missed creating a (required, non-elidable) copy as part of a
user-defined conversion, which resulted in a miscompile. This commit
also fixes PR6757, where the missing copy made us reject well-formed
code in the ternary operator.
This commit also cleans up our handling of copy elision in the case
where we create an extra copy of a temporary object, which became
necessary now that we produce the right copies. The code that seeks to
find the temporary object being copied has moved into
Expr::getTemporaryObject(); it used to have two different
not-quite-the-same implementations, one in Sema and one in CodeGen.
Note that we still do not attempt to perform the named return value
optimization, so we miss copy elisions for return values and throw
expressions.
llvm-svn: 100196
2010-04-03 02:24:57 +08:00
} ;
struct Bar {
operator const Foo1 & ( ) const ;
operator const Foo2 & ( ) const ;
operator const Foo3 & ( ) const ;
} ;
void f ( ) {
( void ) ( true ? Bar ( ) : Foo1 ( ) ) ; // okay
( void ) ( true ? Bar ( ) : Foo2 ( ) ) ; // okay
2010-04-18 06:01:05 +08:00
( void ) ( true ? Bar ( ) : Foo3 ( ) ) ; // expected-error{{no viable constructor copying temporary}}
Rework our handling of copy construction of temporaries, which was a
poor (and wrong) approximation of the actual rules governing when to
build a copy and when it can be elided.
The correct implementation is actually simpler than the
approximation. When we only enumerate constructors as part of
initialization (e.g., for direct initialization or when we're copying
from a class type or one of its derived classes), we don't create a
copy. When we enumerate all conversion functions, we do create a
copy. Before, we created some extra copies and missed some
others. The new test copy-initialization.cpp shows a case where we
missed creating a (required, non-elidable) copy as part of a
user-defined conversion, which resulted in a miscompile. This commit
also fixes PR6757, where the missing copy made us reject well-formed
code in the ternary operator.
This commit also cleans up our handling of copy elision in the case
where we create an extra copy of a temporary object, which became
necessary now that we produce the right copies. The code that seeks to
find the temporary object being copied has moved into
Expr::getTemporaryObject(); it used to have two different
not-quite-the-same implementations, one in Sema and one in CodeGen.
Note that we still do not attempt to perform the named return value
optimization, so we miss copy elisions for return values and throw
expressions.
llvm-svn: 100196
2010-04-03 02:24:57 +08:00
}
}
2010-05-06 16:58:33 +08:00
// Reduced from selfhost.
namespace test1 {
struct A {
enum Foo {
fa , fb , fc , fd , fe , ff
} ;
Foo x ( ) ;
} ;
void foo ( int ) ;
void test ( A * a ) {
foo ( a ? a - > x ( ) : 0 ) ;
}
}
2010-05-20 07:40:50 +08:00
namespace rdar7998817 {
class X {
X ( X & ) ; // expected-note{{declared private here}}
struct ref { } ;
public :
X ( ) ;
X ( ref ) ;
operator ref ( ) ;
} ;
void f ( bool B ) {
X x ;
( void ) ( B ? x // expected-error{{calling a private constructor of class 'rdar7998817::X'}}
: X ( ) ) ;
}
}
2010-07-13 16:18:22 +08:00
namespace PR7598 {
enum Enum {
v = 1 ,
} ;
2010-07-14 14:36:18 +08:00
const Enum g ( ) {
2010-07-13 16:18:22 +08:00
return v ;
}
2010-07-14 14:36:18 +08:00
const volatile Enum g2 ( ) {
2010-07-13 16:50:30 +08:00
return v ;
}
2010-07-13 16:18:22 +08:00
void f ( ) {
const Enum v2 = v ;
Enum e = false ? g ( ) : v ;
Enum e2 = false ? v2 : v ;
2010-07-13 16:50:30 +08:00
Enum e3 = false ? g2 ( ) : v ;
2010-07-13 16:18:22 +08:00
}
}
2011-02-19 07:54:50 +08:00
namespace PR9236 {
# define NULL 0L
void f ( ) {
2011-02-19 08:13:59 +08:00
int i ;
2011-02-19 07:54:50 +08:00
( void ) ( true ? A ( ) : NULL ) ; // expected-error{{non-pointer operand type 'A' incompatible with NULL}}
( void ) ( true ? NULL : A ( ) ) ; // expected-error{{non-pointer operand type 'A' incompatible with NULL}}
( void ) ( true ? 0 : A ( ) ) ; // expected-error{{incompatible operand types}}
( void ) ( true ? nullptr : A ( ) ) ; // expected-error{{non-pointer operand type 'A' incompatible with nullptr}}
2011-02-19 08:13:59 +08:00
( void ) ( true ? nullptr : i ) ; // expected-error{{non-pointer operand type 'int' incompatible with nullptr}}
2011-02-19 07:54:50 +08:00
( void ) ( true ? __null : A ( ) ) ; // expected-error{{non-pointer operand type 'A' incompatible with NULL}}
( void ) ( true ? ( void * ) 0 : A ( ) ) ; // expected-error{{incompatible operand types}}
}
}
2012-08-08 14:13:49 +08:00
namespace DR587 {
template < typename T >
const T * f ( bool b ) {
static T t1 = T ( ) ;
static const T t2 = T ( ) ;
return & ( b ? t1 : t2 ) ;
}
struct S { } ;
template const int * f ( bool ) ;
template const S * f ( bool ) ;
extern bool b ;
int i = 0 ;
const int ci = 0 ;
volatile int vi = 0 ;
const volatile int cvi = 0 ;
const int & cir = b ? i : ci ;
volatile int & vir = b ? vi : i ;
const volatile int & cvir1 = b ? ci : cvi ;
const volatile int & cvir2 = b ? cvi : vi ;
const volatile int & cvir3 = b ? ci : vi ; // expected-error{{volatile lvalue reference to type 'const volatile int' cannot bind to a temporary of type 'int'}}
}
2014-01-27 12:19:56 +08:00
namespace PR17052 {
struct X {
int i_ ;
bool b_ ;
int & test ( ) { return b_ ? i_ : throw 1 ; }
} ;
}
2016-04-26 03:30:37 +08:00
namespace PR26448 {
struct Base { } ;
struct Derived : Base { } ;
Base b ;
Derived d ;
typedef decltype ( true ? static_cast < Base & & > ( b ) : static_cast < Derived & & > ( d ) ) x ;
typedef Base & & x ;
}