test/SemaCXX/expression-traits.cpp - fp2-dev/platform/external/clang - Gitiles

 // RUN: %clang_cc1 -fsyntax-only -verify -fcxx-exceptions %s

 //
 // Tests for "expression traits" intrinsics such as __is_lvalue_expr.
 //
 // For the time being, these tests are written against the 2003 C++
 // standard (ISO/IEC 14882:2003 -- see draft at
 // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2001/n1316/).
 //
 // C++0x has its own, more-refined, idea of lvalues and rvalues.
 // If/when we need to support those, we'll need to track both
 // standard documents.

 #if !__has_feature(cxx_static_assert)
 # define CONCAT_(X_, Y_) CONCAT1_(X_, Y_)
 # define CONCAT1_(X_, Y_) X_ ## Y_

 // This emulation can be used multiple times on one line (and thus in
 // a macro), except at class scope
 # define static_assert(b_, m_) \
   typedef int CONCAT_(sa_, __LINE__)[b_ ? 1 : -1]
 #endif

 // Tests are broken down according to section of the C++03 standard
 // (ISO/IEC 14882:2003(E))

 // Assertion macros encoding the following two paragraphs
 //
 // basic.lval/1 Every expression is either an lvalue or an rvalue.
 //
 // expr.prim/5 A parenthesized expression is a primary expression whose type
 // and value are identical to those of the enclosed expression. The
 // presence of parentheses does not affect whether the expression is
 // an lvalue.
 //
 // Note: these asserts cannot be made at class scope in C++03.  Put
 // them in a member function instead.
 #define ASSERT_LVALUE(expr)                                             \
     static_assert(__is_lvalue_expr(expr), "should be an lvalue");       \
     static_assert(__is_lvalue_expr((expr)),                             \
                   "the presence of parentheses should have"             \
                   " no effect on lvalueness (expr.prim/5)");            \
     static_assert(!__is_rvalue_expr(expr), "should be an lvalue");      \
     static_assert(!__is_rvalue_expr((expr)),                            \
                   "the presence of parentheses should have"             \
                   " no effect on lvalueness (expr.prim/5)")

 #define ASSERT_RVALUE(expr);                                            \
     static_assert(__is_rvalue_expr(expr), "should be an rvalue");       \
     static_assert(__is_rvalue_expr((expr)),                             \
                   "the presence of parentheses should have"             \
                   " no effect on lvalueness (expr.prim/5)");            \
     static_assert(!__is_lvalue_expr(expr), "should be an rvalue");      \
     static_assert(!__is_lvalue_expr((expr)),                            \
                   "the presence of parentheses should have"             \
                   " no effect on lvalueness (expr.prim/5)")

 enum Enum { Enumerator };

 int ReturnInt();
 void ReturnVoid();
 Enum ReturnEnum();

 void basic_lval_5()
 {
     // basic.lval/5: The result of calling a function that does not return
     // a reference is an rvalue.
     ASSERT_RVALUE(ReturnInt());
     ASSERT_RVALUE(ReturnVoid());
     ASSERT_RVALUE(ReturnEnum());
 }

 int& ReturnIntReference();
 extern Enum& ReturnEnumReference();

 void basic_lval_6()
 {
     // basic.lval/6: An expression which holds a temporary object resulting
     // from a cast to a nonreference type is an rvalue (this includes
     // the explicit creation of an object using functional notation
     struct IntClass
     {
         explicit IntClass(int = 0);
         IntClass(char const*);
         operator int() const;
     };

     struct ConvertibleToIntClass
     {
         operator IntClass() const;
     };

     ConvertibleToIntClass b;

     // Make sure even trivial conversions are not detected as lvalues
     int intLvalue = 0;
     ASSERT_RVALUE((int)intLvalue);
     ASSERT_RVALUE((short)intLvalue);
     ASSERT_RVALUE((long)intLvalue);

     // Same tests with function-call notation
     ASSERT_RVALUE(int(intLvalue));
     ASSERT_RVALUE(short(intLvalue));
     ASSERT_RVALUE(long(intLvalue));

     char charLValue = 'x';
     ASSERT_RVALUE((signed char)charLValue);
     ASSERT_RVALUE((unsigned char)charLValue);

     ASSERT_RVALUE(static_cast<int>(IntClass()));
     IntClass intClassLValue;
     ASSERT_RVALUE(static_cast<int>(intClassLValue));
     ASSERT_RVALUE(static_cast<IntClass>(ConvertibleToIntClass()));
     ConvertibleToIntClass convertibleToIntClassLValue;
     ASSERT_RVALUE(static_cast<IntClass>(convertibleToIntClassLValue));


     typedef signed char signed_char;
     typedef unsigned char unsigned_char;
     ASSERT_RVALUE(signed_char(charLValue));
     ASSERT_RVALUE(unsigned_char(charLValue));

     ASSERT_RVALUE(int(IntClass()));
     ASSERT_RVALUE(int(intClassLValue));
     ASSERT_RVALUE(IntClass(ConvertibleToIntClass()));
     ASSERT_RVALUE(IntClass(convertibleToIntClassLValue));
 }

 void conv_ptr_1()
 {
     // conv.ptr/1: A null pointer constant is an integral constant
     // expression (5.19) rvalue of integer type that evaluates to
     // zero.
     ASSERT_RVALUE(0);
 }

 void expr_6()
 {
     // expr/6: If an expression initially has the type "reference to T"
     // (8.3.2, 8.5.3), ... the expression is an lvalue.
     int x = 0;
     int& referenceToInt = x;
     ASSERT_LVALUE(referenceToInt);
     ASSERT_LVALUE(ReturnIntReference());
 }

 void expr_prim_2()
 {
     // 5.1/2 A string literal is an lvalue; all other
     // literals are rvalues.
     ASSERT_LVALUE("foo");
     ASSERT_RVALUE(1);
     ASSERT_RVALUE(1.2);
     ASSERT_RVALUE(10UL);
 }

 void expr_prim_3()
 {
     // 5.1/3: The keyword "this" names a pointer to the object for
     // which a nonstatic member function (9.3.2) is invoked. ...The
     // expression is an rvalue.
     struct ThisTest
     {
         void f() { ASSERT_RVALUE(this); }
     };
 }

 extern int variable;
 void Function();

 struct BaseClass
 {
     virtual ~BaseClass();

     int BaseNonstaticMemberFunction();
     static int BaseStaticMemberFunction();
     int baseDataMember;
 };

 struct Class : BaseClass
 {
     static void function();
     static int variable;

     template <class T>
     struct NestedClassTemplate {};

     template <class T>
     static int& NestedFuncTemplate() { return variable; }  // expected-note{{possible target for call}}

     template <class T>
     int& NestedMemfunTemplate() { return variable; }

     int operator*() const;

     template <class T>
     int operator+(T) const;

     int NonstaticMemberFunction();
     static int StaticMemberFunction();
     int dataMember;

     int& referenceDataMember;
     static int& staticReferenceDataMember;
     static int staticNonreferenceDataMember;

     enum Enum { Enumerator };

     operator long() const;

     Class();
     Class(int,int);

     void expr_prim_4()
     {
         // 5.1/4: The operator :: followed by an identifier, a
         // qualified-id, or an operator-function-id is a primary-
         // expression. ...The result is an lvalue if the entity is
         // a function or variable.
         ASSERT_LVALUE(::Function);         // identifier: function
         ASSERT_LVALUE(::variable);         // identifier: variable

         // the only qualified-id form that can start without "::" (and thus
         // be legal after "::" ) is
         //
         // ::<sub>opt</sub> nested-name-specifier template<sub>opt</sub> unqualified-id
         ASSERT_LVALUE(::Class::function);  // qualified-id: function
         ASSERT_LVALUE(::Class::variable);  // qualified-id: variable

         // The standard doesn't give a clear answer about whether these
         // should really be lvalues or rvalues without some surrounding
         // context that forces them to be interpreted as naming a
         // particular function template specialization (that situation
         // doesn't come up in legal pure C++ programs). This language
         // extension simply rejects them as requiring additional context
         __is_lvalue_expr(::Class::NestedFuncTemplate);    // qualified-id: template \
         // expected-error{{reference to overloaded function could not be resolved; did you mean to call it?}}

         __is_lvalue_expr(::Class::NestedMemfunTemplate);  // qualified-id: template \
         // expected-error{{reference to non-static member function must be called}}

         __is_lvalue_expr(::Class::operator+);             // operator-function-id: template \
         // expected-error{{reference to non-static member function must be called}}

         //ASSERT_RVALUE(::Class::operator*);         // operator-function-id: member function
     }

     void expr_prim_7()
     {
         // expr.prim/7 An identifier is an id-expression provided it has been
         // suitably declared (clause 7). [Note: ... ] The type of the
         // expression is the type of the identifier. The result is the
         // entity denoted by the identifier. The result is an lvalue if
         // the entity is a function, variable, or data member... (cont'd)
         ASSERT_LVALUE(Function);        // identifier: function
         ASSERT_LVALUE(StaticMemberFunction);        // identifier: function
         ASSERT_LVALUE(variable);        // identifier: variable
         ASSERT_LVALUE(dataMember);      // identifier: data member
         //ASSERT_RVALUE(NonstaticMemberFunction); // identifier: member function

         // (cont'd)...A nested-name-specifier that names a class,
         // optionally followed by the keyword template (14.2), and then
         // followed by the name of a member of either that class (9.2) or
         // one of its base classes... is a qualified-id... The result is
         // the member. The type of the result is the type of the
         // member. The result is an lvalue if the member is a static
         // member function or a data member.
         ASSERT_LVALUE(Class::dataMember);
         ASSERT_LVALUE(Class::StaticMemberFunction);
         //ASSERT_RVALUE(Class::NonstaticMemberFunction); // identifier: member function

         ASSERT_LVALUE(Class::baseDataMember);
         ASSERT_LVALUE(Class::BaseStaticMemberFunction);
         //ASSERT_RVALUE(Class::BaseNonstaticMemberFunction); // identifier: member function
     }
 };

 void expr_call_10()
 {
     // expr.call/10: A function call is an lvalue if and only if the
     // result type is a reference.  This statement is partially
     // redundant with basic.lval/5
     basic_lval_5();

     ASSERT_LVALUE(ReturnIntReference());
     ASSERT_LVALUE(ReturnEnumReference());
 }

 namespace Namespace
 {
   int x;
   void function();
 }

 void expr_prim_8()
 {
     // expr.prim/8 A nested-name-specifier that names a namespace
     // (7.3), followed by the name of a member of that namespace (or
     // the name of a member of a namespace made visible by a
     // using-directive ) is a qualified-id; 3.4.3.2 describes name
     // lookup for namespace members that appear in qualified-ids. The
     // result is the member. The type of the result is the type of the
     // member. The result is an lvalue if the member is a function or
     // a variable.
     ASSERT_LVALUE(Namespace::x);
     ASSERT_LVALUE(Namespace::function);
 }

 void expr_sub_1(int* pointer)
 {
     // expr.sub/1 A postfix expression followed by an expression in
     // square brackets is a postfix expression. One of the expressions
     // shall have the type "pointer to T" and the other shall have
     // enumeration or integral type. The result is an lvalue of type
     // "T."
     ASSERT_LVALUE(pointer[1]);

     // The expression E1[E2] is identical (by definition) to *((E1)+(E2)).
     ASSERT_LVALUE(*(pointer+1));
 }

 void expr_type_conv_1()
 {
     // expr.type.conv/1 A simple-type-specifier (7.1.5) followed by a
     // parenthesized expression-list constructs a value of the specified
     // type given the expression list. ... If the expression list
     // specifies more than a single value, the type shall be a class with
     // a suitably declared constructor (8.5, 12.1), and the expression
     // T(x1, x2, ...) is equivalent in effect to the declaration T t(x1,
     // x2, ...); for some invented temporary variable t, with the result
     // being the value of t as an rvalue.
     ASSERT_RVALUE(Class(2,2));
 }

 void expr_type_conv_2()
 {
     // expr.type.conv/2 The expression T(), where T is a
     // simple-type-specifier (7.1.5.2) for a non-array complete object
     // type or the (possibly cv-qualified) void type, creates an
     // rvalue of the specified type,
     ASSERT_RVALUE(int());
     ASSERT_RVALUE(Class());
     ASSERT_RVALUE(void());
 }


 void expr_ref_4()
 {
     // Applies to expressions of the form E1.E2

     // If E2 is declared to have type "reference to T", then E1.E2 is
     // an lvalue;.... Otherwise, one of the following rules applies.
     ASSERT_LVALUE(Class().staticReferenceDataMember);
     ASSERT_LVALUE(Class().referenceDataMember);

     // - If E2 is a static data member, and the type of E2 is T, then
     // E1.E2 is an lvalue; ...
     ASSERT_LVALUE(Class().staticNonreferenceDataMember);
     ASSERT_LVALUE(Class().staticReferenceDataMember);


     // - If E2 is a non-static data member, ... If E1 is an lvalue,
     // then E1.E2 is an lvalue...
     Class lvalue;
     ASSERT_LVALUE(lvalue.dataMember);
     ASSERT_RVALUE(Class().dataMember);

     // - If E1.E2 refers to a static member function, ... then E1.E2
     // is an lvalue
     ASSERT_LVALUE(Class().StaticMemberFunction);

     // - Otherwise, if E1.E2 refers to a non-static member function,
     // then E1.E2 is not an lvalue.
     //ASSERT_RVALUE(Class().NonstaticMemberFunction);

     // - If E2 is a member enumerator, and the type of E2 is T, the
     // expression E1.E2 is not an lvalue. The type of E1.E2 is T.
     ASSERT_RVALUE(Class().Enumerator);
     ASSERT_RVALUE(lvalue.Enumerator);
 }


 void expr_post_incr_1(int x)
 {
     // expr.post.incr/1 The value obtained by applying a postfix ++ is
     // the value that the operand had before applying the
     // operator... The result is an rvalue.
     ASSERT_RVALUE(x++);
 }

 void expr_dynamic_cast_2()
 {
     // expr.dynamic.cast/2: If T is a pointer type, v shall be an
     // rvalue of a pointer to complete class type, and the result is
     // an rvalue of type T.
     Class instance;
     ASSERT_RVALUE(dynamic_cast<Class*>(&instance));

     // If T is a reference type, v shall be an
     // lvalue of a complete class type, and the result is an lvalue of
     // the type referred to by T.
     ASSERT_LVALUE(dynamic_cast<Class&>(instance));
 }

 void expr_dynamic_cast_5()
 {
     // expr.dynamic.cast/5: If T is "reference to cv1 B" and v has type
     // "cv2 D" such that B is a base class of D, the result is an
     // lvalue for the unique B sub-object of the D object referred
     // to by v.
     typedef BaseClass B;
     typedef Class D;
     D object;
     ASSERT_LVALUE(dynamic_cast<B&>(object));
 }

 // expr.dynamic.cast/8: The run-time check logically executes as follows:
 //
 // - If, in the most derived object pointed (referred) to by v, v
 // points (refers) to a public base class subobject of a T object, and
 // if only one object of type T is derived from the sub-object pointed
 // (referred) to by v, the result is a pointer (an lvalue referring)
 // to that T object.
 //
 // - Otherwise, if v points (refers) to a public base class sub-object
 // of the most derived object, and the type of the most derived object
 // has a base class, of type T, that is unambiguous and public, the
 // result is a pointer (an lvalue referring) to the T sub-object of
 // the most derived object.
 //
 // The mention of "lvalue" in the text above appears to be a
 // defect that is being corrected by the response to UK65 (see
 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2841.html).

 #if 0
 void expr_typeid_1()
 {
     // expr.typeid/1: The result of a typeid expression is an lvalue...
     ASSERT_LVALUE(typeid(1));
 }
 #endif

 void expr_static_cast_1(int x)
 {
     // expr.static.cast/1: The result of the expression
     // static_cast<T>(v) is the result of converting the expression v
     // to type T. If T is a reference type, the result is an lvalue;
     // otherwise, the result is an rvalue.
     ASSERT_LVALUE(static_cast<int&>(x));
     ASSERT_RVALUE(static_cast<int>(x));
 }

 void expr_reinterpret_cast_1()
 {
     // expr.reinterpret.cast/1: The result of the expression
     // reinterpret_cast<T>(v) is the result of converting the
     // expression v to type T. If T is a reference type, the result is
     // an lvalue; otherwise, the result is an rvalue
     ASSERT_RVALUE(reinterpret_cast<int*>(0));
     char const v = 0;
     ASSERT_LVALUE(reinterpret_cast<char const&>(v));
 }

 void expr_unary_op_1(int* pointer, struct incomplete* pointerToIncompleteType)
 {
     // expr.unary.op/1: The unary * operator performs indirection: the
     // expression to which it is applied shall be a pointer to an
     // object type, or a pointer to a function type and the result is
     // an lvalue referring to the object or function to which the
     // expression points.
     ASSERT_LVALUE(*pointer);
     ASSERT_LVALUE(*Function);

     // [Note: a pointer to an incomplete type
     // (other than cv void ) can be dereferenced. ]
     ASSERT_LVALUE(*pointerToIncompleteType);
 }

 void expr_pre_incr_1(int operand)
 {
     // expr.pre.incr/1: The operand of prefix ++ ... shall be a
     // modifiable lvalue.... The value is the new value of the
     // operand; it is an lvalue.
     ASSERT_LVALUE(++operand);
 }

 void expr_cast_1(int x)
 {
     // expr.cast/1: The result of the expression (T) cast-expression
     // is of type T. The result is an lvalue if T is a reference type,
     // otherwise the result is an rvalue.
     ASSERT_LVALUE((void(&)())expr_cast_1);
     ASSERT_LVALUE((int&)x);
     ASSERT_RVALUE((void(*)())expr_cast_1);
     ASSERT_RVALUE((int)x);
 }

 void expr_mptr_oper()
 {
     // expr.mptr.oper/6: The result of a .* expression is an lvalue
     // only if its first operand is an lvalue and its second operand
     // is a pointer to data member... (cont'd)
     typedef Class MakeRValue;
     ASSERT_RVALUE(MakeRValue().*(&Class::dataMember));
     //ASSERT_RVALUE(MakeRValue().*(&Class::NonstaticMemberFunction));
     Class lvalue;
     ASSERT_LVALUE(lvalue.*(&Class::dataMember));
     //ASSERT_RVALUE(lvalue.*(&Class::NonstaticMemberFunction));

     // (cont'd)...The result of an ->* expression is an lvalue only
     // if its second operand is a pointer to data member. If the
     // second operand is the null pointer to member value (4.11), the
     // behavior is undefined.
     ASSERT_LVALUE((&lvalue)->*(&Class::dataMember));
     //ASSERT_RVALUE((&lvalue)->*(&Class::NonstaticMemberFunction));
 }

 void expr_cond(bool cond)
 {
     // 5.16 Conditional operator [expr.cond]
     //
     // 2 If either the second or the third operand has type (possibly
     // cv-qualified) void, then the lvalue-to-rvalue (4.1),
     // array-to-pointer (4.2), and function-to-pointer (4.3) standard
     // conversions are performed on the second and third operands, and one
     // of the following shall hold:
     //
     // - The second or the third operand (but not both) is a
     // throw-expression (15.1); the result is of the type of the other and
     // is an rvalue.

     Class classLvalue;
     ASSERT_RVALUE(cond ? throw 1 : (void)0);
     ASSERT_RVALUE(cond ? (void)0 : throw 1);
     ASSERT_RVALUE(cond ? throw 1 : classLvalue);
     ASSERT_RVALUE(cond ? classLvalue : throw 1);

     // - Both the second and the third operands have type void; the result
     // is of type void and is an rvalue. [Note: this includes the case
     // where both operands are throw-expressions. ]
     ASSERT_RVALUE(cond ? (void)1 : (void)0);
     ASSERT_RVALUE(cond ? throw 1 : throw 0);

     // expr.cond/4: If the second and third operands are lvalues and
     // have the same type, the result is of that type and is an
     // lvalue.
     ASSERT_LVALUE(cond ? classLvalue : classLvalue);
     int intLvalue = 0;
     ASSERT_LVALUE(cond ? intLvalue : intLvalue);

     // expr.cond/5:Otherwise, the result is an rvalue.
     typedef Class MakeRValue;
     ASSERT_RVALUE(cond ? MakeRValue() : classLvalue);
     ASSERT_RVALUE(cond ? classLvalue : MakeRValue());
     ASSERT_RVALUE(cond ? MakeRValue() : MakeRValue());
     ASSERT_RVALUE(cond ? classLvalue : intLvalue);
     ASSERT_RVALUE(cond ? intLvalue : int());
 }

 void expr_ass_1(int x)
 {
     // expr.ass/1: There are several assignment operators, all of
     // which group right-to-left. All require a modifiable lvalue as
     // their left operand, and the type of an assignment expression is
     // that of its left operand. The result of the assignment
     // operation is the value stored in the left operand after the
     // assignment has taken place; the result is an lvalue.
     ASSERT_LVALUE(x = 1);
     ASSERT_LVALUE(x += 1);
     ASSERT_LVALUE(x -= 1);
     ASSERT_LVALUE(x *= 1);
     ASSERT_LVALUE(x /= 1);
     ASSERT_LVALUE(x %= 1);
     ASSERT_LVALUE(x ^= 1);
     ASSERT_LVALUE(x &= 1);
     ASSERT_LVALUE(x |= 1);
 }

 void expr_comma(int x)
 {
     // expr.comma: A pair of expressions separated by a comma is
     // evaluated left-to-right and the value of the left expression is
     // discarded... result is an lvalue if its right operand is.

     // Can't use the ASSERT_XXXX macros without adding parens around
     // the comma expression.
     static_assert(__is_lvalue_expr(x,x), "expected an lvalue");
     static_assert(__is_rvalue_expr(x,1), "expected an rvalue");
     static_assert(__is_lvalue_expr(1,x), "expected an lvalue");
     static_assert(__is_rvalue_expr(1,1), "expected an rvalue");
 }

 #if 0
 template<typename T> void f();

 // FIXME These currently fail
 void expr_fun_lvalue()
 {
   ASSERT_LVALUE(&f<int>);
 }

 void expr_fun_rvalue()
 {
   ASSERT_RVALUE(f<int>);
 }
 #endif

 template <int NonTypeNonReferenceParameter, int& NonTypeReferenceParameter>
 void check_temp_param_6()
 {
     ASSERT_RVALUE(NonTypeNonReferenceParameter);
     ASSERT_LVALUE(NonTypeReferenceParameter);
 }

 int AnInt = 0;

 void temp_param_6()
 {
     check_temp_param_6<3,AnInt>();
 }
	// RUN: %clang_cc1 -fsyntax-only -verify -fcxx-exceptions %s

	//
	// Tests for "expression traits" intrinsics such as __is_lvalue_expr.
	//
	// For the time being, these tests are written against the 2003 C++
	// standard (ISO/IEC 14882:2003 -- see draft at
	// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2001/n1316/).
	//
	// C++0x has its own, more-refined, idea of lvalues and rvalues.
	// If/when we need to support those, we'll need to track both
	// standard documents.

	#if !__has_feature(cxx_static_assert)
	# define CONCAT_(X_, Y_) CONCAT1_(X_, Y_)
	# define CONCAT1_(X_, Y_) X_ ## Y_

	// This emulation can be used multiple times on one line (and thus in
	// a macro), except at class scope
	# define static_assert(b_, m_) \
	typedef int CONCAT_(sa_, __LINE__)[b_ ? 1 : -1]
	#endif

	// Tests are broken down according to section of the C++03 standard
	// (ISO/IEC 14882:2003(E))

	// Assertion macros encoding the following two paragraphs
	//
	// basic.lval/1 Every expression is either an lvalue or an rvalue.
	//
	// expr.prim/5 A parenthesized expression is a primary expression whose type
	// and value are identical to those of the enclosed expression. The
	// presence of parentheses does not affect whether the expression is
	// an lvalue.
	//
	// Note: these asserts cannot be made at class scope in C++03. Put
	// them in a member function instead.
	#define ASSERT_LVALUE(expr) \
	static_assert(__is_lvalue_expr(expr), "should be an lvalue"); \
	static_assert(__is_lvalue_expr((expr)), \
	"the presence of parentheses should have" \
	" no effect on lvalueness (expr.prim/5)"); \
	static_assert(!__is_rvalue_expr(expr), "should be an lvalue"); \
	static_assert(!__is_rvalue_expr((expr)), \
	"the presence of parentheses should have" \
	" no effect on lvalueness (expr.prim/5)")

	#define ASSERT_RVALUE(expr); \
	static_assert(__is_rvalue_expr(expr), "should be an rvalue"); \
	static_assert(__is_rvalue_expr((expr)), \
	"the presence of parentheses should have" \
	" no effect on lvalueness (expr.prim/5)"); \
	static_assert(!__is_lvalue_expr(expr), "should be an rvalue"); \
	static_assert(!__is_lvalue_expr((expr)), \
	"the presence of parentheses should have" \
	" no effect on lvalueness (expr.prim/5)")

	enum Enum { Enumerator };

	int ReturnInt();
	void ReturnVoid();
	Enum ReturnEnum();

	void basic_lval_5()
	{
	// basic.lval/5: The result of calling a function that does not return
	// a reference is an rvalue.
	ASSERT_RVALUE(ReturnInt());
	ASSERT_RVALUE(ReturnVoid());
	ASSERT_RVALUE(ReturnEnum());
	}

	int& ReturnIntReference();
	extern Enum& ReturnEnumReference();

	void basic_lval_6()
	{
	// basic.lval/6: An expression which holds a temporary object resulting
	// from a cast to a nonreference type is an rvalue (this includes
	// the explicit creation of an object using functional notation
	struct IntClass
	{
	explicit IntClass(int = 0);
	IntClass(char const*);
	operator int() const;
	};

	struct ConvertibleToIntClass
	{
	operator IntClass() const;
	};

	ConvertibleToIntClass b;

	// Make sure even trivial conversions are not detected as lvalues
	int intLvalue = 0;
	ASSERT_RVALUE((int)intLvalue);
	ASSERT_RVALUE((short)intLvalue);
	ASSERT_RVALUE((long)intLvalue);

	// Same tests with function-call notation
	ASSERT_RVALUE(int(intLvalue));
	ASSERT_RVALUE(short(intLvalue));
	ASSERT_RVALUE(long(intLvalue));

	char charLValue = 'x';
	ASSERT_RVALUE((signed char)charLValue);
	ASSERT_RVALUE((unsigned char)charLValue);

	ASSERT_RVALUE(static_cast<int>(IntClass()));
	IntClass intClassLValue;
	ASSERT_RVALUE(static_cast<int>(intClassLValue));
	ASSERT_RVALUE(static_cast<IntClass>(ConvertibleToIntClass()));
	ConvertibleToIntClass convertibleToIntClassLValue;
	ASSERT_RVALUE(static_cast<IntClass>(convertibleToIntClassLValue));


	typedef signed char signed_char;
	typedef unsigned char unsigned_char;
	ASSERT_RVALUE(signed_char(charLValue));
	ASSERT_RVALUE(unsigned_char(charLValue));

	ASSERT_RVALUE(int(IntClass()));
	ASSERT_RVALUE(int(intClassLValue));
	ASSERT_RVALUE(IntClass(ConvertibleToIntClass()));
	ASSERT_RVALUE(IntClass(convertibleToIntClassLValue));
	}

	void conv_ptr_1()
	{
	// conv.ptr/1: A null pointer constant is an integral constant
	// expression (5.19) rvalue of integer type that evaluates to
	// zero.
	ASSERT_RVALUE(0);
	}

	void expr_6()
	{
	// expr/6: If an expression initially has the type "reference to T"
	// (8.3.2, 8.5.3), ... the expression is an lvalue.
	int x = 0;
	int& referenceToInt = x;
	ASSERT_LVALUE(referenceToInt);
	ASSERT_LVALUE(ReturnIntReference());
	}

	void expr_prim_2()
	{
	// 5.1/2 A string literal is an lvalue; all other
	// literals are rvalues.
	ASSERT_LVALUE("foo");
	ASSERT_RVALUE(1);
	ASSERT_RVALUE(1.2);
	ASSERT_RVALUE(10UL);
	}

	void expr_prim_3()
	{
	// 5.1/3: The keyword "this" names a pointer to the object for
	// which a nonstatic member function (9.3.2) is invoked. ...The
	// expression is an rvalue.
	struct ThisTest
	{
	void f() { ASSERT_RVALUE(this); }
	};
	}

	extern int variable;
	void Function();

	struct BaseClass
	{
	virtual ~BaseClass();

	int BaseNonstaticMemberFunction();
	static int BaseStaticMemberFunction();
	int baseDataMember;
	};

	struct Class : BaseClass
	{
	static void function();
	static int variable;

	template <class T>
	struct NestedClassTemplate {};

	template <class T>
	static int& NestedFuncTemplate() { return variable; } // expected-note{{possible target for call}}

	template <class T>
	int& NestedMemfunTemplate() { return variable; }

	int operator*() const;

	template <class T>
	int operator+(T) const;

	int NonstaticMemberFunction();
	static int StaticMemberFunction();
	int dataMember;

	int& referenceDataMember;
	static int& staticReferenceDataMember;
	static int staticNonreferenceDataMember;

	enum Enum { Enumerator };

	operator long() const;

	Class();
	Class(int,int);

	void expr_prim_4()
	{
	// 5.1/4: The operator :: followed by an identifier, a
	// qualified-id, or an operator-function-id is a primary-
	// expression. ...The result is an lvalue if the entity is
	// a function or variable.
	ASSERT_LVALUE(::Function); // identifier: function
	ASSERT_LVALUE(::variable); // identifier: variable

	// the only qualified-id form that can start without "::" (and thus
	// be legal after "::" ) is
	//
	// ::<sub>opt</sub> nested-name-specifier template<sub>opt</sub> unqualified-id
	ASSERT_LVALUE(::Class::function); // qualified-id: function
	ASSERT_LVALUE(::Class::variable); // qualified-id: variable

	// The standard doesn't give a clear answer about whether these
	// should really be lvalues or rvalues without some surrounding
	// context that forces them to be interpreted as naming a
	// particular function template specialization (that situation
	// doesn't come up in legal pure C++ programs). This language
	// extension simply rejects them as requiring additional context
	__is_lvalue_expr(::Class::NestedFuncTemplate); // qualified-id: template \
	// expected-error{{reference to overloaded function could not be resolved; did you mean to call it?}}

	__is_lvalue_expr(::Class::NestedMemfunTemplate); // qualified-id: template \
	// expected-error{{reference to non-static member function must be called}}

	__is_lvalue_expr(::Class::operator+); // operator-function-id: template \
	// expected-error{{reference to non-static member function must be called}}

	//ASSERT_RVALUE(::Class::operator*); // operator-function-id: member function
	}

	void expr_prim_7()
	{
	// expr.prim/7 An identifier is an id-expression provided it has been
	// suitably declared (clause 7). [Note: ... ] The type of the
	// expression is the type of the identifier. The result is the
	// entity denoted by the identifier. The result is an lvalue if
	// the entity is a function, variable, or data member... (cont'd)
	ASSERT_LVALUE(Function); // identifier: function
	ASSERT_LVALUE(StaticMemberFunction); // identifier: function
	ASSERT_LVALUE(variable); // identifier: variable
	ASSERT_LVALUE(dataMember); // identifier: data member
	//ASSERT_RVALUE(NonstaticMemberFunction); // identifier: member function

	// (cont'd)...A nested-name-specifier that names a class,
	// optionally followed by the keyword template (14.2), and then
	// followed by the name of a member of either that class (9.2) or
	// one of its base classes... is a qualified-id... The result is
	// the member. The type of the result is the type of the
	// member. The result is an lvalue if the member is a static
	// member function or a data member.
	ASSERT_LVALUE(Class::dataMember);
	ASSERT_LVALUE(Class::StaticMemberFunction);
	//ASSERT_RVALUE(Class::NonstaticMemberFunction); // identifier: member function

	ASSERT_LVALUE(Class::baseDataMember);
	ASSERT_LVALUE(Class::BaseStaticMemberFunction);
	//ASSERT_RVALUE(Class::BaseNonstaticMemberFunction); // identifier: member function
	}
	};

	void expr_call_10()
	{
	// expr.call/10: A function call is an lvalue if and only if the
	// result type is a reference. This statement is partially
	// redundant with basic.lval/5
	basic_lval_5();

	ASSERT_LVALUE(ReturnIntReference());
	ASSERT_LVALUE(ReturnEnumReference());
	}

	namespace Namespace
	{
	int x;
	void function();
	}

	void expr_prim_8()
	{
	// expr.prim/8 A nested-name-specifier that names a namespace
	// (7.3), followed by the name of a member of that namespace (or
	// the name of a member of a namespace made visible by a
	// using-directive ) is a qualified-id; 3.4.3.2 describes name
	// lookup for namespace members that appear in qualified-ids. The
	// result is the member. The type of the result is the type of the
	// member. The result is an lvalue if the member is a function or
	// a variable.
	ASSERT_LVALUE(Namespace::x);
	ASSERT_LVALUE(Namespace::function);
	}

	void expr_sub_1(int* pointer)
	{
	// expr.sub/1 A postfix expression followed by an expression in
	// square brackets is a postfix expression. One of the expressions
	// shall have the type "pointer to T" and the other shall have
	// enumeration or integral type. The result is an lvalue of type
	// "T."
	ASSERT_LVALUE(pointer[1]);

	// The expression E1[E2] is identical (by definition) to *((E1)+(E2)).
	ASSERT_LVALUE(*(pointer+1));
	}

	void expr_type_conv_1()
	{
	// expr.type.conv/1 A simple-type-specifier (7.1.5) followed by a
	// parenthesized expression-list constructs a value of the specified
	// type given the expression list. ... If the expression list
	// specifies more than a single value, the type shall be a class with
	// a suitably declared constructor (8.5, 12.1), and the expression
	// T(x1, x2, ...) is equivalent in effect to the declaration T t(x1,
	// x2, ...); for some invented temporary variable t, with the result
	// being the value of t as an rvalue.
	ASSERT_RVALUE(Class(2,2));
	}

	void expr_type_conv_2()
	{
	// expr.type.conv/2 The expression T(), where T is a
	// simple-type-specifier (7.1.5.2) for a non-array complete object
	// type or the (possibly cv-qualified) void type, creates an
	// rvalue of the specified type,
	ASSERT_RVALUE(int());
	ASSERT_RVALUE(Class());
	ASSERT_RVALUE(void());
	}


	void expr_ref_4()
	{
	// Applies to expressions of the form E1.E2

	// If E2 is declared to have type "reference to T", then E1.E2 is
	// an lvalue;.... Otherwise, one of the following rules applies.
	ASSERT_LVALUE(Class().staticReferenceDataMember);
	ASSERT_LVALUE(Class().referenceDataMember);

	// - If E2 is a static data member, and the type of E2 is T, then
	// E1.E2 is an lvalue; ...
	ASSERT_LVALUE(Class().staticNonreferenceDataMember);
	ASSERT_LVALUE(Class().staticReferenceDataMember);


	// - If E2 is a non-static data member, ... If E1 is an lvalue,
	// then E1.E2 is an lvalue...
	Class lvalue;
	ASSERT_LVALUE(lvalue.dataMember);
	ASSERT_RVALUE(Class().dataMember);

	// - If E1.E2 refers to a static member function, ... then E1.E2
	// is an lvalue
	ASSERT_LVALUE(Class().StaticMemberFunction);

	// - Otherwise, if E1.E2 refers to a non-static member function,
	// then E1.E2 is not an lvalue.
	//ASSERT_RVALUE(Class().NonstaticMemberFunction);

	// - If E2 is a member enumerator, and the type of E2 is T, the
	// expression E1.E2 is not an lvalue. The type of E1.E2 is T.
	ASSERT_RVALUE(Class().Enumerator);
	ASSERT_RVALUE(lvalue.Enumerator);
	}


	void expr_post_incr_1(int x)
	{
	// expr.post.incr/1 The value obtained by applying a postfix ++ is
	// the value that the operand had before applying the
	// operator... The result is an rvalue.
	ASSERT_RVALUE(x++);
	}

	void expr_dynamic_cast_2()
	{
	// expr.dynamic.cast/2: If T is a pointer type, v shall be an
	// rvalue of a pointer to complete class type, and the result is
	// an rvalue of type T.
	Class instance;
	ASSERT_RVALUE(dynamic_cast<Class*>(&instance));

	// If T is a reference type, v shall be an
	// lvalue of a complete class type, and the result is an lvalue of
	// the type referred to by T.
	ASSERT_LVALUE(dynamic_cast<Class&>(instance));
	}

	void expr_dynamic_cast_5()
	{
	// expr.dynamic.cast/5: If T is "reference to cv1 B" and v has type
	// "cv2 D" such that B is a base class of D, the result is an
	// lvalue for the unique B sub-object of the D object referred
	// to by v.
	typedef BaseClass B;
	typedef Class D;
	D object;
	ASSERT_LVALUE(dynamic_cast<B&>(object));
	}

	// expr.dynamic.cast/8: The run-time check logically executes as follows:
	//
	// - If, in the most derived object pointed (referred) to by v, v
	// points (refers) to a public base class subobject of a T object, and
	// if only one object of type T is derived from the sub-object pointed
	// (referred) to by v, the result is a pointer (an lvalue referring)
	// to that T object.
	//
	// - Otherwise, if v points (refers) to a public base class sub-object
	// of the most derived object, and the type of the most derived object
	// has a base class, of type T, that is unambiguous and public, the
	// result is a pointer (an lvalue referring) to the T sub-object of
	// the most derived object.
	//
	// The mention of "lvalue" in the text above appears to be a
	// defect that is being corrected by the response to UK65 (see
	// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2841.html).

	#if 0
	void expr_typeid_1()
	{
	// expr.typeid/1: The result of a typeid expression is an lvalue...
	ASSERT_LVALUE(typeid(1));
	}
	#endif

	void expr_static_cast_1(int x)
	{
	// expr.static.cast/1: The result of the expression
	// static_cast<T>(v) is the result of converting the expression v
	// to type T. If T is a reference type, the result is an lvalue;
	// otherwise, the result is an rvalue.
	ASSERT_LVALUE(static_cast<int&>(x));
	ASSERT_RVALUE(static_cast<int>(x));
	}

	void expr_reinterpret_cast_1()
	{
	// expr.reinterpret.cast/1: The result of the expression
	// reinterpret_cast<T>(v) is the result of converting the
	// expression v to type T. If T is a reference type, the result is
	// an lvalue; otherwise, the result is an rvalue
	ASSERT_RVALUE(reinterpret_cast<int*>(0));
	char const v = 0;
	ASSERT_LVALUE(reinterpret_cast<char const&>(v));
	}

	void expr_unary_op_1(int* pointer, struct incomplete* pointerToIncompleteType)
	{
	// expr.unary.op/1: The unary * operator performs indirection: the
	// expression to which it is applied shall be a pointer to an
	// object type, or a pointer to a function type and the result is
	// an lvalue referring to the object or function to which the
	// expression points.
	ASSERT_LVALUE(*pointer);
	ASSERT_LVALUE(*Function);

	// [Note: a pointer to an incomplete type
	// (other than cv void ) can be dereferenced. ]
	ASSERT_LVALUE(*pointerToIncompleteType);
	}

	void expr_pre_incr_1(int operand)
	{
	// expr.pre.incr/1: The operand of prefix ++ ... shall be a
	// modifiable lvalue.... The value is the new value of the
	// operand; it is an lvalue.
	ASSERT_LVALUE(++operand);
	}

	void expr_cast_1(int x)
	{
	// expr.cast/1: The result of the expression (T) cast-expression
	// is of type T. The result is an lvalue if T is a reference type,
	// otherwise the result is an rvalue.
	ASSERT_LVALUE((void(&)())expr_cast_1);
	ASSERT_LVALUE((int&)x);
	ASSERT_RVALUE((void(*)())expr_cast_1);
	ASSERT_RVALUE((int)x);
	}

	void expr_mptr_oper()
	{
	// expr.mptr.oper/6: The result of a .* expression is an lvalue
	// only if its first operand is an lvalue and its second operand
	// is a pointer to data member... (cont'd)
	typedef Class MakeRValue;
	ASSERT_RVALUE(MakeRValue().*(&Class::dataMember));
	//ASSERT_RVALUE(MakeRValue().*(&Class::NonstaticMemberFunction));
	Class lvalue;
	ASSERT_LVALUE(lvalue.*(&Class::dataMember));
	//ASSERT_RVALUE(lvalue.*(&Class::NonstaticMemberFunction));

	// (cont'd)...The result of an ->* expression is an lvalue only
	// if its second operand is a pointer to data member. If the
	// second operand is the null pointer to member value (4.11), the
	// behavior is undefined.
	ASSERT_LVALUE((&lvalue)->*(&Class::dataMember));
	//ASSERT_RVALUE((&lvalue)->*(&Class::NonstaticMemberFunction));
	}

	void expr_cond(bool cond)
	{
	// 5.16 Conditional operator [expr.cond]
	//
	// 2 If either the second or the third operand has type (possibly
	// cv-qualified) void, then the lvalue-to-rvalue (4.1),
	// array-to-pointer (4.2), and function-to-pointer (4.3) standard
	// conversions are performed on the second and third operands, and one
	// of the following shall hold:
	//
	// - The second or the third operand (but not both) is a
	// throw-expression (15.1); the result is of the type of the other and
	// is an rvalue.

	Class classLvalue;
	ASSERT_RVALUE(cond ? throw 1 : (void)0);
	ASSERT_RVALUE(cond ? (void)0 : throw 1);
	ASSERT_RVALUE(cond ? throw 1 : classLvalue);
	ASSERT_RVALUE(cond ? classLvalue : throw 1);

	// - Both the second and the third operands have type void; the result
	// is of type void and is an rvalue. [Note: this includes the case
	// where both operands are throw-expressions. ]
	ASSERT_RVALUE(cond ? (void)1 : (void)0);
	ASSERT_RVALUE(cond ? throw 1 : throw 0);

	// expr.cond/4: If the second and third operands are lvalues and
	// have the same type, the result is of that type and is an
	// lvalue.
	ASSERT_LVALUE(cond ? classLvalue : classLvalue);
	int intLvalue = 0;
	ASSERT_LVALUE(cond ? intLvalue : intLvalue);

	// expr.cond/5:Otherwise, the result is an rvalue.
	typedef Class MakeRValue;
	ASSERT_RVALUE(cond ? MakeRValue() : classLvalue);
	ASSERT_RVALUE(cond ? classLvalue : MakeRValue());
	ASSERT_RVALUE(cond ? MakeRValue() : MakeRValue());
	ASSERT_RVALUE(cond ? classLvalue : intLvalue);
	ASSERT_RVALUE(cond ? intLvalue : int());
	}

	void expr_ass_1(int x)
	{
	// expr.ass/1: There are several assignment operators, all of
	// which group right-to-left. All require a modifiable lvalue as
	// their left operand, and the type of an assignment expression is
	// that of its left operand. The result of the assignment
	// operation is the value stored in the left operand after the
	// assignment has taken place; the result is an lvalue.
	ASSERT_LVALUE(x = 1);
	ASSERT_LVALUE(x += 1);
	ASSERT_LVALUE(x -= 1);
	ASSERT_LVALUE(x *= 1);
	ASSERT_LVALUE(x /= 1);
	ASSERT_LVALUE(x %= 1);
	ASSERT_LVALUE(x ^= 1);
	ASSERT_LVALUE(x &= 1);
	ASSERT_LVALUE(x \|= 1);
	}

	void expr_comma(int x)
	{
	// expr.comma: A pair of expressions separated by a comma is
	// evaluated left-to-right and the value of the left expression is
	// discarded... result is an lvalue if its right operand is.

	// Can't use the ASSERT_XXXX macros without adding parens around
	// the comma expression.
	static_assert(__is_lvalue_expr(x,x), "expected an lvalue");
	static_assert(__is_rvalue_expr(x,1), "expected an rvalue");
	static_assert(__is_lvalue_expr(1,x), "expected an lvalue");
	static_assert(__is_rvalue_expr(1,1), "expected an rvalue");
	}

	#if 0
	template<typename T> void f();

	// FIXME These currently fail
	void expr_fun_lvalue()
	{
	ASSERT_LVALUE(&f<int>);
	}

	void expr_fun_rvalue()
	{
	ASSERT_RVALUE(f<int>);
	}
	#endif

	template <int NonTypeNonReferenceParameter, int& NonTypeReferenceParameter>
	void check_temp_param_6()
	{
	ASSERT_RVALUE(NonTypeNonReferenceParameter);
	ASSERT_LVALUE(NonTypeReferenceParameter);
	}

	int AnInt = 0;

	void temp_param_6()
	{
	check_temp_param_6<3,AnInt>();
	}