Clang Project

clang_source_code/test/SemaTemplate/temp_arg_template_cxx1z.cpp
1// RUN: %clang_cc1 -fsyntax-only -verify -std=c++1z -frelaxed-template-template-args %s
2
3// expected-note@temp_arg_template_cxx1z.cpp:* 1+{{}}
4
5template<template<int> typename> struct Ti;
6template<template<int...> typename> struct TPi;
7template<template<int, int...> typename> struct TiPi;
8template<template<int..., int...> typename> struct TPiPi; // FIXME: Why is this not ill-formed?
9
10template<typename T, template<T> typename> struct tT0;
11template<template<typename T, T> typename> struct Tt0;
12
13template<template<typename> typename> struct Tt;
14template<template<typename, typename...> typename> struct TtPt;
15
16template<int> struct i;
17template<int, int = 0> struct iDi;
18template<int, int> struct ii;
19template<int...> struct Pi;
20template<int, int, int...> struct iiPi;
21
22template<int, typename = int> struct iDt;
23template<int, typename> struct it;
24
25template<typename T, T v> struct t0;
26
27template<typename...> struct Pt;
28
29namespace IntParam {
30  using ok = Pt<Ti<i>,
31        Ti<iDi>,
32        Ti<Pi>,
33        Ti<iDt>>;
34  using err1 = Ti<ii>; // expected-error {{different template parameters}}
35  using err2 = Ti<iiPi>; // expected-error {{different template parameters}}
36  using err3 = Ti<t0>; // expected-error {{different template parameters}}
37  using err4 = Ti<it>; // expected-error {{different template parameters}}
38}
39
40// These are accepted by the backwards-compatibility "parameter pack in
41// parameter matches any number of parameters in arguments" rule.
42namespace IntPackParam {
43  using ok = TPi<Pi>;
44  using ok_compat = Pt<TPi<i>, TPi<iDi>, TPi<ii>, TPi<iiPi>>;
45  using err1 = TPi<t0>; // expected-error {{different template parameters}}
46  using err2 = TPi<iDt>; // expected-error {{different template parameters}}
47  using err3 = TPi<it>; // expected-error {{different template parameters}}
48}
49
50namespace IntAndPackParam {
51  using ok = TiPi<Pi>;
52  using ok_compat = Pt<TiPi<ii>, TiPi<iDi>, TiPi<iiPi>>;
53  using err = TiPi<iDi>;
54}
55
56namespace DependentType {
57  using ok = Pt<tT0<int, i>, tT0<int, iDi>>;
58  using err1 = tT0<int, ii>; // expected-error {{different template parameters}}
59  using err2 = tT0<short, i>; // FIXME: should this be OK?
60  using err2a = tT0<long long, i>; // FIXME: should this be OK (if long long is larger than int)?
61  using err2b = tT0<void*, i>; // expected-error {{different template parameters}}
62  using err3 = tT0<short, t0>; // expected-error {{different template parameters}}
63
64  using ok2 = Tt0<t0>;
65  using err4 = Tt0<it>; // expected-error {{different template parameters}}
66}
67
68namespace Auto {
69  template<template<int> typename T> struct TInt {};
70  template<template<int*> typename T> struct TIntPtr {};
71  template<template<auto> typename T> struct TAuto {};
72  template<template<auto*> typename T> struct TAutoPtr {};
73  template<template<decltype(auto)> typename T> struct TDecltypeAuto {};
74  template<auto> struct Auto;
75  template<auto*> struct AutoPtr;
76  template<decltype(auto)> struct DecltypeAuto;
77  template<int> struct Int;
78  template<int*> struct IntPtr;
79
80  TInt<Auto> ia;
81  TInt<AutoPtr> iap; // FIXME: ill-formed (?)
82  TInt<DecltypeAuto> ida;
83  TInt<Int> ii;
84  TInt<IntPtr> iip; // expected-error {{different template parameters}}
85
86  TIntPtr<Auto> ipa;
87  TIntPtr<AutoPtr> ipap;
88  TIntPtr<DecltypeAuto> ipda;
89  TIntPtr<Int> ipi; // expected-error {{different template parameters}}
90  TIntPtr<IntPtr> ipip;
91
92  TAuto<Auto> aa;
93  TAuto<AutoPtr> aap; // FIXME: ill-formed (?)
94  TAuto<Int> ai; // FIXME: ill-formed (?)
95  TAuto<IntPtr> aip; // FIXME: ill-formed (?)
96
97  TAutoPtr<Auto> apa;
98  TAutoPtr<AutoPtr> apap;
99  TAutoPtr<Int> api; // FIXME: ill-formed (?)
100  TAutoPtr<IntPtr> apip; // FIXME: ill-formed (?)
101
102  TDecltypeAuto<DecltypeAuto> dada;
103  TDecltypeAuto<Int> dai; // FIXME: ill-formed (?)
104  TDecltypeAuto<IntPtr> daip; // FIXME: ill-formed (?)
105
106  // FIXME: It's completely unclear what should happen here, but these results
107  // seem at least plausible:
108  TAuto<DecltypeAuto> ada;
109  TAutoPtr<DecltypeAuto> apda;
110  // Perhaps this case should be invalid, as there are valid 'decltype(auto)'
111  // parameters (such as 'user-defined-type &') that are not valid 'auto'
112  // parameters.
113  TDecltypeAuto<Auto> daa;
114  TDecltypeAuto<AutoPtr> daap; // FIXME: should probably be ill-formed
115
116  int n;
117  template<auto A, decltype(A) B = &n> struct SubstFailure;
118  TInt<SubstFailure> isf; // FIXME: this should be ill-formed
119  TIntPtr<SubstFailure> ipsf;
120}
121
CodeThinker, Enjoy your reading code