| // RUN: %clang_cc1 -fsyntax-only -verify %s |
| #define T(b) (b) ? 1 : -1 |
| #define F(b) (b) ? -1 : 1 |
| |
| struct NonPOD { NonPOD(int); }; |
| |
| // PODs |
| enum Enum { EV }; |
| struct POD { Enum e; int i; float f; NonPOD* p; }; |
| struct Empty {}; |
| typedef Empty EmptyAr[10]; |
| typedef int Int; |
| typedef Int IntAr[10]; |
| typedef Int IntArNB[]; |
| class Statics { static int priv; static NonPOD np; }; |
| union EmptyUnion {}; |
| union Union { int i; float f; }; |
| struct HasFunc { void f (); }; |
| struct HasOp { void operator *(); }; |
| struct HasConv { operator int(); }; |
| struct HasAssign { void operator =(int); }; |
| |
| struct HasAnonymousUnion { |
| union { |
| int i; |
| float f; |
| }; |
| }; |
| |
| // Not PODs |
| typedef const void cvoid; |
| struct Derives : POD {}; |
| struct DerivesEmpty : Empty {}; |
| struct HasCons { HasCons(int); }; |
| struct HasCopyAssign { HasCopyAssign operator =(const HasCopyAssign&); }; |
| struct HasDest { ~HasDest(); }; |
| class HasPriv { int priv; }; |
| class HasProt { protected: int prot; }; |
| struct HasRef { int i; int& ref; HasRef() : i(0), ref(i) {} }; |
| struct HasNonPOD { NonPOD np; }; |
| struct HasVirt { virtual void Virt() {}; }; |
| typedef Derives NonPODAr[10]; |
| typedef HasVirt VirtAr[10]; |
| typedef HasCons NonPODArNB[]; |
| union NonPODUnion { int i; Derives n; }; |
| |
| struct HasNoThrowCopyAssign { |
| void operator =(const HasNoThrowCopyAssign&) throw(); |
| }; |
| struct HasMultipleCopyAssign { |
| void operator =(const HasMultipleCopyAssign&) throw(); |
| void operator =(volatile HasMultipleCopyAssign&); |
| }; |
| struct HasMultipleNoThrowCopyAssign { |
| void operator =(const HasMultipleNoThrowCopyAssign&) throw(); |
| void operator =(volatile HasMultipleNoThrowCopyAssign&) throw(); |
| }; |
| |
| struct HasNoThrowConstructor { HasNoThrowConstructor() throw(); }; |
| struct HasNoThrowConstructorWithArgs { |
| HasNoThrowConstructorWithArgs(HasCons i = HasCons(0)) throw(); |
| }; |
| |
| struct HasNoThrowCopy { HasNoThrowCopy(const HasNoThrowCopy&) throw(); }; |
| struct HasMultipleCopy { |
| HasMultipleCopy(const HasMultipleCopy&) throw(); |
| HasMultipleCopy(volatile HasMultipleCopy&); |
| }; |
| struct HasMultipleNoThrowCopy { |
| HasMultipleNoThrowCopy(const HasMultipleNoThrowCopy&) throw(); |
| HasMultipleNoThrowCopy(volatile HasMultipleNoThrowCopy&) throw(); |
| }; |
| |
| struct HasVirtDest { virtual ~HasVirtDest(); }; |
| struct DerivedVirtDest : HasVirtDest {}; |
| typedef HasVirtDest VirtDestAr[1]; |
| |
| void is_pod() |
| { |
| int t01[T(__is_pod(int))]; |
| int t02[T(__is_pod(Enum))]; |
| int t03[T(__is_pod(POD))]; |
| int t04[T(__is_pod(Int))]; |
| int t05[T(__is_pod(IntAr))]; |
| int t06[T(__is_pod(Statics))]; |
| int t07[T(__is_pod(Empty))]; |
| int t08[T(__is_pod(EmptyUnion))]; |
| int t09[T(__is_pod(Union))]; |
| int t10[T(__is_pod(HasFunc))]; |
| int t11[T(__is_pod(HasOp))]; |
| int t12[T(__is_pod(HasConv))]; |
| int t13[T(__is_pod(HasAssign))]; |
| int t14[T(__is_pod(IntArNB))]; |
| int t15[T(__is_pod(HasAnonymousUnion))]; |
| |
| int t21[F(__is_pod(Derives))]; |
| int t22[F(__is_pod(HasCons))]; |
| int t23[F(__is_pod(HasCopyAssign))]; |
| int t24[F(__is_pod(HasDest))]; |
| int t25[F(__is_pod(HasPriv))]; |
| int t26[F(__is_pod(HasProt))]; |
| int t27[F(__is_pod(HasRef))]; |
| int t28[F(__is_pod(HasNonPOD))]; |
| int t29[F(__is_pod(HasVirt))]; |
| int t30[F(__is_pod(NonPODAr))]; |
| int t31[F(__is_pod(DerivesEmpty))]; |
| int t32[F(__is_pod(void))]; |
| int t33[F(__is_pod(cvoid))]; |
| int t34[F(__is_pod(NonPODArNB))]; |
| // int t32[F(__is_pod(NonPODUnion))]; |
| } |
| |
| typedef Empty EmptyAr[10]; |
| struct Bit0 { int : 0; }; |
| struct Bit0Cons { int : 0; Bit0Cons(); }; |
| struct BitOnly { int x : 3; }; |
| //struct DerivesVirt : virtual POD {}; |
| |
| void is_empty() |
| { |
| int t01[T(__is_empty(Empty))]; |
| int t02[T(__is_empty(DerivesEmpty))]; |
| int t03[T(__is_empty(HasCons))]; |
| int t04[T(__is_empty(HasCopyAssign))]; |
| int t05[T(__is_empty(HasDest))]; |
| int t06[T(__is_empty(HasFunc))]; |
| int t07[T(__is_empty(HasOp))]; |
| int t08[T(__is_empty(HasConv))]; |
| int t09[T(__is_empty(HasAssign))]; |
| int t10[T(__is_empty(Bit0))]; |
| int t11[T(__is_empty(Bit0Cons))]; |
| |
| int t21[F(__is_empty(Int))]; |
| int t22[F(__is_empty(POD))]; |
| int t23[F(__is_empty(EmptyUnion))]; |
| int t24[F(__is_empty(EmptyAr))]; |
| int t25[F(__is_empty(HasRef))]; |
| int t26[F(__is_empty(HasVirt))]; |
| int t27[F(__is_empty(BitOnly))]; |
| int t28[F(__is_empty(void))]; |
| int t29[F(__is_empty(IntArNB))]; |
| int t30[F(__is_empty(HasAnonymousUnion))]; |
| // int t27[F(__is_empty(DerivesVirt))]; |
| } |
| |
| typedef Derives ClassType; |
| |
| void is_class() |
| { |
| int t01[T(__is_class(Derives))]; |
| int t02[T(__is_class(HasPriv))]; |
| int t03[T(__is_class(ClassType))]; |
| int t04[T(__is_class(HasAnonymousUnion))]; |
| |
| int t11[F(__is_class(int))]; |
| int t12[F(__is_class(Enum))]; |
| int t13[F(__is_class(Int))]; |
| int t14[F(__is_class(IntAr))]; |
| int t15[F(__is_class(NonPODAr))]; |
| int t16[F(__is_class(Union))]; |
| int t17[F(__is_class(cvoid))]; |
| int t18[F(__is_class(IntArNB))]; |
| } |
| |
| typedef Union UnionAr[10]; |
| typedef Union UnionType; |
| |
| void is_union() |
| { |
| int t01[T(__is_union(Union))]; |
| int t02[T(__is_union(UnionType))]; |
| |
| int t11[F(__is_union(int))]; |
| int t12[F(__is_union(Enum))]; |
| int t13[F(__is_union(Int))]; |
| int t14[F(__is_union(IntAr))]; |
| int t15[F(__is_union(UnionAr))]; |
| int t16[F(__is_union(cvoid))]; |
| int t17[F(__is_union(IntArNB))]; |
| int t18[F(__is_union(HasAnonymousUnion))]; |
| } |
| |
| typedef Enum EnumType; |
| |
| void is_enum() |
| { |
| int t01[T(__is_enum(Enum))]; |
| int t02[T(__is_enum(EnumType))]; |
| |
| int t11[F(__is_enum(int))]; |
| int t12[F(__is_enum(Union))]; |
| int t13[F(__is_enum(Int))]; |
| int t14[F(__is_enum(IntAr))]; |
| int t15[F(__is_enum(UnionAr))]; |
| int t16[F(__is_enum(Derives))]; |
| int t17[F(__is_enum(ClassType))]; |
| int t18[F(__is_enum(cvoid))]; |
| int t19[F(__is_enum(IntArNB))]; |
| int t20[F(__is_enum(HasAnonymousUnion))]; |
| } |
| |
| typedef HasVirt Polymorph; |
| struct InheritPolymorph : Polymorph {}; |
| |
| void is_polymorphic() |
| { |
| int t01[T(__is_polymorphic(Polymorph))]; |
| int t02[T(__is_polymorphic(InheritPolymorph))]; |
| |
| int t11[F(__is_polymorphic(int))]; |
| int t12[F(__is_polymorphic(Union))]; |
| int t13[F(__is_polymorphic(Int))]; |
| int t14[F(__is_polymorphic(IntAr))]; |
| int t15[F(__is_polymorphic(UnionAr))]; |
| int t16[F(__is_polymorphic(Derives))]; |
| int t17[F(__is_polymorphic(ClassType))]; |
| int t18[F(__is_polymorphic(Enum))]; |
| int t19[F(__is_polymorphic(cvoid))]; |
| int t20[F(__is_polymorphic(IntArNB))]; |
| } |
| |
| typedef Int& IntRef; |
| typedef const IntAr ConstIntAr; |
| typedef ConstIntAr ConstIntArAr[4]; |
| |
| struct HasCopy { |
| HasCopy(HasCopy& cp); |
| }; |
| |
| struct HasTemplateCons { |
| HasVirt Annoying; |
| |
| template <typename T> |
| HasTemplateCons(const T&); |
| }; |
| |
| void has_trivial_default_constructor() { |
| int t01[T(__has_trivial_constructor(Int))]; |
| int t02[T(__has_trivial_constructor(IntAr))]; |
| int t03[T(__has_trivial_constructor(Union))]; |
| int t04[T(__has_trivial_constructor(UnionAr))]; |
| int t05[T(__has_trivial_constructor(POD))]; |
| int t06[T(__has_trivial_constructor(Derives))]; |
| int t07[T(__has_trivial_constructor(ConstIntAr))]; |
| int t08[T(__has_trivial_constructor(ConstIntArAr))]; |
| int t09[T(__has_trivial_constructor(HasDest))]; |
| int t10[T(__has_trivial_constructor(HasPriv))]; |
| int t11[F(__has_trivial_constructor(HasCons))]; |
| int t12[F(__has_trivial_constructor(HasRef))]; |
| int t13[F(__has_trivial_constructor(HasCopy))]; |
| int t14[F(__has_trivial_constructor(IntRef))]; |
| int t15[T(__has_trivial_constructor(HasCopyAssign))]; |
| int t16[T(__has_trivial_constructor(const Int))]; |
| int t17[T(__has_trivial_constructor(NonPODAr))]; |
| int t18[F(__has_trivial_constructor(VirtAr))]; |
| int t19[F(__has_trivial_constructor(void))]; |
| int t20[F(__has_trivial_constructor(cvoid))]; |
| int t21[F(__has_trivial_constructor(HasTemplateCons))]; |
| } |
| |
| void has_trivial_copy_constructor() { |
| int t01[T(__has_trivial_copy(Int))]; |
| int t02[T(__has_trivial_copy(IntAr))]; |
| int t03[T(__has_trivial_copy(Union))]; |
| int t04[T(__has_trivial_copy(UnionAr))]; |
| int t05[T(__has_trivial_copy(POD))]; |
| int t06[T(__has_trivial_copy(Derives))]; |
| int t07[T(__has_trivial_copy(ConstIntAr))]; |
| int t08[T(__has_trivial_copy(ConstIntArAr))]; |
| int t09[T(__has_trivial_copy(HasDest))]; |
| int t10[T(__has_trivial_copy(HasPriv))]; |
| int t11[T(__has_trivial_copy(HasCons))]; |
| int t12[T(__has_trivial_copy(HasRef))]; |
| int t13[F(__has_trivial_copy(HasCopy))]; |
| int t14[T(__has_trivial_copy(IntRef))]; |
| int t15[T(__has_trivial_copy(HasCopyAssign))]; |
| int t16[T(__has_trivial_copy(const Int))]; |
| int t17[F(__has_trivial_copy(NonPODAr))]; |
| int t18[F(__has_trivial_copy(VirtAr))]; |
| int t19[F(__has_trivial_copy(void))]; |
| int t20[F(__has_trivial_copy(cvoid))]; |
| int t21[F(__has_trivial_copy(HasTemplateCons))]; |
| } |
| |
| void has_trivial_copy_assignment() { |
| int t01[T(__has_trivial_assign(Int))]; |
| int t02[T(__has_trivial_assign(IntAr))]; |
| int t03[T(__has_trivial_assign(Union))]; |
| int t04[T(__has_trivial_assign(UnionAr))]; |
| int t05[T(__has_trivial_assign(POD))]; |
| int t06[T(__has_trivial_assign(Derives))]; |
| int t07[F(__has_trivial_assign(ConstIntAr))]; |
| int t08[F(__has_trivial_assign(ConstIntArAr))]; |
| int t09[T(__has_trivial_assign(HasDest))]; |
| int t10[T(__has_trivial_assign(HasPriv))]; |
| int t11[T(__has_trivial_assign(HasCons))]; |
| int t12[T(__has_trivial_assign(HasRef))]; |
| int t13[T(__has_trivial_assign(HasCopy))]; |
| int t14[F(__has_trivial_assign(IntRef))]; |
| int t15[F(__has_trivial_assign(HasCopyAssign))]; |
| int t16[F(__has_trivial_assign(const Int))]; |
| int t17[F(__has_trivial_assign(NonPODAr))]; |
| int t18[F(__has_trivial_assign(VirtAr))]; |
| int t19[F(__has_trivial_assign(void))]; |
| int t20[F(__has_trivial_assign(cvoid))]; |
| } |
| |
| void has_trivial_destructor() { |
| int t01[T(__has_trivial_destructor(Int))]; |
| int t02[T(__has_trivial_destructor(IntAr))]; |
| int t03[T(__has_trivial_destructor(Union))]; |
| int t04[T(__has_trivial_destructor(UnionAr))]; |
| int t05[T(__has_trivial_destructor(POD))]; |
| int t06[T(__has_trivial_destructor(Derives))]; |
| int t07[T(__has_trivial_destructor(ConstIntAr))]; |
| int t08[T(__has_trivial_destructor(ConstIntArAr))]; |
| int t09[F(__has_trivial_destructor(HasDest))]; |
| int t10[T(__has_trivial_destructor(HasPriv))]; |
| int t11[T(__has_trivial_destructor(HasCons))]; |
| int t12[T(__has_trivial_destructor(HasRef))]; |
| int t13[T(__has_trivial_destructor(HasCopy))]; |
| int t14[T(__has_trivial_destructor(IntRef))]; |
| int t15[T(__has_trivial_destructor(HasCopyAssign))]; |
| int t16[T(__has_trivial_destructor(const Int))]; |
| int t17[T(__has_trivial_destructor(NonPODAr))]; |
| int t18[T(__has_trivial_destructor(VirtAr))]; |
| int t19[F(__has_trivial_destructor(void))]; |
| int t20[F(__has_trivial_destructor(cvoid))]; |
| } |
| |
| struct A { ~A() {} }; |
| template<typename> struct B : A { }; |
| |
| void f() { |
| int t01[F(__has_trivial_destructor(A))]; |
| int t02[F(__has_trivial_destructor(B<int>))]; |
| } |
| |
| void has_nothrow_assign() { |
| int t01[T(__has_nothrow_assign(Int))]; |
| int t02[T(__has_nothrow_assign(IntAr))]; |
| int t03[T(__has_nothrow_assign(Union))]; |
| int t04[T(__has_nothrow_assign(UnionAr))]; |
| int t05[T(__has_nothrow_assign(POD))]; |
| int t06[T(__has_nothrow_assign(Derives))]; |
| int t07[F(__has_nothrow_assign(ConstIntAr))]; |
| int t08[F(__has_nothrow_assign(ConstIntArAr))]; |
| int t09[T(__has_nothrow_assign(HasDest))]; |
| int t10[T(__has_nothrow_assign(HasPriv))]; |
| int t11[T(__has_nothrow_assign(HasCons))]; |
| int t12[T(__has_nothrow_assign(HasRef))]; |
| int t13[T(__has_nothrow_assign(HasCopy))]; |
| int t14[F(__has_nothrow_assign(IntRef))]; |
| int t15[F(__has_nothrow_assign(HasCopyAssign))]; |
| int t16[F(__has_nothrow_assign(const Int))]; |
| int t17[F(__has_nothrow_assign(NonPODAr))]; |
| int t18[F(__has_nothrow_assign(VirtAr))]; |
| int t19[T(__has_nothrow_assign(HasNoThrowCopyAssign))]; |
| int t20[F(__has_nothrow_assign(HasMultipleCopyAssign))]; |
| int t21[T(__has_nothrow_assign(HasMultipleNoThrowCopyAssign))]; |
| int t22[F(__has_nothrow_assign(void))]; |
| int t23[F(__has_nothrow_assign(cvoid))]; |
| int t24[T(__has_nothrow_assign(HasVirtDest))]; |
| } |
| |
| void has_nothrow_copy() { |
| int t01[T(__has_nothrow_copy(Int))]; |
| int t02[T(__has_nothrow_copy(IntAr))]; |
| int t03[T(__has_nothrow_copy(Union))]; |
| int t04[T(__has_nothrow_copy(UnionAr))]; |
| int t05[T(__has_nothrow_copy(POD))]; |
| int t06[T(__has_nothrow_copy(Derives))]; |
| int t07[T(__has_nothrow_copy(ConstIntAr))]; |
| int t08[T(__has_nothrow_copy(ConstIntArAr))]; |
| int t09[T(__has_nothrow_copy(HasDest))]; |
| int t10[T(__has_nothrow_copy(HasPriv))]; |
| int t11[T(__has_nothrow_copy(HasCons))]; |
| int t12[T(__has_nothrow_copy(HasRef))]; |
| int t13[F(__has_nothrow_copy(HasCopy))]; |
| int t14[T(__has_nothrow_copy(IntRef))]; |
| int t15[T(__has_nothrow_copy(HasCopyAssign))]; |
| int t16[T(__has_nothrow_copy(const Int))]; |
| int t17[F(__has_nothrow_copy(NonPODAr))]; |
| int t18[F(__has_nothrow_copy(VirtAr))]; |
| |
| int t19[T(__has_nothrow_copy(HasNoThrowCopy))]; |
| int t20[F(__has_nothrow_copy(HasMultipleCopy))]; |
| int t21[T(__has_nothrow_copy(HasMultipleNoThrowCopy))]; |
| int t22[F(__has_nothrow_copy(void))]; |
| int t23[F(__has_nothrow_copy(cvoid))]; |
| int t24[T(__has_nothrow_copy(HasVirtDest))]; |
| int t25[T(__has_nothrow_copy(HasTemplateCons))]; |
| } |
| |
| void has_nothrow_constructor() { |
| int t01[T(__has_nothrow_constructor(Int))]; |
| int t02[T(__has_nothrow_constructor(IntAr))]; |
| int t03[T(__has_nothrow_constructor(Union))]; |
| int t04[T(__has_nothrow_constructor(UnionAr))]; |
| int t05[T(__has_nothrow_constructor(POD))]; |
| int t06[T(__has_nothrow_constructor(Derives))]; |
| int t07[T(__has_nothrow_constructor(ConstIntAr))]; |
| int t08[T(__has_nothrow_constructor(ConstIntArAr))]; |
| int t09[T(__has_nothrow_constructor(HasDest))]; |
| int t10[T(__has_nothrow_constructor(HasPriv))]; |
| int t11[F(__has_nothrow_constructor(HasCons))]; |
| int t12[F(__has_nothrow_constructor(HasRef))]; |
| int t13[F(__has_nothrow_constructor(HasCopy))]; |
| int t14[F(__has_nothrow_constructor(IntRef))]; |
| int t15[T(__has_nothrow_constructor(HasCopyAssign))]; |
| int t16[T(__has_nothrow_constructor(const Int))]; |
| int t17[T(__has_nothrow_constructor(NonPODAr))]; |
| // int t18[T(__has_nothrow_constructor(VirtAr))]; // not implemented |
| |
| int t19[T(__has_nothrow_constructor(HasNoThrowConstructor))]; |
| int t20[F(__has_nothrow_constructor(HasNoThrowConstructorWithArgs))]; |
| int t21[F(__has_nothrow_constructor(void))]; |
| int t22[F(__has_nothrow_constructor(cvoid))]; |
| int t23[T(__has_nothrow_constructor(HasVirtDest))]; |
| int t24[F(__has_nothrow_constructor(HasTemplateCons))]; |
| } |
| |
| void has_virtual_destructor() { |
| int t01[F(__has_virtual_destructor(Int))]; |
| int t02[F(__has_virtual_destructor(IntAr))]; |
| int t03[F(__has_virtual_destructor(Union))]; |
| int t04[F(__has_virtual_destructor(UnionAr))]; |
| int t05[F(__has_virtual_destructor(POD))]; |
| int t06[F(__has_virtual_destructor(Derives))]; |
| int t07[F(__has_virtual_destructor(ConstIntAr))]; |
| int t08[F(__has_virtual_destructor(ConstIntArAr))]; |
| int t09[F(__has_virtual_destructor(HasDest))]; |
| int t10[F(__has_virtual_destructor(HasPriv))]; |
| int t11[F(__has_virtual_destructor(HasCons))]; |
| int t12[F(__has_virtual_destructor(HasRef))]; |
| int t13[F(__has_virtual_destructor(HasCopy))]; |
| int t14[F(__has_virtual_destructor(IntRef))]; |
| int t15[F(__has_virtual_destructor(HasCopyAssign))]; |
| int t16[F(__has_virtual_destructor(const Int))]; |
| int t17[F(__has_virtual_destructor(NonPODAr))]; |
| int t18[F(__has_virtual_destructor(VirtAr))]; |
| |
| int t19[T(__has_virtual_destructor(HasVirtDest))]; |
| int t20[T(__has_virtual_destructor(DerivedVirtDest))]; |
| int t21[F(__has_virtual_destructor(VirtDestAr))]; |
| int t22[F(__has_virtual_destructor(void))]; |
| int t23[F(__has_virtual_destructor(cvoid))]; |
| } |
| |
| |
| class Base {}; |
| class Derived : Base {}; |
| class Derived2a : Derived {}; |
| class Derived2b : Derived {}; |
| class Derived3 : virtual Derived2a, virtual Derived2b {}; |
| template<typename T> struct BaseA { T a; }; |
| template<typename T> struct DerivedB : BaseA<T> { }; |
| template<typename T> struct CrazyDerived : T { }; |
| |
| |
| class class_forward; // expected-note {{forward declaration of 'class_forward'}} |
| |
| template <typename Base, typename Derived> |
| void isBaseOfT() { |
| int t[T(__is_base_of(Base, Derived))]; |
| }; |
| template <typename Base, typename Derived> |
| void isBaseOfF() { |
| int t[F(__is_base_of(Base, Derived))]; |
| }; |
| |
| template <class T> class DerivedTemp : Base {}; |
| template <class T> class NonderivedTemp {}; |
| template <class T> class UndefinedTemp; // expected-note {{declared here}} |
| |
| void is_base_of() { |
| int t01[T(__is_base_of(Base, Derived))]; |
| int t02[T(__is_base_of(const Base, Derived))]; |
| int t03[F(__is_base_of(Derived, Base))]; |
| int t04[F(__is_base_of(Derived, int))]; |
| int t05[T(__is_base_of(Base, Base))]; |
| int t06[T(__is_base_of(Base, Derived3))]; |
| int t07[T(__is_base_of(Derived, Derived3))]; |
| int t08[T(__is_base_of(Derived2b, Derived3))]; |
| int t09[T(__is_base_of(Derived2a, Derived3))]; |
| int t10[T(__is_base_of(BaseA<int>, DerivedB<int>))]; |
| int t11[F(__is_base_of(DerivedB<int>, BaseA<int>))]; |
| int t12[T(__is_base_of(Base, CrazyDerived<Base>))]; |
| int t13[F(__is_base_of(Union, Union))]; |
| int t14[T(__is_base_of(Empty, Empty))]; |
| int t15[T(__is_base_of(class_forward, class_forward))]; |
| int t16[F(__is_base_of(Empty, class_forward))]; // expected-error {{incomplete type 'class_forward' used in type trait expression}} |
| int t17[F(__is_base_of(Base&, Derived&))]; |
| int t18[F(__is_base_of(Base[10], Derived[10]))]; |
| int t19[F(__is_base_of(int, int))]; |
| int t20[F(__is_base_of(long, int))]; |
| int t21[T(__is_base_of(Base, DerivedTemp<int>))]; |
| int t22[F(__is_base_of(Base, NonderivedTemp<int>))]; |
| int t23[F(__is_base_of(Base, UndefinedTemp<int>))]; // expected-error {{implicit instantiation of undefined template 'UndefinedTemp<int>'}} |
| |
| isBaseOfT<Base, Derived>(); |
| isBaseOfF<Derived, Base>(); |
| |
| isBaseOfT<Base, CrazyDerived<Base> >(); |
| isBaseOfF<CrazyDerived<Base>, Base>(); |
| |
| isBaseOfT<BaseA<int>, DerivedB<int> >(); |
| isBaseOfF<DerivedB<int>, BaseA<int> >(); |
| } |
| |
| struct FromInt { FromInt(int); }; |
| struct ToInt { operator int(); }; |
| typedef void Function(); |
| |
| void is_convertible_to(); |
| class PrivateCopy { |
| PrivateCopy(const PrivateCopy&); |
| friend void is_convertible_to(); |
| }; |
| |
| template<typename T> |
| struct X0 { |
| template<typename U> X0(const X0<U>&); |
| }; |
| |
| void is_convertible_to() { |
| int t01[T(__is_convertible_to(Int, Int))]; |
| int t02[F(__is_convertible_to(Int, IntAr))]; |
| int t03[F(__is_convertible_to(IntAr, IntAr))]; |
| int t04[T(__is_convertible_to(void, void))]; |
| int t05[T(__is_convertible_to(cvoid, void))]; |
| int t06[T(__is_convertible_to(void, cvoid))]; |
| int t07[T(__is_convertible_to(cvoid, cvoid))]; |
| int t08[T(__is_convertible_to(int, FromInt))]; |
| int t09[T(__is_convertible_to(long, FromInt))]; |
| int t10[T(__is_convertible_to(double, FromInt))]; |
| int t11[T(__is_convertible_to(const int, FromInt))]; |
| int t12[T(__is_convertible_to(const int&, FromInt))]; |
| int t13[T(__is_convertible_to(ToInt, int))]; |
| int t14[T(__is_convertible_to(ToInt, const int&))]; |
| int t15[T(__is_convertible_to(ToInt, long))]; |
| int t16[F(__is_convertible_to(ToInt, int&))]; |
| int t17[F(__is_convertible_to(ToInt, FromInt))]; |
| int t18[T(__is_convertible_to(IntAr&, IntAr&))]; |
| int t19[T(__is_convertible_to(IntAr&, const IntAr&))]; |
| int t20[F(__is_convertible_to(const IntAr&, IntAr&))]; |
| int t21[F(__is_convertible_to(Function, Function))]; |
| int t22[F(__is_convertible_to(PrivateCopy, PrivateCopy))]; |
| int t23[T(__is_convertible_to(X0<int>, X0<float>))]; |
| } |
