maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/lib/Sema/SemaTemplateDeduction.cpp

4944 lines
199 KiB
C++
Raw Normal View History

When performing template argument deduction, ensure that multiple deductions of the same template parameter are equivalent. This allows us to implement the is_same type trait (!). Also, move template argument deduction into its own file and update a few build systems with this change (grrrr). llvm-svn: 72819
2009-06-04 08:03:07 +08:00
//===------- SemaTemplateDeduction.cpp - Template Argument Deduction ------===/
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//===----------------------------------------------------------------------===/
//
// This file implements C++ template argument deduction.
//
//===----------------------------------------------------------------------===/
Move more stuff out of Sema.h. llvm-svn: 112026
2010-08-25 13:32:35 +08:00
#include "clang/Sema/TemplateDeduction.h"
Sort all of Clang's files under 'lib', and fix up the broken headers uncovered. This required manually correcting all of the incorrect main-module headers I could find, and running the new llvm/utils/sort_includes.py script over the files. I also manually added quite a few missing headers that were uncovered by shuffling the order or moving headers up to be main-module-headers. llvm-svn: 169237
2012-12-04 17:13:33 +08:00
#include "TreeTransform.h"
When performing template argument deduction, ensure that multiple deductions of the same template parameter are equivalent. This allows us to implement the is_same type trait (!). Also, move template argument deduction into its own file and update a few build systems with this change (grrrr). llvm-svn: 72819
2009-06-04 08:03:07 +08:00
#include "clang/AST/ASTContext.h"
Struggle mightily against header inclusion in Sema.h. llvm-svn: 111904
2010-08-24 15:21:54 +08:00
#include "clang/AST/DeclObjC.h"
When performing template argument deduction, ensure that multiple deductions of the same template parameter are equivalent. This allows us to implement the is_same type trait (!). Also, move template argument deduction into its own file and update a few build systems with this change (grrrr). llvm-svn: 72819
2009-06-04 08:03:07 +08:00
#include "clang/AST/DeclTemplate.h"
#include "clang/AST/Expr.h"
#include "clang/AST/ExprCXX.h"
Sort all of Clang's files under 'lib', and fix up the broken headers uncovered. This required manually correcting all of the incorrect main-module headers I could find, and running the new llvm/utils/sort_includes.py script over the files. I also manually added quite a few missing headers that were uncovered by shuffling the order or moving headers up to be main-module-headers. llvm-svn: 169237
2012-12-04 17:13:33 +08:00
#include "clang/AST/StmtVisitor.h"
#include "clang/Sema/DeclSpec.h"
#include "clang/Sema/Sema.h"
#include "clang/Sema/Template.h"
SmallBitVectorize the deduced parameter set. llvm-svn: 149253
2012-01-31 00:17:39 +08:00
#include "llvm/ADT/SmallBitVector.h"
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
#include <algorithm>
During template argument deduction from a function call, allow deduction from pointer and pointer-to-member types to work even in the presence of a qualification conversion (C++ [temp.deduct.type]p3 bullet 2). llvm-svn: 74354
2009-06-27 07:10:12 +08:00
namespace clang {
Move more stuff out of Sema.h. llvm-svn: 112026
2010-08-25 13:32:35 +08:00
using namespace sema;
During template argument deduction from a function call, allow deduction from pointer and pointer-to-member types to work even in the presence of a qualification conversion (C++ [temp.deduct.type]p3 bullet 2). llvm-svn: 74354
2009-06-27 07:10:12 +08:00
/// \brief Various flags that control template argument deduction.
///
/// These flags can be bitwise-OR'd together.
enum TemplateDeductionFlags {
/// \brief No template argument deduction flags, which indicates the
/// strictest results for template argument deduction (as used for, e.g.,
/// matching class template partial specializations).
TDF_None = 0,
/// \brief Within template argument deduction from a function call, we are
/// matching with a parameter type for which the original parameter was
/// a reference.
TDF_ParamWithReferenceType = 0x1,
/// \brief Within template argument deduction from a function call, we
/// are matching in a case where we ignore cv-qualifiers.
TDF_IgnoreQualifiers = 0x02,
/// \brief Within template argument deduction from a function call,
/// we are matching in a case where we can perform template argument
Set the rest of the flags we need to perform template argument deduction using a base class of the argument type. No actual functionality change; this is just a hook. llvm-svn: 74356
2009-06-27 07:27:24 +08:00
/// deduction from a template-id of a derived class of the argument type.
Tighten up checking of non-dependent arguments as part of template argument deduction. This fixes the new test case (since partial ordering does not have a "verify the results of deduction" step), and will allow failed template argument deductions to return more quickly for, e.g., matching class template partial specializations. llvm-svn: 81779
2009-09-15 04:00:47 +08:00
TDF_DerivedClass = 0x04,
/// \brief Allow non-dependent types to differ, e.g., when performing
/// template argument deduction from a function call where conversions
/// may apply.
Implement the rvalue-reference deduction transformation (from T&& -> T) when taking the address of an overloaded function or matching a specialization to a template (C++0x [temp.deduct.type]p10). Fixes PR9044. llvm-svn: 124197
2011-01-26 01:19:08 +08:00
TDF_SkipNonDependent = 0x08,
/// \brief Whether we are performing template argument deduction for
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
/// parameters and arguments in a top-level template argument
Fix PR15291: noreturn adjustment in overload resolution for function templates, from Alexander Zinenko! llvm-svn: 179680
2013-04-17 16:45:07 +08:00
TDF_TopLevelParameterTypeList = 0x10,
/// \brief Within template argument deduction from overload resolution per
/// C++ [over.over] allow matching function types that are compatible in
/// terms of noreturn and default calling convention adjustments.
TDF_InOverloadResolution = 0x20
During template argument deduction from a function call, allow deduction from pointer and pointer-to-member types to work even in the presence of a qualification conversion (C++ [temp.deduct.type]p3 bullet 2). llvm-svn: 74354
2009-06-27 07:10:12 +08:00
};
}
When performing template argument deduction, ensure that multiple deductions of the same template parameter are equivalent. This allows us to implement the is_same type trait (!). Also, move template argument deduction into its own file and update a few build systems with this change (grrrr). llvm-svn: 72819
2009-06-04 08:03:07 +08:00
using namespace clang;
When deducing an integral template argument for a non-type template parameter, keep the integral value exactly as it was in the source code rather than trying to convert it to the type of the non-type template parameter (which may still be dependent!). The value will then be converted to the appropriate type once we check the resulting template arguments. Fixes PR6707. llvm-svn: 99611
2010-03-26 13:50:28 +08:00
/// \brief Compare two APSInts, extending and switching the sign as
/// necessary to compare their values regardless of underlying type.
static bool hasSameExtendedValue(llvm::APSInt X, llvm::APSInt Y) {
if (Y.getBitWidth() > X.getBitWidth())
PR5207: Change APInt methods trunc(), sext(), zext(), sextOrTrunc() and zextOrTrunc(), and APSInt methods extend(), extOrTrunc() and new method trunc(), to be const and to return a new value instead of modifying the object in place. llvm-svn: 121121
2010-12-07 16:25:34 +08:00
X = X.extend(Y.getBitWidth());
When deducing an integral template argument for a non-type template parameter, keep the integral value exactly as it was in the source code rather than trying to convert it to the type of the non-type template parameter (which may still be dependent!). The value will then be converted to the appropriate type once we check the resulting template arguments. Fixes PR6707. llvm-svn: 99611
2010-03-26 13:50:28 +08:00
else if (Y.getBitWidth() < X.getBitWidth())
PR5207: Change APInt methods trunc(), sext(), zext(), sextOrTrunc() and zextOrTrunc(), and APSInt methods extend(), extOrTrunc() and new method trunc(), to be const and to return a new value instead of modifying the object in place. llvm-svn: 121121
2010-12-07 16:25:34 +08:00
Y = Y.extend(X.getBitWidth());
When deducing an integral template argument for a non-type template parameter, keep the integral value exactly as it was in the source code rather than trying to convert it to the type of the non-type template parameter (which may still be dependent!). The value will then be converted to the appropriate type once we check the resulting template arguments. Fixes PR6707. llvm-svn: 99611
2010-03-26 13:50:28 +08:00
// If there is a signedness mismatch, correct it.
if (X.isSigned() != Y.isSigned()) {
// If the signed value is negative, then the values cannot be the same.
if ((Y.isSigned() && Y.isNegative()) || (X.isSigned() && X.isNegative()))
return false;
Y.setIsSigned(true);
X.setIsSigned(true);
}
return X == Y;
}
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
static Sema::TemplateDeductionResult
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
DeduceTemplateArguments(Sema &S,
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
TemplateParameterList *TemplateParams,
const TemplateArgument &Param,
Implement partial ordering of class template partial specializations and function templates that contain variadic templates. This involves three small-ish changes: (1) When transforming a pack expansion, if the transformed argument still contains unexpanded parameter packs, build a pack expansion. This can happen during the substitution that occurs into class template partial specialiation template arguments during partial ordering. (2) When performing template argument deduction where the argument is a pack expansion, match against the pattern of that pack expansion. (3) When performing template argument deduction against a non-pack parameter, or a non-expansion template argument, deduction fails if the argument itself is a pack expansion (C++0x [temp.deduct.type]p22). llvm-svn: 123279
2011-01-12 06:21:24 +08:00
TemplateArgument Arg,
Move more stuff out of Sema.h. llvm-svn: 112026
2010-08-25 13:32:35 +08:00
TemplateDeductionInfo &Info,
Function argument formatting fixes. llvm-svn: 185785
2013-07-08 12:13:06 +08:00
SmallVectorImpl<DeducedTemplateArgument> &Deduced);
Implement template argument deduction for class template specialization types. As the example shows, we can now compute the length of a type-list using a template metaprogram and class template partial specialization. llvm-svn: 73136
2009-06-10 00:35:58 +08:00
Implement core issue 1164, which concerns the partial ordering of f(T&) and f(T&&). llvm-svn: 123981
2011-01-22 01:29:42 +08:00
/// \brief Whether template argument deduction for two reference parameters
/// resulted in the argument type, parameter type, or neither type being more
/// qualified than the other.
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
enum DeductionQualifierComparison {
NeitherMoreQualified = 0,
ParamMoreQualified,
ArgMoreQualified
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
};
Implement core issue 1164, which concerns the partial ordering of f(T&) and f(T&&). llvm-svn: 123981
2011-01-22 01:29:42 +08:00
/// \brief Stores the result of comparing two reference parameters while
/// performing template argument deduction for partial ordering of function
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
/// templates.
Implement core issue 1164, which concerns the partial ordering of f(T&) and f(T&&). llvm-svn: 123981
2011-01-22 01:29:42 +08:00
struct RefParamPartialOrderingComparison {
/// \brief Whether the parameter type is an rvalue reference type.
bool ParamIsRvalueRef;
/// \brief Whether the argument type is an rvalue reference type.
bool ArgIsRvalueRef;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement core issue 1164, which concerns the partial ordering of f(T&) and f(T&&). llvm-svn: 123981
2011-01-22 01:29:42 +08:00
/// \brief Whether the parameter or argument (or neither) is more qualified.
DeductionQualifierComparison Qualifiers;
};
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
static Sema::TemplateDeductionResult
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
DeduceTemplateArgumentsByTypeMatch(Sema &S,
TemplateParameterList *TemplateParams,
QualType Param,
QualType Arg,
TemplateDeductionInfo &Info,
SmallVectorImpl<DeducedTemplateArgument> &
Deduced,
unsigned TDF,
bool PartialOrdering = false,
SmallVectorImpl<RefParamPartialOrderingComparison> *
Implement core issue 1164, which concerns the partial ordering of f(T&) and f(T&&). llvm-svn: 123981
2011-01-22 01:29:42 +08:00
RefParamComparisons = 0);
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
Implicitly expand argument packs when performing template argument deduction. Unify all of the looping over template arguments for deduction purposes into a single place, where argument pack expansion occurs; this is also the hook for deducing from pack expansions, which itself is not yet implemented. For now, at least we can handle a basic "count" metafunction written with variadics. See the new test for the formulation that works. llvm-svn: 122418
2010-12-23 02:17:10 +08:00
static Sema::TemplateDeductionResult
DeduceTemplateArguments(Sema &S,
TemplateParameterList *TemplateParams,
const TemplateArgument *Params, unsigned NumParams,
const TemplateArgument *Args, unsigned NumArgs,
TemplateDeductionInfo &Info,
Fix http://stackoverflow.com/questions/13521163 Don't require that, during template deduction, a template specialization type as a function parameter has at least as many template arguments as one used in a function argument (not even if the argument has been resolved to an exact type); the additional parameters might be provided by default template arguments in the template. We don't need this check, since we now implement [temp.deduct.call]p4 with an additional check after deduction. llvm-svn: 169475
2012-12-06 14:44:44 +08:00
SmallVectorImpl<DeducedTemplateArgument> &Deduced);
Implicitly expand argument packs when performing template argument deduction. Unify all of the looping over template arguments for deduction purposes into a single place, where argument pack expansion occurs; this is also the hook for deducing from pack expansions, which itself is not yet implemented. For now, at least we can handle a basic "count" metafunction written with variadics. See the new test for the formulation that works. llvm-svn: 122418
2010-12-23 02:17:10 +08:00
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
/// \brief If the given expression is of a form that permits the deduction
/// of a non-type template parameter, return the declaration of that
/// non-type template parameter.
static NonTypeTemplateParmDecl *getDeducedParameterFromExpr(Expr *E) {
PR13243: When deducing a non-type template parameter which is specified as an expression, skip over any SubstNonTypeTemplateParmExprs which alias templates may have inserted before checking for a DeclRefExpr referring to a non-type template parameter declaration. llvm-svn: 159909
2012-07-08 12:37:51 +08:00
// If we are within an alias template, the expression may have undergone
// any number of parameter substitutions already.
while (1) {
if (ImplicitCastExpr *IC = dyn_cast<ImplicitCastExpr>(E))
E = IC->getSubExpr();
else if (SubstNonTypeTemplateParmExpr *Subst =
dyn_cast<SubstNonTypeTemplateParmExpr>(E))
E = Subst->getReplacement();
else
break;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
return dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl());
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
return 0;
}
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
/// \brief Determine whether two declaration pointers refer to the same
/// declaration.
static bool isSameDeclaration(Decl *X, Decl *Y) {
if (NamedDecl *NX = dyn_cast<NamedDecl>(X))
X = NX->getUnderlyingDecl();
if (NamedDecl *NY = dyn_cast<NamedDecl>(Y))
Y = NY->getUnderlyingDecl();
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
return X->getCanonicalDecl() == Y->getCanonicalDecl();
}
/// \brief Verify that the given, deduced template arguments are compatible.
///
/// \returns The deduced template argument, or a NULL template argument if
/// the deduced template arguments were incompatible.
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
static DeducedTemplateArgument
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
checkDeducedTemplateArguments(ASTContext &Context,
const DeducedTemplateArgument &X,
const DeducedTemplateArgument &Y) {
// We have no deduction for one or both of the arguments; they're compatible.
if (X.isNull())
return Y;
if (Y.isNull())
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
return X;
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
switch (X.getKind()) {
case TemplateArgument::Null:
llvm_unreachable("Non-deduced template arguments handled above");
case TemplateArgument::Type:
// If two template type arguments have the same type, they're compatible.
if (Y.getKind() == TemplateArgument::Type &&
Context.hasSameType(X.getAsType(), Y.getAsType()))
return X;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
return DeducedTemplateArgument();
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
case TemplateArgument::Integral:
// If we deduced a constant in one case and either a dependent expression or
// declaration in another case, keep the integral constant.
// If both are integral constants with the same value, keep that value.
if (Y.getKind() == TemplateArgument::Expression ||
Y.getKind() == TemplateArgument::Declaration ||
(Y.getKind() == TemplateArgument::Integral &&
Plug a long standing memory leak in TemplateArgument. The integral APSInt value is now stored in a decomposed form and the backing store for large values is allocated via the ASTContext. This way its not leaked as TemplateArguments are never destructed when they are allocated in the ASTContext. Since the integral data is immutable it is now shared between instances, making copying TemplateArguments a trivial operation. Currently getting the integral data out of a TemplateArgument requires creating a new APSInt object. This is cheap when the value is small but can be expensive if it's not. If this turns out to be an issue a more efficient accessor could be added. llvm-svn: 158150
2012-06-07 23:09:51 +08:00
hasSameExtendedValue(X.getAsIntegral(), Y.getAsIntegral())))
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
return DeducedTemplateArgument(X,
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
X.wasDeducedFromArrayBound() &&
Y.wasDeducedFromArrayBound());
// All other combinations are incompatible.
return DeducedTemplateArgument();
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
case TemplateArgument::Template:
if (Y.getKind() == TemplateArgument::Template &&
Context.hasSameTemplateName(X.getAsTemplate(), Y.getAsTemplate()))
return X;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
// All other combinations are incompatible.
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
return DeducedTemplateArgument();
Replace the representation of template template argument pack expansions with something that is easier to use correctly: a new template argment kind, rather than a bit on an existing kind. Update all of the switch statements that deal with template arguments, fixing a few latent bugs in the process. I"m happy with this representation, now. And, oh look! Template instantiation and deduction work for template template argument pack expansions. llvm-svn: 122896
2011-01-06 02:58:31 +08:00
case TemplateArgument::TemplateExpansion:
if (Y.getKind() == TemplateArgument::TemplateExpansion &&
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Context.hasSameTemplateName(X.getAsTemplateOrTemplatePattern(),
Replace the representation of template template argument pack expansions with something that is easier to use correctly: a new template argment kind, rather than a bit on an existing kind. Update all of the switch statements that deal with template arguments, fixing a few latent bugs in the process. I"m happy with this representation, now. And, oh look! Template instantiation and deduction work for template template argument pack expansions. llvm-svn: 122896
2011-01-06 02:58:31 +08:00
Y.getAsTemplateOrTemplatePattern()))
return X;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Replace the representation of template template argument pack expansions with something that is easier to use correctly: a new template argment kind, rather than a bit on an existing kind. Update all of the switch statements that deal with template arguments, fixing a few latent bugs in the process. I"m happy with this representation, now. And, oh look! Template instantiation and deduction work for template template argument pack expansions. llvm-svn: 122896
2011-01-06 02:58:31 +08:00
// All other combinations are incompatible.
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
return DeducedTemplateArgument();
Replace the representation of template template argument pack expansions with something that is easier to use correctly: a new template argment kind, rather than a bit on an existing kind. Update all of the switch statements that deal with template arguments, fixing a few latent bugs in the process. I"m happy with this representation, now. And, oh look! Template instantiation and deduction work for template template argument pack expansions. llvm-svn: 122896
2011-01-06 02:58:31 +08:00
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
case TemplateArgument::Expression:
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// If we deduced a dependent expression in one case and either an integral
// constant or a declaration in another case, keep the integral constant
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
// or declaration.
if (Y.getKind() == TemplateArgument::Integral ||
Y.getKind() == TemplateArgument::Declaration)
return DeducedTemplateArgument(Y, X.wasDeducedFromArrayBound() &&
Y.wasDeducedFromArrayBound());
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
if (Y.getKind() == TemplateArgument::Expression) {
// Compare the expressions for equality
llvm::FoldingSetNodeID ID1, ID2;
X.getAsExpr()->Profile(ID1, Context, true);
Y.getAsExpr()->Profile(ID2, Context, true);
if (ID1 == ID2)
return X;
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
// All other combinations are incompatible.
return DeducedTemplateArgument();
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
case TemplateArgument::Declaration:
// If we deduced a declaration and a dependent expression, keep the
// declaration.
if (Y.getKind() == TemplateArgument::Expression)
return X;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
// If we deduced a declaration and an integral constant, keep the
// integral constant.
if (Y.getKind() == TemplateArgument::Integral)
return Y;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
// If we deduced two declarations, make sure they they refer to the
// same declaration.
if (Y.getKind() == TemplateArgument::Declaration &&
Fix the AST representation for non-type template arguments to encode enough information so we can mangle them correctly in cases involving dependent parameter types. (This specifically impacts cases involving null pointers and cases involving parameters of reference type.) Fix the mangler to use this information instead of trying to scavenge it out of the parameter declaration. <rdar://problem/12296776>. llvm-svn: 164656
2012-09-26 10:36:12 +08:00
isSameDeclaration(X.getAsDecl(), Y.getAsDecl()) &&
X.isDeclForReferenceParam() == Y.isDeclForReferenceParam())
return X;
// All other combinations are incompatible.
return DeducedTemplateArgument();
case TemplateArgument::NullPtr:
// If we deduced a null pointer and a dependent expression, keep the
// null pointer.
if (Y.getKind() == TemplateArgument::Expression)
return X;
// If we deduced a null pointer and an integral constant, keep the
// integral constant.
if (Y.getKind() == TemplateArgument::Integral)
return Y;
// If we deduced two null pointers, make sure they have the same type.
if (Y.getKind() == TemplateArgument::NullPtr &&
Context.hasSameType(X.getNullPtrType(), Y.getNullPtrType()))
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
return X;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
// All other combinations are incompatible.
return DeducedTemplateArgument();
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
case TemplateArgument::Pack:
if (Y.getKind() != TemplateArgument::Pack ||
X.pack_size() != Y.pack_size())
return DeducedTemplateArgument();
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
for (TemplateArgument::pack_iterator XA = X.pack_begin(),
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
XAEnd = X.pack_end(),
YA = Y.pack_begin();
XA != XAEnd; ++XA, ++YA) {
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
if (checkDeducedTemplateArguments(Context,
DeducedTemplateArgument(*XA, X.wasDeducedFromArrayBound()),
Propagate the "deduced from array bound" bit when comparing deduced template argument packs. Plus, remove a FIXME that I fixed yesterday. llvm-svn: 122903
2011-01-06 05:00:53 +08:00
DeducedTemplateArgument(*YA, Y.wasDeducedFromArrayBound()))
.isNull())
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
return DeducedTemplateArgument();
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
return X;
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
More dead code removal (using -Wunreachable-code) llvm-svn: 148577
2012-01-21 05:50:17 +08:00
llvm_unreachable("Invalid TemplateArgument Kind!");
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
/// \brief Deduce the value of the given non-type template parameter
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
/// from the given constant.
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
static Sema::TemplateDeductionResult
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
DeduceNonTypeTemplateArgument(Sema &S,
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
NonTypeTemplateParmDecl *NTTP,
When deducing an integral template argument for a non-type template parameter, keep the integral value exactly as it was in the source code rather than trying to convert it to the type of the non-type template parameter (which may still be dependent!). The value will then be converted to the appropriate type once we check the resulting template arguments. Fixes PR6707. llvm-svn: 99611
2010-03-26 13:50:28 +08:00
llvm::APSInt Value, QualType ValueType,
After performing template argument deduction for a function template, check deduced non-type template arguments and template template arguments against the template parameters for which they were deduced, performing conversions as appropriate so that deduced template arguments get the same treatment as explicitly-specified template arguments. This is the bulk of PR6723. Also keep track of whether deduction of a non-type template argument came from an array bound (vs. anywhere else). With this information, we enforce C++ [temp.deduct.type]p17, which requires exact type matches when deduction deduces a non-type template argument from something that is not an array bound. Finally, when in a SFINAE context, translate the "zero sized arrays are an extension" extension diagnostic into a hard error (for better standard conformance), which was a minor part of PR6723. llvm-svn: 99734
2010-03-28 10:42:43 +08:00
bool DeducedFromArrayBound,
Move more stuff out of Sema.h. llvm-svn: 112026
2010-08-25 13:32:35 +08:00
TemplateDeductionInfo &Info,
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
assert(NTTP->getDepth() == 0 &&
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
"Cannot deduce non-type template argument with depth > 0");
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Plug a long standing memory leak in TemplateArgument. The integral APSInt value is now stored in a decomposed form and the backing store for large values is allocated via the ASTContext. This way its not leaked as TemplateArguments are never destructed when they are allocated in the ASTContext. Since the integral data is immutable it is now shared between instances, making copying TemplateArguments a trivial operation. Currently getting the integral data out of a TemplateArgument requires creating a new APSInt object. This is cheap when the value is small but can be expensive if it's not. If this turns out to be an issue a more efficient accessor could be added. llvm-svn: 158150
2012-06-07 23:09:51 +08:00
DeducedTemplateArgument NewDeduced(S.Context, Value, ValueType,
DeducedFromArrayBound);
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
Deduced[NTTP->getIndex()],
NewDeduced);
if (Result.isNull()) {
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
Info.Param = NTTP;
Info.FirstArg = Deduced[NTTP->getIndex()];
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
Info.SecondArg = NewDeduced;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
return Sema::TDK_Inconsistent;
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
Deduced[NTTP->getIndex()] = Result;
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
return Sema::TDK_Success;
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
/// \brief Deduce the value of the given non-type template parameter
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
/// from the given type- or value-dependent expression.
///
/// \returns true if deduction succeeded, false otherwise.
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
static Sema::TemplateDeductionResult
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
DeduceNonTypeTemplateArgument(Sema &S,
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
NonTypeTemplateParmDecl *NTTP,
Expr *Value,
Move more stuff out of Sema.h. llvm-svn: 112026
2010-08-25 13:32:35 +08:00
TemplateDeductionInfo &Info,
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
assert(NTTP->getDepth() == 0 &&
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
"Cannot deduce non-type template argument with depth > 0");
assert((Value->isTypeDependent() || Value->isValueDependent()) &&
"Expression template argument must be type- or value-dependent.");
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
DeducedTemplateArgument NewDeduced(Value);
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
Deduced[NTTP->getIndex()],
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
NewDeduced);
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
if (Result.isNull()) {
Info.Param = NTTP;
Info.FirstArg = Deduced[NTTP->getIndex()];
Info.SecondArg = NewDeduced;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
return Sema::TDK_Inconsistent;
Slightly improved template argument deduction for use in partial ordering, along with another test case for partial ordering of partial specializations. llvm-svn: 81869
2009-09-16 00:51:42 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
Deduced[NTTP->getIndex()] = Result;
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
return Sema::TDK_Success;
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
}
Template argument deduction of a non-type template parameter from a template argument. llvm-svn: 88722
2009-11-14 07:45:44 +08:00
/// \brief Deduce the value of the given non-type template parameter
/// from the given declaration.
///
/// \returns true if deduction succeeded, false otherwise.
static Sema::TemplateDeductionResult
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
DeduceNonTypeTemplateArgument(Sema &S,
Function argument formatting fixes. No functional change. llvm-svn: 185786
2013-07-08 12:16:49 +08:00
NonTypeTemplateParmDecl *NTTP,
ValueDecl *D,
TemplateDeductionInfo &Info,
SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
Template argument deduction of a non-type template parameter from a template argument. llvm-svn: 88722
2009-11-14 07:45:44 +08:00
assert(NTTP->getDepth() == 0 &&
"Cannot deduce non-type template argument with depth > 0");
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Fix the AST representation for non-type template arguments to encode enough information so we can mangle them correctly in cases involving dependent parameter types. (This specifically impacts cases involving null pointers and cases involving parameters of reference type.) Fix the mangler to use this information instead of trying to scavenge it out of the parameter declaration. <rdar://problem/12296776>. llvm-svn: 164656
2012-09-26 10:36:12 +08:00
D = D ? cast<ValueDecl>(D->getCanonicalDecl()) : 0;
TemplateArgument New(D, NTTP->getType()->isReferenceType());
DeducedTemplateArgument NewDeduced(New);
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
Deduced[NTTP->getIndex()],
NewDeduced);
if (Result.isNull()) {
Info.Param = NTTP;
Info.FirstArg = Deduced[NTTP->getIndex()];
Info.SecondArg = NewDeduced;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
return Sema::TDK_Inconsistent;
Template argument deduction of a non-type template parameter from a template argument. llvm-svn: 88722
2009-11-14 07:45:44 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
Deduced[NTTP->getIndex()] = Result;
Template argument deduction of a non-type template parameter from a template argument. llvm-svn: 88722
2009-11-14 07:45:44 +08:00
return Sema::TDK_Success;
}
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
static Sema::TemplateDeductionResult
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
DeduceTemplateArguments(Sema &S,
Template argument deduction for template template parameters. This permits, among other things, ripping apart and reconstructing templates via partial specialization: template<typename T> struct DeepRemoveConst { typedef T type; }; template<typename T> struct DeepRemoveConst<const T> { typedef typename DeepRemoveConst<T>::type type; }; template<template<typename> class TT, typename T> struct DeepRemoveConst<TT<T> > { typedef TT<typename DeepRemoveConst<T>::type> type; }; Also, fix a longstanding thinko in the code handling partial ordering of class template partial specializations. We were performing the second deduction without clearing out the results of the first deduction. It's amazing we got through so much code with such a horrendous error :( llvm-svn: 86893
2009-11-12 07:06:43 +08:00
TemplateParameterList *TemplateParams,
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
TemplateName Param,
TemplateName Arg,
Move more stuff out of Sema.h. llvm-svn: 112026
2010-08-25 13:32:35 +08:00
TemplateDeductionInfo &Info,
Function argument formatting fixes. No functional change. llvm-svn: 185786
2013-07-08 12:16:49 +08:00
SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
Implement template argument deduction for class template specialization types. As the example shows, we can now compute the length of a type-list using a template metaprogram and class template partial specialization. llvm-svn: 73136
2009-06-10 00:35:58 +08:00
TemplateDecl *ParamDecl = Param.getAsTemplateDecl();
Template argument deduction for template template parameters. This permits, among other things, ripping apart and reconstructing templates via partial specialization: template<typename T> struct DeepRemoveConst { typedef T type; }; template<typename T> struct DeepRemoveConst<const T> { typedef typename DeepRemoveConst<T>::type type; }; template<template<typename> class TT, typename T> struct DeepRemoveConst<TT<T> > { typedef TT<typename DeepRemoveConst<T>::type> type; }; Also, fix a longstanding thinko in the code handling partial ordering of class template partial specializations. We were performing the second deduction without clearing out the results of the first deduction. It's amazing we got through so much code with such a horrendous error :( llvm-svn: 86893
2009-11-12 07:06:43 +08:00
if (!ParamDecl) {
// The parameter type is dependent and is not a template template parameter,
// so there is nothing that we can deduce.
return Sema::TDK_Success;
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Template argument deduction for template template parameters. This permits, among other things, ripping apart and reconstructing templates via partial specialization: template<typename T> struct DeepRemoveConst { typedef T type; }; template<typename T> struct DeepRemoveConst<const T> { typedef typename DeepRemoveConst<T>::type type; }; template<template<typename> class TT, typename T> struct DeepRemoveConst<TT<T> > { typedef TT<typename DeepRemoveConst<T>::type> type; }; Also, fix a longstanding thinko in the code handling partial ordering of class template partial specializations. We were performing the second deduction without clearing out the results of the first deduction. It's amazing we got through so much code with such a horrendous error :( llvm-svn: 86893
2009-11-12 07:06:43 +08:00
if (TemplateTemplateParmDecl *TempParam
= dyn_cast<TemplateTemplateParmDecl>(ParamDecl)) {
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
DeducedTemplateArgument NewDeduced(S.Context.getCanonicalTemplateName(Arg));
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
Deduced[TempParam->getIndex()],
NewDeduced);
if (Result.isNull()) {
Info.Param = TempParam;
Info.FirstArg = Deduced[TempParam->getIndex()];
Info.SecondArg = NewDeduced;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
return Sema::TDK_Inconsistent;
Template argument deduction for template template parameters. This permits, among other things, ripping apart and reconstructing templates via partial specialization: template<typename T> struct DeepRemoveConst { typedef T type; }; template<typename T> struct DeepRemoveConst<const T> { typedef typename DeepRemoveConst<T>::type type; }; template<template<typename> class TT, typename T> struct DeepRemoveConst<TT<T> > { typedef TT<typename DeepRemoveConst<T>::type> type; }; Also, fix a longstanding thinko in the code handling partial ordering of class template partial specializations. We were performing the second deduction without clearing out the results of the first deduction. It's amazing we got through so much code with such a horrendous error :( llvm-svn: 86893
2009-11-12 07:06:43 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
Deduced[TempParam->getIndex()] = Result;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
return Sema::TDK_Success;
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Template argument deduction for template template parameters. This permits, among other things, ripping apart and reconstructing templates via partial specialization: template<typename T> struct DeepRemoveConst { typedef T type; }; template<typename T> struct DeepRemoveConst<const T> { typedef typename DeepRemoveConst<T>::type type; }; template<template<typename> class TT, typename T> struct DeepRemoveConst<TT<T> > { typedef TT<typename DeepRemoveConst<T>::type> type; }; Also, fix a longstanding thinko in the code handling partial ordering of class template partial specializations. We were performing the second deduction without clearing out the results of the first deduction. It's amazing we got through so much code with such a horrendous error :( llvm-svn: 86893
2009-11-12 07:06:43 +08:00
// Verify that the two template names are equivalent.
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
if (S.Context.hasSameTemplateName(Param, Arg))
Template argument deduction for template template parameters. This permits, among other things, ripping apart and reconstructing templates via partial specialization: template<typename T> struct DeepRemoveConst { typedef T type; }; template<typename T> struct DeepRemoveConst<const T> { typedef typename DeepRemoveConst<T>::type type; }; template<template<typename> class TT, typename T> struct DeepRemoveConst<TT<T> > { typedef TT<typename DeepRemoveConst<T>::type> type; }; Also, fix a longstanding thinko in the code handling partial ordering of class template partial specializations. We were performing the second deduction without clearing out the results of the first deduction. It's amazing we got through so much code with such a horrendous error :( llvm-svn: 86893
2009-11-12 07:06:43 +08:00
return Sema::TDK_Success;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Template argument deduction for template template parameters. This permits, among other things, ripping apart and reconstructing templates via partial specialization: template<typename T> struct DeepRemoveConst { typedef T type; }; template<typename T> struct DeepRemoveConst<const T> { typedef typename DeepRemoveConst<T>::type type; }; template<template<typename> class TT, typename T> struct DeepRemoveConst<TT<T> > { typedef TT<typename DeepRemoveConst<T>::type> type; }; Also, fix a longstanding thinko in the code handling partial ordering of class template partial specializations. We were performing the second deduction without clearing out the results of the first deduction. It's amazing we got through so much code with such a horrendous error :( llvm-svn: 86893
2009-11-12 07:06:43 +08:00
// Mismatch of non-dependent template parameter to argument.
Info.FirstArg = TemplateArgument(Param);
Info.SecondArg = TemplateArgument(Arg);
return Sema::TDK_NonDeducedMismatch;
Implement template argument deduction for class template specialization types. As the example shows, we can now compute the length of a type-list using a template metaprogram and class template partial specialization. llvm-svn: 73136
2009-06-10 00:35:58 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
/// \brief Deduce the template arguments by comparing the template parameter
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
/// type (which is a template-id) with the template argument type.
///
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
/// \param S the Sema
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
///
/// \param TemplateParams the template parameters that we are deducing
///
/// \param Param the parameter type
///
/// \param Arg the argument type
///
/// \param Info information about the template argument deduction itself
///
/// \param Deduced the deduced template arguments
///
/// \returns the result of template argument deduction so far. Note that a
/// "success" result means that template argument deduction has not yet failed,
/// but it may still fail, later, for other reasons.
static Sema::TemplateDeductionResult
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
DeduceTemplateArguments(Sema &S,
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
TemplateParameterList *TemplateParams,
const TemplateSpecializationType *Param,
QualType Arg,
Move more stuff out of Sema.h. llvm-svn: 112026
2010-08-25 13:32:35 +08:00
TemplateDeductionInfo &Info,
Function argument formatting fixes. llvm-svn: 185785
2013-07-08 12:13:06 +08:00
SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
Canonicality is a property of qualified types, not unqualified types. llvm-svn: 84891
2009-10-23 04:10:53 +08:00
assert(Arg.isCanonical() && "Argument type must be canonical");
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
// Check whether the template argument is a dependent template-id.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
if (const TemplateSpecializationType *SpecArg
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
= dyn_cast<TemplateSpecializationType>(Arg)) {
// Perform template argument deduction for the template name.
if (Sema::TemplateDeductionResult Result
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
= DeduceTemplateArguments(S, TemplateParams,
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
Param->getTemplateName(),
SpecArg->getTemplateName(),
Info, Deduced))
return Result;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
// Perform template argument deduction on each template
When performing template argument deduction where the argument is a dependent template specialization type, the number of template arguments need not match precisely. Rather than checking the number of arguments eagerly (which does not consider argument packs), let the deduction routine for template argument lists cope with too many/too few arguments. llvm-svn: 122425
2010-12-23 02:55:49 +08:00
// argument. Ignore any missing/extra arguments, since they could be
// filled in by default arguments.
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
return DeduceTemplateArguments(S, TemplateParams,
Param->getArgs(), Param->getNumArgs(),
When performing template argument deduction where the argument is a dependent template specialization type, the number of template arguments need not match precisely. Rather than checking the number of arguments eagerly (which does not consider argument packs), let the deduction routine for template argument lists cope with too many/too few arguments. llvm-svn: 122425
2010-12-23 02:55:49 +08:00
SpecArg->getArgs(), SpecArg->getNumArgs(),
Fix http://stackoverflow.com/questions/13521163 Don't require that, during template deduction, a template specialization type as a function parameter has at least as many template arguments as one used in a function argument (not even if the argument has been resolved to an exact type); the additional parameters might be provided by default template arguments in the template. We don't need this check, since we now implement [temp.deduct.call]p4 with an additional check after deduction. llvm-svn: 169475
2012-12-06 14:44:44 +08:00
Info, Deduced);
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
// If the argument type is a class template specialization, we
// perform template argument deduction using its template
// arguments.
const RecordType *RecordArg = dyn_cast<RecordType>(Arg);
Improve 'failed template argument deduction' diagnostic for the case where we have a direct mismatch between some component of the template and some component of the argument. The diagnostic now says what the mismatch was, but doesn't yet say which part of the template doesn't match. llvm-svn: 174039
2013-01-31 13:19:49 +08:00
if (!RecordArg) {
Info.FirstArg = TemplateArgument(QualType(Param, 0));
Info.SecondArg = TemplateArgument(Arg);
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
return Sema::TDK_NonDeducedMismatch;
Improve 'failed template argument deduction' diagnostic for the case where we have a direct mismatch between some component of the template and some component of the argument. The diagnostic now says what the mismatch was, but doesn't yet say which part of the template doesn't match. llvm-svn: 174039
2013-01-31 13:19:49 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
ClassTemplateSpecializationDecl *SpecArg
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
= dyn_cast<ClassTemplateSpecializationDecl>(RecordArg->getDecl());
Improve 'failed template argument deduction' diagnostic for the case where we have a direct mismatch between some component of the template and some component of the argument. The diagnostic now says what the mismatch was, but doesn't yet say which part of the template doesn't match. llvm-svn: 174039
2013-01-31 13:19:49 +08:00
if (!SpecArg) {
Info.FirstArg = TemplateArgument(QualType(Param, 0));
Info.SecondArg = TemplateArgument(Arg);
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
return Sema::TDK_NonDeducedMismatch;
Improve 'failed template argument deduction' diagnostic for the case where we have a direct mismatch between some component of the template and some component of the argument. The diagnostic now says what the mismatch was, but doesn't yet say which part of the template doesn't match. llvm-svn: 174039
2013-01-31 13:19:49 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
// Perform template argument deduction for the template name.
if (Sema::TemplateDeductionResult Result
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
= DeduceTemplateArguments(S,
Template argument deduction for template template parameters. This permits, among other things, ripping apart and reconstructing templates via partial specialization: template<typename T> struct DeepRemoveConst { typedef T type; }; template<typename T> struct DeepRemoveConst<const T> { typedef typename DeepRemoveConst<T>::type type; }; template<template<typename> class TT, typename T> struct DeepRemoveConst<TT<T> > { typedef TT<typename DeepRemoveConst<T>::type> type; }; Also, fix a longstanding thinko in the code handling partial ordering of class template partial specializations. We were performing the second deduction without clearing out the results of the first deduction. It's amazing we got through so much code with such a horrendous error :( llvm-svn: 86893
2009-11-12 07:06:43 +08:00
TemplateParams,
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
Param->getTemplateName(),
TemplateName(SpecArg->getSpecializedTemplate()),
Info, Deduced))
return Result;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implicitly expand argument packs when performing template argument deduction. Unify all of the looping over template arguments for deduction purposes into a single place, where argument pack expansion occurs; this is also the hook for deducing from pack expansions, which itself is not yet implemented. For now, at least we can handle a basic "count" metafunction written with variadics. See the new test for the formulation that works. llvm-svn: 122418
2010-12-23 02:17:10 +08:00
// Perform template argument deduction for the template arguments.
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
return DeduceTemplateArguments(S, TemplateParams,
Implicitly expand argument packs when performing template argument deduction. Unify all of the looping over template arguments for deduction purposes into a single place, where argument pack expansion occurs; this is also the hook for deducing from pack expansions, which itself is not yet implemented. For now, at least we can handle a basic "count" metafunction written with variadics. See the new test for the formulation that works. llvm-svn: 122418
2010-12-23 02:17:10 +08:00
Param->getArgs(), Param->getNumArgs(),
SpecArg->getTemplateArgs().data(),
SpecArg->getTemplateArgs().size(),
Info, Deduced);
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
}
When perform exact-qualifier-match template argument deduction, properly account for the possibility that certain opaque types might be more qualified than they appear. Fixes PR7708. llvm-svn: 112390
2010-08-29 06:14:41 +08:00
/// \brief Determines whether the given type is an opaque type that
/// might be more qualified when instantiated.
static bool IsPossiblyOpaquelyQualifiedType(QualType T) {
switch (T->getTypeClass()) {
case Type::TypeOfExpr:
case Type::TypeOf:
case Type::DependentName:
case Type::Decltype:
case Type::UnresolvedUsing:
Generalize some operations on qualifiers. QualType::getQualifiers() and ::getCVRQualifiers() now look through array types, like all the other standard queries. Also, make a 'split' variant of getUnqualifiedType(). llvm-svn: 123751
2011-01-18 15:41:22 +08:00
case Type::TemplateTypeParm:
When perform exact-qualifier-match template argument deduction, properly account for the possibility that certain opaque types might be more qualified than they appear. Fixes PR7708. llvm-svn: 112390
2010-08-29 06:14:41 +08:00
return true;
case Type::ConstantArray:
case Type::IncompleteArray:
case Type::VariableArray:
case Type::DependentSizedArray:
return IsPossiblyOpaquelyQualifiedType(
cast<ArrayType>(T)->getElementType());
default:
return false;
}
}
Work-in-progress implementation of C++0x [temp.arg.explicit]p9, which allows an argument pack determines via explicit specification of function template arguments to be extended by further, deduced arguments. For example: template<class ... Types> void f(Types ... values); void g() { f<int*, float*>(0, 0, 0); // Types is deduced to the sequence int*, float*, int } There are a number of FIXMEs in here that indicate places where we need to implement + test retained expansions, plus a number of other places in deduction where we need to correctly cope with the explicitly-specified arguments when deducing an argument pack. Furthermore, it appears that the RecursiveASTVisitor needs to be auditied; it's missing some traversals (especially w.r.t. template arguments) that cause it not to find unexpanded parameter packs when it should. The good news, however, is that the tr1::tuple implementation now works fully, and the tr1::bind example (both from N2080) is actually working now. llvm-svn: 123163
2011-01-10 15:32:04 +08:00
/// \brief Retrieve the depth and index of a template parameter.
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
static std::pair<unsigned, unsigned>
Work-in-progress implementation of C++0x [temp.arg.explicit]p9, which allows an argument pack determines via explicit specification of function template arguments to be extended by further, deduced arguments. For example: template<class ... Types> void f(Types ... values); void g() { f<int*, float*>(0, 0, 0); // Types is deduced to the sequence int*, float*, int } There are a number of FIXMEs in here that indicate places where we need to implement + test retained expansions, plus a number of other places in deduction where we need to correctly cope with the explicitly-specified arguments when deducing an argument pack. Furthermore, it appears that the RecursiveASTVisitor needs to be auditied; it's missing some traversals (especially w.r.t. template arguments) that cause it not to find unexpanded parameter packs when it should. The good news, however, is that the tr1::tuple implementation now works fully, and the tr1::bind example (both from N2080) is actually working now. llvm-svn: 123163
2011-01-10 15:32:04 +08:00
getDepthAndIndex(NamedDecl *ND) {
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ND))
return std::make_pair(TTP->getDepth(), TTP->getIndex());
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(ND))
return std::make_pair(NTTP->getDepth(), NTTP->getIndex());
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(ND);
return std::make_pair(TTP->getDepth(), TTP->getIndex());
}
Work-in-progress implementation of C++0x [temp.arg.explicit]p9, which allows an argument pack determines via explicit specification of function template arguments to be extended by further, deduced arguments. For example: template<class ... Types> void f(Types ... values); void g() { f<int*, float*>(0, 0, 0); // Types is deduced to the sequence int*, float*, int } There are a number of FIXMEs in here that indicate places where we need to implement + test retained expansions, plus a number of other places in deduction where we need to correctly cope with the explicitly-specified arguments when deducing an argument pack. Furthermore, it appears that the RecursiveASTVisitor needs to be auditied; it's missing some traversals (especially w.r.t. template arguments) that cause it not to find unexpanded parameter packs when it should. The good news, however, is that the tr1::tuple implementation now works fully, and the tr1::bind example (both from N2080) is actually working now. llvm-svn: 123163
2011-01-10 15:32:04 +08:00
/// \brief Retrieve the depth and index of an unexpanded parameter pack.
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
static std::pair<unsigned, unsigned>
Work-in-progress implementation of C++0x [temp.arg.explicit]p9, which allows an argument pack determines via explicit specification of function template arguments to be extended by further, deduced arguments. For example: template<class ... Types> void f(Types ... values); void g() { f<int*, float*>(0, 0, 0); // Types is deduced to the sequence int*, float*, int } There are a number of FIXMEs in here that indicate places where we need to implement + test retained expansions, plus a number of other places in deduction where we need to correctly cope with the explicitly-specified arguments when deducing an argument pack. Furthermore, it appears that the RecursiveASTVisitor needs to be auditied; it's missing some traversals (especially w.r.t. template arguments) that cause it not to find unexpanded parameter packs when it should. The good news, however, is that the tr1::tuple implementation now works fully, and the tr1::bind example (both from N2080) is actually working now. llvm-svn: 123163
2011-01-10 15:32:04 +08:00
getDepthAndIndex(UnexpandedParameterPack UPP) {
if (const TemplateTypeParmType *TTP
= UPP.first.dyn_cast<const TemplateTypeParmType *>())
return std::make_pair(TTP->getDepth(), TTP->getIndex());
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Work-in-progress implementation of C++0x [temp.arg.explicit]p9, which allows an argument pack determines via explicit specification of function template arguments to be extended by further, deduced arguments. For example: template<class ... Types> void f(Types ... values); void g() { f<int*, float*>(0, 0, 0); // Types is deduced to the sequence int*, float*, int } There are a number of FIXMEs in here that indicate places where we need to implement + test retained expansions, plus a number of other places in deduction where we need to correctly cope with the explicitly-specified arguments when deducing an argument pack. Furthermore, it appears that the RecursiveASTVisitor needs to be auditied; it's missing some traversals (especially w.r.t. template arguments) that cause it not to find unexpanded parameter packs when it should. The good news, however, is that the tr1::tuple implementation now works fully, and the tr1::bind example (both from N2080) is actually working now. llvm-svn: 123163
2011-01-10 15:32:04 +08:00
return getDepthAndIndex(UPP.first.get<NamedDecl *>());
}
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
/// \brief Helper function to build a TemplateParameter when we don't
/// know its type statically.
static TemplateParameter makeTemplateParameter(Decl *D) {
if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(D))
return TemplateParameter(TTP);
Remove 'else' after 'return' llvm-svn: 185787
2013-07-08 12:24:47 +08:00
if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D))
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
return TemplateParameter(NTTP);
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
return TemplateParameter(cast<TemplateTemplateParmDecl>(D));
}
Introduce a typedef for the type of NewlyDeducedPacks to avoid repeating the small size of the inner SmallVector. llvm-svn: 185789
2013-07-08 12:44:01 +08:00
typedef SmallVector<SmallVector<DeducedTemplateArgument, 4>, 2>
NewlyDeducedPacksType;
Factor out the code to set up template argument deduction for a set of template argument packs. This also ensures that explicitly-specified template arguments get properly represented in those cases. llvm-svn: 123180
2011-01-11 01:35:05 +08:00
/// \brief Prepare to perform template argument deduction for all of the
/// arguments in a set of argument packs.
Introduce a typedef for the type of NewlyDeducedPacks to avoid repeating the small size of the inner SmallVector. llvm-svn: 185789
2013-07-08 12:44:01 +08:00
static void
PrepareArgumentPackDeduction(Sema &S,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
ArrayRef<unsigned> PackIndices,
SmallVectorImpl<DeducedTemplateArgument> &SavedPacks,
NewlyDeducedPacksType &NewlyDeducedPacks) {
Factor out the code to set up template argument deduction for a set of template argument packs. This also ensures that explicitly-specified template arguments get properly represented in those cases. llvm-svn: 123180
2011-01-11 01:35:05 +08:00
// Save the deduced template arguments for each parameter pack expanded
// by this pack expansion, then clear out the deduction.
for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) {
// Save the previously-deduced argument pack, then clear it out so that we
// can deduce a new argument pack.
SavedPacks[I] = Deduced[PackIndices[I]];
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Deduced[PackIndices[I]] = TemplateArgument();
Fix undefined behavior: member function calls where 'this' is a null pointer. llvm-svn: 162430
2012-08-23 14:16:52 +08:00
if (!S.CurrentInstantiationScope)
continue;
PR9023: A template template parameter whose template parameter list contains an unexpanded parameter pack is a pack expansion. Thus, as with a non-type template parameter which is a pack expansion, it needs to be expanded early into a fixed list of template parameters. Since the expanded list of template parameters is not itself a parameter pack, it is permitted to appear before the end of the template parameter list, so also remove that restriction (for both template template parameter pack expansions and non-type template parameter pack expansions). llvm-svn: 163369
2012-09-07 10:06:42 +08:00
// If the template argument pack was explicitly specified, add that to
Factor out the code to set up template argument deduction for a set of template argument packs. This also ensures that explicitly-specified template arguments get properly represented in those cases. llvm-svn: 123180
2011-01-11 01:35:05 +08:00
// the set of deduced arguments.
const TemplateArgument *ExplicitArgs;
unsigned NumExplicitArgs;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
if (NamedDecl *PartiallySubstitutedPack
Factor out the code to set up template argument deduction for a set of template argument packs. This also ensures that explicitly-specified template arguments get properly represented in those cases. llvm-svn: 123180
2011-01-11 01:35:05 +08:00
= S.CurrentInstantiationScope->getPartiallySubstitutedPack(
&ExplicitArgs,
&NumExplicitArgs)) {
if (getDepthAndIndex(PartiallySubstitutedPack).second == PackIndices[I])
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
NewlyDeducedPacks[I].append(ExplicitArgs,
Factor out the code to set up template argument deduction for a set of template argument packs. This also ensures that explicitly-specified template arguments get properly represented in those cases. llvm-svn: 123180
2011-01-11 01:35:05 +08:00
ExplicitArgs + NumExplicitArgs);
}
}
}
Repent for my copy-and-paste sins, factoring out the code that forms argument packs from a set of deduced arguments, then checks that those argument packs match previously-deduced argument packs. llvm-svn: 123182
2011-01-11 01:53:52 +08:00
/// \brief Finish template argument deduction for a set of argument packs,
/// producing the argument packs and checking for consistency with prior
/// deductions.
static Sema::TemplateDeductionResult
FinishArgumentPackDeduction(Sema &S,
Introduce a typedef for the type of NewlyDeducedPacks to avoid repeating the small size of the inner SmallVector. llvm-svn: 185789
2013-07-08 12:44:01 +08:00
TemplateParameterList *TemplateParams,
bool HasAnyArguments,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
ArrayRef<unsigned> PackIndices,
SmallVectorImpl<DeducedTemplateArgument> &SavedPacks,
NewlyDeducedPacksType &NewlyDeducedPacks,
TemplateDeductionInfo &Info) {
Repent for my copy-and-paste sins, factoring out the code that forms argument packs from a set of deduced arguments, then checks that those argument packs match previously-deduced argument packs. llvm-svn: 123182
2011-01-11 01:53:52 +08:00
// Build argument packs for each of the parameter packs expanded by this
// pack expansion.
for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) {
if (HasAnyArguments && NewlyDeducedPacks[I].empty()) {
// We were not able to deduce anything for this parameter pack,
// so just restore the saved argument pack.
Deduced[PackIndices[I]] = SavedPacks[I];
continue;
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Repent for my copy-and-paste sins, factoring out the code that forms argument packs from a set of deduced arguments, then checks that those argument packs match previously-deduced argument packs. llvm-svn: 123182
2011-01-11 01:53:52 +08:00
DeducedTemplateArgument NewPack;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Repent for my copy-and-paste sins, factoring out the code that forms argument packs from a set of deduced arguments, then checks that those argument packs match previously-deduced argument packs. llvm-svn: 123182
2011-01-11 01:53:52 +08:00
if (NewlyDeducedPacks[I].empty()) {
// If we deduced an empty argument pack, create it now.
Fix the AST representation for non-type template arguments to encode enough information so we can mangle them correctly in cases involving dependent parameter types. (This specifically impacts cases involving null pointers and cases involving parameters of reference type.) Fix the mangler to use this information instead of trying to scavenge it out of the parameter declaration. <rdar://problem/12296776>. llvm-svn: 164656
2012-09-26 10:36:12 +08:00
NewPack = DeducedTemplateArgument(TemplateArgument::getEmptyPack());
Repent for my copy-and-paste sins, factoring out the code that forms argument packs from a set of deduced arguments, then checks that those argument packs match previously-deduced argument packs. llvm-svn: 123182
2011-01-11 01:53:52 +08:00
} else {
TemplateArgument *ArgumentPack
Add TemplateArgument::CreatePackCopy() to create a new parameter pack in ASTContext-allocated memory, copying the provided template arguments. Use this new routine where we can. No functionality change. llvm-svn: 123289
2011-01-12 07:09:57 +08:00
= new (S.Context) TemplateArgument [NewlyDeducedPacks[I].size()];
Repent for my copy-and-paste sins, factoring out the code that forms argument packs from a set of deduced arguments, then checks that those argument packs match previously-deduced argument packs. llvm-svn: 123182
2011-01-11 01:53:52 +08:00
std::copy(NewlyDeducedPacks[I].begin(), NewlyDeducedPacks[I].end(),
ArgumentPack);
NewPack
Add TemplateArgument::CreatePackCopy() to create a new parameter pack in ASTContext-allocated memory, copying the provided template arguments. Use this new routine where we can. No functionality change. llvm-svn: 123289
2011-01-12 07:09:57 +08:00
= DeducedTemplateArgument(TemplateArgument(ArgumentPack,
NewlyDeducedPacks[I].size()),
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
NewlyDeducedPacks[I][0].wasDeducedFromArrayBound());
Repent for my copy-and-paste sins, factoring out the code that forms argument packs from a set of deduced arguments, then checks that those argument packs match previously-deduced argument packs. llvm-svn: 123182
2011-01-11 01:53:52 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Repent for my copy-and-paste sins, factoring out the code that forms argument packs from a set of deduced arguments, then checks that those argument packs match previously-deduced argument packs. llvm-svn: 123182
2011-01-11 01:53:52 +08:00
DeducedTemplateArgument Result
= checkDeducedTemplateArguments(S.Context, SavedPacks[I], NewPack);
if (Result.isNull()) {
Info.Param
= makeTemplateParameter(TemplateParams->getParam(PackIndices[I]));
Info.FirstArg = SavedPacks[I];
Info.SecondArg = NewPack;
return Sema::TDK_Inconsistent;
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Repent for my copy-and-paste sins, factoring out the code that forms argument packs from a set of deduced arguments, then checks that those argument packs match previously-deduced argument packs. llvm-svn: 123182
2011-01-11 01:53:52 +08:00
Deduced[PackIndices[I]] = Result;
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Repent for my copy-and-paste sins, factoring out the code that forms argument packs from a set of deduced arguments, then checks that those argument packs match previously-deduced argument packs. llvm-svn: 123182
2011-01-11 01:53:52 +08:00
return Sema::TDK_Success;
}
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
/// \brief Deduce the template arguments by comparing the list of parameter
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
/// types to the list of argument types, as in the parameter-type-lists of
/// function types (C++ [temp.deduct.type]p10).
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
///
/// \param S The semantic analysis object within which we are deducing
///
/// \param TemplateParams The template parameters that we are deducing
///
/// \param Params The list of parameter types
///
/// \param NumParams The number of types in \c Params
///
/// \param Args The list of argument types
///
/// \param NumArgs The number of types in \c Args
///
/// \param Info information about the template argument deduction itself
///
/// \param Deduced the deduced template arguments
///
/// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe
/// how template argument deduction is performed.
///
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
/// \param PartialOrdering If true, we are performing template argument
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
/// deduction for during partial ordering for a call
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
/// (C++0x [temp.deduct.partial]).
///
Implement core issue 1164, which concerns the partial ordering of f(T&) and f(T&&). llvm-svn: 123981
2011-01-22 01:29:42 +08:00
/// \param RefParamComparisons If we're performing template argument deduction
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
/// in the context of partial ordering, the set of qualifier comparisons.
///
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
/// \returns the result of template argument deduction so far. Note that a
/// "success" result means that template argument deduction has not yet failed,
/// but it may still fail, later, for other reasons.
static Sema::TemplateDeductionResult
DeduceTemplateArguments(Sema &S,
TemplateParameterList *TemplateParams,
const QualType *Params, unsigned NumParams,
const QualType *Args, unsigned NumArgs,
TemplateDeductionInfo &Info,
Function argument formatting fixes. No functional change. llvm-svn: 185786
2013-07-08 12:16:49 +08:00
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
unsigned TDF,
bool PartialOrdering = false,
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVectorImpl<RefParamPartialOrderingComparison> *
Implement core issue 1164, which concerns the partial ordering of f(T&) and f(T&&). llvm-svn: 123981
2011-01-22 01:29:42 +08:00
RefParamComparisons = 0) {
Fast-path an arity check when performing template argument deduction that compares two parameter-type-lists. No functionality change. llvm-svn: 122928
2011-01-06 07:23:17 +08:00
// Fast-path check to see if we have too many/too few arguments.
if (NumParams != NumArgs &&
!(NumParams && isa<PackExpansionType>(Params[NumParams - 1])) &&
!(NumArgs && isa<PackExpansionType>(Args[NumArgs - 1])))
Improve 'failed template argument deduction' diagnostic for the case where we have a direct mismatch between some component of the template and some component of the argument. The diagnostic now says what the mismatch was, but doesn't yet say which part of the template doesn't match. llvm-svn: 174039
2013-01-31 13:19:49 +08:00
return Sema::TDK_MiscellaneousDeductionFailure;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
// C++0x [temp.deduct.type]p10:
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// Similarly, if P has a form that contains (T), then each parameter type
// Pi of the respective parameter-type- list of P is compared with the
// corresponding parameter type Ai of the corresponding parameter-type-list
// of A. [...]
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
unsigned ArgIdx = 0, ParamIdx = 0;
for (; ParamIdx != NumParams; ++ParamIdx) {
// Check argument types.
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
const PackExpansionType *Expansion
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
= dyn_cast<PackExpansionType>(Params[ParamIdx]);
if (!Expansion) {
// Simple case: compare the parameter and argument types at this point.
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
// Make sure we have an argument.
if (ArgIdx >= NumArgs)
Improve 'failed template argument deduction' diagnostic for the case where we have a direct mismatch between some component of the template and some component of the argument. The diagnostic now says what the mismatch was, but doesn't yet say which part of the template doesn't match. llvm-svn: 174039
2013-01-31 13:19:49 +08:00
return Sema::TDK_MiscellaneousDeductionFailure;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement partial ordering of class template partial specializations and function templates that contain variadic templates. This involves three small-ish changes: (1) When transforming a pack expansion, if the transformed argument still contains unexpanded parameter packs, build a pack expansion. This can happen during the substitution that occurs into class template partial specialiation template arguments during partial ordering. (2) When performing template argument deduction where the argument is a pack expansion, match against the pattern of that pack expansion. (3) When performing template argument deduction against a non-pack parameter, or a non-expansion template argument, deduction fails if the argument itself is a pack expansion (C++0x [temp.deduct.type]p22). llvm-svn: 123279
2011-01-12 06:21:24 +08:00
if (isa<PackExpansionType>(Args[ArgIdx])) {
// C++0x [temp.deduct.type]p22:
// If the original function parameter associated with A is a function
// parameter pack and the function parameter associated with P is not
// a function parameter pack, then template argument deduction fails.
Improve 'failed template argument deduction' diagnostic for the case where we have a direct mismatch between some component of the template and some component of the argument. The diagnostic now says what the mismatch was, but doesn't yet say which part of the template doesn't match. llvm-svn: 174039
2013-01-31 13:19:49 +08:00
return Sema::TDK_MiscellaneousDeductionFailure;
Implement partial ordering of class template partial specializations and function templates that contain variadic templates. This involves three small-ish changes: (1) When transforming a pack expansion, if the transformed argument still contains unexpanded parameter packs, build a pack expansion. This can happen during the substitution that occurs into class template partial specialiation template arguments during partial ordering. (2) When performing template argument deduction where the argument is a pack expansion, match against the pattern of that pack expansion. (3) When performing template argument deduction against a non-pack parameter, or a non-expansion template argument, deduction fails if the argument itself is a pack expansion (C++0x [temp.deduct.type]p22). llvm-svn: 123279
2011-01-12 06:21:24 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
if (Sema::TemplateDeductionResult Result
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
= DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
Params[ParamIdx], Args[ArgIdx],
Info, Deduced, TDF,
PartialOrdering,
RefParamComparisons))
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
return Result;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
++ArgIdx;
continue;
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement the last bullet of [temp.deduct.type]p5 and part of the last sentence of [temp.deduct.call]p1, both of which concern the non-deducibility of parameter packs not at the end of a parameter-type-list. The latter isn't fully implemented yet; see the new FIXME. llvm-svn: 123210
2011-01-11 09:52:23 +08:00
// C++0x [temp.deduct.type]p5:
// The non-deduced contexts are:
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// - A function parameter pack that does not occur at the end of the
Implement the last bullet of [temp.deduct.type]p5 and part of the last sentence of [temp.deduct.call]p1, both of which concern the non-deducibility of parameter packs not at the end of a parameter-type-list. The latter isn't fully implemented yet; see the new FIXME. llvm-svn: 123210
2011-01-11 09:52:23 +08:00
// parameter-declaration-clause.
if (ParamIdx + 1 < NumParams)
return Sema::TDK_Success;
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
// C++0x [temp.deduct.type]p10:
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// If the parameter-declaration corresponding to Pi is a function
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
// parameter pack, then the type of its declarator- id is compared with
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// each remaining parameter type in the parameter-type-list of A. Each
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
// comparison deduces template arguments for subsequent positions in the
// template parameter packs expanded by the function parameter pack.
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
// Compute the set of template parameter indices that correspond to
// parameter packs expanded by the pack expansion.
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<unsigned, 2> PackIndices;
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
QualType Pattern = Expansion->getPattern();
{
SmallBitVectorize the deduced parameter set. llvm-svn: 149253
2012-01-31 00:17:39 +08:00
llvm::SmallBitVector SawIndices(TemplateParams->size());
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<UnexpandedParameterPack, 2> Unexpanded;
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
S.collectUnexpandedParameterPacks(Pattern, Unexpanded);
for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
unsigned Depth, Index;
llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]);
if (Depth == 0 && !SawIndices[Index]) {
SawIndices[Index] = true;
PackIndices.push_back(Index);
}
}
}
assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?");
Work-in-progress implementation of C++0x [temp.arg.explicit]p9, which allows an argument pack determines via explicit specification of function template arguments to be extended by further, deduced arguments. For example: template<class ... Types> void f(Types ... values); void g() { f<int*, float*>(0, 0, 0); // Types is deduced to the sequence int*, float*, int } There are a number of FIXMEs in here that indicate places where we need to implement + test retained expansions, plus a number of other places in deduction where we need to correctly cope with the explicitly-specified arguments when deducing an argument pack. Furthermore, it appears that the RecursiveASTVisitor needs to be auditied; it's missing some traversals (especially w.r.t. template arguments) that cause it not to find unexpanded parameter packs when it should. The good news, however, is that the tr1::tuple implementation now works fully, and the tr1::bind example (both from N2080) is actually working now. llvm-svn: 123163
2011-01-10 15:32:04 +08:00
// Keep track of the deduced template arguments for each parameter pack
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// expanded by this pack expansion (the outer index) and for each
Work-in-progress implementation of C++0x [temp.arg.explicit]p9, which allows an argument pack determines via explicit specification of function template arguments to be extended by further, deduced arguments. For example: template<class ... Types> void f(Types ... values); void g() { f<int*, float*>(0, 0, 0); // Types is deduced to the sequence int*, float*, int } There are a number of FIXMEs in here that indicate places where we need to implement + test retained expansions, plus a number of other places in deduction where we need to correctly cope with the explicitly-specified arguments when deducing an argument pack. Furthermore, it appears that the RecursiveASTVisitor needs to be auditied; it's missing some traversals (especially w.r.t. template arguments) that cause it not to find unexpanded parameter packs when it should. The good news, however, is that the tr1::tuple implementation now works fully, and the tr1::bind example (both from N2080) is actually working now. llvm-svn: 123163
2011-01-10 15:32:04 +08:00
// template argument (the inner SmallVectors).
Introduce a typedef for the type of NewlyDeducedPacks to avoid repeating the small size of the inner SmallVector. llvm-svn: 185789
2013-07-08 12:44:01 +08:00
NewlyDeducedPacksType NewlyDeducedPacks(PackIndices.size());
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<DeducedTemplateArgument, 2>
Factor out the code to set up template argument deduction for a set of template argument packs. This also ensures that explicitly-specified template arguments get properly represented in those cases. llvm-svn: 123180
2011-01-11 01:35:05 +08:00
SavedPacks(PackIndices.size());
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
PrepareArgumentPackDeduction(S, Deduced, PackIndices, SavedPacks,
Factor out the code to set up template argument deduction for a set of template argument packs. This also ensures that explicitly-specified template arguments get properly represented in those cases. llvm-svn: 123180
2011-01-11 01:35:05 +08:00
NewlyDeducedPacks);
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
bool HasAnyArguments = false;
for (; ArgIdx < NumArgs; ++ArgIdx) {
HasAnyArguments = true;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
// Deduce template arguments from the pattern.
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
if (Sema::TemplateDeductionResult Result
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
= DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, Pattern,
Args[ArgIdx], Info, Deduced,
TDF, PartialOrdering,
RefParamComparisons))
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
return Result;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
// Capture the deduced template arguments for each parameter pack expanded
// by this pack expansion, add them to the list of arguments we've deduced
// for that pack, then clear out the deduced argument.
for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) {
DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]];
if (!DeducedArg.isNull()) {
NewlyDeducedPacks[I].push_back(DeducedArg);
DeducedArg = DeducedTemplateArgument();
}
}
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
// Build argument packs for each of the parameter packs expanded by this
// pack expansion.
Repent for my copy-and-paste sins, factoring out the code that forms argument packs from a set of deduced arguments, then checks that those argument packs match previously-deduced argument packs. llvm-svn: 123182
2011-01-11 01:53:52 +08:00
if (Sema::TemplateDeductionResult Result
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
= FinishArgumentPackDeduction(S, TemplateParams, HasAnyArguments,
Repent for my copy-and-paste sins, factoring out the code that forms argument packs from a set of deduced arguments, then checks that those argument packs match previously-deduced argument packs. llvm-svn: 123182
2011-01-11 01:53:52 +08:00
Deduced, PackIndices, SavedPacks,
NewlyDeducedPacks, Info))
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
return Result;
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
// Make sure we don't have any extra arguments.
if (ArgIdx < NumArgs)
Improve 'failed template argument deduction' diagnostic for the case where we have a direct mismatch between some component of the template and some component of the argument. The diagnostic now says what the mismatch was, but doesn't yet say which part of the template doesn't match. llvm-svn: 174039
2013-01-31 13:19:49 +08:00
return Sema::TDK_MiscellaneousDeductionFailure;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
return Sema::TDK_Success;
}
More cleanup of template argument deduction and its handling of non-CVR qualifiers. We can now properly match address-space--qualified references during template argument deduction. llvm-svn: 130365
2011-04-28 08:56:09 +08:00
/// \brief Determine whether the parameter has qualifiers that are either
/// inconsistent with or a superset of the argument's qualifiers.
static bool hasInconsistentOrSupersetQualifiersOf(QualType ParamType,
QualType ArgType) {
Qualifiers ParamQs = ParamType.getQualifiers();
Qualifiers ArgQs = ArgType.getQualifiers();
if (ParamQs == ArgQs)
return false;
// Mismatched (but not missing) Objective-C GC attributes.
if (ParamQs.getObjCGCAttr() != ArgQs.getObjCGCAttr() &&
ParamQs.hasObjCGCAttr())
return true;
// Mismatched (but not missing) address spaces.
if (ParamQs.getAddressSpace() != ArgQs.getAddressSpace() &&
ParamQs.hasAddressSpace())
return true;
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
// Mismatched (but not missing) Objective-C lifetime qualifiers.
if (ParamQs.getObjCLifetime() != ArgQs.getObjCLifetime() &&
ParamQs.hasObjCLifetime())
return true;
More cleanup of template argument deduction and its handling of non-CVR qualifiers. We can now properly match address-space--qualified references during template argument deduction. llvm-svn: 130365
2011-04-28 08:56:09 +08:00
// CVR qualifier superset.
return (ParamQs.getCVRQualifiers() != ArgQs.getCVRQualifiers()) &&
((ParamQs.getCVRQualifiers() | ArgQs.getCVRQualifiers())
== ParamQs.getCVRQualifiers());
}
Fix PR15291: noreturn adjustment in overload resolution for function templates, from Alexander Zinenko! llvm-svn: 179680
2013-04-17 16:45:07 +08:00
/// \brief Compare types for equality with respect to possibly compatible
/// function types (noreturn adjustment, implicit calling conventions). If any
/// of parameter and argument is not a function, just perform type comparison.
///
/// \param Param the template parameter type.
///
/// \param Arg the argument type.
bool Sema::isSameOrCompatibleFunctionType(CanQualType Param,
CanQualType Arg) {
const FunctionType *ParamFunction = Param->getAs<FunctionType>(),
*ArgFunction = Arg->getAs<FunctionType>();
// Just compare if not functions.
if (!ParamFunction || !ArgFunction)
return Param == Arg;
// Noreturn adjustment.
QualType AdjustedParam;
if (IsNoReturnConversion(Param, Arg, AdjustedParam))
return Arg == Context.getCanonicalType(AdjustedParam);
// FIXME: Compatible calling conventions.
return Param == Arg;
}
Improve template argument deduction for reference parameters when deducing template arguments from a function call. Plus, add a bunch of tests. llvm-svn: 74301
2009-06-27 02:27:22 +08:00
/// \brief Deduce the template arguments by comparing the parameter type and
/// the argument type (C++ [temp.deduct.type]).
///
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
/// \param S the semantic analysis object within which we are deducing
Improve template argument deduction for reference parameters when deducing template arguments from a function call. Plus, add a bunch of tests. llvm-svn: 74301
2009-06-27 02:27:22 +08:00
///
/// \param TemplateParams the template parameters that we are deducing
///
/// \param ParamIn the parameter type
///
/// \param ArgIn the argument type
///
/// \param Info information about the template argument deduction itself
///
/// \param Deduced the deduced template arguments
///
During template argument deduction from a function call, allow deduction from pointer and pointer-to-member types to work even in the presence of a qualification conversion (C++ [temp.deduct.type]p3 bullet 2). llvm-svn: 74354
2009-06-27 07:10:12 +08:00
/// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
/// how template argument deduction is performed.
Improve template argument deduction for reference parameters when deducing template arguments from a function call. Plus, add a bunch of tests. llvm-svn: 74301
2009-06-27 02:27:22 +08:00
///
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
/// \param PartialOrdering Whether we're performing template argument deduction
/// in the context of partial ordering (C++0x [temp.deduct.partial]).
///
Implement core issue 1164, which concerns the partial ordering of f(T&) and f(T&&). llvm-svn: 123981
2011-01-22 01:29:42 +08:00
/// \param RefParamComparisons If we're performing template argument deduction
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
/// in the context of partial ordering, the set of qualifier comparisons.
///
Improve template argument deduction for reference parameters when deducing template arguments from a function call. Plus, add a bunch of tests. llvm-svn: 74301
2009-06-27 02:27:22 +08:00
/// \returns the result of template argument deduction so far. Note that a
/// "success" result means that template argument deduction has not yet failed,
/// but it may still fail, later, for other reasons.
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
static Sema::TemplateDeductionResult
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
DeduceTemplateArgumentsByTypeMatch(Sema &S,
TemplateParameterList *TemplateParams,
QualType ParamIn, QualType ArgIn,
TemplateDeductionInfo &Info,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
unsigned TDF,
bool PartialOrdering,
SmallVectorImpl<RefParamPartialOrderingComparison> *
RefParamComparisons) {
When performing template argument deduction, ensure that multiple deductions of the same template parameter are equivalent. This allows us to implement the is_same type trait (!). Also, move template argument deduction into its own file and update a few build systems with this change (grrrr). llvm-svn: 72819
2009-06-04 08:03:07 +08:00
// We only want to look at the canonical types, since typedefs and
// sugar are not part of template argument deduction.
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
QualType Param = S.Context.getCanonicalType(ParamIn);
QualType Arg = S.Context.getCanonicalType(ArgIn);
When performing template argument deduction, ensure that multiple deductions of the same template parameter are equivalent. This allows us to implement the is_same type trait (!). Also, move template argument deduction into its own file and update a few build systems with this change (grrrr). llvm-svn: 72819
2009-06-04 08:03:07 +08:00
Implement partial ordering of class template partial specializations and function templates that contain variadic templates. This involves three small-ish changes: (1) When transforming a pack expansion, if the transformed argument still contains unexpanded parameter packs, build a pack expansion. This can happen during the substitution that occurs into class template partial specialiation template arguments during partial ordering. (2) When performing template argument deduction where the argument is a pack expansion, match against the pattern of that pack expansion. (3) When performing template argument deduction against a non-pack parameter, or a non-expansion template argument, deduction fails if the argument itself is a pack expansion (C++0x [temp.deduct.type]p22). llvm-svn: 123279
2011-01-12 06:21:24 +08:00
// If the argument type is a pack expansion, look at its pattern.
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// This isn't explicitly called out
Implement partial ordering of class template partial specializations and function templates that contain variadic templates. This involves three small-ish changes: (1) When transforming a pack expansion, if the transformed argument still contains unexpanded parameter packs, build a pack expansion. This can happen during the substitution that occurs into class template partial specialiation template arguments during partial ordering. (2) When performing template argument deduction where the argument is a pack expansion, match against the pattern of that pack expansion. (3) When performing template argument deduction against a non-pack parameter, or a non-expansion template argument, deduction fails if the argument itself is a pack expansion (C++0x [temp.deduct.type]p22). llvm-svn: 123279
2011-01-12 06:21:24 +08:00
if (const PackExpansionType *ArgExpansion
= dyn_cast<PackExpansionType>(Arg))
Arg = ArgExpansion->getPattern();
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
if (PartialOrdering) {
// C++0x [temp.deduct.partial]p5:
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// Before the partial ordering is done, certain transformations are
// performed on the types used for partial ordering:
// - If P is a reference type, P is replaced by the type referred to.
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
const ReferenceType *ParamRef = Param->getAs<ReferenceType>();
if (ParamRef)
Param = ParamRef->getPointeeType();
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
// - If A is a reference type, A is replaced by the type referred to.
const ReferenceType *ArgRef = Arg->getAs<ReferenceType>();
if (ArgRef)
Arg = ArgRef->getPointeeType();
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement core issue 1164, which concerns the partial ordering of f(T&) and f(T&&). llvm-svn: 123981
2011-01-22 01:29:42 +08:00
if (RefParamComparisons && ParamRef && ArgRef) {
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
// C++0x [temp.deduct.partial]p6:
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// If both P and A were reference types (before being replaced with the
// type referred to above), determine which of the two types (if any) is
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
// more cv-qualified than the other; otherwise the types are considered
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// to be equally cv-qualified for partial ordering purposes. The result
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
// of this determination will be used below.
//
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// We save this information for later, using it only when deduction
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
// succeeds in both directions.
Implement core issue 1164, which concerns the partial ordering of f(T&) and f(T&&). llvm-svn: 123981
2011-01-22 01:29:42 +08:00
RefParamPartialOrderingComparison Comparison;
Comparison.ParamIsRvalueRef = ParamRef->getAs<RValueReferenceType>();
Comparison.ArgIsRvalueRef = ArgRef->getAs<RValueReferenceType>();
Comparison.Qualifiers = NeitherMoreQualified;
When comparing parameters of reference-to-qualified type during partial ordering of function templates, use a simple superset relationship rather than the convertibility-implying isMoreQualifiedThan/compatibilyIncludes relationship. Fixes partial ordering between references and address-space-qualified references. llvm-svn: 130612
2011-05-01 01:07:52 +08:00
Qualifiers ParamQuals = Param.getQualifiers();
Qualifiers ArgQuals = Arg.getQualifiers();
if (ParamQuals.isStrictSupersetOf(ArgQuals))
Implement core issue 1164, which concerns the partial ordering of f(T&) and f(T&&). llvm-svn: 123981
2011-01-22 01:29:42 +08:00
Comparison.Qualifiers = ParamMoreQualified;
When comparing parameters of reference-to-qualified type during partial ordering of function templates, use a simple superset relationship rather than the convertibility-implying isMoreQualifiedThan/compatibilyIncludes relationship. Fixes partial ordering between references and address-space-qualified references. llvm-svn: 130612
2011-05-01 01:07:52 +08:00
else if (ArgQuals.isStrictSupersetOf(ParamQuals))
Implement core issue 1164, which concerns the partial ordering of f(T&) and f(T&&). llvm-svn: 123981
2011-01-22 01:29:42 +08:00
Comparison.Qualifiers = ArgMoreQualified;
RefParamComparisons->push_back(Comparison);
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
// C++0x [temp.deduct.partial]p7:
// Remove any top-level cv-qualifiers:
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// - If P is a cv-qualified type, P is replaced by the cv-unqualified
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
// version of P.
Param = Param.getUnqualifiedType();
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// - If A is a cv-qualified type, A is replaced by the cv-unqualified
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
// version of A.
Arg = Arg.getUnqualifiedType();
} else {
// C++0x [temp.deduct.call]p4 bullet 1:
// - If the original P is a reference type, the deduced A (i.e., the type
// referred to by the reference) can be more cv-qualified than the
// transformed A.
if (TDF & TDF_ParamWithReferenceType) {
Qualifiers Quals;
QualType UnqualParam = S.Context.getUnqualifiedArrayType(Param, Quals);
Quals.setCVRQualifiers(Quals.getCVRQualifiers() &
Generalize some operations on qualifiers. QualType::getQualifiers() and ::getCVRQualifiers() now look through array types, like all the other standard queries. Also, make a 'split' variant of getUnqualifiedType(). llvm-svn: 123751
2011-01-18 15:41:22 +08:00
Arg.getCVRQualifiers());
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
Param = S.Context.getQualifiedType(UnqualParam, Quals);
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement the rvalue-reference deduction transformation (from T&& -> T) when taking the address of an overloaded function or matching a specialization to a template (C++0x [temp.deduct.type]p10). Fixes PR9044. llvm-svn: 124197
2011-01-26 01:19:08 +08:00
if ((TDF & TDF_TopLevelParameterTypeList) && !Param->isFunctionType()) {
// C++0x [temp.deduct.type]p10:
// If P and A are function types that originated from deduction when
// taking the address of a function template (14.8.2.2) or when deducing
// template arguments from a function declaration (14.8.2.6) and Pi and
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// Ai are parameters of the top-level parameter-type-list of P and A,
// respectively, Pi is adjusted if it is an rvalue reference to a
// cv-unqualified template parameter and Ai is an lvalue reference, in
// which case the type of Pi is changed to be the template parameter
Implement the rvalue-reference deduction transformation (from T&& -> T) when taking the address of an overloaded function or matching a specialization to a template (C++0x [temp.deduct.type]p10). Fixes PR9044. llvm-svn: 124197
2011-01-26 01:19:08 +08:00
// type (i.e., T&& is changed to simply T). [ Note: As a result, when
// Pi is T&& and Ai is X&, the adjusted Pi will be T, causing T to be
7bit-ize. llvm-svn: 124363
2011-01-27 15:09:49 +08:00
// deduced as X&. - end note ]
Implement the rvalue-reference deduction transformation (from T&& -> T) when taking the address of an overloaded function or matching a specialization to a template (C++0x [temp.deduct.type]p10). Fixes PR9044. llvm-svn: 124197
2011-01-26 01:19:08 +08:00
TDF &= ~TDF_TopLevelParameterTypeList;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement the rvalue-reference deduction transformation (from T&& -> T) when taking the address of an overloaded function or matching a specialization to a template (C++0x [temp.deduct.type]p10). Fixes PR9044. llvm-svn: 124197
2011-01-26 01:19:08 +08:00
if (const RValueReferenceType *ParamRef
= Param->getAs<RValueReferenceType>()) {
if (isa<TemplateTypeParmType>(ParamRef->getPointeeType()) &&
!ParamRef->getPointeeType().getQualifiers())
if (Arg->isLValueReferenceType())
Param = ParamRef->getPointeeType();
}
}
Improve template argument deduction for reference parameters when deducing template arguments from a function call. Plus, add a bunch of tests. llvm-svn: 74301
2009-06-27 02:27:22 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
// C++ [temp.deduct.type]p9:
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
// A template type argument T, a template template argument TT or a
// template non-type argument i can be deduced if P and A have one of
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
// the following forms:
//
// T
// cv-list T
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
if (const TemplateTypeParmType *TemplateTypeParm
Change all the Type::getAsFoo() methods to specializations of Type::getAs(). Several of the existing methods were identical to their respective specializations, and so have been removed entirely. Several more 'leaf' optimizations were introduced. The getAsFoo() methods which imposed extra conditions, like getAsObjCInterfacePointerType(), have been left in place. llvm-svn: 82501
2009-09-22 07:43:11 +08:00
= Param->getAs<TemplateTypeParmType>()) {
Don't allow template argument deduction to deduce a placeholder type, ever. Fixes PR10939. llvm-svn: 140304
2011-09-22 23:57:07 +08:00
// Just skip any attempts to deduce from a placeholder type.
if (Arg->isPlaceholderType())
return Sema::TDK_Success;
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
unsigned Index = TemplateTypeParm->getIndex();
Fix the problems with template argument deduction and array types for real. It turns out that we need to actually move all of the qualifiers up to the array type itself, then recanonicalize the deduced template argument type. llvm-svn: 76788
2009-07-23 05:30:48 +08:00
bool RecanonicalizeArg = false;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Improve template argument deduction for array types, so that a parameter const T can be matched with, e.g., volatile int [5] llvm-svn: 76773
2009-07-23 04:02:25 +08:00
// If the argument type is an array type, move the qualifiers up to the
// top level, so they can be matched with the qualifiers on the parameter.
Fix the problems with template argument deduction and array types for real. It turns out that we need to actually move all of the qualifiers up to the array type itself, then recanonicalize the deduced template argument type. llvm-svn: 76788
2009-07-23 05:30:48 +08:00
if (isa<ArrayType>(Arg)) {
Refactor the representation of qualifiers to bring ExtQualType out of the Type hierarchy. Demote 'volatile' to extended-qualifier status. Audit our use of qualifiers and fix a few places that weren't dealing with qualifiers quite right; many more remain. llvm-svn: 82705
2009-09-25 03:53:00 +08:00
Qualifiers Quals;
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
Arg = S.Context.getUnqualifiedArrayType(Arg, Quals);
Refactor the representation of qualifiers to bring ExtQualType out of the Type hierarchy. Demote 'volatile' to extended-qualifier status. Audit our use of qualifiers and fix a few places that weren't dealing with qualifiers quite right; many more remain. llvm-svn: 82705
2009-09-25 03:53:00 +08:00
if (Quals) {
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
Arg = S.Context.getQualifiedType(Arg, Quals);
Fix the problems with template argument deduction and array types for real. It turns out that we need to actually move all of the qualifiers up to the array type itself, then recanonicalize the deduced template argument type. llvm-svn: 76788
2009-07-23 05:30:48 +08:00
RecanonicalizeArg = true;
}
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
When performing template argument deduction, ensure that multiple deductions of the same template parameter are equivalent. This allows us to implement the is_same type trait (!). Also, move template argument deduction into its own file and update a few build systems with this change (grrrr). llvm-svn: 72819
2009-06-04 08:03:07 +08:00
// The argument type can not be less qualified than the parameter
// type.
More cleanup of template argument deduction and its handling of non-CVR qualifiers. We can now properly match address-space--qualified references during template argument deduction. llvm-svn: 130365
2011-04-28 08:56:09 +08:00
if (!(TDF & TDF_IgnoreQualifiers) &&
hasInconsistentOrSupersetQualifiersOf(Param, Arg)) {
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index));
TDK_InconsistentQuals is really totally different from TDK_Inconsistent. Rename it to TDK_Underqualified to avoid this sort of confusion and give it its own diagnostic. llvm-svn: 110318
2010-08-05 17:05:08 +08:00
Info.FirstArg = TemplateArgument(Param);
Track source information for template arguments and template specialization types. Preserve it through template instantiation. Preserve it through PCH, although TSTs themselves aren't serializable, so that's pretty much meaningless. llvm-svn: 85500
2009-10-29 16:12:44 +08:00
Info.SecondArg = TemplateArgument(Arg);
TDK_InconsistentQuals is really totally different from TDK_Inconsistent. Rename it to TDK_Underqualified to avoid this sort of confusion and give it its own diagnostic. llvm-svn: 110318
2010-08-05 17:05:08 +08:00
return Sema::TDK_Underqualified;
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
}
When performing template argument deduction, ensure that multiple deductions of the same template parameter are equivalent. This allows us to implement the is_same type trait (!). Also, move template argument deduction into its own file and update a few build systems with this change (grrrr). llvm-svn: 72819
2009-06-04 08:03:07 +08:00
assert(TemplateTypeParm->getDepth() == 0 && "Can't deduce with depth > 0");
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
assert(Arg != S.Context.OverloadTy && "Unresolved overloaded function");
Refactor the representation of qualifiers to bring ExtQualType out of the Type hierarchy. Demote 'volatile' to extended-qualifier status. Audit our use of qualifiers and fix a few places that weren't dealing with qualifiers quite right; many more remain. llvm-svn: 82705
2009-09-25 03:53:00 +08:00
QualType DeducedType = Arg;
It's kindof silly that ExtQuals has an ASTContext&, and we can use that space better. Remove this reference. To make that work, change some APIs (most importantly, getDesugaredType()) to take an ASTContext& if they need to return a QualType. Simultaneously, diminish the need to return a QualType by introducing some useful APIs on SplitQualType, which is just a std::pair<const Type *, Qualifiers>. llvm-svn: 121478
2010-12-10 19:01:00 +08:00
More cleanup of template argument deduction and its handling of non-CVR qualifiers. We can now properly match address-space--qualified references during template argument deduction. llvm-svn: 130365
2011-04-28 08:56:09 +08:00
// Remove any qualifiers on the parameter from the deduced type.
// We checked the qualifiers for consistency above.
Qualifiers DeducedQs = DeducedType.getQualifiers();
Qualifiers ParamQs = Param.getQualifiers();
DeducedQs.removeCVRQualifiers(ParamQs.getCVRQualifiers());
if (ParamQs.hasObjCGCAttr())
DeducedQs.removeObjCGCAttr();
if (ParamQs.hasAddressSpace())
DeducedQs.removeAddressSpace();
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
if (ParamQs.hasObjCLifetime())
DeducedQs.removeObjCLifetime();
Objective-ARC++: infer template type arguments of ownership-unqualified retainable object type as __strong. This allows us to write, e.g., std::vector<id> and we'll infer that the vector's element types have __strong ownership semantics, which is far nicer than requiring: std::vector<__strong id> Note that we allow one to override the ownership qualifier of a substituted template type parameter, e.g., given template<typename T> struct X { typedef __weak T type; }; X<id> is treated the same as X<__strong id>. At instantiation type, the __weak in "__weak T" overrides the (inferred or specified) __strong on the template argument type, so that we can still provide metaprogramming transformations. This is part of <rdar://problem/9595486>. llvm-svn: 133303
2011-06-18 06:11:49 +08:00
Objective-C++ ARC: When performing template argument deduction for a lifetime-qualified template parameter, ensure that the deduced template argument is a lifetime type. Fixes <rdar://problem/9828157>. llvm-svn: 136078
2011-07-26 22:53:44 +08:00
// Objective-C ARC:
// If template deduction would produce a lifetime qualifier on a type
// that is not a lifetime type, template argument deduction fails.
if (ParamQs.hasObjCLifetime() && !DeducedType->isObjCLifetimeType() &&
!DeducedType->isDependentType()) {
Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index));
Info.FirstArg = TemplateArgument(Param);
Info.SecondArg = TemplateArgument(Arg);
return Sema::TDK_Underqualified;
}
Objective-ARC++: infer template type arguments of ownership-unqualified retainable object type as __strong. This allows us to write, e.g., std::vector<id> and we'll infer that the vector's element types have __strong ownership semantics, which is far nicer than requiring: std::vector<__strong id> Note that we allow one to override the ownership qualifier of a substituted template type parameter, e.g., given template<typename T> struct X { typedef __weak T type; }; X<id> is treated the same as X<__strong id>. At instantiation type, the __weak in "__weak T" overrides the (inferred or specified) __strong on the template argument type, so that we can still provide metaprogramming transformations. This is part of <rdar://problem/9595486>. llvm-svn: 133303
2011-06-18 06:11:49 +08:00
// Objective-C ARC:
// If template deduction would produce an argument type with lifetime type
// but no lifetime qualifier, the __strong lifetime qualifier is inferred.
Unify naming of LangOptions variable/get function across the Clang stack (Lex to AST). The member variable is always "LangOpts" and the member function is always "getLangOpts". Reviewed by Chris Lattner llvm-svn: 152536
2012-03-11 15:00:24 +08:00
if (S.getLangOpts().ObjCAutoRefCount &&
Objective-ARC++: infer template type arguments of ownership-unqualified retainable object type as __strong. This allows us to write, e.g., std::vector<id> and we'll infer that the vector's element types have __strong ownership semantics, which is far nicer than requiring: std::vector<__strong id> Note that we allow one to override the ownership qualifier of a substituted template type parameter, e.g., given template<typename T> struct X { typedef __weak T type; }; X<id> is treated the same as X<__strong id>. At instantiation type, the __weak in "__weak T" overrides the (inferred or specified) __strong on the template argument type, so that we can still provide metaprogramming transformations. This is part of <rdar://problem/9595486>. llvm-svn: 133303
2011-06-18 06:11:49 +08:00
DeducedType->isObjCLifetimeType() &&
!DeducedQs.hasObjCLifetime())
DeducedQs.setObjCLifetime(Qualifiers::OCL_Strong);
More cleanup of template argument deduction and its handling of non-CVR qualifiers. We can now properly match address-space--qualified references during template argument deduction. llvm-svn: 130365
2011-04-28 08:56:09 +08:00
DeducedType = S.Context.getQualifiedType(DeducedType.getUnqualifiedType(),
DeducedQs);
Fix the problems with template argument deduction and array types for real. It turns out that we need to actually move all of the qualifiers up to the array type itself, then recanonicalize the deduced template argument type. llvm-svn: 76788
2009-07-23 05:30:48 +08:00
if (RecanonicalizeArg)
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
DeducedType = S.Context.getCanonicalType(DeducedType);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
DeducedTemplateArgument NewDeduced(DeducedType);
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
Deduced[Index],
NewDeduced);
if (Result.isNull()) {
Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index));
Info.FirstArg = Deduced[Index];
Info.SecondArg = NewDeduced;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
return Sema::TDK_Inconsistent;
When performing template argument deduction, ensure that multiple deductions of the same template parameter are equivalent. This allows us to implement the is_same type trait (!). Also, move template argument deduction into its own file and update a few build systems with this change (grrrr). llvm-svn: 72819
2009-06-04 08:03:07 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Unify the consistency checking for deduced template arguments into a single routine. Extend that routine to handle consistency checking for template argument packs, so that we can compare the deduced packs for template parameter packs across different pack expansions. llvm-svn: 122452
2010-12-23 07:09:49 +08:00
Deduced[Index] = Result;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
return Sema::TDK_Success;
When performing template argument deduction, ensure that multiple deductions of the same template parameter are equivalent. This allows us to implement the is_same type trait (!). Also, move template argument deduction into its own file and update a few build systems with this change (grrrr). llvm-svn: 72819
2009-06-04 08:03:07 +08:00
}
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
// Set up the template argument deduction information for a failure.
Track source information for template arguments and template specialization types. Preserve it through template instantiation. Preserve it through PCH, although TSTs themselves aren't serializable, so that's pretty much meaningless. llvm-svn: 85500
2009-10-29 16:12:44 +08:00
Info.FirstArg = TemplateArgument(ParamIn);
Info.SecondArg = TemplateArgument(ArgIn);
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
Fix a few warnings stemming from my inability to properly fill out switch() statements. llvm-svn: 123429
2011-01-14 13:11:40 +08:00
// If the parameter is an already-substituted template parameter
// pack, do nothing: we don't know which of its arguments to look
// at, so we have to wait until all of the parameter packs in this
// expansion have arguments.
if (isa<SubstTemplateTypeParmPackType>(Param))
return Sema::TDK_Success;
During template argument deduction from a function call, allow deduction from pointer and pointer-to-member types to work even in the presence of a qualification conversion (C++ [temp.deduct.type]p3 bullet 2). llvm-svn: 74354
2009-06-27 07:10:12 +08:00
// Check the cv-qualifiers on the parameter and argument types.
Fix PR15291: noreturn adjustment in overload resolution for function templates, from Alexander Zinenko! llvm-svn: 179680
2013-04-17 16:45:07 +08:00
CanQualType CanParam = S.Context.getCanonicalType(Param);
CanQualType CanArg = S.Context.getCanonicalType(Arg);
During template argument deduction from a function call, allow deduction from pointer and pointer-to-member types to work even in the presence of a qualification conversion (C++ [temp.deduct.type]p3 bullet 2). llvm-svn: 74354
2009-06-27 07:10:12 +08:00
if (!(TDF & TDF_IgnoreQualifiers)) {
if (TDF & TDF_ParamWithReferenceType) {
More cleanup of template argument deduction and its handling of non-CVR qualifiers. We can now properly match address-space--qualified references during template argument deduction. llvm-svn: 130365
2011-04-28 08:56:09 +08:00
if (hasInconsistentOrSupersetQualifiersOf(Param, Arg))
During template argument deduction from a function call, allow deduction from pointer and pointer-to-member types to work even in the presence of a qualification conversion (C++ [temp.deduct.type]p3 bullet 2). llvm-svn: 74354
2009-06-27 07:10:12 +08:00
return Sema::TDK_NonDeducedMismatch;
When perform exact-qualifier-match template argument deduction, properly account for the possibility that certain opaque types might be more qualified than they appear. Fixes PR7708. llvm-svn: 112390
2010-08-29 06:14:41 +08:00
} else if (!IsPossiblyOpaquelyQualifiedType(Param)) {
During template argument deduction from a function call, allow deduction from pointer and pointer-to-member types to work even in the presence of a qualification conversion (C++ [temp.deduct.type]p3 bullet 2). llvm-svn: 74354
2009-06-27 07:10:12 +08:00
if (Param.getCVRQualifiers() != Arg.getCVRQualifiers())
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
return Sema::TDK_NonDeducedMismatch;
During template argument deduction from a function call, allow deduction from pointer and pointer-to-member types to work even in the presence of a qualification conversion (C++ [temp.deduct.type]p3 bullet 2). llvm-svn: 74354
2009-06-27 07:10:12 +08:00
}
When template argument deduction is ignoring qualifiers, perform deep structural comparison of non-dependent types. Otherwise, we end up rejecting cases where the non-dependent types don't match due to qualifiers in, e.g., a pointee type. Fixes PR12132. llvm-svn: 152529
2012-03-11 11:29:50 +08:00
// If the parameter type is not dependent, there is nothing to deduce.
if (!Param->isDependentType()) {
Fix PR15291: noreturn adjustment in overload resolution for function templates, from Alexander Zinenko! llvm-svn: 179680
2013-04-17 16:45:07 +08:00
if (!(TDF & TDF_SkipNonDependent)) {
bool NonDeduced = (TDF & TDF_InOverloadResolution)?
!S.isSameOrCompatibleFunctionType(CanParam, CanArg) :
Param != Arg;
if (NonDeduced) {
return Sema::TDK_NonDeducedMismatch;
}
}
When template argument deduction is ignoring qualifiers, perform deep structural comparison of non-dependent types. Otherwise, we end up rejecting cases where the non-dependent types don't match due to qualifiers in, e.g., a pointee type. Fixes PR12132. llvm-svn: 152529
2012-03-11 11:29:50 +08:00
return Sema::TDK_Success;
}
Fix PR15291: noreturn adjustment in overload resolution for function templates, from Alexander Zinenko! llvm-svn: 179680
2013-04-17 16:45:07 +08:00
} else if (!Param->isDependentType()) {
CanQualType ParamUnqualType = CanParam.getUnqualifiedType(),
ArgUnqualType = CanArg.getUnqualifiedType();
bool Success = (TDF & TDF_InOverloadResolution)?
S.isSameOrCompatibleFunctionType(ParamUnqualType,
ArgUnqualType) :
ParamUnqualType == ArgUnqualType;
if (Success)
return Sema::TDK_Success;
During template argument deduction from a function call, allow deduction from pointer and pointer-to-member types to work even in the presence of a qualification conversion (C++ [temp.deduct.type]p3 bullet 2). llvm-svn: 74354
2009-06-27 07:10:12 +08:00
}
When performing template argument deduction, ensure that multiple deductions of the same template parameter are equivalent. This allows us to implement the is_same type trait (!). Also, move template argument deduction into its own file and update a few build systems with this change (grrrr). llvm-svn: 72819
2009-06-04 08:03:07 +08:00
Template argument deduction for references llvm-svn: 72822
2009-06-04 08:21:18 +08:00
switch (Param->getTypeClass()) {
Eliminate a 'default' case in template argument deduction, where we were just punting on template argument deduction for a number of type nodes. Most of them, obviously, didn't matter. As a consequence of this, make extended vector types (via the ext_vector_type attribute) actually work properly for several important cases: - If the attribute appears in a type-id (i.e, not attached to a typedef), actually build a proper vector type - Build ExtVectorType whenever the size is constant; previously, we were building DependentSizedExtVectorType when the size was constant but the type was dependent, which makes no sense at all. - Teach template argument deduction to handle ExtVectorType/DependentSizedExtVectorType. llvm-svn: 133060
2011-06-16 00:02:29 +08:00
// Non-canonical types cannot appear here.
#define NON_CANONICAL_TYPE(Class, Base) \
case Type::Class: llvm_unreachable("deducing non-canonical type: " #Class);
#define TYPE(Class, Base)
#include "clang/AST/TypeNodes.def"
case Type::TemplateTypeParm:
case Type::SubstTemplateTypeParmPack:
llvm_unreachable("Type nodes handled above");
When template argument deduction is ignoring qualifiers, perform deep structural comparison of non-dependent types. Otherwise, we end up rejecting cases where the non-dependent types don't match due to qualifiers in, e.g., a pointee type. Fixes PR12132. llvm-svn: 152529
2012-03-11 11:29:50 +08:00
// These types cannot be dependent, so simply check whether the types are
// the same.
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
case Type::Builtin:
Eliminate a 'default' case in template argument deduction, where we were just punting on template argument deduction for a number of type nodes. Most of them, obviously, didn't matter. As a consequence of this, make extended vector types (via the ext_vector_type attribute) actually work properly for several important cases: - If the attribute appears in a type-id (i.e, not attached to a typedef), actually build a proper vector type - Build ExtVectorType whenever the size is constant; previously, we were building DependentSizedExtVectorType when the size was constant but the type was dependent, which makes no sense at all. - Teach template argument deduction to handle ExtVectorType/DependentSizedExtVectorType. llvm-svn: 133060
2011-06-16 00:02:29 +08:00
case Type::VariableArray:
case Type::Vector:
case Type::FunctionNoProto:
case Type::Record:
case Type::Enum:
case Type::ObjCObject:
case Type::ObjCInterface:
When template argument deduction is ignoring qualifiers, perform deep structural comparison of non-dependent types. Otherwise, we end up rejecting cases where the non-dependent types don't match due to qualifiers in, e.g., a pointee type. Fixes PR12132. llvm-svn: 152529
2012-03-11 11:29:50 +08:00
case Type::ObjCObjectPointer: {
if (TDF & TDF_SkipNonDependent)
return Sema::TDK_Success;
if (TDF & TDF_IgnoreQualifiers) {
Param = Param.getUnqualifiedType();
Arg = Arg.getUnqualifiedType();
}
return Param == Arg? Sema::TDK_Success : Sema::TDK_NonDeducedMismatch;
}
Eliminate a 'default' case in template argument deduction, where we were just punting on template argument deduction for a number of type nodes. Most of them, obviously, didn't matter. As a consequence of this, make extended vector types (via the ext_vector_type attribute) actually work properly for several important cases: - If the attribute appears in a type-id (i.e, not attached to a typedef), actually build a proper vector type - Build ExtVectorType whenever the size is constant; previously, we were building DependentSizedExtVectorType when the size was constant but the type was dependent, which makes no sense at all. - Teach template argument deduction to handle ExtVectorType/DependentSizedExtVectorType. llvm-svn: 133060
2011-06-16 00:02:29 +08:00
// _Complex T [placeholder extension]
case Type::Complex:
if (const ComplexType *ComplexArg = Arg->getAs<ComplexType>())
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
Eliminate a 'default' case in template argument deduction, where we were just punting on template argument deduction for a number of type nodes. Most of them, obviously, didn't matter. As a consequence of this, make extended vector types (via the ext_vector_type attribute) actually work properly for several important cases: - If the attribute appears in a type-id (i.e, not attached to a typedef), actually build a proper vector type - Build ExtVectorType whenever the size is constant; previously, we were building DependentSizedExtVectorType when the size was constant but the type was dependent, which makes no sense at all. - Teach template argument deduction to handle ExtVectorType/DependentSizedExtVectorType. llvm-svn: 133060
2011-06-16 00:02:29 +08:00
cast<ComplexType>(Param)->getElementType(),
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
ComplexArg->getElementType(),
Info, Deduced, TDF);
Eliminate a 'default' case in template argument deduction, where we were just punting on template argument deduction for a number of type nodes. Most of them, obviously, didn't matter. As a consequence of this, make extended vector types (via the ext_vector_type attribute) actually work properly for several important cases: - If the attribute appears in a type-id (i.e, not attached to a typedef), actually build a proper vector type - Build ExtVectorType whenever the size is constant; previously, we were building DependentSizedExtVectorType when the size was constant but the type was dependent, which makes no sense at all. - Teach template argument deduction to handle ExtVectorType/DependentSizedExtVectorType. llvm-svn: 133060
2011-06-16 00:02:29 +08:00
return Sema::TDK_NonDeducedMismatch;
Support for C1x _Atomic specifier (see testcase). This is primarily being committed at the moment to help support C++0x <atomic>, but it should be a solid base for implementing the full specification of C1x _Atomic. Thanks to Jeffrey Yasskin for the thorough review! llvm-svn: 141330
2011-10-07 07:00:33 +08:00
// _Atomic T [extension]
case Type::Atomic:
if (const AtomicType *AtomicArg = Arg->getAs<AtomicType>())
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
Support for C1x _Atomic specifier (see testcase). This is primarily being committed at the moment to help support C++0x <atomic>, but it should be a solid base for implementing the full specification of C1x _Atomic. Thanks to Jeffrey Yasskin for the thorough review! llvm-svn: 141330
2011-10-07 07:00:33 +08:00
cast<AtomicType>(Param)->getValueType(),
AtomicArg->getValueType(),
Info, Deduced, TDF);
return Sema::TDK_NonDeducedMismatch;
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
// T *
Template argument deduction for references llvm-svn: 72822
2009-06-04 08:21:18 +08:00
case Type::Pointer: {
When performing template argument deduction, match Objective C pointers against pointer patterns. llvm-svn: 103706
2010-05-13 15:48:05 +08:00
QualType PointeeType;
if (const PointerType *PointerArg = Arg->getAs<PointerType>()) {
PointeeType = PointerArg->getPointeeType();
} else if (const ObjCObjectPointerType *PointerArg
= Arg->getAs<ObjCObjectPointerType>()) {
PointeeType = PointerArg->getPointeeType();
} else {
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
return Sema::TDK_NonDeducedMismatch;
When performing template argument deduction, match Objective C pointers against pointer patterns. llvm-svn: 103706
2010-05-13 15:48:05 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Set the rest of the flags we need to perform template argument deduction using a base class of the argument type. No actual functionality change; this is just a hook. llvm-svn: 74356
2009-06-27 07:27:24 +08:00
unsigned SubTDF = TDF & (TDF_IgnoreQualifiers | TDF_DerivedClass);
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
cast<PointerType>(Param)->getPointeeType(),
When performing template argument deduction, match Objective C pointers against pointer patterns. llvm-svn: 103706
2010-05-13 15:48:05 +08:00
PointeeType,
Set the rest of the flags we need to perform template argument deduction using a base class of the argument type. No actual functionality change; this is just a hook. llvm-svn: 74356
2009-06-27 07:27:24 +08:00
Info, Deduced, SubTDF);
Template argument deduction for references llvm-svn: 72822
2009-06-04 08:21:18 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
// T &
Template argument deduction for references llvm-svn: 72822
2009-06-04 08:21:18 +08:00
case Type::LValueReference: {
Change uses of: Type::getAsReferenceType() -> Type::getAs<ReferenceType>() Type::getAsRecordType() -> Type::getAs<RecordType>() Type::getAsPointerType() -> Type::getAs<PointerType>() Type::getAsBlockPointerType() -> Type::getAs<BlockPointerType>() Type::getAsLValueReferenceType() -> Type::getAs<LValueReferenceType>() Type::getAsRValueReferenceType() -> Type::getAs<RValueReferenceType>() Type::getAsMemberPointerType() -> Type::getAs<MemberPointerType>() Type::getAsReferenceType() -> Type::getAs<ReferenceType>() Type::getAsTagType() -> Type::getAs<TagType>() And remove Type::getAsReferenceType(), etc. This change is similar to one I made a couple weeks ago, but that was partly reverted pending some additional design discussion. With Doug's pending smart pointer changes for Types, it seemed natural to take this approach. llvm-svn: 77510
2009-07-30 05:53:49 +08:00
const LValueReferenceType *ReferenceArg = Arg->getAs<LValueReferenceType>();
Template argument deduction for references llvm-svn: 72822
2009-06-04 08:21:18 +08:00
if (!ReferenceArg)
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
return Sema::TDK_NonDeducedMismatch;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
Template argument deduction for references llvm-svn: 72822
2009-06-04 08:21:18 +08:00
cast<LValueReferenceType>(Param)->getPointeeType(),
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
ReferenceArg->getPointeeType(), Info, Deduced, 0);
Template argument deduction for references llvm-svn: 72822
2009-06-04 08:21:18 +08:00
}
When performing template argument deduction, ensure that multiple deductions of the same template parameter are equivalent. This allows us to implement the is_same type trait (!). Also, move template argument deduction into its own file and update a few build systems with this change (grrrr). llvm-svn: 72819
2009-06-04 08:03:07 +08:00
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
// T && [C++0x]
Template argument deduction for references llvm-svn: 72822
2009-06-04 08:21:18 +08:00
case Type::RValueReference: {
Change uses of: Type::getAsReferenceType() -> Type::getAs<ReferenceType>() Type::getAsRecordType() -> Type::getAs<RecordType>() Type::getAsPointerType() -> Type::getAs<PointerType>() Type::getAsBlockPointerType() -> Type::getAs<BlockPointerType>() Type::getAsLValueReferenceType() -> Type::getAs<LValueReferenceType>() Type::getAsRValueReferenceType() -> Type::getAs<RValueReferenceType>() Type::getAsMemberPointerType() -> Type::getAs<MemberPointerType>() Type::getAsReferenceType() -> Type::getAs<ReferenceType>() Type::getAsTagType() -> Type::getAs<TagType>() And remove Type::getAsReferenceType(), etc. This change is similar to one I made a couple weeks ago, but that was partly reverted pending some additional design discussion. With Doug's pending smart pointer changes for Types, it seemed natural to take this approach. llvm-svn: 77510
2009-07-30 05:53:49 +08:00
const RValueReferenceType *ReferenceArg = Arg->getAs<RValueReferenceType>();
Template argument deduction for references llvm-svn: 72822
2009-06-04 08:21:18 +08:00
if (!ReferenceArg)
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
return Sema::TDK_NonDeducedMismatch;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
cast<RValueReferenceType>(Param)->getPointeeType(),
ReferenceArg->getPointeeType(),
Info, Deduced, 0);
Template argument deduction for references llvm-svn: 72822
2009-06-04 08:21:18 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
// T [] (implied, but not stated explicitly)
Template argument deduction for incomplete and constant array types. Doug, please review. llvm-svn: 72844
2009-06-04 12:11:30 +08:00
case Type::IncompleteArray: {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
const IncompleteArrayType *IncompleteArrayArg =
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
S.Context.getAsIncompleteArrayType(Arg);
Template argument deduction for incomplete and constant array types. Doug, please review. llvm-svn: 72844
2009-06-04 12:11:30 +08:00
if (!IncompleteArrayArg)
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
return Sema::TDK_NonDeducedMismatch;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
When deducing the element type of an array, ignore qualifiers if the context allows us to ignore qualifiers on the array type itself. llvm-svn: 111486
2010-08-19 08:20:19 +08:00
unsigned SubTDF = TDF & TDF_IgnoreQualifiers;
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
S.Context.getAsIncompleteArrayType(Param)->getElementType(),
IncompleteArrayArg->getElementType(),
Info, Deduced, SubTDF);
Template argument deduction for incomplete and constant array types. Doug, please review. llvm-svn: 72844
2009-06-04 12:11:30 +08:00
}
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
// T [integer-constant]
Template argument deduction for incomplete and constant array types. Doug, please review. llvm-svn: 72844
2009-06-04 12:11:30 +08:00
case Type::ConstantArray: {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
const ConstantArrayType *ConstantArrayArg =
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
S.Context.getAsConstantArrayType(Arg);
Template argument deduction for incomplete and constant array types. Doug, please review. llvm-svn: 72844
2009-06-04 12:11:30 +08:00
if (!ConstantArrayArg)
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
return Sema::TDK_NonDeducedMismatch;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
const ConstantArrayType *ConstantArrayParm =
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
S.Context.getAsConstantArrayType(Param);
Template argument deduction for incomplete and constant array types. Doug, please review. llvm-svn: 72844
2009-06-04 12:11:30 +08:00
if (ConstantArrayArg->getSize() != ConstantArrayParm->getSize())
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
return Sema::TDK_NonDeducedMismatch;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
When deducing the element type of an array, ignore qualifiers if the context allows us to ignore qualifiers on the array type itself. llvm-svn: 111486
2010-08-19 08:20:19 +08:00
unsigned SubTDF = TDF & TDF_IgnoreQualifiers;
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
ConstantArrayParm->getElementType(),
ConstantArrayArg->getElementType(),
Info, Deduced, SubTDF);
Template argument deduction for incomplete and constant array types. Doug, please review. llvm-svn: 72844
2009-06-04 12:11:30 +08:00
}
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
// type [i]
case Type::DependentSizedArray: {
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
const ArrayType *ArrayArg = S.Context.getAsArrayType(Arg);
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
if (!ArrayArg)
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
return Sema::TDK_NonDeducedMismatch;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
When deducing the element type of an array, ignore qualifiers if the context allows us to ignore qualifiers on the array type itself. llvm-svn: 111486
2010-08-19 08:20:19 +08:00
unsigned SubTDF = TDF & TDF_IgnoreQualifiers;
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
// Check the element type of the arrays
const DependentSizedArrayType *DependentArrayParm
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
= S.Context.getAsDependentSizedArrayType(Param);
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
if (Sema::TemplateDeductionResult Result
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
= DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
DependentArrayParm->getElementType(),
ArrayArg->getElementType(),
Info, Deduced, SubTDF))
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
return Result;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
// Determine the array bound is something we can deduce.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
NonTypeTemplateParmDecl *NTTP
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
= getDeducedParameterFromExpr(DependentArrayParm->getSizeExpr());
if (!NTTP)
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
return Sema::TDK_Success;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
// We can perform template argument deduction for the given non-type
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
// template parameter.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
assert(NTTP->getDepth() == 0 &&
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
"Cannot deduce non-type template argument at depth > 0");
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
if (const ConstantArrayType *ConstantArrayArg
Make DeduceNonTypeTemplateArgument take an APSInt instead of an APInt. llvm-svn: 73574
2009-06-17 06:44:31 +08:00
= dyn_cast<ConstantArrayType>(ArrayArg)) {
llvm::APSInt Size(ConstantArrayArg->getSize());
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
return DeduceNonTypeTemplateArgument(S, NTTP, Size,
When deducing an integral template argument for a non-type template parameter, keep the integral value exactly as it was in the source code rather than trying to convert it to the type of the non-type template parameter (which may still be dependent!). The value will then be converted to the appropriate type once we check the resulting template arguments. Fixes PR6707. llvm-svn: 99611
2010-03-26 13:50:28 +08:00
S.Context.getSizeType(),
After performing template argument deduction for a function template, check deduced non-type template arguments and template template arguments against the template parameters for which they were deduced, performing conversions as appropriate so that deduced template arguments get the same treatment as explicitly-specified template arguments. This is the bulk of PR6723. Also keep track of whether deduction of a non-type template argument came from an array bound (vs. anywhere else). With this information, we enforce C++ [temp.deduct.type]p17, which requires exact type matches when deduction deduces a non-type template argument from something that is not an array bound. Finally, when in a SFINAE context, translate the "zero sized arrays are an extension" extension diagnostic into a hard error (for better standard conformance), which was a minor part of PR6723. llvm-svn: 99734
2010-03-28 10:42:43 +08:00
/*ArrayBound=*/true,
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
Info, Deduced);
Make DeduceNonTypeTemplateArgument take an APSInt instead of an APInt. llvm-svn: 73574
2009-06-17 06:44:31 +08:00
}
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
if (const DependentSizedArrayType *DependentArrayArg
= dyn_cast<DependentSizedArrayType>(ArrayArg))
Be paranoid about NULL size expressions in dependently-sized array types llvm-svn: 122454
2010-12-23 07:15:38 +08:00
if (DependentArrayArg->getSizeExpr())
return DeduceNonTypeTemplateArgument(S, NTTP,
DependentArrayArg->getSizeExpr(),
Info, Deduced);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
// Incomplete type does not match a dependently-sized array type
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
return Sema::TDK_NonDeducedMismatch;
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
// type(*)(T)
// T(*)()
// T(*)(T)
Template argument deduction for function types. llvm-svn: 73070
2009-06-08 23:19:08 +08:00
case Type::FunctionProto: {
Implement the rvalue-reference deduction transformation (from T&& -> T) when taking the address of an overloaded function or matching a specialization to a template (C++0x [temp.deduct.type]p10). Fixes PR9044. llvm-svn: 124197
2011-01-26 01:19:08 +08:00
unsigned SubTDF = TDF & TDF_TopLevelParameterTypeList;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
const FunctionProtoType *FunctionProtoArg =
Template argument deduction for function types. llvm-svn: 73070
2009-06-08 23:19:08 +08:00
dyn_cast<FunctionProtoType>(Arg);
if (!FunctionProtoArg)
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
return Sema::TDK_NonDeducedMismatch;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
const FunctionProtoType *FunctionProtoParam =
Template argument deduction for function types. llvm-svn: 73070
2009-06-08 23:19:08 +08:00
cast<FunctionProtoType>(Param);
Address comments from Doug. llvm-svn: 73077
2009-06-09 03:22:23 +08:00
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
if (FunctionProtoParam->getTypeQuals()
Rvalue references for *this: tentative parsing and template argument deduction. llvm-svn: 124295
2011-01-27 00:50:54 +08:00
!= FunctionProtoArg->getTypeQuals() ||
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
FunctionProtoParam->getRefQualifier()
Rvalue references for *this: tentative parsing and template argument deduction. llvm-svn: 124295
2011-01-27 00:50:54 +08:00
!= FunctionProtoArg->getRefQualifier() ||
FunctionProtoParam->isVariadic() != FunctionProtoArg->isVariadic())
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
return Sema::TDK_NonDeducedMismatch;
Address comments from Doug. llvm-svn: 73077
2009-06-09 03:22:23 +08:00
Template argument deduction for function types. llvm-svn: 73070
2009-06-08 23:19:08 +08:00
// Check return types.
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
if (Sema::TemplateDeductionResult Result
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
= DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
FunctionProtoParam->getResultType(),
FunctionProtoArg->getResultType(),
Info, Deduced, 0))
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
return Result;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Initial implementation of function parameter packs. This implementation allows: 1) Declaration of function parameter packs 2) Instantiation of function parameter packs within function types. 3) Template argument deduction of function parameter packs when matching two function types. We're missing all of the important template-instantiation logic for function template definitions, along with template argument deduction from the argument list of a function call, so don't even think of trying to use these for real yet. llvm-svn: 122926
2011-01-06 07:12:31 +08:00
return DeduceTemplateArguments(S, TemplateParams,
FunctionProtoParam->arg_type_begin(),
FunctionProtoParam->getNumArgs(),
FunctionProtoArg->arg_type_begin(),
FunctionProtoArg->getNumArgs(),
Implement the rvalue-reference deduction transformation (from T&& -> T) when taking the address of an overloaded function or matching a specialization to a template (C++0x [temp.deduct.type]p10). Fixes PR9044. llvm-svn: 124197
2011-01-26 01:19:08 +08:00
Info, Deduced, SubTDF);
Template argument deduction for function types. llvm-svn: 73070
2009-06-08 23:19:08 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Create a new InjectedClassNameType to represent bare-word references to the injected class name of a class template or class template partial specialization. This is a non-canonical type; the canonical type is still a template specialization type. This becomes the TypeForDecl of the pattern declaration, which cleans up some amount of code (and complicates some other parts, but whatever). Fixes PR6326 and probably a few others, primarily by re-establishing a few invariants about TypeLoc sizes. llvm-svn: 98134
2010-03-10 11:28:59 +08:00
case Type::InjectedClassName: {
// Treat a template's injected-class-name as if the template
// specialization type had been used.
Make the InjectedClassNameType the canonical type of the current instantiation of a class template or class template partial specialization. That is to say, in template <class T> class A { ... }; or template <class T> class B<const T*> { ... }; make 'A<T>' and 'B<const T*>' sugar for the corresponding InjectedClassNameType when written inside the appropriate context. This allows us to track the current instantiation appropriately even inside AST routines. It also allows us to compute a DeclContext for a type much more efficiently, at some extra cost every time we write a template specialization (which can be optimized, but I've left it simple in this patch). llvm-svn: 102407
2010-04-27 08:57:59 +08:00
Param = cast<InjectedClassNameType>(Param)
->getInjectedSpecializationType();
Create a new InjectedClassNameType to represent bare-word references to the injected class name of a class template or class template partial specialization. This is a non-canonical type; the canonical type is still a template specialization type. This becomes the TypeForDecl of the pattern declaration, which cleans up some amount of code (and complicates some other parts, but whatever). Fixes PR6326 and probably a few others, primarily by re-establishing a few invariants about TypeLoc sizes. llvm-svn: 98134
2010-03-10 11:28:59 +08:00
assert(isa<TemplateSpecializationType>(Param) &&
"injected class name is not a template specialization type");
// fall through
}
Template argument deduction is no longer responsible for checking non-dependent parameter types. Instead, class template partial specializations perform a final check of all of the instantiated arguments. This model is cleaner, and works better for function templates where the "final check" occurs during overload resolution. Also, cope with cv-qualifiers when the parameter type was originally a reference type, so that the deduced argument can be more qualified than the transformed argument. llvm-svn: 74323
2009-06-27 04:57:09 +08:00
// template-name<T> (where template-name refers to a class template)
Implement template argument deduction for class template specialization types. As the example shows, we can now compute the length of a type-list using a template metaprogram and class template partial specialization. llvm-svn: 73136
2009-06-10 00:35:58 +08:00
// template-name<i>
Template argument deduction for template template parameters. This permits, among other things, ripping apart and reconstructing templates via partial specialization: template<typename T> struct DeepRemoveConst { typedef T type; }; template<typename T> struct DeepRemoveConst<const T> { typedef typename DeepRemoveConst<T>::type type; }; template<template<typename> class TT, typename T> struct DeepRemoveConst<TT<T> > { typedef TT<typename DeepRemoveConst<T>::type> type; }; Also, fix a longstanding thinko in the code handling partial ordering of class template partial specializations. We were performing the second deduction without clearing out the results of the first deduction. It's amazing we got through so much code with such a horrendous error :( llvm-svn: 86893
2009-11-12 07:06:43 +08:00
// TT<T>
// TT<i>
// TT<>
Implement template argument deduction for class template specialization types. As the example shows, we can now compute the length of a type-list using a template metaprogram and class template partial specialization. llvm-svn: 73136
2009-06-10 00:35:58 +08:00
case Type::TemplateSpecialization: {
const TemplateSpecializationType *SpecParam
= cast<TemplateSpecializationType>(Param);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
// Try to deduce template arguments from the template-id.
Sema::TemplateDeductionResult Result
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
= DeduceTemplateArguments(S, TemplateParams, SpecParam, Arg,
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
Info, Deduced);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Improve template argument deduction in the case where the parameter type is a template-id (e.g., basic_ostream<CharT, Traits>) and the argument type is a class that has a derived class matching the parameter type. Previously, we were giving up on template argument deduction too early. llvm-svn: 83177
2009-10-01 06:13:51 +08:00
if (Result && (TDF & TDF_DerivedClass)) {
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
// C++ [temp.deduct.call]p3b3:
// If P is a class, and P has the form template-id, then A can be a
// derived class of the deduced A. Likewise, if P is a pointer to a
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
// class of the form template-id, A can be a pointer to a derived
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
// class pointed to by the deduced A.
//
// More importantly:
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
// These alternatives are considered only if type deduction would
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
// otherwise fail.
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
if (const RecordType *RecordT = Arg->getAs<RecordType>()) {
// We cannot inspect base classes as part of deduction when the type
// is incomplete, so either instantiate any templates necessary to
// complete the type, or skip over it if it cannot be completed.
Thread a source location into the template-argument deduction routines. There may be some other places that could take advantage of this new information, but I haven't really looked yet. llvm-svn: 95600
2010-02-09 07:07:23 +08:00
if (S.RequireCompleteType(Info.getLocation(), Arg, 0))
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
return Result;
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
// Use data recursion to crawl through the list of base classes.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
// Visited contains the set of nodes we have already visited, while
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
// ToVisit is our stack of records that we still need to visit.
llvm::SmallPtrSet<const RecordType *, 8> Visited;
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<const RecordType *, 8> ToVisit;
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
ToVisit.push_back(RecordT);
bool Successful = false;
Replace a dubious use of SmallVectorImpl with a proper copy. llvm-svn: 148549
2012-01-21 00:39:18 +08:00
SmallVector<DeducedTemplateArgument, 8> DeducedOrig(Deduced.begin(),
Deduced.end());
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
while (!ToVisit.empty()) {
// Retrieve the next class in the inheritance hierarchy.
const RecordType *NextT = ToVisit.back();
ToVisit.pop_back();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
// If we have already seen this type, skip it.
if (!Visited.insert(NextT))
continue;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
// If this is a base class, try to perform template argument
// deduction from it.
if (NextT != RecordT) {
When template deduction fails on a derived class, try a template deduction on the base class. If the base class deduction succeeds, use those results. If it fails, keep using the results from the derived class template deduction. This prevents an assertion later where the type of deduction failure doesn't match up with the template deduction info. llvm-svn: 167550
2012-11-08 05:17:13 +08:00
TemplateDeductionInfo BaseInfo(Info.getLocation());
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
Sema::TemplateDeductionResult BaseResult
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
= DeduceTemplateArguments(S, TemplateParams, SpecParam,
When template deduction fails on a derived class, try a template deduction on the base class. If the base class deduction succeeds, use those results. If it fails, keep using the results from the derived class template deduction. This prevents an assertion later where the type of deduction failure doesn't match up with the template deduction info. llvm-svn: 167550
2012-11-08 05:17:13 +08:00
QualType(NextT, 0), BaseInfo,
Deduced);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
// If template argument deduction for this base was successful,
When performing template argument deduction against a template-id, only keep deduction results for successful deductions, so that they can be compared against each other. Fixes PR8462, from Richard Smith! llvm-svn: 117983
2010-11-02 08:02:34 +08:00
// note that we had some success. Otherwise, ignore any deductions
// from this base class.
if (BaseResult == Sema::TDK_Success) {
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
Successful = true;
Replace a dubious use of SmallVectorImpl with a proper copy. llvm-svn: 148549
2012-01-21 00:39:18 +08:00
DeducedOrig.clear();
DeducedOrig.append(Deduced.begin(), Deduced.end());
When template deduction fails on a derived class, try a template deduction on the base class. If the base class deduction succeeds, use those results. If it fails, keep using the results from the derived class template deduction. This prevents an assertion later where the type of deduction failure doesn't match up with the template deduction info. llvm-svn: 167550
2012-11-08 05:17:13 +08:00
Info.Param = BaseInfo.Param;
Info.FirstArg = BaseInfo.FirstArg;
Info.SecondArg = BaseInfo.SecondArg;
When performing template argument deduction against a template-id, only keep deduction results for successful deductions, so that they can be compared against each other. Fixes PR8462, from Richard Smith! llvm-svn: 117983
2010-11-02 08:02:34 +08:00
}
else
Deduced = DeducedOrig;
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
// Visit base classes
CXXRecordDecl *Next = cast<CXXRecordDecl>(NextT->getDecl());
for (CXXRecordDecl::base_class_iterator Base = Next->bases_begin(),
BaseEnd = Next->bases_end();
Audit the code for places where it is assumed that every base specifier refers to a RecordType. Add assertions or conditions as appropriate. This fixes another crash in the Apache stdlib vector. llvm-svn: 85055
2009-10-26 01:03:50 +08:00
Base != BaseEnd; ++Base) {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
assert(Base->getType()->isRecordType() &&
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
"Base class that isn't a record?");
Change uses of: Type::getAsReferenceType() -> Type::getAs<ReferenceType>() Type::getAsRecordType() -> Type::getAs<RecordType>() Type::getAsPointerType() -> Type::getAs<PointerType>() Type::getAsBlockPointerType() -> Type::getAs<BlockPointerType>() Type::getAsLValueReferenceType() -> Type::getAs<LValueReferenceType>() Type::getAsRValueReferenceType() -> Type::getAs<RValueReferenceType>() Type::getAsMemberPointerType() -> Type::getAs<MemberPointerType>() Type::getAsReferenceType() -> Type::getAs<ReferenceType>() Type::getAsTagType() -> Type::getAs<TagType>() And remove Type::getAsReferenceType(), etc. This change is similar to one I made a couple weeks ago, but that was partly reverted pending some additional design discussion. With Doug's pending smart pointer changes for Types, it seemed natural to take this approach. llvm-svn: 77510
2009-07-30 05:53:49 +08:00
ToVisit.push_back(Base->getType()->getAs<RecordType>());
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
}
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
if (Successful)
return Sema::TDK_Success;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Improve template argument deduction from a call. In particular, implement C++ [temp.deduct.call]p3b3, which allows a template-id parameter to match a derived class of the argument, while deducing template arguments. llvm-svn: 74965
2009-07-08 07:09:34 +08:00
return Result;
Implement template argument deduction for class template specialization types. As the example shows, we can now compute the length of a type-list using a template metaprogram and class template partial specialization. llvm-svn: 73136
2009-06-10 00:35:58 +08:00
}
Template argument deduction for member pointers. Also, introduced some of the framework for performing instantiation as part of template argument deduction. llvm-svn: 73175
2009-06-11 07:47:09 +08:00
// T type::*
// T T::*
// T (type::*)()
// type (T::*)()
// type (type::*)(T)
// type (T::*)(T)
// T (type::*)(T)
// T (T::*)()
// T (T::*)(T)
case Type::MemberPointer: {
const MemberPointerType *MemPtrParam = cast<MemberPointerType>(Param);
const MemberPointerType *MemPtrArg = dyn_cast<MemberPointerType>(Arg);
if (!MemPtrArg)
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
return Sema::TDK_NonDeducedMismatch;
if (Sema::TemplateDeductionResult Result
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
= DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
MemPtrParam->getPointeeType(),
MemPtrArg->getPointeeType(),
Info, Deduced,
TDF & TDF_IgnoreQualifiers))
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
return Result;
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
QualType(MemPtrParam->getClass(), 0),
QualType(MemPtrArg->getClass(), 0),
When template argument deduction is ignoring qualifiers, perform deep structural comparison of non-dependent types. Otherwise, we end up rejecting cases where the non-dependent types don't match due to qualifiers in, e.g., a pointee type. Fixes PR12132. llvm-svn: 152529
2012-03-11 11:29:50 +08:00
Info, Deduced,
TDF & TDF_IgnoreQualifiers);
Template argument deduction for member pointers. Also, introduced some of the framework for performing instantiation as part of template argument deduction. llvm-svn: 73175
2009-06-11 07:47:09 +08:00
}
Address comments from Doug - Add a Sema::SemaRef.BuildBlockPointerType and use it. llvm-svn: 73264
2009-06-13 06:56:54 +08:00
// (clang extension)
//
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
// type(^)(T)
// T(^)()
// T(^)(T)
Deducation and instantiation of block types. llvm-svn: 73232
2009-06-13 00:23:10 +08:00
case Type::BlockPointer: {
const BlockPointerType *BlockPtrParam = cast<BlockPointerType>(Param);
const BlockPointerType *BlockPtrArg = dyn_cast<BlockPointerType>(Arg);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Deducation and instantiation of block types. llvm-svn: 73232
2009-06-13 00:23:10 +08:00
if (!BlockPtrArg)
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
return Sema::TDK_NonDeducedMismatch;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
BlockPtrParam->getPointeeType(),
BlockPtrArg->getPointeeType(),
Info, Deduced, 0);
Deducation and instantiation of block types. llvm-svn: 73232
2009-06-13 00:23:10 +08:00
}
Eliminate a 'default' case in template argument deduction, where we were just punting on template argument deduction for a number of type nodes. Most of them, obviously, didn't matter. As a consequence of this, make extended vector types (via the ext_vector_type attribute) actually work properly for several important cases: - If the attribute appears in a type-id (i.e, not attached to a typedef), actually build a proper vector type - Build ExtVectorType whenever the size is constant; previously, we were building DependentSizedExtVectorType when the size was constant but the type was dependent, which makes no sense at all. - Teach template argument deduction to handle ExtVectorType/DependentSizedExtVectorType. llvm-svn: 133060
2011-06-16 00:02:29 +08:00
// (clang extension)
//
// T __attribute__(((ext_vector_type(<integral constant>))))
case Type::ExtVector: {
const ExtVectorType *VectorParam = cast<ExtVectorType>(Param);
if (const ExtVectorType *VectorArg = dyn_cast<ExtVectorType>(Arg)) {
// Make sure that the vectors have the same number of elements.
if (VectorParam->getNumElements() != VectorArg->getNumElements())
return Sema::TDK_NonDeducedMismatch;
// Perform deduction on the element types.
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
VectorParam->getElementType(),
VectorArg->getElementType(),
Info, Deduced, TDF);
Eliminate a 'default' case in template argument deduction, where we were just punting on template argument deduction for a number of type nodes. Most of them, obviously, didn't matter. As a consequence of this, make extended vector types (via the ext_vector_type attribute) actually work properly for several important cases: - If the attribute appears in a type-id (i.e, not attached to a typedef), actually build a proper vector type - Build ExtVectorType whenever the size is constant; previously, we were building DependentSizedExtVectorType when the size was constant but the type was dependent, which makes no sense at all. - Teach template argument deduction to handle ExtVectorType/DependentSizedExtVectorType. llvm-svn: 133060
2011-06-16 00:02:29 +08:00
}
if (const DependentSizedExtVectorType *VectorArg
= dyn_cast<DependentSizedExtVectorType>(Arg)) {
// We can't check the number of elements, since the argument has a
// dependent number of elements. This can only occur during partial
// ordering.
// Perform deduction on the element types.
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
VectorParam->getElementType(),
VectorArg->getElementType(),
Info, Deduced, TDF);
Eliminate a 'default' case in template argument deduction, where we were just punting on template argument deduction for a number of type nodes. Most of them, obviously, didn't matter. As a consequence of this, make extended vector types (via the ext_vector_type attribute) actually work properly for several important cases: - If the attribute appears in a type-id (i.e, not attached to a typedef), actually build a proper vector type - Build ExtVectorType whenever the size is constant; previously, we were building DependentSizedExtVectorType when the size was constant but the type was dependent, which makes no sense at all. - Teach template argument deduction to handle ExtVectorType/DependentSizedExtVectorType. llvm-svn: 133060
2011-06-16 00:02:29 +08:00
}
return Sema::TDK_NonDeducedMismatch;
}
// (clang extension)
//
// T __attribute__(((ext_vector_type(N))))
case Type::DependentSizedExtVector: {
const DependentSizedExtVectorType *VectorParam
= cast<DependentSizedExtVectorType>(Param);
if (const ExtVectorType *VectorArg = dyn_cast<ExtVectorType>(Arg)) {
// Perform deduction on the element types.
if (Sema::TemplateDeductionResult Result
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
= DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
VectorParam->getElementType(),
VectorArg->getElementType(),
Info, Deduced, TDF))
Eliminate a 'default' case in template argument deduction, where we were just punting on template argument deduction for a number of type nodes. Most of them, obviously, didn't matter. As a consequence of this, make extended vector types (via the ext_vector_type attribute) actually work properly for several important cases: - If the attribute appears in a type-id (i.e, not attached to a typedef), actually build a proper vector type - Build ExtVectorType whenever the size is constant; previously, we were building DependentSizedExtVectorType when the size was constant but the type was dependent, which makes no sense at all. - Teach template argument deduction to handle ExtVectorType/DependentSizedExtVectorType. llvm-svn: 133060
2011-06-16 00:02:29 +08:00
return Result;
// Perform deduction on the vector size, if we can.
NonTypeTemplateParmDecl *NTTP
= getDeducedParameterFromExpr(VectorParam->getSizeExpr());
if (!NTTP)
return Sema::TDK_Success;
llvm::APSInt ArgSize(S.Context.getTypeSize(S.Context.IntTy), false);
ArgSize = VectorArg->getNumElements();
return DeduceNonTypeTemplateArgument(S, NTTP, ArgSize, S.Context.IntTy,
false, Info, Deduced);
}
if (const DependentSizedExtVectorType *VectorArg
= dyn_cast<DependentSizedExtVectorType>(Arg)) {
// Perform deduction on the element types.
if (Sema::TemplateDeductionResult Result
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
= DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
VectorParam->getElementType(),
VectorArg->getElementType(),
Info, Deduced, TDF))
Eliminate a 'default' case in template argument deduction, where we were just punting on template argument deduction for a number of type nodes. Most of them, obviously, didn't matter. As a consequence of this, make extended vector types (via the ext_vector_type attribute) actually work properly for several important cases: - If the attribute appears in a type-id (i.e, not attached to a typedef), actually build a proper vector type - Build ExtVectorType whenever the size is constant; previously, we were building DependentSizedExtVectorType when the size was constant but the type was dependent, which makes no sense at all. - Teach template argument deduction to handle ExtVectorType/DependentSizedExtVectorType. llvm-svn: 133060
2011-06-16 00:02:29 +08:00
return Result;
// Perform deduction on the vector size, if we can.
NonTypeTemplateParmDecl *NTTP
= getDeducedParameterFromExpr(VectorParam->getSizeExpr());
if (!NTTP)
return Sema::TDK_Success;
return DeduceNonTypeTemplateArgument(S, NTTP, VectorArg->getSizeExpr(),
Info, Deduced);
}
return Sema::TDK_NonDeducedMismatch;
}
Template argument deduction for member pointers. Also, introduced some of the framework for performing instantiation as part of template argument deduction. llvm-svn: 73175
2009-06-11 07:47:09 +08:00
case Type::TypeOfExpr:
case Type::TypeOf:
Rename TypenameType to DependentNameType in anticipation of some refactoring work in this area. llvm-svn: 100019
2010-04-01 01:34:00 +08:00
case Type::DependentName:
Eliminate a 'default' case in template argument deduction, where we were just punting on template argument deduction for a number of type nodes. Most of them, obviously, didn't matter. As a consequence of this, make extended vector types (via the ext_vector_type attribute) actually work properly for several important cases: - If the attribute appears in a type-id (i.e, not attached to a typedef), actually build a proper vector type - Build ExtVectorType whenever the size is constant; previously, we were building DependentSizedExtVectorType when the size was constant but the type was dependent, which makes no sense at all. - Teach template argument deduction to handle ExtVectorType/DependentSizedExtVectorType. llvm-svn: 133060
2011-06-16 00:02:29 +08:00
case Type::UnresolvedUsing:
case Type::Decltype:
case Type::UnaryTransform:
case Type::Auto:
case Type::DependentTemplateSpecialization:
case Type::PackExpansion:
Template argument deduction for member pointers. Also, introduced some of the framework for performing instantiation as part of template argument deduction. llvm-svn: 73175
2009-06-11 07:47:09 +08:00
// No template argument deduction for these types
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
return Sema::TDK_Success;
When performing template argument deduction, ensure that multiple deductions of the same template parameter are equivalent. This allows us to implement the is_same type trait (!). Also, move template argument deduction into its own file and update a few build systems with this change (grrrr). llvm-svn: 72819
2009-06-04 08:03:07 +08:00
}
More dead code removal (using -Wunreachable-code) llvm-svn: 148577
2012-01-21 05:50:17 +08:00
llvm_unreachable("Invalid Type Class!");
When performing template argument deduction, ensure that multiple deductions of the same template parameter are equivalent. This allows us to implement the is_same type trait (!). Also, move template argument deduction into its own file and update a few build systems with this change (grrrr). llvm-svn: 72819
2009-06-04 08:03:07 +08:00
}
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
static Sema::TemplateDeductionResult
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
DeduceTemplateArguments(Sema &S,
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
TemplateParameterList *TemplateParams,
const TemplateArgument &Param,
Implement partial ordering of class template partial specializations and function templates that contain variadic templates. This involves three small-ish changes: (1) When transforming a pack expansion, if the transformed argument still contains unexpanded parameter packs, build a pack expansion. This can happen during the substitution that occurs into class template partial specialiation template arguments during partial ordering. (2) When performing template argument deduction where the argument is a pack expansion, match against the pattern of that pack expansion. (3) When performing template argument deduction against a non-pack parameter, or a non-expansion template argument, deduction fails if the argument itself is a pack expansion (C++0x [temp.deduct.type]p22). llvm-svn: 123279
2011-01-12 06:21:24 +08:00
TemplateArgument Arg,
Move more stuff out of Sema.h. llvm-svn: 112026
2010-08-25 13:32:35 +08:00
TemplateDeductionInfo &Info,
Function argument formatting fixes. llvm-svn: 185785
2013-07-08 12:13:06 +08:00
SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
Implement partial ordering of class template partial specializations and function templates that contain variadic templates. This involves three small-ish changes: (1) When transforming a pack expansion, if the transformed argument still contains unexpanded parameter packs, build a pack expansion. This can happen during the substitution that occurs into class template partial specialiation template arguments during partial ordering. (2) When performing template argument deduction where the argument is a pack expansion, match against the pattern of that pack expansion. (3) When performing template argument deduction against a non-pack parameter, or a non-expansion template argument, deduction fails if the argument itself is a pack expansion (C++0x [temp.deduct.type]p22). llvm-svn: 123279
2011-01-12 06:21:24 +08:00
// If the template argument is a pack expansion, perform template argument
// deduction against the pattern of that expansion. This only occurs during
// partial ordering.
if (Arg.isPackExpansion())
Arg = Arg.getPackExpansionPattern();
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
When performing template argument deduction, ensure that multiple deductions of the same template parameter are equivalent. This allows us to implement the is_same type trait (!). Also, move template argument deduction into its own file and update a few build systems with this change (grrrr). llvm-svn: 72819
2009-06-04 08:03:07 +08:00
switch (Param.getKind()) {
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
case TemplateArgument::Null:
Switch assert(0/false) llvm_unreachable. llvm-svn: 140367
2011-09-23 13:06:16 +08:00
llvm_unreachable("Null template argument in parameter list");
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
case TemplateArgument::Type:
Introduce a new representation for template template parameters. Rather than storing them as either declarations (for the non-dependent case) or expressions (for the dependent case), we now (always) store them as TemplateNames. The primary change here is to add a new kind of TemplateArgument, which stores a TemplateName. However, making that change ripples to every switch on a TemplateArgument's kind, also affecting TemplateArgumentLocInfo/TemplateArgumentLoc, default template arguments for template template parameters, type-checking of template template arguments, etc. This change is light on testing. It should fix several pre-existing problems with template template parameters, such as: - the inability to use dependent template names as template template arguments - template template parameter default arguments cannot be instantiation However, there are enough pieces missing that more implementation is required before we can adequately test template template parameters. llvm-svn: 86777
2009-11-11 09:00:40 +08:00
if (Arg.getKind() == TemplateArgument::Type)
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
Param.getAsType(),
Arg.getAsType(),
Info, Deduced, 0);
Introduce a new representation for template template parameters. Rather than storing them as either declarations (for the non-dependent case) or expressions (for the dependent case), we now (always) store them as TemplateNames. The primary change here is to add a new kind of TemplateArgument, which stores a TemplateName. However, making that change ripples to every switch on a TemplateArgument's kind, also affecting TemplateArgumentLocInfo/TemplateArgumentLoc, default template arguments for template template parameters, type-checking of template template arguments, etc. This change is light on testing. It should fix several pre-existing problems with template template parameters, such as: - the inability to use dependent template names as template template arguments - template template parameter default arguments cannot be instantiation However, there are enough pieces missing that more implementation is required before we can adequately test template template parameters. llvm-svn: 86777
2009-11-11 09:00:40 +08:00
Info.FirstArg = Param;
Info.SecondArg = Arg;
return Sema::TDK_NonDeducedMismatch;
Replace the representation of template template argument pack expansions with something that is easier to use correctly: a new template argment kind, rather than a bit on an existing kind. Update all of the switch statements that deal with template arguments, fixing a few latent bugs in the process. I"m happy with this representation, now. And, oh look! Template instantiation and deduction work for template template argument pack expansions. llvm-svn: 122896
2011-01-06 02:58:31 +08:00
Introduce a new representation for template template parameters. Rather than storing them as either declarations (for the non-dependent case) or expressions (for the dependent case), we now (always) store them as TemplateNames. The primary change here is to add a new kind of TemplateArgument, which stores a TemplateName. However, making that change ripples to every switch on a TemplateArgument's kind, also affecting TemplateArgumentLocInfo/TemplateArgumentLoc, default template arguments for template template parameters, type-checking of template template arguments, etc. This change is light on testing. It should fix several pre-existing problems with template template parameters, such as: - the inability to use dependent template names as template template arguments - template template parameter default arguments cannot be instantiation However, there are enough pieces missing that more implementation is required before we can adequately test template template parameters. llvm-svn: 86777
2009-11-11 09:00:40 +08:00
case TemplateArgument::Template:
Template argument deduction for template template parameters. This permits, among other things, ripping apart and reconstructing templates via partial specialization: template<typename T> struct DeepRemoveConst { typedef T type; }; template<typename T> struct DeepRemoveConst<const T> { typedef typename DeepRemoveConst<T>::type type; }; template<template<typename> class TT, typename T> struct DeepRemoveConst<TT<T> > { typedef TT<typename DeepRemoveConst<T>::type> type; }; Also, fix a longstanding thinko in the code handling partial ordering of class template partial specializations. We were performing the second deduction without clearing out the results of the first deduction. It's amazing we got through so much code with such a horrendous error :( llvm-svn: 86893
2009-11-12 07:06:43 +08:00
if (Arg.getKind() == TemplateArgument::Template)
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
return DeduceTemplateArguments(S, TemplateParams,
Introduce a new representation for template template parameters. Rather than storing them as either declarations (for the non-dependent case) or expressions (for the dependent case), we now (always) store them as TemplateNames. The primary change here is to add a new kind of TemplateArgument, which stores a TemplateName. However, making that change ripples to every switch on a TemplateArgument's kind, also affecting TemplateArgumentLocInfo/TemplateArgumentLoc, default template arguments for template template parameters, type-checking of template template arguments, etc. This change is light on testing. It should fix several pre-existing problems with template template parameters, such as: - the inability to use dependent template names as template template arguments - template template parameter default arguments cannot be instantiation However, there are enough pieces missing that more implementation is required before we can adequately test template template parameters. llvm-svn: 86777
2009-11-11 09:00:40 +08:00
Param.getAsTemplate(),
Template argument deduction for template template parameters. This permits, among other things, ripping apart and reconstructing templates via partial specialization: template<typename T> struct DeepRemoveConst { typedef T type; }; template<typename T> struct DeepRemoveConst<const T> { typedef typename DeepRemoveConst<T>::type type; }; template<template<typename> class TT, typename T> struct DeepRemoveConst<TT<T> > { typedef TT<typename DeepRemoveConst<T>::type> type; }; Also, fix a longstanding thinko in the code handling partial ordering of class template partial specializations. We were performing the second deduction without clearing out the results of the first deduction. It's amazing we got through so much code with such a horrendous error :( llvm-svn: 86893
2009-11-12 07:06:43 +08:00
Arg.getAsTemplate(), Info, Deduced);
Introduce a new representation for template template parameters. Rather than storing them as either declarations (for the non-dependent case) or expressions (for the dependent case), we now (always) store them as TemplateNames. The primary change here is to add a new kind of TemplateArgument, which stores a TemplateName. However, making that change ripples to every switch on a TemplateArgument's kind, also affecting TemplateArgumentLocInfo/TemplateArgumentLoc, default template arguments for template template parameters, type-checking of template template arguments, etc. This change is light on testing. It should fix several pre-existing problems with template template parameters, such as: - the inability to use dependent template names as template template arguments - template template parameter default arguments cannot be instantiation However, there are enough pieces missing that more implementation is required before we can adequately test template template parameters. llvm-svn: 86777
2009-11-11 09:00:40 +08:00
Info.FirstArg = Param;
Info.SecondArg = Arg;
return Sema::TDK_NonDeducedMismatch;
Replace the representation of template template argument pack expansions with something that is easier to use correctly: a new template argment kind, rather than a bit on an existing kind. Update all of the switch statements that deal with template arguments, fixing a few latent bugs in the process. I"m happy with this representation, now. And, oh look! Template instantiation and deduction work for template template argument pack expansions. llvm-svn: 122896
2011-01-06 02:58:31 +08:00
case TemplateArgument::TemplateExpansion:
llvm_unreachable("caller should handle pack expansions");
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
case TemplateArgument::Declaration:
Introduce a new representation for template template parameters. Rather than storing them as either declarations (for the non-dependent case) or expressions (for the dependent case), we now (always) store them as TemplateNames. The primary change here is to add a new kind of TemplateArgument, which stores a TemplateName. However, making that change ripples to every switch on a TemplateArgument's kind, also affecting TemplateArgumentLocInfo/TemplateArgumentLoc, default template arguments for template template parameters, type-checking of template template arguments, etc. This change is light on testing. It should fix several pre-existing problems with template template parameters, such as: - the inability to use dependent template names as template template arguments - template template parameter default arguments cannot be instantiation However, there are enough pieces missing that more implementation is required before we can adequately test template template parameters. llvm-svn: 86777
2009-11-11 09:00:40 +08:00
if (Arg.getKind() == TemplateArgument::Declaration &&
Fix the AST representation for non-type template arguments to encode enough information so we can mangle them correctly in cases involving dependent parameter types. (This specifically impacts cases involving null pointers and cases involving parameters of reference type.) Fix the mangler to use this information instead of trying to scavenge it out of the parameter declaration. <rdar://problem/12296776>. llvm-svn: 164656
2012-09-26 10:36:12 +08:00
isSameDeclaration(Param.getAsDecl(), Arg.getAsDecl()) &&
Param.isDeclForReferenceParam() == Arg.isDeclForReferenceParam())
return Sema::TDK_Success;
Info.FirstArg = Param;
Info.SecondArg = Arg;
return Sema::TDK_NonDeducedMismatch;
case TemplateArgument::NullPtr:
if (Arg.getKind() == TemplateArgument::NullPtr &&
S.Context.hasSameType(Param.getNullPtrType(), Arg.getNullPtrType()))
Introduce a new representation for template template parameters. Rather than storing them as either declarations (for the non-dependent case) or expressions (for the dependent case), we now (always) store them as TemplateNames. The primary change here is to add a new kind of TemplateArgument, which stores a TemplateName. However, making that change ripples to every switch on a TemplateArgument's kind, also affecting TemplateArgumentLocInfo/TemplateArgumentLoc, default template arguments for template template parameters, type-checking of template template arguments, etc. This change is light on testing. It should fix several pre-existing problems with template template parameters, such as: - the inability to use dependent template names as template template arguments - template template parameter default arguments cannot be instantiation However, there are enough pieces missing that more implementation is required before we can adequately test template template parameters. llvm-svn: 86777
2009-11-11 09:00:40 +08:00
return Sema::TDK_Success;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
Info.FirstArg = Param;
Info.SecondArg = Arg;
return Sema::TDK_NonDeducedMismatch;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
case TemplateArgument::Integral:
if (Arg.getKind() == TemplateArgument::Integral) {
Plug a long standing memory leak in TemplateArgument. The integral APSInt value is now stored in a decomposed form and the backing store for large values is allocated via the ASTContext. This way its not leaked as TemplateArguments are never destructed when they are allocated in the ASTContext. Since the integral data is immutable it is now shared between instances, making copying TemplateArguments a trivial operation. Currently getting the integral data out of a TemplateArgument requires creating a new APSInt object. This is cheap when the value is small but can be expensive if it's not. If this turns out to be an issue a more efficient accessor could be added. llvm-svn: 158150
2012-06-07 23:09:51 +08:00
if (hasSameExtendedValue(Param.getAsIntegral(), Arg.getAsIntegral()))
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
return Sema::TDK_Success;
Info.FirstArg = Param;
Info.SecondArg = Arg;
return Sema::TDK_NonDeducedMismatch;
}
if (Arg.getKind() == TemplateArgument::Expression) {
Info.FirstArg = Param;
Info.SecondArg = Arg;
return Sema::TDK_NonDeducedMismatch;
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
}
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
Info.FirstArg = Param;
Info.SecondArg = Arg;
return Sema::TDK_NonDeducedMismatch;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
case TemplateArgument::Expression: {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
if (NonTypeTemplateParmDecl *NTTP
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
= getDeducedParameterFromExpr(Param.getAsExpr())) {
if (Arg.getKind() == TemplateArgument::Integral)
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
return DeduceNonTypeTemplateArgument(S, NTTP,
Plug a long standing memory leak in TemplateArgument. The integral APSInt value is now stored in a decomposed form and the backing store for large values is allocated via the ASTContext. This way its not leaked as TemplateArguments are never destructed when they are allocated in the ASTContext. Since the integral data is immutable it is now shared between instances, making copying TemplateArguments a trivial operation. Currently getting the integral data out of a TemplateArgument requires creating a new APSInt object. This is cheap when the value is small but can be expensive if it's not. If this turns out to be an issue a more efficient accessor could be added. llvm-svn: 158150
2012-06-07 23:09:51 +08:00
Arg.getAsIntegral(),
When deducing an integral template argument for a non-type template parameter, keep the integral value exactly as it was in the source code rather than trying to convert it to the type of the non-type template parameter (which may still be dependent!). The value will then be converted to the appropriate type once we check the resulting template arguments. Fixes PR6707. llvm-svn: 99611
2010-03-26 13:50:28 +08:00
Arg.getIntegralType(),
After performing template argument deduction for a function template, check deduced non-type template arguments and template template arguments against the template parameters for which they were deduced, performing conversions as appropriate so that deduced template arguments get the same treatment as explicitly-specified template arguments. This is the bulk of PR6723. Also keep track of whether deduction of a non-type template argument came from an array bound (vs. anywhere else). With this information, we enforce C++ [temp.deduct.type]p17, which requires exact type matches when deduction deduces a non-type template argument from something that is not an array bound. Finally, when in a SFINAE context, translate the "zero sized arrays are an extension" extension diagnostic into a hard error (for better standard conformance), which was a minor part of PR6723. llvm-svn: 99734
2010-03-28 10:42:43 +08:00
/*ArrayBound=*/false,
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
Info, Deduced);
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
if (Arg.getKind() == TemplateArgument::Expression)
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsExpr(),
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
Info, Deduced);
Template argument deduction of a non-type template parameter from a template argument. llvm-svn: 88722
2009-11-14 07:45:44 +08:00
if (Arg.getKind() == TemplateArgument::Declaration)
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsDecl(),
Template argument deduction of a non-type template parameter from a template argument. llvm-svn: 88722
2009-11-14 07:45:44 +08:00
Info, Deduced);
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
Info.FirstArg = Param;
Info.SecondArg = Arg;
return Sema::TDK_NonDeducedMismatch;
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
// Can't deduce anything, but that's okay.
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
return Sema::TDK_Success;
Several improvements to template argument deduction: - Once we have deduced template arguments for a class template partial specialization, we use exactly those template arguments for instantiating the definition of the class template partial specialization. - Added template argument deduction for non-type template parameters. - Added template argument deduction for dependently-sized array types. With these changes, we can now implement, e.g., the remove_reference type trait. Also, Daniel's Ackermann template metaprogram now compiles properly. llvm-svn: 72909
2009-06-05 08:53:49 +08:00
}
Add a new 'Pack' argument kind to TemplateArgument. This is not yet used. llvm-svn: 73391
2009-06-16 01:04:53 +08:00
case TemplateArgument::Pack:
Implicitly expand argument packs when performing template argument deduction. Unify all of the looping over template arguments for deduction purposes into a single place, where argument pack expansion occurs; this is also the hook for deducing from pack expansions, which itself is not yet implemented. For now, at least we can handle a basic "count" metafunction written with variadics. See the new test for the formulation that works. llvm-svn: 122418
2010-12-23 02:17:10 +08:00
llvm_unreachable("Argument packs should be expanded by the caller!");
When performing template argument deduction, ensure that multiple deductions of the same template parameter are equivalent. This allows us to implement the is_same type trait (!). Also, move template argument deduction into its own file and update a few build systems with this change (grrrr). llvm-svn: 72819
2009-06-04 08:03:07 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
More dead code removal (using -Wunreachable-code) llvm-svn: 148577
2012-01-21 05:50:17 +08:00
llvm_unreachable("Invalid TemplateArgument Kind!");
When performing template argument deduction, ensure that multiple deductions of the same template parameter are equivalent. This allows us to implement the is_same type trait (!). Also, move template argument deduction into its own file and update a few build systems with this change (grrrr). llvm-svn: 72819
2009-06-04 08:03:07 +08:00
}
Implicitly expand argument packs when performing template argument deduction. Unify all of the looping over template arguments for deduction purposes into a single place, where argument pack expansion occurs; this is also the hook for deducing from pack expansions, which itself is not yet implemented. For now, at least we can handle a basic "count" metafunction written with variadics. See the new test for the formulation that works. llvm-svn: 122418
2010-12-23 02:17:10 +08:00
/// \brief Determine whether there is a template argument to be used for
/// deduction.
///
/// This routine "expands" argument packs in-place, overriding its input
/// parameters so that \c Args[ArgIdx] will be the available template argument.
///
/// \returns true if there is another template argument (which will be at
/// \c Args[ArgIdx]), false otherwise.
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
static bool hasTemplateArgumentForDeduction(const TemplateArgument *&Args,
Implicitly expand argument packs when performing template argument deduction. Unify all of the looping over template arguments for deduction purposes into a single place, where argument pack expansion occurs; this is also the hook for deducing from pack expansions, which itself is not yet implemented. For now, at least we can handle a basic "count" metafunction written with variadics. See the new test for the formulation that works. llvm-svn: 122418
2010-12-23 02:17:10 +08:00
unsigned &ArgIdx,
unsigned &NumArgs) {
if (ArgIdx == NumArgs)
return false;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implicitly expand argument packs when performing template argument deduction. Unify all of the looping over template arguments for deduction purposes into a single place, where argument pack expansion occurs; this is also the hook for deducing from pack expansions, which itself is not yet implemented. For now, at least we can handle a basic "count" metafunction written with variadics. See the new test for the formulation that works. llvm-svn: 122418
2010-12-23 02:17:10 +08:00
const TemplateArgument &Arg = Args[ArgIdx];
if (Arg.getKind() != TemplateArgument::Pack)
return true;
assert(ArgIdx == NumArgs - 1 && "Pack not at the end of argument list?");
Args = Arg.pack_begin();
NumArgs = Arg.pack_size();
ArgIdx = 0;
return ArgIdx < NumArgs;
}
Implement the rest of C++0x [temp.deduct.type]p9, which specifies that the presence of a pack expansion anywhere except at the end of a template-argument-list causes the entire template-argument-list to be a non-deduced context. llvm-svn: 122461
2010-12-23 09:24:45 +08:00
/// \brief Determine whether the given set of template arguments has a pack
/// expansion that is not the last template argument.
static bool hasPackExpansionBeforeEnd(const TemplateArgument *Args,
unsigned NumArgs) {
unsigned ArgIdx = 0;
while (ArgIdx < NumArgs) {
const TemplateArgument &Arg = Args[ArgIdx];
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement the rest of C++0x [temp.deduct.type]p9, which specifies that the presence of a pack expansion anywhere except at the end of a template-argument-list causes the entire template-argument-list to be a non-deduced context. llvm-svn: 122461
2010-12-23 09:24:45 +08:00
// Unwrap argument packs.
if (Args[ArgIdx].getKind() == TemplateArgument::Pack) {
Args = Arg.pack_begin();
NumArgs = Arg.pack_size();
ArgIdx = 0;
continue;
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement the rest of C++0x [temp.deduct.type]p9, which specifies that the presence of a pack expansion anywhere except at the end of a template-argument-list causes the entire template-argument-list to be a non-deduced context. llvm-svn: 122461
2010-12-23 09:24:45 +08:00
++ArgIdx;
if (ArgIdx == NumArgs)
return false;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement the rest of C++0x [temp.deduct.type]p9, which specifies that the presence of a pack expansion anywhere except at the end of a template-argument-list causes the entire template-argument-list to be a non-deduced context. llvm-svn: 122461
2010-12-23 09:24:45 +08:00
if (Arg.isPackExpansion())
return true;
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement the rest of C++0x [temp.deduct.type]p9, which specifies that the presence of a pack expansion anywhere except at the end of a template-argument-list causes the entire template-argument-list to be a non-deduced context. llvm-svn: 122461
2010-12-23 09:24:45 +08:00
return false;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
static Sema::TemplateDeductionResult
Require a complete type before examining base classes during template argument deduction. This requires refactoring the deduction to have access to the Sema object instead of merely the ASTContext. Still leaves something to be desired due to poor source location. Fixes PR6257 and half of PR6259. llvm-svn: 95528
2010-02-08 05:33:28 +08:00
DeduceTemplateArguments(Sema &S,
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
TemplateParameterList *TemplateParams,
Implicitly expand argument packs when performing template argument deduction. Unify all of the looping over template arguments for deduction purposes into a single place, where argument pack expansion occurs; this is also the hook for deducing from pack expansions, which itself is not yet implemented. For now, at least we can handle a basic "count" metafunction written with variadics. See the new test for the formulation that works. llvm-svn: 122418
2010-12-23 02:17:10 +08:00
const TemplateArgument *Params, unsigned NumParams,
const TemplateArgument *Args, unsigned NumArgs,
Move more stuff out of Sema.h. llvm-svn: 112026
2010-08-25 13:32:35 +08:00
TemplateDeductionInfo &Info,
Fix http://stackoverflow.com/questions/13521163 Don't require that, during template deduction, a template specialization type as a function parameter has at least as many template arguments as one used in a function argument (not even if the argument has been resolved to an exact type); the additional parameters might be provided by default template arguments in the template. We don't need this check, since we now implement [temp.deduct.call]p4 with an additional check after deduction. llvm-svn: 169475
2012-12-06 14:44:44 +08:00
SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
Implement template argument deduction for pack expansions whose pattern is a template argument, which involves repeatedly deducing template arguments using the pattern of the pack expansion, then bundling the resulting deductions into an argument pack. We can now handle a variety of simple list-handling metaprograms using variadic templates. See, e.g., the new "count" metaprogram. llvm-svn: 122439
2010-12-23 05:19:48 +08:00
// C++0x [temp.deduct.type]p9:
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// If the template argument list of P contains a pack expansion that is not
// the last template argument, the entire template argument list is a
Implement template argument deduction for pack expansions whose pattern is a template argument, which involves repeatedly deducing template arguments using the pattern of the pack expansion, then bundling the resulting deductions into an argument pack. We can now handle a variety of simple list-handling metaprograms using variadic templates. See, e.g., the new "count" metaprogram. llvm-svn: 122439
2010-12-23 05:19:48 +08:00
// non-deduced context.
Implement the rest of C++0x [temp.deduct.type]p9, which specifies that the presence of a pack expansion anywhere except at the end of a template-argument-list causes the entire template-argument-list to be a non-deduced context. llvm-svn: 122461
2010-12-23 09:24:45 +08:00
if (hasPackExpansionBeforeEnd(Params, NumParams))
return Sema::TDK_Success;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement template argument deduction for pack expansions whose pattern is a template argument, which involves repeatedly deducing template arguments using the pattern of the pack expansion, then bundling the resulting deductions into an argument pack. We can now handle a variety of simple list-handling metaprograms using variadic templates. See, e.g., the new "count" metaprogram. llvm-svn: 122439
2010-12-23 05:19:48 +08:00
// C++0x [temp.deduct.type]p9:
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// If P has a form that contains <T> or <i>, then each argument Pi of the
// respective template argument list P is compared with the corresponding
Implement template argument deduction for pack expansions whose pattern is a template argument, which involves repeatedly deducing template arguments using the pattern of the pack expansion, then bundling the resulting deductions into an argument pack. We can now handle a variety of simple list-handling metaprograms using variadic templates. See, e.g., the new "count" metaprogram. llvm-svn: 122439
2010-12-23 05:19:48 +08:00
// argument Ai of the corresponding template argument list of A.
Implicitly expand argument packs when performing template argument deduction. Unify all of the looping over template arguments for deduction purposes into a single place, where argument pack expansion occurs; this is also the hook for deducing from pack expansions, which itself is not yet implemented. For now, at least we can handle a basic "count" metafunction written with variadics. See the new test for the formulation that works. llvm-svn: 122418
2010-12-23 02:17:10 +08:00
unsigned ArgIdx = 0, ParamIdx = 0;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
for (; hasTemplateArgumentForDeduction(Params, ParamIdx, NumParams);
Implicitly expand argument packs when performing template argument deduction. Unify all of the looping over template arguments for deduction purposes into a single place, where argument pack expansion occurs; this is also the hook for deducing from pack expansions, which itself is not yet implemented. For now, at least we can handle a basic "count" metafunction written with variadics. See the new test for the formulation that works. llvm-svn: 122418
2010-12-23 02:17:10 +08:00
++ParamIdx) {
if (!Params[ParamIdx].isPackExpansion()) {
Implement template argument deduction for pack expansions whose pattern is a template argument, which involves repeatedly deducing template arguments using the pattern of the pack expansion, then bundling the resulting deductions into an argument pack. We can now handle a variety of simple list-handling metaprograms using variadic templates. See, e.g., the new "count" metaprogram. llvm-svn: 122439
2010-12-23 05:19:48 +08:00
// The simple case: deduce template arguments by matching Pi and Ai.
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implicitly expand argument packs when performing template argument deduction. Unify all of the looping over template arguments for deduction purposes into a single place, where argument pack expansion occurs; this is also the hook for deducing from pack expansions, which itself is not yet implemented. For now, at least we can handle a basic "count" metafunction written with variadics. See the new test for the formulation that works. llvm-svn: 122418
2010-12-23 02:17:10 +08:00
// Check whether we have enough arguments.
if (!hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs))
Fix http://stackoverflow.com/questions/13521163 Don't require that, during template deduction, a template specialization type as a function parameter has at least as many template arguments as one used in a function argument (not even if the argument has been resolved to an exact type); the additional parameters might be provided by default template arguments in the template. We don't need this check, since we now implement [temp.deduct.call]p4 with an additional check after deduction. llvm-svn: 169475
2012-12-06 14:44:44 +08:00
return Sema::TDK_Success;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement partial ordering of class template partial specializations and function templates that contain variadic templates. This involves three small-ish changes: (1) When transforming a pack expansion, if the transformed argument still contains unexpanded parameter packs, build a pack expansion. This can happen during the substitution that occurs into class template partial specialiation template arguments during partial ordering. (2) When performing template argument deduction where the argument is a pack expansion, match against the pattern of that pack expansion. (3) When performing template argument deduction against a non-pack parameter, or a non-expansion template argument, deduction fails if the argument itself is a pack expansion (C++0x [temp.deduct.type]p22). llvm-svn: 123279
2011-01-12 06:21:24 +08:00
if (Args[ArgIdx].isPackExpansion()) {
// FIXME: We follow the logic of C++0x [temp.deduct.type]p22 here,
// but applied to pack expansions that are template arguments.
Improve 'failed template argument deduction' diagnostic for the case where we have a direct mismatch between some component of the template and some component of the argument. The diagnostic now says what the mismatch was, but doesn't yet say which part of the template doesn't match. llvm-svn: 174039
2013-01-31 13:19:49 +08:00
return Sema::TDK_MiscellaneousDeductionFailure;
Implement partial ordering of class template partial specializations and function templates that contain variadic templates. This involves three small-ish changes: (1) When transforming a pack expansion, if the transformed argument still contains unexpanded parameter packs, build a pack expansion. This can happen during the substitution that occurs into class template partial specialiation template arguments during partial ordering. (2) When performing template argument deduction where the argument is a pack expansion, match against the pattern of that pack expansion. (3) When performing template argument deduction against a non-pack parameter, or a non-expansion template argument, deduction fails if the argument itself is a pack expansion (C++0x [temp.deduct.type]p22). llvm-svn: 123279
2011-01-12 06:21:24 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement template argument deduction for pack expansions whose pattern is a template argument, which involves repeatedly deducing template arguments using the pattern of the pack expansion, then bundling the resulting deductions into an argument pack. We can now handle a variety of simple list-handling metaprograms using variadic templates. See, e.g., the new "count" metaprogram. llvm-svn: 122439
2010-12-23 05:19:48 +08:00
// Perform deduction for this Pi/Ai pair.
Implicitly expand argument packs when performing template argument deduction. Unify all of the looping over template arguments for deduction purposes into a single place, where argument pack expansion occurs; this is also the hook for deducing from pack expansions, which itself is not yet implemented. For now, at least we can handle a basic "count" metafunction written with variadics. See the new test for the formulation that works. llvm-svn: 122418
2010-12-23 02:17:10 +08:00
if (Sema::TemplateDeductionResult Result
Implement partial ordering of class template partial specializations and function templates that contain variadic templates. This involves three small-ish changes: (1) When transforming a pack expansion, if the transformed argument still contains unexpanded parameter packs, build a pack expansion. This can happen during the substitution that occurs into class template partial specialiation template arguments during partial ordering. (2) When performing template argument deduction where the argument is a pack expansion, match against the pattern of that pack expansion. (3) When performing template argument deduction against a non-pack parameter, or a non-expansion template argument, deduction fails if the argument itself is a pack expansion (C++0x [temp.deduct.type]p22). llvm-svn: 123279
2011-01-12 06:21:24 +08:00
= DeduceTemplateArguments(S, TemplateParams,
Params[ParamIdx], Args[ArgIdx],
Info, Deduced))
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
return Result;
Implicitly expand argument packs when performing template argument deduction. Unify all of the looping over template arguments for deduction purposes into a single place, where argument pack expansion occurs; this is also the hook for deducing from pack expansions, which itself is not yet implemented. For now, at least we can handle a basic "count" metafunction written with variadics. See the new test for the formulation that works. llvm-svn: 122418
2010-12-23 02:17:10 +08:00
// Move to the next argument.
++ArgIdx;
continue;
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement template argument deduction for pack expansions whose pattern is a template argument, which involves repeatedly deducing template arguments using the pattern of the pack expansion, then bundling the resulting deductions into an argument pack. We can now handle a variety of simple list-handling metaprograms using variadic templates. See, e.g., the new "count" metaprogram. llvm-svn: 122439
2010-12-23 05:19:48 +08:00
// The parameter is a pack expansion.
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement template argument deduction for pack expansions whose pattern is a template argument, which involves repeatedly deducing template arguments using the pattern of the pack expansion, then bundling the resulting deductions into an argument pack. We can now handle a variety of simple list-handling metaprograms using variadic templates. See, e.g., the new "count" metaprogram. llvm-svn: 122439
2010-12-23 05:19:48 +08:00
// C++0x [temp.deduct.type]p9:
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// If Pi is a pack expansion, then the pattern of Pi is compared with
// each remaining argument in the template argument list of A. Each
// comparison deduces template arguments for subsequent positions in the
Implement template argument deduction for pack expansions whose pattern is a template argument, which involves repeatedly deducing template arguments using the pattern of the pack expansion, then bundling the resulting deductions into an argument pack. We can now handle a variety of simple list-handling metaprograms using variadic templates. See, e.g., the new "count" metaprogram. llvm-svn: 122439
2010-12-23 05:19:48 +08:00
// template parameter packs expanded by Pi.
TemplateArgument Pattern = Params[ParamIdx].getPackExpansionPattern();
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement template argument deduction for pack expansions whose pattern is a template argument, which involves repeatedly deducing template arguments using the pattern of the pack expansion, then bundling the resulting deductions into an argument pack. We can now handle a variety of simple list-handling metaprograms using variadic templates. See, e.g., the new "count" metaprogram. llvm-svn: 122439
2010-12-23 05:19:48 +08:00
// Compute the set of template parameter indices that correspond to
// parameter packs expanded by the pack expansion.
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<unsigned, 2> PackIndices;
Implement template argument deduction for pack expansions whose pattern is a template argument, which involves repeatedly deducing template arguments using the pattern of the pack expansion, then bundling the resulting deductions into an argument pack. We can now handle a variety of simple list-handling metaprograms using variadic templates. See, e.g., the new "count" metaprogram. llvm-svn: 122439
2010-12-23 05:19:48 +08:00
{
SmallBitVectorize the deduced parameter set. llvm-svn: 149253
2012-01-31 00:17:39 +08:00
llvm::SmallBitVector SawIndices(TemplateParams->size());
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<UnexpandedParameterPack, 2> Unexpanded;
Implement template argument deduction for pack expansions whose pattern is a template argument, which involves repeatedly deducing template arguments using the pattern of the pack expansion, then bundling the resulting deductions into an argument pack. We can now handle a variety of simple list-handling metaprograms using variadic templates. See, e.g., the new "count" metaprogram. llvm-svn: 122439
2010-12-23 05:19:48 +08:00
S.collectUnexpandedParameterPacks(Pattern, Unexpanded);
for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
unsigned Depth, Index;
llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]);
if (Depth == 0 && !SawIndices[Index]) {
SawIndices[Index] = true;
PackIndices.push_back(Index);
}
}
}
assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?");
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement template argument deduction for pack expansions whose pattern is a template argument, which involves repeatedly deducing template arguments using the pattern of the pack expansion, then bundling the resulting deductions into an argument pack. We can now handle a variety of simple list-handling metaprograms using variadic templates. See, e.g., the new "count" metaprogram. llvm-svn: 122439
2010-12-23 05:19:48 +08:00
// FIXME: If there are no remaining arguments, we can bail out early
// and set any deduced parameter packs to an empty argument pack.
// The latter part of this is a (minor) correctness issue.
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement template argument deduction for pack expansions whose pattern is a template argument, which involves repeatedly deducing template arguments using the pattern of the pack expansion, then bundling the resulting deductions into an argument pack. We can now handle a variety of simple list-handling metaprograms using variadic templates. See, e.g., the new "count" metaprogram. llvm-svn: 122439
2010-12-23 05:19:48 +08:00
// Save the deduced template arguments for each parameter pack expanded
// by this pack expansion, then clear out the deduction.
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<DeducedTemplateArgument, 2>
Implement template argument deduction for pack expansions whose pattern is a template argument, which involves repeatedly deducing template arguments using the pattern of the pack expansion, then bundling the resulting deductions into an argument pack. We can now handle a variety of simple list-handling metaprograms using variadic templates. See, e.g., the new "count" metaprogram. llvm-svn: 122439
2010-12-23 05:19:48 +08:00
SavedPacks(PackIndices.size());
Introduce a typedef for the type of NewlyDeducedPacks to avoid repeating the small size of the inner SmallVector. llvm-svn: 185789
2013-07-08 12:44:01 +08:00
NewlyDeducedPacksType NewlyDeducedPacks(PackIndices.size());
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
PrepareArgumentPackDeduction(S, Deduced, PackIndices, SavedPacks,
Factor out the code to set up template argument deduction for a set of template argument packs. This also ensures that explicitly-specified template arguments get properly represented in those cases. llvm-svn: 123180
2011-01-11 01:35:05 +08:00
NewlyDeducedPacks);
Implement template argument deduction for pack expansions whose pattern is a template argument, which involves repeatedly deducing template arguments using the pattern of the pack expansion, then bundling the resulting deductions into an argument pack. We can now handle a variety of simple list-handling metaprograms using variadic templates. See, e.g., the new "count" metaprogram. llvm-svn: 122439
2010-12-23 05:19:48 +08:00
// Keep track of the deduced template arguments for each parameter pack
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// expanded by this pack expansion (the outer index) and for each
Implement template argument deduction for pack expansions whose pattern is a template argument, which involves repeatedly deducing template arguments using the pattern of the pack expansion, then bundling the resulting deductions into an argument pack. We can now handle a variety of simple list-handling metaprograms using variadic templates. See, e.g., the new "count" metaprogram. llvm-svn: 122439
2010-12-23 05:19:48 +08:00
// template argument (the inner SmallVectors).
bool HasAnyArguments = false;
while (hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs)) {
HasAnyArguments = true;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement template argument deduction for pack expansions whose pattern is a template argument, which involves repeatedly deducing template arguments using the pattern of the pack expansion, then bundling the resulting deductions into an argument pack. We can now handle a variety of simple list-handling metaprograms using variadic templates. See, e.g., the new "count" metaprogram. llvm-svn: 122439
2010-12-23 05:19:48 +08:00
// Deduce template arguments from the pattern.
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
if (Sema::TemplateDeductionResult Result
Implement template argument deduction for pack expansions whose pattern is a template argument, which involves repeatedly deducing template arguments using the pattern of the pack expansion, then bundling the resulting deductions into an argument pack. We can now handle a variety of simple list-handling metaprograms using variadic templates. See, e.g., the new "count" metaprogram. llvm-svn: 122439
2010-12-23 05:19:48 +08:00
= DeduceTemplateArguments(S, TemplateParams, Pattern, Args[ArgIdx],
Info, Deduced))
return Result;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement template argument deduction for pack expansions whose pattern is a template argument, which involves repeatedly deducing template arguments using the pattern of the pack expansion, then bundling the resulting deductions into an argument pack. We can now handle a variety of simple list-handling metaprograms using variadic templates. See, e.g., the new "count" metaprogram. llvm-svn: 122439
2010-12-23 05:19:48 +08:00
// Capture the deduced template arguments for each parameter pack expanded
// by this pack expansion, add them to the list of arguments we've deduced
// for that pack, then clear out the deduced argument.
for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) {
DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]];
if (!DeducedArg.isNull()) {
NewlyDeducedPacks[I].push_back(DeducedArg);
DeducedArg = DeducedTemplateArgument();
}
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement template argument deduction for pack expansions whose pattern is a template argument, which involves repeatedly deducing template arguments using the pattern of the pack expansion, then bundling the resulting deductions into an argument pack. We can now handle a variety of simple list-handling metaprograms using variadic templates. See, e.g., the new "count" metaprogram. llvm-svn: 122439
2010-12-23 05:19:48 +08:00
++ArgIdx;
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement template argument deduction for pack expansions whose pattern is a template argument, which involves repeatedly deducing template arguments using the pattern of the pack expansion, then bundling the resulting deductions into an argument pack. We can now handle a variety of simple list-handling metaprograms using variadic templates. See, e.g., the new "count" metaprogram. llvm-svn: 122439
2010-12-23 05:19:48 +08:00
// Build argument packs for each of the parameter packs expanded by this
// pack expansion.
Repent for my copy-and-paste sins, factoring out the code that forms argument packs from a set of deduced arguments, then checks that those argument packs match previously-deduced argument packs. llvm-svn: 123182
2011-01-11 01:53:52 +08:00
if (Sema::TemplateDeductionResult Result
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
= FinishArgumentPackDeduction(S, TemplateParams, HasAnyArguments,
Repent for my copy-and-paste sins, factoring out the code that forms argument packs from a set of deduced arguments, then checks that those argument packs match previously-deduced argument packs. llvm-svn: 123182
2011-01-11 01:53:52 +08:00
Deduced, PackIndices, SavedPacks,
NewlyDeducedPacks, Info))
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
return Result;
When performing template argument deduction, ensure that multiple deductions of the same template parameter are equivalent. This allows us to implement the is_same type trait (!). Also, move template argument deduction into its own file and update a few build systems with this change (grrrr). llvm-svn: 72819
2009-06-04 08:03:07 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
return Sema::TDK_Success;
When performing template argument deduction, ensure that multiple deductions of the same template parameter are equivalent. This allows us to implement the is_same type trait (!). Also, move template argument deduction into its own file and update a few build systems with this change (grrrr). llvm-svn: 72819
2009-06-04 08:03:07 +08:00
}
Implicitly expand argument packs when performing template argument deduction. Unify all of the looping over template arguments for deduction purposes into a single place, where argument pack expansion occurs; this is also the hook for deducing from pack expansions, which itself is not yet implemented. For now, at least we can handle a basic "count" metafunction written with variadics. See the new test for the formulation that works. llvm-svn: 122418
2010-12-23 02:17:10 +08:00
static Sema::TemplateDeductionResult
DeduceTemplateArguments(Sema &S,
TemplateParameterList *TemplateParams,
const TemplateArgumentList &ParamList,
const TemplateArgumentList &ArgList,
TemplateDeductionInfo &Info,
Function argument formatting fixes. llvm-svn: 185785
2013-07-08 12:13:06 +08:00
SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
return DeduceTemplateArguments(S, TemplateParams,
Implicitly expand argument packs when performing template argument deduction. Unify all of the looping over template arguments for deduction purposes into a single place, where argument pack expansion occurs; this is also the hook for deducing from pack expansions, which itself is not yet implemented. For now, at least we can handle a basic "count" metafunction written with variadics. See the new test for the formulation that works. llvm-svn: 122418
2010-12-23 02:17:10 +08:00
ParamList.data(), ParamList.size(),
ArgList.data(), ArgList.size(),
Info, Deduced);
}
Template argument deduction is no longer responsible for checking non-dependent parameter types. Instead, class template partial specializations perform a final check of all of the instantiated arguments. This model is cleaner, and works better for function templates where the "final check" occurs during overload resolution. Also, cope with cv-qualifiers when the parameter type was originally a reference type, so that the deduced argument can be more qualified than the transformed argument. llvm-svn: 74323
2009-06-27 04:57:09 +08:00
/// \brief Determine whether two template arguments are the same.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
static bool isSameTemplateArg(ASTContext &Context,
Template argument deduction is no longer responsible for checking non-dependent parameter types. Instead, class template partial specializations perform a final check of all of the instantiated arguments. This model is cleaner, and works better for function templates where the "final check" occurs during overload resolution. Also, cope with cv-qualifiers when the parameter type was originally a reference type, so that the deduced argument can be more qualified than the transformed argument. llvm-svn: 74323
2009-06-27 04:57:09 +08:00
const TemplateArgument &X,
const TemplateArgument &Y) {
if (X.getKind() != Y.getKind())
return false;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Template argument deduction is no longer responsible for checking non-dependent parameter types. Instead, class template partial specializations perform a final check of all of the instantiated arguments. This model is cleaner, and works better for function templates where the "final check" occurs during overload resolution. Also, cope with cv-qualifiers when the parameter type was originally a reference type, so that the deduced argument can be more qualified than the transformed argument. llvm-svn: 74323
2009-06-27 04:57:09 +08:00
switch (X.getKind()) {
case TemplateArgument::Null:
Switch assert(0/false) llvm_unreachable. llvm-svn: 140367
2011-09-23 13:06:16 +08:00
llvm_unreachable("Comparing NULL template argument");
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Template argument deduction is no longer responsible for checking non-dependent parameter types. Instead, class template partial specializations perform a final check of all of the instantiated arguments. This model is cleaner, and works better for function templates where the "final check" occurs during overload resolution. Also, cope with cv-qualifiers when the parameter type was originally a reference type, so that the deduced argument can be more qualified than the transformed argument. llvm-svn: 74323
2009-06-27 04:57:09 +08:00
case TemplateArgument::Type:
return Context.getCanonicalType(X.getAsType()) ==
Context.getCanonicalType(Y.getAsType());
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Template argument deduction is no longer responsible for checking non-dependent parameter types. Instead, class template partial specializations perform a final check of all of the instantiated arguments. This model is cleaner, and works better for function templates where the "final check" occurs during overload resolution. Also, cope with cv-qualifiers when the parameter type was originally a reference type, so that the deduced argument can be more qualified than the transformed argument. llvm-svn: 74323
2009-06-27 04:57:09 +08:00
case TemplateArgument::Declaration:
Fix the AST representation for non-type template arguments to encode enough information so we can mangle them correctly in cases involving dependent parameter types. (This specifically impacts cases involving null pointers and cases involving parameters of reference type.) Fix the mangler to use this information instead of trying to scavenge it out of the parameter declaration. <rdar://problem/12296776>. llvm-svn: 164656
2012-09-26 10:36:12 +08:00
return isSameDeclaration(X.getAsDecl(), Y.getAsDecl()) &&
X.isDeclForReferenceParam() == Y.isDeclForReferenceParam();
case TemplateArgument::NullPtr:
return Context.hasSameType(X.getNullPtrType(), Y.getNullPtrType());
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Introduce a new representation for template template parameters. Rather than storing them as either declarations (for the non-dependent case) or expressions (for the dependent case), we now (always) store them as TemplateNames. The primary change here is to add a new kind of TemplateArgument, which stores a TemplateName. However, making that change ripples to every switch on a TemplateArgument's kind, also affecting TemplateArgumentLocInfo/TemplateArgumentLoc, default template arguments for template template parameters, type-checking of template template arguments, etc. This change is light on testing. It should fix several pre-existing problems with template template parameters, such as: - the inability to use dependent template names as template template arguments - template template parameter default arguments cannot be instantiation However, there are enough pieces missing that more implementation is required before we can adequately test template template parameters. llvm-svn: 86777
2009-11-11 09:00:40 +08:00
case TemplateArgument::Template:
Replace the representation of template template argument pack expansions with something that is easier to use correctly: a new template argment kind, rather than a bit on an existing kind. Update all of the switch statements that deal with template arguments, fixing a few latent bugs in the process. I"m happy with this representation, now. And, oh look! Template instantiation and deduction work for template template argument pack expansions. llvm-svn: 122896
2011-01-06 02:58:31 +08:00
case TemplateArgument::TemplateExpansion:
return Context.getCanonicalTemplateName(
X.getAsTemplateOrTemplatePattern()).getAsVoidPointer() ==
Context.getCanonicalTemplateName(
Y.getAsTemplateOrTemplatePattern()).getAsVoidPointer();
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Template argument deduction is no longer responsible for checking non-dependent parameter types. Instead, class template partial specializations perform a final check of all of the instantiated arguments. This model is cleaner, and works better for function templates where the "final check" occurs during overload resolution. Also, cope with cv-qualifiers when the parameter type was originally a reference type, so that the deduced argument can be more qualified than the transformed argument. llvm-svn: 74323
2009-06-27 04:57:09 +08:00
case TemplateArgument::Integral:
Plug a long standing memory leak in TemplateArgument. The integral APSInt value is now stored in a decomposed form and the backing store for large values is allocated via the ASTContext. This way its not leaked as TemplateArguments are never destructed when they are allocated in the ASTContext. Since the integral data is immutable it is now shared between instances, making copying TemplateArguments a trivial operation. Currently getting the integral data out of a TemplateArgument requires creating a new APSInt object. This is cheap when the value is small but can be expensive if it's not. If this turns out to be an issue a more efficient accessor could be added. llvm-svn: 158150
2012-06-07 23:09:51 +08:00
return X.getAsIntegral() == Y.getAsIntegral();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Introduce a new representation for template template parameters. Rather than storing them as either declarations (for the non-dependent case) or expressions (for the dependent case), we now (always) store them as TemplateNames. The primary change here is to add a new kind of TemplateArgument, which stores a TemplateName. However, making that change ripples to every switch on a TemplateArgument's kind, also affecting TemplateArgumentLocInfo/TemplateArgumentLoc, default template arguments for template template parameters, type-checking of template template arguments, etc. This change is light on testing. It should fix several pre-existing problems with template template parameters, such as: - the inability to use dependent template names as template template arguments - template template parameter default arguments cannot be instantiation However, there are enough pieces missing that more implementation is required before we can adequately test template template parameters. llvm-svn: 86777
2009-11-11 09:00:40 +08:00
case TemplateArgument::Expression: {
llvm::FoldingSetNodeID XID, YID;
X.getAsExpr()->Profile(XID, Context, true);
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Y.getAsExpr()->Profile(YID, Context, true);
Introduce a new representation for template template parameters. Rather than storing them as either declarations (for the non-dependent case) or expressions (for the dependent case), we now (always) store them as TemplateNames. The primary change here is to add a new kind of TemplateArgument, which stores a TemplateName. However, making that change ripples to every switch on a TemplateArgument's kind, also affecting TemplateArgumentLocInfo/TemplateArgumentLoc, default template arguments for template template parameters, type-checking of template template arguments, etc. This change is light on testing. It should fix several pre-existing problems with template template parameters, such as: - the inability to use dependent template names as template template arguments - template template parameter default arguments cannot be instantiation However, there are enough pieces missing that more implementation is required before we can adequately test template template parameters. llvm-svn: 86777
2009-11-11 09:00:40 +08:00
return XID == YID;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Template argument deduction is no longer responsible for checking non-dependent parameter types. Instead, class template partial specializations perform a final check of all of the instantiated arguments. This model is cleaner, and works better for function templates where the "final check" occurs during overload resolution. Also, cope with cv-qualifiers when the parameter type was originally a reference type, so that the deduced argument can be more qualified than the transformed argument. llvm-svn: 74323
2009-06-27 04:57:09 +08:00
case TemplateArgument::Pack:
if (X.pack_size() != Y.pack_size())
return false;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
for (TemplateArgument::pack_iterator XP = X.pack_begin(),
XPEnd = X.pack_end(),
Template argument deduction is no longer responsible for checking non-dependent parameter types. Instead, class template partial specializations perform a final check of all of the instantiated arguments. This model is cleaner, and works better for function templates where the "final check" occurs during overload resolution. Also, cope with cv-qualifiers when the parameter type was originally a reference type, so that the deduced argument can be more qualified than the transformed argument. llvm-svn: 74323
2009-06-27 04:57:09 +08:00
YP = Y.pack_begin();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
XP != XPEnd; ++XP, ++YP)
Template argument deduction is no longer responsible for checking non-dependent parameter types. Instead, class template partial specializations perform a final check of all of the instantiated arguments. This model is cleaner, and works better for function templates where the "final check" occurs during overload resolution. Also, cope with cv-qualifiers when the parameter type was originally a reference type, so that the deduced argument can be more qualified than the transformed argument. llvm-svn: 74323
2009-06-27 04:57:09 +08:00
if (!isSameTemplateArg(Context, *XP, *YP))
return false;
return true;
}
More dead code removal (using -Wunreachable-code) llvm-svn: 148577
2012-01-21 05:50:17 +08:00
llvm_unreachable("Invalid TemplateArgument Kind!");
Template argument deduction is no longer responsible for checking non-dependent parameter types. Instead, class template partial specializations perform a final check of all of the instantiated arguments. This model is cleaner, and works better for function templates where the "final check" occurs during overload resolution. Also, cope with cv-qualifiers when the parameter type was originally a reference type, so that the deduced argument can be more qualified than the transformed argument. llvm-svn: 74323
2009-06-27 04:57:09 +08:00
}
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
/// \brief Allocate a TemplateArgumentLoc where all locations have
/// been initialized to the given location.
///
/// \param S The semantic analysis object.
///
Still more Doxygen documentation fixes: * Escape #, < and @ symbols where Doxygen would try to interpret them; * Fix several function param documentation where names had got out of sync; * Delete param documentation referring to parameters that no longer exist. llvm-svn: 158472
2012-06-15 05:40:34 +08:00
/// \param Arg The template argument we are producing template argument
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
/// location information for.
///
/// \param NTTPType For a declaration template argument, the type of
/// the non-type template parameter that corresponds to this template
/// argument.
///
/// \param Loc The source location to use for the resulting template
/// argument.
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
static TemplateArgumentLoc
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
getTrivialTemplateArgumentLoc(Sema &S,
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
const TemplateArgument &Arg,
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
QualType NTTPType,
SourceLocation Loc) {
switch (Arg.getKind()) {
case TemplateArgument::Null:
llvm_unreachable("Can't get a NULL template argument here");
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
case TemplateArgument::Type:
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
return TemplateArgumentLoc(Arg,
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
S.Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc));
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
case TemplateArgument::Declaration: {
Expr *E
Add semantic analysis for the creation of and an AST representation for template template argument pack expansions. This allows fun such as: template<template<class> class ...> struct apply_impl { /*...*/ }; template<template<class> class ...Metafunctions> struct apply { typedef typename apply_impl<Metafunctions...>::type type; }; However, neither template argument deduction nor template instantiation is implemented for template template argument packs, so this functionality isn't useful yet. I'll probably replace the encoding of template template argument pack expansions in TemplateArgument so that it's harder to accidentally forget about the expansion. However, this is a step in the right general direction. llvm-svn: 122890
2011-01-06 01:40:24 +08:00
= S.BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc)
Implement support for null non-type template arguments for non-type template parameters of pointer, pointer-to-member, or nullptr_t type in C++11. Fixes PR9700 / <rdar://problem/11193097>. llvm-svn: 154219
2012-04-07 06:40:38 +08:00
.takeAs<Expr>();
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
return TemplateArgumentLoc(TemplateArgument(E), E);
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Fix the AST representation for non-type template arguments to encode enough information so we can mangle them correctly in cases involving dependent parameter types. (This specifically impacts cases involving null pointers and cases involving parameters of reference type.) Fix the mangler to use this information instead of trying to scavenge it out of the parameter declaration. <rdar://problem/12296776>. llvm-svn: 164656
2012-09-26 10:36:12 +08:00
case TemplateArgument::NullPtr: {
Expr *E
= S.BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc)
.takeAs<Expr>();
return TemplateArgumentLoc(TemplateArgument(NTTPType, /*isNullPtr*/true),
E);
}
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
case TemplateArgument::Integral: {
Expr *E
Add semantic analysis for the creation of and an AST representation for template template argument pack expansions. This allows fun such as: template<template<class> class ...> struct apply_impl { /*...*/ }; template<template<class> class ...Metafunctions> struct apply { typedef typename apply_impl<Metafunctions...>::type type; }; However, neither template argument deduction nor template instantiation is implemented for template template argument packs, so this functionality isn't useful yet. I'll probably replace the encoding of template template argument pack expansions in TemplateArgument so that it's harder to accidentally forget about the expansion. However, this is a step in the right general direction. llvm-svn: 122890
2011-01-06 01:40:24 +08:00
= S.BuildExpressionFromIntegralTemplateArgument(Arg, Loc).takeAs<Expr>();
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
return TemplateArgumentLoc(TemplateArgument(E), E);
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Push nested-name-specifier source location information into template template arguments. I believe that this is the last place in the AST where we were storing a source range for a nested-name-specifier rather than a proper nested-name-specifier location structure. (Yay!) There is still a lot of cleanup to do in the TreeTransform, which doesn't take advantage of nested-name-specifiers with source-location information everywhere it could. llvm-svn: 126844
2011-03-03 01:09:35 +08:00
case TemplateArgument::Template:
case TemplateArgument::TemplateExpansion: {
NestedNameSpecifierLocBuilder Builder;
TemplateName Template = Arg.getAsTemplate();
if (DependentTemplateName *DTN = Template.getAsDependentTemplateName())
Builder.MakeTrivial(S.Context, DTN->getQualifier(), Loc);
else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
Builder.MakeTrivial(S.Context, QTN->getQualifier(), Loc);
if (Arg.getKind() == TemplateArgument::Template)
return TemplateArgumentLoc(Arg,
Builder.getWithLocInContext(S.Context),
Loc);
return TemplateArgumentLoc(Arg, Builder.getWithLocInContext(S.Context),
Loc, Loc);
}
Replace the representation of template template argument pack expansions with something that is easier to use correctly: a new template argment kind, rather than a bit on an existing kind. Update all of the switch statements that deal with template arguments, fixing a few latent bugs in the process. I"m happy with this representation, now. And, oh look! Template instantiation and deduction work for template template argument pack expansions. llvm-svn: 122896
2011-01-06 02:58:31 +08:00
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
case TemplateArgument::Expression:
return TemplateArgumentLoc(Arg, Arg.getAsExpr());
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
case TemplateArgument::Pack:
return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo());
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
More dead code removal (using -Wunreachable-code) llvm-svn: 148577
2012-01-21 05:50:17 +08:00
llvm_unreachable("Invalid TemplateArgument Kind!");
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
}
/// \brief Convert the given deduced template argument and add it to the set of
/// fully-converted template arguments.
Function argument formatting fixes. llvm-svn: 185785
2013-07-08 12:13:06 +08:00
static bool
ConvertDeducedTemplateArgument(Sema &S, NamedDecl *Param,
DeducedTemplateArgument Arg,
NamedDecl *Template,
QualType NTTPType,
unsigned ArgumentPackIndex,
TemplateDeductionInfo &Info,
bool InFunctionTemplate,
SmallVectorImpl<TemplateArgument> &Output) {
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
if (Arg.getKind() == TemplateArgument::Pack) {
// This is a template argument pack, so check each of its arguments against
// the template parameter.
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<TemplateArgument, 2> PackedArgsBuilder;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
for (TemplateArgument::pack_iterator PA = Arg.pack_begin(),
Propagate the "deduced from array bound" bit when comparing deduced template argument packs. Plus, remove a FIXME that I fixed yesterday. llvm-svn: 122903
2011-01-06 05:00:53 +08:00
PAEnd = Arg.pack_end();
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
PA != PAEnd; ++PA) {
When we're converting deduced template arguments to the type of the corresponding template parameter, make sure that prior converted template arguments are available for substitution. llvm-svn: 122902
2011-01-06 04:52:18 +08:00
// When converting the deduced template argument, append it to the
// general output list. We need to do this so that the template argument
// checking logic has all of the prior template arguments available.
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
DeducedTemplateArgument InnerArg(*PA);
InnerArg.setDeducedFromArrayBound(Arg.wasDeducedFromArrayBound());
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
if (ConvertDeducedTemplateArgument(S, Param, InnerArg, Template,
Implement support for non-type template parameter packs whose type is a pack expansion, e.g., the parameter pack Values in: template<typename ...Types> struct Outer { template<Types ...Values> struct Inner; }; This new implementation approach introduces the notion of an "expanded" non-type template parameter pack, for which we have already expanded the types of the parameter pack (to, say, "int*, float*", for Outer<int*, float*>) but have not yet expanded the values. Aside from creating these expanded non-type template parameter packs, this patch updates template argument checking and non-type template parameter pack instantiation to make use of the appropriate types in the parameter pack. llvm-svn: 123845
2011-01-20 04:10:05 +08:00
NTTPType, PackedArgsBuilder.size(),
Info, InFunctionTemplate, Output))
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
return true;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
When we're converting deduced template arguments to the type of the corresponding template parameter, make sure that prior converted template arguments are available for substitution. llvm-svn: 122902
2011-01-06 04:52:18 +08:00
// Move the converted template argument into our argument pack.
PackedArgsBuilder.push_back(Output.back());
Output.pop_back();
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
// Create the resulting argument pack.
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Output.push_back(TemplateArgument::CreatePackCopy(S.Context,
Add TemplateArgument::CreatePackCopy() to create a new parameter pack in ASTContext-allocated memory, copying the provided template arguments. Use this new routine where we can. No functionality change. llvm-svn: 123289
2011-01-12 07:09:57 +08:00
PackedArgsBuilder.data(),
PackedArgsBuilder.size()));
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
return false;
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
// Convert the deduced template argument into a template
// argument that we can check, almost as if the user had written
// the template argument explicitly.
TemplateArgumentLoc ArgLoc = getTrivialTemplateArgumentLoc(S, Arg, NTTPType,
Info.getLocation());
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
// Check the template argument, converting it as necessary.
return S.CheckTemplateArgument(Param, ArgLoc,
Template,
Template->getLocation(),
Template->getSourceRange().getEnd(),
Implement support for non-type template parameter packs whose type is a pack expansion, e.g., the parameter pack Values in: template<typename ...Types> struct Outer { template<Types ...Values> struct Inner; }; This new implementation approach introduces the notion of an "expanded" non-type template parameter pack, for which we have already expanded the types of the parameter pack (to, say, "int*, float*", for Outer<int*, float*>) but have not yet expanded the values. Aside from creating these expanded non-type template parameter packs, this patch updates template argument checking and non-type template parameter pack instantiation to make use of the appropriate types in the parameter pack. llvm-svn: 123845
2011-01-20 04:10:05 +08:00
ArgumentPackIndex,
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
Output,
InFunctionTemplate
? (Arg.wasDeducedFromArrayBound()
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
? Sema::CTAK_DeducedFromArrayBound
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
: Sema::CTAK_Deduced)
: Sema::CTAK_Specified);
}
For template argument deduction from class template partial specializations, separate out the deduction part from the checking and substitution of the deduced arguments. llvm-svn: 102600
2010-04-29 14:21:43 +08:00
/// Complete template argument deduction for a class template partial
/// specialization.
static Sema::TemplateDeductionResult
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
FinishTemplateArgumentDeduction(Sema &S,
For template argument deduction from class template partial specializations, separate out the deduction part from the checking and substitution of the deduced arguments. llvm-svn: 102600
2010-04-29 14:21:43 +08:00
ClassTemplatePartialSpecializationDecl *Partial,
const TemplateArgumentList &TemplateArgs,
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
Move more stuff out of Sema.h. llvm-svn: 112026
2010-08-25 13:32:35 +08:00
TemplateDeductionInfo &Info) {
Make sure template argument deduction is consistently performed in an unevaluated context. llvm-svn: 150049
2012-02-08 11:07:05 +08:00
// Unevaluated SFINAE context.
EnterExpressionEvaluationContext Unevaluated(S, Sema::Unevaluated);
For template argument deduction from class template partial specializations, separate out the deduction part from the checking and substitution of the deduced arguments. llvm-svn: 102600
2010-04-29 14:21:43 +08:00
Sema::SFINAETrap Trap(S);
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
For template argument deduction from class template partial specializations, separate out the deduction part from the checking and substitution of the deduced arguments. llvm-svn: 102600
2010-04-29 14:21:43 +08:00
Sema::ContextRAII SavedContext(S, Partial);
Properly switch into the declaring scope of a template when performing template argument deduction or (more importantly) the final substitution required by such deduction. Makes access control magically work in these cases. Fixes PR6967. llvm-svn: 102572
2010-04-29 08:35:03 +08:00
Once we have deduced the template arguments of a class template partial specialization, substitute those template arguments back into the template arguments of the class template partial specialization to see if the results still match the original template arguments. This code is more general than it needs to be, since we don't yet diagnose C++ [temp.class.spec]p9. However, it's likely to be needed for function templates. llvm-svn: 73196
2009-06-12 02:10:32 +08:00
// C++ [temp.deduct.type]p2:
// [...] or if any template argument remains neither deduced nor
// explicitly specified, template argument deduction fails.
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<TemplateArgument, 4> Builder;
Minor cleanups for template argument deduction in the presence of variadic templates. No functionality change. llvm-svn: 122847
2011-01-05 06:23:38 +08:00
TemplateParameterList *PartialParams = Partial->getTemplateParameters();
for (unsigned I = 0, N = PartialParams->size(); I != N; ++I) {
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
NamedDecl *Param = PartialParams->getParam(I);
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
if (Deduced[I].isNull()) {
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
Info.Param = makeTemplateParameter(Param);
For template argument deduction from class template partial specializations, separate out the deduction part from the checking and substitution of the deduced arguments. llvm-svn: 102600
2010-04-29 14:21:43 +08:00
return Sema::TDK_Incomplete;
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
// We have deduced this argument, so it still needs to be
// checked and converted.
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
// First, for a non-type template parameter type that is
// initialized by a declaration, we need the type of the
// corresponding non-type template parameter.
QualType NTTPType;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
if (NonTypeTemplateParmDecl *NTTP
When we're converting deduced template arguments to the type of the corresponding template parameter, make sure that prior converted template arguments are available for substitution. llvm-svn: 122902
2011-01-06 04:52:18 +08:00
= dyn_cast<NonTypeTemplateParmDecl>(Param)) {
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
NTTPType = NTTP->getType();
When we're converting deduced template arguments to the type of the corresponding template parameter, make sure that prior converted template arguments are available for substitution. llvm-svn: 122902
2011-01-06 04:52:18 +08:00
if (NTTPType->isDependentType()) {
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack,
When we're converting deduced template arguments to the type of the corresponding template parameter, make sure that prior converted template arguments are available for substitution. llvm-svn: 122902
2011-01-06 04:52:18 +08:00
Builder.data(), Builder.size());
NTTPType = S.SubstType(NTTPType,
MultiLevelTemplateArgumentList(TemplateArgs),
NTTP->getLocation(),
NTTP->getDeclName());
if (NTTPType.isNull()) {
Info.Param = makeTemplateParameter(Param);
// FIXME: These template arguments are temporary. Free them!
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Info.reset(TemplateArgumentList::CreateCopy(S.Context,
Builder.data(),
When we're converting deduced template arguments to the type of the corresponding template parameter, make sure that prior converted template arguments are available for substitution. llvm-svn: 122902
2011-01-06 04:52:18 +08:00
Builder.size()));
return Sema::TDK_SubstitutionFailure;
}
}
}
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
if (ConvertDeducedTemplateArgument(S, Param, Deduced[I],
Implement support for non-type template parameter packs whose type is a pack expansion, e.g., the parameter pack Values in: template<typename ...Types> struct Outer { template<Types ...Values> struct Inner; }; This new implementation approach introduces the notion of an "expanded" non-type template parameter pack, for which we have already expanded the types of the parameter pack (to, say, "int*, float*", for Outer<int*, float*>) but have not yet expanded the values. Aside from creating these expanded non-type template parameter packs, this patch updates template argument checking and non-type template parameter pack instantiation to make use of the appropriate types in the parameter pack. llvm-svn: 123845
2011-01-20 04:10:05 +08:00
Partial, NTTPType, 0, Info, false,
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
Builder)) {
Info.Param = makeTemplateParameter(Param);
// FIXME: These template arguments are temporary. Free them!
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder.data(),
Builder.size()));
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
return Sema::TDK_SubstitutionFailure;
}
Once we have deduced the template arguments of a class template partial specialization, substitute those template arguments back into the template arguments of the class template partial specialization to see if the results still match the original template arguments. This code is more general than it needs to be, since we don't yet diagnose C++ [temp.class.spec]p9. However, it's likely to be needed for function templates. llvm-svn: 73196
2009-06-12 02:10:32 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Once we have deduced the template arguments of a class template partial specialization, substitute those template arguments back into the template arguments of the class template partial specialization to see if the results still match the original template arguments. This code is more general than it needs to be, since we don't yet diagnose C++ [temp.class.spec]p9. However, it's likely to be needed for function templates. llvm-svn: 73196
2009-06-12 02:10:32 +08:00
// Form the template argument list from the deduced template arguments.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
TemplateArgumentList *DeducedArgumentList
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
= TemplateArgumentList::CreateCopy(S.Context, Builder.data(),
Remove broken support for variadic templates, along with the various abstractions (e.g., TemplateArgumentListBuilder) that were designed to support variadic templates. Only a few remnants of variadic templates remain, in the parser (parsing template type parameter packs), AST (template type parameter pack bits and TemplateArgument::Pack), and Sema; these are expected to be used in a future implementation of variadic templates. But don't get too excited about that happening now. llvm-svn: 118385
2010-11-08 07:05:16 +08:00
Builder.size());
Improve template argument deduction to keep track of why template argument deduction failed. For example, given template<typename T> struct is_same<T, T> { ... }; template argument deduction will fail for is_same<int, float>, and now reports enough information Right now, we don't do anything with this extra information, but it can be used for informative diagnostics that say, e.g., "template argument deduction failed because T was deduced to 'int' in one context and 'float' in another". llvm-svn: 73237
2009-06-13 02:26:56 +08:00
Info.reset(DeducedArgumentList);
Once we have deduced the template arguments of a class template partial specialization, substitute those template arguments back into the template arguments of the class template partial specialization to see if the results still match the original template arguments. This code is more general than it needs to be, since we don't yet diagnose C++ [temp.class.spec]p9. However, it's likely to be needed for function templates. llvm-svn: 73196
2009-06-12 02:10:32 +08:00
// Substitute the deduced template arguments into the template
// arguments of the class template partial specialization, and
// verify that the instantiated template arguments are both valid
// and are equivalent to the template arguments originally provided
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
// to the class template.
Move more stuff out of Sema.h. llvm-svn: 112026
2010-08-25 13:32:35 +08:00
LocalInstantiationScope InstScope(S);
Once we have deduced the template arguments of a class template partial specialization, substitute those template arguments back into the template arguments of the class template partial specialization to see if the results still match the original template arguments. This code is more general than it needs to be, since we don't yet diagnose C++ [temp.class.spec]p9. However, it's likely to be needed for function templates. llvm-svn: 73196
2009-06-12 02:10:32 +08:00
ClassTemplateDecl *ClassTemplate = Partial->getSpecializedTemplate();
Added source locs for angled parentheses in class/var template partial specs. llvm-svn: 188134
2013-08-10 15:24:53 +08:00
const ASTTemplateArgumentListInfo *PartialTemplArgInfo
Track source information for template arguments and template specialization types. Preserve it through template instantiation. Preserve it through PCH, although TSTs themselves aren't serializable, so that's pretty much meaningless. llvm-svn: 85500
2009-10-29 16:12:44 +08:00
= Partial->getTemplateArgsAsWritten();
Added source locs for angled parentheses in class/var template partial specs. llvm-svn: 188134
2013-08-10 15:24:53 +08:00
const TemplateArgumentLoc *PartialTemplateArgs
= PartialTemplArgInfo->getTemplateArgs();
Encapsulate "an array of TemplateArgumentLocs and two angle bracket locations" into a new class. Use it pervasively throughout Sema. My fingers hurt. llvm-svn: 89638
2009-11-23 09:53:49 +08:00
Added source locs for angled parentheses in class/var template partial specs. llvm-svn: 188134
2013-08-10 15:24:53 +08:00
TemplateArgumentListInfo InstArgs(PartialTemplArgInfo->LAngleLoc,
PartialTemplArgInfo->RAngleLoc);
Encapsulate "an array of TemplateArgumentLocs and two angle bracket locations" into a new class. Use it pervasively throughout Sema. My fingers hurt. llvm-svn: 89638
2009-11-23 09:53:49 +08:00
Added source locs for angled parentheses in class/var template partial specs. llvm-svn: 188134
2013-08-10 15:24:53 +08:00
if (S.Subst(PartialTemplateArgs, PartialTemplArgInfo->NumTemplateArgs,
Implement template argument deduction for pack expansions whose pattern is a template argument, which involves repeatedly deducing template arguments using the pattern of the pack expansion, then bundling the resulting deductions into an argument pack. We can now handle a variety of simple list-handling metaprograms using variadic templates. See, e.g., the new "count" metaprogram. llvm-svn: 122439
2010-12-23 05:19:48 +08:00
InstArgs, MultiLevelTemplateArgumentList(*DeducedArgumentList))) {
unsigned ArgIdx = InstArgs.size(), ParamIdx = ArgIdx;
if (ParamIdx >= Partial->getTemplateParameters()->size())
ParamIdx = Partial->getTemplateParameters()->size() - 1;
Decl *Param
= const_cast<NamedDecl *>(
Partial->getTemplateParameters()->getParam(ParamIdx));
Info.Param = makeTemplateParameter(Param);
Info.FirstArg = PartialTemplateArgs[ArgIdx].getArgument();
return Sema::TDK_SubstitutionFailure;
Track source information for template arguments and template specialization types. Preserve it through template instantiation. Preserve it through PCH, although TSTs themselves aren't serializable, so that's pretty much meaningless. llvm-svn: 85500
2009-10-29 16:12:44 +08:00
}
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<TemplateArgument, 4> ConvertedInstArgs;
For template argument deduction from class template partial specializations, separate out the deduction part from the checking and substitution of the deduced arguments. llvm-svn: 102600
2010-04-29 14:21:43 +08:00
if (S.CheckTemplateArgumentList(ClassTemplate, Partial->getLocation(),
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
InstArgs, false, ConvertedInstArgs))
For template argument deduction from class template partial specializations, separate out the deduction part from the checking and substitution of the deduced arguments. llvm-svn: 102600
2010-04-29 14:21:43 +08:00
return Sema::TDK_SubstitutionFailure;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
TemplateParameterList *TemplateParams
= ClassTemplate->getTemplateParameters();
for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) {
Remove broken support for variadic templates, along with the various abstractions (e.g., TemplateArgumentListBuilder) that were designed to support variadic templates. Only a few remnants of variadic templates remain, in the parser (parsing template type parameter packs), AST (template type parameter pack bits and TemplateArgument::Pack), and Sema; these are expected to be used in a future implementation of variadic templates. But don't get too excited about that happening now. llvm-svn: 118385
2010-11-08 07:05:16 +08:00
TemplateArgument InstArg = ConvertedInstArgs.data()[I];
For template argument deduction from class template partial specializations, separate out the deduction part from the checking and substitution of the deduced arguments. llvm-svn: 102600
2010-04-29 14:21:43 +08:00
if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg)) {
Many of the built-in operator candidates introduced into overload resolution require that the pointed-to type be an object type, but we weren't filtering out non-object types. Do so, fixing PR7851. llvm-svn: 122853
2011-01-05 08:13:17 +08:00
Info.Param = makeTemplateParameter(TemplateParams->getParam(I));
Template argument deduction is no longer responsible for checking non-dependent parameter types. Instead, class template partial specializations perform a final check of all of the instantiated arguments. This model is cleaner, and works better for function templates where the "final check" occurs during overload resolution. Also, cope with cv-qualifiers when the parameter type was originally a reference type, so that the deduced argument can be more qualified than the transformed argument. llvm-svn: 74323
2009-06-27 04:57:09 +08:00
Info.FirstArg = TemplateArgs[I];
Info.SecondArg = InstArg;
For template argument deduction from class template partial specializations, separate out the deduction part from the checking and substitution of the deduced arguments. llvm-svn: 102600
2010-04-29 14:21:43 +08:00
return Sema::TDK_NonDeducedMismatch;
Template argument deduction is no longer responsible for checking non-dependent parameter types. Instead, class template partial specializations perform a final check of all of the instantiated arguments. This model is cleaner, and works better for function templates where the "final check" occurs during overload resolution. Also, cope with cv-qualifiers when the parameter type was originally a reference type, so that the deduced argument can be more qualified than the transformed argument. llvm-svn: 74323
2009-06-27 04:57:09 +08:00
}
Once we have deduced the template arguments of a class template partial specialization, substitute those template arguments back into the template arguments of the class template partial specialization to see if the results still match the original template arguments. This code is more general than it needs to be, since we don't yet diagnose C++ [temp.class.spec]p9. However, it's likely to be needed for function templates. llvm-svn: 73196
2009-06-12 02:10:32 +08:00
}
Introduce a SFINAE "trap" that keeps track of the number of errors that were suppressed due to SFINAE. By checking whether any errors occur at the end of template argument deduction, we avoid the possibility of suppressing an error (due to SFINAE) and then recovering so well that template argument deduction never detects that there was a problem. Thanks to Eli for the push in this direction. llvm-svn: 73336
2009-06-14 16:02:22 +08:00
if (Trap.hasErrorOccurred())
For template argument deduction from class template partial specializations, separate out the deduction part from the checking and substitution of the deduced arguments. llvm-svn: 102600
2010-04-29 14:21:43 +08:00
return Sema::TDK_SubstitutionFailure;
Introduce a SFINAE "trap" that keeps track of the number of errors that were suppressed due to SFINAE. By checking whether any errors occur at the end of template argument deduction, we avoid the possibility of suppressing an error (due to SFINAE) and then recovering so well that template argument deduction never detects that there was a problem. Thanks to Eli for the push in this direction. llvm-svn: 73336
2009-06-14 16:02:22 +08:00
For template argument deduction from class template partial specializations, separate out the deduction part from the checking and substitution of the deduced arguments. llvm-svn: 102600
2010-04-29 14:21:43 +08:00
return Sema::TDK_Success;
}
/// \brief Perform template argument deduction to determine whether
A bit of clean up based on peer's feedback... llvm-svn: 187784
2013-08-06 15:33:00 +08:00
/// the given template arguments match the given class template
For template argument deduction from class template partial specializations, separate out the deduction part from the checking and substitution of the deduced arguments. llvm-svn: 102600
2010-04-29 14:21:43 +08:00
/// partial specialization per C++ [temp.class.spec.match].
Sema::TemplateDeductionResult
Sema::DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial,
const TemplateArgumentList &TemplateArgs,
TemplateDeductionInfo &Info) {
Don't perform template argument deduction against invalid templates; it's likely to lead to a crash later on. Fixes PR12933 / <rdar://problem/11525335>. llvm-svn: 163838
2012-09-14 05:01:57 +08:00
if (Partial->isInvalidDecl())
return TDK_Invalid;
For template argument deduction from class template partial specializations, separate out the deduction part from the checking and substitution of the deduced arguments. llvm-svn: 102600
2010-04-29 14:21:43 +08:00
// C++ [temp.class.spec.match]p2:
// A partial specialization matches a given actual template
// argument list if the template arguments of the partial
// specialization can be deduced from the actual template argument
// list (14.8.2).
Make sure template argument deduction is consistently performed in an unevaluated context. llvm-svn: 150049
2012-02-08 11:07:05 +08:00
// Unevaluated SFINAE context.
EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
For template argument deduction from class template partial specializations, separate out the deduction part from the checking and substitution of the deduced arguments. llvm-svn: 102600
2010-04-29 14:21:43 +08:00
SFINAETrap Trap(*this);
Make sure template argument deduction is consistently performed in an unevaluated context. llvm-svn: 150049
2012-02-08 11:07:05 +08:00
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<DeducedTemplateArgument, 4> Deduced;
For template argument deduction from class template partial specializations, separate out the deduction part from the checking and substitution of the deduced arguments. llvm-svn: 102600
2010-04-29 14:21:43 +08:00
Deduced.resize(Partial->getTemplateParameters()->size());
if (TemplateDeductionResult Result
= ::DeduceTemplateArguments(*this,
Partial->getTemplateParameters(),
Partial->getTemplateArgs(),
TemplateArgs, Info, Deduced))
return Result;
PR13365: Fix code which was trying to treat an array of DeducedTemplateArgument as an array of its base class TemplateArgument. Switch the const TemplateArgument* parameters of InstantiatingTemplate's constructors to ArrayRef<TemplateArgument> to prevent this from happening again in the future. llvm-svn: 160245
2012-07-16 09:09:10 +08:00
SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end());
For template argument deduction from class template partial specializations, separate out the deduction part from the checking and substitution of the deduced arguments. llvm-svn: 102600
2010-04-29 14:21:43 +08:00
InstantiatingTemplate Inst(*this, Partial->getLocation(), Partial,
PR13365: Fix code which was trying to treat an array of DeducedTemplateArgument as an array of its base class TemplateArgument. Switch the const TemplateArgument* parameters of InstantiatingTemplate's constructors to ArrayRef<TemplateArgument> to prevent this from happening again in the future. llvm-svn: 160245
2012-07-16 09:09:10 +08:00
DeducedArgs, Info);
For template argument deduction from class template partial specializations, separate out the deduction part from the checking and substitution of the deduced arguments. llvm-svn: 102600
2010-04-29 14:21:43 +08:00
if (Inst)
return TDK_InstantiationDepth;
if (Trap.hasErrorOccurred())
return Sema::TDK_SubstitutionFailure;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
return ::FinishTemplateArgumentDeduction(*this, Partial, TemplateArgs,
For template argument deduction from class template partial specializations, separate out the deduction part from the checking and substitution of the deduced arguments. llvm-svn: 102600
2010-04-29 14:21:43 +08:00
Deduced, Info);
When performing template argument deduction, ensure that multiple deductions of the same template parameter are equivalent. This allows us to implement the is_same type trait (!). Also, move template argument deduction into its own file and update a few build systems with this change (grrrr). llvm-svn: 72819
2009-06-04 08:03:07 +08:00
}
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
/// Complete template argument deduction for a variable template partial
/// specialization.
/// TODO: Unify with ClassTemplatePartialSpecializationDecl version.
static Sema::TemplateDeductionResult FinishTemplateArgumentDeduction(
Sema &S, VarTemplatePartialSpecializationDecl *Partial,
const TemplateArgumentList &TemplateArgs,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
TemplateDeductionInfo &Info) {
// Unevaluated SFINAE context.
EnterExpressionEvaluationContext Unevaluated(S, Sema::Unevaluated);
Sema::SFINAETrap Trap(S);
// C++ [temp.deduct.type]p2:
// [...] or if any template argument remains neither deduced nor
// explicitly specified, template argument deduction fails.
SmallVector<TemplateArgument, 4> Builder;
TemplateParameterList *PartialParams = Partial->getTemplateParameters();
for (unsigned I = 0, N = PartialParams->size(); I != N; ++I) {
NamedDecl *Param = PartialParams->getParam(I);
if (Deduced[I].isNull()) {
Info.Param = makeTemplateParameter(Param);
return Sema::TDK_Incomplete;
}
// We have deduced this argument, so it still needs to be
// checked and converted.
// First, for a non-type template parameter type that is
// initialized by a declaration, we need the type of the
// corresponding non-type template parameter.
QualType NTTPType;
if (NonTypeTemplateParmDecl *NTTP =
dyn_cast<NonTypeTemplateParmDecl>(Param)) {
NTTPType = NTTP->getType();
if (NTTPType->isDependentType()) {
TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack,
Builder.data(), Builder.size());
NTTPType =
S.SubstType(NTTPType, MultiLevelTemplateArgumentList(TemplateArgs),
NTTP->getLocation(), NTTP->getDeclName());
if (NTTPType.isNull()) {
Info.Param = makeTemplateParameter(Param);
// FIXME: These template arguments are temporary. Free them!
Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder.data(),
Builder.size()));
return Sema::TDK_SubstitutionFailure;
}
}
}
if (ConvertDeducedTemplateArgument(S, Param, Deduced[I], Partial, NTTPType,
0, Info, false, Builder)) {
Info.Param = makeTemplateParameter(Param);
// FIXME: These template arguments are temporary. Free them!
Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder.data(),
Builder.size()));
return Sema::TDK_SubstitutionFailure;
}
}
// Form the template argument list from the deduced template arguments.
TemplateArgumentList *DeducedArgumentList = TemplateArgumentList::CreateCopy(
S.Context, Builder.data(), Builder.size());
Info.reset(DeducedArgumentList);
// Substitute the deduced template arguments into the template
// arguments of the class template partial specialization, and
// verify that the instantiated template arguments are both valid
// and are equivalent to the template arguments originally provided
// to the class template.
LocalInstantiationScope InstScope(S);
VarTemplateDecl *VarTemplate = Partial->getSpecializedTemplate();
Added source locs for angled parentheses in class/var template partial specs. llvm-svn: 188134
2013-08-10 15:24:53 +08:00
const ASTTemplateArgumentListInfo *PartialTemplArgInfo
= Partial->getTemplateArgsAsWritten();
const TemplateArgumentLoc *PartialTemplateArgs
= PartialTemplArgInfo->getTemplateArgs();
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
Added source locs for angled parentheses in class/var template partial specs. llvm-svn: 188134
2013-08-10 15:24:53 +08:00
TemplateArgumentListInfo InstArgs(PartialTemplArgInfo->LAngleLoc,
PartialTemplArgInfo->RAngleLoc);
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
Added source locs for angled parentheses in class/var template partial specs. llvm-svn: 188134
2013-08-10 15:24:53 +08:00
if (S.Subst(PartialTemplateArgs, PartialTemplArgInfo->NumTemplateArgs,
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
InstArgs, MultiLevelTemplateArgumentList(*DeducedArgumentList))) {
unsigned ArgIdx = InstArgs.size(), ParamIdx = ArgIdx;
if (ParamIdx >= Partial->getTemplateParameters()->size())
ParamIdx = Partial->getTemplateParameters()->size() - 1;
Decl *Param = const_cast<NamedDecl *>(
Partial->getTemplateParameters()->getParam(ParamIdx));
Info.Param = makeTemplateParameter(Param);
Info.FirstArg = PartialTemplateArgs[ArgIdx].getArgument();
return Sema::TDK_SubstitutionFailure;
}
SmallVector<TemplateArgument, 4> ConvertedInstArgs;
if (S.CheckTemplateArgumentList(VarTemplate, Partial->getLocation(), InstArgs,
false, ConvertedInstArgs))
return Sema::TDK_SubstitutionFailure;
TemplateParameterList *TemplateParams = VarTemplate->getTemplateParameters();
for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) {
TemplateArgument InstArg = ConvertedInstArgs.data()[I];
if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg)) {
Info.Param = makeTemplateParameter(TemplateParams->getParam(I));
Info.FirstArg = TemplateArgs[I];
Info.SecondArg = InstArg;
return Sema::TDK_NonDeducedMismatch;
}
}
if (Trap.hasErrorOccurred())
return Sema::TDK_SubstitutionFailure;
return Sema::TDK_Success;
}
/// \brief Perform template argument deduction to determine whether
/// the given template arguments match the given variable template
/// partial specialization per C++ [temp.class.spec.match].
/// TODO: Unify with ClassTemplatePartialSpecializationDecl version.
Sema::TemplateDeductionResult
Sema::DeduceTemplateArguments(VarTemplatePartialSpecializationDecl *Partial,
const TemplateArgumentList &TemplateArgs,
TemplateDeductionInfo &Info) {
if (Partial->isInvalidDecl())
return TDK_Invalid;
// C++ [temp.class.spec.match]p2:
// A partial specialization matches a given actual template
// argument list if the template arguments of the partial
// specialization can be deduced from the actual template argument
// list (14.8.2).
// Unevaluated SFINAE context.
EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
SFINAETrap Trap(*this);
SmallVector<DeducedTemplateArgument, 4> Deduced;
Deduced.resize(Partial->getTemplateParameters()->size());
if (TemplateDeductionResult Result = ::DeduceTemplateArguments(
*this, Partial->getTemplateParameters(), Partial->getTemplateArgs(),
TemplateArgs, Info, Deduced))
return Result;
SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end());
InstantiatingTemplate Inst(*this, Partial->getLocation(), Partial,
DeducedArgs, Info);
if (Inst)
return TDK_InstantiationDepth;
if (Trap.hasErrorOccurred())
return Sema::TDK_SubstitutionFailure;
return ::FinishTemplateArgumentDeduction(*this, Partial, TemplateArgs,
Deduced, Info);
}
Set the rest of the flags we need to perform template argument deduction using a base class of the argument type. No actual functionality change; this is just a hook. llvm-svn: 74356
2009-06-27 07:27:24 +08:00
/// \brief Determine whether the given type T is a simple-template-id type.
static bool isSimpleTemplateIdType(QualType T) {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
if (const TemplateSpecializationType *Spec
Change all the Type::getAsFoo() methods to specializations of Type::getAs(). Several of the existing methods were identical to their respective specializations, and so have been removed entirely. Several more 'leaf' optimizations were introduced. The getAsFoo() methods which imposed extra conditions, like getAsObjCInterfacePointerType(), have been left in place. llvm-svn: 82501
2009-09-22 07:43:11 +08:00
= T->getAs<TemplateSpecializationType>())
Set the rest of the flags we need to perform template argument deduction using a base class of the argument type. No actual functionality change; this is just a hook. llvm-svn: 74356
2009-06-27 07:27:24 +08:00
return Spec->getTemplateName().getAsTemplateDecl() != 0;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Set the rest of the flags we need to perform template argument deduction using a base class of the argument type. No actual functionality change; this is just a hook. llvm-svn: 74356
2009-06-27 07:27:24 +08:00
return false;
}
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
/// \brief Substitute the explicitly-provided template arguments into the
/// given function template according to C++ [temp.arg.explicit].
///
/// \param FunctionTemplate the function template into which the explicit
/// template arguments will be substituted.
///
Still more Doxygen documentation fixes: * Escape #, < and @ symbols where Doxygen would try to interpret them; * Fix several function param documentation where names had got out of sync; * Delete param documentation referring to parameters that no longer exist. llvm-svn: 158472
2012-06-15 05:40:34 +08:00
/// \param ExplicitTemplateArgs the explicitly-specified template
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
/// arguments.
///
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
/// \param Deduced the deduced template arguments, which will be populated
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
/// with the converted and checked explicit template arguments.
///
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
/// \param ParamTypes will be populated with the instantiated function
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
/// parameters.
///
/// \param FunctionType if non-NULL, the result type of the function template
/// will also be instantiated and the pointed-to value will be updated with
/// the instantiated function type.
///
/// \param Info if substitution fails for any reason, this object will be
/// populated with more information about the failure.
///
/// \returns TDK_Success if substitution was successful, or some failure
/// condition.
Sema::TemplateDeductionResult
Sema::SubstituteExplicitTemplateArguments(
FunctionTemplateDecl *FunctionTemplate,
When we use the default template arguments of a template template parameter, save the instantiated default template arguments along with the explicitly-specified template argument list. That way, we prefer the default template template arguments corresponding to the template template parameter rather than those of its template template argument. This addresses the likely direction of C++ core issue 150, and fixes PR9353/<rdar://problem/9069136>, bringing us closer to the behavior of EDG and GCC. llvm-svn: 126920
2011-03-03 10:41:12 +08:00
TemplateArgumentListInfo &ExplicitTemplateArgs,
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
SmallVectorImpl<QualType> &ParamTypes,
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
QualType *FunctionType,
TemplateDeductionInfo &Info) {
FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
TemplateParameterList *TemplateParams
= FunctionTemplate->getTemplateParameters();
Encapsulate "an array of TemplateArgumentLocs and two angle bracket locations" into a new class. Use it pervasively throughout Sema. My fingers hurt. llvm-svn: 89638
2009-11-23 09:53:49 +08:00
if (ExplicitTemplateArgs.size() == 0) {
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
// No arguments to substitute; just copy over the parameter types and
// fill in the function type.
for (FunctionDecl::param_iterator P = Function->param_begin(),
PEnd = Function->param_end();
P != PEnd;
++P)
ParamTypes.push_back((*P)->getType());
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
if (FunctionType)
*FunctionType = Function->getType();
return TDK_Success;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Make sure template argument deduction is consistently performed in an unevaluated context. llvm-svn: 150049
2012-02-08 11:07:05 +08:00
// Unevaluated SFINAE context.
EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
SFINAETrap Trap(*this);
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
// C++ [temp.arg.explicit]p3:
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
// Template arguments that are present shall be specified in the
// declaration order of their corresponding template-parameters. The
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
// template argument list shall not specify more template-arguments than
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
// there are corresponding template-parameters.
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<TemplateArgument, 4> Builder;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
// Enter a new template instantiation context where we check the
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
// explicitly-specified template arguments against this function template,
// and then substitute them into the function parameter types.
PR13365: Fix code which was trying to treat an array of DeducedTemplateArgument as an array of its base class TemplateArgument. Switch the const TemplateArgument* parameters of InstantiatingTemplate's constructors to ArrayRef<TemplateArgument> to prevent this from happening again in the future. llvm-svn: 160245
2012-07-16 09:09:10 +08:00
SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end());
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
InstantiatingTemplate Inst(*this, FunctionTemplate->getLocation(),
PR13365: Fix code which was trying to treat an array of DeducedTemplateArgument as an array of its base class TemplateArgument. Switch the const TemplateArgument* parameters of InstantiatingTemplate's constructors to ArrayRef<TemplateArgument> to prevent this from happening again in the future. llvm-svn: 160245
2012-07-16 09:09:10 +08:00
FunctionTemplate, DeducedArgs,
Introduce support for emitting diagnostics (warnings + their notes) that are suppressed during template argument deduction. This change queues diagnostics computed during template argument deduction. Then, if the resulting function template specialization or partial specialization is chosen by overload resolution or partial ordering (respectively), we will emit the queued diagnostics at that point. This addresses most of PR6784. However, the check for unnamed/local template arguments (which existed before this change) is still only skin-deep, and needs to be extended to look deeper into types. It must be improved to finish PR6784. llvm-svn: 116373
2010-10-13 07:32:35 +08:00
ActiveTemplateInstantiation::ExplicitTemplateArgumentSubstitution,
Info);
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
if (Inst)
return TDK_InstantiationDepth;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
if (CheckTemplateArgumentList(FunctionTemplate,
SourceLocation(),
Encapsulate "an array of TemplateArgumentLocs and two angle bracket locations" into a new class. Use it pervasively throughout Sema. My fingers hurt. llvm-svn: 89638
2009-11-23 09:53:49 +08:00
ExplicitTemplateArgs,
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
true,
Improve overload-candidate diagnostic for a function template that failed because the explicitly-specified template arguments did not match its template parameters, e.g., test/SemaTemplate/overload-candidates.cpp:18:8: note: candidate template ignored: invalid explicitly-specified argument for template parameter 'I' void get(const T&); ^ test/SemaTemplate/overload-candidates.cpp:20:8: note: candidate template ignored: invalid explicitly-specified argument for 1st template parameter void get(const T&); ^ llvm-svn: 103344
2010-05-09 03:15:54 +08:00
Builder) || Trap.hasErrorOccurred()) {
Remove broken support for variadic templates, along with the various abstractions (e.g., TemplateArgumentListBuilder) that were designed to support variadic templates. Only a few remnants of variadic templates remain, in the parser (parsing template type parameter packs), AST (template type parameter pack bits and TemplateArgument::Pack), and Sema; these are expected to be used in a future implementation of variadic templates. But don't get too excited about that happening now. llvm-svn: 118385
2010-11-08 07:05:16 +08:00
unsigned Index = Builder.size();
Be more careful about picking a template parameter when we fail to substitute explicit template arguments into a function template llvm-svn: 103369
2010-05-09 09:26:06 +08:00
if (Index >= TemplateParams->size())
Index = TemplateParams->size() - 1;
Info.Param = makeTemplateParameter(TemplateParams->getParam(Index));
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
return TDK_InvalidExplicitArguments;
Improve overload-candidate diagnostic for a function template that failed because the explicitly-specified template arguments did not match its template parameters, e.g., test/SemaTemplate/overload-candidates.cpp:18:8: note: candidate template ignored: invalid explicitly-specified argument for template parameter 'I' void get(const T&); ^ test/SemaTemplate/overload-candidates.cpp:20:8: note: candidate template ignored: invalid explicitly-specified argument for 1st template parameter void get(const T&); ^ llvm-svn: 103344
2010-05-09 03:15:54 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
// Form the template argument list from the explicitly-specified
// template arguments.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
TemplateArgumentList *ExplicitArgumentList
Remove broken support for variadic templates, along with the various abstractions (e.g., TemplateArgumentListBuilder) that were designed to support variadic templates. Only a few remnants of variadic templates remain, in the parser (parsing template type parameter packs), AST (template type parameter pack bits and TemplateArgument::Pack), and Sema; these are expected to be used in a future implementation of variadic templates. But don't get too excited about that happening now. llvm-svn: 118385
2010-11-08 07:05:16 +08:00
= TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size());
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
Info.reset(ExplicitArgumentList);
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Enter the context of the declared function template when performing deduction and the final substitution, but not while substituting the explicit template arguments. Fixes rdar://problem/8537391 llvm-svn: 116332
2010-10-13 03:40:14 +08:00
// Template argument deduction and the final substitution should be
// done in the context of the templated declaration. Explicit
// argument substitution, on the other hand, needs to happen in the
// calling context.
ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl());
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// If we deduced template arguments for a template parameter pack,
Work-in-progress implementation of C++0x [temp.arg.explicit]p9, which allows an argument pack determines via explicit specification of function template arguments to be extended by further, deduced arguments. For example: template<class ... Types> void f(Types ... values); void g() { f<int*, float*>(0, 0, 0); // Types is deduced to the sequence int*, float*, int } There are a number of FIXMEs in here that indicate places where we need to implement + test retained expansions, plus a number of other places in deduction where we need to correctly cope with the explicitly-specified arguments when deducing an argument pack. Furthermore, it appears that the RecursiveASTVisitor needs to be auditied; it's missing some traversals (especially w.r.t. template arguments) that cause it not to find unexpanded parameter packs when it should. The good news, however, is that the tr1::tuple implementation now works fully, and the tr1::bind example (both from N2080) is actually working now. llvm-svn: 123163
2011-01-10 15:32:04 +08:00
// note that the template argument pack is partially substituted and record
// the explicit template arguments. They'll be used as part of deduction
// for this template parameter pack.
for (unsigned I = 0, N = Builder.size(); I != N; ++I) {
const TemplateArgument &Arg = Builder[I];
if (Arg.getKind() == TemplateArgument::Pack) {
CurrentInstantiationScope->SetPartiallySubstitutedPack(
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
TemplateParams->getParam(I),
Work-in-progress implementation of C++0x [temp.arg.explicit]p9, which allows an argument pack determines via explicit specification of function template arguments to be extended by further, deduced arguments. For example: template<class ... Types> void f(Types ... values); void g() { f<int*, float*>(0, 0, 0); // Types is deduced to the sequence int*, float*, int } There are a number of FIXMEs in here that indicate places where we need to implement + test retained expansions, plus a number of other places in deduction where we need to correctly cope with the explicitly-specified arguments when deducing an argument pack. Furthermore, it appears that the RecursiveASTVisitor needs to be auditied; it's missing some traversals (especially w.r.t. template arguments) that cause it not to find unexpanded parameter packs when it should. The good news, however, is that the tr1::tuple implementation now works fully, and the tr1::bind example (both from N2080) is actually working now. llvm-svn: 123163
2011-01-10 15:32:04 +08:00
Arg.pack_begin(),
Arg.pack_size());
break;
}
}
Track whether a function type has a trailing return type as type sugar. Use this to pretty-print such function types better, and to fix a case where we were not instantiating templates in lexical order. In passing, move the Variadic bit from Type's bitfields to FunctionProtoType to get the Type bitfields down to 32 bits. Also ensure that we always substitute the return type of a function when substituting explicitly-specified arguments, since that can cause us to bail out with a SFINAE error before we hit a hard error in parameter substitution. llvm-svn: 150241
2012-02-10 17:58:53 +08:00
const FunctionProtoType *Proto
= Function->getType()->getAs<FunctionProtoType>();
assert(Proto && "Function template does not have a prototype?");
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
// Instantiate the types of each of the function parameters given the
Track whether a function type has a trailing return type as type sugar. Use this to pretty-print such function types better, and to fix a case where we were not instantiating templates in lexical order. In passing, move the Variadic bit from Type's bitfields to FunctionProtoType to get the Type bitfields down to 32 bits. Also ensure that we always substitute the return type of a function when substituting explicitly-specified arguments, since that can cause us to bail out with a SFINAE error before we hit a hard error in parameter substitution. llvm-svn: 150241
2012-02-10 17:58:53 +08:00
// explicitly-specified template arguments. If the function has a trailing
// return type, substitute it after the arguments to ensure we substitute
// in lexical order.
Implement C++11 [expr.prim.general]p3, which permits the use of 'this' in the declaration of a non-static member function after the (optional) cv-qualifier-seq, which in practice means in the exception specification and late-specified return type. The new scheme here used to manage 'this' outside of a member function scope is more general than the Scope-based mechanism previously used for non-static data member initializers and late-parsesd attributes, because it can also handle the cv-qualifiers on the member function. Note, however, that a separate pass is required for static member functions to determine whether 'this' was used, because we might not know that we have a static function until after declaration matching. Finally, this introduces name mangling for 'this' and for the implicit 'this', which is intended to match GCC's mangling. Independent verification for the new mangling test case would be appreciated. Fixes PR10036 and PR12450. llvm-svn: 154799
2012-04-16 15:05:22 +08:00
if (Proto->hasTrailingReturn()) {
if (SubstParmTypes(Function->getLocation(),
Function->param_begin(), Function->getNumParams(),
MultiLevelTemplateArgumentList(*ExplicitArgumentList),
ParamTypes))
return TDK_SubstitutionFailure;
}
Track whether a function type has a trailing return type as type sugar. Use this to pretty-print such function types better, and to fix a case where we were not instantiating templates in lexical order. In passing, move the Variadic bit from Type's bitfields to FunctionProtoType to get the Type bitfields down to 32 bits. Also ensure that we always substitute the return type of a function when substituting explicitly-specified arguments, since that can cause us to bail out with a SFINAE error before we hit a hard error in parameter substitution. llvm-svn: 150241
2012-02-10 17:58:53 +08:00
// Instantiate the return type.
Implement C++11 [expr.prim.general]p3, which permits the use of 'this' in the declaration of a non-static member function after the (optional) cv-qualifier-seq, which in practice means in the exception specification and late-specified return type. The new scheme here used to manage 'this' outside of a member function scope is more general than the Scope-based mechanism previously used for non-static data member initializers and late-parsesd attributes, because it can also handle the cv-qualifiers on the member function. Note, however, that a separate pass is required for static member functions to determine whether 'this' was used, because we might not know that we have a static function until after declaration matching. Finally, this introduces name mangling for 'this' and for the implicit 'this', which is intended to match GCC's mangling. Independent verification for the new mangling test case would be appreciated. Fixes PR10036 and PR12450. llvm-svn: 154799
2012-04-16 15:05:22 +08:00
QualType ResultType;
{
// C++11 [expr.prim.general]p3:
// If a declaration declares a member function or member function
// template of a class X, the expression this is a prvalue of type
// "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq
// and the end of the function-definition, member-declarator, or
// declarator.
unsigned ThisTypeQuals = 0;
CXXRecordDecl *ThisContext = 0;
if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) {
ThisContext = Method->getParent();
ThisTypeQuals = Method->getTypeQualifiers();
}
CXXThisScopeRAII ThisScope(*this, ThisContext, ThisTypeQuals,
s/CPlusPlus0x/CPlusPlus11/g llvm-svn: 171367
2013-01-02 19:42:31 +08:00
getLangOpts().CPlusPlus11);
Implement C++11 [expr.prim.general]p3, which permits the use of 'this' in the declaration of a non-static member function after the (optional) cv-qualifier-seq, which in practice means in the exception specification and late-specified return type. The new scheme here used to manage 'this' outside of a member function scope is more general than the Scope-based mechanism previously used for non-static data member initializers and late-parsesd attributes, because it can also handle the cv-qualifiers on the member function. Note, however, that a separate pass is required for static member functions to determine whether 'this' was used, because we might not know that we have a static function until after declaration matching. Finally, this introduces name mangling for 'this' and for the implicit 'this', which is intended to match GCC's mangling. Independent verification for the new mangling test case would be appreciated. Fixes PR10036 and PR12450. llvm-svn: 154799
2012-04-16 15:05:22 +08:00
ResultType = SubstType(Proto->getResultType(),
MultiLevelTemplateArgumentList(*ExplicitArgumentList),
Function->getTypeSpecStartLoc(),
Function->getDeclName());
if (ResultType.isNull() || Trap.hasErrorOccurred())
return TDK_SubstitutionFailure;
}
Track whether a function type has a trailing return type as type sugar. Use this to pretty-print such function types better, and to fix a case where we were not instantiating templates in lexical order. In passing, move the Variadic bit from Type's bitfields to FunctionProtoType to get the Type bitfields down to 32 bits. Also ensure that we always substitute the return type of a function when substituting explicitly-specified arguments, since that can cause us to bail out with a SFINAE error before we hit a hard error in parameter substitution. llvm-svn: 150241
2012-02-10 17:58:53 +08:00
// Instantiate the types of each of the function parameters given the
// explicitly-specified template arguments if we didn't do so earlier.
if (!Proto->hasTrailingReturn() &&
SubstParmTypes(Function->getLocation(),
Function->param_begin(), Function->getNumParams(),
MultiLevelTemplateArgumentList(*ExplicitArgumentList),
ParamTypes))
return TDK_SubstitutionFailure;
if (FunctionType) {
ArrayRef-ize ASTContext::getFunctionType and Sema::BuildFunctionType. No (intended) functionality change. llvm-svn: 176726
2013-03-09 05:51:21 +08:00
*FunctionType = BuildFunctionType(ResultType, ParamTypes,
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
Function->getLocation(),
Preserve calling convention etc. across template instantiations. llvm-svn: 110304
2010-08-05 10:54:05 +08:00
Function->getDeclName(),
Sema: Preserve attributes on parameters in instantiated function templates. This was causing correctness issues for ARC and the static analyzer when a function template has "consumed" Objective-C object parameters (i.e. parameters that will be released by the function before returning). The fix is threefold: (1) Actually copy over the attributes from old ParmVarDecls to new ones. (2) Have Sema::BuildFunctionType only work for building FunctionProtoTypes, which it was doing anyway. This allows us to pass an ExtProtoInfo instead of a plain ExtInfo and several flags. (3) Drop param attributes as part of StripImplicitInstantiation, which is used when an implicit instantiation is followed by an explicit one. <rdar://problem/12685622> llvm-svn: 176728
2013-03-09 06:25:36 +08:00
Proto->getExtProtoInfo());
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
if (FunctionType->isNull() || Trap.hasErrorOccurred())
return TDK_SubstitutionFailure;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
// C++ [temp.arg.explicit]p2:
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
// Trailing template arguments that can be deduced (14.8.2) may be
// omitted from the list of explicit template-arguments. If all of the
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
// template arguments can be deduced, they may all be omitted; in this
// case, the empty template argument list <> itself may also be omitted.
//
Work-in-progress implementation of C++0x [temp.arg.explicit]p9, which allows an argument pack determines via explicit specification of function template arguments to be extended by further, deduced arguments. For example: template<class ... Types> void f(Types ... values); void g() { f<int*, float*>(0, 0, 0); // Types is deduced to the sequence int*, float*, int } There are a number of FIXMEs in here that indicate places where we need to implement + test retained expansions, plus a number of other places in deduction where we need to correctly cope with the explicitly-specified arguments when deducing an argument pack. Furthermore, it appears that the RecursiveASTVisitor needs to be auditied; it's missing some traversals (especially w.r.t. template arguments) that cause it not to find unexpanded parameter packs when it should. The good news, however, is that the tr1::tuple implementation now works fully, and the tr1::bind example (both from N2080) is actually working now. llvm-svn: 123163
2011-01-10 15:32:04 +08:00
// Take all of the explicitly-specified arguments and put them into
// the set of deduced template arguments. Explicitly-specified
// parameter packs, however, will be set to NULL since the deduction
// mechanisms handle explicitly-specified argument packs directly.
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
Deduced.reserve(TemplateParams->size());
Work-in-progress implementation of C++0x [temp.arg.explicit]p9, which allows an argument pack determines via explicit specification of function template arguments to be extended by further, deduced arguments. For example: template<class ... Types> void f(Types ... values); void g() { f<int*, float*>(0, 0, 0); // Types is deduced to the sequence int*, float*, int } There are a number of FIXMEs in here that indicate places where we need to implement + test retained expansions, plus a number of other places in deduction where we need to correctly cope with the explicitly-specified arguments when deducing an argument pack. Furthermore, it appears that the RecursiveASTVisitor needs to be auditied; it's missing some traversals (especially w.r.t. template arguments) that cause it not to find unexpanded parameter packs when it should. The good news, however, is that the tr1::tuple implementation now works fully, and the tr1::bind example (both from N2080) is actually working now. llvm-svn: 123163
2011-01-10 15:32:04 +08:00
for (unsigned I = 0, N = ExplicitArgumentList->size(); I != N; ++I) {
const TemplateArgument &Arg = ExplicitArgumentList->get(I);
if (Arg.getKind() == TemplateArgument::Pack)
Deduced.push_back(DeducedTemplateArgument());
else
Deduced.push_back(Arg);
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
return TDK_Success;
}
Factor the checking of the deduced argument type against the actual argument type for C++ [temp.deduct.call]p4 out of Sema::FinishTemplateArgumentDeduction(). No functionality change. llvm-svn: 133237
2011-06-17 13:18:17 +08:00
/// \brief Check whether the deduced argument type for a call to a function
/// template matches the actual argument type per C++ [temp.deduct.call]p4.
static bool
CheckOriginalCallArgDeduction(Sema &S, Sema::OriginalCallArg OriginalArg,
QualType DeducedA) {
ASTContext &Context = S.Context;
QualType A = OriginalArg.OriginalArgType;
QualType OriginalParamType = OriginalArg.OriginalParamType;
// Check for type equality (top-level cv-qualifiers are ignored).
if (Context.hasSameUnqualifiedType(A, DeducedA))
return false;
// Strip off references on the argument types; they aren't needed for
// the following checks.
if (const ReferenceType *DeducedARef = DeducedA->getAs<ReferenceType>())
DeducedA = DeducedARef->getPointeeType();
if (const ReferenceType *ARef = A->getAs<ReferenceType>())
A = ARef->getPointeeType();
// C++ [temp.deduct.call]p4:
// [...] However, there are three cases that allow a difference:
// - If the original P is a reference type, the deduced A (i.e., the
// type referred to by the reference) can be more cv-qualified than
// the transformed A.
if (const ReferenceType *OriginalParamRef
= OriginalParamType->getAs<ReferenceType>()) {
// We don't want to keep the reference around any more.
OriginalParamType = OriginalParamRef->getPointeeType();
Qualifiers AQuals = A.getQualifiers();
Qualifiers DeducedAQuals = DeducedA.getQualifiers();
When performing the deduced/actual argument type check for C++ [temp.deduct.call]p4 under Objective-C++ ARC, make sure to adjust the qualifiers to introduce the implicit strong lifetime when needed. Fixes <rdar://problem/11825671>. llvm-svn: 160412
2012-07-18 08:14:59 +08:00
// Under Objective-C++ ARC, the deduced type may have implicitly been
// given strong lifetime. If so, update the original qualifiers to
// include this strong lifetime.
if (S.getLangOpts().ObjCAutoRefCount &&
DeducedAQuals.getObjCLifetime() == Qualifiers::OCL_Strong &&
AQuals.getObjCLifetime() == Qualifiers::OCL_None) {
AQuals.setObjCLifetime(Qualifiers::OCL_Strong);
}
Factor the checking of the deduced argument type against the actual argument type for C++ [temp.deduct.call]p4 out of Sema::FinishTemplateArgumentDeduction(). No functionality change. llvm-svn: 133237
2011-06-17 13:18:17 +08:00
if (AQuals == DeducedAQuals) {
// Qualifiers match; there's nothing to do.
} else if (!DeducedAQuals.compatiblyIncludes(AQuals)) {
Fix refactoro, silencing an MSVC warning. Thanks, Francois. llvm-svn: 133257
2011-06-17 22:36:00 +08:00
return true;
Factor the checking of the deduced argument type against the actual argument type for C++ [temp.deduct.call]p4 out of Sema::FinishTemplateArgumentDeduction(). No functionality change. llvm-svn: 133237
2011-06-17 13:18:17 +08:00
} else {
// Qualifiers are compatible, so have the argument type adopt the
// deduced argument type's qualifiers as if we had performed the
// qualification conversion.
A = Context.getQualifiedType(A.getUnqualifiedType(), DeducedAQuals);
}
}
// - The transformed A can be another pointer or pointer to member
// type that can be converted to the deduced A via a qualification
// conversion.
Accept no-return stripping conversions for pointer type arguments after deducing template parameter types. Recently Clang began enforcing the more strict checking that the argument type and the deduced function parameter type (after substitution) match, but that only consideres qualification conversions. One problem with this patch is that we check noreturn conversions and qualification conversions independently. If a valid conversion would require *both*, perhaps interleaved with each other, it will be rejected. If this actually occurs (I'm not yet sure it does) and is in fact a problem (I'm not yet sure it is), there is a FIXME to implement more intelligent conversion checking. However, this step at least allows Clang to resume accepting valid code we're seeing in the wild. llvm-svn: 133327
2011-06-18 09:19:03 +08:00
//
// Also allow conversions which merely strip [[noreturn]] from function types
// (recursively) as an extension.
// FIXME: Currently, this doesn't place nicely with qualfication conversions.
Factor the checking of the deduced argument type against the actual argument type for C++ [temp.deduct.call]p4 out of Sema::FinishTemplateArgumentDeduction(). No functionality change. llvm-svn: 133237
2011-06-17 13:18:17 +08:00
bool ObjCLifetimeConversion = false;
Accept no-return stripping conversions for pointer type arguments after deducing template parameter types. Recently Clang began enforcing the more strict checking that the argument type and the deduced function parameter type (after substitution) match, but that only consideres qualification conversions. One problem with this patch is that we check noreturn conversions and qualification conversions independently. If a valid conversion would require *both*, perhaps interleaved with each other, it will be rejected. If this actually occurs (I'm not yet sure it does) and is in fact a problem (I'm not yet sure it is), there is a FIXME to implement more intelligent conversion checking. However, this step at least allows Clang to resume accepting valid code we're seeing in the wild. llvm-svn: 133327
2011-06-18 09:19:03 +08:00
QualType ResultTy;
Factor the checking of the deduced argument type against the actual argument type for C++ [temp.deduct.call]p4 out of Sema::FinishTemplateArgumentDeduction(). No functionality change. llvm-svn: 133237
2011-06-17 13:18:17 +08:00
if ((A->isAnyPointerType() || A->isMemberPointerType()) &&
Accept no-return stripping conversions for pointer type arguments after deducing template parameter types. Recently Clang began enforcing the more strict checking that the argument type and the deduced function parameter type (after substitution) match, but that only consideres qualification conversions. One problem with this patch is that we check noreturn conversions and qualification conversions independently. If a valid conversion would require *both*, perhaps interleaved with each other, it will be rejected. If this actually occurs (I'm not yet sure it does) and is in fact a problem (I'm not yet sure it is), there is a FIXME to implement more intelligent conversion checking. However, this step at least allows Clang to resume accepting valid code we're seeing in the wild. llvm-svn: 133327
2011-06-18 09:19:03 +08:00
(S.IsQualificationConversion(A, DeducedA, false,
ObjCLifetimeConversion) ||
S.IsNoReturnConversion(A, DeducedA, ResultTy)))
Factor the checking of the deduced argument type against the actual argument type for C++ [temp.deduct.call]p4 out of Sema::FinishTemplateArgumentDeduction(). No functionality change. llvm-svn: 133237
2011-06-17 13:18:17 +08:00
return false;
// - If P is a class and P has the form simple-template-id, then the
// transformed A can be a derived class of the deduced A. [...]
// [...] Likewise, if P is a pointer to a class of the form
// simple-template-id, the transformed A can be a pointer to a
// derived class pointed to by the deduced A.
if (const PointerType *OriginalParamPtr
= OriginalParamType->getAs<PointerType>()) {
if (const PointerType *DeducedAPtr = DeducedA->getAs<PointerType>()) {
if (const PointerType *APtr = A->getAs<PointerType>()) {
if (A->getPointeeType()->isRecordType()) {
OriginalParamType = OriginalParamPtr->getPointeeType();
DeducedA = DeducedAPtr->getPointeeType();
A = APtr->getPointeeType();
}
}
}
}
if (Context.hasSameUnqualifiedType(A, DeducedA))
return false;
if (A->isRecordType() && isSimpleTemplateIdType(OriginalParamType) &&
S.IsDerivedFrom(A, DeducedA))
return false;
return true;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
/// \brief Finish template argument deduction for a function template,
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
/// checking the deduced template arguments for completeness and forming
/// the function template specialization.
Implement the consistency checking for C++ [temp.deduct.call]p3, which checks that the deduced argument type for a function call matches the actual argument type provided. The only place we've found where the consistency checking should actually cause template argument deduction failure is due to qualifier differences that don't fall into the realm of qualification conversions (which are *not* checked when we initially perform deduction). However, we're performing the full checking as specified in the standard to ensure that no other cases exist. Fixes PR9233 / <rdar://problem/9039590>. llvm-svn: 133163
2011-06-17 00:50:48 +08:00
///
/// \param OriginalCallArgs If non-NULL, the original call arguments against
/// which the deduced argument types should be compared.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Sema::TemplateDeductionResult
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
Sema::FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate,
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
After performing template argument deduction for a function template, check deduced non-type template arguments and template template arguments against the template parameters for which they were deduced, performing conversions as appropriate so that deduced template arguments get the same treatment as explicitly-specified template arguments. This is the bulk of PR6723. Also keep track of whether deduction of a non-type template argument came from an array bound (vs. anywhere else). With this information, we enforce C++ [temp.deduct.type]p17, which requires exact type matches when deduction deduces a non-type template argument from something that is not an array bound. Finally, when in a SFINAE context, translate the "zero sized arrays are an extension" extension diagnostic into a hard error (for better standard conformance), which was a minor part of PR6723. llvm-svn: 99734
2010-03-28 10:42:43 +08:00
unsigned NumExplicitlySpecified,
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
FunctionDecl *&Specialization,
Implement the consistency checking for C++ [temp.deduct.call]p3, which checks that the deduced argument type for a function call matches the actual argument type provided. The only place we've found where the consistency checking should actually cause template argument deduction failure is due to qualifier differences that don't fall into the realm of qualification conversions (which are *not* checked when we initially perform deduction). However, we're performing the full checking as specified in the standard to ensure that no other cases exist. Fixes PR9233 / <rdar://problem/9039590>. llvm-svn: 133163
2011-06-17 00:50:48 +08:00
TemplateDeductionInfo &Info,
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVectorImpl<OriginalCallArg> const *OriginalCallArgs) {
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
TemplateParameterList *TemplateParams
= FunctionTemplate->getTemplateParameters();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Make sure template argument deduction is consistently performed in an unevaluated context. llvm-svn: 150049
2012-02-08 11:07:05 +08:00
// Unevaluated SFINAE context.
EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
Implement support for default template arguments of function templates. llvm-svn: 89874
2009-11-26 02:55:14 +08:00
SFINAETrap Trap(*this);
// Enter a new template instantiation context while we instantiate the
// actual function declaration.
PR13365: Fix code which was trying to treat an array of DeducedTemplateArgument as an array of its base class TemplateArgument. Switch the const TemplateArgument* parameters of InstantiatingTemplate's constructors to ArrayRef<TemplateArgument> to prevent this from happening again in the future. llvm-svn: 160245
2012-07-16 09:09:10 +08:00
SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end());
Implement support for default template arguments of function templates. llvm-svn: 89874
2009-11-26 02:55:14 +08:00
InstantiatingTemplate Inst(*this, FunctionTemplate->getLocation(),
PR13365: Fix code which was trying to treat an array of DeducedTemplateArgument as an array of its base class TemplateArgument. Switch the const TemplateArgument* parameters of InstantiatingTemplate's constructors to ArrayRef<TemplateArgument> to prevent this from happening again in the future. llvm-svn: 160245
2012-07-16 09:09:10 +08:00
FunctionTemplate, DeducedArgs,
Introduce support for emitting diagnostics (warnings + their notes) that are suppressed during template argument deduction. This change queues diagnostics computed during template argument deduction. Then, if the resulting function template specialization or partial specialization is chosen by overload resolution or partial ordering (respectively), we will emit the queued diagnostics at that point. This addresses most of PR6784. However, the check for unnamed/local template arguments (which existed before this change) is still only skin-deep, and needs to be extended to look deeper into types. It must be improved to finish PR6784. llvm-svn: 116373
2010-10-13 07:32:35 +08:00
ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution,
Info);
Implement support for default template arguments of function templates. llvm-svn: 89874
2009-11-26 02:55:14 +08:00
if (Inst)
return TDK_InstantiationDepth;
Access-check during template argument deduction from the context of the template decl itself, not its context. Testcase to follow; fixes selfhost. llvm-svn: 102578
2010-04-29 09:18:58 +08:00
ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl());
Properly switch into the declaring scope of a template when performing template argument deduction or (more importantly) the final substitution required by such deduction. Makes access control magically work in these cases. Fixes PR6967. llvm-svn: 102572
2010-04-29 08:35:03 +08:00
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
// C++ [temp.deduct.type]p2:
// [...] or if any template argument remains neither deduced nor
// explicitly specified, template argument deduction fails.
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<TemplateArgument, 4> Builder;
Improve the checking of deduced template arguments stored within template argument packs when finishing template argument deduction for a function template llvm-svn: 122843
2011-01-05 06:13:36 +08:00
for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
NamedDecl *Param = TemplateParams->getParam(I);
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement support for default template arguments of function templates. llvm-svn: 89874
2009-11-26 02:55:14 +08:00
if (!Deduced[I].isNull()) {
When finalizing a function template specialization following template argument deduction, make sure to check the correctness of deduced template type arguments (which we had previously skipped) along with other kinds of template arguments. This fixes part of PR6784, but we're still swallowing the extension warning about unnamed/local template arguments. llvm-svn: 116327
2010-10-13 02:51:08 +08:00
if (I < NumExplicitlySpecified) {
After performing template argument deduction for a function template, check deduced non-type template arguments and template template arguments against the template parameters for which they were deduced, performing conversions as appropriate so that deduced template arguments get the same treatment as explicitly-specified template arguments. This is the bulk of PR6723. Also keep track of whether deduction of a non-type template argument came from an array bound (vs. anywhere else). With this information, we enforce C++ [temp.deduct.type]p17, which requires exact type matches when deduction deduces a non-type template argument from something that is not an array bound. Finally, when in a SFINAE context, translate the "zero sized arrays are an extension" extension diagnostic into a hard error (for better standard conformance), which was a minor part of PR6723. llvm-svn: 99734
2010-03-28 10:42:43 +08:00
// We have already fully type-checked and converted this
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// argument, because it was explicitly-specified. Just record the
When finalizing a function template specialization following template argument deduction, make sure to check the correctness of deduced template type arguments (which we had previously skipped) along with other kinds of template arguments. This fixes part of PR6784, but we're still swallowing the extension warning about unnamed/local template arguments. llvm-svn: 116327
2010-10-13 02:51:08 +08:00
// presence of this argument.
Remove broken support for variadic templates, along with the various abstractions (e.g., TemplateArgumentListBuilder) that were designed to support variadic templates. Only a few remnants of variadic templates remain, in the parser (parsing template type parameter packs), AST (template type parameter pack bits and TemplateArgument::Pack), and Sema; these are expected to be used in a future implementation of variadic templates. But don't get too excited about that happening now. llvm-svn: 118385
2010-11-08 07:05:16 +08:00
Builder.push_back(Deduced[I]);
After performing template argument deduction for a function template, check deduced non-type template arguments and template template arguments against the template parameters for which they were deduced, performing conversions as appropriate so that deduced template arguments get the same treatment as explicitly-specified template arguments. This is the bulk of PR6723. Also keep track of whether deduction of a non-type template argument came from an array bound (vs. anywhere else). With this information, we enforce C++ [temp.deduct.type]p17, which requires exact type matches when deduction deduces a non-type template argument from something that is not an array bound. Finally, when in a SFINAE context, translate the "zero sized arrays are an extension" extension diagnostic into a hard error (for better standard conformance), which was a minor part of PR6723. llvm-svn: 99734
2010-03-28 10:42:43 +08:00
continue;
}
// We have deduced this argument, so it still needs to be
// checked and converted.
// First, for a non-type template parameter type that is
// initialized by a declaration, we need the type of the
// corresponding non-type template parameter.
QualType NTTPType;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
if (NonTypeTemplateParmDecl *NTTP
= dyn_cast<NonTypeTemplateParmDecl>(Param)) {
Improve the checking of deduced template arguments stored within template argument packs when finishing template argument deduction for a function template llvm-svn: 122843
2011-01-05 06:13:36 +08:00
NTTPType = NTTP->getType();
if (NTTPType->isDependentType()) {
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack,
Improve the checking of deduced template arguments stored within template argument packs when finishing template argument deduction for a function template llvm-svn: 122843
2011-01-05 06:13:36 +08:00
Builder.data(), Builder.size());
NTTPType = SubstType(NTTPType,
MultiLevelTemplateArgumentList(TemplateArgs),
NTTP->getLocation(),
NTTP->getDeclName());
if (NTTPType.isNull()) {
Info.Param = makeTemplateParameter(Param);
// FIXME: These template arguments are temporary. Free them!
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Info.reset(TemplateArgumentList::CreateCopy(Context,
Builder.data(),
Improve the checking of deduced template arguments stored within template argument packs when finishing template argument deduction for a function template llvm-svn: 122843
2011-01-05 06:13:36 +08:00
Builder.size()));
return TDK_SubstitutionFailure;
After performing template argument deduction for a function template, check deduced non-type template arguments and template template arguments against the template parameters for which they were deduced, performing conversions as appropriate so that deduced template arguments get the same treatment as explicitly-specified template arguments. This is the bulk of PR6723. Also keep track of whether deduction of a non-type template argument came from an array bound (vs. anywhere else). With this information, we enforce C++ [temp.deduct.type]p17, which requires exact type matches when deduction deduces a non-type template argument from something that is not an array bound. Finally, when in a SFINAE context, translate the "zero sized arrays are an extension" extension diagnostic into a hard error (for better standard conformance), which was a minor part of PR6723. llvm-svn: 99734
2010-03-28 10:42:43 +08:00
}
}
}
Improve the checking of deduced template arguments stored within template argument packs when finishing template argument deduction for a function template llvm-svn: 122843
2011-01-05 06:13:36 +08:00
if (ConvertDeducedTemplateArgument(*this, Param, Deduced[I],
Implement support for non-type template parameter packs whose type is a pack expansion, e.g., the parameter pack Values in: template<typename ...Types> struct Outer { template<Types ...Values> struct Inner; }; This new implementation approach introduces the notion of an "expanded" non-type template parameter pack, for which we have already expanded the types of the parameter pack (to, say, "int*, float*", for Outer<int*, float*>) but have not yet expanded the values. Aside from creating these expanded non-type template parameter packs, this patch updates template argument checking and non-type template parameter pack instantiation to make use of the appropriate types in the parameter pack. llvm-svn: 123845
2011-01-20 04:10:05 +08:00
FunctionTemplate, NTTPType, 0, Info,
Improve our handling of non-type template parameters in partial specializations. We weren't dealing with any of the cases where the type of the non-type template argument differs from the type of the corresponding template parameter in the primary template. We would think that the template parameter in the partial specialization was not deducible (and warn about it, incorrectly), then fail to convert a deduced parameter to the type of the template parameter in the partial specialization (which may involve truncation, among other things). Fixes PR8905. llvm-svn: 122851
2011-01-05 07:35:54 +08:00
true, Builder)) {
Improve the checking of deduced template arguments stored within template argument packs when finishing template argument deduction for a function template llvm-svn: 122843
2011-01-05 06:13:36 +08:00
Info.Param = makeTemplateParameter(Param);
Remove broken support for variadic templates, along with the various abstractions (e.g., TemplateArgumentListBuilder) that were designed to support variadic templates. Only a few remnants of variadic templates remain, in the parser (parsing template type parameter packs), AST (template type parameter pack bits and TemplateArgument::Pack), and Sema; these are expected to be used in a future implementation of variadic templates. But don't get too excited about that happening now. llvm-svn: 118385
2010-11-08 07:05:16 +08:00
// FIXME: These template arguments are temporary. Free them!
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(),
Builder.size()));
After performing template argument deduction for a function template, check deduced non-type template arguments and template template arguments against the template parameters for which they were deduced, performing conversions as appropriate so that deduced template arguments get the same treatment as explicitly-specified template arguments. This is the bulk of PR6723. Also keep track of whether deduction of a non-type template argument came from an array bound (vs. anywhere else). With this information, we enforce C++ [temp.deduct.type]p17, which requires exact type matches when deduction deduces a non-type template argument from something that is not an array bound. Finally, when in a SFINAE context, translate the "zero sized arrays are an extension" extension diagnostic into a hard error (for better standard conformance), which was a minor part of PR6723. llvm-svn: 99734
2010-03-28 10:42:43 +08:00
return TDK_SubstitutionFailure;
}
Implement support for default template arguments of function templates. llvm-svn: 89874
2009-11-26 02:55:14 +08:00
continue;
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement the part of C++0x [temp.arg.explicit]p3 that pertains to parameter packs. In particular, a parameter pack not otherwise deduced is deduced to an empty parameter pack. The C++0x wording here is a bit unfortunate; this should really only apply to function templates, and it mentions "trailing" parameter packs, which doesn't really make sense in the context of function templates. Will file a core issue separately. llvm-svn: 122463
2010-12-23 09:52:01 +08:00
// C++0x [temp.arg.explicit]p3:
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// A trailing template parameter pack (14.5.3) not otherwise deduced will
Implement the part of C++0x [temp.arg.explicit]p3 that pertains to parameter packs. In particular, a parameter pack not otherwise deduced is deduced to an empty parameter pack. The C++0x wording here is a bit unfortunate; this should really only apply to function templates, and it mentions "trailing" parameter packs, which doesn't really make sense in the context of function templates. Will file a core issue separately. llvm-svn: 122463
2010-12-23 09:52:01 +08:00
// be deduced to an empty sequence of template arguments.
// FIXME: Where did the word "trailing" come from?
if (Param->isTemplateParameterPack()) {
Work-in-progress implementation of C++0x [temp.arg.explicit]p9, which allows an argument pack determines via explicit specification of function template arguments to be extended by further, deduced arguments. For example: template<class ... Types> void f(Types ... values); void g() { f<int*, float*>(0, 0, 0); // Types is deduced to the sequence int*, float*, int } There are a number of FIXMEs in here that indicate places where we need to implement + test retained expansions, plus a number of other places in deduction where we need to correctly cope with the explicitly-specified arguments when deducing an argument pack. Furthermore, it appears that the RecursiveASTVisitor needs to be auditied; it's missing some traversals (especially w.r.t. template arguments) that cause it not to find unexpanded parameter packs when it should. The good news, however, is that the tr1::tuple implementation now works fully, and the tr1::bind example (both from N2080) is actually working now. llvm-svn: 123163
2011-01-10 15:32:04 +08:00
// We may have had explicitly-specified template arguments for this
// template parameter pack. If so, our empty deduction extends the
// explicitly-specified set (C++0x [temp.arg.explicit]p9).
const TemplateArgument *ExplicitArgs;
unsigned NumExplicitArgs;
Fix undefined behavior: member function calls where 'this' is a null pointer. llvm-svn: 162430
2012-08-23 14:16:52 +08:00
if (CurrentInstantiationScope &&
CurrentInstantiationScope->getPartiallySubstitutedPack(&ExplicitArgs,
Work-in-progress implementation of C++0x [temp.arg.explicit]p9, which allows an argument pack determines via explicit specification of function template arguments to be extended by further, deduced arguments. For example: template<class ... Types> void f(Types ... values); void g() { f<int*, float*>(0, 0, 0); // Types is deduced to the sequence int*, float*, int } There are a number of FIXMEs in here that indicate places where we need to implement + test retained expansions, plus a number of other places in deduction where we need to correctly cope with the explicitly-specified arguments when deducing an argument pack. Furthermore, it appears that the RecursiveASTVisitor needs to be auditied; it's missing some traversals (especially w.r.t. template arguments) that cause it not to find unexpanded parameter packs when it should. The good news, however, is that the tr1::tuple implementation now works fully, and the tr1::bind example (both from N2080) is actually working now. llvm-svn: 123163
2011-01-10 15:32:04 +08:00
&NumExplicitArgs)
Once we've collected the template arguments for a partially-substituted parameter pack in a template, forget about the partially-substituted parameter pack: it is now completed. Fixes <rdar://problem/12176336>. llvm-svn: 172859
2013-01-19 06:27:09 +08:00
== Param) {
Work-in-progress implementation of C++0x [temp.arg.explicit]p9, which allows an argument pack determines via explicit specification of function template arguments to be extended by further, deduced arguments. For example: template<class ... Types> void f(Types ... values); void g() { f<int*, float*>(0, 0, 0); // Types is deduced to the sequence int*, float*, int } There are a number of FIXMEs in here that indicate places where we need to implement + test retained expansions, plus a number of other places in deduction where we need to correctly cope with the explicitly-specified arguments when deducing an argument pack. Furthermore, it appears that the RecursiveASTVisitor needs to be auditied; it's missing some traversals (especially w.r.t. template arguments) that cause it not to find unexpanded parameter packs when it should. The good news, however, is that the tr1::tuple implementation now works fully, and the tr1::bind example (both from N2080) is actually working now. llvm-svn: 123163
2011-01-10 15:32:04 +08:00
Builder.push_back(TemplateArgument(ExplicitArgs, NumExplicitArgs));
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Once we've collected the template arguments for a partially-substituted parameter pack in a template, forget about the partially-substituted parameter pack: it is now completed. Fixes <rdar://problem/12176336>. llvm-svn: 172859
2013-01-19 06:27:09 +08:00
// Forget the partially-substituted pack; it's substitution is now
// complete.
CurrentInstantiationScope->ResetPartiallySubstitutedPack();
} else {
Builder.push_back(TemplateArgument::getEmptyPack());
}
Implement the part of C++0x [temp.arg.explicit]p3 that pertains to parameter packs. In particular, a parameter pack not otherwise deduced is deduced to an empty parameter pack. The C++0x wording here is a bit unfortunate; this should really only apply to function templates, and it mentions "trailing" parameter packs, which doesn't really make sense in the context of function templates. Will file a core issue separately. llvm-svn: 122463
2010-12-23 09:52:01 +08:00
continue;
}
Implement support for default template arguments of function templates. llvm-svn: 89874
2009-11-26 02:55:14 +08:00
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// Substitute into the default template argument, if available.
Part of PR15673: If a function template has a default argument in which substitution failed, report that as a substitution failure rather than pretending that there was no default argument. The test cases in PR15673 have exposed some pre-existing poor diagnostics here. llvm-svn: 185604
2013-07-04 09:01:24 +08:00
bool HasDefaultArg = false;
Implement support for default template arguments of function templates. llvm-svn: 89874
2009-11-26 02:55:14 +08:00
TemplateArgumentLoc DefArg
= SubstDefaultTemplateArgumentIfAvailable(FunctionTemplate,
FunctionTemplate->getLocation(),
FunctionTemplate->getSourceRange().getEnd(),
Param,
Part of PR15673: If a function template has a default argument in which substitution failed, report that as a substitution failure rather than pretending that there was no default argument. The test cases in PR15673 have exposed some pre-existing poor diagnostics here. llvm-svn: 185604
2013-07-04 09:01:24 +08:00
Builder, HasDefaultArg);
Implement support for default template arguments of function templates. llvm-svn: 89874
2009-11-26 02:55:14 +08:00
// If there was no default argument, deduction is incomplete.
if (DefArg.getArgument().isNull()) {
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
Info.Param = makeTemplateParameter(
Implement support for default template arguments of function templates. llvm-svn: 89874
2009-11-26 02:55:14 +08:00
const_cast<NamedDecl *>(TemplateParams->getParam(I)));
Part of PR15673: If a function template has a default argument in which substitution failed, report that as a substitution failure rather than pretending that there was no default argument. The test cases in PR15673 have exposed some pre-existing poor diagnostics here. llvm-svn: 185604
2013-07-04 09:01:24 +08:00
Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(),
Builder.size()));
return HasDefaultArg ? TDK_SubstitutionFailure : TDK_Incomplete;
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement support for default template arguments of function templates. llvm-svn: 89874
2009-11-26 02:55:14 +08:00
// Check whether we can actually use the default argument.
if (CheckTemplateArgument(Param, DefArg,
FunctionTemplate,
FunctionTemplate->getLocation(),
FunctionTemplate->getSourceRange().getEnd(),
Implement support for non-type template parameter packs whose type is a pack expansion, e.g., the parameter pack Values in: template<typename ...Types> struct Outer { template<Types ...Values> struct Inner; }; This new implementation approach introduces the notion of an "expanded" non-type template parameter pack, for which we have already expanded the types of the parameter pack (to, say, "int*, float*", for Outer<int*, float*>) but have not yet expanded the values. Aside from creating these expanded non-type template parameter packs, this patch updates template argument checking and non-type template parameter pack instantiation to make use of the appropriate types in the parameter pack. llvm-svn: 123845
2011-01-20 04:10:05 +08:00
0, Builder,
When checking the instantiation of a default template argument against the template parameter, perform the checking as a "specified" template argument rather than a "deduced" template argument; the latter implies stricter type checking that is not permitted for default template arguments. Also, cleanup our handling of substitution of explicit template arguments for a function template. We were actually performing some substitution of default arguments at this point! Fixes PR10069. llvm-svn: 132529
2011-06-03 10:59:40 +08:00
CTAK_Specified)) {
Implement support for default template arguments of function templates. llvm-svn: 89874
2009-11-26 02:55:14 +08:00
Info.Param = makeTemplateParameter(
const_cast<NamedDecl *>(TemplateParams->getParam(I)));
Remove broken support for variadic templates, along with the various abstractions (e.g., TemplateArgumentListBuilder) that were designed to support variadic templates. Only a few remnants of variadic templates remain, in the parser (parsing template type parameter packs), AST (template type parameter pack bits and TemplateArgument::Pack), and Sema; these are expected to be used in a future implementation of variadic templates. But don't get too excited about that happening now. llvm-svn: 118385
2010-11-08 07:05:16 +08:00
// FIXME: These template arguments are temporary. Free them!
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(),
Remove broken support for variadic templates, along with the various abstractions (e.g., TemplateArgumentListBuilder) that were designed to support variadic templates. Only a few remnants of variadic templates remain, in the parser (parsing template type parameter packs), AST (template type parameter pack bits and TemplateArgument::Pack), and Sema; these are expected to be used in a future implementation of variadic templates. But don't get too excited about that happening now. llvm-svn: 118385
2010-11-08 07:05:16 +08:00
Builder.size()));
Implement support for default template arguments of function templates. llvm-svn: 89874
2009-11-26 02:55:14 +08:00
return TDK_SubstitutionFailure;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement support for default template arguments of function templates. llvm-svn: 89874
2009-11-26 02:55:14 +08:00
// If we get here, we successfully used the default template argument.
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
// Form the template argument list from the deduced template arguments.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
TemplateArgumentList *DeducedArgumentList
Remove broken support for variadic templates, along with the various abstractions (e.g., TemplateArgumentListBuilder) that were designed to support variadic templates. Only a few remnants of variadic templates remain, in the parser (parsing template type parameter packs), AST (template type parameter pack bits and TemplateArgument::Pack), and Sema; these are expected to be used in a future implementation of variadic templates. But don't get too excited about that happening now. llvm-svn: 118385
2010-11-08 07:05:16 +08:00
= TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size());
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
Info.reset(DeducedArgumentList);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
// Substitute the deduced template arguments into the function template
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
// declaration to produce the function template specialization.
When instantiating a function template specialization following template argument deduction, use the lexical declaration context as the owner for friend function templates. Fixes 2 failures in Boost.Graph. llvm-svn: 102489
2010-04-28 12:52:24 +08:00
DeclContext *Owner = FunctionTemplate->getDeclContext();
if (FunctionTemplate->getFriendObjectKind())
Owner = FunctionTemplate->getLexicalDeclContext();
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
Specialization = cast_or_null<FunctionDecl>(
When instantiating a function template specialization following template argument deduction, use the lexical declaration context as the owner for friend function templates. Fixes 2 failures in Boost.Graph. llvm-svn: 102489
2010-04-28 12:52:24 +08:00
SubstDecl(FunctionTemplate->getTemplatedDecl(), Owner,
Tighten up the conversion from a single-level template argument list to a multi-level template argument list by making it explicit. The forced auditing of callers found a bug in the instantiation of member classes inside member templates. I *love* static type systems. llvm-svn: 80391
2009-08-29 04:50:45 +08:00
MultiLevelTemplateArgumentList(*DeducedArgumentList)));
When we determine that a function template specialization produced as part of template argument deduction is ill-formed, we mark it as invalid and treat it as a deduction failure. If we happen to find that specialization again, treat it as a deduction failure rather than silently building a call to the declaration. Fixes PR11117, a marvelous bug where deduction failed after creating an invalid specialization, causing overload resolution to pick a different candidate. Then we performed a similar overload resolution later, and happily picked the invalid specialization to call... resulting in a silent link failure. llvm-svn: 141809
2011-10-13 04:35:48 +08:00
if (!Specialization || Specialization->isInvalidDecl())
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
return TDK_SubstitutionFailure;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
assert(Specialization->getPrimaryTemplate()->getCanonicalDecl() ==
Add an assertion and a test case, in a fruitless attempt to track down an existing bug llvm-svn: 81885
2009-09-16 02:26:13 +08:00
FunctionTemplate->getCanonicalDecl());
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
// If the template argument list is owned by the function template
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
// specialization, release it.
When printing an overload candidate that failed due to SFINAE, print a specific message that includes the template arguments, e.g., test/SemaTemplate/overload-candidates.cpp:27:20: note: candidate template ignored: substitution failure [with T = int *] typename T::type get_type(const T&); // expected-note{{candidate ... ^ llvm-svn: 103348
2010-05-09 04:07:26 +08:00
if (Specialization->getTemplateSpecializationArgs() == DeducedArgumentList &&
!Trap.hasErrorOccurred())
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
Info.take();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
When we determine that a function template specialization produced as part of template argument deduction is ill-formed, we mark it as invalid and treat it as a deduction failure. If we happen to find that specialization again, treat it as a deduction failure rather than silently building a call to the declaration. Fixes PR11117, a marvelous bug where deduction failed after creating an invalid specialization, causing overload resolution to pick a different candidate. Then we performed a similar overload resolution later, and happily picked the invalid specialization to call... resulting in a silent link failure. llvm-svn: 141809
2011-10-13 04:35:48 +08:00
// There may have been an error that did not prevent us from constructing a
// declaration. Mark the declaration invalid and return with a substitution
// failure.
if (Trap.hasErrorOccurred()) {
Specialization->setInvalidDecl(true);
return TDK_SubstitutionFailure;
}
Implement the consistency checking for C++ [temp.deduct.call]p3, which checks that the deduced argument type for a function call matches the actual argument type provided. The only place we've found where the consistency checking should actually cause template argument deduction failure is due to qualifier differences that don't fall into the realm of qualification conversions (which are *not* checked when we initially perform deduction). However, we're performing the full checking as specified in the standard to ensure that no other cases exist. Fixes PR9233 / <rdar://problem/9039590>. llvm-svn: 133163
2011-06-17 00:50:48 +08:00
if (OriginalCallArgs) {
// C++ [temp.deduct.call]p4:
// In general, the deduction process attempts to find template argument
// values that will make the deduced A identical to A (after the type A
// is transformed as described above). [...]
for (unsigned I = 0, N = OriginalCallArgs->size(); I != N; ++I) {
OriginalCallArg OriginalArg = (*OriginalCallArgs)[I];
unsigned ParamIdx = OriginalArg.ArgIdx;
if (ParamIdx >= Specialization->getNumParams())
continue;
QualType DeducedA = Specialization->getParamDecl(ParamIdx)->getType();
Factor the checking of the deduced argument type against the actual argument type for C++ [temp.deduct.call]p4 out of Sema::FinishTemplateArgumentDeduction(). No functionality change. llvm-svn: 133237
2011-06-17 13:18:17 +08:00
if (CheckOriginalCallArgDeduction(*this, OriginalArg, DeducedA))
return Sema::TDK_SubstitutionFailure;
Implement the consistency checking for C++ [temp.deduct.call]p3, which checks that the deduced argument type for a function call matches the actual argument type provided. The only place we've found where the consistency checking should actually cause template argument deduction failure is due to qualifier differences that don't fall into the realm of qualification conversions (which are *not* checked when we initially perform deduction). However, we're performing the full checking as specified in the standard to ensure that no other cases exist. Fixes PR9233 / <rdar://problem/9039590>. llvm-svn: 133163
2011-06-17 00:50:48 +08:00
}
}
Introduce support for emitting diagnostics (warnings + their notes) that are suppressed during template argument deduction. This change queues diagnostics computed during template argument deduction. Then, if the resulting function template specialization or partial specialization is chosen by overload resolution or partial ordering (respectively), we will emit the queued diagnostics at that point. This addresses most of PR6784. However, the check for unnamed/local template arguments (which existed before this change) is still only skin-deep, and needs to be extended to look deeper into types. It must be improved to finish PR6784. llvm-svn: 116373
2010-10-13 07:32:35 +08:00
// If we suppressed any diagnostics while performing template argument
// deduction, and if we haven't already instantiated this declaration,
// keep track of these diagnostics. They'll be emitted if this specialization
// is actually used.
if (Info.diag_begin() != Info.diag_end()) {
Add typedefs for Densemaps containing SmallVectors to avoid repeating the SmallVector size when creating iterators for the DenseMap. llvm-svn: 185682
2013-07-05 12:33:53 +08:00
SuppressedDiagnosticsMap::iterator
Introduce support for emitting diagnostics (warnings + their notes) that are suppressed during template argument deduction. This change queues diagnostics computed during template argument deduction. Then, if the resulting function template specialization or partial specialization is chosen by overload resolution or partial ordering (respectively), we will emit the queued diagnostics at that point. This addresses most of PR6784. However, the check for unnamed/local template arguments (which existed before this change) is still only skin-deep, and needs to be extended to look deeper into types. It must be improved to finish PR6784. llvm-svn: 116373
2010-10-13 07:32:35 +08:00
Pos = SuppressedDiagnostics.find(Specialization->getCanonicalDecl());
if (Pos == SuppressedDiagnostics.end())
SuppressedDiagnostics[Specialization->getCanonicalDecl()]
.append(Info.diag_begin(), Info.diag_end());
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
}
Introduce support for emitting diagnostics (warnings + their notes) that are suppressed during template argument deduction. This change queues diagnostics computed during template argument deduction. Then, if the resulting function template specialization or partial specialization is chosen by overload resolution or partial ordering (respectively), we will emit the queued diagnostics at that point. This addresses most of PR6784. However, the check for unnamed/local template arguments (which existed before this change) is still only skin-deep, and needs to be extended to look deeper into types. It must be improved to finish PR6784. llvm-svn: 116373
2010-10-13 07:32:35 +08:00
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
return TDK_Success;
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
}
Propagate whether an id-expression is the immediate argument of an '&' expression from the second caller of ActOnIdExpression. Teach template argument deduction that an overloaded id-expression doesn't give a valid type for deduction purposes to a non-static member function unless the expression has the correct syntactic form. Teach ActOnIdExpression that it shouldn't try to create implicit member expressions for '&function', because this isn't a permitted form of use for member functions. Teach CheckAddressOfOperand to diagnose these more carefully. Some of these cases aren't reachable right now because earlier diagnostics interrupt them. llvm-svn: 112258
2010-08-27 17:08:28 +08:00
/// Gets the type of a function for template-argument-deducton
/// purposes when it's considered as part of an overload set.
Implement most of N3638 (return type deduction for normal functions). Missing (somewhat ironically) is support for the new deduction rules in lambda functions, plus PCH support for return type patching. llvm-svn: 181108
2013-05-04 15:00:32 +08:00
static QualType GetTypeOfFunction(Sema &S, const OverloadExpr::FindResult &R,
Implement C++ [temp.deduct.call]p6, template argument deduction for overloaded arguments. Fix a bug where incomplete explicit specializations were being passed through as legitimate. Fix a bug where the absence of an explicit specialization in an overload set was causing overall deduction to fail. Fixes PR6191. llvm-svn: 95052
2010-02-02 10:21:27 +08:00
FunctionDecl *Fn) {
Implement most of N3638 (return type deduction for normal functions). Missing (somewhat ironically) is support for the new deduction rules in lambda functions, plus PCH support for return type patching. llvm-svn: 181108
2013-05-04 15:00:32 +08:00
// We may need to deduce the return type of the function now.
if (S.getLangOpts().CPlusPlus1y && Fn->getResultType()->isUndeducedType() &&
S.DeduceReturnType(Fn, R.Expression->getExprLoc(), /*Diagnose*/false))
return QualType();
Implement C++ [temp.deduct.call]p6, template argument deduction for overloaded arguments. Fix a bug where incomplete explicit specializations were being passed through as legitimate. Fix a bug where the absence of an explicit specialization in an overload set was causing overall deduction to fail. Fixes PR6191. llvm-svn: 95052
2010-02-02 10:21:27 +08:00
if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn))
Propagate whether an id-expression is the immediate argument of an '&' expression from the second caller of ActOnIdExpression. Teach template argument deduction that an overloaded id-expression doesn't give a valid type for deduction purposes to a non-static member function unless the expression has the correct syntactic form. Teach ActOnIdExpression that it shouldn't try to create implicit member expressions for '&function', because this isn't a permitted form of use for member functions. Teach CheckAddressOfOperand to diagnose these more carefully. Some of these cases aren't reachable right now because earlier diagnostics interrupt them. llvm-svn: 112258
2010-08-27 17:08:28 +08:00
if (Method->isInstance()) {
// An instance method that's referenced in a form that doesn't
// look like a member pointer is just invalid.
if (!R.HasFormOfMemberPointer) return QualType();
Implement most of N3638 (return type deduction for normal functions). Missing (somewhat ironically) is support for the new deduction rules in lambda functions, plus PCH support for return type patching. llvm-svn: 181108
2013-05-04 15:00:32 +08:00
return S.Context.getMemberPointerType(Fn->getType(),
S.Context.getTypeDeclType(Method->getParent()).getTypePtr());
Propagate whether an id-expression is the immediate argument of an '&' expression from the second caller of ActOnIdExpression. Teach template argument deduction that an overloaded id-expression doesn't give a valid type for deduction purposes to a non-static member function unless the expression has the correct syntactic form. Teach ActOnIdExpression that it shouldn't try to create implicit member expressions for '&function', because this isn't a permitted form of use for member functions. Teach CheckAddressOfOperand to diagnose these more carefully. Some of these cases aren't reachable right now because earlier diagnostics interrupt them. llvm-svn: 112258
2010-08-27 17:08:28 +08:00
}
if (!R.IsAddressOfOperand) return Fn->getType();
Implement most of N3638 (return type deduction for normal functions). Missing (somewhat ironically) is support for the new deduction rules in lambda functions, plus PCH support for return type patching. llvm-svn: 181108
2013-05-04 15:00:32 +08:00
return S.Context.getPointerType(Fn->getType());
Implement C++ [temp.deduct.call]p6, template argument deduction for overloaded arguments. Fix a bug where incomplete explicit specializations were being passed through as legitimate. Fix a bug where the absence of an explicit specialization in an overload set was causing overall deduction to fail. Fixes PR6191. llvm-svn: 95052
2010-02-02 10:21:27 +08:00
}
/// Apply the deduction rules for overload sets.
///
/// \return the null type if this argument should be treated as an
/// undeduced context
static QualType
ResolveOverloadForDeduction(Sema &S, TemplateParameterList *TemplateParams,
Perform the function-to-pointer adjustment during template argument deduction where the parameter is a function reference, function pointer, or member function pointer and the argument is an overloaded function. Fixes <rdar://problem/8360106>, a template argument deduction issue found by Boost.Filesystem. llvm-svn: 112523
2010-08-31 05:04:23 +08:00
Expr *Arg, QualType ParamType,
bool ParamWasReference) {
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Propagate whether an id-expression is the immediate argument of an '&' expression from the second caller of ActOnIdExpression. Teach template argument deduction that an overloaded id-expression doesn't give a valid type for deduction purposes to a non-static member function unless the expression has the correct syntactic form. Teach ActOnIdExpression that it shouldn't try to create implicit member expressions for '&function', because this isn't a permitted form of use for member functions. Teach CheckAddressOfOperand to diagnose these more carefully. Some of these cases aren't reachable right now because earlier diagnostics interrupt them. llvm-svn: 112258
2010-08-27 17:08:28 +08:00
OverloadExpr::FindResult R = OverloadExpr::find(Arg);
Implement C++ [temp.deduct.call]p6, template argument deduction for overloaded arguments. Fix a bug where incomplete explicit specializations were being passed through as legitimate. Fix a bug where the absence of an explicit specialization in an overload set was causing overall deduction to fail. Fixes PR6191. llvm-svn: 95052
2010-02-02 10:21:27 +08:00
Propagate whether an id-expression is the immediate argument of an '&' expression from the second caller of ActOnIdExpression. Teach template argument deduction that an overloaded id-expression doesn't give a valid type for deduction purposes to a non-static member function unless the expression has the correct syntactic form. Teach ActOnIdExpression that it shouldn't try to create implicit member expressions for '&function', because this isn't a permitted form of use for member functions. Teach CheckAddressOfOperand to diagnose these more carefully. Some of these cases aren't reachable right now because earlier diagnostics interrupt them. llvm-svn: 112258
2010-08-27 17:08:28 +08:00
OverloadExpr *Ovl = R.Expression;
Implement C++ [temp.deduct.call]p6, template argument deduction for overloaded arguments. Fix a bug where incomplete explicit specializations were being passed through as legitimate. Fix a bug where the absence of an explicit specialization in an overload set was causing overall deduction to fail. Fixes PR6191. llvm-svn: 95052
2010-02-02 10:21:27 +08:00
Perform the function-to-pointer adjustment during template argument deduction where the parameter is a function reference, function pointer, or member function pointer and the argument is an overloaded function. Fixes <rdar://problem/8360106>, a template argument deduction issue found by Boost.Filesystem. llvm-svn: 112523
2010-08-31 05:04:23 +08:00
// C++0x [temp.deduct.call]p4
unsigned TDF = 0;
if (ParamWasReference)
TDF |= TDF_ParamWithReferenceType;
if (R.IsAddressOfOperand)
TDF |= TDF_IgnoreQualifiers;
Implement C++ [temp.deduct.call]p6, template argument deduction for overloaded arguments. Fix a bug where incomplete explicit specializations were being passed through as legitimate. Fix a bug where the absence of an explicit specialization in an overload set was causing overall deduction to fail. Fixes PR6191. llvm-svn: 95052
2010-02-02 10:21:27 +08:00
// C++0x [temp.deduct.call]p6:
// When P is a function type, pointer to function type, or pointer
// to member function type:
if (!ParamType->isFunctionType() &&
!ParamType->isFunctionPointerType() &&
C++11 [temp.deduct.call]p6 tweak: when given a set of overlaoded functions that includes an explicit template argument list, perform an inner deduction against each of the function templates in that list and, if successful, use the result of that deduction for the outer template argument deduction. Fixes PR11713. llvm-svn: 152575
2012-03-13 05:09:16 +08:00
!ParamType->isMemberFunctionPointerType()) {
if (Ovl->hasExplicitTemplateArgs()) {
// But we can still look for an explicit specialization.
if (FunctionDecl *ExplicitSpec
= S.ResolveSingleFunctionTemplateSpecialization(Ovl))
Implement most of N3638 (return type deduction for normal functions). Missing (somewhat ironically) is support for the new deduction rules in lambda functions, plus PCH support for return type patching. llvm-svn: 181108
2013-05-04 15:00:32 +08:00
return GetTypeOfFunction(S, R, ExplicitSpec);
C++11 [temp.deduct.call]p6 tweak: when given a set of overlaoded functions that includes an explicit template argument list, perform an inner deduction against each of the function templates in that list and, if successful, use the result of that deduction for the outer template argument deduction. Fixes PR11713. llvm-svn: 152575
2012-03-13 05:09:16 +08:00
}
Implement C++ [temp.deduct.call]p6, template argument deduction for overloaded arguments. Fix a bug where incomplete explicit specializations were being passed through as legitimate. Fix a bug where the absence of an explicit specialization in an overload set was causing overall deduction to fail. Fixes PR6191. llvm-svn: 95052
2010-02-02 10:21:27 +08:00
C++11 [temp.deduct.call]p6 tweak: when given a set of overlaoded functions that includes an explicit template argument list, perform an inner deduction against each of the function templates in that list and, if successful, use the result of that deduction for the outer template argument deduction. Fixes PR11713. llvm-svn: 152575
2012-03-13 05:09:16 +08:00
return QualType();
}
// Gather the explicit template arguments, if any.
TemplateArgumentListInfo ExplicitTemplateArgs;
if (Ovl->hasExplicitTemplateArgs())
Ovl->getExplicitTemplateArgs().copyInto(ExplicitTemplateArgs);
Implement C++ [temp.deduct.call]p6, template argument deduction for overloaded arguments. Fix a bug where incomplete explicit specializations were being passed through as legitimate. Fix a bug where the absence of an explicit specialization in an overload set was causing overall deduction to fail. Fixes PR6191. llvm-svn: 95052
2010-02-02 10:21:27 +08:00
QualType Match;
Extract a common base class between UnresolvedLookupExpr and UnresolvedMemberExpr and employ it in a few places where it's useful. llvm-svn: 95072
2010-02-02 14:20:04 +08:00
for (UnresolvedSetIterator I = Ovl->decls_begin(),
E = Ovl->decls_end(); I != E; ++I) {
Implement C++ [temp.deduct.call]p6, template argument deduction for overloaded arguments. Fix a bug where incomplete explicit specializations were being passed through as legitimate. Fix a bug where the absence of an explicit specialization in an overload set was causing overall deduction to fail. Fixes PR6191. llvm-svn: 95052
2010-02-02 10:21:27 +08:00
NamedDecl *D = (*I)->getUnderlyingDecl();
C++11 [temp.deduct.call]p6 tweak: when given a set of overlaoded functions that includes an explicit template argument list, perform an inner deduction against each of the function templates in that list and, if successful, use the result of that deduction for the outer template argument deduction. Fixes PR11713. llvm-svn: 152575
2012-03-13 05:09:16 +08:00
if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D)) {
// - If the argument is an overload set containing one or more
// function templates, the parameter is treated as a
// non-deduced context.
if (!Ovl->hasExplicitTemplateArgs())
return QualType();
// Otherwise, see if we can resolve a function type
FunctionDecl *Specialization = 0;
Remove Context argument from TemplateDeductionInfo constructor. It was no longer needed after the unused Context member was removed in r164104. llvm-svn: 164196
2012-09-19 10:26:47 +08:00
TemplateDeductionInfo Info(Ovl->getNameLoc());
C++11 [temp.deduct.call]p6 tweak: when given a set of overlaoded functions that includes an explicit template argument list, perform an inner deduction against each of the function templates in that list and, if successful, use the result of that deduction for the outer template argument deduction. Fixes PR11713. llvm-svn: 152575
2012-03-13 05:09:16 +08:00
if (S.DeduceTemplateArguments(FunTmpl, &ExplicitTemplateArgs,
Specialization, Info))
continue;
D = Specialization;
}
Implement C++ [temp.deduct.call]p6, template argument deduction for overloaded arguments. Fix a bug where incomplete explicit specializations were being passed through as legitimate. Fix a bug where the absence of an explicit specialization in an overload set was causing overall deduction to fail. Fixes PR6191. llvm-svn: 95052
2010-02-02 10:21:27 +08:00
FunctionDecl *Fn = cast<FunctionDecl>(D);
Implement most of N3638 (return type deduction for normal functions). Missing (somewhat ironically) is support for the new deduction rules in lambda functions, plus PCH support for return type patching. llvm-svn: 181108
2013-05-04 15:00:32 +08:00
QualType ArgType = GetTypeOfFunction(S, R, Fn);
Propagate whether an id-expression is the immediate argument of an '&' expression from the second caller of ActOnIdExpression. Teach template argument deduction that an overloaded id-expression doesn't give a valid type for deduction purposes to a non-static member function unless the expression has the correct syntactic form. Teach ActOnIdExpression that it shouldn't try to create implicit member expressions for '&function', because this isn't a permitted form of use for member functions. Teach CheckAddressOfOperand to diagnose these more carefully. Some of these cases aren't reachable right now because earlier diagnostics interrupt them. llvm-svn: 112258
2010-08-27 17:08:28 +08:00
if (ArgType.isNull()) continue;
Implement C++ [temp.deduct.call]p6, template argument deduction for overloaded arguments. Fix a bug where incomplete explicit specializations were being passed through as legitimate. Fix a bug where the absence of an explicit specialization in an overload set was causing overall deduction to fail. Fixes PR6191. llvm-svn: 95052
2010-02-02 10:21:27 +08:00
Perform the function-to-pointer adjustment during template argument deduction where the parameter is a function reference, function pointer, or member function pointer and the argument is an overloaded function. Fixes <rdar://problem/8360106>, a template argument deduction issue found by Boost.Filesystem. llvm-svn: 112523
2010-08-31 05:04:23 +08:00
// Function-to-pointer conversion.
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
if (!ParamWasReference && ParamType->isPointerType() &&
Perform the function-to-pointer adjustment during template argument deduction where the parameter is a function reference, function pointer, or member function pointer and the argument is an overloaded function. Fixes <rdar://problem/8360106>, a template argument deduction issue found by Boost.Filesystem. llvm-svn: 112523
2010-08-31 05:04:23 +08:00
ArgType->isFunctionType())
ArgType = S.Context.getPointerType(ArgType);
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement C++ [temp.deduct.call]p6, template argument deduction for overloaded arguments. Fix a bug where incomplete explicit specializations were being passed through as legitimate. Fix a bug where the absence of an explicit specialization in an overload set was causing overall deduction to fail. Fixes PR6191. llvm-svn: 95052
2010-02-02 10:21:27 +08:00
// - If the argument is an overload set (not containing function
// templates), trial argument deduction is attempted using each
// of the members of the set. If deduction succeeds for only one
// of the overload set members, that member is used as the
// argument value for the deduction. If deduction succeeds for
// more than one member of the overload set the parameter is
// treated as a non-deduced context.
// We do all of this in a fresh context per C++0x [temp.deduct.type]p2:
// Type deduction is done independently for each P/A pair, and
// the deduced template argument values are then combined.
// So we do not reject deductions which were made elsewhere.
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<DeducedTemplateArgument, 8>
After performing template argument deduction for a function template, check deduced non-type template arguments and template template arguments against the template parameters for which they were deduced, performing conversions as appropriate so that deduced template arguments get the same treatment as explicitly-specified template arguments. This is the bulk of PR6723. Also keep track of whether deduction of a non-type template argument came from an array bound (vs. anywhere else). With this information, we enforce C++ [temp.deduct.type]p17, which requires exact type matches when deduction deduces a non-type template argument from something that is not an array bound. Finally, when in a SFINAE context, translate the "zero sized arrays are an extension" extension diagnostic into a hard error (for better standard conformance), which was a minor part of PR6723. llvm-svn: 99734
2010-03-28 10:42:43 +08:00
Deduced(TemplateParams->size());
Remove Context argument from TemplateDeductionInfo constructor. It was no longer needed after the unused Context member was removed in r164104. llvm-svn: 164196
2012-09-19 10:26:47 +08:00
TemplateDeductionInfo Info(Ovl->getNameLoc());
Implement C++ [temp.deduct.call]p6, template argument deduction for overloaded arguments. Fix a bug where incomplete explicit specializations were being passed through as legitimate. Fix a bug where the absence of an explicit specialization in an overload set was causing overall deduction to fail. Fixes PR6191. llvm-svn: 95052
2010-02-02 10:21:27 +08:00
Sema::TemplateDeductionResult Result
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
= DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ParamType,
ArgType, Info, Deduced, TDF);
Implement C++ [temp.deduct.call]p6, template argument deduction for overloaded arguments. Fix a bug where incomplete explicit specializations were being passed through as legitimate. Fix a bug where the absence of an explicit specialization in an overload set was causing overall deduction to fail. Fixes PR6191. llvm-svn: 95052
2010-02-02 10:21:27 +08:00
if (Result) continue;
if (!Match.isNull()) return QualType();
Match = ArgType;
}
return Match;
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
/// \brief Perform the adjustments to the parameter and argument types
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
/// described in C++ [temp.deduct.call].
///
/// \returns true if the caller should not attempt to perform any template
Replace "failed template argument deduction" diagnostic with something useful in the one case where we've already factored out a reason code. llvm-svn: 174036
2013-01-31 12:03:12 +08:00
/// argument deduction based on this P/A pair because the argument is an
/// overloaded function set that could not be resolved.
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
static bool AdjustFunctionParmAndArgTypesForDeduction(Sema &S,
TemplateParameterList *TemplateParams,
QualType &ParamType,
QualType &ArgType,
Expr *Arg,
unsigned &TDF) {
// C++0x [temp.deduct.call]p3:
7bit-ize. llvm-svn: 124363
2011-01-27 15:09:49 +08:00
// If P is a cv-qualified type, the top level cv-qualifiers of P's type
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
// are ignored for type deduction.
Clean up the handling of non-CVR qualifiers in template argument deduction. The good news is that address spaces are a lot less broken in this regard than I'd expected. llvm-svn: 130346
2011-04-28 07:34:22 +08:00
if (ParamType.hasQualifiers())
ParamType = ParamType.getUnqualifiedType();
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>();
if (ParamRefType) {
Implement the C++0x deduced 'auto' feature. This fixes PR 8738, 9060 and 9132. llvm-svn: 126069
2011-02-20 11:19:35 +08:00
QualType PointeeType = ParamRefType->getPointeeType();
Replace "failed template argument deduction" diagnostic with something useful in the one case where we've already factored out a reason code. llvm-svn: 174036
2013-01-31 12:03:12 +08:00
// If the argument has incomplete array type, try to complete its type.
Move Sema::RequireCompleteType() and Sema::RequireCompleteExprType() off PartialDiagnostic. PartialDiagnostic is rather heavyweight for something that is in the critical path and is rarely used. So, switch over to an abstract-class-based callback mechanism that delays most of the work until a diagnostic is actually produced. Good for ~11k code size reduction in the compiler and 1% speedup in -fsyntax-only on the code in <rdar://problem/11004361>. llvm-svn: 156176
2012-05-05 00:32:21 +08:00
if (ArgType->isIncompleteArrayType() && !S.RequireCompleteExprType(Arg, 0))
When performing template argument deduction given a function argument of incomplete array type, attempt to complete the array type. This was made much easier by Chandler's addition of RequireCompleteExprType(), which I've tweaked (slightly) to improve the consistency of the DeclRefExpr. Fixes PR7985. llvm-svn: 132530
2011-06-03 11:35:07 +08:00
ArgType = Arg->getType();
Implement the special template argument deduction rule for T&& in a call (C++0x [temp.deduct.call]p3). As part of this, start improving the reference-binding implementation used in the computation of implicit conversion sequences (for overload resolution) to reflect C++0x semantics. It still needs more work and testing, of course. llvm-svn: 123966
2011-01-21 13:18:22 +08:00
// [C++0x] If P is an rvalue reference to a cv-unqualified
// template parameter and the argument is an lvalue, the type
// "lvalue reference to A" is used in place of A for type
// deduction.
Implement the C++0x deduced 'auto' feature. This fixes PR 8738, 9060 and 9132. llvm-svn: 126069
2011-02-20 11:19:35 +08:00
if (isa<RValueReferenceType>(ParamType)) {
if (!PointeeType.getQualifiers() &&
isa<TemplateTypeParmType>(PointeeType) &&
It's considered poor form to create references to the overloaded function type. Educate template argument deduction thusly, fixing PR9974 / <rdar://problem/9479155>. llvm-svn: 131811
2011-05-22 06:16:50 +08:00
Arg->Classify(S.Context).isLValue() &&
Arg->getType() != S.Context.OverloadTy &&
Arg->getType() != S.Context.BoundMemberTy)
Implement the special template argument deduction rule for T&& in a call (C++0x [temp.deduct.call]p3). As part of this, start improving the reference-binding implementation used in the computation of implicit conversion sequences (for overload resolution) to reflect C++0x semantics. It still needs more work and testing, of course. llvm-svn: 123966
2011-01-21 13:18:22 +08:00
ArgType = S.Context.getLValueReferenceType(ArgType);
}
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
// [...] If P is a reference type, the type referred to by P is used
// for type deduction.
Implement the C++0x deduced 'auto' feature. This fixes PR 8738, 9060 and 9132. llvm-svn: 126069
2011-02-20 11:19:35 +08:00
ParamType = PointeeType;
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
// Overload sets usually make this parameter an undeduced
// context, but there are sometimes special circumstances.
if (ArgType == S.Context.OverloadTy) {
ArgType = ResolveOverloadForDeduction(S, TemplateParams,
Arg, ParamType,
ParamRefType != 0);
if (ArgType.isNull())
return true;
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
if (ParamRefType) {
// C++0x [temp.deduct.call]p3:
// [...] If P is of the form T&&, where T is a template parameter, and
// the argument is an lvalue, the type A& is used in place of A for
// type deduction.
if (ParamRefType->isRValueReferenceType() &&
ParamRefType->getAs<TemplateTypeParmType>() &&
Arg->isLValue())
ArgType = S.Context.getLValueReferenceType(ArgType);
} else {
// C++ [temp.deduct.call]p2:
// If P is not a reference type:
// - If A is an array type, the pointer type produced by the
// array-to-pointer standard conversion (4.2) is used in place of
// A for type deduction; otherwise,
if (ArgType->isArrayType())
ArgType = S.Context.getArrayDecayedType(ArgType);
// - If A is a function type, the pointer type produced by the
// function-to-pointer standard conversion (4.3) is used in place
// of A for type deduction; otherwise,
else if (ArgType->isFunctionType())
ArgType = S.Context.getPointerType(ArgType);
else {
7bit-ize. llvm-svn: 124363
2011-01-27 15:09:49 +08:00
// - If A is a cv-qualified type, the top level cv-qualifiers of A's
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
// type are ignored for type deduction.
Clean up the handling of non-CVR qualifiers in template argument deduction. The good news is that address spaces are a lot less broken in this regard than I'd expected. llvm-svn: 130346
2011-04-28 07:34:22 +08:00
ArgType = ArgType.getUnqualifiedType();
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
}
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
// C++0x [temp.deduct.call]p4:
// In general, the deduction process attempts to find template argument
// values that will make the deduced A identical to A (after the type A
// is transformed as described above). [...]
TDF = TDF_SkipNonDependent;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
// - If the original P is a reference type, the deduced A (i.e., the
// type referred to by the reference) can be more cv-qualified than
// the transformed A.
if (ParamRefType)
TDF |= TDF_ParamWithReferenceType;
// - The transformed A can be another pointer or pointer to member
// type that can be converted to the deduced A via a qualification
// conversion (4.4).
if (ArgType->isPointerType() || ArgType->isMemberPointerType() ||
ArgType->isObjCObjectPointerType())
TDF |= TDF_IgnoreQualifiers;
// - If P is a class and P has the form simple-template-id, then the
// transformed A can be a derived class of the deduced A. Likewise,
// if P is a pointer to a class of the form simple-template-id, the
// transformed A can be a pointer to a derived class pointed to by
// the deduced A.
if (isSimpleTemplateIdType(ParamType) ||
(isa<PointerType>(ParamType) &&
isSimpleTemplateIdType(
ParamType->getAs<PointerType>()->getPointeeType())))
TDF |= TDF_DerivedClass;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
return false;
}
Implement the consistency checking for C++ [temp.deduct.call]p3, which checks that the deduced argument type for a function call matches the actual argument type provided. The only place we've found where the consistency checking should actually cause template argument deduction failure is due to qualifier differences that don't fall into the realm of qualification conversions (which are *not* checked when we initially perform deduction). However, we're performing the full checking as specified in the standard to ensure that no other cases exist. Fixes PR9233 / <rdar://problem/9039590>. llvm-svn: 133163
2011-06-17 00:50:48 +08:00
static bool hasDeducibleTemplateParameters(Sema &S,
FunctionTemplateDecl *FunctionTemplate,
QualType T);
Support deducing template arguments from nested initializer lists. PR12119. llvm-svn: 152848
2012-03-16 05:40:51 +08:00
/// \brief Perform template argument deduction by matching a parameter type
/// against a single expression, where the expression is an element of
Replace "failed template argument deduction" diagnostic with something useful in the one case where we've already factored out a reason code. llvm-svn: 174036
2013-01-31 12:03:12 +08:00
/// an initializer list that was originally matched against a parameter
/// of type \c initializer_list\<ParamType\>.
Support deducing template arguments from nested initializer lists. PR12119. llvm-svn: 152848
2012-03-16 05:40:51 +08:00
static Sema::TemplateDeductionResult
DeduceTemplateArgumentByListElement(Sema &S,
TemplateParameterList *TemplateParams,
QualType ParamType, Expr *Arg,
TemplateDeductionInfo &Info,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
unsigned TDF) {
// Handle the case where an init list contains another init list as the
// element.
if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) {
QualType X;
if (!S.isStdInitializerList(ParamType.getNonReferenceType(), &X))
return Sema::TDK_Success; // Just ignore this expression.
// Recurse down into the init list.
for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) {
if (Sema::TemplateDeductionResult Result =
DeduceTemplateArgumentByListElement(S, TemplateParams, X,
ILE->getInit(i),
Info, Deduced, TDF))
return Result;
}
return Sema::TDK_Success;
}
// For all other cases, just match by type.
When performing template argument deduction for an initializer list, be sure to perform the argument type adjustments in [temp.deduct.call]p2, e.g., array decay. And, when performing these deductions in the context of 'auto', make sure that we're deducing the P' in std::initializer_list<P'> rather than the whole initializer list. Together, this makes code like for( auto s : {"Deferred", "New", "Open", "Review"}) { } work properly. llvm-svn: 153998
2012-04-04 13:10:53 +08:00
QualType ArgType = Arg->getType();
if (AdjustFunctionParmAndArgTypesForDeduction(S, TemplateParams, ParamType,
Replace "failed template argument deduction" diagnostic with something useful in the one case where we've already factored out a reason code. llvm-svn: 174036
2013-01-31 12:03:12 +08:00
ArgType, Arg, TDF)) {
Info.Expression = Arg;
When performing template argument deduction for an initializer list, be sure to perform the argument type adjustments in [temp.deduct.call]p2, e.g., array decay. And, when performing these deductions in the context of 'auto', make sure that we're deducing the P' in std::initializer_list<P'> rather than the whole initializer list. Together, this makes code like for( auto s : {"Deferred", "New", "Open", "Review"}) { } work properly. llvm-svn: 153998
2012-04-04 13:10:53 +08:00
return Sema::TDK_FailedOverloadResolution;
Replace "failed template argument deduction" diagnostic with something useful in the one case where we've already factored out a reason code. llvm-svn: 174036
2013-01-31 12:03:12 +08:00
}
Support deducing template arguments from nested initializer lists. PR12119. llvm-svn: 152848
2012-03-16 05:40:51 +08:00
return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ParamType,
When performing template argument deduction for an initializer list, be sure to perform the argument type adjustments in [temp.deduct.call]p2, e.g., array decay. And, when performing these deductions in the context of 'auto', make sure that we're deducing the P' in std::initializer_list<P'> rather than the whole initializer list. Together, this makes code like for( auto s : {"Deferred", "New", "Open", "Review"}) { } work properly. llvm-svn: 153998
2012-04-04 13:10:53 +08:00
ArgType, Info, Deduced, TDF);
Support deducing template arguments from nested initializer lists. PR12119. llvm-svn: 152848
2012-03-16 05:40:51 +08:00
}
Improved semantic analysis and AST respresentation for function templates. For example, this now type-checks (but does not instantiate the body of deref<int>): template<typename T> T& deref(T* t) { return *t; } void test(int *ip) { int &ir = deref(ip); } Specific changes/additions: * Template argument deduction from a call to a function template. * Instantiation of a function template specializations (just the declarations) from the template arguments deduced from a call. * FunctionTemplateDecls are stored directly in declaration contexts and found via name lookup (all forms), rather than finding the FunctionDecl and then realizing it is a template. This is responsible for most of the churn, since some of the core declaration matching and lookup code assumes that all functions are FunctionDecls. llvm-svn: 74213
2009-06-26 06:08:12 +08:00
/// \brief Perform template argument deduction from a function call
/// (C++ [temp.deduct.call]).
///
/// \param FunctionTemplate the function template for which we are performing
/// template argument deduction.
///
Diagnostics cleanup: Fixing \params to match the code. llvm-svn: 158981
2012-06-22 16:52:37 +08:00
/// \param ExplicitTemplateArgs the explicit template arguments provided
Implement name lookup for conversion function template specializations (C++ [temp.mem]p5-6), which involves template argument deduction based on the type named, e.g., given struct X { template<typename T> operator T*(); } x; when we call x.operator int*(); we perform template argument deduction to determine that T=int. This template argument deduction is needed for template specialization and explicit instantiation, e.g., template<> X::operator float*() { /* ... */ } and when calling or otherwise naming a conversion function (as in the first example). This fixes PR5742 and PR5762, although there's some remaining ugliness that's causing out-of-line definitions of conversion function templates to fail. I'll look into that separately. llvm-svn: 93162
2010-01-12 02:40:55 +08:00
/// for this call.
When explicit template arguments are provided for a function call, substitute those template arguments into the function parameter types prior to template argument deduction. There's still a bit of work to do to make this work properly when only some of the template arguments are specified. llvm-svn: 74576
2009-07-01 07:57:56 +08:00
///
Improved semantic analysis and AST respresentation for function templates. For example, this now type-checks (but does not instantiate the body of deref<int>): template<typename T> T& deref(T* t) { return *t; } void test(int *ip) { int &ir = deref(ip); } Specific changes/additions: * Template argument deduction from a call to a function template. * Instantiation of a function template specializations (just the declarations) from the template arguments deduced from a call. * FunctionTemplateDecls are stored directly in declaration contexts and found via name lookup (all forms), rather than finding the FunctionDecl and then realizing it is a template. This is responsible for most of the churn, since some of the core declaration matching and lookup code assumes that all functions are FunctionDecls. llvm-svn: 74213
2009-06-26 06:08:12 +08:00
/// \param Args the function call arguments
///
/// \param Specialization if template argument deduction was successful,
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
/// this will be set to the function template specialization produced by
Improved semantic analysis and AST respresentation for function templates. For example, this now type-checks (but does not instantiate the body of deref<int>): template<typename T> T& deref(T* t) { return *t; } void test(int *ip) { int &ir = deref(ip); } Specific changes/additions: * Template argument deduction from a call to a function template. * Instantiation of a function template specializations (just the declarations) from the template arguments deduced from a call. * FunctionTemplateDecls are stored directly in declaration contexts and found via name lookup (all forms), rather than finding the FunctionDecl and then realizing it is a template. This is responsible for most of the churn, since some of the core declaration matching and lookup code assumes that all functions are FunctionDecls. llvm-svn: 74213
2009-06-26 06:08:12 +08:00
/// template argument deduction.
///
/// \param Info the argument will be updated to provide additional information
/// about template argument deduction.
///
/// \returns the result of template argument deduction.
Omit llvm:: before ArrayRef, as we have using llvm::ArrayRef in include/clang/Basic/LLVM.h. llvm-svn: 188089
2013-08-10 02:02:13 +08:00
Sema::TemplateDeductionResult Sema::DeduceTemplateArguments(
FunctionTemplateDecl *FunctionTemplate,
TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
FunctionDecl *&Specialization, TemplateDeductionInfo &Info) {
Don't perform template argument deduction against invalid templates; it's likely to lead to a crash later on. Fixes PR12933 / <rdar://problem/11525335>. llvm-svn: 163838
2012-09-14 05:01:57 +08:00
if (FunctionTemplate->isInvalidDecl())
return TDK_Invalid;
Improved semantic analysis and AST respresentation for function templates. For example, this now type-checks (but does not instantiate the body of deref<int>): template<typename T> T& deref(T* t) { return *t; } void test(int *ip) { int &ir = deref(ip); } Specific changes/additions: * Template argument deduction from a call to a function template. * Instantiation of a function template specializations (just the declarations) from the template arguments deduced from a call. * FunctionTemplateDecls are stored directly in declaration contexts and found via name lookup (all forms), rather than finding the FunctionDecl and then realizing it is a template. This is responsible for most of the churn, since some of the core declaration matching and lookup code assumes that all functions are FunctionDecls. llvm-svn: 74213
2009-06-26 06:08:12 +08:00
FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
When explicit template arguments are provided for a function call, substitute those template arguments into the function parameter types prior to template argument deduction. There's still a bit of work to do to make this work properly when only some of the template arguments are specified. llvm-svn: 74576
2009-07-01 07:57:56 +08:00
Improved semantic analysis and AST respresentation for function templates. For example, this now type-checks (but does not instantiate the body of deref<int>): template<typename T> T& deref(T* t) { return *t; } void test(int *ip) { int &ir = deref(ip); } Specific changes/additions: * Template argument deduction from a call to a function template. * Instantiation of a function template specializations (just the declarations) from the template arguments deduced from a call. * FunctionTemplateDecls are stored directly in declaration contexts and found via name lookup (all forms), rather than finding the FunctionDecl and then realizing it is a template. This is responsible for most of the churn, since some of the core declaration matching and lookup code assumes that all functions are FunctionDecls. llvm-svn: 74213
2009-06-26 06:08:12 +08:00
// C++ [temp.deduct.call]p1:
// Template argument deduction is done by comparing each function template
// parameter type (call it P) with the type of the corresponding argument
// of the call (call it A) as described below.
ArrayRef'ize various functions in the AST/Parser/Sema. llvm-svn: 151447
2012-02-25 19:00:22 +08:00
unsigned CheckArgs = Args.size();
if (Args.size() < Function->getMinRequiredArguments())
Improved semantic analysis and AST respresentation for function templates. For example, this now type-checks (but does not instantiate the body of deref<int>): template<typename T> T& deref(T* t) { return *t; } void test(int *ip) { int &ir = deref(ip); } Specific changes/additions: * Template argument deduction from a call to a function template. * Instantiation of a function template specializations (just the declarations) from the template arguments deduced from a call. * FunctionTemplateDecls are stored directly in declaration contexts and found via name lookup (all forms), rather than finding the FunctionDecl and then realizing it is a template. This is responsible for most of the churn, since some of the core declaration matching and lookup code assumes that all functions are FunctionDecls. llvm-svn: 74213
2009-06-26 06:08:12 +08:00
return TDK_TooFewArguments;
ArrayRef'ize various functions in the AST/Parser/Sema. llvm-svn: 151447
2012-02-25 19:00:22 +08:00
else if (Args.size() > Function->getNumParams()) {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
const FunctionProtoType *Proto
Change all the Type::getAsFoo() methods to specializations of Type::getAs(). Several of the existing methods were identical to their respective specializations, and so have been removed entirely. Several more 'leaf' optimizations were introduced. The getAsFoo() methods which imposed extra conditions, like getAsObjCInterfacePointerType(), have been left in place. llvm-svn: 82501
2009-09-22 07:43:11 +08:00
= Function->getType()->getAs<FunctionProtoType>();
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
if (Proto->isTemplateVariadic())
/* Do nothing */;
else if (Proto->isVariadic())
CheckArgs = Function->getNumParams();
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
else
Improved semantic analysis and AST respresentation for function templates. For example, this now type-checks (but does not instantiate the body of deref<int>): template<typename T> T& deref(T* t) { return *t; } void test(int *ip) { int &ir = deref(ip); } Specific changes/additions: * Template argument deduction from a call to a function template. * Instantiation of a function template specializations (just the declarations) from the template arguments deduced from a call. * FunctionTemplateDecls are stored directly in declaration contexts and found via name lookup (all forms), rather than finding the FunctionDecl and then realizing it is a template. This is responsible for most of the churn, since some of the core declaration matching and lookup code assumes that all functions are FunctionDecls. llvm-svn: 74213
2009-06-26 06:08:12 +08:00
return TDK_TooManyArguments;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
When explicit template arguments are provided for a function call, substitute those template arguments into the function parameter types prior to template argument deduction. There's still a bit of work to do to make this work properly when only some of the template arguments are specified. llvm-svn: 74576
2009-07-01 07:57:56 +08:00
// The types of the parameters from which we will perform template argument
// deduction.
Move more stuff out of Sema.h. llvm-svn: 112026
2010-08-25 13:32:35 +08:00
LocalInstantiationScope InstScope(*this);
Improved semantic analysis and AST respresentation for function templates. For example, this now type-checks (but does not instantiate the body of deref<int>): template<typename T> T& deref(T* t) { return *t; } void test(int *ip) { int &ir = deref(ip); } Specific changes/additions: * Template argument deduction from a call to a function template. * Instantiation of a function template specializations (just the declarations) from the template arguments deduced from a call. * FunctionTemplateDecls are stored directly in declaration contexts and found via name lookup (all forms), rather than finding the FunctionDecl and then realizing it is a template. This is responsible for most of the churn, since some of the core declaration matching and lookup code assumes that all functions are FunctionDecls. llvm-svn: 74213
2009-06-26 06:08:12 +08:00
TemplateParameterList *TemplateParams
= FunctionTemplate->getTemplateParameters();
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<DeducedTemplateArgument, 4> Deduced;
SmallVector<QualType, 4> ParamTypes;
After performing template argument deduction for a function template, check deduced non-type template arguments and template template arguments against the template parameters for which they were deduced, performing conversions as appropriate so that deduced template arguments get the same treatment as explicitly-specified template arguments. This is the bulk of PR6723. Also keep track of whether deduction of a non-type template argument came from an array bound (vs. anywhere else). With this information, we enforce C++ [temp.deduct.type]p17, which requires exact type matches when deduction deduces a non-type template argument from something that is not an array bound. Finally, when in a SFINAE context, translate the "zero sized arrays are an extension" extension diagnostic into a hard error (for better standard conformance), which was a minor part of PR6723. llvm-svn: 99734
2010-03-28 10:42:43 +08:00
unsigned NumExplicitlySpecified = 0;
Encapsulate "an array of TemplateArgumentLocs and two angle bracket locations" into a new class. Use it pervasively throughout Sema. My fingers hurt. llvm-svn: 89638
2009-11-23 09:53:49 +08:00
if (ExplicitTemplateArgs) {
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
TemplateDeductionResult Result =
SubstituteExplicitTemplateArguments(FunctionTemplate,
Encapsulate "an array of TemplateArgumentLocs and two angle bracket locations" into a new class. Use it pervasively throughout Sema. My fingers hurt. llvm-svn: 89638
2009-11-23 09:53:49 +08:00
*ExplicitTemplateArgs,
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
Deduced,
ParamTypes,
0,
Info);
if (Result)
return Result;
After performing template argument deduction for a function template, check deduced non-type template arguments and template template arguments against the template parameters for which they were deduced, performing conversions as appropriate so that deduced template arguments get the same treatment as explicitly-specified template arguments. This is the bulk of PR6723. Also keep track of whether deduction of a non-type template argument came from an array bound (vs. anywhere else). With this information, we enforce C++ [temp.deduct.type]p17, which requires exact type matches when deduction deduces a non-type template argument from something that is not an array bound. Finally, when in a SFINAE context, translate the "zero sized arrays are an extension" extension diagnostic into a hard error (for better standard conformance), which was a minor part of PR6723. llvm-svn: 99734
2010-03-28 10:42:43 +08:00
NumExplicitlySpecified = Deduced.size();
When explicit template arguments are provided for a function call, substitute those template arguments into the function parameter types prior to template argument deduction. There's still a bit of work to do to make this work properly when only some of the template arguments are specified. llvm-svn: 74576
2009-07-01 07:57:56 +08:00
} else {
// Just fill in the parameter types from the function declaration.
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I)
When explicit template arguments are provided for a function call, substitute those template arguments into the function parameter types prior to template argument deduction. There's still a bit of work to do to make this work properly when only some of the template arguments are specified. llvm-svn: 74576
2009-07-01 07:57:56 +08:00
ParamTypes.push_back(Function->getParamDecl(I)->getType());
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
When explicit template arguments are provided for a function call, substitute those template arguments into the function parameter types prior to template argument deduction. There's still a bit of work to do to make this work properly when only some of the template arguments are specified. llvm-svn: 74576
2009-07-01 07:57:56 +08:00
// Deduce template arguments from the function parameters.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Deduced.resize(TemplateParams->size());
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
unsigned ArgIdx = 0;
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<OriginalCallArg, 4> OriginalCallArgs;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
for (unsigned ParamIdx = 0, NumParams = ParamTypes.size();
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
ParamIdx != NumParams; ++ParamIdx) {
Implement the consistency checking for C++ [temp.deduct.call]p3, which checks that the deduced argument type for a function call matches the actual argument type provided. The only place we've found where the consistency checking should actually cause template argument deduction failure is due to qualifier differences that don't fall into the realm of qualification conversions (which are *not* checked when we initially perform deduction). However, we're performing the full checking as specified in the standard to ensure that no other cases exist. Fixes PR9233 / <rdar://problem/9039590>. llvm-svn: 133163
2011-06-17 00:50:48 +08:00
QualType OrigParamType = ParamTypes[ParamIdx];
QualType ParamType = OrigParamType;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
const PackExpansionType *ParamExpansion
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
= dyn_cast<PackExpansionType>(ParamType);
if (!ParamExpansion) {
// Simple case: matching a function parameter to a function argument.
if (ArgIdx >= CheckArgs)
break;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
Expr *Arg = Args[ArgIdx++];
QualType ArgType = Arg->getType();
Implement the consistency checking for C++ [temp.deduct.call]p3, which checks that the deduced argument type for a function call matches the actual argument type provided. The only place we've found where the consistency checking should actually cause template argument deduction failure is due to qualifier differences that don't fall into the realm of qualification conversions (which are *not* checked when we initially perform deduction). However, we're performing the full checking as specified in the standard to ensure that no other cases exist. Fixes PR9233 / <rdar://problem/9039590>. llvm-svn: 133163
2011-06-17 00:50:48 +08:00
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
unsigned TDF = 0;
if (AdjustFunctionParmAndArgTypesForDeduction(*this, TemplateParams,
ParamType, ArgType, Arg,
TDF))
continue;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Per the note in C++0x [temp.deduct.call]p4, don't attempt template argument deduction against a function parameter that has no deducible template parameters in it. Fixes PR8598. llvm-svn: 141517
2011-10-10 06:06:46 +08:00
// If we have nothing to deduce, we're done.
if (!hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType))
continue;
Template argument deduction for std::initializer_list arguments from initializer lists. llvm-svn: 148352
2012-01-18 06:49:58 +08:00
// If the argument is an initializer list ...
if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) {
// ... then the parameter is an undeduced context, unless the parameter
// type is (reference to cv) std::initializer_list<P'>, in which case
// deduction is done for each element of the initializer list, and the
// result is the deduced type if it's the same for all elements.
QualType X;
// Removing references was already done.
if (!isStdInitializerList(ParamType, &X))
continue;
for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) {
if (TemplateDeductionResult Result =
Support deducing template arguments from nested initializer lists. PR12119. llvm-svn: 152848
2012-03-16 05:40:51 +08:00
DeduceTemplateArgumentByListElement(*this, TemplateParams, X,
ILE->getInit(i),
Info, Deduced, TDF))
Template argument deduction for std::initializer_list arguments from initializer lists. llvm-svn: 148352
2012-01-18 06:49:58 +08:00
return Result;
}
// Don't track the argument type, since an initializer list has none.
continue;
}
Implement the consistency checking for C++ [temp.deduct.call]p3, which checks that the deduced argument type for a function call matches the actual argument type provided. The only place we've found where the consistency checking should actually cause template argument deduction failure is due to qualifier differences that don't fall into the realm of qualification conversions (which are *not* checked when we initially perform deduction). However, we're performing the full checking as specified in the standard to ensure that no other cases exist. Fixes PR9233 / <rdar://problem/9039590>. llvm-svn: 133163
2011-06-17 00:50:48 +08:00
// Keep track of the argument type and corresponding parameter index,
// so we can check for compatibility between the deduced A and A.
Per the note in C++0x [temp.deduct.call]p4, don't attempt template argument deduction against a function parameter that has no deducible template parameters in it. Fixes PR8598. llvm-svn: 141517
2011-10-10 06:06:46 +08:00
OriginalCallArgs.push_back(OriginalCallArg(OrigParamType, ArgIdx-1,
ArgType));
Implement the consistency checking for C++ [temp.deduct.call]p3, which checks that the deduced argument type for a function call matches the actual argument type provided. The only place we've found where the consistency checking should actually cause template argument deduction failure is due to qualifier differences that don't fall into the realm of qualification conversions (which are *not* checked when we initially perform deduction). However, we're performing the full checking as specified in the standard to ensure that no other cases exist. Fixes PR9233 / <rdar://problem/9039590>. llvm-svn: 133163
2011-06-17 00:50:48 +08:00
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
if (TemplateDeductionResult Result
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
= DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams,
ParamType, ArgType,
Info, Deduced, TDF))
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
return Result;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
continue;
Perform the function-to-pointer adjustment during template argument deduction where the parameter is a function reference, function pointer, or member function pointer and the argument is an overloaded function. Fixes <rdar://problem/8360106>, a template argument deduction issue found by Boost.Filesystem. llvm-svn: 112523
2010-08-31 05:04:23 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
// C++0x [temp.deduct.call]p1:
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// For a function parameter pack that occurs at the end of the
// parameter-declaration-list, the type A of each remaining argument of
// the call is compared with the type P of the declarator-id of the
// function parameter pack. Each comparison deduces template arguments
// for subsequent positions in the template parameter packs expanded by
Implement the last bullet of [temp.deduct.type]p5 and part of the last sentence of [temp.deduct.call]p1, both of which concern the non-deducibility of parameter packs not at the end of a parameter-type-list. The latter isn't fully implemented yet; see the new FIXME. llvm-svn: 123210
2011-01-11 09:52:23 +08:00
// the function parameter pack. For a function parameter pack that does
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// not occur at the end of the parameter-declaration-list, the type of
Implement the last bullet of [temp.deduct.type]p5 and part of the last sentence of [temp.deduct.call]p1, both of which concern the non-deducibility of parameter packs not at the end of a parameter-type-list. The latter isn't fully implemented yet; see the new FIXME. llvm-svn: 123210
2011-01-11 09:52:23 +08:00
// the parameter pack is a non-deduced context.
if (ParamIdx + 1 < NumParams)
break;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
QualType ParamPattern = ParamExpansion->getPattern();
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<unsigned, 2> PackIndices;
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
{
SmallBitVectorize the deduced parameter set. llvm-svn: 149253
2012-01-31 00:17:39 +08:00
llvm::SmallBitVector SawIndices(TemplateParams->size());
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<UnexpandedParameterPack, 2> Unexpanded;
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
collectUnexpandedParameterPacks(ParamPattern, Unexpanded);
for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
unsigned Depth, Index;
llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]);
if (Depth == 0 && !SawIndices[Index]) {
SawIndices[Index] = true;
PackIndices.push_back(Index);
}
}
}
assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?");
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Work-in-progress implementation of C++0x [temp.arg.explicit]p9, which allows an argument pack determines via explicit specification of function template arguments to be extended by further, deduced arguments. For example: template<class ... Types> void f(Types ... values); void g() { f<int*, float*>(0, 0, 0); // Types is deduced to the sequence int*, float*, int } There are a number of FIXMEs in here that indicate places where we need to implement + test retained expansions, plus a number of other places in deduction where we need to correctly cope with the explicitly-specified arguments when deducing an argument pack. Furthermore, it appears that the RecursiveASTVisitor needs to be auditied; it's missing some traversals (especially w.r.t. template arguments) that cause it not to find unexpanded parameter packs when it should. The good news, however, is that the tr1::tuple implementation now works fully, and the tr1::bind example (both from N2080) is actually working now. llvm-svn: 123163
2011-01-10 15:32:04 +08:00
// Keep track of the deduced template arguments for each parameter pack
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// expanded by this pack expansion (the outer index) and for each
Work-in-progress implementation of C++0x [temp.arg.explicit]p9, which allows an argument pack determines via explicit specification of function template arguments to be extended by further, deduced arguments. For example: template<class ... Types> void f(Types ... values); void g() { f<int*, float*>(0, 0, 0); // Types is deduced to the sequence int*, float*, int } There are a number of FIXMEs in here that indicate places where we need to implement + test retained expansions, plus a number of other places in deduction where we need to correctly cope with the explicitly-specified arguments when deducing an argument pack. Furthermore, it appears that the RecursiveASTVisitor needs to be auditied; it's missing some traversals (especially w.r.t. template arguments) that cause it not to find unexpanded parameter packs when it should. The good news, however, is that the tr1::tuple implementation now works fully, and the tr1::bind example (both from N2080) is actually working now. llvm-svn: 123163
2011-01-10 15:32:04 +08:00
// template argument (the inner SmallVectors).
Introduce a typedef for the type of NewlyDeducedPacks to avoid repeating the small size of the inner SmallVector. llvm-svn: 185789
2013-07-08 12:44:01 +08:00
NewlyDeducedPacksType NewlyDeducedPacks(PackIndices.size());
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<DeducedTemplateArgument, 2>
Work-in-progress implementation of C++0x [temp.arg.explicit]p9, which allows an argument pack determines via explicit specification of function template arguments to be extended by further, deduced arguments. For example: template<class ... Types> void f(Types ... values); void g() { f<int*, float*>(0, 0, 0); // Types is deduced to the sequence int*, float*, int } There are a number of FIXMEs in here that indicate places where we need to implement + test retained expansions, plus a number of other places in deduction where we need to correctly cope with the explicitly-specified arguments when deducing an argument pack. Furthermore, it appears that the RecursiveASTVisitor needs to be auditied; it's missing some traversals (especially w.r.t. template arguments) that cause it not to find unexpanded parameter packs when it should. The good news, however, is that the tr1::tuple implementation now works fully, and the tr1::bind example (both from N2080) is actually working now. llvm-svn: 123163
2011-01-10 15:32:04 +08:00
SavedPacks(PackIndices.size());
Factor out the code to set up template argument deduction for a set of template argument packs. This also ensures that explicitly-specified template arguments get properly represented in those cases. llvm-svn: 123180
2011-01-11 01:35:05 +08:00
PrepareArgumentPackDeduction(*this, Deduced, PackIndices, SavedPacks,
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
NewlyDeducedPacks);
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
bool HasAnyArguments = false;
ArrayRef'ize various functions in the AST/Parser/Sema. llvm-svn: 151447
2012-02-25 19:00:22 +08:00
for (; ArgIdx < Args.size(); ++ArgIdx) {
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
HasAnyArguments = true;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement the consistency checking for C++ [temp.deduct.call]p3, which checks that the deduced argument type for a function call matches the actual argument type provided. The only place we've found where the consistency checking should actually cause template argument deduction failure is due to qualifier differences that don't fall into the realm of qualification conversions (which are *not* checked when we initially perform deduction). However, we're performing the full checking as specified in the standard to ensure that no other cases exist. Fixes PR9233 / <rdar://problem/9039590>. llvm-svn: 133163
2011-06-17 00:50:48 +08:00
QualType OrigParamType = ParamPattern;
ParamType = OrigParamType;
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
Expr *Arg = Args[ArgIdx];
QualType ArgType = Arg->getType();
Implement the consistency checking for C++ [temp.deduct.call]p3, which checks that the deduced argument type for a function call matches the actual argument type provided. The only place we've found where the consistency checking should actually cause template argument deduction failure is due to qualifier differences that don't fall into the realm of qualification conversions (which are *not* checked when we initially perform deduction). However, we're performing the full checking as specified in the standard to ensure that no other cases exist. Fixes PR9233 / <rdar://problem/9039590>. llvm-svn: 133163
2011-06-17 00:50:48 +08:00
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
unsigned TDF = 0;
if (AdjustFunctionParmAndArgTypesForDeduction(*this, TemplateParams,
ParamType, ArgType, Arg,
TDF)) {
// We can't actually perform any deduction for this argument, so stop
// deduction at this point.
++ArgIdx;
break;
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Template argument deduction for std::initializer_list arguments from initializer lists. llvm-svn: 148352
2012-01-18 06:49:58 +08:00
// As above, initializer lists need special handling.
if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) {
QualType X;
if (!isStdInitializerList(ParamType, &X)) {
++ArgIdx;
break;
}
Implement the consistency checking for C++ [temp.deduct.call]p3, which checks that the deduced argument type for a function call matches the actual argument type provided. The only place we've found where the consistency checking should actually cause template argument deduction failure is due to qualifier differences that don't fall into the realm of qualification conversions (which are *not* checked when we initially perform deduction). However, we're performing the full checking as specified in the standard to ensure that no other cases exist. Fixes PR9233 / <rdar://problem/9039590>. llvm-svn: 133163
2011-06-17 00:50:48 +08:00
Template argument deduction for std::initializer_list arguments from initializer lists. llvm-svn: 148352
2012-01-18 06:49:58 +08:00
for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) {
if (TemplateDeductionResult Result =
DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, X,
ILE->getInit(i)->getType(),
Info, Deduced, TDF))
return Result;
}
} else {
// Keep track of the argument type and corresponding argument index,
// so we can check for compatibility between the deduced A and A.
if (hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType))
OriginalCallArgs.push_back(OriginalCallArg(OrigParamType, ArgIdx,
ArgType));
if (TemplateDeductionResult Result
= DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams,
ParamType, ArgType, Info,
Deduced, TDF))
return Result;
}
Implement C++ [temp.deduct.call]p6, template argument deduction for overloaded arguments. Fix a bug where incomplete explicit specializations were being passed through as legitimate. Fix a bug where the absence of an explicit specialization in an overload set was causing overall deduction to fail. Fixes PR6191. llvm-svn: 95052
2010-02-02 10:21:27 +08:00
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
// Capture the deduced template arguments for each parameter pack expanded
// by this pack expansion, add them to the list of arguments we've deduced
// for that pack, then clear out the deduced argument.
for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) {
DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]];
if (!DeducedArg.isNull()) {
NewlyDeducedPacks[I].push_back(DeducedArg);
DeducedArg = DeducedTemplateArgument();
}
Improved semantic analysis and AST respresentation for function templates. For example, this now type-checks (but does not instantiate the body of deref<int>): template<typename T> T& deref(T* t) { return *t; } void test(int *ip) { int &ir = deref(ip); } Specific changes/additions: * Template argument deduction from a call to a function template. * Instantiation of a function template specializations (just the declarations) from the template arguments deduced from a call. * FunctionTemplateDecls are stored directly in declaration contexts and found via name lookup (all forms), rather than finding the FunctionDecl and then realizing it is a template. This is responsible for most of the churn, since some of the core declaration matching and lookup code assumes that all functions are FunctionDecls. llvm-svn: 74213
2009-06-26 06:08:12 +08:00
}
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
// Build argument packs for each of the parameter packs expanded by this
// pack expansion.
Repent for my copy-and-paste sins, factoring out the code that forms argument packs from a set of deduced arguments, then checks that those argument packs match previously-deduced argument packs. llvm-svn: 123182
2011-01-11 01:53:52 +08:00
if (Sema::TemplateDeductionResult Result
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
= FinishArgumentPackDeduction(*this, TemplateParams, HasAnyArguments,
Repent for my copy-and-paste sins, factoring out the code that forms argument packs from a set of deduced arguments, then checks that those argument packs match previously-deduced argument packs. llvm-svn: 123182
2011-01-11 01:53:52 +08:00
Deduced, PackIndices, SavedPacks,
NewlyDeducedPacks, Info))
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
return Result;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement template argument deduction from a call to a function template whose last parameter is a parameter pack. This allows us to form a call to, e.g., template<typename ...Args1, typename ...Args2> void f(std::pair<Args1, Args2> ...pairs); given zero or more instances of "pair". llvm-svn: 122973
2011-01-07 06:09:01 +08:00
// After we've matching against a parameter pack, we're done.
break;
Improved semantic analysis and AST respresentation for function templates. For example, this now type-checks (but does not instantiate the body of deref<int>): template<typename T> T& deref(T* t) { return *t; } void test(int *ip) { int &ir = deref(ip); } Specific changes/additions: * Template argument deduction from a call to a function template. * Instantiation of a function template specializations (just the declarations) from the template arguments deduced from a call. * FunctionTemplateDecls are stored directly in declaration contexts and found via name lookup (all forms), rather than finding the FunctionDecl and then realizing it is a template. This is responsible for most of the churn, since some of the core declaration matching and lookup code assumes that all functions are FunctionDecls. llvm-svn: 74213
2009-06-26 06:08:12 +08:00
}
Implement conversion function templates, along with the ability to use template argument deduction from a conversion function (C++ [temp.deduct.conv]) with implicit conversions. llvm-svn: 79693
2009-08-22 07:19:43 +08:00
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
return FinishTemplateArgumentDeduction(FunctionTemplate, Deduced,
After performing template argument deduction for a function template, check deduced non-type template arguments and template template arguments against the template parameters for which they were deduced, performing conversions as appropriate so that deduced template arguments get the same treatment as explicitly-specified template arguments. This is the bulk of PR6723. Also keep track of whether deduction of a non-type template argument came from an array bound (vs. anywhere else). With this information, we enforce C++ [temp.deduct.type]p17, which requires exact type matches when deduction deduces a non-type template argument from something that is not an array bound. Finally, when in a SFINAE context, translate the "zero sized arrays are an extension" extension diagnostic into a hard error (for better standard conformance), which was a minor part of PR6723. llvm-svn: 99734
2010-03-28 10:42:43 +08:00
NumExplicitlySpecified,
Implement the consistency checking for C++ [temp.deduct.call]p3, which checks that the deduced argument type for a function call matches the actual argument type provided. The only place we've found where the consistency checking should actually cause template argument deduction failure is due to qualifier differences that don't fall into the realm of qualification conversions (which are *not* checked when we initially perform deduction). However, we're performing the full checking as specified in the standard to ensure that no other cases exist. Fixes PR9233 / <rdar://problem/9039590>. llvm-svn: 133163
2011-06-17 00:50:48 +08:00
Specialization, Info, &OriginalCallArgs);
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
}
Keep track of function template specializations, to eliminate redundant, implicit instantiations of function templates and provide a place where we can hang function template specializations. llvm-svn: 74454
2009-06-30 04:59:39 +08:00
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
/// \brief Deduce template arguments when taking the address of a function
When a template-id refers to a single function template, and the explicitly-specified template arguments are enough to determine the instantiation, and either template argument deduction fails or is not performed in that context, we can resolve the template-id down to a function template specialization (so sayeth C++0x [temp.arg.explicit]p3). Fixes PR5811. llvm-svn: 91852
2009-12-22 07:17:24 +08:00
/// template (C++ [temp.deduct.funcaddr]) or matching a specialization to
/// a template.
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
///
/// \param FunctionTemplate the function template for which we are performing
/// template argument deduction.
///
Diagnostics cleanup: Fixing \params to match the code. llvm-svn: 158981
2012-06-22 16:52:37 +08:00
/// \param ExplicitTemplateArgs the explicitly-specified template
When a template-id refers to a single function template, and the explicitly-specified template arguments are enough to determine the instantiation, and either template argument deduction fails or is not performed in that context, we can resolve the template-id down to a function template specialization (so sayeth C++0x [temp.arg.explicit]p3). Fixes PR5811. llvm-svn: 91852
2009-12-22 07:17:24 +08:00
/// arguments.
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
///
/// \param ArgFunctionType the function type that will be used as the
/// "argument" type (A) when performing template argument deduction from the
When a template-id refers to a single function template, and the explicitly-specified template arguments are enough to determine the instantiation, and either template argument deduction fails or is not performed in that context, we can resolve the template-id down to a function template specialization (so sayeth C++0x [temp.arg.explicit]p3). Fixes PR5811. llvm-svn: 91852
2009-12-22 07:17:24 +08:00
/// function template's function type. This type may be NULL, if there is no
/// argument type to compare against, in C++0x [temp.arg.explicit]p3.
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
///
/// \param Specialization if template argument deduction was successful,
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
/// this will be set to the function template specialization produced by
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
/// template argument deduction.
///
/// \param Info the argument will be updated to provide additional information
/// about template argument deduction.
///
/// \returns the result of template argument deduction.
Sema::TemplateDeductionResult
Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
When we use the default template arguments of a template template parameter, save the instantiated default template arguments along with the explicitly-specified template argument list. That way, we prefer the default template template arguments corresponding to the template template parameter rather than those of its template template argument. This addresses the likely direction of C++ core issue 150, and fixes PR9353/<rdar://problem/9069136>, bringing us closer to the behavior of EDG and GCC. llvm-svn: 126920
2011-03-03 10:41:12 +08:00
TemplateArgumentListInfo *ExplicitTemplateArgs,
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
QualType ArgFunctionType,
FunctionDecl *&Specialization,
Fix PR15291: noreturn adjustment in overload resolution for function templates, from Alexander Zinenko! llvm-svn: 179680
2013-04-17 16:45:07 +08:00
TemplateDeductionInfo &Info,
bool InOverloadResolution) {
Don't perform template argument deduction against invalid templates; it's likely to lead to a crash later on. Fixes PR12933 / <rdar://problem/11525335>. llvm-svn: 163838
2012-09-14 05:01:57 +08:00
if (FunctionTemplate->isInvalidDecl())
return TDK_Invalid;
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
TemplateParameterList *TemplateParams
= FunctionTemplate->getTemplateParameters();
QualType FunctionType = Function->getType();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
// Substitute any explicit template arguments.
Move more stuff out of Sema.h. llvm-svn: 112026
2010-08-25 13:32:35 +08:00
LocalInstantiationScope InstScope(*this);
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<DeducedTemplateArgument, 4> Deduced;
After performing template argument deduction for a function template, check deduced non-type template arguments and template template arguments against the template parameters for which they were deduced, performing conversions as appropriate so that deduced template arguments get the same treatment as explicitly-specified template arguments. This is the bulk of PR6723. Also keep track of whether deduction of a non-type template argument came from an array bound (vs. anywhere else). With this information, we enforce C++ [temp.deduct.type]p17, which requires exact type matches when deduction deduces a non-type template argument from something that is not an array bound. Finally, when in a SFINAE context, translate the "zero sized arrays are an extension" extension diagnostic into a hard error (for better standard conformance), which was a minor part of PR6723. llvm-svn: 99734
2010-03-28 10:42:43 +08:00
unsigned NumExplicitlySpecified = 0;
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<QualType, 4> ParamTypes;
Encapsulate "an array of TemplateArgumentLocs and two angle bracket locations" into a new class. Use it pervasively throughout Sema. My fingers hurt. llvm-svn: 89638
2009-11-23 09:53:49 +08:00
if (ExplicitTemplateArgs) {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
if (TemplateDeductionResult Result
= SubstituteExplicitTemplateArguments(FunctionTemplate,
Encapsulate "an array of TemplateArgumentLocs and two angle bracket locations" into a new class. Use it pervasively throughout Sema. My fingers hurt. llvm-svn: 89638
2009-11-23 09:53:49 +08:00
*ExplicitTemplateArgs,
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Deduced, ParamTypes,
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
&FunctionType, Info))
return Result;
After performing template argument deduction for a function template, check deduced non-type template arguments and template template arguments against the template parameters for which they were deduced, performing conversions as appropriate so that deduced template arguments get the same treatment as explicitly-specified template arguments. This is the bulk of PR6723. Also keep track of whether deduction of a non-type template argument came from an array bound (vs. anywhere else). With this information, we enforce C++ [temp.deduct.type]p17, which requires exact type matches when deduction deduces a non-type template argument from something that is not an array bound. Finally, when in a SFINAE context, translate the "zero sized arrays are an extension" extension diagnostic into a hard error (for better standard conformance), which was a minor part of PR6723. llvm-svn: 99734
2010-03-28 10:42:43 +08:00
NumExplicitlySpecified = Deduced.size();
Keep track of function template specializations, to eliminate redundant, implicit instantiations of function templates and provide a place where we can hang function template specializations. llvm-svn: 74454
2009-06-30 04:59:39 +08:00
}
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
Make sure template argument deduction is consistently performed in an unevaluated context. llvm-svn: 150049
2012-02-08 11:07:05 +08:00
// Unevaluated SFINAE context.
EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
SFINAETrap Trap(*this);
Implement C++ [temp.deduct.call]p6, template argument deduction for overloaded arguments. Fix a bug where incomplete explicit specializations were being passed through as legitimate. Fix a bug where the absence of an explicit specialization in an overload set was causing overall deduction to fail. Fixes PR6191. llvm-svn: 95052
2010-02-02 10:21:27 +08:00
Deduced.resize(TemplateParams->size());
Implement most of N3638 (return type deduction for normal functions). Missing (somewhat ironically) is support for the new deduction rules in lambda functions, plus PCH support for return type patching. llvm-svn: 181108
2013-05-04 15:00:32 +08:00
// If the function has a deduced return type, substitute it for a dependent
// type so that we treat it as a non-deduced context in what follows.
PR16875: The return type of a dependent function type is visible when it's referenced as a member of the current instantiation. In that case, deduce the type of the function to a dependent type rather than exposing an undeduced auto type to the rest of the current instantiation. The standard doesn't really say that the type is dependent in this case; I'll bring this up with CWG. llvm-svn: 188410
2013-08-15 04:16:31 +08:00
bool HasDeducedReturnType = false;
Implement most of N3638 (return type deduction for normal functions). Missing (somewhat ironically) is support for the new deduction rules in lambda functions, plus PCH support for return type patching. llvm-svn: 181108
2013-05-04 15:00:32 +08:00
if (getLangOpts().CPlusPlus1y && InOverloadResolution &&
PR16875: The return type of a dependent function type is visible when it's referenced as a member of the current instantiation. In that case, deduce the type of the function to a dependent type rather than exposing an undeduced auto type to the rest of the current instantiation. The standard doesn't really say that the type is dependent in this case; I'll bring this up with CWG. llvm-svn: 188410
2013-08-15 04:16:31 +08:00
Function->getResultType()->getContainedAutoType()) {
Implement most of N3638 (return type deduction for normal functions). Missing (somewhat ironically) is support for the new deduction rules in lambda functions, plus PCH support for return type patching. llvm-svn: 181108
2013-05-04 15:00:32 +08:00
FunctionType = SubstAutoType(FunctionType, Context.DependentTy);
PR16875: The return type of a dependent function type is visible when it's referenced as a member of the current instantiation. In that case, deduce the type of the function to a dependent type rather than exposing an undeduced auto type to the rest of the current instantiation. The standard doesn't really say that the type is dependent in this case; I'll bring this up with CWG. llvm-svn: 188410
2013-08-15 04:16:31 +08:00
HasDeducedReturnType = true;
Implement most of N3638 (return type deduction for normal functions). Missing (somewhat ironically) is support for the new deduction rules in lambda functions, plus PCH support for return type patching. llvm-svn: 181108
2013-05-04 15:00:32 +08:00
}
When a template-id refers to a single function template, and the explicitly-specified template arguments are enough to determine the instantiation, and either template argument deduction fails or is not performed in that context, we can resolve the template-id down to a function template specialization (so sayeth C++0x [temp.arg.explicit]p3). Fixes PR5811. llvm-svn: 91852
2009-12-22 07:17:24 +08:00
if (!ArgFunctionType.isNull()) {
Fix PR15291: noreturn adjustment in overload resolution for function templates, from Alexander Zinenko! llvm-svn: 179680
2013-04-17 16:45:07 +08:00
unsigned TDF = TDF_TopLevelParameterTypeList;
if (InOverloadResolution) TDF |= TDF_InOverloadResolution;
When a template-id refers to a single function template, and the explicitly-specified template arguments are enough to determine the instantiation, and either template argument deduction fails or is not performed in that context, we can resolve the template-id down to a function template specialization (so sayeth C++0x [temp.arg.explicit]p3). Fixes PR5811. llvm-svn: 91852
2009-12-22 07:17:24 +08:00
// Deduce template arguments from the function type.
if (TemplateDeductionResult Result
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
= DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams,
Fix PR15291: noreturn adjustment in overload resolution for function templates, from Alexander Zinenko! llvm-svn: 179680
2013-04-17 16:45:07 +08:00
FunctionType, ArgFunctionType,
Info, Deduced, TDF))
When a template-id refers to a single function template, and the explicitly-specified template arguments are enough to determine the instantiation, and either template argument deduction fails or is not performed in that context, we can resolve the template-id down to a function template specialization (so sayeth C++0x [temp.arg.explicit]p3). Fixes PR5811. llvm-svn: 91852
2009-12-22 07:17:24 +08:00
return Result;
}
When performing template argument deduction of a function template against a function type, be sure to check the type of the resulting function template specialization against the desired function type after substituting the deduced/defaulted template arguments. Fixes PR8196. llvm-svn: 115086
2010-09-30 05:14:36 +08:00
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
if (TemplateDeductionResult Result
When performing template argument deduction of a function template against a function type, be sure to check the type of the resulting function template specialization against the desired function type after substituting the deduced/defaulted template arguments. Fixes PR8196. llvm-svn: 115086
2010-09-30 05:14:36 +08:00
= FinishTemplateArgumentDeduction(FunctionTemplate, Deduced,
NumExplicitlySpecified,
Specialization, Info))
return Result;
Implement most of N3638 (return type deduction for normal functions). Missing (somewhat ironically) is support for the new deduction rules in lambda functions, plus PCH support for return type patching. llvm-svn: 181108
2013-05-04 15:00:32 +08:00
// If the function has a deduced return type, deduce it now, so we can check
// that the deduced function type matches the requested type.
PR16875: The return type of a dependent function type is visible when it's referenced as a member of the current instantiation. In that case, deduce the type of the function to a dependent type rather than exposing an undeduced auto type to the rest of the current instantiation. The standard doesn't really say that the type is dependent in this case; I'll bring this up with CWG. llvm-svn: 188410
2013-08-15 04:16:31 +08:00
if (HasDeducedReturnType &&
Implement most of N3638 (return type deduction for normal functions). Missing (somewhat ironically) is support for the new deduction rules in lambda functions, plus PCH support for return type patching. llvm-svn: 181108
2013-05-04 15:00:32 +08:00
Specialization->getResultType()->isUndeducedType() &&
DeduceReturnType(Specialization, Info.getLocation(), false))
return TDK_MiscellaneousDeductionFailure;
When performing template argument deduction of a function template against a function type, be sure to check the type of the resulting function template specialization against the desired function type after substituting the deduced/defaulted template arguments. Fixes PR8196. llvm-svn: 115086
2010-09-30 05:14:36 +08:00
// If the requested function type does not match the actual type of the
Fix PR15291: noreturn adjustment in overload resolution for function templates, from Alexander Zinenko! llvm-svn: 179680
2013-04-17 16:45:07 +08:00
// specialization with respect to arguments of compatible pointer to function
// types, template argument deduction fails.
if (!ArgFunctionType.isNull()) {
if (InOverloadResolution && !isSameOrCompatibleFunctionType(
Context.getCanonicalType(Specialization->getType()),
Context.getCanonicalType(ArgFunctionType)))
return TDK_MiscellaneousDeductionFailure;
else if(!InOverloadResolution &&
!Context.hasSameType(Specialization->getType(), ArgFunctionType))
return TDK_MiscellaneousDeductionFailure;
}
When performing template argument deduction of a function template against a function type, be sure to check the type of the resulting function template specialization against the desired function type after substituting the deduced/defaulted template arguments. Fixes PR8196. llvm-svn: 115086
2010-09-30 05:14:36 +08:00
return TDK_Success;
Improved semantic analysis and AST respresentation for function templates. For example, this now type-checks (but does not instantiate the body of deref<int>): template<typename T> T& deref(T* t) { return *t; } void test(int *ip) { int &ir = deref(ip); } Specific changes/additions: * Template argument deduction from a call to a function template. * Instantiation of a function template specializations (just the declarations) from the template arguments deduced from a call. * FunctionTemplateDecls are stored directly in declaration contexts and found via name lookup (all forms), rather than finding the FunctionDecl and then realizing it is a template. This is responsible for most of the churn, since some of the core declaration matching and lookup code assumes that all functions are FunctionDecls. llvm-svn: 74213
2009-06-26 06:08:12 +08:00
}
Implement conversion function templates, along with the ability to use template argument deduction from a conversion function (C++ [temp.deduct.conv]) with implicit conversions. llvm-svn: 79693
2009-08-22 07:19:43 +08:00
/// \brief Deduce template arguments for a templated conversion
/// function (C++ [temp.deduct.conv]) and, if successful, produce a
/// conversion function template specialization.
Sema::TemplateDeductionResult
Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
QualType ToType,
CXXConversionDecl *&Specialization,
TemplateDeductionInfo &Info) {
Don't perform template argument deduction against invalid templates; it's likely to lead to a crash later on. Fixes PR12933 / <rdar://problem/11525335>. llvm-svn: 163838
2012-09-14 05:01:57 +08:00
if (FunctionTemplate->isInvalidDecl())
return TDK_Invalid;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
CXXConversionDecl *Conv
Implement conversion function templates, along with the ability to use template argument deduction from a conversion function (C++ [temp.deduct.conv]) with implicit conversions. llvm-svn: 79693
2009-08-22 07:19:43 +08:00
= cast<CXXConversionDecl>(FunctionTemplate->getTemplatedDecl());
QualType FromType = Conv->getConversionType();
// Canonicalize the types for deduction.
QualType P = Context.getCanonicalType(FromType);
QualType A = Context.getCanonicalType(ToType);
When performing template argument deduction for a non-reference conversion function when we're binding the result to a reference, drop cv-qualifiers on the type we're referring to, since we should be deducing a type that can be adjusted (via cv-qualification) to the requested type. Fixes PR9336, and the remaining Boost.Assign failure. llvm-svn: 127117
2011-03-06 17:03:20 +08:00
// C++0x [temp.deduct.conv]p2:
Implement conversion function templates, along with the ability to use template argument deduction from a conversion function (C++ [temp.deduct.conv]) with implicit conversions. llvm-svn: 79693
2009-08-22 07:19:43 +08:00
// If P is a reference type, the type referred to by P is used for
// type deduction.
if (const ReferenceType *PRef = P->getAs<ReferenceType>())
P = PRef->getPointeeType();
When performing template argument deduction for a non-reference conversion function when we're binding the result to a reference, drop cv-qualifiers on the type we're referring to, since we should be deducing a type that can be adjusted (via cv-qualification) to the requested type. Fixes PR9336, and the remaining Boost.Assign failure. llvm-svn: 127117
2011-03-06 17:03:20 +08:00
// C++0x [temp.deduct.conv]p4:
// [...] If A is a reference type, the type referred to by A is used
Implement conversion function templates, along with the ability to use template argument deduction from a conversion function (C++ [temp.deduct.conv]) with implicit conversions. llvm-svn: 79693
2009-08-22 07:19:43 +08:00
// for type deduction.
if (const ReferenceType *ARef = A->getAs<ReferenceType>())
When performing template argument deduction for a non-reference conversion function when we're binding the result to a reference, drop cv-qualifiers on the type we're referring to, since we should be deducing a type that can be adjusted (via cv-qualification) to the requested type. Fixes PR9336, and the remaining Boost.Assign failure. llvm-svn: 127117
2011-03-06 17:03:20 +08:00
A = ARef->getPointeeType().getUnqualifiedType();
// C++ [temp.deduct.conv]p3:
Implement conversion function templates, along with the ability to use template argument deduction from a conversion function (C++ [temp.deduct.conv]) with implicit conversions. llvm-svn: 79693
2009-08-22 07:19:43 +08:00
//
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
// If A is not a reference type:
Implement conversion function templates, along with the ability to use template argument deduction from a conversion function (C++ [temp.deduct.conv]) with implicit conversions. llvm-svn: 79693
2009-08-22 07:19:43 +08:00
else {
assert(!A->isReferenceType() && "Reference types were handled above");
// - If P is an array type, the pointer type produced by the
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
// array-to-pointer standard conversion (4.2) is used in place
Implement conversion function templates, along with the ability to use template argument deduction from a conversion function (C++ [temp.deduct.conv]) with implicit conversions. llvm-svn: 79693
2009-08-22 07:19:43 +08:00
// of P for type deduction; otherwise,
if (P->isArrayType())
P = Context.getArrayDecayedType(P);
// - If P is a function type, the pointer type produced by the
// function-to-pointer standard conversion (4.3) is used in
// place of P for type deduction; otherwise,
else if (P->isFunctionType())
P = Context.getPointerType(P);
// - If P is a cv-qualified type, the top level cv-qualifiers of
7bit-ize. llvm-svn: 124363
2011-01-27 15:09:49 +08:00
// P's type are ignored for type deduction.
Implement conversion function templates, along with the ability to use template argument deduction from a conversion function (C++ [temp.deduct.conv]) with implicit conversions. llvm-svn: 79693
2009-08-22 07:19:43 +08:00
else
P = P.getUnqualifiedType();
When performing template argument deduction for a non-reference conversion function when we're binding the result to a reference, drop cv-qualifiers on the type we're referring to, since we should be deducing a type that can be adjusted (via cv-qualification) to the requested type. Fixes PR9336, and the remaining Boost.Assign failure. llvm-svn: 127117
2011-03-06 17:03:20 +08:00
// C++0x [temp.deduct.conv]p4:
7bit-ize. llvm-svn: 124363
2011-01-27 15:09:49 +08:00
// If A is a cv-qualified type, the top level cv-qualifiers of A's
When performing template argument deduction for a non-reference conversion function when we're binding the result to a reference, drop cv-qualifiers on the type we're referring to, since we should be deducing a type that can be adjusted (via cv-qualification) to the requested type. Fixes PR9336, and the remaining Boost.Assign failure. llvm-svn: 127117
2011-03-06 17:03:20 +08:00
// type are ignored for type deduction. If A is a reference type, the type
// referred to by A is used for type deduction.
Implement conversion function templates, along with the ability to use template argument deduction from a conversion function (C++ [temp.deduct.conv]) with implicit conversions. llvm-svn: 79693
2009-08-22 07:19:43 +08:00
A = A.getUnqualifiedType();
}
Make sure template argument deduction is consistently performed in an unevaluated context. llvm-svn: 150049
2012-02-08 11:07:05 +08:00
// Unevaluated SFINAE context.
EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
SFINAETrap Trap(*this);
Implement conversion function templates, along with the ability to use template argument deduction from a conversion function (C++ [temp.deduct.conv]) with implicit conversions. llvm-svn: 79693
2009-08-22 07:19:43 +08:00
// C++ [temp.deduct.conv]p1:
// Template argument deduction is done by comparing the return
// type of the template conversion function (call it P) with the
// type that is required as the result of the conversion (call it
// A) as described in 14.8.2.4.
TemplateParameterList *TemplateParams
= FunctionTemplate->getTemplateParameters();
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<DeducedTemplateArgument, 4> Deduced;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Deduced.resize(TemplateParams->size());
Implement conversion function templates, along with the ability to use template argument deduction from a conversion function (C++ [temp.deduct.conv]) with implicit conversions. llvm-svn: 79693
2009-08-22 07:19:43 +08:00
// C++0x [temp.deduct.conv]p4:
// In general, the deduction process attempts to find template
// argument values that will make the deduced A identical to
// A. However, there are two cases that allow a difference:
unsigned TDF = 0;
// - If the original A is a reference type, A can be more
// cv-qualified than the deduced A (i.e., the type referred to
// by the reference)
if (ToType->isReferenceType())
TDF |= TDF_ParamWithReferenceType;
// - The deduced A can be another pointer or pointer to member
7bit-ize. llvm-svn: 124363
2011-01-27 15:09:49 +08:00
// type that can be converted to A via a qualification
Implement conversion function templates, along with the ability to use template argument deduction from a conversion function (C++ [temp.deduct.conv]) with implicit conversions. llvm-svn: 79693
2009-08-22 07:19:43 +08:00
// conversion.
//
// (C++0x [temp.deduct.conv]p6 clarifies that this only happens when
// both P and A are pointers or member pointers. In this case, we
// just ignore cv-qualifiers completely).
if ((P->isPointerType() && A->isPointerType()) ||
Fix a typo when determining whether to strip cv-qualifiers during template argument deduction llvm-svn: 138787
2011-08-30 08:37:54 +08:00
(P->isMemberPointerType() && A->isMemberPointerType()))
Implement conversion function templates, along with the ability to use template argument deduction from a conversion function (C++ [temp.deduct.conv]) with implicit conversions. llvm-svn: 79693
2009-08-22 07:19:43 +08:00
TDF |= TDF_IgnoreQualifiers;
if (TemplateDeductionResult Result
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
= DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams,
P, A, Info, Deduced, TDF))
Implement conversion function templates, along with the ability to use template argument deduction from a conversion function (C++ [temp.deduct.conv]) with implicit conversions. llvm-svn: 79693
2009-08-22 07:19:43 +08:00
return Result;
// Finish template argument deduction.
Move more stuff out of Sema.h. llvm-svn: 112026
2010-08-25 13:32:35 +08:00
LocalInstantiationScope InstScope(*this);
Implement conversion function templates, along with the ability to use template argument deduction from a conversion function (C++ [temp.deduct.conv]) with implicit conversions. llvm-svn: 79693
2009-08-22 07:19:43 +08:00
FunctionDecl *Spec = 0;
TemplateDeductionResult Result
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
= FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, 0, Spec,
After performing template argument deduction for a function template, check deduced non-type template arguments and template template arguments against the template parameters for which they were deduced, performing conversions as appropriate so that deduced template arguments get the same treatment as explicitly-specified template arguments. This is the bulk of PR6723. Also keep track of whether deduction of a non-type template argument came from an array bound (vs. anywhere else). With this information, we enforce C++ [temp.deduct.type]p17, which requires exact type matches when deduction deduces a non-type template argument from something that is not an array bound. Finally, when in a SFINAE context, translate the "zero sized arrays are an extension" extension diagnostic into a hard error (for better standard conformance), which was a minor part of PR6723. llvm-svn: 99734
2010-03-28 10:42:43 +08:00
Info);
Implement conversion function templates, along with the ability to use template argument deduction from a conversion function (C++ [temp.deduct.conv]) with implicit conversions. llvm-svn: 79693
2009-08-22 07:19:43 +08:00
Specialization = cast_or_null<CXXConversionDecl>(Spec);
return Result;
}
When a template-id refers to a single function template, and the explicitly-specified template arguments are enough to determine the instantiation, and either template argument deduction fails or is not performed in that context, we can resolve the template-id down to a function template specialization (so sayeth C++0x [temp.arg.explicit]p3). Fixes PR5811. llvm-svn: 91852
2009-12-22 07:17:24 +08:00
/// \brief Deduce template arguments for a function template when there is
/// nothing to deduce against (C++0x [temp.arg.explicit]p3).
///
/// \param FunctionTemplate the function template for which we are performing
/// template argument deduction.
///
Diagnostics cleanup: Fixing \params to match the code. llvm-svn: 158981
2012-06-22 16:52:37 +08:00
/// \param ExplicitTemplateArgs the explicitly-specified template
When a template-id refers to a single function template, and the explicitly-specified template arguments are enough to determine the instantiation, and either template argument deduction fails or is not performed in that context, we can resolve the template-id down to a function template specialization (so sayeth C++0x [temp.arg.explicit]p3). Fixes PR5811. llvm-svn: 91852
2009-12-22 07:17:24 +08:00
/// arguments.
///
/// \param Specialization if template argument deduction was successful,
/// this will be set to the function template specialization produced by
/// template argument deduction.
///
/// \param Info the argument will be updated to provide additional information
/// about template argument deduction.
///
/// \returns the result of template argument deduction.
Sema::TemplateDeductionResult
Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
When we use the default template arguments of a template template parameter, save the instantiated default template arguments along with the explicitly-specified template argument list. That way, we prefer the default template template arguments corresponding to the template template parameter rather than those of its template template argument. This addresses the likely direction of C++ core issue 150, and fixes PR9353/<rdar://problem/9069136>, bringing us closer to the behavior of EDG and GCC. llvm-svn: 126920
2011-03-03 10:41:12 +08:00
TemplateArgumentListInfo *ExplicitTemplateArgs,
When a template-id refers to a single function template, and the explicitly-specified template arguments are enough to determine the instantiation, and either template argument deduction fails or is not performed in that context, we can resolve the template-id down to a function template specialization (so sayeth C++0x [temp.arg.explicit]p3). Fixes PR5811. llvm-svn: 91852
2009-12-22 07:17:24 +08:00
FunctionDecl *&Specialization,
Fix PR15291: noreturn adjustment in overload resolution for function templates, from Alexander Zinenko! llvm-svn: 179680
2013-04-17 16:45:07 +08:00
TemplateDeductionInfo &Info,
bool InOverloadResolution) {
When a template-id refers to a single function template, and the explicitly-specified template arguments are enough to determine the instantiation, and either template argument deduction fails or is not performed in that context, we can resolve the template-id down to a function template specialization (so sayeth C++0x [temp.arg.explicit]p3). Fixes PR5811. llvm-svn: 91852
2009-12-22 07:17:24 +08:00
return DeduceTemplateArguments(FunctionTemplate, ExplicitTemplateArgs,
Fix PR15291: noreturn adjustment in overload resolution for function templates, from Alexander Zinenko! llvm-svn: 179680
2013-04-17 16:45:07 +08:00
QualType(), Specialization, Info,
InOverloadResolution);
When a template-id refers to a single function template, and the explicitly-specified template arguments are enough to determine the instantiation, and either template argument deduction fails or is not performed in that context, we can resolve the template-id down to a function template specialization (so sayeth C++0x [temp.arg.explicit]p3). Fixes PR5811. llvm-svn: 91852
2009-12-22 07:17:24 +08:00
}
Implement the C++0x deduced 'auto' feature. This fixes PR 8738, 9060 and 9132. llvm-svn: 126069
2011-02-20 11:19:35 +08:00
namespace {
/// Substitute the 'auto' type specifier within a type for a given replacement
/// type.
class SubstituteAutoTransform :
public TreeTransform<SubstituteAutoTransform> {
QualType Replacement;
public:
SubstituteAutoTransform(Sema &SemaRef, QualType Replacement) :
TreeTransform<SubstituteAutoTransform>(SemaRef), Replacement(Replacement) {
}
QualType TransformAutoType(TypeLocBuilder &TLB, AutoTypeLoc TL) {
// If we're building the type pattern to deduce against, don't wrap the
// substituted type in an AutoType. Certain template deduction rules
// apply only when a template type parameter appears directly (and not if
// the parameter is found through desugaring). For instance:
// auto &&lref = lvalue;
// must transform into "rvalue reference to T" not "rvalue reference to
// auto type deduced as T" in order for [temp.deduct.call]p3 to apply.
Implement most of N3638 (return type deduction for normal functions). Missing (somewhat ironically) is support for the new deduction rules in lambda functions, plus PCH support for return type patching. llvm-svn: 181108
2013-05-04 15:00:32 +08:00
if (!Replacement.isNull() && isa<TemplateTypeParmType>(Replacement)) {
Implement the C++0x deduced 'auto' feature. This fixes PR 8738, 9060 and 9132. llvm-svn: 126069
2011-02-20 11:19:35 +08:00
QualType Result = Replacement;
Implement C++1y decltype(auto). llvm-svn: 180610
2013-04-27 00:15:35 +08:00
TemplateTypeParmTypeLoc NewTL =
TLB.push<TemplateTypeParmTypeLoc>(Result);
Implement the C++0x deduced 'auto' feature. This fixes PR 8738, 9060 and 9132. llvm-svn: 126069
2011-02-20 11:19:35 +08:00
NewTL.setNameLoc(TL.getNameLoc());
return Result;
} else {
Don't treat a non-deduced 'auto' type as being type-dependent. Instead, there are now two distinct canonical 'AutoType's: one is the undeduced 'auto' placeholder type, and the other is a deduced-but-dependent type. All deduced-to-a-non-dependent-type cases are still non-canonical. llvm-svn: 180789
2013-04-30 21:56:41 +08:00
bool Dependent =
!Replacement.isNull() && Replacement->isDependentType();
QualType Result =
SemaRef.Context.getAutoType(Dependent ? QualType() : Replacement,
TL.getTypePtr()->isDecltypeAuto(),
Revert "Implement a rudimentary form of generic lambdas." This reverts commit 606f5d7a99b11957e057e4cd1f55f931f66a42c7. llvm-svn: 189004
2013-08-22 20:12:24 +08:00
Dependent);
Implement the C++0x deduced 'auto' feature. This fixes PR 8738, 9060 and 9132. llvm-svn: 126069
2011-02-20 11:19:35 +08:00
AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());
return Result;
}
}
Introduce support for template instantiation of lambda expressions. This is mostly a simple refact, splitting the main "start a lambda expression" function into smaller chunks that are driven either from the parser (Sema::ActOnLambdaExpr) or during AST transformation (TreeTransform::TransformLambdaExpr). A few minor interesting points: - Added new entry points for TreeTransform, so that we can explicitly establish the link between the lambda closure type in the template and the lambda closure type in the instantiation. - Added a bit into LambdaExpr specifying whether it had an explicit result type or not. We should have had this anyway. This code is 'lightly' tested. llvm-svn: 150417
2012-02-14 06:00:16 +08:00
ExprResult TransformLambdaExpr(LambdaExpr *E) {
// Lambdas never need to be transformed.
return E;
}
When deducing an 'auto' type, don't modify the type-as-written. llvm-svn: 180808
2013-05-01 05:23:01 +08:00
Implement most of N3638 (return type deduction for normal functions). Missing (somewhat ironically) is support for the new deduction rules in lambda functions, plus PCH support for return type patching. llvm-svn: 181108
2013-05-04 15:00:32 +08:00
QualType Apply(TypeLoc TL) {
// Create some scratch storage for the transformed type locations.
// FIXME: We're just going to throw this information away. Don't build it.
TypeLocBuilder TLB;
TLB.reserve(TL.getFullDataSize());
return TransformType(TLB, TL);
When deducing an 'auto' type, don't modify the type-as-written. llvm-svn: 180808
2013-05-01 05:23:01 +08:00
}
Implement the C++0x deduced 'auto' feature. This fixes PR 8738, 9060 and 9132. llvm-svn: 126069
2011-02-20 11:19:35 +08:00
};
}
Implement most of N3638 (return type deduction for normal functions). Missing (somewhat ironically) is support for the new deduction rules in lambda functions, plus PCH support for return type patching. llvm-svn: 181108
2013-05-04 15:00:32 +08:00
Sema::DeduceAutoResult
Sema::DeduceAutoType(TypeSourceInfo *Type, Expr *&Init, QualType &Result) {
return DeduceAutoType(Type->getTypeLoc(), Init, Result);
}
When deducing an 'auto' type, don't modify the type-as-written. llvm-svn: 180808
2013-05-01 05:23:01 +08:00
/// \brief Deduce the type for an auto type-specifier (C++11 [dcl.spec.auto]p6)
Implement the C++0x deduced 'auto' feature. This fixes PR 8738, 9060 and 9132. llvm-svn: 126069
2011-02-20 11:19:35 +08:00
///
/// \param Type the type pattern using the auto type-specifier.
/// \param Init the initializer for the variable whose type is to be deduced.
/// \param Result if type deduction was successful, this will be set to the
When deducing an 'auto' type, don't modify the type-as-written. llvm-svn: 180808
2013-05-01 05:23:01 +08:00
/// deduced type.
Minor fixups for auto deduction of initializer lists. Fix some review comments. Add a test for deduction when std::initializer_list isn't available yet. Fix redundant error messages. This fixes and outstanding FIXME too. llvm-svn: 148735
2012-01-24 06:09:39 +08:00
Sema::DeduceAutoResult
Implement most of N3638 (return type deduction for normal functions). Missing (somewhat ironically) is support for the new deduction rules in lambda functions, plus PCH support for return type patching. llvm-svn: 181108
2013-05-04 15:00:32 +08:00
Sema::DeduceAutoType(TypeLoc Type, Expr *&Init, QualType &Result) {
Resolve placeholder expressions before trying to deduce 'auto'. Introduce a convenience method to make this a bit easier, and use it elsewhere. llvm-svn: 144605
2011-11-15 09:35:18 +08:00
if (Init->getType()->isNonOverloadPlaceholderType()) {
When deducing an 'auto' type, don't modify the type-as-written. llvm-svn: 180808
2013-05-01 05:23:01 +08:00
ExprResult NonPlaceholder = CheckPlaceholderExpr(Init);
if (NonPlaceholder.isInvalid())
return DAR_FailedAlreadyDiagnosed;
Init = NonPlaceholder.take();
Resolve placeholder expressions before trying to deduce 'auto'. Introduce a convenience method to make this a bit easier, and use it elsewhere. llvm-svn: 144605
2011-11-15 09:35:18 +08:00
}
Implement most of N3638 (return type deduction for normal functions). Missing (somewhat ironically) is support for the new deduction rules in lambda functions, plus PCH support for return type patching. llvm-svn: 181108
2013-05-04 15:00:32 +08:00
if (Init->isTypeDependent() || Type.getType()->isDependentType()) {
When deducing an 'auto' type, don't modify the type-as-written. llvm-svn: 180808
2013-05-01 05:23:01 +08:00
Result = SubstituteAutoTransform(*this, Context.DependentTy).Apply(Type);
Implement most of N3638 (return type deduction for normal functions). Missing (somewhat ironically) is support for the new deduction rules in lambda functions, plus PCH support for return type patching. llvm-svn: 181108
2013-05-04 15:00:32 +08:00
assert(!Result.isNull() && "substituting DependentTy can't fail");
Minor fixups for auto deduction of initializer lists. Fix some review comments. Add a test for deduction when std::initializer_list isn't available yet. Fix redundant error messages. This fixes and outstanding FIXME too. llvm-svn: 148735
2012-01-24 06:09:39 +08:00
return DAR_Succeeded;
Implement the C++0x deduced 'auto' feature. This fixes PR 8738, 9060 and 9132. llvm-svn: 126069
2011-02-20 11:19:35 +08:00
}
Implement C++1y decltype(auto). llvm-svn: 180610
2013-04-27 00:15:35 +08:00
// If this is a 'decltype(auto)' specifier, do the decltype dance.
// Since 'decltype(auto)' can only occur at the top of the type, we
// don't need to go digging for it.
Implement most of N3638 (return type deduction for normal functions). Missing (somewhat ironically) is support for the new deduction rules in lambda functions, plus PCH support for return type patching. llvm-svn: 181108
2013-05-04 15:00:32 +08:00
if (const AutoType *AT = Type.getType()->getAs<AutoType>()) {
Implement C++1y decltype(auto). llvm-svn: 180610
2013-04-27 00:15:35 +08:00
if (AT->isDecltypeAuto()) {
if (isa<InitListExpr>(Init)) {
Diag(Init->getLocStart(), diag::err_decltype_auto_initializer_list);
return DAR_FailedAlreadyDiagnosed;
}
QualType Deduced = BuildDecltypeType(Init, Init->getLocStart());
// FIXME: Support a non-canonical deduced type for 'auto'.
Deduced = Context.getCanonicalType(Deduced);
When deducing an 'auto' type, don't modify the type-as-written. llvm-svn: 180808
2013-05-01 05:23:01 +08:00
Result = SubstituteAutoTransform(*this, Deduced).Apply(Type);
Implement most of N3638 (return type deduction for normal functions). Missing (somewhat ironically) is support for the new deduction rules in lambda functions, plus PCH support for return type patching. llvm-svn: 181108
2013-05-04 15:00:32 +08:00
if (Result.isNull())
return DAR_FailedAlreadyDiagnosed;
Implement C++1y decltype(auto). llvm-svn: 180610
2013-04-27 00:15:35 +08:00
return DAR_Succeeded;
}
}
Implement the C++0x deduced 'auto' feature. This fixes PR 8738, 9060 and 9132. llvm-svn: 126069
2011-02-20 11:19:35 +08:00
SourceLocation Loc = Init->getExprLoc();
LocalInstantiationScope InstScope(*this);
// Build template<class TemplParam> void Func(FuncParam);
Re-applies the patch first applied way back in r106099, with accompanying fixes to make it work today. The core of this patch is to provide a link from a TemplateTypeParmType back to the TemplateTypeParmDecl node which declared it. This in turn provides much more precise information about the type, where it came from, and how it functions for AST consumers. To make the patch work almost a year after its first attempt, it needed serialization support, and it now retains the old getName() interface. Finally, it requires us to not attempt to instantiate the type in an unsupported friend decl -- specifically those coming from template friend decls but which refer to a specific type through a dependent name. A cleaner representation of the last item would be to build FriendTemplateDecl nodes for these, storing their template parameters etc, and to perform proper instantation of them like any other template declaration. They can still be flagged as unsupported for the purpose of access checking, etc. This passed an asserts-enabled bootstrap for me, and the reduced test case mentioned in the original review thread no longer causes issues, likely fixed at somewhere amidst the 24k revisions that have elapsed. llvm-svn: 130628
2011-05-01 08:51:33 +08:00
TemplateTypeParmDecl *TemplParam =
TemplateTypeParmDecl::Create(Context, 0, SourceLocation(), Loc, 0, 0, 0,
false, false);
QualType TemplArg = QualType(TemplParam->getTypeForDecl(), 0);
NamedDecl *TemplParamPtr = TemplParam;
Tweaks to C++0x deduced auto type support: * Flag indicating 'we're parsing this auto typed variable's initializer' moved from VarDecl to Sema * Temporary template parameter list for auto deduction is now allocated on the stack. * Deduced 'auto' types are now uniqued. llvm-svn: 126139
2011-02-22 04:05:19 +08:00
FixedSizeTemplateParameterList<1> TemplateParams(Loc, Loc, &TemplParamPtr,
Loc);
When deducing an 'auto' type, don't modify the type-as-written. llvm-svn: 180808
2013-05-01 05:23:01 +08:00
QualType FuncParam = SubstituteAutoTransform(*this, TemplArg).Apply(Type);
assert(!FuncParam.isNull() &&
"substituting template parameter for 'auto' failed");
Implement the C++0x deduced 'auto' feature. This fixes PR 8738, 9060 and 9132. llvm-svn: 126069
2011-02-20 11:19:35 +08:00
// Deduce type of TemplParam in Func(Init)
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<DeducedTemplateArgument, 1> Deduced;
Implement the C++0x deduced 'auto' feature. This fixes PR 8738, 9060 and 9132. llvm-svn: 126069
2011-02-20 11:19:35 +08:00
Deduced.resize(1);
QualType InitType = Init->getType();
unsigned TDF = 0;
Remove Context argument from TemplateDeductionInfo constructor. It was no longer needed after the unused Context member was removed in r164104. llvm-svn: 164196
2012-09-19 10:26:47 +08:00
TemplateDeductionInfo Info(Loc);
Auto deduction support for std::initializer_list, including for-range support. This means you can now write: for (int i : {1, 4, 512, 23, 251}) {} llvm-svn: 148353
2012-01-18 06:50:08 +08:00
PR13293: Defer deduction of an auto type with a dependent declarator, such as "auto (*f)(T t)". llvm-svn: 159908
2012-07-08 12:13:07 +08:00
InitListExpr *InitList = dyn_cast<InitListExpr>(Init);
Auto deduction support for std::initializer_list, including for-range support. This means you can now write: for (int i : {1, 4, 512, 23, 251}) {} llvm-svn: 148353
2012-01-18 06:50:08 +08:00
if (InitList) {
for (unsigned i = 0, e = InitList->getNumInits(); i < e; ++i) {
PR13293: Defer deduction of an auto type with a dependent declarator, such as "auto (*f)(T t)". llvm-svn: 159908
2012-07-08 12:13:07 +08:00
if (DeduceTemplateArgumentByListElement(*this, &TemplateParams,
When performing template argument deduction for an initializer list, be sure to perform the argument type adjustments in [temp.deduct.call]p2, e.g., array decay. And, when performing these deductions in the context of 'auto', make sure that we're deducing the P' in std::initializer_list<P'> rather than the whole initializer list. Together, this makes code like for( auto s : {"Deferred", "New", "Open", "Review"}) { } work properly. llvm-svn: 153998
2012-04-04 13:10:53 +08:00
TemplArg,
InitList->getInit(i),
Info, Deduced, TDF))
Minor fixups for auto deduction of initializer lists. Fix some review comments. Add a test for deduction when std::initializer_list isn't available yet. Fix redundant error messages. This fixes and outstanding FIXME too. llvm-svn: 148735
2012-01-24 06:09:39 +08:00
return DAR_Failed;
Auto deduction support for std::initializer_list, including for-range support. This means you can now write: for (int i : {1, 4, 512, 23, 251}) {} llvm-svn: 148353
2012-01-18 06:50:08 +08:00
}
} else {
When performing template argument deduction for an initializer list, be sure to perform the argument type adjustments in [temp.deduct.call]p2, e.g., array decay. And, when performing these deductions in the context of 'auto', make sure that we're deducing the P' in std::initializer_list<P'> rather than the whole initializer list. Together, this makes code like for( auto s : {"Deferred", "New", "Open", "Review"}) { } work properly. llvm-svn: 153998
2012-04-04 13:10:53 +08:00
if (AdjustFunctionParmAndArgTypesForDeduction(*this, &TemplateParams,
FuncParam, InitType, Init,
TDF))
return DAR_Failed;
PR13293: Defer deduction of an auto type with a dependent declarator, such as "auto (*f)(T t)". llvm-svn: 159908
2012-07-08 12:13:07 +08:00
Auto deduction support for std::initializer_list, including for-range support. This means you can now write: for (int i : {1, 4, 512, 23, 251}) {} llvm-svn: 148353
2012-01-18 06:50:08 +08:00
if (DeduceTemplateArgumentsByTypeMatch(*this, &TemplateParams, FuncParam,
InitType, Info, Deduced, TDF))
Minor fixups for auto deduction of initializer lists. Fix some review comments. Add a test for deduction when std::initializer_list isn't available yet. Fix redundant error messages. This fixes and outstanding FIXME too. llvm-svn: 148735
2012-01-24 06:09:39 +08:00
return DAR_Failed;
Auto deduction support for std::initializer_list, including for-range support. This means you can now write: for (int i : {1, 4, 512, 23, 251}) {} llvm-svn: 148353
2012-01-18 06:50:08 +08:00
}
Implement the C++0x deduced 'auto' feature. This fixes PR 8738, 9060 and 9132. llvm-svn: 126069
2011-02-20 11:19:35 +08:00
Fix assertion failure with auto and nested initializer list; PR14272. llvm-svn: 167506
2012-11-07 07:56:42 +08:00
if (Deduced[0].getKind() != TemplateArgument::Type)
Minor fixups for auto deduction of initializer lists. Fix some review comments. Add a test for deduction when std::initializer_list isn't available yet. Fix redundant error messages. This fixes and outstanding FIXME too. llvm-svn: 148735
2012-01-24 06:09:39 +08:00
return DAR_Failed;
Auto deduction support for std::initializer_list, including for-range support. This means you can now write: for (int i : {1, 4, 512, 23, 251}) {} llvm-svn: 148353
2012-01-18 06:50:08 +08:00
Fix assertion failure with auto and nested initializer list; PR14272. llvm-svn: 167506
2012-11-07 07:56:42 +08:00
QualType DeducedType = Deduced[0].getAsType();
Auto deduction support for std::initializer_list, including for-range support. This means you can now write: for (int i : {1, 4, 512, 23, 251}) {} llvm-svn: 148353
2012-01-18 06:50:08 +08:00
if (InitList) {
DeducedType = BuildStdInitializerList(DeducedType, Loc);
if (DeducedType.isNull())
Minor fixups for auto deduction of initializer lists. Fix some review comments. Add a test for deduction when std::initializer_list isn't available yet. Fix redundant error messages. This fixes and outstanding FIXME too. llvm-svn: 148735
2012-01-24 06:09:39 +08:00
return DAR_FailedAlreadyDiagnosed;
Auto deduction support for std::initializer_list, including for-range support. This means you can now write: for (int i : {1, 4, 512, 23, 251}) {} llvm-svn: 148353
2012-01-18 06:50:08 +08:00
}
When deducing an 'auto' type, don't modify the type-as-written. llvm-svn: 180808
2013-05-01 05:23:01 +08:00
Result = SubstituteAutoTransform(*this, DeducedType).Apply(Type);
Implement most of N3638 (return type deduction for normal functions). Missing (somewhat ironically) is support for the new deduction rules in lambda functions, plus PCH support for return type patching. llvm-svn: 181108
2013-05-04 15:00:32 +08:00
if (Result.isNull())
return DAR_FailedAlreadyDiagnosed;
Auto deduction support for std::initializer_list, including for-range support. This means you can now write: for (int i : {1, 4, 512, 23, 251}) {} llvm-svn: 148353
2012-01-18 06:50:08 +08:00
Extend the deduced/actual argument type checking of C++ [temp.deduct.call]p4 to the deduction performed for 'auto', finishing the fix for PR9233. llvm-svn: 133239
2011-06-17 13:31:46 +08:00
// Check that the deduced argument type is compatible with the original
// argument type per C++ [temp.deduct.call]p4.
When deducing an 'auto' type, don't modify the type-as-written. llvm-svn: 180808
2013-05-01 05:23:01 +08:00
if (!InitList && !Result.isNull() &&
CheckOriginalCallArgDeduction(*this,
Extend the deduced/actual argument type checking of C++ [temp.deduct.call]p4 to the deduction performed for 'auto', finishing the fix for PR9233. llvm-svn: 133239
2011-06-17 13:31:46 +08:00
Sema::OriginalCallArg(FuncParam,0,InitType),
When deducing an 'auto' type, don't modify the type-as-written. llvm-svn: 180808
2013-05-01 05:23:01 +08:00
Result)) {
Result = QualType();
Minor fixups for auto deduction of initializer lists. Fix some review comments. Add a test for deduction when std::initializer_list isn't available yet. Fix redundant error messages. This fixes and outstanding FIXME too. llvm-svn: 148735
2012-01-24 06:09:39 +08:00
return DAR_Failed;
Extend the deduced/actual argument type checking of C++ [temp.deduct.call]p4 to the deduction performed for 'auto', finishing the fix for PR9233. llvm-svn: 133239
2011-06-17 13:31:46 +08:00
}
Minor fixups for auto deduction of initializer lists. Fix some review comments. Add a test for deduction when std::initializer_list isn't available yet. Fix redundant error messages. This fixes and outstanding FIXME too. llvm-svn: 148735
2012-01-24 06:09:39 +08:00
return DAR_Succeeded;
Implement the C++0x deduced 'auto' feature. This fixes PR 8738, 9060 and 9132. llvm-svn: 126069
2011-02-20 11:19:35 +08:00
}
Revert "Implement a rudimentary form of generic lambdas." This reverts commit 606f5d7a99b11957e057e4cd1f55f931f66a42c7. llvm-svn: 189004
2013-08-22 20:12:24 +08:00
QualType Sema::SubstAutoType(QualType Type, QualType Deduced) {
return SubstituteAutoTransform(*this, Deduced).TransformType(Type);
Don't treat a non-deduced 'auto' type as being type-dependent. Instead, there are now two distinct canonical 'AutoType's: one is the undeduced 'auto' placeholder type, and the other is a deduced-but-dependent type. All deduced-to-a-non-dependent-type cases are still non-canonical. llvm-svn: 180789
2013-04-30 21:56:41 +08:00
}
Auto deduction support for std::initializer_list, including for-range support. This means you can now write: for (int i : {1, 4, 512, 23, 251}) {} llvm-svn: 148353
2012-01-18 06:50:08 +08:00
void Sema::DiagnoseAutoDeductionFailure(VarDecl *VDecl, Expr *Init) {
if (isa<InitListExpr>(Init))
Diag(VDecl->getLocation(),
diag::err_auto_var_deduction_failure_from_init_list)
<< VDecl->getDeclName() << VDecl->getType() << Init->getSourceRange();
else
Diag(VDecl->getLocation(), diag::err_auto_var_deduction_failure)
<< VDecl->getDeclName() << VDecl->getType() << Init->getType()
<< Init->getSourceRange();
}
Implement most of N3638 (return type deduction for normal functions). Missing (somewhat ironically) is support for the new deduction rules in lambda functions, plus PCH support for return type patching. llvm-svn: 181108
2013-05-04 15:00:32 +08:00
bool Sema::DeduceReturnType(FunctionDecl *FD, SourceLocation Loc,
bool Diagnose) {
assert(FD->getResultType()->isUndeducedType());
if (FD->getTemplateInstantiationPattern())
InstantiateFunctionDefinition(Loc, FD);
bool StillUndeduced = FD->getResultType()->isUndeducedType();
if (StillUndeduced && Diagnose && !FD->isInvalidDecl()) {
Diag(Loc, diag::err_auto_fn_used_before_defined) << FD;
Diag(FD->getLocation(), diag::note_callee_decl) << FD;
}
return StillUndeduced;
}
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
static void
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(ASTContext &Ctx, QualType T,
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
bool OnlyDeduced,
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
unsigned Level,
SmallBitVectorize the deduced parameter set. llvm-svn: 149253
2012-01-31 00:17:39 +08:00
llvm::SmallBitVector &Deduced);
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
/// \brief If this is a non-static member function,
Function argument formatting fixes. llvm-svn: 185785
2013-07-08 12:13:06 +08:00
static void
AddImplicitObjectParameterType(ASTContext &Context,
CXXMethodDecl *Method,
SmallVectorImpl<QualType> &ArgTypes) {
Fix a small FIXME involving template partial ordering and member function templates with an rvalue ref qualifier. llvm-svn: 164267
2012-09-20 07:52:13 +08:00
// C++11 [temp.func.order]p3:
// [...] The new parameter is of type "reference to cv A," where cv are
// the cv-qualifiers of the function template (if any) and A is
// the class of which the function template is a member.
Implement C++ [over.match.funcs]p4 as it concerns partial ordering of function templates. Fixes PR8130. llvm-svn: 118944
2010-11-13 07:44:13 +08:00
//
Fix a small FIXME involving template partial ordering and member function templates with an rvalue ref qualifier. llvm-svn: 164267
2012-09-20 07:52:13 +08:00
// The standard doesn't say explicitly, but we pick the appropriate kind of
// reference type based on [over.match.funcs]p4.
Implement C++ [over.match.funcs]p4 as it concerns partial ordering of function templates. Fixes PR8130. llvm-svn: 118944
2010-11-13 07:44:13 +08:00
QualType ArgTy = Context.getTypeDeclType(Method->getParent());
ArgTy = Context.getQualifiedType(ArgTy,
Qualifiers::fromCVRMask(Method->getTypeQualifiers()));
Fix a small FIXME involving template partial ordering and member function templates with an rvalue ref qualifier. llvm-svn: 164267
2012-09-20 07:52:13 +08:00
if (Method->getRefQualifier() == RQ_RValue)
ArgTy = Context.getRValueReferenceType(ArgTy);
else
ArgTy = Context.getLValueReferenceType(ArgTy);
Implement C++ [over.match.funcs]p4 as it concerns partial ordering of function templates. Fixes PR8130. llvm-svn: 118944
2010-11-13 07:44:13 +08:00
ArgTypes.push_back(ArgTy);
}
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
/// \brief Determine whether the function template \p FT1 is at least as
/// specialized as \p FT2.
static bool isAtLeastAsSpecializedAs(Sema &S,
Thread a source location into the template-argument deduction routines. There may be some other places that could take advantage of this new information, but I haven't really looked yet. llvm-svn: 95600
2010-02-09 07:07:23 +08:00
SourceLocation Loc,
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
FunctionTemplateDecl *FT1,
FunctionTemplateDecl *FT2,
TemplatePartialOrderingContext TPOC,
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
unsigned NumCallArguments,
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVectorImpl<RefParamPartialOrderingComparison> *RefParamComparisons) {
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
FunctionDecl *FD1 = FT1->getTemplatedDecl();
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
FunctionDecl *FD2 = FT2->getTemplatedDecl();
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
const FunctionProtoType *Proto1 = FD1->getType()->getAs<FunctionProtoType>();
const FunctionProtoType *Proto2 = FD2->getType()->getAs<FunctionProtoType>();
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
assert(Proto1 && Proto2 && "Function templates must have prototypes");
TemplateParameterList *TemplateParams = FT2->getTemplateParameters();
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<DeducedTemplateArgument, 4> Deduced;
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
Deduced.resize(TemplateParams->size());
// C++0x [temp.deduct.partial]p3:
// The types used to determine the ordering depend on the context in which
// the partial ordering is done:
Remove Context argument from TemplateDeductionInfo constructor. It was no longer needed after the unused Context member was removed in r164104. llvm-svn: 164196
2012-09-19 10:26:47 +08:00
TemplateDeductionInfo Info(Loc);
Implement C++0x [temp.func.order]p3 (aka DR532) properly. In particular, we only add the implement object parameter type if only one of the function templates is a non-static member function template. Moreover, since this DR differs from existing practice in C++98/03, this commit implements the existing practice (which ignores the first parameter of the function template that is not the non-static member function template) in C++98/03 mode. llvm-svn: 119145
2010-11-15 23:41:16 +08:00
CXXMethodDecl *Method1 = 0;
CXXMethodDecl *Method2 = 0;
bool IsNonStatic2 = false;
bool IsNonStatic1 = false;
unsigned Skip2 = 0;
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
switch (TPOC) {
case TPOC_Call: {
// - In the context of a function call, the function parameter types are
// used.
Implement C++0x [temp.func.order]p3 (aka DR532) properly. In particular, we only add the implement object parameter type if only one of the function templates is a non-static member function template. Moreover, since this DR differs from existing practice in C++98/03, this commit implements the existing practice (which ignores the first parameter of the function template that is not the non-static member function template) in C++98/03 mode. llvm-svn: 119145
2010-11-15 23:41:16 +08:00
Method1 = dyn_cast<CXXMethodDecl>(FD1);
Method2 = dyn_cast<CXXMethodDecl>(FD2);
IsNonStatic1 = Method1 && !Method1->isStatic();
IsNonStatic2 = Method2 && !Method2->isStatic();
Fix function template partial ordering rules for static vs. non-static functions. llvm-svn: 164263
2012-09-20 07:27:04 +08:00
// C++11 [temp.func.order]p3:
Implement C++0x [temp.func.order]p3 (aka DR532) properly. In particular, we only add the implement object parameter type if only one of the function templates is a non-static member function template. Moreover, since this DR differs from existing practice in C++98/03, this commit implements the existing practice (which ignores the first parameter of the function template that is not the non-static member function template) in C++98/03 mode. llvm-svn: 119145
2010-11-15 23:41:16 +08:00
// [...] If only one of the function templates is a non-static
// member, that function template is considered to have a new
// first parameter inserted in its function parameter list. The
// new parameter is of type "reference to cv A," where cv are
// the cv-qualifiers of the function template (if any) and A is
// the class of which the function template is a member.
//
Fix function template partial ordering rules for static vs. non-static functions. llvm-svn: 164263
2012-09-20 07:27:04 +08:00
// Note that we interpret this to mean "if one of the function
// templates is a non-static member and the other is a non-member";
// otherwise, the ordering rules for static functions against non-static
// functions don't make any sense.
//
Implement C++0x [temp.func.order]p3 (aka DR532) properly. In particular, we only add the implement object parameter type if only one of the function templates is a non-static member function template. Moreover, since this DR differs from existing practice in C++98/03, this commit implements the existing practice (which ignores the first parameter of the function template that is not the non-static member function template) in C++98/03 mode. llvm-svn: 119145
2010-11-15 23:41:16 +08:00
// C++98/03 doesn't have this provision, so instead we drop the
Fix function template partial ordering rules for static vs. non-static functions. llvm-svn: 164263
2012-09-20 07:27:04 +08:00
// first argument of the free function, which seems to match
// existing practice.
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<QualType, 4> Args1;
s/CPlusPlus0x/CPlusPlus11/g llvm-svn: 171367
2013-01-02 19:42:31 +08:00
unsigned Skip1 = !S.getLangOpts().CPlusPlus11 && IsNonStatic2 && !Method1;
if (S.getLangOpts().CPlusPlus11 && IsNonStatic1 && !Method2)
Fix a small FIXME involving template partial ordering and member function templates with an rvalue ref qualifier. llvm-svn: 164267
2012-09-20 07:52:13 +08:00
AddImplicitObjectParameterType(S.Context, Method1, Args1);
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Args1.insert(Args1.end(),
Implement C++0x [temp.func.order]p3 (aka DR532) properly. In particular, we only add the implement object parameter type if only one of the function templates is a non-static member function template. Moreover, since this DR differs from existing practice in C++98/03, this commit implements the existing practice (which ignores the first parameter of the function template that is not the non-static member function template) in C++98/03 mode. llvm-svn: 119145
2010-11-15 23:41:16 +08:00
Proto1->arg_type_begin() + Skip1, Proto1->arg_type_end());
Implement C++ [over.match.funcs]p4 as it concerns partial ordering of function templates. Fixes PR8130. llvm-svn: 118944
2010-11-13 07:44:13 +08:00
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<QualType, 4> Args2;
s/CPlusPlus0x/CPlusPlus11/g llvm-svn: 171367
2013-01-02 19:42:31 +08:00
Skip2 = !S.getLangOpts().CPlusPlus11 && IsNonStatic1 && !Method2;
if (S.getLangOpts().CPlusPlus11 && IsNonStatic2 && !Method1)
Fix a small FIXME involving template partial ordering and member function templates with an rvalue ref qualifier. llvm-svn: 164267
2012-09-20 07:52:13 +08:00
AddImplicitObjectParameterType(S.Context, Method2, Args2);
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Args2.insert(Args2.end(),
Implement C++0x [temp.func.order]p3 (aka DR532) properly. In particular, we only add the implement object parameter type if only one of the function templates is a non-static member function template. Moreover, since this DR differs from existing practice in C++98/03, this commit implements the existing practice (which ignores the first parameter of the function template that is not the non-static member function template) in C++98/03 mode. llvm-svn: 119145
2010-11-15 23:41:16 +08:00
Proto2->arg_type_begin() + Skip2, Proto2->arg_type_end());
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
// C++ [temp.func.order]p5:
// The presence of unused ellipsis and default arguments has no effect on
// the partial ordering of function templates.
if (Args1.size() > NumCallArguments)
Args1.resize(NumCallArguments);
if (Args2.size() > NumCallArguments)
Args2.resize(NumCallArguments);
if (DeduceTemplateArguments(S, TemplateParams, Args2.data(), Args2.size(),
Args1.data(), Args1.size(), Info, Deduced,
TDF_None, /*PartialOrdering=*/true,
Implement core issue 1164, which concerns the partial ordering of f(T&) and f(T&&). llvm-svn: 123981
2011-01-22 01:29:42 +08:00
RefParamComparisons))
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
return false;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
break;
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
case TPOC_Conversion:
// - In the context of a call to a conversion operator, the return types
// of the conversion function templates are used.
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
if (DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
Proto2->getResultType(),
Proto1->getResultType(),
Info, Deduced, TDF_None,
/*PartialOrdering=*/true,
RefParamComparisons))
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
return false;
break;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
case TPOC_Other:
7bit-ize. llvm-svn: 124363
2011-01-27 15:09:49 +08:00
// - In other contexts (14.6.6.2) the function template's function type
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
// is used.
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
if (DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
FD2->getType(), FD1->getType(),
Info, Deduced, TDF_None,
/*PartialOrdering=*/true,
RefParamComparisons))
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
return false;
break;
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
// C++0x [temp.deduct.partial]p11:
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// In most cases, all template parameters must have values in order for
// deduction to succeed, but for partial ordering purposes a template
// parameter may remain without a value provided it is not used in the
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
// types being used for partial ordering. [ Note: a template parameter used
// in a non-deduced context is considered used. -end note]
unsigned ArgIdx = 0, NumArgs = Deduced.size();
for (; ArgIdx != NumArgs; ++ArgIdx)
if (Deduced[ArgIdx].isNull())
break;
if (ArgIdx == NumArgs) {
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// All template arguments were deduced. FT1 is at least as specialized
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
// as FT2.
return true;
}
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
// Figure out which template parameters were used.
SmallBitVectorize the deduced parameter set. llvm-svn: 149253
2012-01-31 00:17:39 +08:00
llvm::SmallBitVector UsedParameters(TemplateParams->size());
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
switch (TPOC) {
case TPOC_Call: {
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
unsigned NumParams = std::min(NumCallArguments,
std::min(Proto1->getNumArgs(),
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
Proto2->getNumArgs()));
s/CPlusPlus0x/CPlusPlus11/g llvm-svn: 171367
2013-01-02 19:42:31 +08:00
if (S.getLangOpts().CPlusPlus11 && IsNonStatic2 && !IsNonStatic1)
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
::MarkUsedTemplateParameters(S.Context, Method2->getThisType(S.Context),
false,
Implement C++0x [temp.func.order]p3 (aka DR532) properly. In particular, we only add the implement object parameter type if only one of the function templates is a non-static member function template. Moreover, since this DR differs from existing practice in C++98/03, this commit implements the existing practice (which ignores the first parameter of the function template that is not the non-static member function template) in C++98/03 mode. llvm-svn: 119145
2010-11-15 23:41:16 +08:00
TemplateParams->getDepth(), UsedParameters);
for (unsigned I = Skip2; I < NumParams; ++I)
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
::MarkUsedTemplateParameters(S.Context, Proto2->getArgType(I), false,
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
TemplateParams->getDepth(),
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
UsedParameters);
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
break;
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
case TPOC_Conversion:
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
::MarkUsedTemplateParameters(S.Context, Proto2->getResultType(), false,
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
TemplateParams->getDepth(),
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
UsedParameters);
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
break;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
case TPOC_Other:
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
::MarkUsedTemplateParameters(S.Context, FD2->getType(), false,
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
TemplateParams->getDepth(),
UsedParameters);
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
break;
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
for (; ArgIdx != NumArgs; ++ArgIdx)
// If this argument had no value deduced but was used in one of the types
// used for partial ordering, then deduction fails.
if (Deduced[ArgIdx].isNull() && UsedParameters[ArgIdx])
return false;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
return true;
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Tweak the partial ordering rules for function templates to prefer a non-variadic function template over a variadic one. This matches GCC and the intent of the C++0x wording, in a way that I think is likely to be acceptable to the committee. llvm-svn: 123581
2011-01-17 00:03:23 +08:00
/// \brief Determine whether this a function template whose parameter-type-list
/// ends with a function parameter pack.
static bool isVariadicFunctionTemplate(FunctionTemplateDecl *FunTmpl) {
FunctionDecl *Function = FunTmpl->getTemplatedDecl();
unsigned NumParams = Function->getNumParams();
if (NumParams == 0)
return false;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Tweak the partial ordering rules for function templates to prefer a non-variadic function template over a variadic one. This matches GCC and the intent of the C++0x wording, in a way that I think is likely to be acceptable to the committee. llvm-svn: 123581
2011-01-17 00:03:23 +08:00
ParmVarDecl *Last = Function->getParamDecl(NumParams - 1);
if (!Last->isParameterPack())
return false;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Tweak the partial ordering rules for function templates to prefer a non-variadic function template over a variadic one. This matches GCC and the intent of the C++0x wording, in a way that I think is likely to be acceptable to the committee. llvm-svn: 123581
2011-01-17 00:03:23 +08:00
// Make sure that no previous parameter is a parameter pack.
while (--NumParams > 0) {
if (Function->getParamDecl(NumParams - 1)->isParameterPack())
return false;
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Tweak the partial ordering rules for function templates to prefer a non-variadic function template over a variadic one. This matches GCC and the intent of the C++0x wording, in a way that I think is likely to be acceptable to the committee. llvm-svn: 123581
2011-01-17 00:03:23 +08:00
return true;
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement partial ordering of class template partial specializations (C++ [temp.class.order]). llvm-svn: 81866
2009-09-16 00:23:51 +08:00
/// \brief Returns the more specialized function template according
Implement conversion function templates, along with the ability to use template argument deduction from a conversion function (C++ [temp.deduct.conv]) with implicit conversions. llvm-svn: 79693
2009-08-22 07:19:43 +08:00
/// to the rules of function template partial ordering (C++ [temp.func.order]).
///
/// \param FT1 the first function template
///
/// \param FT2 the second function template
///
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
/// \param TPOC the context in which we are performing partial ordering of
/// function templates.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
///
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
/// \param NumCallArguments The number of arguments in a call, used only
/// when \c TPOC is \c TPOC_Call.
///
Implement partial ordering of class template partial specializations (C++ [temp.class.order]). llvm-svn: 81866
2009-09-16 00:23:51 +08:00
/// \returns the more specialized function template. If neither
Implement conversion function templates, along with the ability to use template argument deduction from a conversion function (C++ [temp.deduct.conv]) with implicit conversions. llvm-svn: 79693
2009-08-22 07:19:43 +08:00
/// template is more specialized, returns NULL.
FunctionTemplateDecl *
Sema::getMoreSpecializedTemplate(FunctionTemplateDecl *FT1,
FunctionTemplateDecl *FT2,
Thread a source location into the template-argument deduction routines. There may be some other places that could take advantage of this new information, but I haven't really looked yet. llvm-svn: 95600
2010-02-09 07:07:23 +08:00
SourceLocation Loc,
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
TemplatePartialOrderingContext TPOC,
unsigned NumCallArguments) {
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<RefParamPartialOrderingComparison, 4> RefParamComparisons;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
bool Better1 = isAtLeastAsSpecializedAs(*this, Loc, FT1, FT2, TPOC,
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
NumCallArguments, 0);
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
bool Better2 = isAtLeastAsSpecializedAs(*this, Loc, FT2, FT1, TPOC,
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
NumCallArguments,
Implement core issue 1164, which concerns the partial ordering of f(T&) and f(T&&). llvm-svn: 123981
2011-01-22 01:29:42 +08:00
&RefParamComparisons);
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
if (Better1 != Better2) // We have a clear winner
return Better1? FT1 : FT2;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
if (!Better1 && !Better2) // Neither is better than the other
Implement conversion function templates, along with the ability to use template argument deduction from a conversion function (C++ [temp.deduct.conv]) with implicit conversions. llvm-svn: 79693
2009-08-22 07:19:43 +08:00
return 0;
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
// C++0x [temp.deduct.partial]p10:
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// If for each type being considered a given template is at least as
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
// specialized for all types and more specialized for some set of types and
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// the other template is not more specialized for any types or is not at
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
// least as specialized for any types, then the given template is more
// specialized than the other template. Otherwise, neither template is more
// specialized than the other.
Better1 = false;
Better2 = false;
Implement core issue 1164, which concerns the partial ordering of f(T&) and f(T&&). llvm-svn: 123981
2011-01-22 01:29:42 +08:00
for (unsigned I = 0, N = RefParamComparisons.size(); I != N; ++I) {
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
// C++0x [temp.deduct.partial]p9:
// If, for a given type, deduction succeeds in both directions (i.e., the
Implement core issue 1164, which concerns the partial ordering of f(T&) and f(T&&). llvm-svn: 123981
2011-01-22 01:29:42 +08:00
// types are identical after the transformations above) and both P and A
// were reference types (before being replaced with the type referred to
// above):
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// -- if the type from the argument template was an lvalue reference
Implement core issue 1164, which concerns the partial ordering of f(T&) and f(T&&). llvm-svn: 123981
2011-01-22 01:29:42 +08:00
// and the type from the parameter template was not, the argument
// type is considered to be more specialized than the other;
// otherwise,
if (!RefParamComparisons[I].ArgIsRvalueRef &&
RefParamComparisons[I].ParamIsRvalueRef) {
Better2 = true;
if (Better1)
return 0;
continue;
} else if (!RefParamComparisons[I].ParamIsRvalueRef &&
RefParamComparisons[I].ArgIsRvalueRef) {
Better1 = true;
if (Better2)
return 0;
continue;
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement core issue 1164, which concerns the partial ordering of f(T&) and f(T&&). llvm-svn: 123981
2011-01-22 01:29:42 +08:00
// -- if the type from the argument template is more cv-qualified than
// the type from the parameter template (as described above), the
// argument type is considered to be more specialized than the
// other; otherwise,
switch (RefParamComparisons[I].Qualifiers) {
case NeitherMoreQualified:
break;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement core issue 1164, which concerns the partial ordering of f(T&) and f(T&&). llvm-svn: 123981
2011-01-22 01:29:42 +08:00
case ParamMoreQualified:
Better1 = true;
if (Better2)
return 0;
continue;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement core issue 1164, which concerns the partial ordering of f(T&) and f(T&&). llvm-svn: 123981
2011-01-22 01:29:42 +08:00
case ArgMoreQualified:
Better2 = true;
if (Better1)
return 0;
continue;
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement core issue 1164, which concerns the partial ordering of f(T&) and f(T&&). llvm-svn: 123981
2011-01-22 01:29:42 +08:00
// -- neither type is more specialized than the other.
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
assert(!(Better1 && Better2) && "Should have broken out in the loop above");
Implement conversion function templates, along with the ability to use template argument deduction from a conversion function (C++ [temp.deduct.conv]) with implicit conversions. llvm-svn: 79693
2009-08-22 07:19:43 +08:00
if (Better1)
return FT1;
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
else if (Better2)
return FT2;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Tweak the partial ordering rules for function templates to prefer a non-variadic function template over a variadic one. This matches GCC and the intent of the C++0x wording, in a way that I think is likely to be acceptable to the committee. llvm-svn: 123581
2011-01-17 00:03:23 +08:00
// FIXME: This mimics what GCC implements, but doesn't match up with the
// proposed resolution for core issue 692. This area needs to be sorted out,
// but for now we attempt to maintain compatibility.
bool Variadic1 = isVariadicFunctionTemplate(FT1);
bool Variadic2 = isVariadicFunctionTemplate(FT2);
if (Variadic1 != Variadic2)
return Variadic1? FT2 : FT1;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Tweak the partial ordering rules for function templates to prefer a non-variadic function template over a variadic one. This matches GCC and the intent of the C++0x wording, in a way that I think is likely to be acceptable to the committee. llvm-svn: 123581
2011-01-17 00:03:23 +08:00
return 0;
Implement conversion function templates, along with the ability to use template argument deduction from a conversion function (C++ [temp.deduct.conv]) with implicit conversions. llvm-svn: 79693
2009-08-22 07:19:43 +08:00
}
Implement template argument deduction when taking the address of a function template. Most of the change here is in factoring out the common bits used for template argument deduction from a function call and when taking the address of a function template. llvm-svn: 75044
2009-07-09 04:55:45 +08:00
WIP implementation of explicit instantiation of function templates, member functions of class template specializations, and static data members. The mechanics are (mostly) present, but the semantic analysis is very weak. llvm-svn: 82789
2009-09-26 02:43:00 +08:00
/// \brief Determine if the two templates are equivalent.
static bool isSameTemplate(TemplateDecl *T1, TemplateDecl *T2) {
if (T1 == T2)
return true;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
WIP implementation of explicit instantiation of function templates, member functions of class template specializations, and static data members. The mechanics are (mostly) present, but the semantic analysis is very weak. llvm-svn: 82789
2009-09-26 02:43:00 +08:00
if (!T1 || !T2)
return false;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
WIP implementation of explicit instantiation of function templates, member functions of class template specializations, and static data members. The mechanics are (mostly) present, but the semantic analysis is very weak. llvm-svn: 82789
2009-09-26 02:43:00 +08:00
return T1->getCanonicalDecl() == T2->getCanonicalDecl();
}
/// \brief Retrieve the most specialized of the given function template
/// specializations.
///
Implement access control for overloaded functions. Suppress access control diagnostics in "early" lookups, such as during typename checks and when building unresolved lookup expressions. llvm-svn: 94647
2010-01-27 09:50:18 +08:00
/// \param SpecBegin the start iterator of the function template
/// specializations that we will be comparing.
WIP implementation of explicit instantiation of function templates, member functions of class template specializations, and static data members. The mechanics are (mostly) present, but the semantic analysis is very weak. llvm-svn: 82789
2009-09-26 02:43:00 +08:00
///
Implement access control for overloaded functions. Suppress access control diagnostics in "early" lookups, such as during typename checks and when building unresolved lookup expressions. llvm-svn: 94647
2010-01-27 09:50:18 +08:00
/// \param SpecEnd the end iterator of the function template
/// specializations, paired with \p SpecBegin.
WIP implementation of explicit instantiation of function templates, member functions of class template specializations, and static data members. The mechanics are (mostly) present, but the semantic analysis is very weak. llvm-svn: 82789
2009-09-26 02:43:00 +08:00
///
/// \param TPOC the partial ordering context to use to compare the function
/// template specializations.
///
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
/// \param NumCallArguments The number of arguments in a call, used only
/// when \c TPOC is \c TPOC_Call.
///
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
/// \param Loc the location where the ambiguity or no-specializations
WIP implementation of explicit instantiation of function templates, member functions of class template specializations, and static data members. The mechanics are (mostly) present, but the semantic analysis is very weak. llvm-svn: 82789
2009-09-26 02:43:00 +08:00
/// diagnostic should occur.
///
/// \param NoneDiag partial diagnostic used to diagnose cases where there are
/// no matching candidates.
///
/// \param AmbigDiag partial diagnostic used to diagnose an ambiguity, if one
/// occurs.
///
/// \param CandidateDiag partial diagnostic used for each function template
/// specialization that is a candidate in the ambiguous ordering. One parameter
/// in this diagnostic should be unbound, which will correspond to the string
/// describing the template arguments for the function template specialization.
///
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
/// \returns the most specialized function template specialization, if
Implement access control for overloaded functions. Suppress access control diagnostics in "early" lookups, such as during typename checks and when building unresolved lookup expressions. llvm-svn: 94647
2010-01-27 09:50:18 +08:00
/// found. Otherwise, returns SpecEnd.
FIXME fix: improving diagnostics for template arguments deduction of class templates and explicit specializations This patch essentially removes all the FIXMEs following calls to DeduceTemplateArguments() that want to keep track of deduction failure info. llvm-svn: 186730
2013-07-20 07:00:19 +08:00
UnresolvedSetIterator Sema::getMostSpecialized(
UnresolvedSetIterator SpecBegin, UnresolvedSetIterator SpecEnd,
TemplateSpecCandidateSet &FailedCandidates,
TemplatePartialOrderingContext TPOC, unsigned NumCallArguments,
SourceLocation Loc, const PartialDiagnostic &NoneDiag,
const PartialDiagnostic &AmbigDiag, const PartialDiagnostic &CandidateDiag,
bool Complain, QualType TargetType) {
Implement access control for overloaded functions. Suppress access control diagnostics in "early" lookups, such as during typename checks and when building unresolved lookup expressions. llvm-svn: 94647
2010-01-27 09:50:18 +08:00
if (SpecBegin == SpecEnd) {
FIXME fix: improving diagnostics for template arguments deduction of class templates and explicit specializations This patch essentially removes all the FIXMEs following calls to DeduceTemplateArguments() that want to keep track of deduction failure info. llvm-svn: 186730
2013-07-20 07:00:19 +08:00
if (Complain) {
Handle the resolution of a reference to a function template (which includes explicitly-specified template arguments) to a function template specialization in cases where no deduction is performed or deduction fails. Patch by Faisal Vali, fixes PR7505! llvm-svn: 126048
2011-02-20 05:32:49 +08:00
Diag(Loc, NoneDiag);
FIXME fix: improving diagnostics for template arguments deduction of class templates and explicit specializations This patch essentially removes all the FIXMEs following calls to DeduceTemplateArguments() that want to keep track of deduction failure info. llvm-svn: 186730
2013-07-20 07:00:19 +08:00
FailedCandidates.NoteCandidates(*this, Loc);
}
Implement access control for overloaded functions. Suppress access control diagnostics in "early" lookups, such as during typename checks and when building unresolved lookup expressions. llvm-svn: 94647
2010-01-27 09:50:18 +08:00
return SpecEnd;
WIP implementation of explicit instantiation of function templates, member functions of class template specializations, and static data members. The mechanics are (mostly) present, but the semantic analysis is very weak. llvm-svn: 82789
2009-09-26 02:43:00 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
if (SpecBegin + 1 == SpecEnd)
Implement access control for overloaded functions. Suppress access control diagnostics in "early" lookups, such as during typename checks and when building unresolved lookup expressions. llvm-svn: 94647
2010-01-27 09:50:18 +08:00
return SpecBegin;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
WIP implementation of explicit instantiation of function templates, member functions of class template specializations, and static data members. The mechanics are (mostly) present, but the semantic analysis is very weak. llvm-svn: 82789
2009-09-26 02:43:00 +08:00
// Find the function template that is better than all of the templates it
// has been compared to.
Implement access control for overloaded functions. Suppress access control diagnostics in "early" lookups, such as during typename checks and when building unresolved lookup expressions. llvm-svn: 94647
2010-01-27 09:50:18 +08:00
UnresolvedSetIterator Best = SpecBegin;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
FunctionTemplateDecl *BestTemplate
Implement access control for overloaded functions. Suppress access control diagnostics in "early" lookups, such as during typename checks and when building unresolved lookup expressions. llvm-svn: 94647
2010-01-27 09:50:18 +08:00
= cast<FunctionDecl>(*Best)->getPrimaryTemplate();
WIP implementation of explicit instantiation of function templates, member functions of class template specializations, and static data members. The mechanics are (mostly) present, but the semantic analysis is very weak. llvm-svn: 82789
2009-09-26 02:43:00 +08:00
assert(BestTemplate && "Not a function template specialization?");
Implement access control for overloaded functions. Suppress access control diagnostics in "early" lookups, such as during typename checks and when building unresolved lookup expressions. llvm-svn: 94647
2010-01-27 09:50:18 +08:00
for (UnresolvedSetIterator I = SpecBegin + 1; I != SpecEnd; ++I) {
FunctionTemplateDecl *Challenger
= cast<FunctionDecl>(*I)->getPrimaryTemplate();
WIP implementation of explicit instantiation of function templates, member functions of class template specializations, and static data members. The mechanics are (mostly) present, but the semantic analysis is very weak. llvm-svn: 82789
2009-09-26 02:43:00 +08:00
assert(Challenger && "Not a function template specialization?");
Implement access control for overloaded functions. Suppress access control diagnostics in "early" lookups, such as during typename checks and when building unresolved lookup expressions. llvm-svn: 94647
2010-01-27 09:50:18 +08:00
if (isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger,
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
Loc, TPOC, NumCallArguments),
WIP implementation of explicit instantiation of function templates, member functions of class template specializations, and static data members. The mechanics are (mostly) present, but the semantic analysis is very weak. llvm-svn: 82789
2009-09-26 02:43:00 +08:00
Challenger)) {
Best = I;
BestTemplate = Challenger;
}
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
WIP implementation of explicit instantiation of function templates, member functions of class template specializations, and static data members. The mechanics are (mostly) present, but the semantic analysis is very weak. llvm-svn: 82789
2009-09-26 02:43:00 +08:00
// Make sure that the "best" function template is more specialized than all
// of the others.
bool Ambiguous = false;
Implement access control for overloaded functions. Suppress access control diagnostics in "early" lookups, such as during typename checks and when building unresolved lookup expressions. llvm-svn: 94647
2010-01-27 09:50:18 +08:00
for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) {
FunctionTemplateDecl *Challenger
= cast<FunctionDecl>(*I)->getPrimaryTemplate();
WIP implementation of explicit instantiation of function templates, member functions of class template specializations, and static data members. The mechanics are (mostly) present, but the semantic analysis is very weak. llvm-svn: 82789
2009-09-26 02:43:00 +08:00
if (I != Best &&
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
!isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger,
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
Loc, TPOC, NumCallArguments),
WIP implementation of explicit instantiation of function templates, member functions of class template specializations, and static data members. The mechanics are (mostly) present, but the semantic analysis is very weak. llvm-svn: 82789
2009-09-26 02:43:00 +08:00
BestTemplate)) {
Ambiguous = true;
break;
}
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
WIP implementation of explicit instantiation of function templates, member functions of class template specializations, and static data members. The mechanics are (mostly) present, but the semantic analysis is very weak. llvm-svn: 82789
2009-09-26 02:43:00 +08:00
if (!Ambiguous) {
// We found an answer. Return it.
Implement access control for overloaded functions. Suppress access control diagnostics in "early" lookups, such as during typename checks and when building unresolved lookup expressions. llvm-svn: 94647
2010-01-27 09:50:18 +08:00
return Best;
WIP implementation of explicit instantiation of function templates, member functions of class template specializations, and static data members. The mechanics are (mostly) present, but the semantic analysis is very weak. llvm-svn: 82789
2009-09-26 02:43:00 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
WIP implementation of explicit instantiation of function templates, member functions of class template specializations, and static data members. The mechanics are (mostly) present, but the semantic analysis is very weak. llvm-svn: 82789
2009-09-26 02:43:00 +08:00
// Diagnose the ambiguity.
Simplify slightly. llvm-svn: 181092
2013-05-04 09:51:08 +08:00
if (Complain) {
Handle the resolution of a reference to a function template (which includes explicitly-specified template arguments) to a function template specialization in cases where no deduction is performed or deduction fails. Patch by Faisal Vali, fixes PR7505! llvm-svn: 126048
2011-02-20 05:32:49 +08:00
Diag(Loc, AmbigDiag);
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Simplify slightly. llvm-svn: 181092
2013-05-04 09:51:08 +08:00
// FIXME: Can we order the candidates in some sane way?
Add feature to diagnostics that will provide more information on function pointer mismatch. Cases covered are: initialization, assignment, and function arguments. Additional text will give the extra information about the nature of the mismatch: different classes for member functions, wrong number of parameters, different parameter type, different return type, and function qualifier mismatch. llvm-svn: 145114
2011-11-24 06:32:32 +08:00
for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) {
PartialDiagnostic PD = CandidateDiag;
PD << getTemplateArgumentBindingsText(
Handle the resolution of a reference to a function template (which includes explicitly-specified template arguments) to a function template specialization in cases where no deduction is performed or deduction fails. Patch by Faisal Vali, fixes PR7505! llvm-svn: 126048
2011-02-20 05:32:49 +08:00
cast<FunctionDecl>(*I)->getPrimaryTemplate()->getTemplateParameters(),
Implement access control for overloaded functions. Suppress access control diagnostics in "early" lookups, such as during typename checks and when building unresolved lookup expressions. llvm-svn: 94647
2010-01-27 09:50:18 +08:00
*cast<FunctionDecl>(*I)->getTemplateSpecializationArgs());
Add feature to diagnostics that will provide more information on function pointer mismatch. Cases covered are: initialization, assignment, and function arguments. Additional text will give the extra information about the nature of the mismatch: different classes for member functions, wrong number of parameters, different parameter type, different return type, and function qualifier mismatch. llvm-svn: 145114
2011-11-24 06:32:32 +08:00
if (!TargetType.isNull())
HandleFunctionTypeMismatch(PD, cast<FunctionDecl>(*I)->getType(),
TargetType);
Diag((*I)->getLocation(), PD);
}
Simplify slightly. llvm-svn: 181092
2013-05-04 09:51:08 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement access control for overloaded functions. Suppress access control diagnostics in "early" lookups, such as during typename checks and when building unresolved lookup expressions. llvm-svn: 94647
2010-01-27 09:50:18 +08:00
return SpecEnd;
WIP implementation of explicit instantiation of function templates, member functions of class template specializations, and static data members. The mechanics are (mostly) present, but the semantic analysis is very weak. llvm-svn: 82789
2009-09-26 02:43:00 +08:00
}
Implement partial ordering of class template partial specializations (C++ [temp.class.order]). llvm-svn: 81866
2009-09-16 00:23:51 +08:00
/// \brief Returns the more specialized class template partial specialization
/// according to the rules of partial ordering of class template partial
/// specializations (C++ [temp.class.order]).
///
/// \param PS1 the first class template partial specialization
///
/// \param PS2 the second class template partial specialization
///
/// \returns the more specialized class template partial specialization. If
/// neither partial specialization is more specialized, returns NULL.
ClassTemplatePartialSpecializationDecl *
Sema::getMoreSpecializedPartialSpecialization(
ClassTemplatePartialSpecializationDecl *PS1,
Thread a source location into the template-argument deduction routines. There may be some other places that could take advantage of this new information, but I haven't really looked yet. llvm-svn: 95600
2010-02-09 07:07:23 +08:00
ClassTemplatePartialSpecializationDecl *PS2,
SourceLocation Loc) {
Implement partial ordering of class template partial specializations (C++ [temp.class.order]). llvm-svn: 81866
2009-09-16 00:23:51 +08:00
// C++ [temp.class.order]p1:
// For two class template partial specializations, the first is at least as
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// specialized as the second if, given the following rewrite to two
// function templates, the first function template is at least as
// specialized as the second according to the ordering rules for function
Implement partial ordering of class template partial specializations (C++ [temp.class.order]). llvm-svn: 81866
2009-09-16 00:23:51 +08:00
// templates (14.6.6.2):
// - the first function template has the same template parameters as the
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// first partial specialization and has a single function parameter
// whose type is a class template specialization with the template
Implement partial ordering of class template partial specializations (C++ [temp.class.order]). llvm-svn: 81866
2009-09-16 00:23:51 +08:00
// arguments of the first partial specialization, and
// - the second function template has the same template parameters as the
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// second partial specialization and has a single function parameter
// whose type is a class template specialization with the template
Implement partial ordering of class template partial specializations (C++ [temp.class.order]). llvm-svn: 81866
2009-09-16 00:23:51 +08:00
// arguments of the second partial specialization.
//
For template argument deduction from class template partial specializations, separate out the deduction part from the checking and substitution of the deduced arguments. llvm-svn: 102600
2010-04-29 14:21:43 +08:00
// Rather than synthesize function templates, we merely perform the
// equivalent partial ordering by performing deduction directly on
// the template arguments of the class template partial
// specializations. This computation is slightly simpler than the
// general problem of function template partial ordering, because
// class template partial specializations are more constrained. We
// know that every template parameter is deducible from the class
// template partial specialization's template arguments, for
// example.
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<DeducedTemplateArgument, 4> Deduced;
Remove Context argument from TemplateDeductionInfo constructor. It was no longer needed after the unused Context member was removed in r164104. llvm-svn: 164196
2012-09-19 10:26:47 +08:00
TemplateDeductionInfo Info(Loc);
Make the InjectedClassNameType the canonical type of the current instantiation of a class template or class template partial specialization. That is to say, in template <class T> class A { ... }; or template <class T> class B<const T*> { ... }; make 'A<T>' and 'B<const T*>' sugar for the corresponding InjectedClassNameType when written inside the appropriate context. This allows us to track the current instantiation appropriately even inside AST routines. It also allows us to compute a DeclContext for a type much more efficiently, at some extra cost every time we write a template specialization (which can be optimized, but I've left it simple in this patch). llvm-svn: 102407
2010-04-27 08:57:59 +08:00
QualType PT1 = PS1->getInjectedSpecializationType();
QualType PT2 = PS2->getInjectedSpecializationType();
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement partial ordering of class template partial specializations (C++ [temp.class.order]). llvm-svn: 81866
2009-09-16 00:23:51 +08:00
// Determine whether PS1 is at least as specialized as PS2
Deduced.resize(PS2->getTemplateParameters()->size());
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
bool Better1 = !DeduceTemplateArgumentsByTypeMatch(*this,
PS2->getTemplateParameters(),
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
PT2, PT1, Info, Deduced, TDF_None,
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
/*PartialOrdering=*/true,
Implement core issue 1164, which concerns the partial ordering of f(T&) and f(T&&). llvm-svn: 123981
2011-01-22 01:29:42 +08:00
/*RefParamComparisons=*/0);
When determining which template partial specialization is more specialized, make sure to setup the instantiation stack. Fixes rdar://8620775 & http://llvm.org/PR8234 llvm-svn: 118314
2010-11-06 07:25:18 +08:00
if (Better1) {
PR13365: Fix code which was trying to treat an array of DeducedTemplateArgument as an array of its base class TemplateArgument. Switch the const TemplateArgument* parameters of InstantiatingTemplate's constructors to ArrayRef<TemplateArgument> to prevent this from happening again in the future. llvm-svn: 160245
2012-07-16 09:09:10 +08:00
SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),Deduced.end());
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
InstantiatingTemplate Inst(*this, PS2->getLocation(), PS2, DeducedArgs,
Info);
Better1 = !::FinishTemplateArgumentDeduction(
*this, PS2, PS1->getTemplateArgs(), Deduced, Info);
}
// Determine whether PS2 is at least as specialized as PS1
Deduced.clear();
Deduced.resize(PS1->getTemplateParameters()->size());
bool Better2 = !DeduceTemplateArgumentsByTypeMatch(
*this, PS1->getTemplateParameters(), PT1, PT2, Info, Deduced, TDF_None,
/*PartialOrdering=*/true,
/*RefParamComparisons=*/0);
if (Better2) {
SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),
Deduced.end());
InstantiatingTemplate Inst(*this, PS1->getLocation(), PS1, DeducedArgs,
Info);
Better2 = !::FinishTemplateArgumentDeduction(
*this, PS1, PS2->getTemplateArgs(), Deduced, Info);
}
if (Better1 == Better2)
return 0;
return Better1 ? PS1 : PS2;
}
/// TODO: Unify with ClassTemplatePartialSpecializationDecl version.
VarTemplatePartialSpecializationDecl *
Sema::getMoreSpecializedPartialSpecialization(
VarTemplatePartialSpecializationDecl *PS1,
VarTemplatePartialSpecializationDecl *PS2, SourceLocation Loc) {
SmallVector<DeducedTemplateArgument, 4> Deduced;
TemplateDeductionInfo Info(Loc);
assert(PS1->getSpecializedTemplate() == PS1->getSpecializedTemplate() &&
"the partial specializations being compared should specialize"
" the same template.");
TemplateName Name(PS1->getSpecializedTemplate());
TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
QualType PT1 = Context.getTemplateSpecializationType(
CanonTemplate, PS1->getTemplateArgs().data(),
PS1->getTemplateArgs().size());
QualType PT2 = Context.getTemplateSpecializationType(
CanonTemplate, PS2->getTemplateArgs().data(),
PS2->getTemplateArgs().size());
// Determine whether PS1 is at least as specialized as PS2
Deduced.resize(PS2->getTemplateParameters()->size());
bool Better1 = !DeduceTemplateArgumentsByTypeMatch(
*this, PS2->getTemplateParameters(), PT2, PT1, Info, Deduced, TDF_None,
/*PartialOrdering=*/true,
/*RefParamComparisons=*/0);
if (Better1) {
SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),
Deduced.end());
When determining which template partial specialization is more specialized, make sure to setup the instantiation stack. Fixes rdar://8620775 & http://llvm.org/PR8234 llvm-svn: 118314
2010-11-06 07:25:18 +08:00
InstantiatingTemplate Inst(*this, PS2->getLocation(), PS2,
PR13365: Fix code which was trying to treat an array of DeducedTemplateArgument as an array of its base class TemplateArgument. Switch the const TemplateArgument* parameters of InstantiatingTemplate's constructors to ArrayRef<TemplateArgument> to prevent this from happening again in the future. llvm-svn: 160245
2012-07-16 09:09:10 +08:00
DeducedArgs, Info);
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Better1 = !::FinishTemplateArgumentDeduction(*this, PS2,
PS1->getTemplateArgs(),
When performing partial ordering of class template partial specializations, substitute the deduced template arguments and check the resulting substitution before concluding that template argument deduction succeeds. This marvelous little fix makes a bunch of Boost.Spirit tests start working. llvm-svn: 102601
2010-04-29 14:31:36 +08:00
Deduced, Info);
When determining which template partial specialization is more specialized, make sure to setup the instantiation stack. Fixes rdar://8620775 & http://llvm.org/PR8234 llvm-svn: 118314
2010-11-06 07:25:18 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement partial ordering of class template partial specializations (C++ [temp.class.order]). llvm-svn: 81866
2009-09-16 00:23:51 +08:00
// Determine whether PS2 is at least as specialized as PS1
Template argument deduction for template template parameters. This permits, among other things, ripping apart and reconstructing templates via partial specialization: template<typename T> struct DeepRemoveConst { typedef T type; }; template<typename T> struct DeepRemoveConst<const T> { typedef typename DeepRemoveConst<T>::type type; }; template<template<typename> class TT, typename T> struct DeepRemoveConst<TT<T> > { typedef TT<typename DeepRemoveConst<T>::type> type; }; Also, fix a longstanding thinko in the code handling partial ordering of class template partial specializations. We were performing the second deduction without clearing out the results of the first deduction. It's amazing we got through so much code with such a horrendous error :( llvm-svn: 86893
2009-11-12 07:06:43 +08:00
Deduced.clear();
Implement partial ordering of class template partial specializations (C++ [temp.class.order]). llvm-svn: 81866
2009-09-16 00:23:51 +08:00
Deduced.resize(PS1->getTemplateParameters()->size());
Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. llvm-svn: 148351
2012-01-18 06:49:52 +08:00
bool Better2 = !DeduceTemplateArgumentsByTypeMatch(*this,
PS1->getTemplateParameters(),
Implement C++ [temp.func.order]p5 more directly, by passing down the number of explicit call arguments. This actually fixes an erroneous test for [temp.deduct.partial]p11, where we were considering parameters corresponding to arguments beyond those that were explicitly provided. llvm-svn: 123244
2011-01-12 01:34:58 +08:00
PT1, PT2, Info, Deduced, TDF_None,
/*PartialOrdering=*/true,
Implement core issue 1164, which concerns the partial ordering of f(T&) and f(T&&). llvm-svn: 123981
2011-01-22 01:29:42 +08:00
/*RefParamComparisons=*/0);
When determining which template partial specialization is more specialized, make sure to setup the instantiation stack. Fixes rdar://8620775 & http://llvm.org/PR8234 llvm-svn: 118314
2010-11-06 07:25:18 +08:00
if (Better2) {
PR13365: Fix code which was trying to treat an array of DeducedTemplateArgument as an array of its base class TemplateArgument. Switch the const TemplateArgument* parameters of InstantiatingTemplate's constructors to ArrayRef<TemplateArgument> to prevent this from happening again in the future. llvm-svn: 160245
2012-07-16 09:09:10 +08:00
SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),Deduced.end());
When determining which template partial specialization is more specialized, make sure to setup the instantiation stack. Fixes rdar://8620775 & http://llvm.org/PR8234 llvm-svn: 118314
2010-11-06 07:25:18 +08:00
InstantiatingTemplate Inst(*this, PS1->getLocation(), PS1,
PR13365: Fix code which was trying to treat an array of DeducedTemplateArgument as an array of its base class TemplateArgument. Switch the const TemplateArgument* parameters of InstantiatingTemplate's constructors to ArrayRef<TemplateArgument> to prevent this from happening again in the future. llvm-svn: 160245
2012-07-16 09:09:10 +08:00
DeducedArgs, Info);
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Better2 = !::FinishTemplateArgumentDeduction(*this, PS1,
PS2->getTemplateArgs(),
When performing partial ordering of class template partial specializations, substitute the deduced template arguments and check the resulting substitution before concluding that template argument deduction succeeds. This marvelous little fix makes a bunch of Boost.Spirit tests start working. llvm-svn: 102601
2010-04-29 14:31:36 +08:00
Deduced, Info);
When determining which template partial specialization is more specialized, make sure to setup the instantiation stack. Fixes rdar://8620775 & http://llvm.org/PR8234 llvm-svn: 118314
2010-11-06 07:25:18 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement partial ordering of class template partial specializations (C++ [temp.class.order]). llvm-svn: 81866
2009-09-16 00:23:51 +08:00
if (Better1 == Better2)
return 0;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement partial ordering of class template partial specializations (C++ [temp.class.order]). llvm-svn: 81866
2009-09-16 00:23:51 +08:00
return Better1? PS1 : PS2;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
static void
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(ASTContext &Ctx,
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
const TemplateArgument &TemplateArg,
bool OnlyDeduced,
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
unsigned Depth,
SmallBitVectorize the deduced parameter set. llvm-svn: 149253
2012-01-31 00:17:39 +08:00
llvm::SmallBitVector &Used);
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
/// \brief Mark the template parameters that are used by the given
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
/// expression.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
static void
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(ASTContext &Ctx,
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
const Expr *E,
bool OnlyDeduced,
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
unsigned Depth,
SmallBitVectorize the deduced parameter set. llvm-svn: 149253
2012-01-31 00:17:39 +08:00
llvm::SmallBitVector &Used) {
Implement support for pack expansions whose pattern is a non-type template argument (described by an expression, of course). For example: template<int...> struct int_tuple { }; template<int ...Values> struct square { typedef int_tuple<(Values*Values)...> type; }; It also lays the foundation for pack expansions in an initializer-list. llvm-svn: 122751
2011-01-04 01:17:50 +08:00
// We can deduce from a pack expansion.
if (const PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(E))
E = Expansion->getPattern();
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
PR13136: * When substituting a reference to a non-type template parameter pack where the corresponding argument is a pack expansion, transform into an expression which contains an unexpanded parameter pack rather than into an expression which contains a pack expansion. This causes the SubstNonTypeTemplateParmExpr to be inside the PackExpansionExpr, rather than outside, so the expression still looks like a pack expansion and can be deduced. * Teach MarkUsedTemplateParameters that we can deduce a reference to a template parameter if it's wrapped in a SubstNonTypeTemplateParmExpr (such nodes are added during alias template substitution). llvm-svn: 159922
2012-07-09 11:07:20 +08:00
// Skip through any implicit casts we added while type-checking, and any
// substitutions performed by template alias expansion.
while (1) {
if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
E = ICE->getSubExpr();
else if (const SubstNonTypeTemplateParmExpr *Subst =
dyn_cast<SubstNonTypeTemplateParmExpr>(E))
E = Subst->getReplacement();
else
break;
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// FIXME: if !OnlyDeduced, we have to walk the whole subexpression to
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
// find other occurrences of template parameters.
Some cleanups suggested by Chris llvm-svn: 73713
2009-06-19 02:45:36 +08:00
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E);
After dyn_cast'ing, it generally makes sense to check the *output* of the dyn_cast against NULL rather than the *input*. Fixes PR6025. llvm-svn: 93435
2010-01-15 02:13:22 +08:00
if (!DRE)
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
return;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
const NonTypeTemplateParmDecl *NTTP
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
= dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl());
if (!NTTP)
return;
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
if (NTTP->getDepth() == Depth)
Used[NTTP->getIndex()] = true;
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
}
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
/// \brief Mark the template parameters that are used by the given
/// nested name specifier.
static void
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(ASTContext &Ctx,
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
NestedNameSpecifier *NNS,
bool OnlyDeduced,
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
unsigned Depth,
SmallBitVectorize the deduced parameter set. llvm-svn: 149253
2012-01-31 00:17:39 +08:00
llvm::SmallBitVector &Used) {
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
if (!NNS)
return;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx, NNS->getPrefix(), OnlyDeduced, Depth,
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
Used);
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx, QualType(NNS->getAsType(), 0),
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
OnlyDeduced, Depth, Used);
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
/// \brief Mark the template parameters that are used by the given
/// template name.
static void
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(ASTContext &Ctx,
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
TemplateName Name,
bool OnlyDeduced,
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
unsigned Depth,
SmallBitVectorize the deduced parameter set. llvm-svn: 149253
2012-01-31 00:17:39 +08:00
llvm::SmallBitVector &Used) {
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
if (TemplateTemplateParmDecl *TTP
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
= dyn_cast<TemplateTemplateParmDecl>(Template)) {
if (TTP->getDepth() == Depth)
Used[TTP->getIndex()] = true;
}
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
return;
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Introduce a new representation for template template parameters. Rather than storing them as either declarations (for the non-dependent case) or expressions (for the dependent case), we now (always) store them as TemplateNames. The primary change here is to add a new kind of TemplateArgument, which stores a TemplateName. However, making that change ripples to every switch on a TemplateArgument's kind, also affecting TemplateArgumentLocInfo/TemplateArgumentLoc, default template arguments for template template parameters, type-checking of template template arguments, etc. This change is light on testing. It should fix several pre-existing problems with template template parameters, such as: - the inability to use dependent template names as template template arguments - template template parameter default arguments cannot be instantiation However, there are enough pieces missing that more implementation is required before we can adequately test template template parameters. llvm-svn: 86777
2009-11-11 09:00:40 +08:00
if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName())
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx, QTN->getQualifier(), OnlyDeduced,
Introduce a new representation for template template parameters. Rather than storing them as either declarations (for the non-dependent case) or expressions (for the dependent case), we now (always) store them as TemplateNames. The primary change here is to add a new kind of TemplateArgument, which stores a TemplateName. However, making that change ripples to every switch on a TemplateArgument's kind, also affecting TemplateArgumentLocInfo/TemplateArgumentLoc, default template arguments for template template parameters, type-checking of template template arguments, etc. This change is light on testing. It should fix several pre-existing problems with template template parameters, such as: - the inability to use dependent template names as template template arguments - template template parameter default arguments cannot be instantiation However, there are enough pieces missing that more implementation is required before we can adequately test template template parameters. llvm-svn: 86777
2009-11-11 09:00:40 +08:00
Depth, Used);
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
if (DependentTemplateName *DTN = Name.getAsDependentTemplateName())
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx, DTN->getQualifier(), OnlyDeduced,
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
Depth, Used);
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
}
/// \brief Mark the template parameters that are used by the given
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
/// type.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
static void
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(ASTContext &Ctx, QualType T,
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
bool OnlyDeduced,
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
unsigned Depth,
SmallBitVectorize the deduced parameter set. llvm-svn: 149253
2012-01-31 00:17:39 +08:00
llvm::SmallBitVector &Used) {
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
if (T.isNull())
return;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
// Non-dependent types have nothing deducible
if (!T->isDependentType())
return;
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
T = Ctx.getCanonicalType(T);
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
switch (T->getTypeClass()) {
case Type::Pointer:
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx,
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
cast<PointerType>(T)->getPointeeType(),
OnlyDeduced,
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
Depth,
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
Used);
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
break;
case Type::BlockPointer:
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx,
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
cast<BlockPointerType>(T)->getPointeeType(),
OnlyDeduced,
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
Depth,
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
Used);
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
break;
case Type::LValueReference:
case Type::RValueReference:
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx,
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
cast<ReferenceType>(T)->getPointeeType(),
OnlyDeduced,
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
Depth,
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
Used);
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
break;
case Type::MemberPointer: {
const MemberPointerType *MemPtr = cast<MemberPointerType>(T.getTypePtr());
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx, MemPtr->getPointeeType(), OnlyDeduced,
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
Depth, Used);
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx, QualType(MemPtr->getClass(), 0),
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
OnlyDeduced, Depth, Used);
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
break;
}
case Type::DependentSizedArray:
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx,
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
cast<DependentSizedArrayType>(T)->getSizeExpr(),
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
OnlyDeduced, Depth, Used);
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
// Fall through to check the element type
case Type::ConstantArray:
case Type::IncompleteArray:
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx,
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
cast<ArrayType>(T)->getElementType(),
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
OnlyDeduced, Depth, Used);
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
break;
case Type::Vector:
case Type::ExtVector:
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx,
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
cast<VectorType>(T)->getElementType(),
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
OnlyDeduced, Depth, Used);
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
break;
Support dependent extended vector types and template instantiation thereof. Patch by Anders Johnsen! llvm-svn: 73641
2009-06-18 05:51:59 +08:00
case Type::DependentSizedExtVector: {
const DependentSizedExtVectorType *VecType
Some cleanups suggested by Chris llvm-svn: 73713
2009-06-19 02:45:36 +08:00
= cast<DependentSizedExtVectorType>(T);
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx, VecType->getElementType(), OnlyDeduced,
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
Depth, Used);
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx, VecType->getSizeExpr(), OnlyDeduced,
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
Depth, Used);
Support dependent extended vector types and template instantiation thereof. Patch by Anders Johnsen! llvm-svn: 73641
2009-06-18 05:51:59 +08:00
break;
}
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
case Type::FunctionProto: {
Some cleanups suggested by Chris llvm-svn: 73713
2009-06-19 02:45:36 +08:00
const FunctionProtoType *Proto = cast<FunctionProtoType>(T);
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx, Proto->getResultType(), OnlyDeduced,
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
Depth, Used);
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
for (unsigned I = 0, N = Proto->getNumArgs(); I != N; ++I)
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx, Proto->getArgType(I), OnlyDeduced,
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
Depth, Used);
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
break;
}
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
case Type::TemplateTypeParm: {
const TemplateTypeParmType *TTP = cast<TemplateTypeParmType>(T);
if (TTP->getDepth() == Depth)
Used[TTP->getIndex()] = true;
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
break;
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
}
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
Fix a few warnings stemming from my inability to properly fill out switch() statements. llvm-svn: 123429
2011-01-14 13:11:40 +08:00
case Type::SubstTemplateTypeParmPack: {
const SubstTemplateTypeParmPackType *Subst
= cast<SubstTemplateTypeParmPackType>(T);
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx,
Fix a few warnings stemming from my inability to properly fill out switch() statements. llvm-svn: 123429
2011-01-14 13:11:40 +08:00
QualType(Subst->getReplacedParameter(), 0),
OnlyDeduced, Depth, Used);
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx, Subst->getArgumentPack(),
Fix a few warnings stemming from my inability to properly fill out switch() statements. llvm-svn: 123429
2011-01-14 13:11:40 +08:00
OnlyDeduced, Depth, Used);
break;
}
Make the InjectedClassNameType the canonical type of the current instantiation of a class template or class template partial specialization. That is to say, in template <class T> class A { ... }; or template <class T> class B<const T*> { ... }; make 'A<T>' and 'B<const T*>' sugar for the corresponding InjectedClassNameType when written inside the appropriate context. This allows us to track the current instantiation appropriately even inside AST routines. It also allows us to compute a DeclContext for a type much more efficiently, at some extra cost every time we write a template specialization (which can be optimized, but I've left it simple in this patch). llvm-svn: 102407
2010-04-27 08:57:59 +08:00
case Type::InjectedClassName:
T = cast<InjectedClassNameType>(T)->getInjectedSpecializationType();
// fall through
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
case Type::TemplateSpecialization: {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
const TemplateSpecializationType *Spec
Some cleanups suggested by Chris llvm-svn: 73713
2009-06-19 02:45:36 +08:00
= cast<TemplateSpecializationType>(T);
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx, Spec->getTemplateName(), OnlyDeduced,
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
Depth, Used);
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement the rest of C++0x [temp.deduct.type]p9, which specifies that the presence of a pack expansion anywhere except at the end of a template-argument-list causes the entire template-argument-list to be a non-deduced context. llvm-svn: 122461
2010-12-23 09:24:45 +08:00
// C++0x [temp.deduct.type]p9:
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// If the template argument list of P contains a pack expansion that is not
// the last template argument, the entire template argument list is a
Implement the rest of C++0x [temp.deduct.type]p9, which specifies that the presence of a pack expansion anywhere except at the end of a template-argument-list causes the entire template-argument-list to be a non-deduced context. llvm-svn: 122461
2010-12-23 09:24:45 +08:00
// non-deduced context.
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
if (OnlyDeduced &&
Implement the rest of C++0x [temp.deduct.type]p9, which specifies that the presence of a pack expansion anywhere except at the end of a template-argument-list causes the entire template-argument-list to be a non-deduced context. llvm-svn: 122461
2010-12-23 09:24:45 +08:00
hasPackExpansionBeforeEnd(Spec->getArgs(), Spec->getNumArgs()))
break;
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I)
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx, Spec->getArg(I), OnlyDeduced, Depth,
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
Used);
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
break;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
case Type::Complex:
if (!OnlyDeduced)
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx,
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
cast<ComplexType>(T)->getElementType(),
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
OnlyDeduced, Depth, Used);
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
break;
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
Support for C1x _Atomic specifier (see testcase). This is primarily being committed at the moment to help support C++0x <atomic>, but it should be a solid base for implementing the full specification of C1x _Atomic. Thanks to Jeffrey Yasskin for the thorough review! llvm-svn: 141330
2011-10-07 07:00:33 +08:00
case Type::Atomic:
if (!OnlyDeduced)
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx,
Support for C1x _Atomic specifier (see testcase). This is primarily being committed at the moment to help support C++0x <atomic>, but it should be a solid base for implementing the full specification of C1x _Atomic. Thanks to Jeffrey Yasskin for the thorough review! llvm-svn: 141330
2011-10-07 07:00:33 +08:00
cast<AtomicType>(T)->getValueType(),
OnlyDeduced, Depth, Used);
break;
Rename TypenameType to DependentNameType in anticipation of some refactoring work in this area. llvm-svn: 100019
2010-04-01 01:34:00 +08:00
case Type::DependentName:
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
if (!OnlyDeduced)
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx,
Rename TypenameType to DependentNameType in anticipation of some refactoring work in this area. llvm-svn: 100019
2010-04-01 01:34:00 +08:00
cast<DependentNameType>(T)->getQualifier(),
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
OnlyDeduced, Depth, Used);
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
break;
Split DependentNameType into two types. DependentNameType represents the case of an elaborated-type-specifier like 'typename A<T>::foo', and DependentTemplateSpecializationType represents the case of an elaborated-type-specifier like 'typename A<T>::template B<T>'. The TypeLoc representation of a DependentTST conveniently exactly matches that of an ElaboratedType wrapping a TST. Kill off the explicit rebuild methods for RebuildInCurrentInstantiation; the standard implementations work fine because the nested name specifier is computable in the newly-entered context. llvm-svn: 105801
2010-06-11 08:33:02 +08:00
case Type::DependentTemplateSpecialization: {
const DependentTemplateSpecializationType *Spec
= cast<DependentTemplateSpecializationType>(T);
if (!OnlyDeduced)
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx, Spec->getQualifier(),
Split DependentNameType into two types. DependentNameType represents the case of an elaborated-type-specifier like 'typename A<T>::foo', and DependentTemplateSpecializationType represents the case of an elaborated-type-specifier like 'typename A<T>::template B<T>'. The TypeLoc representation of a DependentTST conveniently exactly matches that of an ElaboratedType wrapping a TST. Kill off the explicit rebuild methods for RebuildInCurrentInstantiation; the standard implementations work fine because the nested name specifier is computable in the newly-entered context. llvm-svn: 105801
2010-06-11 08:33:02 +08:00
OnlyDeduced, Depth, Used);
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement the rest of C++0x [temp.deduct.type]p9, which specifies that the presence of a pack expansion anywhere except at the end of a template-argument-list causes the entire template-argument-list to be a non-deduced context. llvm-svn: 122461
2010-12-23 09:24:45 +08:00
// C++0x [temp.deduct.type]p9:
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// If the template argument list of P contains a pack expansion that is not
// the last template argument, the entire template argument list is a
Implement the rest of C++0x [temp.deduct.type]p9, which specifies that the presence of a pack expansion anywhere except at the end of a template-argument-list causes the entire template-argument-list to be a non-deduced context. llvm-svn: 122461
2010-12-23 09:24:45 +08:00
// non-deduced context.
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
if (OnlyDeduced &&
Implement the rest of C++0x [temp.deduct.type]p9, which specifies that the presence of a pack expansion anywhere except at the end of a template-argument-list causes the entire template-argument-list to be a non-deduced context. llvm-svn: 122461
2010-12-23 09:24:45 +08:00
hasPackExpansionBeforeEnd(Spec->getArgs(), Spec->getNumArgs()))
break;
Split DependentNameType into two types. DependentNameType represents the case of an elaborated-type-specifier like 'typename A<T>::foo', and DependentTemplateSpecializationType represents the case of an elaborated-type-specifier like 'typename A<T>::template B<T>'. The TypeLoc representation of a DependentTST conveniently exactly matches that of an ElaboratedType wrapping a TST. Kill off the explicit rebuild methods for RebuildInCurrentInstantiation; the standard implementations work fine because the nested name specifier is computable in the newly-entered context. llvm-svn: 105801
2010-06-11 08:33:02 +08:00
for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I)
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx, Spec->getArg(I), OnlyDeduced, Depth,
Split DependentNameType into two types. DependentNameType represents the case of an elaborated-type-specifier like 'typename A<T>::foo', and DependentTemplateSpecializationType represents the case of an elaborated-type-specifier like 'typename A<T>::template B<T>'. The TypeLoc representation of a DependentTST conveniently exactly matches that of an ElaboratedType wrapping a TST. Kill off the explicit rebuild methods for RebuildInCurrentInstantiation; the standard implementations work fine because the nested name specifier is computable in the newly-entered context. llvm-svn: 105801
2010-06-11 08:33:02 +08:00
Used);
break;
}
Split out types that are non-canonical unless dependent as their own category. Use this in a few places to eliminate unnecessary TST cases and do some future-proofing. Provide terrible manglings for typeof. Mangle decltype with some hope of accuracy. Our manglings for some of the cases covered in the testcase are different from gcc's, which I've raised as an issue with the ABI list. llvm-svn: 97523
2010-03-02 07:49:17 +08:00
case Type::TypeOf:
if (!OnlyDeduced)
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx,
Split out types that are non-canonical unless dependent as their own category. Use this in a few places to eliminate unnecessary TST cases and do some future-proofing. Provide terrible manglings for typeof. Mangle decltype with some hope of accuracy. Our manglings for some of the cases covered in the testcase are different from gcc's, which I've raised as an issue with the ABI list. llvm-svn: 97523
2010-03-02 07:49:17 +08:00
cast<TypeOfType>(T)->getUnderlyingType(),
OnlyDeduced, Depth, Used);
break;
case Type::TypeOfExpr:
if (!OnlyDeduced)
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx,
Split out types that are non-canonical unless dependent as their own category. Use this in a few places to eliminate unnecessary TST cases and do some future-proofing. Provide terrible manglings for typeof. Mangle decltype with some hope of accuracy. Our manglings for some of the cases covered in the testcase are different from gcc's, which I've raised as an issue with the ABI list. llvm-svn: 97523
2010-03-02 07:49:17 +08:00
cast<TypeOfExprType>(T)->getUnderlyingExpr(),
OnlyDeduced, Depth, Used);
break;
case Type::Decltype:
if (!OnlyDeduced)
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx,
Split out types that are non-canonical unless dependent as their own category. Use this in a few places to eliminate unnecessary TST cases and do some future-proofing. Provide terrible manglings for typeof. Mangle decltype with some hope of accuracy. Our manglings for some of the cases covered in the testcase are different from gcc's, which I've raised as an issue with the ABI list. llvm-svn: 97523
2010-03-02 07:49:17 +08:00
cast<DecltypeType>(T)->getUnderlyingExpr(),
OnlyDeduced, Depth, Used);
break;
Implement a new type node, UnaryTransformType, designed to represent a type that turns one type into another. This is used as the basis to implement __underlying_type properly - with TypeSourceInfo and proper behavior in the face of templates. llvm-svn: 132017
2011-05-25 06:41:36 +08:00
case Type::UnaryTransform:
if (!OnlyDeduced)
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx,
Implement a new type node, UnaryTransformType, designed to represent a type that turns one type into another. This is used as the basis to implement __underlying_type properly - with TypeSourceInfo and proper behavior in the face of templates. llvm-svn: 132017
2011-05-25 06:41:36 +08:00
cast<UnaryTransformType>(T)->getUnderlyingType(),
OnlyDeduced, Depth, Used);
break;
Split out types that are non-canonical unless dependent as their own category. Use this in a few places to eliminate unnecessary TST cases and do some future-proofing. Provide terrible manglings for typeof. Mangle decltype with some hope of accuracy. Our manglings for some of the cases covered in the testcase are different from gcc's, which I've raised as an issue with the ABI list. llvm-svn: 97523
2010-03-02 07:49:17 +08:00
Introduce a new type, PackExpansionType, to capture types that are pack expansions, e.g. given template<typename... Types> struct tuple; template<typename... Types> struct tuple_of_refs { typedef tuple<Types&...> types; }; the type of the "types" typedef is a PackExpansionType whose pattern is Types&. This commit introduces support for creating pack expansions for template type arguments, as above, but not for any other kind of pack expansion, nor for any form of instantiation. llvm-svn: 122223
2010-12-20 10:24:11 +08:00
case Type::PackExpansion:
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx,
Introduce a new type, PackExpansionType, to capture types that are pack expansions, e.g. given template<typename... Types> struct tuple; template<typename... Types> struct tuple_of_refs { typedef tuple<Types&...> types; }; the type of the "types" typedef is a PackExpansionType whose pattern is Types&. This commit introduces support for creating pack expansions for template type arguments, as above, but not for any other kind of pack expansion, nor for any form of instantiation. llvm-svn: 122223
2010-12-20 10:24:11 +08:00
cast<PackExpansionType>(T)->getPattern(),
OnlyDeduced, Depth, Used);
break;
Implement the C++0x deduced 'auto' feature. This fixes PR 8738, 9060 and 9132. llvm-svn: 126069
2011-02-20 11:19:35 +08:00
case Type::Auto:
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx,
Implement the C++0x deduced 'auto' feature. This fixes PR 8738, 9060 and 9132. llvm-svn: 126069
2011-02-20 11:19:35 +08:00
cast<AutoType>(T)->getDeducedType(),
OnlyDeduced, Depth, Used);
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
// None of these types have any template parameters in them.
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
case Type::Builtin:
case Type::VariableArray:
case Type::FunctionNoProto:
case Type::Record:
case Type::Enum:
case Type::ObjCInterface:
Substantially alter the design of the Objective C type AST by introducing ObjCObjectType, which is basically just a pair of one of {primitive-id, primitive-Class, user-defined @class} with a list of protocols. An ObjCObjectPointerType is therefore just a pointer which always points to one of these types (possibly sugared). ObjCInterfaceType is now just a kind of ObjCObjectType which happens to not carry any protocols. Alter a rather large number of use sites to use ObjCObjectType instead of ObjCInterfaceType. Store an ObjCInterfaceType as a pointer on the decl rather than hashing them in a FoldingSet. Remove some number of methods that are no longer used, at least after this patch. By simplifying ObjCObjectPointerType, we are now able to easily remove and apply pointers to Objective-C types, which is crucial for a certain kind of ObjC++ metaprogramming common in WebKit. llvm-svn: 103870
2010-05-15 19:32:37 +08:00
case Type::ObjCObject:
First step toward fixing <rdar://problem/6613046> refactor clang objc type representation. Add a type (ObjCObjectPointerType) and remove a type (ObjCQualifiedIdType). This large/tedious patch is just a first step. Next step is to remove ObjCQualifiedInterfaceType. After that, I will remove the magic TypedefType for 'id' (installed by Sema). This work will enable various simplifications throughout clang (when dealing with ObjC types). No functionality change. llvm-svn: 73649
2009-06-18 06:40:22 +08:00
case Type::ObjCObjectPointer:
Fix "using typename" and the instantiation of non-dependent using declarations. llvm-svn: 90614
2009-12-05 06:46:56 +08:00
case Type::UnresolvedUsing:
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
#define TYPE(Class, Base)
#define ABSTRACT_TYPE(Class, Base)
#define DEPENDENT_TYPE(Class, Base)
#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
#include "clang/AST/TypeNodes.def"
break;
}
}
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
/// \brief Mark the template parameters that are used by this
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
/// template argument.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
static void
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(ASTContext &Ctx,
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
const TemplateArgument &TemplateArg,
bool OnlyDeduced,
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
unsigned Depth,
SmallBitVectorize the deduced parameter set. llvm-svn: 149253
2012-01-31 00:17:39 +08:00
llvm::SmallBitVector &Used) {
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
switch (TemplateArg.getKind()) {
case TemplateArgument::Null:
case TemplateArgument::Integral:
Implement support for null non-type template arguments for non-type template parameters of pointer, pointer-to-member, or nullptr_t type in C++11. Fixes PR9700 / <rdar://problem/11193097>. llvm-svn: 154219
2012-04-07 06:40:38 +08:00
case TemplateArgument::Declaration:
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
break;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Fix the AST representation for non-type template arguments to encode enough information so we can mangle them correctly in cases involving dependent parameter types. (This specifically impacts cases involving null pointers and cases involving parameters of reference type.) Fix the mangler to use this information instead of trying to scavenge it out of the parameter declaration. <rdar://problem/12296776>. llvm-svn: 164656
2012-09-26 10:36:12 +08:00
case TemplateArgument::NullPtr:
MarkUsedTemplateParameters(Ctx, TemplateArg.getNullPtrType(), OnlyDeduced,
Depth, Used);
break;
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
case TemplateArgument::Type:
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx, TemplateArg.getAsType(), OnlyDeduced,
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
Depth, Used);
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
break;
Introduce a new representation for template template parameters. Rather than storing them as either declarations (for the non-dependent case) or expressions (for the dependent case), we now (always) store them as TemplateNames. The primary change here is to add a new kind of TemplateArgument, which stores a TemplateName. However, making that change ripples to every switch on a TemplateArgument's kind, also affecting TemplateArgumentLocInfo/TemplateArgumentLoc, default template arguments for template template parameters, type-checking of template template arguments, etc. This change is light on testing. It should fix several pre-existing problems with template template parameters, such as: - the inability to use dependent template names as template template arguments - template template parameter default arguments cannot be instantiation However, there are enough pieces missing that more implementation is required before we can adequately test template template parameters. llvm-svn: 86777
2009-11-11 09:00:40 +08:00
case TemplateArgument::Template:
Replace the representation of template template argument pack expansions with something that is easier to use correctly: a new template argment kind, rather than a bit on an existing kind. Update all of the switch statements that deal with template arguments, fixing a few latent bugs in the process. I"m happy with this representation, now. And, oh look! Template instantiation and deduction work for template template argument pack expansions. llvm-svn: 122896
2011-01-06 02:58:31 +08:00
case TemplateArgument::TemplateExpansion:
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx,
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
TemplateArg.getAsTemplateOrTemplatePattern(),
Introduce a new representation for template template parameters. Rather than storing them as either declarations (for the non-dependent case) or expressions (for the dependent case), we now (always) store them as TemplateNames. The primary change here is to add a new kind of TemplateArgument, which stores a TemplateName. However, making that change ripples to every switch on a TemplateArgument's kind, also affecting TemplateArgumentLocInfo/TemplateArgumentLoc, default template arguments for template template parameters, type-checking of template template arguments, etc. This change is light on testing. It should fix several pre-existing problems with template template parameters, such as: - the inability to use dependent template names as template template arguments - template template parameter default arguments cannot be instantiation However, there are enough pieces missing that more implementation is required before we can adequately test template template parameters. llvm-svn: 86777
2009-11-11 09:00:40 +08:00
OnlyDeduced, Depth, Used);
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
break;
case TemplateArgument::Expression:
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx, TemplateArg.getAsExpr(), OnlyDeduced,
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
Depth, Used);
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
break;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Add a new 'Pack' argument kind to TemplateArgument. This is not yet used. llvm-svn: 73391
2009-06-16 01:04:53 +08:00
case TemplateArgument::Pack:
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
for (TemplateArgument::pack_iterator P = TemplateArg.pack_begin(),
PEnd = TemplateArg.pack_end();
P != PEnd; ++P)
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
MarkUsedTemplateParameters(Ctx, *P, OnlyDeduced, Depth, Used);
Add a new 'Pack' argument kind to TemplateArgument. This is not yet used. llvm-svn: 73391
2009-06-16 01:04:53 +08:00
break;
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
}
}
Documentation cleanup: making \param docs match the code. llvm-svn: 158982
2012-06-22 18:16:05 +08:00
/// \brief Mark which template parameters can be deduced from a given
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
/// template argument list.
///
/// \param TemplateArgs the template argument list from which template
/// parameters will be deduced.
///
Documentation cleanup: making \param docs match the code. llvm-svn: 158982
2012-06-22 18:16:05 +08:00
/// \param Used a bit vector whose elements will be set to \c true
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
/// to indicate when the corresponding template parameter will be
/// deduced.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
void
Refactor MarkDeductedTemplateParameters into MarkUsedTemplateParameters, which is able to mark template parameters used within non-deduced contexts as well as deduced contexts. Use this to finish the implementation of [temp.deduct.partial]p11. llvm-svn: 81794
2009-09-15 05:25:05 +08:00
Sema::MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs,
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
bool OnlyDeduced, unsigned Depth,
SmallBitVectorize the deduced parameter set. llvm-svn: 149253
2012-01-31 00:17:39 +08:00
llvm::SmallBitVector &Used) {
Implement the rest of C++0x [temp.deduct.type]p9, which specifies that the presence of a pack expansion anywhere except at the end of a template-argument-list causes the entire template-argument-list to be a non-deduced context. llvm-svn: 122461
2010-12-23 09:24:45 +08:00
// C++0x [temp.deduct.type]p9:
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// If the template argument list of P contains a pack expansion that is not
// the last template argument, the entire template argument list is a
Implement the rest of C++0x [temp.deduct.type]p9, which specifies that the presence of a pack expansion anywhere except at the end of a template-argument-list causes the entire template-argument-list to be a non-deduced context. llvm-svn: 122461
2010-12-23 09:24:45 +08:00
// non-deduced context.
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
if (OnlyDeduced &&
Implement the rest of C++0x [temp.deduct.type]p9, which specifies that the presence of a pack expansion anywhere except at the end of a template-argument-list causes the entire template-argument-list to be a non-deduced context. llvm-svn: 122461
2010-12-23 09:24:45 +08:00
hasPackExpansionBeforeEnd(TemplateArgs.data(), TemplateArgs.size()))
return;
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
::MarkUsedTemplateParameters(Context, TemplateArgs[I], OnlyDeduced,
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
Depth, Used);
When some template parameters of a class template partial specialization cannot be deduced, produce a warning noting that the affected class template partial specialization will never be used. llvm-svn: 73274
2009-06-13 08:26:55 +08:00
}
Make the construction of the code-completion string for a function template smarter, by taking into account which function template parameters are deducible from the call arguments. For example, template<typename RandomAccessIterator> void sort(RandomAccessIterator first, RandomAccessIterator last); will have a code-completion string like sort({RandomAccessIterator first}, {RandomAccessIterator last}) since the template argument for its template parameter is deducible. On the other hand, template<class X, class Y> X* dyn_cast(Y *Val); will have a code-completion string like dyn_cast<{class X}>({Y *Val}) since the template type parameter X is not deducible from the function call. llvm-svn: 82306
2009-09-19 07:21:38 +08:00
/// \brief Marks all of the template parameters that will be deduced by a
/// call to the given function template.
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
void
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
Sema::MarkDeducedTemplateParameters(ASTContext &Ctx,
Use 'const Decl *' throughout code completion in Sema llvm-svn: 173277
2013-01-24 01:21:11 +08:00
const FunctionTemplateDecl *FunctionTemplate,
SmallBitVectorize the deduced parameter set. llvm-svn: 149253
2012-01-31 00:17:39 +08:00
llvm::SmallBitVector &Deduced) {
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
TemplateParameterList *TemplateParams
Make the construction of the code-completion string for a function template smarter, by taking into account which function template parameters are deducible from the call arguments. For example, template<typename RandomAccessIterator> void sort(RandomAccessIterator first, RandomAccessIterator last); will have a code-completion string like sort({RandomAccessIterator first}, {RandomAccessIterator last}) since the template argument for its template parameter is deducible. On the other hand, template<class X, class Y> X* dyn_cast(Y *Val); will have a code-completion string like dyn_cast<{class X}>({Y *Val}) since the template type parameter X is not deducible from the function call. llvm-svn: 82306
2009-09-19 07:21:38 +08:00
= FunctionTemplate->getTemplateParameters();
Deduced.clear();
Deduced.resize(TemplateParams->size());
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Make the construction of the code-completion string for a function template smarter, by taking into account which function template parameters are deducible from the call arguments. For example, template<typename RandomAccessIterator> void sort(RandomAccessIterator first, RandomAccessIterator last); will have a code-completion string like sort({RandomAccessIterator first}, {RandomAccessIterator last}) since the template argument for its template parameter is deducible. On the other hand, template<class X, class Y> X* dyn_cast(Y *Val); will have a code-completion string like dyn_cast<{class X}>({Y *Val}) since the template type parameter X is not deducible from the function call. llvm-svn: 82306
2009-09-19 07:21:38 +08:00
FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I)
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
::MarkUsedTemplateParameters(Ctx, Function->getParamDecl(I)->getType(),
Implement support for semantic checking and template instantiation of class template partial specializations of member templates. Also, fixes a silly little bug in the marking of "used" template parameters in member templates. Fixes PR5236. llvm-svn: 85447
2009-10-29 08:04:11 +08:00
true, TemplateParams->getDepth(), Deduced);
Make the construction of the code-completion string for a function template smarter, by taking into account which function template parameters are deducible from the call arguments. For example, template<typename RandomAccessIterator> void sort(RandomAccessIterator first, RandomAccessIterator last); will have a code-completion string like sort({RandomAccessIterator first}, {RandomAccessIterator last}) since the template argument for its template parameter is deducible. On the other hand, template<class X, class Y> X* dyn_cast(Y *Val); will have a code-completion string like dyn_cast<{class X}>({Y *Val}) since the template type parameter X is not deducible from the function call. llvm-svn: 82306
2009-09-19 07:21:38 +08:00
}
Implement the consistency checking for C++ [temp.deduct.call]p3, which checks that the deduced argument type for a function call matches the actual argument type provided. The only place we've found where the consistency checking should actually cause template argument deduction failure is due to qualifier differences that don't fall into the realm of qualification conversions (which are *not* checked when we initially perform deduction). However, we're performing the full checking as specified in the standard to ensure that no other cases exist. Fixes PR9233 / <rdar://problem/9039590>. llvm-svn: 133163
2011-06-17 00:50:48 +08:00
bool hasDeducibleTemplateParameters(Sema &S,
FunctionTemplateDecl *FunctionTemplate,
QualType T) {
if (!T->isDependentType())
return false;
TemplateParameterList *TemplateParams
= FunctionTemplate->getTemplateParameters();
SmallBitVectorize the deduced parameter set. llvm-svn: 149253
2012-01-31 00:17:39 +08:00
llvm::SmallBitVector Deduced(TemplateParams->size());
Introduce a static Sema::MarkDeducedTemplateParameters() that only depends on an ASTContext. This is a step towards making clang_getCursorCompletionString not depend on Sema. llvm-svn: 148277
2012-01-17 10:15:41 +08:00
::MarkUsedTemplateParameters(S.Context, T, true, TemplateParams->getDepth(),
Implement the consistency checking for C++ [temp.deduct.call]p3, which checks that the deduced argument type for a function call matches the actual argument type provided. The only place we've found where the consistency checking should actually cause template argument deduction failure is due to qualifier differences that don't fall into the realm of qualification conversions (which are *not* checked when we initially perform deduction). However, we're performing the full checking as specified in the standard to ensure that no other cases exist. Fixes PR9233 / <rdar://problem/9039590>. llvm-svn: 133163
2011-06-17 00:50:48 +08:00
Deduced);
SmallBitVectorize the deduced parameter set. llvm-svn: 149253
2012-01-31 00:17:39 +08:00
return Deduced.any();
Implement the consistency checking for C++ [temp.deduct.call]p3, which checks that the deduced argument type for a function call matches the actual argument type provided. The only place we've found where the consistency checking should actually cause template argument deduction failure is due to qualifier differences that don't fall into the realm of qualification conversions (which are *not* checked when we initially perform deduction). However, we're performing the full checking as specified in the standard to ensure that no other cases exist. Fixes PR9233 / <rdar://problem/9039590>. llvm-svn: 133163
2011-06-17 00:50:48 +08:00
}