1 // RUN: %clang_cc1 -fsyntax-only -verify %s
2 template<template<typename T> class MetaFun, typename Value>
3 struct apply {
4   typedef typename MetaFun<Value>::type type;
5 };
6 
7 template<class T>
8 struct add_pointer {
9   typedef T* type;
10 };
11 
12 template<class T>
13 struct add_reference {
14   typedef T& type;
15 };
16 
17 int i;
18 apply<add_pointer, int>::type ip = &i;
19 apply<add_reference, int>::type ir = i;
20 apply<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
23 template<int> struct B; // expected-note{{has a different type 'int'}}
24 
25 template<typename T,
26          template<T Value> class X> // expected-error{{cannot have type 'float'}} \
27                                     // expected-note{{with type 'long'}}
28 struct X0 { };
29 
30 X0<int, B> x0b1;
31 X0<float, B> x0b2; // expected-note{{while substituting}}
32 X0<long, B> x0b3; // expected-error{{template template argument has different template parameters}}
33 
34 template<template<int V> class TT> // expected-note{{parameter with type 'int'}}
35 struct X1 { };
36 
37 template<typename T, template<T V> class TT>
38 struct X2 {
39   X1<TT> x1; // expected-error{{has different template parameters}}
40 };
41 
42 template<int V> struct X3i { };
43 template<long V> struct X3l { }; // expected-note{{different type 'long'}}
44 
45 X2<int, X3i> x2okay;
46 X2<long, X3l> x2bad; // expected-note{{instantiation}}
47 
48 template <typename T, template <T, T> class TT, class R = TT<1, 2> >
49 struct 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 
57 template <int x, int y> struct lt {
58   static const bool result = x < y;
59 };
60 
61 Comp<int, lt> c0;
62 
63 namespace 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