llvm-project/clang/test/SemaTemplate/instantiation-default-2.cpp

// RUN: %clang_cc1 -fsyntax-only -verify %s

template<typename T, T Value> struct Constant; // expected-note{{template parameter is declared here}} \
// FIXME: bad location expected-error{{a non-type template parameter cannot have type 'float'}}

Constant<int, 5> *c1;

int x;
float f(int, double);

Constant<int&, x> *c2;
Constant<int*, &x> *c3;
Constant<float (*)(int, double), f> *c4;
Constant<float (*)(int, double), &f> *c5;

Constant<float (*)(int, int), f> *c6; // expected-error{{non-type template argument of type 'float (*)(int, double)' cannot be converted to a value of type 'float (*)(int, int)'}}

Constant<float, 0> *c7; // expected-note{{while substituting}}
Update tests to use %clang_cc1 instead of 'clang-cc' or 'clang -cc1'. - This is designed to make it obvious that %clang_cc1 is a "test variable" which is substituted. It is '%clang_cc1' instead of '%clang -cc1' because it can be useful to redefine what gets run as 'clang -cc1' (for example, to set a default target). llvm-svn: 91446 2009-12-16 04:14:24 +08:00			`// RUN: %clang_cc1 -fsyntax-only -verify %s`
Implement the basics of implicit instantiation of class templates, in response to attempts to diagnose an "incomplete" type. This will force us to use DiagnoseIncompleteType more regularly (rather than looking at isIncompleteType), but that's also a good thing. Implicit instantiation is still very simplistic, and will create a new definition for the class template specialization (as it should) but it only actually instantiates the base classes and attaches those. Actually instantiating class members will follow. Also, instantiate the types of non-type template parameters before checking them, allowing, e.g., template<typename T, T Value> struct Constant; to work properly. llvm-svn: 65924 2009-03-03 12:44:36 +08:00
			`template<typename T, T Value> struct Constant; // expected-note{{template parameter is declared here}} \`
			`// FIXME: bad location expected-error{{a non-type template parameter cannot have type 'float'}}`

			`Constant<int, 5> *c1;`

			`int x;`
			`float f(int, double);`

			`Constant<int&, x> *c2;`
			`Constant<int, &x> c3;`
			`Constant<float ()(int, double), f> c4;`
			`Constant<float ()(int, double), &f> c5;`

			`Constant<float ()(int, int), f> c6; // expected-error{{non-type template argument of type 'float ()(int, double)' cannot be converted to a value of type 'float ()(int, int)'}}`

Before checking a template template argument against its corresponding template template parameter, substitute any prior template arguments into the template template parameter. This, for example, allows us to properly check the template template argument for a class such as: template<typename T, template<T Value> class X> struct Foo; The actual implementation of this feature was trivial; most of the change is dedicated to giving decent diagnostics when this substitution goes horribly wrong. We now get a note like: note: while substituting prior template arguments into template template parameter 'X' [with T = float] As part of this change, enabled some very pedantic checking when comparing template template parameter lists, which shook out a bug in our overly-eager checking of default arguments of template template parameters. We now perform only minimal checking of such default arguments when they are initially parsed. llvm-svn: 86864 2009-11-12 03:13:48 +08:00			`Constant<float, 0> *c7; // expected-note{{while substituting}}`