Home | History | Annotate | Download | only in temp.variadic 
      1 // RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s
      2 
      3 template<typename T, typename U> struct pair { };
      4 template<typename ...Types> struct tuple { };
      5 
      6 template<typename T, typename U>
      7 struct is_same {
      8   static const bool value = false;
      9 };
     10 
     11 template<typename T>
     12 struct is_same<T, T> {
     13   static const bool value = true;
     14 };
     15 
     16 namespace ExpandIntoFixed {
     17   template<typename T,
     18            typename U,
     19            typename V = pair<T, U>,
     20            typename W = V*>
     21   class X0 { };
     22 
     23   template<typename ...Ts>
     24   class X1 {
     25   public:
     26     typedef X0<Ts...> type;
     27   };
     28 
     29   static_assert(is_same<X1<int, int>::type,
     30                         X0<int, int, pair<int, int>, pair<int, int>*>>::value,
     31                 "fails with two default arguments");
     32 
     33   static_assert(is_same<X1<int, int, float>::type,
     34                         X0<int, int, float, float*>>::value,
     35                 "fails with one default argument");
     36 
     37   static_assert(is_same<X1<int, int, float, double>::type,
     38                         X0<int, int, float, double>>::value,
     39                 "fails with no default arguments");
     40 }
     41 
     42 namespace ExpandIntoFixedShifted {
     43   template<typename T,
     44            typename U,
     45            typename V = pair<T, U>,
     46            typename W = V*>
     47   class X0 { };
     48 
     49   template<typename ...Ts>
     50   class X1 {
     51   public:
     52     typedef X0<char, Ts...> type;
     53   };
     54 
     55   static_assert(is_same<X1<int>::type,
     56                         X0<char, int, pair<char, int>, pair<char, int>*>>::value,
     57                 "fails with two default arguments");
     58 
     59   static_assert(is_same<X1<int, float>::type,
     60                         X0<char, int, float, float*>>::value,
     61                 "fails with one default argument");
     62 
     63   static_assert(is_same<X1<int, float, double>::type,
     64                         X0<char, int, float, double>>::value,
     65                 "fails with no default arguments");
     66 }
     67 
     68 namespace Deduction {
     69   template <typename X, typename Y = double> struct Foo {};
     70   template <typename ...Args> tuple<Args...> &foo(Foo<Args...>);
     71 
     72   void call_foo(Foo<int, float> foo_if, Foo<int> foo_i) {
     73     tuple<int, float> &t1 = foo(foo_if);
     74     tuple<int, double> &t2 = foo(foo_i);
     75   }
     76 }
     77 
     78 namespace PR9021a {
     79   template<typename, typename>
     80   struct A { };
     81 
     82   template<typename ...T>
     83   struct B {
     84     A<T...> a1;
     85   };
     86 
     87   void test() {
     88     B<int, int> c;
     89   }
     90 }
     91 
     92 namespace PR9021b {
     93   template<class, class>
     94   struct t2
     95   {
     96 
     97   };
     98 
     99   template<template<class...> class M>
    100   struct m
    101   {
    102     template<class... B>
    103     using inner = M<B...>;
    104   };
    105 
    106   m<t2> sta2;
    107 }
    108 
    109 namespace PartialSpecialization {
    110   template<typename T, typename U, typename V = U>
    111   struct X0; // expected-note{{template is declared here}}
    112 
    113   template<typename ...Ts>
    114   struct X0<Ts...> {
    115   };
    116 
    117   X0<int> x0i; // expected-error{{too few template arguments for class template 'X0'}}
    118   X0<int, float> x0if;
    119   X0<int, float, double> x0ifd;
    120 }
    121 
    122 namespace FixedAliasTemplate {
    123   template<typename,typename,typename> struct S {};
    124   template<typename T, typename U> using U = S<T, int, U>;
    125   template<typename...Ts> U<Ts...> &f(U<Ts...>, Ts...);
    126   S<int, int, double> &s1 = f({}, 0, 0.0);
    127 }
    128