Lines Matching refs:Template
351 // template-parameter (14.1). It shall not be specified for a
397 // For non-template functions, default arguments can be added in
433 // of template class. The new default parameter's value is ignored.
485 // Paragraph 4, quoted above, only applies to non-template functions.
497 // - the explicit specialization of a function template;
498 // - the explicit specialization of a member function template;
500 // template where the class template specialization to which the
509 // Default arguments for a member function of a class template shall
511 // within the class template.
553 // template has a constexpr specifier then all its declarations shall
1739 // Member field could not be with "template" keyword.
1744 // There is no such thing as a member field template.
1750 // There is an extraneous 'template<>' for this member.
1814 // If we have declared a member function template, set the access of the
1965 /// instantiating an in-class initializer in a class template. Such actions
2376 // Template instantiation doesn't reconstruct ParenListExprs for us.
2495 // If we are in a dependent context, template instantiation will
2627 // If we are in a dependent context, template instantiation will
3171 // Let template instantiation know whether we had errors.
3850 // TODO: other template argument types?
4082 // If a template instantiates to a non-literal type, but its members
4083 // instantiate to constexpr functions, the template is technically
4138 // involve, for instance, template instantiation), we compute whether a
4962 // struct A { template<typename T> A(T&); };
5527 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(D))
5528 Params = Template->getTemplateParameters();
6254 // template <typename E> class std::initializer_list.
6259 ClassTemplateDecl *Template = 0;
6269 Template = Specialization->getSpecializedTemplate();
6273 Template = dyn_cast_or_null<ClassTemplateDecl>(
6277 if (!Template)
6282 CXXRecordDecl *TemplateClass = Template->getTemplatedDecl();
6288 // This is a template called std::initializer_list, but is it the right
6289 // template?
6290 TemplateParameterList *Params = Template->getTemplateParameters();
6296 // It's the right template.
6297 StdInitializerList = Template;
6300 if (Template != StdInitializerList)
6322 ClassTemplateDecl *Template = Result.getAsSingle<ClassTemplateDecl>();
6323 if (!Template) {
6331 // We found some template
6333 TemplateParameterList *Params = Template->getTemplateParameters();
6336 S.Diag(Template->getLocation(), diag::err_malformed_std_initializer_list);
6340 return Template;
6639 // template <class T> struct C : A {};
6640 // template <class T> struct D : C<T> { using B::foo; } // <---
7070 // template instantiation can cause this check to trigger when it
7254 // Warn about shadowing the name of a template parameter.
7333 // Merge any previous default template arguments into our parameters,
7710 // - all non-template constructors of X, and
7711 // - for each non-template constructor of X that has at least one
9810 // A function template must have at least 2 parameters.
10047 // This might be the definition of a literal operator template.
10049 // This might be a specialization of a literal operator template.
10053 // template <char...> type operator "" name() is the only valid template
10057 // Must have only one template parameter
10063 // The template parameter must be a char parameter pack.
10357 // Maybe we will complain about the shadowed template parameter.
10453 // Do not complain about the form of friend template types during
10454 // template instantiation; we will already have complained when the
10455 // template was declared.
10528 // This is a declaration of a class template.
10539 // The "template<>" header is extraneous.
10559 // about the template header and build an appropriate non-templated
10608 // template <class T> class A<T>::B;
10635 /// class-head (i.e. no typedefs in the scope chain), template
10636 /// parameters are required to match up with simple template-ids, &c.
10637 /// However, unlike when declaring a template specialization, it's
10638 /// okay to refer to a template specialization without an empty
10639 /// template parameter declaration, e.g.
10641 /// We permit this as a special case; if there are any template
10643 /// template <> template \<class T> friend class A<int>::B;
10668 // template <T> friend A<T>::foo;
10675 // FIXME: handle "template <> friend class A<T>;", which
10692 // friend a member of an arbitrary specialization of your template).
10729 // type dependent on a template-parameter and this causes
10778 // appropriate scope and look for a function or function template
10784 // a template-id and the declaration is a function or an
10848 // or function template.
10898 // - There's a scope specifier that does not match any template
10900 // create a method or method template, and wait for instantiation.
10901 // - There's a scope specifier that does match some template
11598 // call in an uninstantiated template.
