1// RUN: %clang_cc1 -fsyntax-only -verify %s
2template<template<typename T> class MetaFun, typename Value>
3struct apply {
4  typedef typename MetaFun<Value>::type type;
5};
6
7template<class T>
8struct add_pointer {
9  typedef T* type;
10};
11
12template<class T>
13struct add_reference {
14  typedef T& type;
15};
16
17int i;
18apply<add_pointer, int>::type ip = &i;
19apply<add_reference, int>::type ir = i;
20apply<add_reference, float>::type fr = i; // expected-error{{non-const lvalue reference to type 'float' cannot bind to a value of unrelated type 'int'}}
21
22// Template template parameters
23template<int> struct B; // expected-note{{has a different type 'int'}}
24
25template<typename T,
26         template<T Value> class X> // expected-error{{cannot have type 'float'}} \
27                                    // expected-note{{with type 'long'}}
28struct X0 { };
29
30X0<int, B> x0b1;
31X0<float, B> x0b2; // expected-note{{while substituting}}
32X0<long, B> x0b3; // expected-error{{template template argument has different template parameters}}
33
34template<template<int V> class TT> // expected-note{{parameter with type 'int'}}
35struct X1 { };
36
37template<typename T, template<T V> class TT>
38struct X2 {
39  X1<TT> x1; // expected-error{{has different template parameters}}
40};
41
42template<int V> struct X3i { };
43template<long V> struct X3l { }; // expected-note{{different type 'long'}}
44
45X2<int, X3i> x2okay;
46X2<long, X3l> x2bad; // expected-note{{instantiation}}
47
48template <typename T, template <T, T> class TT, class R = TT<1, 2> >
49struct Comp {
50  typedef R r1;
51  template <T x, T y> struct gt {
52    static const bool result = x > y;
53  };
54  typedef gt<2, 1> r2;
55};
56
57template <int x, int y> struct lt {
58  static const bool result = x < y;
59};
60
61Comp<int, lt> c0;
62
63namespace PR8629 {
64  template<template<int> class TT> struct X0
65  {
66    static void apply();
67  };
68  template<int> struct Type { };
69
70  template<class T> struct X1
71  {
72    template<class U> struct Inner;
73
74    template<class U> void g()
75    {
76      typedef Inner<U> Init;
77      X0<Init::template VeryInner>::apply();
78    }
79    template<int N> void f ()
80    {
81      g<Type<N> >();
82    }
83  };
84  template<class T> template<class U> struct X1<T>::Inner
85  {
86    template<int> struct VeryInner {
87    };
88  };
89  struct X1Container
90  {
91    X1Container()
92    {
93      simplex_.f<0>();
94    }
95    X1<double> simplex_;
96  };
97}
98