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

5436 lines
219 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"
Implement conversion to function pointer for generic lambdas without captures. The general strategy is to create template versions of the conversion function and static invoker and then during template argument deduction of the conversion function, create the corresponding call-operator and static invoker specializations, and when the conversion function is marked referenced generate the body of the conversion function using the corresponding static-invoker specialization. Similarly, Codegen does something similar - when asked to emit the IR for a specialized static invoker of a generic lambda, it forwards emission to the corresponding call operator. This patch has been reviewed in person both by Doug and Richard. Richard gave me the LGTM. A few minor changes: - per Richard's request i added a simple check to gracefully inform that captures (init, explicit or default) have not been added to generic lambdas just yet (instead of the assertion violation). - I removed a few lines of code that added the call operators instantiated parameters to the currentinstantiationscope. Not only did it not handle parameter packs, but it is more relevant in the patch for nested lambdas which will follow this one, and fix that problem more comprehensively. - Doug had commented that the original implementation strategy of using the TypeSourceInfo of the call operator to create the static-invoker was flawed and allowed const as a member qualifier to creep into the type of the static-invoker. I currently kludge around it - but after my initial discussion with Doug, with a follow up session with Richard, I have added a FIXME so that a more elegant solution that involves the use of TrivialTypeSourceInfo call followed by the correct wiring of the template parameters to the functionprototypeloc is forthcoming. Thanks! llvm-svn: 191634
2013-09-29 16:45:24 +08:00
#include "clang/AST/ASTLambda.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"
Add missing "original call argument has same type as deduced parameter type" check for deductions from elements of a braced-init-list. llvm-svn: 291190
2017-01-06 07:02:44 +08:00
#include "clang/AST/TypeOrdering.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/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
[c++1z] Support deducing B in noexcept(B). This is not required by the standard (yet), but there seems to be reasonable support for this being a defect according to CWG discussion, and libstdc++ 7.1 relies on it working. llvm-svn: 304946
2017-06-08 05:46:22 +08:00
/// terms of noreturn and default calling convention adjustments, or
/// similarly matching a declared template specialization against a
/// possible template, per C++ [temp.deduct.decl]. In either case, permit
/// deduction where the parameter is a function type that can be converted
/// to the argument type.
TDF_AllowCompatibleFunctionType = 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
};
Revert r240270 ("Fixed/added namespace ending comments using clang-tidy"). llvm-svn: 240353
2015-06-23 07:07:51 +08:00
}
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
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,
P0127R2: Support type deduction for types of non-type template parameters in C++1z. Patch by James Touton! Some bugfixes and rebasing by me. llvm-svn: 282651
2016-09-29 07:55:27 +08:00
bool PartialOrdering = false,
bool DeducedFromArrayBound = false);
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
[Sema] Disallow ambigious base classes in template argument deduction Fixes PR28195. Differential revision: http://reviews.llvm.org/D21653 llvm-svn: 274077
2016-06-29 07:05:09 +08:00
DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
ArrayRefize lists of TemplateArguments in template argument deduction. llvm-svn: 290461
2016-12-24 07:46:56 +08:00
ArrayRef<TemplateArgument> Params,
ArrayRef<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
TemplateDeductionInfo &Info,
[Sema] Disallow ambigious base classes in template argument deduction Fixes PR28195. Differential revision: http://reviews.llvm.org/D21653 llvm-svn: 274077
2016-06-29 07:05:09 +08:00
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
bool NumberOfArgumentsMustMatch);
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
Fix deduction of type of pack-expanded non-type template parameter. We need to look through the PackExpansionType in the parameter type when deducing, and we need to consider the possibility of deducing arguments for packs that are not lexically mentioned in the pattern (but are nonetheless deducible) when figuring out which packs are covered by a pack deduction scope. llvm-svn: 295790
2017-02-22 07:49:18 +08:00
static void MarkUsedTemplateParameters(ASTContext &Ctx,
const TemplateArgument &TemplateArg,
bool OnlyDeduced, unsigned Depth,
llvm::SmallBitVector &Used);
static void MarkUsedTemplateParameters(ASTContext &Ctx, QualType T,
bool OnlyDeduced, unsigned Level,
llvm::SmallBitVector &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
/// \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.
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
static NonTypeTemplateParmDecl *
getDeducedParameterFromExpr(TemplateDeductionInfo &Info, 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))
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
if (auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl()))
if (NTTP->getDepth() == Info.getDeducedDepth())
return NTTP;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
return nullptr;
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
}
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
When merging two deduced non-type template arguments for the same parameter, fail the merge if the arguments have different types (except if one of them was deduced from an array bound, in which case take the type from the other). This is correct because (except in the array bound case) the type of the template argument in each deduction must match the type of the parameter, so at least one of the two deduced arguments must have a mismatched type. This is necessary because we would otherwise lose the type information for the discarded template argument in the merge, and fail to diagnose the mismatch. In order to power this, we now properly retain the type of a deduced non-type template argument deduced from a declaration, rather than giving it the type of the template parameter; we'll convert it to the template parameter type when checking the deduced arguments. llvm-svn: 290399
2016-12-23 09:30:39 +08:00
// If we have two non-type template argument values deduced for the same
// parameter, they must both match the type of the parameter, and thus must
// match each other's type. As we're only keeping one of them, we must check
// for that now. The exception is that if either was deduced from an array
// bound, the type is permitted to differ.
if (!X.wasDeducedFromArrayBound() && !Y.wasDeducedFromArrayBound()) {
QualType XType = X.getNonTypeTemplateArgumentType();
if (!XType.isNull()) {
QualType YType = Y.getNonTypeTemplateArgumentType();
if (YType.isNull() || !Context.hasSameType(XType, YType))
return 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
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
P0127R2: Support type deduction for types of non-type template parameters in C++1z. Patch by James Touton! Some bugfixes and rebasing by me. llvm-svn: 282651
2016-09-29 07:55:27 +08:00
// If one of the two arguments was deduced from an array bound, the other
// supersedes it.
if (X.wasDeducedFromArrayBound() != Y.wasDeducedFromArrayBound())
return X.wasDeducedFromArrayBound() ? Y : X;
// The arguments are not compatible.
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())))
When merging two deduced non-type template arguments for the same parameter, fail the merge if the arguments have different types (except if one of them was deduced from an array bound, in which case take the type from the other). This is correct because (except in the array bound case) the type of the template argument in each deduction must match the type of the parameter, so at least one of the two deduced arguments must have a mismatched type. This is necessary because we would otherwise lose the type information for the discarded template argument in the merge, and fail to diagnose the mismatch. In order to power this, we now properly retain the type of a deduced non-type template argument deduced from a declaration, rather than giving it the type of the template parameter; we'll convert it to the template parameter type when checking the deduced arguments. llvm-svn: 290399
2016-12-23 09:30:39 +08:00
return X.wasDeducedFromArrayBound() ? Y : 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
// 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
When merging two deduced non-type template arguments for the same parameter, fail the merge if the arguments have different types (except if one of them was deduced from an array bound, in which case take the type from the other). This is correct because (except in the array bound case) the type of the template argument in each deduction must match the type of the parameter, so at least one of the two deduced arguments must have a mismatched type. This is necessary because we would otherwise lose the type information for the discarded template argument in the merge, and fail to diagnose the mismatch. In order to power this, we now properly retain the type of a deduced non-type template argument deduced from a declaration, rather than giving it the type of the template parameter; we'll convert it to the template parameter type when checking the deduced arguments. llvm-svn: 290399
2016-12-23 09:30:39 +08:00
case TemplateArgument::Expression: {
if (Y.getKind() != TemplateArgument::Expression)
return checkDeducedTemplateArguments(Context, Y, X);
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
When merging two deduced non-type template arguments for the same parameter, fail the merge if the arguments have different types (except if one of them was deduced from an array bound, in which case take the type from the other). This is correct because (except in the array bound case) the type of the template argument in each deduction must match the type of the parameter, so at least one of the two deduced arguments must have a mismatched type. This is necessary because we would otherwise lose the type information for the discarded template argument in the merge, and fail to diagnose the mismatch. In order to power this, we now properly retain the type of a deduced non-type template argument deduced from a declaration, rather than giving it the type of the template parameter; we'll convert it to the template parameter type when checking the deduced arguments. llvm-svn: 290399
2016-12-23 09:30:39 +08:00
// 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.wasDeducedFromArrayBound() ? Y : X;
// Differing dependent expressions are incompatible.
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();
When merging two deduced non-type template arguments for the same parameter, fail the merge if the arguments have different types (except if one of them was deduced from an array bound, in which case take the type from the other). This is correct because (except in the array bound case) the type of the template argument in each deduction must match the type of the parameter, so at least one of the two deduced arguments must have a mismatched type. This is necessary because we would otherwise lose the type information for the discarded template argument in the merge, and fail to diagnose the mismatch. In order to power this, we now properly retain the type of a deduced non-type template argument deduced from a declaration, rather than giving it the type of the template parameter; we'll convert it to the template parameter type when checking the deduced arguments. llvm-svn: 290399
2016-12-23 09:30:39 +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
case TemplateArgument::Declaration:
When merging two deduced non-type template arguments for the same parameter, fail the merge if the arguments have different types (except if one of them was deduced from an array bound, in which case take the type from the other). This is correct because (except in the array bound case) the type of the template argument in each deduction must match the type of the parameter, so at least one of the two deduced arguments must have a mismatched type. This is necessary because we would otherwise lose the type information for the discarded template argument in the merge, and fail to diagnose the mismatch. In order to power this, we now properly retain the type of a deduced non-type template argument deduced from a declaration, rather than giving it the type of the template parameter; we'll convert it to the template parameter type when checking the deduced arguments. llvm-svn: 290399
2016-12-23 09:30:39 +08:00
assert(!X.wasDeducedFromArrayBound());
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 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
When merging two deduced non-type template arguments for the same parameter, fail the merge if the arguments have different types (except if one of them was deduced from an array bound, in which case take the type from the other). This is correct because (except in the array bound case) the type of the template argument in each deduction must match the type of the parameter, so at least one of the two deduced arguments must have a mismatched type. This is necessary because we would otherwise lose the type information for the discarded template argument in the merge, and fail to diagnose the mismatch. In order to power this, we now properly retain the type of a deduced non-type template argument deduced from a declaration, rather than giving it the type of the template parameter; we'll convert it to the template parameter type when checking the deduced arguments. llvm-svn: 290399
2016-12-23 09:30:39 +08:00
// integral constant and whichever type did not come from an array
// bound.
if (Y.getKind() == TemplateArgument::Integral) {
if (Y.wasDeducedFromArrayBound())
return TemplateArgument(Context, Y.getAsIntegral(),
X.getParamTypeForDecl());
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 Y;
When merging two deduced non-type template arguments for the same parameter, fail the merge if the arguments have different types (except if one of them was deduced from an array bound, in which case take the type from the other). This is correct because (except in the array bound case) the type of the template argument in each deduction must match the type of the parameter, so at least one of the two deduced arguments must have a mismatched type. This is necessary because we would otherwise lose the type information for the discarded template argument in the merge, and fail to diagnose the mismatch. In order to power this, we now properly retain the type of a deduced non-type template argument deduced from a declaration, rather than giving it the type of the template parameter; we'll convert it to the template parameter type when checking the deduced arguments. llvm-svn: 290399
2016-12-23 09:30:39 +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
// If we deduced two declarations, make sure they they refer to the
// same declaration.
if (Y.getKind() == TemplateArgument::Declaration &&
PR21246: DebugInfo: Emit the appropriate type (cv qualifiers, reference-ness, etc) for non-type template parameters Plumb through the full QualType of the TemplateArgument::Declaration, as it's insufficient to only know whether the type is a reference or pointer (that was necessary for mangling, but insufficient for debug info). This shouldn't increase the size of TemplateArgument as TemplateArgument::Integer is still longer by another 32 bits. Several bits of code were testing that the reference-ness of the parameters matched, but this seemed to be insufficient (various other features of the type could've mismatched and wouldn't've been caught) and unnecessary, at least insofar as removing those tests didn't cause anything to fail. (Richard - perchaps you can hypothesize why any of these checks might need to test reference-ness of the parameters (& explain why reference-ness is part of the mangling - I would've figured that for the reference-ness to be different, a prior template argument would have to be different). I'd be happy to add them in/beef them up and add test cases if there's a reason for them) llvm-svn: 219900
2014-10-16 12:21:25 +08:00
isSameDeclaration(X.getAsDecl(), Y.getAsDecl()))
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 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;
When merging two deduced non-type template arguments for the same parameter, fail the merge if the arguments have different types (except if one of them was deduced from an array bound, in which case take the type from the other). This is correct because (except in the array bound case) the type of the template argument in each deduction must match the type of the parameter, so at least one of the two deduced arguments must have a mismatched type. This is necessary because we would otherwise lose the type information for the discarded template argument in the merge, and fail to diagnose the mismatch. In order to power this, we now properly retain the type of a deduced non-type template argument deduced from a declaration, rather than giving it the type of the template parameter; we'll convert it to the template parameter type when checking the deduced arguments. llvm-svn: 290399
2016-12-23 09:30:39 +08:00
// If we deduced two null pointers, they are the same.
if (Y.getKind() == TemplateArgument::NullPtr)
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
Fix template argument deduction when only some of a parameter pack is a non-deduced context. When a parameter pack has multiple corresponding arguments, and some subset of them are overloaded functions, it's possible that some subset of the parameters are non-deduced contexts. In such a case, keep deducing from the remainder of the arguments, and resolve the incomplete pack against whatever other deductions we've performed for the pack. GCC, MSVC, and ICC give three different bad behaviors for this case; what we do now (and what we did before) don't exactly match any of them, sadly :( I'm getting a core issue opened to specify more precisely how this should be handled. llvm-svn: 290923
2017-01-04 09:48:55 +08:00
llvm::SmallVector<TemplateArgument, 8> NewPack;
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 template argument deduction when only some of a parameter pack is a non-deduced context. When a parameter pack has multiple corresponding arguments, and some subset of them are overloaded functions, it's possible that some subset of the parameters are non-deduced contexts. In such a case, keep deducing from the remainder of the arguments, and resolve the incomplete pack against whatever other deductions we've performed for the pack. GCC, MSVC, and ICC give three different bad behaviors for this case; what we do now (and what we did before) don't exactly match any of them, sadly :( I'm getting a core issue opened to specify more precisely how this should be handled. llvm-svn: 290923
2017-01-04 09:48:55 +08:00
TemplateArgument Merged = checkDeducedTemplateArguments(
Context, DeducedTemplateArgument(*XA, X.wasDeducedFromArrayBound()),
DeducedTemplateArgument(*YA, Y.wasDeducedFromArrayBound()));
if (Merged.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 template argument deduction when only some of a parameter pack is a non-deduced context. When a parameter pack has multiple corresponding arguments, and some subset of them are overloaded functions, it's possible that some subset of the parameters are non-deduced contexts. In such a case, keep deducing from the remainder of the arguments, and resolve the incomplete pack against whatever other deductions we've performed for the pack. GCC, MSVC, and ICC give three different bad behaviors for this case; what we do now (and what we did before) don't exactly match any of them, sadly :( I'm getting a core issue opened to specify more precisely how this should be handled. llvm-svn: 290923
2017-01-04 09:48:55 +08:00
NewPack.push_back(Merged);
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
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Fix template argument deduction when only some of a parameter pack is a non-deduced context. When a parameter pack has multiple corresponding arguments, and some subset of them are overloaded functions, it's possible that some subset of the parameters are non-deduced contexts. In such a case, keep deducing from the remainder of the arguments, and resolve the incomplete pack against whatever other deductions we've performed for the pack. GCC, MSVC, and ICC give three different bad behaviors for this case; what we do now (and what we did before) don't exactly match any of them, sadly :( I'm getting a core issue opened to specify more precisely how this should be handled. llvm-svn: 290923
2017-01-04 09:48:55 +08:00
return DeducedTemplateArgument(
TemplateArgument::CreatePackCopy(Context, NewPack),
X.wasDeducedFromArrayBound() && Y.wasDeducedFromArrayBound());
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
}
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
Factor out repeated code for deducing a non-type template parameter as a given argument value. No functionality change intended. llvm-svn: 290576
2016-12-27 11:59:58 +08:00
/// as the given deduced template argument. All non-type template parameter
/// deduction is funneled through here.
Apply some suggestions from clang-tidy's performance-unnecessary-value-param. No functionality change intended. llvm-svn: 272789
2016-06-15 22:20:56 +08:00
static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument(
P0127R2: Support type deduction for types of non-type template parameters in C++1z. Patch by James Touton! Some bugfixes and rebasing by me. llvm-svn: 282651
2016-09-29 07:55:27 +08:00
Sema &S, TemplateParameterList *TemplateParams,
Factor out repeated code for deducing a non-type template parameter as a given argument value. No functionality change intended. llvm-svn: 290576
2016-12-27 11:59:58 +08:00
NonTypeTemplateParmDecl *NTTP, const DeducedTemplateArgument &NewDeduced,
QualType ValueType, TemplateDeductionInfo &Info,
Apply some suggestions from clang-tidy's performance-unnecessary-value-param. No functionality change intended. llvm-svn: 272789
2016-06-15 22:20:56 +08:00
SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
assert(NTTP->getDepth() == Info.getDeducedDepth() &&
"deducing non-type template argument with wrong depth");
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Factor out repeated code for deducing a non-type template parameter as a given argument value. No functionality change intended. llvm-svn: 290576
2016-12-27 11:59:58 +08:00
DeducedTemplateArgument Result = checkDeducedTemplateArguments(
S.Context, Deduced[NTTP->getIndex()], NewDeduced);
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()) {
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;
Work around a standard defect: template argument deduction for non-type template parameters of reference type basically doesn't work, because we're always deducing from an argument expression of non-reference type, so the type of the deduced expression never matches. Instead, compare the type of an expression naming the parameter to the type of the argument. llvm-svn: 290586
2016-12-27 14:14:37 +08:00
if (!S.getLangOpts().CPlusPlus1z)
return Sema::TDK_Success;
Fix deduction of type of pack-expanded non-type template parameter. We need to look through the PackExpansionType in the parameter type when deducing, and we need to consider the possibility of deducing arguments for packs that are not lexically mentioned in the pattern (but are nonetheless deducible) when figuring out which packs are covered by a pack deduction scope. llvm-svn: 295790
2017-02-22 07:49:18 +08:00
if (NTTP->isExpandedParameterPack())
// FIXME: We may still need to deduce parts of the type here! But we
// don't have any way to find which slice of the type to use, and the
// type stored on the NTTP itself is nonsense. Perhaps the type of an
// expanded NTTP should be a pack expansion type?
return Sema::TDK_Success;
// Get the type of the parameter for deduction.
QualType ParamType = NTTP->getType();
if (auto *Expansion = dyn_cast<PackExpansionType>(ParamType))
ParamType = Expansion->getPattern();
Work around a standard defect: template argument deduction for non-type template parameters of reference type basically doesn't work, because we're always deducing from an argument expression of non-reference type, so the type of the deduced expression never matches. Instead, compare the type of an expression naming the parameter to the type of the argument. llvm-svn: 290586
2016-12-27 14:14:37 +08:00
// FIXME: It's not clear how deduction of a parameter of reference
// type from an argument (of non-reference type) should be performed.
// For now, we just remove reference types from both sides and let
// the final check for matching types sort out the mess.
return DeduceTemplateArgumentsByTypeMatch(
Fix deduction of type of pack-expanded non-type template parameter. We need to look through the PackExpansionType in the parameter type when deducing, and we need to consider the possibility of deducing arguments for packs that are not lexically mentioned in the pattern (but are nonetheless deducible) when figuring out which packs are covered by a pack deduction scope. llvm-svn: 295790
2017-02-22 07:49:18 +08:00
S, TemplateParams, ParamType.getNonReferenceType(),
Work around a standard defect: template argument deduction for non-type template parameters of reference type basically doesn't work, because we're always deducing from an argument expression of non-reference type, so the type of the deduced expression never matches. Instead, compare the type of an expression naming the parameter to the type of the argument. llvm-svn: 290586
2016-12-27 14:14:37 +08:00
ValueType.getNonReferenceType(), Info, Deduced, TDF_SkipNonDependent,
/*PartialOrdering=*/false,
/*ArrayBound=*/NewDeduced.wasDeducedFromArrayBound());
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
}
Factor out repeated code for deducing a non-type template parameter as a given argument value. No functionality change intended. llvm-svn: 290576
2016-12-27 11:59:58 +08:00
/// \brief Deduce the value of the given non-type template parameter
/// from the given integral constant.
static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument(
Sema &S, TemplateParameterList *TemplateParams,
NonTypeTemplateParmDecl *NTTP, const llvm::APSInt &Value,
QualType ValueType, bool DeducedFromArrayBound, TemplateDeductionInfo &Info,
SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
return DeduceNonTypeTemplateArgument(
S, TemplateParams, NTTP,
DeducedTemplateArgument(S.Context, Value, ValueType,
DeducedFromArrayBound),
ValueType, Info, Deduced);
}
Fix bug where template argument deduction of a non-type template parameter used as a template argument in a template-id, from a null non-type template argument, failed. Extracted from a patch by James Touton! llvm-svn: 282641
2016-09-29 06:08:38 +08:00
/// \brief Deduce the value of the given non-type template parameter
/// from the given null pointer template argument type.
static Sema::TemplateDeductionResult DeduceNullPtrTemplateArgument(
P0127R2: Support type deduction for types of non-type template parameters in C++1z. Patch by James Touton! Some bugfixes and rebasing by me. llvm-svn: 282651
2016-09-29 07:55:27 +08:00
Sema &S, TemplateParameterList *TemplateParams,
NonTypeTemplateParmDecl *NTTP, QualType NullPtrType,
Fix bug where template argument deduction of a non-type template parameter used as a template argument in a template-id, from a null non-type template argument, failed. Extracted from a patch by James Touton! llvm-svn: 282641
2016-09-29 06:08:38 +08:00
TemplateDeductionInfo &Info,
SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
Expr *Value =
S.ImpCastExprToType(new (S.Context) CXXNullPtrLiteralExpr(
S.Context.NullPtrTy, NTTP->getLocation()),
NullPtrType, CK_NullToPointer)
.get();
Factor out repeated code for deducing a non-type template parameter as a given argument value. No functionality change intended. llvm-svn: 290576
2016-12-27 11:59:58 +08:00
return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
DeducedTemplateArgument(Value),
Value->getType(), Info, Deduced);
Fix bug where template argument deduction of a non-type template parameter used as a template argument in a template-id, from a null non-type template argument, failed. Extracted from a patch by James Touton! llvm-svn: 282641
2016-09-29 06:08:38 +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.
Factor out repeated code for deducing a non-type template parameter as a given argument value. No functionality change intended. llvm-svn: 290576
2016-12-27 11:59:58 +08:00
static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument(
Sema &S, TemplateParameterList *TemplateParams,
NonTypeTemplateParmDecl *NTTP, Expr *Value, TemplateDeductionInfo &Info,
SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
DeducedTemplateArgument(Value),
Value->getType(), 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
}
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.
Factor out repeated code for deducing a non-type template parameter as a given argument value. No functionality change intended. llvm-svn: 290576
2016-12-27 11:59:58 +08:00
static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument(
Sema &S, TemplateParameterList *TemplateParams,
NonTypeTemplateParmDecl *NTTP, ValueDecl *D, QualType T,
TemplateDeductionInfo &Info,
SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
D = D ? cast<ValueDecl>(D->getCanonicalDecl()) : nullptr;
When merging two deduced non-type template arguments for the same parameter, fail the merge if the arguments have different types (except if one of them was deduced from an array bound, in which case take the type from the other). This is correct because (except in the array bound case) the type of the template argument in each deduction must match the type of the parameter, so at least one of the two deduced arguments must have a mismatched type. This is necessary because we would otherwise lose the type information for the discarded template argument in the merge, and fail to diagnose the mismatch. In order to power this, we now properly retain the type of a deduced non-type template argument deduced from a declaration, rather than giving it the type of the template parameter; we'll convert it to the template parameter type when checking the deduced arguments. llvm-svn: 290399
2016-12-23 09:30:39 +08:00
TemplateArgument New(D, T);
Factor out repeated code for deducing a non-type template parameter as a given argument value. No functionality change intended. llvm-svn: 290576
2016-12-27 11:59:58 +08:00
return DeduceNonTypeTemplateArgument(
S, TemplateParams, NTTP, DeducedTemplateArgument(New), T, 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
}
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)) {
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
// If we're not deducing at this depth, there's nothing to deduce.
if (TempParam->getDepth() != Info.getDeducedDepth())
return Sema::TDK_Success;
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.
ArrayRefize lists of TemplateArguments in template argument deduction. llvm-svn: 290461
2016-12-24 07:46:56 +08:00
return DeduceTemplateArguments(S, TemplateParams,
Param->template_arguments(),
SpecArg->template_arguments(), Info, Deduced,
[Sema] Disallow ambigious base classes in template argument deduction Fixes PR28195. Differential revision: http://reviews.llvm.org/D21653 llvm-svn: 274077
2016-06-29 07:05:09 +08:00
/*NumberOfArgumentsMustMatch=*/false);
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.
ArrayRefize lists of TemplateArguments in template argument deduction. llvm-svn: 290461
2016-12-24 07:46:56 +08:00
return DeduceTemplateArguments(S, TemplateParams, Param->template_arguments(),
SpecArg->getTemplateArgs().asArray(), Info,
Deduced, /*NumberOfArgumentsMustMatch=*/true);
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));
}
PR19878: If a pack expansion appears within another pack expansion, correctly deduce any packs that are expanded by both expansions. llvm-svn: 209786
2014-05-29 09:12:14 +08:00
/// A pack that we're currently deducing.
struct clang::DeducedPack {
DeducedPack(unsigned Index) : Index(Index), Outer(nullptr) {}
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
PR19878: If a pack expansion appears within another pack expansion, correctly deduce any packs that are expanded by both expansions. llvm-svn: 209786
2014-05-29 09:12:14 +08:00
// The index of the pack.
unsigned Index;
// The old value of the pack before we started deducing it.
DeducedTemplateArgument Saved;
// A deferred value of this pack from an inner deduction, that couldn't be
// deduced because this deduction hadn't happened yet.
DeducedTemplateArgument DeferredDeduction;
// The new value of the pack.
SmallVector<DeducedTemplateArgument, 4> New;
// The outer deduction for this pack, if any.
DeducedPack *Outer;
};
Move private classes into anonymous namespaces Also merge anonymous namespaces in Targets.cpp a bit. NFC. llvm-svn: 232945
2015-03-23 20:31:05 +08:00
namespace {
PR19878: If a pack expansion appears within another pack expansion, correctly deduce any packs that are expanded by both expansions. llvm-svn: 209786
2014-05-29 09:12:14 +08:00
/// A scope in which we're performing pack deduction.
class PackDeductionScope {
public:
PackDeductionScope(Sema &S, TemplateParameterList *TemplateParams,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
TemplateDeductionInfo &Info, TemplateArgument Pattern)
: S(S), TemplateParams(TemplateParams), Deduced(Deduced), Info(Info) {
Fix deduction of type of pack-expanded non-type template parameter. We need to look through the PackExpansionType in the parameter type when deducing, and we need to consider the possibility of deducing arguments for packs that are not lexically mentioned in the pattern (but are nonetheless deducible) when figuring out which packs are covered by a pack deduction scope. llvm-svn: 295790
2017-02-22 07:49:18 +08:00
// Dig out the partially-substituted pack, if there is one.
const TemplateArgument *PartialPackArgs = nullptr;
unsigned NumPartialPackArgs = 0;
std::pair<unsigned, unsigned> PartialPackDepthIndex(-1u, -1u);
if (auto *Scope = S.CurrentInstantiationScope)
if (auto *Partial = Scope->getPartiallySubstitutedPack(
&PartialPackArgs, &NumPartialPackArgs))
PartialPackDepthIndex = getDepthAndIndex(Partial);
PR19878: If a pack expansion appears within another pack expansion, correctly deduce any packs that are expanded by both expansions. llvm-svn: 209786
2014-05-29 09:12:14 +08:00
// Compute the set of template parameter indices that correspond to
// parameter packs expanded by the pack expansion.
{
llvm::SmallBitVector SawIndices(TemplateParams->size());
Fix deduction of type of pack-expanded non-type template parameter. We need to look through the PackExpansionType in the parameter type when deducing, and we need to consider the possibility of deducing arguments for packs that are not lexically mentioned in the pattern (but are nonetheless deducible) when figuring out which packs are covered by a pack deduction scope. llvm-svn: 295790
2017-02-22 07:49:18 +08:00
auto AddPack = [&](unsigned Index) {
if (SawIndices[Index])
return;
SawIndices[Index] = true;
// Save the deduced template argument for the parameter pack expanded
// by this pack expansion, then clear out the deduction.
DeducedPack Pack(Index);
Pack.Saved = Deduced[Index];
Deduced[Index] = TemplateArgument();
Packs.push_back(Pack);
};
// First look for unexpanded packs in the pattern.
PR19878: If a pack expansion appears within another pack expansion, correctly deduce any packs that are expanded by both expansions. llvm-svn: 209786
2014-05-29 09:12:14 +08:00
SmallVector<UnexpandedParameterPack, 2> Unexpanded;
S.collectUnexpandedParameterPacks(Pattern, Unexpanded);
for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
unsigned Depth, Index;
std::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]);
Fix deduction of type of pack-expanded non-type template parameter. We need to look through the PackExpansionType in the parameter type when deducing, and we need to consider the possibility of deducing arguments for packs that are not lexically mentioned in the pattern (but are nonetheless deducible) when figuring out which packs are covered by a pack deduction scope. llvm-svn: 295790
2017-02-22 07:49:18 +08:00
if (Depth == Info.getDeducedDepth())
AddPack(Index);
PR19878: If a pack expansion appears within another pack expansion, correctly deduce any packs that are expanded by both expansions. llvm-svn: 209786
2014-05-29 09:12:14 +08:00
}
Fix deduction of type of pack-expanded non-type template parameter. We need to look through the PackExpansionType in the parameter type when deducing, and we need to consider the possibility of deducing arguments for packs that are not lexically mentioned in the pattern (but are nonetheless deducible) when figuring out which packs are covered by a pack deduction scope. llvm-svn: 295790
2017-02-22 07:49:18 +08:00
assert(!Packs.empty() && "Pack expansion without unexpanded packs?");
// This pack expansion will have been partially expanded iff the only
// unexpanded parameter pack within it is the partially-substituted pack.
IsPartiallyExpanded =
Packs.size() == 1 &&
PartialPackDepthIndex ==
std::make_pair(Info.getDeducedDepth(), Packs.front().Index);
// Skip over the pack elements that were expanded into separate arguments.
if (IsPartiallyExpanded)
PackElements += NumPartialPackArgs;
// We can also have deduced template parameters that do not actually
// appear in the pattern, but can be deduced by it (the type of a non-type
// template parameter pack, in particular). These won't have prevented us
// from partially expanding the pack.
llvm::SmallBitVector Used(TemplateParams->size());
MarkUsedTemplateParameters(S.Context, Pattern, /*OnlyDeduced*/true,
Info.getDeducedDepth(), Used);
for (int Index = Used.find_first(); Index != -1;
Index = Used.find_next(Index))
if (TemplateParams->getParam(Index)->isParameterPack())
AddPack(Index);
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
}
PR19878: If a pack expansion appears within another pack expansion, correctly deduce any packs that are expanded by both expansions. llvm-svn: 209786
2014-05-29 09:12:14 +08:00
for (auto &Pack : Packs) {
if (Info.PendingDeducedPacks.size() > Pack.Index)
Pack.Outer = Info.PendingDeducedPacks[Pack.Index];
else
Info.PendingDeducedPacks.resize(Pack.Index + 1);
Info.PendingDeducedPacks[Pack.Index] = &Pack;
Fix deduction of type of pack-expanded non-type template parameter. We need to look through the PackExpansionType in the parameter type when deducing, and we need to consider the possibility of deducing arguments for packs that are not lexically mentioned in the pattern (but are nonetheless deducible) when figuring out which packs are covered by a pack deduction scope. llvm-svn: 295790
2017-02-22 07:49:18 +08:00
if (PartialPackDepthIndex ==
std::make_pair(Info.getDeducedDepth(), Pack.Index)) {
Pack.New.append(PartialPackArgs, PartialPackArgs + NumPartialPackArgs);
// We pre-populate the deduced value of the partially-substituted
// pack with the specified value. This is not entirely correct: the
// value is supposed to have been substituted, not deduced, but the
// cases where this is observable require an exact type match anyway.
//
// FIXME: If we could represent a "depth i, index j, pack elem k"
// parameter, we could substitute the partially-substituted pack
// everywhere and avoid this.
if (Pack.New.size() > PackElements)
Deduced[Pack.Index] = Pack.New[PackElements];
PR19878: If a pack expansion appears within another pack expansion, correctly deduce any packs that are expanded by both expansions. llvm-svn: 209786
2014-05-29 09:12:14 +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
}
PR19878: If a pack expansion appears within another pack expansion, correctly deduce any packs that are expanded by both expansions. llvm-svn: 209786
2014-05-29 09:12:14 +08:00
}
~PackDeductionScope() {
for (auto &Pack : Packs)
Info.PendingDeducedPacks[Pack.Index] = Pack.Outer;
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement DR1388 (wg21.link/cwg1388). This issue clarifies how deduction proceeds past a non-trailing function parameter pack. Essentially, the pack itself is skipped and consumes no arguments (except for those implied by an explicitly-specified template arguments), and nothing is deduced from it. As a small fix to the standard's rule, we do not allow subsequent deduction to change the length of the function parameter pack (by preventing extension of the explicitly-specified pack if present, and otherwise deducing all contained packs to empty packs). llvm-svn: 291425
2017-01-09 15:14:40 +08:00
/// Determine whether this pack has already been partially expanded into a
/// sequence of (prior) function parameters / template arguments.
Fix deduction of type of pack-expanded non-type template parameter. We need to look through the PackExpansionType in the parameter type when deducing, and we need to consider the possibility of deducing arguments for packs that are not lexically mentioned in the pattern (but are nonetheless deducible) when figuring out which packs are covered by a pack deduction scope. llvm-svn: 295790
2017-02-22 07:49:18 +08:00
bool isPartiallyExpanded() { return IsPartiallyExpanded; }
Implement DR1388 (wg21.link/cwg1388). This issue clarifies how deduction proceeds past a non-trailing function parameter pack. Essentially, the pack itself is skipped and consumes no arguments (except for those implied by an explicitly-specified template arguments), and nothing is deduced from it. As a small fix to the standard's rule, we do not allow subsequent deduction to change the length of the function parameter pack (by preventing extension of the explicitly-specified pack if present, and otherwise deducing all contained packs to empty packs). llvm-svn: 291425
2017-01-09 15:14:40 +08:00
PR19878: If a pack expansion appears within another pack expansion, correctly deduce any packs that are expanded by both expansions. llvm-svn: 209786
2014-05-29 09:12:14 +08:00
/// Move to deducing the next element in each pack that is being deduced.
void nextPackElement() {
// 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 (auto &Pack : Packs) {
DeducedTemplateArgument &DeducedArg = Deduced[Pack.Index];
Fix template argument deduction when only some of a parameter pack is a non-deduced context. When a parameter pack has multiple corresponding arguments, and some subset of them are overloaded functions, it's possible that some subset of the parameters are non-deduced contexts. In such a case, keep deducing from the remainder of the arguments, and resolve the incomplete pack against whatever other deductions we've performed for the pack. GCC, MSVC, and ICC give three different bad behaviors for this case; what we do now (and what we did before) don't exactly match any of them, sadly :( I'm getting a core issue opened to specify more precisely how this should be handled. llvm-svn: 290923
2017-01-04 09:48:55 +08:00
if (!Pack.New.empty() || !DeducedArg.isNull()) {
while (Pack.New.size() < PackElements)
Pack.New.push_back(DeducedTemplateArgument());
Fix deduction of type of pack-expanded non-type template parameter. We need to look through the PackExpansionType in the parameter type when deducing, and we need to consider the possibility of deducing arguments for packs that are not lexically mentioned in the pattern (but are nonetheless deducible) when figuring out which packs are covered by a pack deduction scope. llvm-svn: 295790
2017-02-22 07:49:18 +08:00
if (Pack.New.size() == PackElements)
Pack.New.push_back(DeducedArg);
else
Pack.New[PackElements] = DeducedArg;
DeducedArg = Pack.New.size() > PackElements + 1
? Pack.New[PackElements + 1]
: DeducedTemplateArgument();
PR19878: If a pack expansion appears within another pack expansion, correctly deduce any packs that are expanded by both expansions. llvm-svn: 209786
2014-05-29 09:12:14 +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
}
Fix template argument deduction when only some of a parameter pack is a non-deduced context. When a parameter pack has multiple corresponding arguments, and some subset of them are overloaded functions, it's possible that some subset of the parameters are non-deduced contexts. In such a case, keep deducing from the remainder of the arguments, and resolve the incomplete pack against whatever other deductions we've performed for the pack. GCC, MSVC, and ICC give three different bad behaviors for this case; what we do now (and what we did before) don't exactly match any of them, sadly :( I'm getting a core issue opened to specify more precisely how this should be handled. llvm-svn: 290923
2017-01-04 09:48:55 +08:00
++PackElements;
PR19878: If a pack expansion appears within another pack expansion, correctly deduce any packs that are expanded by both expansions. llvm-svn: 209786
2014-05-29 09:12:14 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
PR19878: If a pack expansion appears within another pack expansion, correctly deduce any packs that are expanded by both expansions. llvm-svn: 209786
2014-05-29 09:12:14 +08:00
/// \brief Finish template argument deduction for a set of argument packs,
/// producing the argument packs and checking for consistency with prior
/// deductions.
Fix template argument deduction when only some of a parameter pack is a non-deduced context. When a parameter pack has multiple corresponding arguments, and some subset of them are overloaded functions, it's possible that some subset of the parameters are non-deduced contexts. In such a case, keep deducing from the remainder of the arguments, and resolve the incomplete pack against whatever other deductions we've performed for the pack. GCC, MSVC, and ICC give three different bad behaviors for this case; what we do now (and what we did before) don't exactly match any of them, sadly :( I'm getting a core issue opened to specify more precisely how this should be handled. llvm-svn: 290923
2017-01-04 09:48:55 +08:00
Sema::TemplateDeductionResult finish() {
PR19878: If a pack expansion appears within another pack expansion, correctly deduce any packs that are expanded by both expansions. llvm-svn: 209786
2014-05-29 09:12:14 +08:00
// Build argument packs for each of the parameter packs expanded by this
// pack expansion.
for (auto &Pack : Packs) {
// Put back the old value for this pack.
Deduced[Pack.Index] = Pack.Saved;
// Build or find a new value for this pack.
DeducedTemplateArgument NewPack;
Fix template argument deduction when only some of a parameter pack is a non-deduced context. When a parameter pack has multiple corresponding arguments, and some subset of them are overloaded functions, it's possible that some subset of the parameters are non-deduced contexts. In such a case, keep deducing from the remainder of the arguments, and resolve the incomplete pack against whatever other deductions we've performed for the pack. GCC, MSVC, and ICC give three different bad behaviors for this case; what we do now (and what we did before) don't exactly match any of them, sadly :( I'm getting a core issue opened to specify more precisely how this should be handled. llvm-svn: 290923
2017-01-04 09:48:55 +08:00
if (PackElements && Pack.New.empty()) {
PR19878: If a pack expansion appears within another pack expansion, correctly deduce any packs that are expanded by both expansions. llvm-svn: 209786
2014-05-29 09:12:14 +08:00
if (Pack.DeferredDeduction.isNull()) {
// We were not able to deduce anything for this parameter pack
// (because it only appeared in non-deduced contexts), so just
// restore the saved argument pack.
continue;
}
NewPack = Pack.DeferredDeduction;
Pack.DeferredDeduction = TemplateArgument();
} else if (Pack.New.empty()) {
// If we deduced an empty argument pack, create it now.
NewPack = DeducedTemplateArgument(TemplateArgument::getEmptyPack());
} else {
TemplateArgument *ArgumentPack =
new (S.Context) TemplateArgument[Pack.New.size()];
std::copy(Pack.New.begin(), Pack.New.end(), ArgumentPack);
NewPack = DeducedTemplateArgument(
[AST] ArrayRefize template argument packs. No functionality change intended. llvm-svn: 244026
2015-08-05 17:40:22 +08:00
TemplateArgument(llvm::makeArrayRef(ArgumentPack, Pack.New.size())),
When deducing an array bound from the length of an initializer list, don't assume the bound has a non-dependent integral type. llvm-svn: 295698
2017-02-21 15:22:31 +08:00
// FIXME: This is wrong, it's possible that some pack elements are
// deduced from an array bound and others are not:
// template<typename ...T, T ...V> void g(const T (&...p)[V]);
// g({1, 2, 3}, {{}, {}});
// ... should deduce T = {int, size_t (from array bound)}.
PR19878: If a pack expansion appears within another pack expansion, correctly deduce any packs that are expanded by both expansions. llvm-svn: 209786
2014-05-29 09:12:14 +08:00
Pack.New[0].wasDeducedFromArrayBound());
}
// Pick where we're going to put the merged pack.
DeducedTemplateArgument *Loc;
if (Pack.Outer) {
if (Pack.Outer->DeferredDeduction.isNull()) {
// Defer checking this pack until we have a complete pack to compare
// it against.
Pack.Outer->DeferredDeduction = NewPack;
continue;
}
Loc = &Pack.Outer->DeferredDeduction;
} else {
Loc = &Deduced[Pack.Index];
}
// Check the new pack matches any previous value.
DeducedTemplateArgument OldPack = *Loc;
DeducedTemplateArgument Result =
checkDeducedTemplateArguments(S.Context, OldPack, NewPack);
// If we deferred a deduction of this pack, check that one now too.
if (!Result.isNull() && !Pack.DeferredDeduction.isNull()) {
OldPack = Result;
NewPack = Pack.DeferredDeduction;
Result = checkDeducedTemplateArguments(S.Context, OldPack, NewPack);
}
if (Result.isNull()) {
Info.Param =
makeTemplateParameter(TemplateParams->getParam(Pack.Index));
Info.FirstArg = OldPack;
Info.SecondArg = NewPack;
return Sema::TDK_Inconsistent;
}
*Loc = Result;
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
PR19878: If a pack expansion appears within another pack expansion, correctly deduce any packs that are expanded by both expansions. llvm-svn: 209786
2014-05-29 09:12:14 +08:00
return Sema::TDK_Success;
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
PR19878: If a pack expansion appears within another pack expansion, correctly deduce any packs that are expanded by both expansions. llvm-svn: 209786
2014-05-29 09:12:14 +08:00
private:
Sema &S;
TemplateParameterList *TemplateParams;
SmallVectorImpl<DeducedTemplateArgument> &Deduced;
TemplateDeductionInfo &Info;
Fix template argument deduction when only some of a parameter pack is a non-deduced context. When a parameter pack has multiple corresponding arguments, and some subset of them are overloaded functions, it's possible that some subset of the parameters are non-deduced contexts. In such a case, keep deducing from the remainder of the arguments, and resolve the incomplete pack against whatever other deductions we've performed for the pack. GCC, MSVC, and ICC give three different bad behaviors for this case; what we do now (and what we did before) don't exactly match any of them, sadly :( I'm getting a core issue opened to specify more precisely how this should be handled. llvm-svn: 290923
2017-01-04 09:48:55 +08:00
unsigned PackElements = 0;
Fix deduction of type of pack-expanded non-type template parameter. We need to look through the PackExpansionType in the parameter type when deducing, and we need to consider the possibility of deducing arguments for packs that are not lexically mentioned in the pattern (but are nonetheless deducible) when figuring out which packs are covered by a pack deduction scope. llvm-svn: 295790
2017-02-22 07:49:18 +08:00
bool IsPartiallyExpanded = false;
PR19878: If a pack expansion appears within another pack expansion, correctly deduce any packs that are expanded by both expansions. llvm-svn: 209786
2014-05-29 09:12:14 +08:00
SmallVector<DeducedPack, 2> Packs;
};
Move private classes into anonymous namespaces Also merge anonymous namespaces in Targets.cpp a bit. NFC. llvm-svn: 232945
2015-03-23 20:31:05 +08:00
} // namespace
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
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]).
///
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,
PR22435: Correctly implement tiebreaker for reference ordering in function template partial ordering rules. This rule applies per pair of types being compared, not per pair of function templates being compared. llvm-svn: 229965
2015-02-20 12:45:22 +08:00
bool PartialOrdering = false) {
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,
PR22435: Correctly implement tiebreaker for reference ordering in function template partial ordering rules. This rule applies per pair of types being compared, not per pair of function templates being compared. llvm-svn: 229965
2015-02-20 12:45:22 +08:00
PartialOrdering))
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
QualType Pattern = Expansion->getPattern();
PR19878: If a pack expansion appears within another pack expansion, correctly deduce any packs that are expanded by both expansions. llvm-svn: 209786
2014-05-29 09:12:14 +08:00
PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern);
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
for (; ArgIdx < NumArgs; ++ArgIdx) {
// 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,
PR22435: Correctly implement tiebreaker for reference ordering in function template partial ordering rules. This rule applies per pair of types being compared, not per pair of function templates being compared. llvm-svn: 229965
2015-02-20 12:45:22 +08:00
TDF, PartialOrdering))
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
PR19878: If a pack expansion appears within another pack expansion, correctly deduce any packs that are expanded by both expansions. llvm-svn: 209786
2014-05-29 09:12:14 +08:00
PackScope.nextPackElement();
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
// Build argument packs for each of the parameter packs expanded by this
// pack expansion.
Fix template argument deduction when only some of a parameter pack is a non-deduced context. When a parameter pack has multiple corresponding arguments, and some subset of them are overloaded functions, it's possible that some subset of the parameters are non-deduced contexts. In such a case, keep deducing from the remainder of the arguments, and resolve the incomplete pack against whatever other deductions we've performed for the pack. GCC, MSVC, and ICC give three different bad behaviors for this case; what we do now (and what we did before) don't exactly match any of them, sadly :( I'm getting a core issue opened to specify more precisely how this should be handled. llvm-svn: 290923
2017-01-04 09:48:55 +08:00
if (auto Result = PackScope.finish())
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;
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +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
// Mismatched (but not missing) Objective-C GC attributes.
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
if (ParamQs.getObjCGCAttr() != ArgQs.getObjCGCAttr() &&
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
ParamQs.hasObjCGCAttr())
return true;
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +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
// 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;
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +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
// 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;
P0012R1: Make exception specifications be part of the type system. This implements the bulk of the change (modifying the type system to include exception specifications), but not all the details just yet. llvm-svn: 284337
2016-10-17 01:54:23 +08:00
// Noreturn and noexcept adjustment.
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 AdjustedParam;
P0012R1: Make exception specifications be part of the type system. This implements the bulk of the change (modifying the type system to include exception specifications), but not all the details just yet. llvm-svn: 284337
2016-10-17 01:54:23 +08:00
if (IsFunctionConversion(Param, Arg, AdjustedParam))
Fix PR15291: noreturn adjustment in overload resolution for function templates, from Alexander Zinenko! llvm-svn: 179680
2013-04-17 16:45:07 +08:00
return Arg == Context.getCanonicalType(AdjustedParam);
// FIXME: Compatible calling conventions.
return Param == Arg;
}
[c++1z] Synthesize implicit deduction guides from constructors on demand. Rank such guides below explicit ones, and ensure that references to the class's template parameters are not treated as forwarding references. We make a few tweaks to the wording in the current standard: 1) The constructor parameter list is copied faithfully to the deduction guide, without losing default arguments or a varargs ellipsis (which the standard wording loses by omission). 2) If the class template declares no constructors, we add a T() -> T<...> guide (which will only ever work if T has default arguments for all non-pack template parameters). 3) If the class template declares nothing that looks like a copy or move constructor, we add a T(T<...>) -> T<...> guide. #2 and #3 follow from the "pretend we had a class type with these constructors" philosophy for deduction guides. llvm-svn: 295007
2017-02-14 08:25:28 +08:00
/// Get the index of the first template parameter that was originally from the
/// innermost template-parameter-list. This is 0 except when we concatenate
/// the template parameter lists of a class template and a constructor template
/// when forming an implicit deduction guide.
static unsigned getFirstInnerIndex(FunctionTemplateDecl *FTD) {
Add an explicit derived class of FunctionDecl to model deduction guides rather than just treating them as FunctionDecls with a funny name. No functionality change intended. llvm-svn: 295491
2017-02-18 04:05:37 +08:00
auto *Guide = dyn_cast<CXXDeductionGuideDecl>(FTD->getTemplatedDecl());
if (!Guide || !Guide->isImplicit())
[c++1z] Synthesize implicit deduction guides from constructors on demand. Rank such guides below explicit ones, and ensure that references to the class's template parameters are not treated as forwarding references. We make a few tweaks to the wording in the current standard: 1) The constructor parameter list is copied faithfully to the deduction guide, without losing default arguments or a varargs ellipsis (which the standard wording loses by omission). 2) If the class template declares no constructors, we add a T() -> T<...> guide (which will only ever work if T has default arguments for all non-pack template parameters). 3) If the class template declares nothing that looks like a copy or move constructor, we add a T(T<...>) -> T<...> guide. #2 and #3 follow from the "pretend we had a class type with these constructors" philosophy for deduction guides. llvm-svn: 295007
2017-02-14 08:25:28 +08:00
return 0;
Add an explicit derived class of FunctionDecl to model deduction guides rather than just treating them as FunctionDecls with a funny name. No functionality change intended. llvm-svn: 295491
2017-02-18 04:05:37 +08:00
return Guide->getDeducedTemplate()->getTemplateParameters()->size();
[c++1z] Synthesize implicit deduction guides from constructors on demand. Rank such guides below explicit ones, and ensure that references to the class's template parameters are not treated as forwarding references. We make a few tweaks to the wording in the current standard: 1) The constructor parameter list is copied faithfully to the deduction guide, without losing default arguments or a varargs ellipsis (which the standard wording loses by omission). 2) If the class template declares no constructors, we add a T() -> T<...> guide (which will only ever work if T has default arguments for all non-pack template parameters). 3) If the class template declares nothing that looks like a copy or move constructor, we add a T(T<...>) -> T<...> guide. #2 and #3 follow from the "pretend we had a class type with these constructors" philosophy for deduction guides. llvm-svn: 295007
2017-02-14 08:25:28 +08:00
}
/// Determine whether a type denotes a forwarding reference.
static bool isForwardingReference(QualType Param, unsigned FirstInnerIndex) {
// C++1z [temp.deduct.call]p3:
// A forwarding reference is an rvalue reference to a cv-unqualified
// template parameter that does not represent a template parameter of a
// class template.
if (auto *ParamRef = Param->getAs<RValueReferenceType>()) {
if (ParamRef->getPointeeType().getQualifiers())
return false;
auto *TypeParm = ParamRef->getPointeeType()->getAs<TemplateTypeParmType>();
return TypeParm && TypeParm->getIndex() >= FirstInnerIndex;
}
return false;
}
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]).
///
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,
P0127R2: Support type deduction for types of non-type template parameters in C++1z. Patch by James Touton! Some bugfixes and rebasing by me. llvm-svn: 282651
2016-09-29 07:55:27 +08:00
bool PartialOrdering,
bool DeducedFromArrayBound) {
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) {
PR22435: Correctly implement tiebreaker for reference ordering in function template partial ordering rules. This rule applies per pair of types being compared, not per pair of function templates being compared. llvm-svn: 229965
2015-02-20 12:45:22 +08:00
// C++11 [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
PR22435: Correctly implement tiebreaker for reference ordering in function template partial ordering rules. This rule applies per pair of types being compared, not per pair of function templates being compared. llvm-svn: 229965
2015-02-20 12:45:22 +08:00
if (ParamRef && ArgRef && S.Context.hasSameUnqualifiedType(Param, Arg)) {
// C++11 [temp.deduct.partial]p9:
// If, for a given type, deduction succeeds in both directions (i.e.,
// the types are identical after the transformations above) and both
// P and A were reference types [...]:
// - if [one type] was an lvalue reference and [the other type] was
// not, [the other type] is not considered to be at least as
// specialized as [the first type]
// - if [one type] is more cv-qualified than [the other type],
// [the other type] is not considered to be at least as specialized
// as [the first type]
// Objective-C ARC adds:
// - [one type] has non-trivial lifetime, [the other type] has
// __unsafe_unretained lifetime, and the types are otherwise
// identical
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
//
PR22435: Correctly implement tiebreaker for reference ordering in function template partial ordering rules. This rule applies per pair of types being compared, not per pair of function templates being compared. llvm-svn: 229965
2015-02-20 12:45:22 +08:00
// A is "considered to be at least as specialized" as P iff deduction
// succeeds, so we model this as a deduction failure. Note that
// [the first type] is P and [the other type] is A here; the standard
// gets this backwards.
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();
PR22435: Correctly implement tiebreaker for reference ordering in function template partial ordering rules. This rule applies per pair of types being compared, not per pair of function templates being compared. llvm-svn: 229965
2015-02-20 12:45:22 +08:00
if ((ParamRef->isLValueReferenceType() &&
!ArgRef->isLValueReferenceType()) ||
ParamQuals.isStrictSupersetOf(ArgQuals) ||
(ParamQuals.hasNonTrivialObjCLifetime() &&
ArgQuals.getObjCLifetime() == Qualifiers::OCL_ExplicitNone &&
ParamQuals.withoutObjCLifetime() ==
ArgQuals.withoutObjCLifetime())) {
Info.FirstArg = TemplateArgument(ParamIn);
Info.SecondArg = TemplateArgument(ArgIn);
return Sema::TDK_NonDeducedMismatch;
Objective-C ARC++: Prefer references to __strong/__weak over __unsafe_unretained. Fixes <rdar://problem/15713945>. llvm-svn: 198343
2014-01-03 03:42:02 +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
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
PR22435: Correctly implement tiebreaker for reference ordering in function template partial ordering rules. This rule applies per pair of types being compared, not per pair of function templates being compared. llvm-svn: 229965
2015-02-20 12:45:22 +08:00
// C++11 [temp.deduct.partial]p7:
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
// 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,
[c++1z] Synthesize implicit deduction guides from constructors on demand. Rank such guides below explicit ones, and ensure that references to the class's template parameters are not treated as forwarding references. We make a few tweaks to the wording in the current standard: 1) The constructor parameter list is copied faithfully to the deduction guide, without losing default arguments or a varargs ellipsis (which the standard wording loses by omission). 2) If the class template declares no constructors, we add a T() -> T<...> guide (which will only ever work if T has default arguments for all non-pack template parameters). 3) If the class template declares nothing that looks like a copy or move constructor, we add a T(T<...>) -> T<...> guide. #2 and #3 follow from the "pretend we had a class type with these constructors" philosophy for deduction guides. llvm-svn: 295007
2017-02-14 08:25:28 +08:00
// respectively, Pi is adjusted if it is a forwarding reference and Ai
// is an lvalue reference, in
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
// 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;
[c++1z] Synthesize implicit deduction guides from constructors on demand. Rank such guides below explicit ones, and ensure that references to the class's template parameters are not treated as forwarding references. We make a few tweaks to the wording in the current standard: 1) The constructor parameter list is copied faithfully to the deduction guide, without losing default arguments or a varargs ellipsis (which the standard wording loses by omission). 2) If the class template declares no constructors, we add a T() -> T<...> guide (which will only ever work if T has default arguments for all non-pack template parameters). 3) If the class template declares nothing that looks like a copy or move constructor, we add a T(T<...>) -> T<...> guide. #2 and #3 follow from the "pretend we had a class type with these constructors" philosophy for deduction guides. llvm-svn: 295007
2017-02-14 08:25:28 +08:00
if (isForwardingReference(Param, 0) && Arg->isLValueReferenceType())
Param = Param->getPointeeType();
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
}
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>()) {
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
// Just skip any attempts to deduce from a placeholder type or a parameter
// at a different depth.
if (Arg->isPlaceholderType() ||
Info.getDeducedDepth() != TemplateTypeParm->getDepth())
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
return Sema::TDK_Success;
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +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
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
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
assert(TemplateTypeParm->getDepth() == Info.getDeducedDepth() &&
"saw template type parameter with wrong depth");
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();
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +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);
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
return Sema::TDK_Underqualified;
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
}
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
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);
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +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
DeducedType = S.Context.getQualifiedType(DeducedType.getUnqualifiedType(),
DeducedQs);
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
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
P0127R2: Support type deduction for types of non-type template parameters in C++1z. Patch by James Touton! Some bugfixes and rebasing by me. llvm-svn: 282651
2016-09-29 07:55:27 +08:00
DeducedTemplateArgument NewDeduced(DeducedType, 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[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
}
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +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)) {
[c++1z] Support deducing B in noexcept(B). This is not required by the standard (yet), but there seems to be reasonable support for this being a defect according to CWG discussion, and libstdc++ 7.1 relies on it working. llvm-svn: 304946
2017-06-08 05:46:22 +08:00
bool NonDeduced =
(TDF & TDF_AllowCompatibleFunctionType)
? !S.isSameOrCompatibleFunctionType(CanParam, CanArg)
: Param != Arg;
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 (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();
[c++1z] Support deducing B in noexcept(B). This is not required by the standard (yet), but there seems to be reasonable support for this being a defect according to CWG discussion, and libstdc++ 7.1 relies on it working. llvm-svn: 304946
2017-06-08 05:46:22 +08:00
bool Success =
(TDF & TDF_AllowCompatibleFunctionType)
? S.isSameOrCompatibleFunctionType(ParamUnqualType, ArgUnqualType)
: ParamUnqualType == ArgUnqualType;
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 (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"
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +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
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;
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +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 (TDF & TDF_IgnoreQualifiers) {
Param = Param.getUnqualifiedType();
Arg = Arg.getUnqualifiedType();
}
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +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
return Param == Arg? Sema::TDK_Success : Sema::TDK_NonDeducedMismatch;
}
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
// _Complex T [placeholder extension]
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::Complex:
if (const ComplexType *ComplexArg = Arg->getAs<ComplexType>())
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
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: {
Wrap to 80 columns. No behavior change. llvm-svn: 214059
2014-07-28 08:02:09 +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: {
Wrap to 80 columns. No behavior change. llvm-svn: 214059
2014-07-28 08:02:09 +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
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
= getDeducedParameterFromExpr(Info, DependentArrayParm->getSizeExpr());
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 (!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.
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
assert(NTTP->getDepth() == Info.getDeducedDepth() &&
"saw non-type template parameter with wrong depth");
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());
P0127R2: Support type deduction for types of non-type template parameters in C++1z. Patch by James Touton! Some bugfixes and rebasing by me. llvm-svn: 282651
2016-09-29 07:55:27 +08:00
return DeduceNonTypeTemplateArgument(S, TemplateParams, 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())
P0127R2: Support type deduction for types of non-type template parameters in C++1z. Patch by James Touton! Some bugfixes and rebasing by me. llvm-svn: 282651
2016-09-29 07:55:27 +08:00
return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
Be paranoid about NULL size expressions in dependently-sized array types llvm-svn: 122454
2010-12-23 07:15:38 +08:00
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.
[c++1z] Support deducing B in noexcept(B). This is not required by the standard (yet), but there seems to be reasonable support for this being a defect according to CWG discussion, and libstdc++ 7.1 relies on it working. llvm-svn: 304946
2017-06-08 05:46:22 +08:00
if (auto Result = DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, FunctionProtoParam->getReturnType(),
FunctionProtoArg->getReturnType(), 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
[c++1z] Support deducing B in noexcept(B). This is not required by the standard (yet), but there seems to be reasonable support for this being a defect according to CWG discussion, and libstdc++ 7.1 relies on it working. llvm-svn: 304946
2017-06-08 05:46:22 +08:00
// Check parameter types.
if (auto Result = DeduceTemplateArguments(
S, TemplateParams, FunctionProtoParam->param_type_begin(),
FunctionProtoParam->getNumParams(),
FunctionProtoArg->param_type_begin(),
FunctionProtoArg->getNumParams(), Info, Deduced, SubTDF))
return Result;
if (TDF & TDF_AllowCompatibleFunctionType)
return Sema::TDK_Success;
// FIXME: Per core-2016/10/1019 (no corresponding core issue yet), permit
// deducing through the noexcept-specifier if it's part of the canonical
// type. libstdc++ relies on this.
Expr *NoexceptExpr = FunctionProtoParam->getNoexceptExpr();
if (NonTypeTemplateParmDecl *NTTP =
NoexceptExpr ? getDeducedParameterFromExpr(Info, NoexceptExpr)
: nullptr) {
assert(NTTP->getDepth() == Info.getDeducedDepth() &&
"saw non-type template parameter with wrong depth");
llvm::APSInt Noexcept(1);
switch (FunctionProtoArg->canThrow(S.Context)) {
case CT_Cannot:
Noexcept = 1;
LLVM_FALLTHROUGH;
case CT_Can:
// We give E in noexcept(E) the "deduced from array bound" treatment.
// FIXME: Should we?
return DeduceNonTypeTemplateArgument(
S, TemplateParams, NTTP, Noexcept, S.Context.BoolTy,
/*ArrayBound*/true, Info, Deduced);
case CT_Dependent:
if (Expr *ArgNoexceptExpr = FunctionProtoArg->getNoexceptExpr())
return DeduceNonTypeTemplateArgument(
S, TemplateParams, NTTP, ArgNoexceptExpr, Info, Deduced);
// Can't deduce anything from throw(T...).
break;
}
}
// FIXME: Detect non-deduced exception specification mismatches?
return Sema::TDK_Success;
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");
[c++1z] Support deducing B in noexcept(B). This is not required by the standard (yet), but there seems to be reasonable support for this being a defect according to CWG discussion, and libstdc++ 7.1 relies on it working. llvm-svn: 304946
2017-06-08 05:46:22 +08:00
LLVM_FALLTHROUGH;
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
}
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: {
When deducing template parameters from base classes of an argument type, don't preserve any deduced types from a failed deduction to a subsequent attempt at deduction. Patch by Erik Pilkington! llvm-svn: 267444
2016-04-26 03:09:05 +08:00
const TemplateSpecializationType *SpecParam =
cast<TemplateSpecializationType>(Param);
// When Arg cannot be a derived class, we can just try to deduce template
// arguments from the template-id.
const RecordType *RecordT = Arg->getAs<RecordType>();
if (!(TDF & TDF_DerivedClass) || !RecordT)
return DeduceTemplateArguments(S, TemplateParams, SpecParam, Arg, Info,
Deduced);
SmallVector<DeducedTemplateArgument, 8> DeducedOrig(Deduced.begin(),
Deduced.end());
Sema::TemplateDeductionResult Result = DeduceTemplateArguments(
S, TemplateParams, SpecParam, Arg, Info, Deduced);
if (Result == Sema::TDK_Success)
return Result;
// 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.
if (!S.isCompleteType(Info.getLocation(), Arg))
return Result;
// C++14 [temp.deduct.call] p4b3:
// 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.
//
// These alternatives are considered only if type deduction would
// otherwise fail. If they yield more than one possible deduced A, the
// type deduction fails.
Fix PR27601 by reverting [r267453] - Refactor traversal of bases in deduction of template parameters from base This reversal is being done with r267453's author's (i.e. Richard Smith's) permission. This fixes https://llvm.org/bugs/show_bug.cgi?id=27601 Also, per Richard's request the examples from the bug report have been added to our test suite. llvm-svn: 270016
2016-05-19 10:28:21 +08:00
// Reset the incorrectly deduced argument from above.
Deduced = DeducedOrig;
// Use data recursion to crawl through the list of base classes.
// Visited contains the set of nodes we have already visited, while
// ToVisit is our stack of records that we still need to visit.
llvm::SmallPtrSet<const RecordType *, 8> Visited;
SmallVector<const RecordType *, 8> ToVisit;
ToVisit.push_back(RecordT);
When deducing template parameters from base classes of an argument type, don't preserve any deduced types from a failed deduction to a subsequent attempt at deduction. Patch by Erik Pilkington! llvm-svn: 267444
2016-04-26 03:09:05 +08:00
bool Successful = false;
[Sema] Disallow ambigious base classes in template argument deduction Fixes PR28195. Differential revision: http://reviews.llvm.org/D21653 llvm-svn: 274077
2016-06-29 07:05:09 +08:00
SmallVector<DeducedTemplateArgument, 8> SuccessfulDeduced;
Fix PR27601 by reverting [r267453] - Refactor traversal of bases in deduction of template parameters from base This reversal is being done with r267453's author's (i.e. Richard Smith's) permission. This fixes https://llvm.org/bugs/show_bug.cgi?id=27601 Also, per Richard's request the examples from the bug report have been added to our test suite. llvm-svn: 270016
2016-05-19 10:28:21 +08:00
while (!ToVisit.empty()) {
// Retrieve the next class in the inheritance hierarchy.
const RecordType *NextT = ToVisit.pop_back_val();
// If we have already seen this type, skip it.
if (!Visited.insert(NextT).second)
continue;
// If this is a base class, try to perform template argument
// deduction from it.
if (NextT != RecordT) {
TemplateDeductionInfo BaseInfo(Info.getLocation());
Sema::TemplateDeductionResult BaseResult =
DeduceTemplateArguments(S, TemplateParams, SpecParam,
QualType(NextT, 0), BaseInfo, Deduced);
// If template argument deduction for this base was successful,
// note that we had some success. Otherwise, ignore any deductions
// from this base class.
if (BaseResult == Sema::TDK_Success) {
[Sema] Disallow ambigious base classes in template argument deduction Fixes PR28195. Differential revision: http://reviews.llvm.org/D21653 llvm-svn: 274077
2016-06-29 07:05:09 +08:00
// If we've already seen some success, then deduction fails due to
// an ambiguity (temp.deduct.call p5).
if (Successful)
return Sema::TDK_MiscellaneousDeductionFailure;
Fix PR27601 by reverting [r267453] - Refactor traversal of bases in deduction of template parameters from base This reversal is being done with r267453's author's (i.e. Richard Smith's) permission. This fixes https://llvm.org/bugs/show_bug.cgi?id=27601 Also, per Richard's request the examples from the bug report have been added to our test suite. llvm-svn: 270016
2016-05-19 10:28:21 +08:00
Successful = true;
[Sema] Disallow ambigious base classes in template argument deduction Fixes PR28195. Differential revision: http://reviews.llvm.org/D21653 llvm-svn: 274077
2016-06-29 07:05:09 +08:00
std::swap(SuccessfulDeduced, Deduced);
Fix PR27601 by reverting [r267453] - Refactor traversal of bases in deduction of template parameters from base This reversal is being done with r267453's author's (i.e. Richard Smith's) permission. This fixes https://llvm.org/bugs/show_bug.cgi?id=27601 Also, per Richard's request the examples from the bug report have been added to our test suite. llvm-svn: 270016
2016-05-19 10:28:21 +08:00
Info.Param = BaseInfo.Param;
Info.FirstArg = BaseInfo.FirstArg;
Info.SecondArg = BaseInfo.SecondArg;
[Sema] Disallow ambigious base classes in template argument deduction Fixes PR28195. Differential revision: http://reviews.llvm.org/D21653 llvm-svn: 274077
2016-06-29 07:05:09 +08:00
}
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
Fix PR27601 by reverting [r267453] - Refactor traversal of bases in deduction of template parameters from base This reversal is being done with r267453's author's (i.e. Richard Smith's) permission. This fixes https://llvm.org/bugs/show_bug.cgi?id=27601 Also, per Richard's request the examples from the bug report have been added to our test suite. llvm-svn: 270016
2016-05-19 10:28:21 +08:00
// Visit base classes
CXXRecordDecl *Next = cast<CXXRecordDecl>(NextT->getDecl());
for (const auto &Base : Next->bases()) {
assert(Base.getType()->isRecordType() &&
"Base class that isn't a record?");
ToVisit.push_back(Base.getType()->getAs<RecordType>());
}
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
[Sema] Disallow ambigious base classes in template argument deduction Fixes PR28195. Differential revision: http://reviews.llvm.org/D21653 llvm-svn: 274077
2016-06-29 07:05:09 +08:00
if (Successful) {
std::swap(SuccessfulDeduced, Deduced);
When deducing template parameters from base classes of an argument type, don't preserve any deduced types from a failed deduction to a subsequent attempt at deduction. Patch by Erik Pilkington! llvm-svn: 267444
2016-04-26 03:09:05 +08:00
return Sema::TDK_Success;
[Sema] Disallow ambigious base classes in template argument deduction Fixes PR28195. Differential revision: http://reviews.llvm.org/D21653 llvm-svn: 274077
2016-06-29 07:05:09 +08:00
}
When deducing template parameters from base classes of an argument type, don't preserve any deduced types from a failed deduction to a subsequent attempt at deduction. Patch by Erik Pilkington! llvm-svn: 267444
2016-04-26 03:09:05 +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;
[MS Compat] Adjust thiscall to cdecl when deducing template arguments Function types can be extracted from member pointer types. However, the type is not appropriate without first adjusting the calling convention. This fixes PR25661. llvm-svn: 254323
2015-12-01 04:34:28 +08:00
QualType ParamPointeeType = MemPtrParam->getPointeeType();
if (ParamPointeeType->isFunctionType())
S.adjustMemberFunctionCC(ParamPointeeType, /*IsStatic=*/true,
/*IsCtorOrDtor=*/false, Info.getLocation());
QualType ArgPointeeType = MemPtrArg->getPointeeType();
if (ArgPointeeType->isFunctionType())
S.adjustMemberFunctionCC(ArgPointeeType, /*IsStatic=*/true,
/*IsCtorOrDtor=*/false, Info.getLocation());
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,
[MS Compat] Adjust thiscall to cdecl when deducing template arguments Function types can be extracted from member pointer types. However, the type is not appropriate without first adjusting the calling convention. This fixes PR25661. llvm-svn: 254323
2015-12-01 04:34:28 +08:00
ParamPointeeType,
ArgPointeeType,
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
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),
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
Info, Deduced,
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
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;
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +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
// 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
}
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
if (const DependentSizedExtVectorType *VectorArg
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
= 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
}
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +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
return Sema::TDK_NonDeducedMismatch;
}
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +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(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;
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +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
// Perform deduction on the vector size, if we can.
NonTypeTemplateParmDecl *NTTP
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
= getDeducedParameterFromExpr(Info, VectorParam->getSizeExpr());
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 (!NTTP)
return Sema::TDK_Success;
llvm::APSInt ArgSize(S.Context.getTypeSize(S.Context.IntTy), false);
ArgSize = VectorArg->getNumElements();
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
// Note that we use the "array bound" rules here; just like in that
// case, we don't have any particular type for the vector size, but
// we can provide one if necessary.
P0127R2: Support type deduction for types of non-type template parameters in C++1z. Patch by James Touton! Some bugfixes and rebasing by me. llvm-svn: 282651
2016-09-29 07:55:27 +08:00
return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, ArgSize,
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
S.Context.IntTy, true, Info,
When merging two deduced non-type template arguments for the same parameter, fail the merge if the arguments have different types (except if one of them was deduced from an array bound, in which case take the type from the other). This is correct because (except in the array bound case) the type of the template argument in each deduction must match the type of the parameter, so at least one of the two deduced arguments must have a mismatched type. This is necessary because we would otherwise lose the type information for the discarded template argument in the merge, and fail to diagnose the mismatch. In order to power this, we now properly retain the type of a deduced non-type template argument deduced from a declaration, rather than giving it the type of the template parameter; we'll convert it to the template parameter type when checking the deduced arguments. llvm-svn: 290399
2016-12-23 09:30:39 +08:00
Deduced);
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
}
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
if (const DependentSizedExtVectorType *VectorArg
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
= 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;
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +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
// Perform deduction on the vector size, if we can.
NonTypeTemplateParmDecl *NTTP
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
= getDeducedParameterFromExpr(Info, VectorParam->getSizeExpr());
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 (!NTTP)
return Sema::TDK_Success;
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
P0127R2: Support type deduction for types of non-type template parameters in C++1z. Patch by James Touton! Some bugfixes and rebasing by me. llvm-svn: 282651
2016-09-29 07:55:27 +08:00
return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
VectorArg->getSizeExpr(),
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
Info, Deduced);
}
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +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
return Sema::TDK_NonDeducedMismatch;
}
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +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
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:
PR0091R3: Implement parsing support for using templates as types. This change adds a new type node, DeducedTemplateSpecializationType, to represent a type template name that has been used as a type. This is modeled around AutoType, and shares a common base class for representing a deduced placeholder type. We allow deduced class template types in a few more places than the standard does: in conditions and for-range-declarators, and in new-type-ids. This is consistent with GCC and with discussion on the core reflector. This patch does not yet support deduced class template types being named in typename specifiers. llvm-svn: 293207
2017-01-27 04:40:47 +08:00
case Type::DeducedTemplateSpecialization:
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::DependentTemplateSpecialization:
case Type::PackExpansion:
[OpenCL] Pipe type support Summary: Support for OpenCL 2.0 pipe type. This is a bug-fix version for bader's patch reviews.llvm.org/D14441 Reviewers: pekka.jaaskelainen, Anastasia Subscribers: bader, Anastasia, cfe-commits Differential Revision: http://reviews.llvm.org/D15603 llvm-svn: 257254
2016-01-09 20:53:17 +08:00
case Type::Pipe:
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 &&
PR21246: DebugInfo: Emit the appropriate type (cv qualifiers, reference-ness, etc) for non-type template parameters Plumb through the full QualType of the TemplateArgument::Declaration, as it's insufficient to only know whether the type is a reference or pointer (that was necessary for mangling, but insufficient for debug info). This shouldn't increase the size of TemplateArgument as TemplateArgument::Integer is still longer by another 32 bits. Several bits of code were testing that the reference-ness of the parameters matched, but this seemed to be insufficient (various other features of the type could've mismatched and wouldn't've been caught) and unnecessary, at least insofar as removing those tests didn't cause anything to fail. (Richard - perchaps you can hypothesize why any of these checks might need to test reference-ness of the parameters (& explain why reference-ness is part of the mangling - I would've figured that for the reference-ness to be different, a prior template argument would have to be different). I'd be happy to add them in/beef them up and add test cases if there's a reason for them) llvm-svn: 219900
2014-10-16 12:21:25 +08:00
isSameDeclaration(Param.getAsDecl(), Arg.getAsDecl()))
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 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
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
= getDeducedParameterFromExpr(Info, Param.getAsExpr())) {
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::Integral)
P0127R2: Support type deduction for types of non-type template parameters in C++1z. Patch by James Touton! Some bugfixes and rebasing by me. llvm-svn: 282651
2016-09-29 07:55:27 +08:00
return DeduceNonTypeTemplateArgument(S, TemplateParams, 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);
Fix bug where template argument deduction of a non-type template parameter used as a template argument in a template-id, from a null non-type template argument, failed. Extracted from a patch by James Touton! llvm-svn: 282641
2016-09-29 06:08:38 +08:00
if (Arg.getKind() == TemplateArgument::NullPtr)
P0127R2: Support type deduction for types of non-type template parameters in C++1z. Patch by James Touton! Some bugfixes and rebasing by me. llvm-svn: 282651
2016-09-29 07:55:27 +08:00
return DeduceNullPtrTemplateArgument(S, TemplateParams, NTTP,
Arg.getNullPtrType(),
Fix bug where template argument deduction of a non-type template parameter used as a template argument in a template-id, from a null non-type template argument, failed. Extracted from a patch by James Touton! llvm-svn: 282641
2016-09-29 06:08:38 +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)
P0127R2: Support type deduction for types of non-type template parameters in C++1z. Patch by James Touton! Some bugfixes and rebasing by me. llvm-svn: 282651
2016-09-29 07:55:27 +08:00
return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
Arg.getAsExpr(), 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)
P0127R2: Support type deduction for types of non-type template parameters in C++1z. Patch by James Touton! Some bugfixes and rebasing by me. llvm-svn: 282651
2016-09-29 07:55:27 +08:00
return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
Arg.getAsDecl(),
Arg.getParamTypeForDecl(),
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.
ArrayRefize lists of TemplateArguments in template argument deduction. llvm-svn: 290461
2016-12-24 07:46:56 +08:00
static bool hasTemplateArgumentForDeduction(ArrayRef<TemplateArgument> &Args,
unsigned &ArgIdx) {
if (ArgIdx == Args.size())
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
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;
ArrayRefize lists of TemplateArguments in template argument deduction. llvm-svn: 290461
2016-12-24 07:46:56 +08:00
assert(ArgIdx == Args.size() - 1 && "Pack not at the end of argument list?");
Args = Arg.pack_elements();
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
ArgIdx = 0;
ArrayRefize lists of TemplateArguments in template argument deduction. llvm-svn: 290461
2016-12-24 07:46:56 +08:00
return ArgIdx < Args.size();
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
}
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.
ArrayRefize lists of TemplateArguments in template argument deduction. llvm-svn: 290461
2016-12-24 07:46:56 +08:00
static bool hasPackExpansionBeforeEnd(ArrayRef<TemplateArgument> Args) {
bool FoundPackExpansion = false;
for (const auto &A : Args) {
if (FoundPackExpansion)
return true;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
ArrayRefize lists of TemplateArguments in template argument deduction. llvm-svn: 290461
2016-12-24 07:46:56 +08:00
if (A.getKind() == TemplateArgument::Pack)
return hasPackExpansionBeforeEnd(A.pack_elements());
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
ArrayRefize lists of TemplateArguments in template argument deduction. llvm-svn: 290461
2016-12-24 07:46:56 +08:00
if (A.isPackExpansion())
FoundPackExpansion = true;
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
}
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
[Sema] Disallow ambigious base classes in template argument deduction Fixes PR28195. Differential revision: http://reviews.llvm.org/D21653 llvm-svn: 274077
2016-06-29 07:05:09 +08:00
DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
ArrayRefize lists of TemplateArguments in template argument deduction. llvm-svn: 290461
2016-12-24 07:46:56 +08:00
ArrayRef<TemplateArgument> Params,
ArrayRef<TemplateArgument> Args,
Move more stuff out of Sema.h. llvm-svn: 112026
2010-08-25 13:32:35 +08:00
TemplateDeductionInfo &Info,
[Sema] Disallow ambigious base classes in template argument deduction Fixes PR28195. Differential revision: http://reviews.llvm.org/D21653 llvm-svn: 274077
2016-06-29 07:05:09 +08:00
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
bool NumberOfArgumentsMustMatch) {
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.
ArrayRefize lists of TemplateArguments in template argument deduction. llvm-svn: 290461
2016-12-24 07:46:56 +08:00
if (hasPackExpansionBeforeEnd(Params))
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 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;
ArrayRefize lists of TemplateArguments in template argument deduction. llvm-svn: 290461
2016-12-24 07:46:56 +08:00
for (; hasTemplateArgumentForDeduction(Params, ParamIdx); ++ParamIdx) {
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 (!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.
ArrayRefize lists of TemplateArguments in template argument deduction. llvm-svn: 290461
2016-12-24 07:46:56 +08:00
if (!hasTemplateArgumentForDeduction(Args, ArgIdx))
Fix assertion failure on deduction failure due to too short template argument list. We were previously incorrectly using TDK_TooFewArguments to report a template argument list that's too short, but it actually means that the number of arguments in a top-level function call was insufficient. When diagnosing the problem, SemaOverload would (rightly) assert that the failure kind didn't make any sense. llvm-svn: 291064
2017-01-05 10:31:32 +08:00
return NumberOfArgumentsMustMatch
? Sema::TDK_MiscellaneousDeductionFailure
: Sema::TDK_Success;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
[c++17] Implement P0522R0 as written. This allows a template template argument to be specified for a template template parameter whenever the parameter is at least as specialized as the argument (when there's an obvious and correct mapping from uses of the parameter to uses of the argument). For example, a template with more parameters can be passed to a template template parameter with fewer, if those trailing parameters have default arguments. This is disabled by default, despite being a DR resolution, as it's fairly broken in its current state: there are no partial ordering rules to cope with template template parameters that have different parameter lists, meaning that code that attempts to decompose template-ids based on arity can hit unavoidable ambiguity issues. The diagnostics produced on a non-matching argument are also pretty bad right now, but I aim to improve them in a subsequent commit. llvm-svn: 290792
2017-01-01 05:41:23 +08:00
// C++1z [temp.deduct.type]p9:
// During partial ordering, if Ai was originally a pack expansion [and]
// Pi is not a pack expansion, template argument deduction fails.
if (Args[ArgIdx].isPackExpansion())
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 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
// 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
PR19878: If a pack expansion appears within another pack expansion, correctly deduce any packs that are expanded by both expansions. llvm-svn: 209786
2014-05-29 09:12:14 +08:00
// Prepare to deduce the packs within the pattern.
PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern);
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).
ArrayRefize lists of TemplateArguments in template argument deduction. llvm-svn: 290461
2016-12-24 07:46:56 +08:00
for (; hasTemplateArgumentForDeduction(Args, ArgIdx); ++ArgIdx) {
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
PR19878: If a pack expansion appears within another pack expansion, correctly deduce any packs that are expanded by both expansions. llvm-svn: 209786
2014-05-29 09:12:14 +08:00
PackScope.nextPackElement();
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
}
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.
Fix template argument deduction when only some of a parameter pack is a non-deduced context. When a parameter pack has multiple corresponding arguments, and some subset of them are overloaded functions, it's possible that some subset of the parameters are non-deduced contexts. In such a case, keep deducing from the remainder of the arguments, and resolve the incomplete pack against whatever other deductions we've performed for the pack. GCC, MSVC, and ICC give three different bad behaviors for this case; what we do now (and what we did before) don't exactly match any of them, sadly :( I'm getting a core issue opened to specify more precisely how this should be handled. llvm-svn: 290923
2017-01-04 09:48:55 +08:00
if (auto Result = PackScope.finish())
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) {
ArrayRefize lists of TemplateArguments in template argument deduction. llvm-svn: 290461
2016-12-24 07:46:56 +08:00
return DeduceTemplateArguments(S, TemplateParams, ParamList.asArray(),
[c++17] Implement P0522R0 as written. This allows a template template argument to be specified for a template template parameter whenever the parameter is at least as specialized as the argument (when there's an obvious and correct mapping from uses of the parameter to uses of the argument). For example, a template with more parameters can be passed to a template template parameter with fewer, if those trailing parameters have default arguments. This is disabled by default, despite being a DR resolution, as it's fairly broken in its current state: there are no partial ordering rules to cope with template template parameters that have different parameter lists, meaning that code that attempts to decompose template-ids based on arity can hit unavoidable ambiguity issues. The diagnostics produced on a non-matching argument are also pretty bad right now, but I aim to improve them in a subsequent commit. llvm-svn: 290792
2017-01-01 05:41:23 +08:00
ArgList.asArray(), Info, Deduced,
/*NumberOfArgumentsMustMatch*/false);
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
}
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,
DR1495: A partial specialization is ill-formed if it is not (strictly) more specialized than the primary template. (Put another way, if we imagine there were a partial specialization matching the primary template, we should never select it if some other partial specialization also matches.) llvm-svn: 290593
2016-12-27 15:56:27 +08:00
TemplateArgument X,
const TemplateArgument &Y,
bool PackExpansionMatchesPack = false) {
// If we're checking deduced arguments (X) against original arguments (Y),
// we will have flattened packs to non-expansions in X.
if (PackExpansionMatchesPack && X.isPackExpansion() && !Y.isPackExpansion())
X = X.getPackExpansionPattern();
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 (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:
PR21246: DebugInfo: Emit the appropriate type (cv qualifiers, reference-ness, etc) for non-type template parameters Plumb through the full QualType of the TemplateArgument::Declaration, as it's insufficient to only know whether the type is a reference or pointer (that was necessary for mangling, but insufficient for debug info). This shouldn't increase the size of TemplateArgument as TemplateArgument::Integer is still longer by another 32 bits. Several bits of code were testing that the reference-ness of the parameters matched, but this seemed to be insufficient (various other features of the type could've mismatched and wouldn't've been caught) and unnecessary, at least insofar as removing those tests didn't cause anything to fail. (Richard - perchaps you can hypothesize why any of these checks might need to test reference-ness of the parameters (& explain why reference-ness is part of the mangling - I would've figured that for the reference-ness to be different, a prior template argument would have to be different). I'd be happy to add them in/beef them up and add test cases if there's a reason for them) llvm-svn: 219900
2014-10-16 12:21:25 +08:00
return isSameDeclaration(X.getAsDecl(), Y.getAsDecl());
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:
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:
Fix assertion failure when deducing an auto-typed argument against a different-width int. llvm-svn: 290522
2016-12-26 04:21:12 +08:00
return hasSameExtendedValue(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)
DR1495: A partial specialization is ill-formed if it is not (strictly) more specialized than the primary template. (Put another way, if we imagine there were a partial specialization matching the primary template, we should never select it if some other partial specialization also matches.) llvm-svn: 290593
2016-12-27 15:56:27 +08:00
if (!isSameTemplateArg(Context, *XP, *YP, PackExpansionMatchesPack))
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
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.
///
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
Only substitute into type of non-type template parameter once, rather than twice, in finalization of template argument deduction. This is a re-commit of r290310 (reverted in r290329); the bug found by the buildbots was fixed in r290399 (we would sometimes build a deduced template argument with a bogus type). llvm-svn: 290403
2016-12-23 10:00:24 +08:00
/// argument. Can be null if no type sugar is available to add to the
/// type from the 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
///
/// \param Loc The source location to use for the resulting template
/// argument.
P0217R3: Perform semantic checks and initialization for the bindings in a decomposition declaration for arrays, aggregate-like structs, tuple-like types, and (as an extension) for complex and vector types. llvm-svn: 278435
2016-08-12 06:25:46 +08:00
TemplateArgumentLoc
Sema::getTrivialTemplateArgumentLoc(const TemplateArgument &Arg,
QualType NTTPType, SourceLocation Loc) {
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
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:
P0217R3: Perform semantic checks and initialization for the bindings in a decomposition declaration for arrays, aggregate-like structs, tuple-like types, and (as an extension) for complex and vector types. llvm-svn: 278435
2016-08-12 06:25:46 +08:00
return TemplateArgumentLoc(
Arg, 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: {
Only substitute into type of non-type template parameter once, rather than twice, in finalization of template argument deduction. This is a re-commit of r290310 (reverted in r290329); the bug found by the buildbots was fixed in r290399 (we would sometimes build a deduced template argument with a bogus type). llvm-svn: 290403
2016-12-23 10:00:24 +08:00
if (NTTPType.isNull())
NTTPType = Arg.getParamTypeForDecl();
P0217R3: Perform semantic checks and initialization for the bindings in a decomposition declaration for arrays, aggregate-like structs, tuple-like types, and (as an extension) for complex and vector types. llvm-svn: 278435
2016-08-12 06:25:46 +08:00
Expr *E = BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc)
.getAs<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: {
Only substitute into type of non-type template parameter once, rather than twice, in finalization of template argument deduction. This is a re-commit of r290310 (reverted in r290329); the bug found by the buildbots was fixed in r290399 (we would sometimes build a deduced template argument with a bogus type). llvm-svn: 290403
2016-12-23 10:00:24 +08:00
if (NTTPType.isNull())
NTTPType = Arg.getNullPtrType();
P0217R3: Perform semantic checks and initialization for the bindings in a decomposition declaration for arrays, aggregate-like structs, tuple-like types, and (as an extension) for complex and vector types. llvm-svn: 278435
2016-08-12 06:25:46 +08:00
Expr *E = BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc)
.getAs<Expr>();
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 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: {
P0217R3: Perform semantic checks and initialization for the bindings in a decomposition declaration for arrays, aggregate-like structs, tuple-like types, and (as an extension) for complex and vector types. llvm-svn: 278435
2016-08-12 06:25:46 +08:00
Expr *E =
BuildExpressionFromIntegralTemplateArgument(Arg, Loc).getAs<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())
P0217R3: Perform semantic checks and initialization for the bindings in a decomposition declaration for arrays, aggregate-like structs, tuple-like types, and (as an extension) for complex and vector types. llvm-svn: 278435
2016-08-12 06:25:46 +08:00
Builder.MakeTrivial(Context, DTN->getQualifier(), Loc);
Wrap to 80 columns. No behavior change. llvm-svn: 214059
2014-07-28 08:02:09 +08:00
else if (QualifiedTemplateName *QTN =
Template.getAsQualifiedTemplateName())
P0217R3: Perform semantic checks and initialization for the bindings in a decomposition declaration for arrays, aggregate-like structs, tuple-like types, and (as an extension) for complex and vector types. llvm-svn: 278435
2016-08-12 06:25:46 +08:00
Builder.MakeTrivial(Context, QTN->getQualifier(), Loc);
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +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
if (Arg.getKind() == TemplateArgument::Template)
P0217R3: Perform semantic checks and initialization for the bindings in a decomposition declaration for arrays, aggregate-like structs, tuple-like types, and (as an extension) for complex and vector types. llvm-svn: 278435
2016-08-12 06:25:46 +08:00
return TemplateArgumentLoc(Arg, Builder.getWithLocInContext(Context),
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
Loc);
P0217R3: Perform semantic checks and initialization for the bindings in a decomposition declaration for arrays, aggregate-like structs, tuple-like types, and (as an extension) for complex and vector types. llvm-svn: 278435
2016-08-12 06:25:46 +08:00
return TemplateArgumentLoc(Arg, Builder.getWithLocInContext(Context),
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
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,
TemplateDeductionInfo &Info,
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
bool IsDeduced,
Function argument formatting fixes. llvm-svn: 185785
2013-07-08 12:13:06 +08:00
SmallVectorImpl<TemplateArgument> &Output) {
Refactor conversion of deduced template arguments to reduce repetition. llvm-svn: 259687
2016-02-04 04:15:01 +08:00
auto ConvertArg = [&](DeducedTemplateArgument Arg,
unsigned ArgumentPackIndex) {
// 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 =
Only substitute into type of non-type template parameter once, rather than twice, in finalization of template argument deduction. This is a re-commit of r290310 (reverted in r290329); the bug found by the buildbots was fixed in r290399 (we would sometimes build a deduced template argument with a bogus type). llvm-svn: 290403
2016-12-23 10:00:24 +08:00
S.getTrivialTemplateArgumentLoc(Arg, QualType(), Info.getLocation());
Refactor conversion of deduced template arguments to reduce repetition. llvm-svn: 259687
2016-02-04 04:15:01 +08:00
// Check the template argument, converting it as necessary.
return S.CheckTemplateArgument(
Param, ArgLoc, Template, Template->getLocation(),
Template->getSourceRange().getEnd(), ArgumentPackIndex, Output,
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
IsDeduced
Refactor conversion of deduced template arguments to reduce repetition. llvm-svn: 259687
2016-02-04 04:15:01 +08:00
? (Arg.wasDeducedFromArrayBound() ? Sema::CTAK_DeducedFromArrayBound
: Sema::CTAK_Deduced)
: Sema::CTAK_Specified);
};
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;
Added the pack_elements range accessor. Refactoring some for loops to use range-based for loops instead. No functional changes intended. llvm-svn: 213095
2014-07-16 05:32:31 +08:00
for (const auto &P : Arg.pack_elements()) {
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.
Added the pack_elements range accessor. Refactoring some for loops to use range-based for loops instead. No functional changes intended. llvm-svn: 213095
2014-07-16 05:32:31 +08:00
DeducedTemplateArgument InnerArg(P);
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
InnerArg.setDeducedFromArrayBound(Arg.wasDeducedFromArrayBound());
Refactor conversion of deduced template arguments to reduce repetition. llvm-svn: 259687
2016-02-04 04:15:01 +08:00
assert(InnerArg.getKind() != TemplateArgument::Pack &&
"deduced nested pack");
Fix template argument deduction when only some of a parameter pack is a non-deduced context. When a parameter pack has multiple corresponding arguments, and some subset of them are overloaded functions, it's possible that some subset of the parameters are non-deduced contexts. In such a case, keep deducing from the remainder of the arguments, and resolve the incomplete pack against whatever other deductions we've performed for the pack. GCC, MSVC, and ICC give three different bad behaviors for this case; what we do now (and what we did before) don't exactly match any of them, sadly :( I'm getting a core issue opened to specify more precisely how this should be handled. llvm-svn: 290923
2017-01-04 09:48:55 +08:00
if (P.isNull()) {
// We deduced arguments for some elements of this pack, but not for
// all of them. This happens if we get a conditionally-non-deduced
// context in a pack expansion (such as an overload set in one of the
// arguments).
S.Diag(Param->getLocation(),
diag::err_template_arg_deduced_incomplete_pack)
<< Arg << Param;
return true;
}
Refactor conversion of deduced template arguments to reduce repetition. llvm-svn: 259687
2016-02-04 04:15:01 +08:00
if (ConvertArg(InnerArg, 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 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.
Use pop_back_val() instead of both back() and pop_back(). No functionality change intended. llvm-svn: 189112
2013-08-24 00:11:15 +08:00
PackedArgsBuilder.push_back(Output.pop_back_val());
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
Ensure that we substitute into the declaration of a template parameter pack (that is not a pack expansion) during template argument deduction, even if we deduced that the pack would be empty. llvm-svn: 259688
2016-02-04 04:40:30 +08:00
// If the pack is empty, we still need to substitute into the parameter
Only substitute into type of non-type template parameter once, rather than twice, in finalization of template argument deduction. This is a re-commit of r290310 (reverted in r290329); the bug found by the buildbots was fixed in r290399 (we would sometimes build a deduced template argument with a bogus type). llvm-svn: 290403
2016-12-23 10:00:24 +08:00
// itself, in case that substitution fails.
if (PackedArgsBuilder.empty()) {
Ensure that we substitute into the declaration of a template parameter pack (that is not a pack expansion) during template argument deduction, even if we deduced that the pack would be empty. llvm-svn: 259688
2016-02-04 04:40:30 +08:00
LocalInstantiationScope Scope(S);
[AST] Use ArrayRef in more interfaces ArrayRef is a little better than passing around a pointer/length pair. No functional change is intended. llvm-svn: 274475
2016-07-04 05:17:51 +08:00
TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Output);
Only substitute into type of non-type template parameter once, rather than twice, in finalization of template argument deduction. This is a re-commit of r290310 (reverted in r290329); the bug found by the buildbots was fixed in r290399 (we would sometimes build a deduced template argument with a bogus type). llvm-svn: 290403
2016-12-23 10:00:24 +08:00
MultiLevelTemplateArgumentList Args(TemplateArgs);
if (auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
Sema::InstantiatingTemplate Inst(S, Template->getLocation(), Template,
NTTP, Output,
Template->getSourceRange());
Wdocumentation fix llvm-svn: 290547
2016-12-27 02:11:49 +08:00
if (Inst.isInvalid() ||
Only substitute into type of non-type template parameter once, rather than twice, in finalization of template argument deduction. This is a re-commit of r290310 (reverted in r290329); the bug found by the buildbots was fixed in r290399 (we would sometimes build a deduced template argument with a bogus type). llvm-svn: 290403
2016-12-23 10:00:24 +08:00
S.SubstType(NTTP->getType(), Args, NTTP->getLocation(),
NTTP->getDeclName()).isNull())
return true;
} else if (auto *TTP = dyn_cast<TemplateTemplateParmDecl>(Param)) {
Sema::InstantiatingTemplate Inst(S, Template->getLocation(), Template,
TTP, Output,
Template->getSourceRange());
if (Inst.isInvalid() || !S.SubstDecl(TTP, S.CurContext, Args))
return true;
}
// For type parameters, no substitution is ever required.
Ensure that we substitute into the declaration of a template parameter pack (that is not a pack expansion) during template argument deduction, even if we deduced that the pack would be empty. llvm-svn: 259688
2016-02-04 04:40:30 +08:00
}
Refactor conversion of deduced template arguments to reduce repetition. llvm-svn: 259687
2016-02-04 04:15:01 +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.
[AST] ArrayRefize template argument packs. No functionality change intended. llvm-svn: 244026
2015-08-05 17:40:22 +08:00
Output.push_back(
TemplateArgument::CreatePackCopy(S.Context, PackedArgsBuilder));
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
Refactor conversion of deduced template arguments to reduce repetition. llvm-svn: 259687
2016-02-04 04:15:01 +08:00
return ConvertArg(Arg, 0);
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
}
Factor out checking of template arguments after deduction into a separate function. (This change would also allow us to handle default template arguments in partial specializations if the standard ever permits them.) llvm-svn: 290225
2016-12-21 09:10:31 +08:00
// FIXME: This should not be a template, but
// ClassTemplatePartialSpecializationDecl sadly does not derive from
// TemplateDecl.
template<typename TemplateDeclT>
static Sema::TemplateDeductionResult ConvertDeducedTemplateArguments(
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
Sema &S, TemplateDeclT *Template, bool IsDeduced,
Factor out checking of template arguments after deduction into a separate function. (This change would also allow us to handle default template arguments in partial specializations if the standard ever permits them.) llvm-svn: 290225
2016-12-21 09:10:31 +08:00
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
TemplateDeductionInfo &Info, SmallVectorImpl<TemplateArgument> &Builder,
LocalInstantiationScope *CurrentInstantiationScope = nullptr,
Revert r295277 to fix buildbot. llvm-svn: 295281
2017-02-16 12:22:56 +08:00
unsigned NumAlreadyConverted = 0, bool PartialOverloading = false) {
Factor out checking of template arguments after deduction into a separate function. (This change would also allow us to handle default template arguments in partial specializations if the standard ever permits them.) llvm-svn: 290225
2016-12-21 09:10:31 +08:00
TemplateParameterList *TemplateParams = Template->getTemplateParameters();
for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
NamedDecl *Param = TemplateParams->getParam(I);
if (!Deduced[I].isNull()) {
if (I < NumAlreadyConverted) {
// We may have had explicitly-specified template arguments for a
// template parameter pack (that may or may not have been extended
// via additional deduced arguments).
If an explicitly-specified pack might have been extended by template argument deduction, don't forget to check the argument is valid. llvm-svn: 291170
2017-01-06 04:27:28 +08:00
if (Param->isParameterPack() && CurrentInstantiationScope &&
CurrentInstantiationScope->getPartiallySubstitutedPack() == Param) {
// Forget the partially-substituted pack; its substitution is now
// complete.
CurrentInstantiationScope->ResetPartiallySubstitutedPack();
// We still need to check the argument in case it was extended by
// deduction.
} else {
// We have already fully type-checked and converted this
// argument, because it was explicitly-specified. Just record the
// presence of this argument.
Builder.push_back(Deduced[I]);
continue;
Factor out checking of template arguments after deduction into a separate function. (This change would also allow us to handle default template arguments in partial specializations if the standard ever permits them.) llvm-svn: 290225
2016-12-21 09:10:31 +08:00
}
}
If an explicitly-specified pack might have been extended by template argument deduction, don't forget to check the argument is valid. llvm-svn: 291170
2017-01-06 04:27:28 +08:00
// We may have deduced this argument, so it still needs to be
Factor out checking of template arguments after deduction into a separate function. (This change would also allow us to handle default template arguments in partial specializations if the standard ever permits them.) llvm-svn: 290225
2016-12-21 09:10:31 +08:00
// checked and converted.
if (ConvertDeducedTemplateArgument(S, Param, Deduced[I], Template, Info,
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
IsDeduced, Builder)) {
Factor out checking of template arguments after deduction into a separate function. (This change would also allow us to handle default template arguments in partial specializations if the standard ever permits them.) llvm-svn: 290225
2016-12-21 09:10:31 +08:00
Info.Param = makeTemplateParameter(Param);
// FIXME: These template arguments are temporary. Free them!
Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder));
return Sema::TDK_SubstitutionFailure;
}
continue;
}
// C++0x [temp.arg.explicit]p3:
// A trailing template parameter pack (14.5.3) not otherwise deduced will
// be deduced to an empty sequence of template arguments.
// FIXME: Where did the word "trailing" come from?
if (Param->isTemplateParameterPack()) {
// 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;
if (CurrentInstantiationScope &&
CurrentInstantiationScope->getPartiallySubstitutedPack(
&ExplicitArgs, &NumExplicitArgs) == Param) {
Builder.push_back(TemplateArgument(
llvm::makeArrayRef(ExplicitArgs, NumExplicitArgs)));
// Forget the partially-substituted pack; its substitution is now
// complete.
CurrentInstantiationScope->ResetPartiallySubstitutedPack();
} else {
// Go through the motions of checking the empty argument pack against
// the parameter pack.
DeducedTemplateArgument DeducedPack(TemplateArgument::getEmptyPack());
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
if (ConvertDeducedTemplateArgument(S, Param, DeducedPack, Template,
Info, IsDeduced, Builder)) {
Factor out checking of template arguments after deduction into a separate function. (This change would also allow us to handle default template arguments in partial specializations if the standard ever permits them.) llvm-svn: 290225
2016-12-21 09:10:31 +08:00
Info.Param = makeTemplateParameter(Param);
// FIXME: These template arguments are temporary. Free them!
Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder));
return Sema::TDK_SubstitutionFailure;
}
}
continue;
}
// Substitute into the default template argument, if available.
bool HasDefaultArg = false;
TemplateDecl *TD = dyn_cast<TemplateDecl>(Template);
if (!TD) {
Fix assertion failure if we can't deduce a template argument for a variable template partial specialization. In passing, fix the deduction-crash.cpp test to actually run all the tests. Due to a typo, the last third of the file was being skipped by the parser and some of the tests were not actually testing anything as a result. Switch from FileCheck to -verify to make the problem more obvious and prevent this happening again. llvm-svn: 304604
2017-06-03 06:53:06 +08:00
assert(isa<ClassTemplatePartialSpecializationDecl>(Template) ||
isa<VarTemplatePartialSpecializationDecl>(Template));
Factor out checking of template arguments after deduction into a separate function. (This change would also allow us to handle default template arguments in partial specializations if the standard ever permits them.) llvm-svn: 290225
2016-12-21 09:10:31 +08:00
return Sema::TDK_Incomplete;
}
TemplateArgumentLoc DefArg = S.SubstDefaultTemplateArgumentIfAvailable(
TD, TD->getLocation(), TD->getSourceRange().getEnd(), Param, Builder,
HasDefaultArg);
// If there was no default argument, deduction is incomplete.
if (DefArg.getArgument().isNull()) {
Info.Param = makeTemplateParameter(
const_cast<NamedDecl *>(TemplateParams->getParam(I)));
Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder));
Revert r295277 to fix buildbot. llvm-svn: 295281
2017-02-16 12:22:56 +08:00
if (PartialOverloading) break;
Factor out checking of template arguments after deduction into a separate function. (This change would also allow us to handle default template arguments in partial specializations if the standard ever permits them.) llvm-svn: 290225
2016-12-21 09:10:31 +08:00
return HasDefaultArg ? Sema::TDK_SubstitutionFailure
: Sema::TDK_Incomplete;
}
// Check whether we can actually use the default argument.
if (S.CheckTemplateArgument(Param, DefArg, TD, TD->getLocation(),
TD->getSourceRange().getEnd(), 0, Builder,
Sema::CTAK_Specified)) {
Info.Param = makeTemplateParameter(
const_cast<NamedDecl *>(TemplateParams->getParam(I)));
// FIXME: These template arguments are temporary. Free them!
Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder));
return Sema::TDK_SubstitutionFailure;
}
// If we get here, we successfully used the default template argument.
}
return Sema::TDK_Success;
}
Make helpers static. NFC. llvm-svn: 294838
2017-02-11 20:21:17 +08:00
static DeclContext *getAsDeclContextOrEnclosing(Decl *D) {
Factor out duplication between partial ordering for class template partial specializations and variable template partial specializations. llvm-svn: 290497
2016-12-25 00:40:51 +08:00
if (auto *DC = dyn_cast<DeclContext>(D))
return DC;
return D->getDeclContext();
}
template<typename T> struct IsPartialSpecialization {
static constexpr bool value = false;
};
template<>
struct IsPartialSpecialization<ClassTemplatePartialSpecializationDecl> {
static constexpr bool value = true;
};
template<>
struct IsPartialSpecialization<VarTemplatePartialSpecializationDecl> {
static constexpr bool value = true;
};
/// Complete template argument deduction for a partial specialization.
template <typename T>
static typename std::enable_if<IsPartialSpecialization<T>::value,
Sema::TemplateDeductionResult>::type
FinishTemplateArgumentDeduction(
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
Sema &S, T *Partial, bool IsPartialOrdering,
const TemplateArgumentList &TemplateArgs,
Factor out duplication between partial ordering for class template partial specializations and variable template partial specializations. llvm-svn: 290497
2016-12-25 00:40:51 +08:00
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
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.
[NFC, Scoped Enum] Convert Sema::ExpressionEvaluationContext into a scoped Enum - also replace direct equality checks against the ConstantEvaluated enumerator with isConstantEvaluted(), in anticipation of adding finer granularity to the various ConstantEvaluated contexts and reinstating certain restrictions on where lambda expressions can occur in C++17. - update the clang tablegen backend that uses these Enumerators, and add the relevant scope where needed. llvm-svn: 299316
2017-04-02 05:30:49 +08:00
EnterExpressionEvaluationContext Unevaluated(
S, Sema::ExpressionEvaluationContext::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
Factor out duplication between partial ordering for class template partial specializations and variable template partial specializations. llvm-svn: 290497
2016-12-25 00:40:51 +08:00
Sema::ContextRAII SavedContext(S, getAsDeclContextOrEnclosing(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;
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
if (auto Result = ConvertDeducedTemplateArguments(
S, Partial, IsPartialOrdering, Deduced, Info, Builder))
Factor out checking of template arguments after deduction into a separate function. (This change would also allow us to handle default template arguments in partial specializations if the standard ever permits them.) llvm-svn: 290225
2016-12-21 09:10:31 +08:00
return Result;
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
[AST] Use ArrayRef in more interfaces ArrayRef is a little better than passing around a pointer/length pair. No functional change is intended. llvm-svn: 274475
2016-07-04 05:17:51 +08:00
= TemplateArgumentList::CreateCopy(S.Context, Builder);
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
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);
Factor out duplication between partial ordering for class template partial specializations and variable template partial specializations. llvm-svn: 290497
2016-12-25 00:40:51 +08:00
auto *Template = Partial->getSpecializedTemplate();
const ASTTemplateArgumentListInfo *PartialTemplArgInfo =
Partial->getTemplateArgsAsWritten();
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;
Factor out duplication between partial ordering for class template partial specializations and variable template partial specializations. llvm-svn: 290497
2016-12-25 00:40:51 +08:00
Decl *Param = const_cast<NamedDecl *>(
Partial->getTemplateParameters()->getParam(ParamIdx));
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
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;
Factor out duplication between partial ordering for class template partial specializations and variable template partial specializations. llvm-svn: 290497
2016-12-25 00:40:51 +08:00
if (S.CheckTemplateArgumentList(Template, Partial->getLocation(), 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
Factor out duplication between partial ordering for class template partial specializations and variable template partial specializations. llvm-svn: 290497
2016-12-25 00:40:51 +08:00
TemplateParameterList *TemplateParams = Template->getTemplateParameters();
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
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;
}
DR1495: A partial specialization is ill-formed if it is not (strictly) more specialized than the primary template. (Put another way, if we imagine there were a partial specialization matching the primary template, we should never select it if some other partial specialization also matches.) llvm-svn: 290593
2016-12-27 15:56:27 +08:00
/// Complete template argument deduction for a class or variable template,
/// when partial ordering against a partial specialization.
// FIXME: Factor out duplication with partial specialization version above.
Make helpers static. NFC. llvm-svn: 294838
2017-02-11 20:21:17 +08:00
static Sema::TemplateDeductionResult FinishTemplateArgumentDeduction(
DR1495: A partial specialization is ill-formed if it is not (strictly) more specialized than the primary template. (Put another way, if we imagine there were a partial specialization matching the primary template, we should never select it if some other partial specialization also matches.) llvm-svn: 290593
2016-12-27 15:56:27 +08:00
Sema &S, TemplateDecl *Template, bool PartialOrdering,
const TemplateArgumentList &TemplateArgs,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
TemplateDeductionInfo &Info) {
// Unevaluated SFINAE context.
[NFC, Scoped Enum] Convert Sema::ExpressionEvaluationContext into a scoped Enum - also replace direct equality checks against the ConstantEvaluated enumerator with isConstantEvaluted(), in anticipation of adding finer granularity to the various ConstantEvaluated contexts and reinstating certain restrictions on where lambda expressions can occur in C++17. - update the clang tablegen backend that uses these Enumerators, and add the relevant scope where needed. llvm-svn: 299316
2017-04-02 05:30:49 +08:00
EnterExpressionEvaluationContext Unevaluated(
S, Sema::ExpressionEvaluationContext::Unevaluated);
DR1495: A partial specialization is ill-formed if it is not (strictly) more specialized than the primary template. (Put another way, if we imagine there were a partial specialization matching the primary template, we should never select it if some other partial specialization also matches.) llvm-svn: 290593
2016-12-27 15:56:27 +08:00
Sema::SFINAETrap Trap(S);
Sema::ContextRAII SavedContext(S, getAsDeclContextOrEnclosing(Template));
// C++ [temp.deduct.type]p2:
// [...] or if any template argument remains neither deduced nor
// explicitly specified, template argument deduction fails.
SmallVector<TemplateArgument, 4> Builder;
if (auto Result = ConvertDeducedTemplateArguments(
S, Template, /*IsDeduced*/PartialOrdering, Deduced, Info, Builder))
return Result;
// Check that we produced the correct argument list.
TemplateParameterList *TemplateParams = Template->getTemplateParameters();
for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) {
TemplateArgument InstArg = Builder[I];
if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg,
/*PackExpansionMatchesPack*/true)) {
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;
}
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
/// \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.
[NFC, Scoped Enum] Convert Sema::ExpressionEvaluationContext into a scoped Enum - also replace direct equality checks against the ConstantEvaluated enumerator with isConstantEvaluted(), in anticipation of adding finer granularity to the various ConstantEvaluated contexts and reinstating certain restrictions on where lambda expressions can occur in C++17. - update the clang tablegen backend that uses these Enumerators, and add the relevant scope where needed. llvm-svn: 299316
2017-04-02 05:30:49 +08:00
EnterExpressionEvaluationContext Unevaluated(
*this, Sema::ExpressionEvaluationContext::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());
Use the appropriate SourceLocation for the template backtrace when doing template argument deduction. llvm-svn: 198995
2014-01-11 10:37:12 +08:00
InstantiatingTemplate Inst(*this, Info.getLocation(), Partial, DeducedArgs,
Info);
Make InstantiatingTemplate depth checks clearer The bool conversion operator on InstantiatingTemplate never added value and only served to obfuscate the template instantiation routines. This replaces the conversion and its callers with an explicit isInvalid() function to make it clear what's going on at a glance. llvm-svn: 192177
2013-10-08 16:09:04 +08:00
if (Inst.isInvalid())
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 TDK_InstantiationDepth;
if (Trap.hasErrorOccurred())
return Sema::TDK_SubstitutionFailure;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
return ::FinishTemplateArgumentDeduction(
*this, Partial, /*PartialOrdering=*/false, TemplateArgs, 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
/// \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].
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.
[NFC, Scoped Enum] Convert Sema::ExpressionEvaluationContext into a scoped Enum - also replace direct equality checks against the ConstantEvaluated enumerator with isConstantEvaluted(), in anticipation of adding finer granularity to the various ConstantEvaluated contexts and reinstating certain restrictions on where lambda expressions can occur in C++17. - update the clang tablegen backend that uses these Enumerators, and add the relevant scope where needed. llvm-svn: 299316
2017-04-02 05:30:49 +08:00
EnterExpressionEvaluationContext Unevaluated(
*this, Sema::ExpressionEvaluationContext::Unevaluated);
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
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());
Use the appropriate SourceLocation for the template backtrace when doing template argument deduction. llvm-svn: 198995
2014-01-11 10:37:12 +08:00
InstantiatingTemplate Inst(*this, Info.getLocation(), Partial, DeducedArgs,
Info);
Make InstantiatingTemplate depth checks clearer The bool conversion operator on InstantiatingTemplate never added value and only served to obfuscate the template instantiation routines. This replaces the conversion and its callers with an explicit isInvalid() function to make it clear what's going on at a glance. llvm-svn: 192177
2013-10-08 16:09:04 +08:00
if (Inst.isInvalid())
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
return TDK_InstantiationDepth;
if (Trap.hasErrorOccurred())
return Sema::TDK_SubstitutionFailure;
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
return ::FinishTemplateArgumentDeduction(
*this, Partial, /*PartialOrdering=*/false, TemplateArgs, Deduced, Info);
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
}
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>())
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
return Spec->getTemplateName().getAsTemplateDecl() != nullptr;
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.
Use more ArrayRefs No functional change is intended, just a small refactoring. llvm-svn: 273647
2016-06-24 12:05:48 +08:00
for (auto P : Function->parameters())
[C++11] Replacing FunctionDecl iterators param_begin() and param_end() with iterator_range params(). Updating all of the usages of the iterators with range-based for loops. llvm-svn: 203248
2014-03-07 23:12:56 +08:00
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.
[NFC, Scoped Enum] Convert Sema::ExpressionEvaluationContext into a scoped Enum - also replace direct equality checks against the ConstantEvaluated enumerator with isConstantEvaluted(), in anticipation of adding finer granularity to the various ConstantEvaluated contexts and reinstating certain restrictions on where lambda expressions can occur in C++17. - update the clang tablegen backend that uses these Enumerators, and add the relevant scope where needed. llvm-svn: 299316
2017-04-02 05:30:49 +08:00
EnterExpressionEvaluationContext Unevaluated(
*this, Sema::ExpressionEvaluationContext::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.
Implement DR1388 (wg21.link/cwg1388). This issue clarifies how deduction proceeds past a non-trailing function parameter pack. Essentially, the pack itself is skipped and consumes no arguments (except for those implied by an explicitly-specified template arguments), and nothing is deduced from it. As a small fix to the standard's rule, we do not allow subsequent deduction to change the length of the function parameter pack (by preventing extension of the explicitly-specified pack if present, and otherwise deducing all contained packs to empty packs). llvm-svn: 291425
2017-01-09 15:14:40 +08:00
SmallVector<TemplateArgument, 4> DeducedArgs;
Rename ActiveTemplateInstantiation to CodeSynthesisContext in preparation for using it for other kinds of context (where we currently produce context notes in a highly ad-hoc manner). llvm-svn: 295919
2017-02-23 09:43:54 +08:00
InstantiatingTemplate Inst(
*this, Info.getLocation(), FunctionTemplate, DeducedArgs,
CodeSynthesisContext::ExplicitTemplateArgumentSubstitution, Info);
Make InstantiatingTemplate depth checks clearer The bool conversion operator on InstantiatingTemplate never added value and only served to obfuscate the template instantiation routines. This replaces the conversion and its callers with an explicit isInvalid() function to make it clear what's going on at a glance. llvm-svn: 192177
2013-10-08 16:09:04 +08:00
if (Inst.isInvalid())
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_InstantiationDepth;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
PR9551: Implement DR1004 (http://wg21.link/cwg1004). This rule permits the injected-class-name of a class template to be used as both a template type argument and a template template argument, with no extra syntax required to disambiguate. llvm-svn: 292426
2017-01-19 03:19:22 +08:00
if (CheckTemplateArgumentList(FunctionTemplate, SourceLocation(),
ExplicitTemplateArgs, true, Builder, false) ||
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
[AST] Use ArrayRef in more interfaces ArrayRef is a little better than passing around a pointer/length pair. No functional change is intended. llvm-svn: 274475
2016-07-04 05:17:51 +08:00
= TemplateArgumentList::CreateCopy(Context, Builder);
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?");
PR22117: Fix a case where we would get confused about which function parameter we're instantiating, if there's a ParmVarDecl within a FunctionDecl context that is not a parameter of that function. Add some asserts to catch this kind of issue more generally, and fix another bug exposed by those asserts where we were missing a local instantiation scope around substitution of explicitly-specified template arguments. llvm-svn: 225490
2015-01-09 09:19:56 +08:00
// Isolate our substituted parameters from our caller.
LocalInstantiationScope InstScope(*this, /*MergeWithOuterScope*/true);
Fix the template instantiation of ExtParameterInfos; tests to follow. llvm-svn: 262289
2016-03-01 10:09:25 +08:00
ExtParameterInfoBuilder ExtParamInfos;
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()) {
Use more ArrayRefs No functional change is intended, just a small refactoring. llvm-svn: 273647
2016-06-24 12:05:48 +08:00
if (SubstParmTypes(Function->getLocation(), Function->parameters(),
Fix the template instantiation of ExtParameterInfos; tests to follow. llvm-svn: 262289
2016-03-01 10:09:25 +08:00
Proto->getExtParameterInfosOrNull(),
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
MultiLevelTemplateArgumentList(*ExplicitArgumentList),
Fix the template instantiation of ExtParameterInfos; tests to follow. llvm-svn: 262289
2016-03-01 10:09:25 +08:00
ParamTypes, /*params*/ nullptr, ExtParamInfos))
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
return TDK_SubstitutionFailure;
}
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
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:
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
// If a declaration declares a member function or member function
// template of a class X, the expression this is a prvalue of 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
// "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
// and the end of the function-definition, member-declarator, or
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
// declarator.
unsigned ThisTypeQuals = 0;
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
CXXRecordDecl *ThisContext = nullptr;
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 (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) {
ThisContext = Method->getParent();
ThisTypeQuals = Method->getTypeQualifiers();
}
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
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
CXXThisScopeRAII ThisScope(*this, ThisContext, ThisTypeQuals,
s/CPlusPlus0x/CPlusPlus11/g llvm-svn: 171367
2013-01-02 19:42:31 +08:00
getLangOpts().CPlusPlus11);
Rename getResultType() on function and method declarations to getReturnType() A return type is the declared or deduced part of the function type specified in the declaration. A result type is the (potentially adjusted) type of the value of an expression that calls the function. Rule of thumb: * Declarations have return types and parameters. * Expressions have result types and arguments. llvm-svn: 200082
2014-01-26 00:55:45 +08:00
ResultType =
SubstType(Proto->getReturnType(),
MultiLevelTemplateArgumentList(*ExplicitArgumentList),
Function->getTypeSpecStartLoc(), Function->getDeclName());
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 (ResultType.isNull() || Trap.hasErrorOccurred())
return TDK_SubstitutionFailure;
}
Fix the template instantiation of ExtParameterInfos; tests to follow. llvm-svn: 262289
2016-03-01 10:09:25 +08:00
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() &&
Use more ArrayRefs No functional change is intended, just a small refactoring. llvm-svn: 273647
2016-06-24 12:05:48 +08:00
SubstParmTypes(Function->getLocation(), Function->parameters(),
Fix the template instantiation of ExtParameterInfos; tests to follow. llvm-svn: 262289
2016-03-01 10:09:25 +08:00
Proto->getExtParameterInfosOrNull(),
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
MultiLevelTemplateArgumentList(*ExplicitArgumentList),
Fix the template instantiation of ExtParameterInfos; tests to follow. llvm-svn: 262289
2016-03-01 10:09:25 +08:00
ParamTypes, /*params*/ nullptr, ExtParamInfos))
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
return TDK_SubstitutionFailure;
if (FunctionType) {
Fix the template instantiation of ExtParameterInfos; tests to follow. llvm-svn: 262289
2016-03-01 10:09:25 +08:00
auto EPI = Proto->getExtProtoInfo();
EPI.ExtParameterInfos = ExtParamInfos.getPointerOrNull(ParamTypes.size());
[c++1z] Support deducing B in noexcept(B). This is not required by the standard (yet), but there seems to be reasonable support for this being a defect according to CWG discussion, and libstdc++ 7.1 relies on it working. llvm-svn: 304946
2017-06-08 05:46:22 +08:00
// In C++1z onwards, exception specifications are part of the function type,
// so substitution into the type must also substitute into the exception
// specification.
SmallVector<QualType, 4> ExceptionStorage;
if (getLangOpts().CPlusPlus1z &&
SubstExceptionSpec(
Function->getLocation(), EPI.ExceptionSpec, ExceptionStorage,
MultiLevelTemplateArgumentList(*ExplicitArgumentList)))
return TDK_SubstitutionFailure;
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(),
Fix the template instantiation of ExtParameterInfos; tests to follow. llvm-svn: 262289
2016-03-01 10:09:25 +08:00
EPI);
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.
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
static bool
CheckOriginalCallArgDeduction(Sema &S, Sema::OriginalCallArg OriginalArg,
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
QualType DeducedA) {
ASTContext &Context = S.Context;
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
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
QualType A = OriginalArg.OriginalArgType;
QualType OriginalParamType = OriginalArg.OriginalParamType;
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
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
// Check for type equality (top-level cv-qualifiers are ignored).
if (Context.hasSameUnqualifiedType(A, DeducedA))
return false;
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
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
// 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();
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
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
// C++ [temp.deduct.call]p4:
// [...] However, there are three cases that allow a difference:
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +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
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
// the transformed A.
if (const ReferenceType *OriginalParamRef
= OriginalParamType->getAs<ReferenceType>()) {
// We don't want to keep the reference around any more.
OriginalParamType = OriginalParamRef->getPointeeType();
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
[c++1z] P0012R1: Implement a few remaining pieces: downgrade diagnostic for mismatched dynamic exception specifications in expressions from an error to a warning, since this is no longer ill-formed in C++1z. Allow reference binding of a reference-to-non-noexcept function to a noexcept function lvalue. As defect resolutions, also allow a conditional between noexcept and non-noexcept function lvalues to produce a non-noexcept function lvalue (rather than decaying to a function pointer), and allow function template argument deduction to deduce a reference to non-noexcept function when binding to a noexcept function type. llvm-svn: 284905
2016-10-22 09:32:19 +08:00
// FIXME: Resolve core issue (no number yet): if the original P is a
// reference type and the transformed A is function type "noexcept F",
// the deduced A can be F.
QualType Tmp;
if (A->isFunctionType() && S.IsFunctionConversion(A, DeducedA, Tmp))
return false;
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
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
Objective-C++ ARC: Improve the conversion to a const __unsafe_unretained reference. Under ARC++, a reference to a const Objective-C pointer is implicitly treated as __unsafe_unretained, and can be initialized with (e.g.) a __strong lvalue. Make sure this behavior does not break template argument deduction and (related) that partial ordering still prefers a 'T* const&' template over a 'T const&' template when this case kicks in. Fixes <rdar://problem/14467941>. llvm-svn: 194239
2013-11-08 10:04:24 +08:00
// Under Objective-C++ ARC, the deduced type may have implicitly
// been given strong or (when dealing with a const reference)
// unsafe_unretained lifetime. If so, update the original
// qualifiers to include this lifetime.
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
if (S.getLangOpts().ObjCAutoRefCount &&
Objective-C++ ARC: Improve the conversion to a const __unsafe_unretained reference. Under ARC++, a reference to a const Objective-C pointer is implicitly treated as __unsafe_unretained, and can be initialized with (e.g.) a __strong lvalue. Make sure this behavior does not break template argument deduction and (related) that partial ordering still prefers a 'T* const&' template over a 'T const&' template when this case kicks in. Fixes <rdar://problem/14467941>. llvm-svn: 194239
2013-11-08 10:04:24 +08:00
((DeducedAQuals.getObjCLifetime() == Qualifiers::OCL_Strong &&
AQuals.getObjCLifetime() == Qualifiers::OCL_None) ||
(DeducedAQuals.hasConst() &&
DeducedAQuals.getObjCLifetime() == Qualifiers::OCL_ExplicitNone))) {
AQuals.setObjCLifetime(DeducedAQuals.getObjCLifetime());
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
}
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;
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
} else {
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
// 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);
}
}
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
// - The transformed A can be another pointer or pointer to member
P0012R1: Make exception specifications be part of the type system. This implements the bulk of the change (modifying the type system to include exception specifications), but not all the details just yet. llvm-svn: 284337
2016-10-17 01:54:23 +08:00
// type that can be converted to the deduced A via a function pointer
// conversion and/or 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
//
[c++1z] P0012R1: Implement a few remaining pieces: downgrade diagnostic for mismatched dynamic exception specifications in expressions from an error to a warning, since this is no longer ill-formed in C++1z. Allow reference binding of a reference-to-non-noexcept function to a noexcept function lvalue. As defect resolutions, also allow a conditional between noexcept and non-noexcept function lvalues to produce a non-noexcept function lvalue (rather than decaying to a function pointer), and allow function template argument deduction to deduce a reference to non-noexcept function when binding to a noexcept function type. llvm-svn: 284905
2016-10-22 09:32:19 +08:00
// Also allow conversions which merely strip __attribute__((noreturn)) from
// function types (recursively).
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) ||
P0012R1: Make exception specifications be part of the type system. This implements the bulk of the change (modifying the type system to include exception specifications), but not all the details just yet. llvm-svn: 284337
2016-10-17 01:54:23 +08:00
S.IsFunctionConversion(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;
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
// - If P is a class and P has the form simple-template-id, then the
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
// transformed A can be a derived class of the deduced A. [...]
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
// [...] Likewise, if P is a pointer to a class of the form
// simple-template-id, the transformed A can be a pointer to a
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
// 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();
}
}
}
}
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
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 (Context.hasSameUnqualifiedType(A, DeducedA))
return false;
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
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->isRecordType() && isSimpleTemplateIdType(OriginalParamType) &&
Wire a SourceLocation into IsDerivedFrom and move the RequireCompleteType call for the derived class into it. This is mostly just a cleanup, but could in principle be a bugfix if there is some codepath that reaches here and didn't previously require a complete type (I couldn't find any such codepath, though). llvm-svn: 256037
2015-12-19 05:45:41 +08:00
S.IsDerivedFrom(SourceLocation(), A, DeducedA))
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;
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
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 true;
}
Add missing "original call argument has same type as deduced parameter type" check for deductions from elements of a braced-init-list. llvm-svn: 291190
2017-01-06 07:02:44 +08:00
/// Find the pack index for a particular parameter index in an instantiation of
/// a function template with specific arguments.
///
/// \return The pack index for whichever pack produced this parameter, or -1
/// if this was not produced by a parameter. Intended to be used as the
/// ArgumentPackSubstitutionIndex for further substitutions.
// FIXME: We should track this in OriginalCallArgs so we don't need to
// reconstruct it here.
static unsigned getPackIndexForParam(Sema &S,
FunctionTemplateDecl *FunctionTemplate,
const MultiLevelTemplateArgumentList &Args,
unsigned ParamIdx) {
unsigned Idx = 0;
for (auto *PD : FunctionTemplate->getTemplatedDecl()->parameters()) {
if (PD->isParameterPack()) {
unsigned NumExpansions =
S.getNumArgumentsInExpansion(PD->getType(), Args).getValueOr(1);
if (Idx + NumExpansions > ParamIdx)
return ParamIdx - Idx;
Idx += NumExpansions;
} else {
if (Idx == ParamIdx)
return -1; // Not a pack expansion
++Idx;
}
}
llvm_unreachable("parameter index would not be produced from template");
}
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.
Implement C++ DR1391 (wg21.link/cwg1391) Check for implicit conversion sequences for non-dependent function template parameters between deduction and substitution. The idea is to accept as many cases as possible, on the basis that substitution failure outside the immediate context is much more common during substitution than during implicit conversion sequence formation. This re-commits r290808, reverted in r290811 and r291412, with a couple of fixes for handling of explicitly-specified non-trailing template argument packs. llvm-svn: 291427
2017-01-09 16:01:21 +08:00
Sema::TemplateDeductionResult Sema::FinishTemplateArgumentDeduction(
FunctionTemplateDecl *FunctionTemplate,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
unsigned NumExplicitlySpecified, FunctionDecl *&Specialization,
TemplateDeductionInfo &Info,
SmallVectorImpl<OriginalCallArg> const *OriginalCallArgs,
bool PartialOverloading, llvm::function_ref<bool()> CheckNonDependent) {
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.
[NFC, Scoped Enum] Convert Sema::ExpressionEvaluationContext into a scoped Enum - also replace direct equality checks against the ConstantEvaluated enumerator with isConstantEvaluted(), in anticipation of adding finer granularity to the various ConstantEvaluated contexts and reinstating certain restrictions on where lambda expressions can occur in C++17. - update the clang tablegen backend that uses these Enumerators, and add the relevant scope where needed. llvm-svn: 299316
2017-04-02 05:30:49 +08:00
EnterExpressionEvaluationContext Unevaluated(
*this, Sema::ExpressionEvaluationContext::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());
Rename ActiveTemplateInstantiation to CodeSynthesisContext in preparation for using it for other kinds of context (where we currently produce context notes in a highly ad-hoc manner). llvm-svn: 295919
2017-02-23 09:43:54 +08:00
InstantiatingTemplate Inst(
*this, Info.getLocation(), FunctionTemplate, DeducedArgs,
CodeSynthesisContext::DeducedTemplateArgumentSubstitution, Info);
Make InstantiatingTemplate depth checks clearer The bool conversion operator on InstantiatingTemplate never added value and only served to obfuscate the template instantiation routines. This replaces the conversion and its callers with an explicit isInvalid() function to make it clear what's going on at a glance. llvm-svn: 192177
2013-10-08 16:09:04 +08:00
if (Inst.isInvalid())
Implement support for default template arguments of function templates. llvm-svn: 89874
2009-11-26 02:55:14 +08:00
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;
Factor out checking of template arguments after deduction into a separate function. (This change would also allow us to handle default template arguments in partial specializations if the standard ever permits them.) llvm-svn: 290225
2016-12-21 09:10:31 +08:00
if (auto Result = ConvertDeducedTemplateArguments(
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
*this, FunctionTemplate, /*IsDeduced*/true, Deduced, Info, Builder,
Factor out checking of template arguments after deduction into a separate function. (This change would also allow us to handle default template arguments in partial specializations if the standard ever permits them.) llvm-svn: 290225
2016-12-21 09:10:31 +08:00
CurrentInstantiationScope, NumExplicitlySpecified,
PartialOverloading))
return Result;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement C++ DR1391 (wg21.link/cwg1391) Check for implicit conversion sequences for non-dependent function template parameters between deduction and substitution. The idea is to accept as many cases as possible, on the basis that substitution failure outside the immediate context is much more common during substitution than during implicit conversion sequence formation. This re-commits r290808, reverted in r290811 and r291412, with a couple of fixes for handling of explicitly-specified non-trailing template argument packs. llvm-svn: 291427
2017-01-09 16:01:21 +08:00
// C++ [temp.deduct.call]p10: [DR1391]
// If deduction succeeds for all parameters that contain
// template-parameters that participate in template argument deduction,
// and all template arguments are explicitly specified, deduced, or
// obtained from default template arguments, remaining parameters are then
// compared with the corresponding arguments. For each remaining parameter
// P with a type that was non-dependent before substitution of any
// explicitly-specified template arguments, if the corresponding argument
// A cannot be implicitly converted to P, deduction fails.
if (CheckNonDependent())
return TDK_NonDependentConversionFailure;
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
[AST] Use ArrayRef in more interfaces ArrayRef is a little better than passing around a pointer/length pair. No functional change is intended. llvm-svn: 274475
2016-07-04 05:17:51 +08:00
= TemplateArgumentList::CreateCopy(Context, Builder);
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();
Add missing "original call argument has same type as deduced parameter type" check for deductions from elements of a braced-init-list. llvm-svn: 291190
2017-01-06 07:02:44 +08:00
MultiLevelTemplateArgumentList SubstArgs(*DeducedArgumentList);
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>(
Add missing "original call argument has same type as deduced parameter type" check for deductions from elements of a braced-init-list. llvm-svn: 291190
2017-01-06 07:02:44 +08:00
SubstDecl(FunctionTemplate->getTemplatedDecl(), Owner, SubstArgs));
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
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
// values that will make the deduced A identical to A (after the type A
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
// is transformed as described above). [...]
Add missing "original call argument has same type as deduced parameter type" check for deductions from elements of a braced-init-list. llvm-svn: 291190
2017-01-06 07:02:44 +08:00
llvm::SmallDenseMap<std::pair<unsigned, QualType>, QualType> DeducedATypes;
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
for (unsigned I = 0, N = OriginalCallArgs->size(); I != N; ++I) {
OriginalCallArg OriginalArg = (*OriginalCallArgs)[I];
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
Add missing "original call argument has same type as deduced parameter type" check for deductions from elements of a braced-init-list. llvm-svn: 291190
2017-01-06 07:02:44 +08:00
auto ParamIdx = OriginalArg.ArgIdx;
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 (ParamIdx >= Specialization->getNumParams())
Add missing "original call argument has same type as deduced parameter type" check for deductions from elements of a braced-init-list. llvm-svn: 291190
2017-01-06 07:02:44 +08:00
// FIXME: This presumably means a pack ended up smaller than we
// expected while deducing. Should this not result in deduction
// failure? Can it even happen?
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
continue;
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
Add missing "original call argument has same type as deduced parameter type" check for deductions from elements of a braced-init-list. llvm-svn: 291190
2017-01-06 07:02:44 +08:00
QualType DeducedA;
if (!OriginalArg.DecomposedParam) {
// P is one of the function parameters, just look up its substituted
// type.
DeducedA = Specialization->getParamDecl(ParamIdx)->getType();
} else {
// P is a decomposed element of a parameter corresponding to a
// braced-init-list argument. Substitute back into P to find the
// deduced A.
QualType &CacheEntry =
DeducedATypes[{ParamIdx, OriginalArg.OriginalParamType}];
if (CacheEntry.isNull()) {
ArgumentPackSubstitutionIndexRAII PackIndex(
*this, getPackIndexForParam(*this, FunctionTemplate, SubstArgs,
ParamIdx));
CacheEntry =
SubstType(OriginalArg.OriginalParamType, SubstArgs,
Specialization->getTypeSpecStartLoc(),
Specialization->getDeclName());
}
DeducedA = CacheEntry;
}
Improve diagnostic for the case where a function template candidate is rejected by overload resolution because deduction succeeds, but the substituted parameter type for some parameter (with deduced type) doesn't exactly match the corresponding adjusted argument type. llvm-svn: 256657
2015-12-31 10:02:54 +08:00
if (CheckOriginalCallArgDeduction(*this, OriginalArg, DeducedA)) {
Info.FirstArg = TemplateArgument(DeducedA);
Info.SecondArg = TemplateArgument(OriginalArg.OriginalArgType);
Info.CallArgIndex = OriginalArg.ArgIdx;
Add missing "original call argument has same type as deduced parameter type" check for deductions from elements of a braced-init-list. llvm-svn: 291190
2017-01-06 07:02:44 +08:00
return OriginalArg.DecomposedParam ? TDK_DeducedMismatchNested
: TDK_DeducedMismatch;
Improve diagnostic for the case where a function template candidate is rejected by overload resolution because deduction succeeds, but the substituted parameter type for some parameter (with deduced type) doesn't exactly match the corresponding adjusted argument type. llvm-svn: 256657
2015-12-31 10:02:54 +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
}
}
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +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.
C++1y is now C++14! Changes diagnostic options, language standard options, diagnostic identifiers, diagnostic wording to use c++14 instead of c++1y. It also modifies related test cases to use the updated diagnostic wording. llvm-svn: 215982
2014-08-19 23:55:55 +08:00
if (S.getLangOpts().CPlusPlus14 && Fn->getReturnType()->isUndeducedType() &&
Rename getResultType() on function and method declarations to getReturnType() A return type is the declared or deduced part of the function type specified in the declaration. A result type is the (potentially adjusted) type of the value of an expression that calls the function. Rule of thumb: * Declarations have return types and parameters. * Expressions have result types and arguments. llvm-svn: 200082
2014-01-26 00:55:45 +08:00
S.DeduceReturnType(Fn, R.Expression->getExprLoc(), /*Diagnose*/ 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
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
[Sema] Make type deduction work with some overloadable functions Some functions can't have their address taken. If we encounter an overload set where only one of the candidates can have its address taken, we should automatically select that candidate's type in type deduction. Differential Revision: http://reviews.llvm.org/D15591 llvm-svn: 263888
2016-03-20 05:51:45 +08:00
DeclAccessPair DAP;
if (FunctionDecl *Viable =
S.resolveAddressOfOnlyViableOverloadCandidate(Arg, DAP))
return GetTypeOfFunction(S, R, Viable);
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();
}
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +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
// Gather the explicit template arguments, if any.
TemplateArgumentListInfo ExplicitTemplateArgs;
if (Ovl->hasExplicitTemplateArgs())
[TrailingObjects] Convert ASTTemplateKWAndArgsInfo and ASTTemplateArgumentListInfo. Doing so required separating them so that the former doesn't inherit from the latter anymore. Investigating that, it became clear that the inheritance wasn't actually providing real value in any case. So also: - Remove a bunch of redundant functions (getExplicitTemplateArgs, getOptionalExplicitTemplateArgs) on various Expr subclasses which depended on the inheritance relationship. - Switched external callers to use pre-existing accessors that return the data they're actually interested in (getTemplateArgs, getNumTemplateArgs, etc). - Switched internal callers to use pre-existing getTemplateKWAndArgsInfo. llvm-svn: 256359
2015-12-24 10:59:37 +08:00
Ovl->copyTemplateArgumentsInto(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();
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
// Otherwise, see if we can resolve a function type
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
FunctionDecl *Specialization = nullptr;
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;
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +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
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.
[c++1z] Synthesize implicit deduction guides from constructors on demand. Rank such guides below explicit ones, and ensure that references to the class's template parameters are not treated as forwarding references. We make a few tweaks to the wording in the current standard: 1) The constructor parameter list is copied faithfully to the deduction guide, without losing default arguments or a varargs ellipsis (which the standard wording loses by omission). 2) If the class template declares no constructors, we add a T() -> T<...> guide (which will only ever work if T has default arguments for all non-pack template parameters). 3) If the class template declares nothing that looks like a copy or move constructor, we add a T(T<...>) -> T<...> guide. #2 and #3 follow from the "pretend we had a class type with these constructors" philosophy for deduction guides. llvm-svn: 295007
2017-02-14 08:25:28 +08:00
static bool AdjustFunctionParmAndArgTypesForDeduction(
Sema &S, TemplateParameterList *TemplateParams, unsigned FirstInnerIndex,
QualType &ParamType, QualType &ArgType, Expr *Arg, unsigned &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
// 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();
reverting due to build bot failure llvm-svn: 225684
2015-01-13 04:13:20 +08:00
restore fix for 18645, buildbot apparently gave a false positive. Correct logic concerning 'T &&' deduction against lvalues. llvm-svn: 226278
2015-01-16 23:20:14 +08:00
// [...] If P is a reference type, the type referred to by P is
// used for type deduction.
const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>();
if (ParamRefType)
ParamType = ParamRefType->getPointeeType();
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
restore fix for 18645, buildbot apparently gave a false positive. Correct logic concerning 'T &&' deduction against lvalues. llvm-svn: 226278
2015-01-16 23:20:14 +08:00
// Overload sets usually make this parameter an undeduced context,
// but there are sometimes special circumstances. Typically
// involving a template-id-expr.
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 (ArgType == S.Context.OverloadTy) {
ArgType = ResolveOverloadForDeduction(S, TemplateParams,
Arg, ParamType,
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
ParamRefType != nullptr);
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 (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) {
restore fix for 18645, buildbot apparently gave a false positive. Correct logic concerning 'T &&' deduction against lvalues. llvm-svn: 226278
2015-01-16 23:20:14 +08:00
// If the argument has incomplete array type, try to complete its type.
Split RequireCompleteType into a function that actually requires that the type is complete (with an error produced if not) and a function that merely queries whether the type is complete. Either way we'll trigger instantiation if necessary, but only the former will diagnose and recover from missing module imports. The intent of this change is to prevent a class of bugs where code would call RequireCompleteType(..., 0) and then ignore the result. With modules, we must check the return value and use it to determine whether the definition of the type is visible. This also fixes a debug info quality issue: calls to isCompleteType do not trigger the emission of debug information for a type in limited-debug-info mode. This allows us to avoid emitting debug information for type definitions in more cases where we believe it is safe to do so. llvm-svn: 256049
2015-12-19 06:40:25 +08:00
if (ArgType->isIncompleteArrayType()) {
S.completeExprArrayBound(Arg);
restore fix for 18645, buildbot apparently gave a false positive. Correct logic concerning 'T &&' deduction against lvalues. llvm-svn: 226278
2015-01-16 23:20:14 +08:00
ArgType = Arg->getType();
Split RequireCompleteType into a function that actually requires that the type is complete (with an error produced if not) and a function that merely queries whether the type is complete. Either way we'll trigger instantiation if necessary, but only the former will diagnose and recover from missing module imports. The intent of this change is to prevent a class of bugs where code would call RequireCompleteType(..., 0) and then ignore the result. With modules, we must check the return value and use it to determine whether the definition of the type is visible. This also fixes a debug info quality issue: calls to isCompleteType do not trigger the emission of debug information for a type in limited-debug-info mode. This allows us to avoid emitting debug information for type definitions in more cases where we believe it is safe to do so. llvm-svn: 256049
2015-12-19 06:40:25 +08:00
}
restore fix for 18645, buildbot apparently gave a false positive. Correct logic concerning 'T &&' deduction against lvalues. llvm-svn: 226278
2015-01-16 23:20:14 +08:00
[c++1z] Synthesize implicit deduction guides from constructors on demand. Rank such guides below explicit ones, and ensure that references to the class's template parameters are not treated as forwarding references. We make a few tweaks to the wording in the current standard: 1) The constructor parameter list is copied faithfully to the deduction guide, without losing default arguments or a varargs ellipsis (which the standard wording loses by omission). 2) If the class template declares no constructors, we add a T() -> T<...> guide (which will only ever work if T has default arguments for all non-pack template parameters). 3) If the class template declares nothing that looks like a copy or move constructor, we add a T(T<...>) -> T<...> guide. #2 and #3 follow from the "pretend we had a class type with these constructors" philosophy for deduction guides. llvm-svn: 295007
2017-02-14 08:25:28 +08:00
// C++1z [temp.deduct.call]p3:
// If P is a forwarding reference and the argument is an lvalue, the type
// "lvalue reference to A" is used in place of A for type deduction.
if (isForwardingReference(QualType(ParamRefType, 0), FirstInnerIndex) &&
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
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;
}
Revert r295277 to fix buildbot. llvm-svn: 295281
2017-02-16 12:22:56 +08:00
static bool
hasDeducibleTemplateParameters(Sema &S, FunctionTemplateDecl *FunctionTemplate,
QualType T);
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
Factor out more common logic in template argument deduction from function call arguments. No functionality change intended. llvm-svn: 291074
2017-01-05 12:08:31 +08:00
static Sema::TemplateDeductionResult DeduceTemplateArgumentsFromCallArgument(
[c++1z] Synthesize implicit deduction guides from constructors on demand. Rank such guides below explicit ones, and ensure that references to the class's template parameters are not treated as forwarding references. We make a few tweaks to the wording in the current standard: 1) The constructor parameter list is copied faithfully to the deduction guide, without losing default arguments or a varargs ellipsis (which the standard wording loses by omission). 2) If the class template declares no constructors, we add a T() -> T<...> guide (which will only ever work if T has default arguments for all non-pack template parameters). 3) If the class template declares nothing that looks like a copy or move constructor, we add a T(T<...>) -> T<...> guide. #2 and #3 follow from the "pretend we had a class type with these constructors" philosophy for deduction guides. llvm-svn: 295007
2017-02-14 08:25:28 +08:00
Sema &S, TemplateParameterList *TemplateParams, unsigned FirstInnerIndex,
QualType ParamType, Expr *Arg, TemplateDeductionInfo &Info,
Factor out more common logic in template argument deduction from function call arguments. No functionality change intended. llvm-svn: 291074
2017-01-05 12:08:31 +08:00
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
SmallVectorImpl<Sema::OriginalCallArg> &OriginalCallArgs,
Add missing "original call argument has same type as deduced parameter type" check for deductions from elements of a braced-init-list. llvm-svn: 291190
2017-01-06 07:02:44 +08:00
bool DecomposedParam, unsigned ArgIdx, unsigned TDF);
Consolidate and unify initializer list deduction Summary: This patch reduces duplication in the template argument deduction code for handling deduction from initializer lists in a function call. This extends the fix for PR12119 to also apply to the case where the corresponding parameter is a trailing parameter pack. Test Plan: A test for deduction from nested initializer lists where the corresponding parameter is a trailing parameter pack is added in `clang/test/SemaCXX/cxx0x-initializer-stdinitializerlist.cpp`. Reviewers: fraggamuffin, rsmith Reviewed By: rsmith Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D10681 llvm-svn: 240612
2015-06-25 08:25:49 +08:00
/// \brief Attempt template argument deduction from an initializer list
/// deemed to be an argument in a function call.
Factor out more common logic in template argument deduction from function call arguments. No functionality change intended. llvm-svn: 291074
2017-01-05 12:08:31 +08:00
static Sema::TemplateDeductionResult DeduceFromInitializerList(
Sema &S, TemplateParameterList *TemplateParams, QualType AdjustedParamType,
InitListExpr *ILE, TemplateDeductionInfo &Info,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
Add missing "original call argument has same type as deduced parameter type" check for deductions from elements of a braced-init-list. llvm-svn: 291190
2017-01-06 07:02:44 +08:00
SmallVectorImpl<Sema::OriginalCallArg> &OriginalCallArgs, unsigned ArgIdx,
unsigned TDF) {
Factor out duplicated code and simplify. No functionality change intended. llvm-svn: 290996
2017-01-05 03:47:19 +08:00
// C++ [temp.deduct.call]p1: (CWG 1591)
// If removing references and cv-qualifiers from P gives
// std::initializer_list<P0> or P0[N] for some P0 and N and the argument is
// a non-empty initializer list, then deduction is performed instead for
// each element of the initializer list, taking P0 as a function template
// parameter type and the initializer element as its argument
//
Factor out more common logic in template argument deduction from function call arguments. No functionality change intended. llvm-svn: 291074
2017-01-05 12:08:31 +08:00
// We've already removed references and cv-qualifiers here.
Per [temp.deduct.call], do not deduce an array bound of 0 from an empty initializer list. llvm-svn: 291075
2017-01-05 12:16:30 +08:00
if (!ILE->getNumInits())
return Sema::TDK_Success;
Factor out duplicated code and simplify. No functionality change intended. llvm-svn: 290996
2017-01-05 03:47:19 +08:00
QualType ElTy;
auto *ArrTy = S.Context.getAsArrayType(AdjustedParamType);
if (ArrTy)
ElTy = ArrTy->getElementType();
else if (!S.isStdInitializerList(AdjustedParamType, &ElTy)) {
// Otherwise, an initializer list argument causes the parameter to be
// considered a non-deduced context
return Sema::TDK_Success;
Fix PR24694 (CWG1591): Deducing array bound and element type from initializer list https://llvm.org/bugs/show_bug.cgi?id=24694 http://wg21.link/cwg1591 Teach DeduceFromInitializerList in SemaTemplateDeduction.cpp to deduce against array (constant and dependent sized) parameters (really, reference to arrays since they don't decay to pointers), by checking if the template parameter is either one of those kinds of arrays, and if so, deducing each initializer list element against the element type, and then deducing the array bound if needed. In brief, this patch enables the following code: template<class T, int N> int *f(T (&&)[N]); int *ip = f({1, 2, 3}); llvm-svn: 255221
2015-12-10 13:36:39 +08:00
}
Factor out duplicated code and simplify. No functionality change intended. llvm-svn: 290996
2017-01-05 03:47:19 +08:00
Fix PR24694 (CWG1591): Deducing array bound and element type from initializer list https://llvm.org/bugs/show_bug.cgi?id=24694 http://wg21.link/cwg1591 Teach DeduceFromInitializerList in SemaTemplateDeduction.cpp to deduce against array (constant and dependent sized) parameters (really, reference to arrays since they don't decay to pointers), by checking if the template parameter is either one of those kinds of arrays, and if so, deducing each initializer list element against the element type, and then deducing the array bound if needed. In brief, this patch enables the following code: template<class T, int N> int *f(T (&&)[N]); int *ip = f({1, 2, 3}); llvm-svn: 255221
2015-12-10 13:36:39 +08:00
// Deduction only needs to be done for dependent types.
if (ElTy->isDependentType()) {
for (Expr *E : ILE->inits()) {
Factor out more common logic in template argument deduction from function call arguments. No functionality change intended. llvm-svn: 291074
2017-01-05 12:08:31 +08:00
if (auto Result = DeduceTemplateArgumentsFromCallArgument(
[c++1z] Synthesize implicit deduction guides from constructors on demand. Rank such guides below explicit ones, and ensure that references to the class's template parameters are not treated as forwarding references. We make a few tweaks to the wording in the current standard: 1) The constructor parameter list is copied faithfully to the deduction guide, without losing default arguments or a varargs ellipsis (which the standard wording loses by omission). 2) If the class template declares no constructors, we add a T() -> T<...> guide (which will only ever work if T has default arguments for all non-pack template parameters). 3) If the class template declares nothing that looks like a copy or move constructor, we add a T(T<...>) -> T<...> guide. #2 and #3 follow from the "pretend we had a class type with these constructors" philosophy for deduction guides. llvm-svn: 295007
2017-02-14 08:25:28 +08:00
S, TemplateParams, 0, ElTy, E, Info, Deduced, OriginalCallArgs, true,
Add missing "original call argument has same type as deduced parameter type" check for deductions from elements of a braced-init-list. llvm-svn: 291190
2017-01-06 07:02:44 +08:00
ArgIdx, TDF))
Factor out duplicated code and simplify. No functionality change intended. llvm-svn: 290996
2017-01-05 03:47:19 +08:00
return Result;
Fix PR24694 (CWG1591): Deducing array bound and element type from initializer list https://llvm.org/bugs/show_bug.cgi?id=24694 http://wg21.link/cwg1591 Teach DeduceFromInitializerList in SemaTemplateDeduction.cpp to deduce against array (constant and dependent sized) parameters (really, reference to arrays since they don't decay to pointers), by checking if the template parameter is either one of those kinds of arrays, and if so, deducing each initializer list element against the element type, and then deducing the array bound if needed. In brief, this patch enables the following code: template<class T, int N> int *f(T (&&)[N]); int *ip = f({1, 2, 3}); llvm-svn: 255221
2015-12-10 13:36:39 +08:00
}
Consolidate and unify initializer list deduction Summary: This patch reduces duplication in the template argument deduction code for handling deduction from initializer lists in a function call. This extends the fix for PR12119 to also apply to the case where the corresponding parameter is a trailing parameter pack. Test Plan: A test for deduction from nested initializer lists where the corresponding parameter is a trailing parameter pack is added in `clang/test/SemaCXX/cxx0x-initializer-stdinitializerlist.cpp`. Reviewers: fraggamuffin, rsmith Reviewed By: rsmith Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D10681 llvm-svn: 240612
2015-06-25 08:25:49 +08:00
}
Factor out duplicated code and simplify. No functionality change intended. llvm-svn: 290996
2017-01-05 03:47:19 +08:00
// in the P0[N] case, if N is a non-type template parameter, N is deduced
// from the length of the initializer list.
if (auto *DependentArrTy = dyn_cast_or_null<DependentSizedArrayType>(ArrTy)) {
Fix PR24694 (CWG1591): Deducing array bound and element type from initializer list https://llvm.org/bugs/show_bug.cgi?id=24694 http://wg21.link/cwg1591 Teach DeduceFromInitializerList in SemaTemplateDeduction.cpp to deduce against array (constant and dependent sized) parameters (really, reference to arrays since they don't decay to pointers), by checking if the template parameter is either one of those kinds of arrays, and if so, deducing each initializer list element against the element type, and then deducing the array bound if needed. In brief, this patch enables the following code: template<class T, int N> int *f(T (&&)[N]); int *ip = f({1, 2, 3}); llvm-svn: 255221
2015-12-10 13:36:39 +08:00
// Determine the array bound is something we can deduce.
if (NonTypeTemplateParmDecl *NTTP =
Factor out duplicated code and simplify. No functionality change intended. llvm-svn: 290996
2017-01-05 03:47:19 +08:00
getDeducedParameterFromExpr(Info, DependentArrTy->getSizeExpr())) {
Fix PR24694 (CWG1591): Deducing array bound and element type from initializer list https://llvm.org/bugs/show_bug.cgi?id=24694 http://wg21.link/cwg1591 Teach DeduceFromInitializerList in SemaTemplateDeduction.cpp to deduce against array (constant and dependent sized) parameters (really, reference to arrays since they don't decay to pointers), by checking if the template parameter is either one of those kinds of arrays, and if so, deducing each initializer list element against the element type, and then deducing the array bound if needed. In brief, this patch enables the following code: template<class T, int N> int *f(T (&&)[N]); int *ip = f({1, 2, 3}); llvm-svn: 255221
2015-12-10 13:36:39 +08:00
// We can perform template argument deduction for the given non-type
// template parameter.
When deducing an array bound from the length of an initializer list, don't assume the bound has a non-dependent integral type. llvm-svn: 295698
2017-02-21 15:22:31 +08:00
// C++ [temp.deduct.type]p13:
// The type of N in the type T[N] is std::size_t.
QualType T = S.Context.getSizeType();
llvm::APInt Size(S.Context.getIntWidth(T), ILE->getNumInits());
Factor out duplicated code and simplify. No functionality change intended. llvm-svn: 290996
2017-01-05 03:47:19 +08:00
if (auto Result = DeduceNonTypeTemplateArgument(
When deducing an array bound from the length of an initializer list, don't assume the bound has a non-dependent integral type. llvm-svn: 295698
2017-02-21 15:22:31 +08:00
S, TemplateParams, NTTP, llvm::APSInt(Size), T,
Factor out duplicated code and simplify. No functionality change intended. llvm-svn: 290996
2017-01-05 03:47:19 +08:00
/*ArrayBound=*/true, Info, Deduced))
return Result;
Fix PR24694 (CWG1591): Deducing array bound and element type from initializer list https://llvm.org/bugs/show_bug.cgi?id=24694 http://wg21.link/cwg1591 Teach DeduceFromInitializerList in SemaTemplateDeduction.cpp to deduce against array (constant and dependent sized) parameters (really, reference to arrays since they don't decay to pointers), by checking if the template parameter is either one of those kinds of arrays, and if so, deducing each initializer list element against the element type, and then deducing the array bound if needed. In brief, this patch enables the following code: template<class T, int N> int *f(T (&&)[N]); int *ip = f({1, 2, 3}); llvm-svn: 255221
2015-12-10 13:36:39 +08:00
}
}
Factor out duplicated code and simplify. No functionality change intended. llvm-svn: 290996
2017-01-05 03:47:19 +08:00
return Sema::TDK_Success;
Consolidate and unify initializer list deduction Summary: This patch reduces duplication in the template argument deduction code for handling deduction from initializer lists in a function call. This extends the fix for PR12119 to also apply to the case where the corresponding parameter is a trailing parameter pack. Test Plan: A test for deduction from nested initializer lists where the corresponding parameter is a trailing parameter pack is added in `clang/test/SemaCXX/cxx0x-initializer-stdinitializerlist.cpp`. Reviewers: fraggamuffin, rsmith Reviewed By: rsmith Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D10681 llvm-svn: 240612
2015-06-25 08:25:49 +08:00
}
Factor out more common logic in template argument deduction from function call arguments. No functionality change intended. llvm-svn: 291074
2017-01-05 12:08:31 +08:00
/// \brief Perform template argument deduction per [temp.deduct.call] for a
/// single parameter / argument pair.
static Sema::TemplateDeductionResult DeduceTemplateArgumentsFromCallArgument(
[c++1z] Synthesize implicit deduction guides from constructors on demand. Rank such guides below explicit ones, and ensure that references to the class's template parameters are not treated as forwarding references. We make a few tweaks to the wording in the current standard: 1) The constructor parameter list is copied faithfully to the deduction guide, without losing default arguments or a varargs ellipsis (which the standard wording loses by omission). 2) If the class template declares no constructors, we add a T() -> T<...> guide (which will only ever work if T has default arguments for all non-pack template parameters). 3) If the class template declares nothing that looks like a copy or move constructor, we add a T(T<...>) -> T<...> guide. #2 and #3 follow from the "pretend we had a class type with these constructors" philosophy for deduction guides. llvm-svn: 295007
2017-02-14 08:25:28 +08:00
Sema &S, TemplateParameterList *TemplateParams, unsigned FirstInnerIndex,
QualType ParamType, Expr *Arg, TemplateDeductionInfo &Info,
Factor out more common logic in template argument deduction from function call arguments. No functionality change intended. llvm-svn: 291074
2017-01-05 12:08:31 +08:00
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
SmallVectorImpl<Sema::OriginalCallArg> &OriginalCallArgs,
Add missing "original call argument has same type as deduced parameter type" check for deductions from elements of a braced-init-list. llvm-svn: 291190
2017-01-06 07:02:44 +08:00
bool DecomposedParam, unsigned ArgIdx, unsigned TDF) {
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();
Factor out more common logic in template argument deduction from function call arguments. No functionality change intended. llvm-svn: 291074
2017-01-05 12:08:31 +08:00
QualType OrigParamType = ParamType;
// If P is a reference type [...]
// If P is a cv-qualified type [...]
[c++1z] Synthesize implicit deduction guides from constructors on demand. Rank such guides below explicit ones, and ensure that references to the class's template parameters are not treated as forwarding references. We make a few tweaks to the wording in the current standard: 1) The constructor parameter list is copied faithfully to the deduction guide, without losing default arguments or a varargs ellipsis (which the standard wording loses by omission). 2) If the class template declares no constructors, we add a T() -> T<...> guide (which will only ever work if T has default arguments for all non-pack template parameters). 3) If the class template declares nothing that looks like a copy or move constructor, we add a T(T<...>) -> T<...> guide. #2 and #3 follow from the "pretend we had a class type with these constructors" philosophy for deduction guides. llvm-svn: 295007
2017-02-14 08:25:28 +08:00
if (AdjustFunctionParmAndArgTypesForDeduction(
S, TemplateParams, FirstInnerIndex, ParamType, ArgType, Arg, TDF))
Fix failure to treat overloaded function in braced-init-list as a non-deduced context. Previously, if an overloaded function in a braced-init-list was encountered in template argument deduction, and the overload set couldn't be resolved to a particular function, we'd immediately produce a deduction failure. That's not correct; this situation is supposed to result in that particular P/A pair being treated as a non-deduced context, and deduction can still succeed if the type can be deduced from elsewhere. llvm-svn: 291014
2017-01-05 06:03:59 +08:00
return Sema::TDK_Success;
Factor out more common logic in template argument deduction from function call arguments. No functionality change intended. llvm-svn: 291074
2017-01-05 12:08:31 +08:00
// If [...] the argument is a non-empty initializer list [...]
if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg))
return DeduceFromInitializerList(S, TemplateParams, ParamType, ILE, Info,
Add missing "original call argument has same type as deduced parameter type" check for deductions from elements of a braced-init-list. llvm-svn: 291190
2017-01-06 07:02:44 +08:00
Deduced, OriginalCallArgs, ArgIdx, TDF);
Factor out more common logic in template argument deduction from function call arguments. No functionality change intended. llvm-svn: 291074
2017-01-05 12:08:31 +08:00
// [...] the deduction process attempts to find template argument values
// that will make the deduced A identical to A
//
// Keep track of the argument type and corresponding parameter index,
// so we can check for compatibility between the deduced A and A.
Add missing "original call argument has same type as deduced parameter type" check for deductions from elements of a braced-init-list. llvm-svn: 291190
2017-01-06 07:02:44 +08:00
OriginalCallArgs.push_back(
Sema::OriginalCallArg(OrigParamType, DecomposedParam, ArgIdx, ArgType));
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.
///
Implement C++ DR1391 (wg21.link/cwg1391) Check for implicit conversion sequences for non-dependent function template parameters between deduction and substitution. The idea is to accept as many cases as possible, on the basis that substitution failure outside the immediate context is much more common during substitution than during implicit conversion sequence formation. This re-commits r290808, reverted in r290811 and r291412, with a couple of fixes for handling of explicitly-specified non-trailing template argument packs. llvm-svn: 291427
2017-01-09 16:01:21 +08:00
/// \param CheckNonDependent A callback to invoke to check conversions for
/// non-dependent parameters, between deduction and substitution, per DR1391.
/// If this returns true, substitution will be skipped and we return
/// TDK_NonDependentConversionFailure. The callback is passed the parameter
/// types (after substituting explicit template arguments).
///
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
/// \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,
Initial support for C++ parameter completion The improved completion in call context now works with: - Functions. - Member functions. - Constructors. - New expressions. - Function call expressions. - Template variants of the previous. There are still rough edges to be fixed: - Provide support for optional parameters. (fix known) - Provide support for member initializers. (fix known) - Provide support for variadic template functions. (fix unknown) - Others? llvm-svn: 226670
2015-01-22 00:24:11 +08:00
FunctionDecl *&Specialization, TemplateDeductionInfo &Info,
Implement C++ DR1391 (wg21.link/cwg1391) Check for implicit conversion sequences for non-dependent function template parameters between deduction and substitution. The idea is to accept as many cases as possible, on the basis that substitution failure outside the immediate context is much more common during substitution than during implicit conversion sequence formation. This re-commits r290808, reverted in r290811 and r291412, with a couple of fixes for handling of explicitly-specified non-trailing template argument packs. llvm-svn: 291427
2017-01-09 16:01:21 +08:00
bool PartialOverloading,
llvm::function_ref<bool(ArrayRef<QualType>)> CheckNonDependent) {
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();
Initial support for C++ parameter completion The improved completion in call context now works with: - Functions. - Member functions. - Constructors. - New expressions. - Function call expressions. - Template variants of the previous. There are still rough edges to be fixed: - Provide support for optional parameters. (fix known) - Provide support for member initializers. (fix known) - Provide support for variadic template functions. (fix unknown) - Others? llvm-svn: 226670
2015-01-22 00:24:11 +08:00
unsigned NumParams = Function->getNumParams();
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
[c++1z] Synthesize implicit deduction guides from constructors on demand. Rank such guides below explicit ones, and ensure that references to the class's template parameters are not treated as forwarding references. We make a few tweaks to the wording in the current standard: 1) The constructor parameter list is copied faithfully to the deduction guide, without losing default arguments or a varargs ellipsis (which the standard wording loses by omission). 2) If the class template declares no constructors, we add a T() -> T<...> guide (which will only ever work if T has default arguments for all non-pack template parameters). 3) If the class template declares nothing that looks like a copy or move constructor, we add a T(T<...>) -> T<...> guide. #2 and #3 follow from the "pretend we had a class type with these constructors" philosophy for deduction guides. llvm-svn: 295007
2017-02-14 08:25:28 +08:00
unsigned FirstInnerIndex = getFirstInnerIndex(FunctionTemplate);
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.
Initial support for C++ parameter completion The improved completion in call context now works with: - Functions. - Member functions. - Constructors. - New expressions. - Function call expressions. - Template variants of the previous. There are still rough edges to be fixed: - Provide support for optional parameters. (fix known) - Provide support for member initializers. (fix known) - Provide support for variadic template functions. (fix unknown) - Others? llvm-svn: 226670
2015-01-22 00:24:11 +08:00
if (Args.size() < Function->getMinRequiredArguments() && !PartialOverloading)
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;
Initial support for C++ parameter completion The improved completion in call context now works with: - Functions. - Member functions. - Constructors. - New expressions. - Function call expressions. - Template variants of the previous. There are still rough edges to be fixed: - Provide support for optional parameters. (fix known) - Provide support for member initializers. (fix known) - Provide support for variadic template functions. (fix unknown) - Others? llvm-svn: 226670
2015-01-22 00:24:11 +08:00
else if (TooManyArguments(NumParams, Args.size(), PartialOverloading)) {
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 */;
Implement DR1388 (wg21.link/cwg1388). This issue clarifies how deduction proceeds past a non-trailing function parameter pack. Essentially, the pack itself is skipped and consumes no arguments (except for those implied by an explicitly-specified template arguments), and nothing is deduced from it. As a small fix to the standard's rule, we do not allow subsequent deduction to change the length of the function parameter pack (by preventing extension of the explicitly-specified pack if present, and otherwise deducing all contained packs to empty packs). llvm-svn: 291425
2017-01-09 15:14:40 +08:00
else if (!Proto->isVariadic())
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;
Implement C++ DR1391 (wg21.link/cwg1391) Check for implicit conversion sequences for non-dependent function template parameters between deduction and substitution. The idea is to accept as many cases as possible, on the basis that substitution failure outside the immediate context is much more common during substitution than during implicit conversion sequence formation. This re-commits r290808, reverted in r290811 and r291412, with a couple of fixes for handling of explicitly-specified non-trailing template argument packs. llvm-svn: 291427
2017-01-09 16:01:21 +08:00
SmallVector<QualType, 8> 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,
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
nullptr,
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);
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.
Initial support for C++ parameter completion The improved completion in call context now works with: - Functions. - Member functions. - Constructors. - New expressions. - Function call expressions. - Template variants of the previous. There are still rough edges to be fixed: - Provide support for optional parameters. (fix known) - Provide support for member initializers. (fix known) - Provide support for variadic template functions. (fix unknown) - Others? llvm-svn: 226670
2015-01-22 00:24:11 +08:00
for (unsigned I = 0; I != NumParams; ++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
Implement C++ DR1391 (wg21.link/cwg1391) Check for implicit conversion sequences for non-dependent function template parameters between deduction and substitution. The idea is to accept as many cases as possible, on the basis that substitution failure outside the immediate context is much more common during substitution than during implicit conversion sequence formation. This re-commits r290808, reverted in r290811 and r291412, with a couple of fixes for handling of explicitly-specified non-trailing template argument packs. llvm-svn: 291427
2017-01-09 16:01:21 +08:00
SmallVector<OriginalCallArg, 8> OriginalCallArgs;
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
Factor out duplicated code and simplify. No functionality change intended. llvm-svn: 290996
2017-01-05 03:47:19 +08:00
// Deduce an argument of type ParamType from an expression with index ArgIdx.
auto DeduceCallArgument = [&](QualType ParamType, unsigned ArgIdx) {
Factor out more common logic in template argument deduction from function call arguments. No functionality change intended. llvm-svn: 291074
2017-01-05 12:08:31 +08:00
// C++ [demp.deduct.call]p1: (DR1391)
// Template argument deduction is done by comparing each function template
// parameter that contains template-parameters that participate in
// template argument deduction ...
Revert r295277 to fix buildbot. llvm-svn: 295281
2017-02-16 12:22:56 +08:00
if (!hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType))
Factor out duplicated code and simplify. No functionality change intended. llvm-svn: 290996
2017-01-05 03:47:19 +08:00
return Sema::TDK_Success;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Factor out more common logic in template argument deduction from function call arguments. No functionality change intended. llvm-svn: 291074
2017-01-05 12:08:31 +08:00
// ... with the type of the corresponding argument
return DeduceTemplateArgumentsFromCallArgument(
[c++1z] Synthesize implicit deduction guides from constructors on demand. Rank such guides below explicit ones, and ensure that references to the class's template parameters are not treated as forwarding references. We make a few tweaks to the wording in the current standard: 1) The constructor parameter list is copied faithfully to the deduction guide, without losing default arguments or a varargs ellipsis (which the standard wording loses by omission). 2) If the class template declares no constructors, we add a T() -> T<...> guide (which will only ever work if T has default arguments for all non-pack template parameters). 3) If the class template declares nothing that looks like a copy or move constructor, we add a T(T<...>) -> T<...> guide. #2 and #3 follow from the "pretend we had a class type with these constructors" philosophy for deduction guides. llvm-svn: 295007
2017-02-14 08:25:28 +08:00
*this, TemplateParams, FirstInnerIndex, ParamType, Args[ArgIdx], Info, Deduced,
Add missing "original call argument has same type as deduced parameter type" check for deductions from elements of a braced-init-list. llvm-svn: 291190
2017-01-06 07:02:44 +08:00
OriginalCallArgs, /*Decomposed*/false, ArgIdx, /*TDF*/ 0);
Factor out duplicated code and simplify. No functionality change intended. llvm-svn: 290996
2017-01-05 03:47:19 +08:00
};
Template argument deduction for std::initializer_list arguments from initializer lists. llvm-svn: 148352
2012-01-18 06:49:58 +08:00
Factor out duplicated code and simplify. No functionality change intended. llvm-svn: 290996
2017-01-05 03:47:19 +08:00
// Deduce template arguments from the function parameters.
Deduced.resize(TemplateParams->size());
Implement C++ DR1391 (wg21.link/cwg1391) Check for implicit conversion sequences for non-dependent function template parameters between deduction and substitution. The idea is to accept as many cases as possible, on the basis that substitution failure outside the immediate context is much more common during substitution than during implicit conversion sequence formation. This re-commits r290808, reverted in r290811 and r291412, with a couple of fixes for handling of explicitly-specified non-trailing template argument packs. llvm-svn: 291427
2017-01-09 16:01:21 +08:00
SmallVector<QualType, 8> ParamTypesForArgChecking;
Factor out duplicated code and simplify. No functionality change intended. llvm-svn: 290996
2017-01-05 03:47:19 +08:00
for (unsigned ParamIdx = 0, NumParamTypes = ParamTypes.size(), ArgIdx = 0;
ParamIdx != NumParamTypes; ++ParamIdx) {
QualType ParamType = ParamTypes[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
Factor out duplicated code and simplify. No functionality change intended. llvm-svn: 290996
2017-01-05 03:47:19 +08:00
const PackExpansionType *ParamExpansion =
dyn_cast<PackExpansionType>(ParamType);
if (!ParamExpansion) {
// Simple case: matching a function parameter to a function argument.
Implement DR1388 (wg21.link/cwg1388). This issue clarifies how deduction proceeds past a non-trailing function parameter pack. Essentially, the pack itself is skipped and consumes no arguments (except for those implied by an explicitly-specified template arguments), and nothing is deduced from it. As a small fix to the standard's rule, we do not allow subsequent deduction to change the length of the function parameter pack (by preventing extension of the explicitly-specified pack if present, and otherwise deducing all contained packs to empty packs). llvm-svn: 291425
2017-01-09 15:14:40 +08:00
if (ArgIdx >= Args.size())
Factor out duplicated code and simplify. No functionality change intended. llvm-svn: 290996
2017-01-05 03:47:19 +08:00
break;
Implement C++ DR1391 (wg21.link/cwg1391) Check for implicit conversion sequences for non-dependent function template parameters between deduction and substitution. The idea is to accept as many cases as possible, on the basis that substitution failure outside the immediate context is much more common during substitution than during implicit conversion sequence formation. This re-commits r290808, reverted in r290811 and r291412, with a couple of fixes for handling of explicitly-specified non-trailing template argument packs. llvm-svn: 291427
2017-01-09 16:01:21 +08:00
ParamTypesForArgChecking.push_back(ParamType);
Factor out duplicated code and simplify. No functionality change intended. llvm-svn: 290996
2017-01-05 03:47:19 +08:00
if (auto Result = DeduceCallArgument(ParamType, 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
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 DR1388 (wg21.link/cwg1388). This issue clarifies how deduction proceeds past a non-trailing function parameter pack. Essentially, the pack itself is skipped and consumes no arguments (except for those implied by an explicitly-specified template arguments), and nothing is deduced from it. As a small fix to the standard's rule, we do not allow subsequent deduction to change the length of the function parameter pack (by preventing extension of the explicitly-specified pack if present, and otherwise deducing all contained packs to empty packs). llvm-svn: 291425
2017-01-09 15:14:40 +08:00
QualType ParamPattern = ParamExpansion->getPattern();
PackDeductionScope PackScope(*this, TemplateParams, Deduced, Info,
ParamPattern);
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 DR1388 (wg21.link/cwg1388). This issue clarifies how deduction proceeds past a non-trailing function parameter pack. Essentially, the pack itself is skipped and consumes no arguments (except for those implied by an explicitly-specified template arguments), and nothing is deduced from it. As a small fix to the standard's rule, we do not allow subsequent deduction to change the length of the function parameter pack (by preventing extension of the explicitly-specified pack if present, and otherwise deducing all contained packs to empty packs). llvm-svn: 291425
2017-01-09 15:14:40 +08:00
// the function parameter pack. When a function parameter pack appears
// in a non-deduced context [not at the end of the list], the type of
// that parameter pack is never deduced.
//
// FIXME: The above rule allows the size of the parameter pack to change
// after we skip it (in the non-deduced case). That makes no sense, so
// we instead notionally deduce the pack against N arguments, where N is
// the length of the explicitly-specified pack if it's expanded by the
// parameter pack and 0 otherwise, and we treat each deduction as a
// non-deduced context.
if (ParamIdx + 1 == NumParamTypes) {
Implement C++ DR1391 (wg21.link/cwg1391) Check for implicit conversion sequences for non-dependent function template parameters between deduction and substitution. The idea is to accept as many cases as possible, on the basis that substitution failure outside the immediate context is much more common during substitution than during implicit conversion sequence formation. This re-commits r290808, reverted in r290811 and r291412, with a couple of fixes for handling of explicitly-specified non-trailing template argument packs. llvm-svn: 291427
2017-01-09 16:01:21 +08:00
for (; ArgIdx < Args.size(); PackScope.nextPackElement(), ++ArgIdx) {
ParamTypesForArgChecking.push_back(ParamPattern);
Implement DR1388 (wg21.link/cwg1388). This issue clarifies how deduction proceeds past a non-trailing function parameter pack. Essentially, the pack itself is skipped and consumes no arguments (except for those implied by an explicitly-specified template arguments), and nothing is deduced from it. As a small fix to the standard's rule, we do not allow subsequent deduction to change the length of the function parameter pack (by preventing extension of the explicitly-specified pack if present, and otherwise deducing all contained packs to empty packs). llvm-svn: 291425
2017-01-09 15:14:40 +08:00
if (auto Result = DeduceCallArgument(ParamPattern, ArgIdx))
return Result;
Implement C++ DR1391 (wg21.link/cwg1391) Check for implicit conversion sequences for non-dependent function template parameters between deduction and substitution. The idea is to accept as many cases as possible, on the basis that substitution failure outside the immediate context is much more common during substitution than during implicit conversion sequence formation. This re-commits r290808, reverted in r290811 and r291412, with a couple of fixes for handling of explicitly-specified non-trailing template argument packs. llvm-svn: 291427
2017-01-09 16:01:21 +08:00
}
Implement DR1388 (wg21.link/cwg1388). This issue clarifies how deduction proceeds past a non-trailing function parameter pack. Essentially, the pack itself is skipped and consumes no arguments (except for those implied by an explicitly-specified template arguments), and nothing is deduced from it. As a small fix to the standard's rule, we do not allow subsequent deduction to change the length of the function parameter pack (by preventing extension of the explicitly-specified pack if present, and otherwise deducing all contained packs to empty packs). llvm-svn: 291425
2017-01-09 15:14:40 +08:00
} else {
// If the parameter type contains an explicitly-specified pack that we
// could not expand, skip the number of parameters notionally created
// by the expansion.
Optional<unsigned> NumExpansions = ParamExpansion->getNumExpansions();
Implement C++ DR1391 (wg21.link/cwg1391) Check for implicit conversion sequences for non-dependent function template parameters between deduction and substitution. The idea is to accept as many cases as possible, on the basis that substitution failure outside the immediate context is much more common during substitution than during implicit conversion sequence formation. This re-commits r290808, reverted in r290811 and r291412, with a couple of fixes for handling of explicitly-specified non-trailing template argument packs. llvm-svn: 291427
2017-01-09 16:01:21 +08:00
if (NumExpansions && !PackScope.isPartiallyExpanded()) {
Implement DR1388 (wg21.link/cwg1388). This issue clarifies how deduction proceeds past a non-trailing function parameter pack. Essentially, the pack itself is skipped and consumes no arguments (except for those implied by an explicitly-specified template arguments), and nothing is deduced from it. As a small fix to the standard's rule, we do not allow subsequent deduction to change the length of the function parameter pack (by preventing extension of the explicitly-specified pack if present, and otherwise deducing all contained packs to empty packs). llvm-svn: 291425
2017-01-09 15:14:40 +08:00
for (unsigned I = 0; I != *NumExpansions && ArgIdx < Args.size();
Implement C++ DR1391 (wg21.link/cwg1391) Check for implicit conversion sequences for non-dependent function template parameters between deduction and substitution. The idea is to accept as many cases as possible, on the basis that substitution failure outside the immediate context is much more common during substitution than during implicit conversion sequence formation. This re-commits r290808, reverted in r290811 and r291412, with a couple of fixes for handling of explicitly-specified non-trailing template argument packs. llvm-svn: 291427
2017-01-09 16:01:21 +08:00
++I, ++ArgIdx) {
ParamTypesForArgChecking.push_back(ParamPattern);
Implement DR1388 (wg21.link/cwg1388). This issue clarifies how deduction proceeds past a non-trailing function parameter pack. Essentially, the pack itself is skipped and consumes no arguments (except for those implied by an explicitly-specified template arguments), and nothing is deduced from it. As a small fix to the standard's rule, we do not allow subsequent deduction to change the length of the function parameter pack (by preventing extension of the explicitly-specified pack if present, and otherwise deducing all contained packs to empty packs). llvm-svn: 291425
2017-01-09 15:14:40 +08:00
// FIXME: Should we add OriginalCallArgs for these? What if the
// corresponding argument is a list?
PackScope.nextPackElement();
Implement C++ DR1391 (wg21.link/cwg1391) Check for implicit conversion sequences for non-dependent function template parameters between deduction and substitution. The idea is to accept as many cases as possible, on the basis that substitution failure outside the immediate context is much more common during substitution than during implicit conversion sequence formation. This re-commits r290808, reverted in r290811 and r291412, with a couple of fixes for handling of explicitly-specified non-trailing template argument packs. llvm-svn: 291427
2017-01-09 16:01:21 +08:00
}
}
Implement DR1388 (wg21.link/cwg1388). This issue clarifies how deduction proceeds past a non-trailing function parameter pack. Essentially, the pack itself is skipped and consumes no arguments (except for those implied by an explicitly-specified template arguments), and nothing is deduced from it. As a small fix to the standard's rule, we do not allow subsequent deduction to change the length of the function parameter pack (by preventing extension of the explicitly-specified pack if present, and otherwise deducing all contained packs to empty packs). llvm-svn: 291425
2017-01-09 15:14:40 +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.
Fix template argument deduction when only some of a parameter pack is a non-deduced context. When a parameter pack has multiple corresponding arguments, and some subset of them are overloaded functions, it's possible that some subset of the parameters are non-deduced contexts. In such a case, keep deducing from the remainder of the arguments, and resolve the incomplete pack against whatever other deductions we've performed for the pack. GCC, MSVC, and ICC give three different bad behaviors for this case; what we do now (and what we did before) don't exactly match any of them, sadly :( I'm getting a core issue opened to specify more precisely how this should be handled. llvm-svn: 290923
2017-01-04 09:48:55 +08:00
if (auto Result = PackScope.finish())
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
return Result;
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
Implement C++ DR1391 (wg21.link/cwg1391) Check for implicit conversion sequences for non-dependent function template parameters between deduction and substitution. The idea is to accept as many cases as possible, on the basis that substitution failure outside the immediate context is much more common during substitution than during implicit conversion sequence formation. This re-commits r290808, reverted in r290811 and r291412, with a couple of fixes for handling of explicitly-specified non-trailing template argument packs. llvm-svn: 291427
2017-01-09 16:01:21 +08:00
return FinishTemplateArgumentDeduction(
FunctionTemplate, Deduced, NumExplicitlySpecified, Specialization, Info,
&OriginalCallArgs, PartialOverloading,
[&]() { return CheckNonDependent(ParamTypesForArgChecking); });
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
Handle CC and NoReturn when instantiating members of class templates. Before we were considering them only when instantiating templates. This fixes pr18033. llvm-svn: 196050
2013-12-02 00:54:29 +08:00
QualType Sema::adjustCCAndNoReturn(QualType ArgFunctionType,
PR31081: ignore exception specifications when deducing function template arguments from a declaration; despite what the standard says, this form of deduction should not be considering exception specifications. llvm-svn: 288301
2016-12-01 10:11:49 +08:00
QualType FunctionType,
bool AdjustExceptionSpec) {
Handle CC and NoReturn when instantiating members of class templates. Before we were considering them only when instantiating templates. This fixes pr18033. llvm-svn: 196050
2013-12-02 00:54:29 +08:00
if (ArgFunctionType.isNull())
return ArgFunctionType;
const FunctionProtoType *FunctionTypeP =
FunctionType->castAs<FunctionProtoType>();
const FunctionProtoType *ArgFunctionTypeP =
ArgFunctionType->getAs<FunctionProtoType>();
PR31081: ignore exception specifications when deducing function template arguments from a declaration; despite what the standard says, this form of deduction should not be considering exception specifications. llvm-svn: 288301
2016-12-01 10:11:49 +08:00
FunctionProtoType::ExtProtoInfo EPI = ArgFunctionTypeP->getExtProtoInfo();
bool Rebuild = false;
CallingConv CC = FunctionTypeP->getCallConv();
if (EPI.ExtInfo.getCC() != CC) {
EPI.ExtInfo = EPI.ExtInfo.withCallingConv(CC);
Rebuild = true;
}
bool NoReturn = FunctionTypeP->getNoReturnAttr();
if (EPI.ExtInfo.getNoReturn() != NoReturn) {
EPI.ExtInfo = EPI.ExtInfo.withNoReturn(NoReturn);
Rebuild = true;
}
if (AdjustExceptionSpec && (FunctionTypeP->hasExceptionSpec() ||
ArgFunctionTypeP->hasExceptionSpec())) {
EPI.ExceptionSpec = FunctionTypeP->getExtProtoInfo().ExceptionSpec;
Rebuild = true;
}
if (!Rebuild)
Handle CC and NoReturn when instantiating members of class templates. Before we were considering them only when instantiating templates. This fixes pr18033. llvm-svn: 196050
2013-12-02 00:54:29 +08:00
return ArgFunctionType;
PR31081: ignore exception specifications when deducing function template arguments from a declaration; despite what the standard says, this form of deduction should not be considering exception specifications. llvm-svn: 288301
2016-12-01 10:11:49 +08:00
return Context.getFunctionType(ArgFunctionTypeP->getReturnType(),
ArgFunctionTypeP->getParamTypes(), EPI);
Handle CC and NoReturn when instantiating members of class templates. Before we were considering them only when instantiating templates. This fixes pr18033. llvm-svn: 196050
2013-12-02 00:54:29 +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.
///
PR31081: ignore exception specifications when deducing function template arguments from a declaration; despite what the standard says, this form of deduction should not be considering exception specifications. llvm-svn: 288301
2016-12-01 10:11:49 +08:00
/// \param IsAddressOfFunction If \c true, we are deducing as part of taking
/// the address of a function template per [temp.deduct.funcaddr] and
/// [over.over]. If \c false, we are looking up a function template
/// specialization based on its signature, per [temp.deduct.decl].
///
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
/// \returns the result of template argument deduction.
PR31081: ignore exception specifications when deducing function template arguments from a declaration; despite what the standard says, this form of deduction should not be considering exception specifications. llvm-svn: 288301
2016-12-01 10:11:49 +08:00
Sema::TemplateDeductionResult Sema::DeduceTemplateArguments(
FunctionTemplateDecl *FunctionTemplate,
TemplateArgumentListInfo *ExplicitTemplateArgs, QualType ArgFunctionType,
FunctionDecl *&Specialization, TemplateDeductionInfo &Info,
bool IsAddressOfFunction) {
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();
PR31081: ignore exception specifications when deducing function template arguments from a declaration; despite what the standard says, this form of deduction should not be considering exception specifications. llvm-svn: 288301
2016-12-01 10:11:49 +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
[c++1z] Support deducing B in noexcept(B). This is not required by the standard (yet), but there seems to be reasonable support for this being a defect according to CWG discussion, and libstdc++ 7.1 relies on it working. llvm-svn: 304946
2017-06-08 05:46:22 +08:00
// When taking the address of a function, we require convertibility of
// the resulting function type. Otherwise, we allow arbitrary mismatches
// of calling convention and noreturn.
if (!IsAddressOfFunction)
ArgFunctionType = adjustCCAndNoReturn(ArgFunctionType, FunctionType,
/*AdjustExceptionSpec*/false);
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.
[NFC, Scoped Enum] Convert Sema::ExpressionEvaluationContext into a scoped Enum - also replace direct equality checks against the ConstantEvaluated enumerator with isConstantEvaluted(), in anticipation of adding finer granularity to the various ConstantEvaluated contexts and reinstating certain restrictions on where lambda expressions can occur in C++17. - update the clang tablegen backend that uses these Enumerators, and add the relevant scope where needed. llvm-svn: 299316
2017-04-02 05:30:49 +08:00
EnterExpressionEvaluationContext Unevaluated(
*this, Sema::ExpressionEvaluationContext::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
PR31081: ignore exception specifications when deducing function template arguments from a declaration; despite what the standard says, this form of deduction should not be considering exception specifications. llvm-svn: 288301
2016-12-01 10:11:49 +08:00
// type so that we treat it as a non-deduced context in what follows. If we
// are looking up by signature, the signature type should also have a deduced
// return type, which we instead expect to exactly match.
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;
PR31081: ignore exception specifications when deducing function template arguments from a declaration; despite what the standard says, this form of deduction should not be considering exception specifications. llvm-svn: 288301
2016-12-01 10:11:49 +08:00
if (getLangOpts().CPlusPlus14 && IsAddressOfFunction &&
Rename getResultType() on function and method declarations to getReturnType() A return type is the declared or deduced part of the function type specified in the declaration. A result type is the (potentially adjusted) type of the value of an expression that calls the function. Rule of thumb: * Declarations have return types and parameters. * Expressions have result types and arguments. llvm-svn: 200082
2014-01-26 00:55:45 +08:00
Function->getReturnType()->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()) {
[c++1z] Support deducing B in noexcept(B). This is not required by the standard (yet), but there seems to be reasonable support for this being a defect according to CWG discussion, and libstdc++ 7.1 relies on it working. llvm-svn: 304946
2017-06-08 05:46:22 +08:00
unsigned TDF =
TDF_TopLevelParameterTypeList | TDF_AllowCompatibleFunctionType;
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 &&
Rename getResultType() on function and method declarations to getReturnType() A return type is the declared or deduced part of the function type specified in the declaration. A result type is the (potentially adjusted) type of the value of an expression that calls the function. Rule of thumb: * Declarations have return types and parameters. * Expressions have result types and arguments. llvm-svn: 200082
2014-01-26 00:55:45 +08:00
Specialization->getReturnType()->isUndeducedType() &&
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
DeduceReturnType(Specialization, Info.getLocation(), false))
return TDK_MiscellaneousDeductionFailure;
p0012: Teach resolving address of overloaded function with dependent exception specification to resolve the exception specification as part of the type check, in C++1z onwards. This is not actually part of P0012 / CWG1330 rules for when an exception specification is "needed", but is necessary for sanity. llvm-svn: 285663
2016-11-01 09:31:23 +08:00
// If the function has a dependent exception specification, resolve it now,
// so we can check that the exception specification matches.
auto *SpecializationFPT =
Specialization->getType()->castAs<FunctionProtoType>();
if (getLangOpts().CPlusPlus1z &&
isUnresolvedExceptionSpec(SpecializationFPT->getExceptionSpecType()) &&
!ResolveExceptionSpec(Info.getLocation(), SpecializationFPT))
return TDK_MiscellaneousDeductionFailure;
[c++1z] Support deducing B in noexcept(B). This is not required by the standard (yet), but there seems to be reasonable support for this being a defect according to CWG discussion, and libstdc++ 7.1 relies on it working. llvm-svn: 304946
2017-06-08 05:46:22 +08:00
// Adjust the exception specification of the argument to match the
PR31081: ignore exception specifications when deducing function template arguments from a declaration; despite what the standard says, this form of deduction should not be considering exception specifications. llvm-svn: 288301
2016-12-01 10:11:49 +08:00
// substituted and resolved type we just formed. (Calling convention and
// noreturn can't be dependent, so we don't actually need this for them
// right now.)
QualType SpecializationType = Specialization->getType();
if (!IsAddressOfFunction)
ArgFunctionType = adjustCCAndNoReturn(ArgFunctionType, SpecializationType,
/*AdjustExceptionSpec*/true);
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()) {
PR31081: ignore exception specifications when deducing function template arguments from a declaration; despite what the standard says, this form of deduction should not be considering exception specifications. llvm-svn: 288301
2016-12-01 10:11:49 +08:00
if (IsAddressOfFunction &&
!isSameOrCompatibleFunctionType(
Context.getCanonicalType(SpecializationType),
Context.getCanonicalType(ArgFunctionType)))
Fix PR15291: noreturn adjustment in overload resolution for function templates, from Alexander Zinenko! llvm-svn: 179680
2013-04-17 16:45:07 +08:00
return TDK_MiscellaneousDeductionFailure;
PR31081: ignore exception specifications when deducing function template arguments from a declaration; despite what the standard says, this form of deduction should not be considering exception specifications. llvm-svn: 288301
2016-12-01 10:11:49 +08:00
if (!IsAddressOfFunction &&
!Context.hasSameType(SpecializationType, ArgFunctionType))
Fix PR15291: noreturn adjustment in overload resolution for function templates, from Alexander Zinenko! llvm-svn: 179680
2013-04-17 16:45:07 +08:00
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
}
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
/// \brief Given a function declaration (e.g. a generic lambda conversion
/// function) that contains an 'auto' in its result type, substitute it
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
/// with TypeToReplaceAutoWith. Be careful to pass in the type you want
/// to replace 'auto' with and not the actual result type you want
/// to set the function to.
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
static inline void
SubstAutoWithinFunctionReturnType(FunctionDecl *F,
Implement conversion to function pointer for generic lambdas without captures. The general strategy is to create template versions of the conversion function and static invoker and then during template argument deduction of the conversion function, create the corresponding call-operator and static invoker specializations, and when the conversion function is marked referenced generate the body of the conversion function using the corresponding static-invoker specialization. Similarly, Codegen does something similar - when asked to emit the IR for a specialized static invoker of a generic lambda, it forwards emission to the corresponding call operator. This patch has been reviewed in person both by Doug and Richard. Richard gave me the LGTM. A few minor changes: - per Richard's request i added a simple check to gracefully inform that captures (init, explicit or default) have not been added to generic lambdas just yet (instead of the assertion violation). - I removed a few lines of code that added the call operators instantiated parameters to the currentinstantiationscope. Not only did it not handle parameter packs, but it is more relevant in the patch for nested lambdas which will follow this one, and fix that problem more comprehensively. - Doug had commented that the original implementation strategy of using the TypeSourceInfo of the call operator to create the static-invoker was flawed and allowed const as a member qualifier to creep into the type of the static-invoker. I currently kludge around it - but after my initial discussion with Doug, with a follow up session with Richard, I have added a FIXME so that a more elegant solution that involves the use of TrivialTypeSourceInfo call followed by the correct wiring of the template parameters to the functionprototypeloc is forthcoming. Thanks! llvm-svn: 191634
2013-09-29 16:45:24 +08:00
QualType TypeToReplaceAutoWith, Sema &S) {
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
assert(!TypeToReplaceAutoWith->getContainedAutoType());
Rename getResultType() on function and method declarations to getReturnType() A return type is the declared or deduced part of the function type specified in the declaration. A result type is the (potentially adjusted) type of the value of an expression that calls the function. Rule of thumb: * Declarations have return types and parameters. * Expressions have result types and arguments. llvm-svn: 200082
2014-01-26 00:55:45 +08:00
QualType AutoResultType = F->getReturnType();
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
assert(AutoResultType->getContainedAutoType());
QualType DeducedResultType = S.SubstAutoType(AutoResultType,
Implement conversion to function pointer for generic lambdas without captures. The general strategy is to create template versions of the conversion function and static invoker and then during template argument deduction of the conversion function, create the corresponding call-operator and static invoker specializations, and when the conversion function is marked referenced generate the body of the conversion function using the corresponding static-invoker specialization. Similarly, Codegen does something similar - when asked to emit the IR for a specialized static invoker of a generic lambda, it forwards emission to the corresponding call operator. This patch has been reviewed in person both by Doug and Richard. Richard gave me the LGTM. A few minor changes: - per Richard's request i added a simple check to gracefully inform that captures (init, explicit or default) have not been added to generic lambdas just yet (instead of the assertion violation). - I removed a few lines of code that added the call operators instantiated parameters to the currentinstantiationscope. Not only did it not handle parameter packs, but it is more relevant in the patch for nested lambdas which will follow this one, and fix that problem more comprehensively. - Doug had commented that the original implementation strategy of using the TypeSourceInfo of the call operator to create the static-invoker was flawed and allowed const as a member qualifier to creep into the type of the static-invoker. I currently kludge around it - but after my initial discussion with Doug, with a follow up session with Richard, I have added a FIXME so that a more elegant solution that involves the use of TrivialTypeSourceInfo call followed by the correct wiring of the template parameters to the functionprototypeloc is forthcoming. Thanks! llvm-svn: 191634
2013-09-29 16:45:24 +08:00
TypeToReplaceAutoWith);
S.Context.adjustDeducedFunctionResultType(F, DeducedResultType);
}
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
/// \brief Given a specialized conversion operator of a generic lambda
/// create the corresponding specializations of the call operator and
/// the static-invoker. If the return type of the call operator is auto,
/// deduce its return type and check if that matches the
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
/// return type of the destination function ptr.
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
static inline Sema::TemplateDeductionResult
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
SpecializeCorrespondingLambdaCallOperatorAndInvoker(
CXXConversionDecl *ConversionSpecialized,
SmallVectorImpl<DeducedTemplateArgument> &DeducedArguments,
QualType ReturnTypeOfDestFunctionPtr,
TemplateDeductionInfo &TDInfo,
Sema &S) {
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
CXXRecordDecl *LambdaClass = ConversionSpecialized->getParent();
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
assert(LambdaClass && LambdaClass->isGenericLambda());
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
CXXMethodDecl *CallOpGeneric = LambdaClass->getLambdaCallOperator();
Rename getResultType() on function and method declarations to getReturnType() A return type is the declared or deduced part of the function type specified in the declaration. A result type is the (potentially adjusted) type of the value of an expression that calls the function. Rule of thumb: * Declarations have return types and parameters. * Expressions have result types and arguments. llvm-svn: 200082
2014-01-26 00:55:45 +08:00
QualType CallOpResultType = CallOpGeneric->getReturnType();
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
const bool GenericLambdaCallOperatorHasDeducedReturnType =
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
CallOpResultType->getContainedAutoType();
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
FunctionTemplateDecl *CallOpTemplate =
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
CallOpGeneric->getDescribedFunctionTemplate();
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
FunctionDecl *CallOpSpecialized = nullptr;
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
// Use the deduced arguments of the conversion function, to specialize our
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
// generic lambda's call operator.
if (Sema::TemplateDeductionResult Result
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
= S.FinishTemplateArgumentDeduction(CallOpTemplate,
DeducedArguments,
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
0, CallOpSpecialized, TDInfo))
return Result;
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
// If we need to deduce the return type, do so (instantiates the callop).
Rename getResultType() on function and method declarations to getReturnType() A return type is the declared or deduced part of the function type specified in the declaration. A result type is the (potentially adjusted) type of the value of an expression that calls the function. Rule of thumb: * Declarations have return types and parameters. * Expressions have result types and arguments. llvm-svn: 200082
2014-01-26 00:55:45 +08:00
if (GenericLambdaCallOperatorHasDeducedReturnType &&
CallOpSpecialized->getReturnType()->isUndeducedType())
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
S.DeduceReturnType(CallOpSpecialized,
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
CallOpSpecialized->getPointOfInstantiation(),
/*Diagnose*/ true);
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
// Check to see if the return type of the destination ptr-to-function
// matches the return type of the call operator.
Rename getResultType() on function and method declarations to getReturnType() A return type is the declared or deduced part of the function type specified in the declaration. A result type is the (potentially adjusted) type of the value of an expression that calls the function. Rule of thumb: * Declarations have return types and parameters. * Expressions have result types and arguments. llvm-svn: 200082
2014-01-26 00:55:45 +08:00
if (!S.Context.hasSameType(CallOpSpecialized->getReturnType(),
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
ReturnTypeOfDestFunctionPtr))
return Sema::TDK_NonDeducedMismatch;
// Since we have succeeded in matching the source and destination
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
// ptr-to-functions (now including return type), and have successfully
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
// specialized our corresponding call operator, we are ready to
// specialize the static invoker with the deduced arguments of our
// ptr-to-function.
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
FunctionDecl *InvokerSpecialized = nullptr;
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
FunctionTemplateDecl *InvokerTemplate = LambdaClass->
getLambdaStaticInvoker()->getDescribedFunctionTemplate();
Silence Visual C++ warning C4189: 'Result' : local variable is initialized but not referenced. Sadly, LLVM_ATTRIBUTE_UNUSED does nothing with Visual C++ which means we'll have to workaround such cases again and again. llvm-svn: 237267
2015-05-14 01:56:46 +08:00
#ifndef NDEBUG
Sema::TemplateDeductionResult LLVM_ATTRIBUTE_UNUSED Result =
#endif
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
S.FinishTemplateArgumentDeduction(InvokerTemplate, DeducedArguments, 0,
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
InvokerSpecialized, TDInfo);
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
assert(Result == Sema::TDK_Success &&
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
"If the call operator succeeded so should the invoker!");
// Set the result type to match the corresponding call operator
// specialization's result type.
Rename getResultType() on function and method declarations to getReturnType() A return type is the declared or deduced part of the function type specified in the declaration. A result type is the (potentially adjusted) type of the value of an expression that calls the function. Rule of thumb: * Declarations have return types and parameters. * Expressions have result types and arguments. llvm-svn: 200082
2014-01-26 00:55:45 +08:00
if (GenericLambdaCallOperatorHasDeducedReturnType &&
InvokerSpecialized->getReturnType()->isUndeducedType()) {
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
// Be sure to get the type to replace 'auto' with and not
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
// the full result type of the call op specialization
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
// to substitute into the 'auto' of the invoker and conversion
// function.
// For e.g.
// int* (*fp)(int*) = [](auto* a) -> auto* { return a; };
// We don't want to subst 'int*' into 'auto' to get int**.
Rename getResultType() on function and method declarations to getReturnType() A return type is the declared or deduced part of the function type specified in the declaration. A result type is the (potentially adjusted) type of the value of an expression that calls the function. Rule of thumb: * Declarations have return types and parameters. * Expressions have result types and arguments. llvm-svn: 200082
2014-01-26 00:55:45 +08:00
QualType TypeToReplaceAutoWith = CallOpSpecialized->getReturnType()
->getContainedAutoType()
->getDeducedType();
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
SubstAutoWithinFunctionReturnType(InvokerSpecialized,
TypeToReplaceAutoWith, S);
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
SubstAutoWithinFunctionReturnType(ConversionSpecialized,
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
TypeToReplaceAutoWith, S);
}
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
// Ensure that static invoker doesn't have a const qualifier.
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
// FIXME: When creating the InvokerTemplate in SemaLambda.cpp
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
// do not use the CallOperator's TypeSourceInfo which allows
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
// the const qualifier to leak through.
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
const FunctionProtoType *InvokerFPT = InvokerSpecialized->
getType().getTypePtr()->castAs<FunctionProtoType>();
FunctionProtoType::ExtProtoInfo EPI = InvokerFPT->getExtProtoInfo();
EPI.TypeQuals = 0;
InvokerSpecialized->setType(S.Context.getFunctionType(
Rename getResultType() on function and method declarations to getReturnType() A return type is the declared or deduced part of the function type specified in the declaration. A result type is the (potentially adjusted) type of the value of an expression that calls the function. Rule of thumb: * Declarations have return types and parameters. * Expressions have result types and arguments. llvm-svn: 200082
2014-01-26 00:55:45 +08:00
InvokerFPT->getReturnType(), InvokerFPT->getParamTypes(), EPI));
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
return Sema::TDK_Success;
}
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
Implement conversion to function pointer for generic lambdas without captures. The general strategy is to create template versions of the conversion function and static invoker and then during template argument deduction of the conversion function, create the corresponding call-operator and static invoker specializations, and when the conversion function is marked referenced generate the body of the conversion function using the corresponding static-invoker specialization. Similarly, Codegen does something similar - when asked to emit the IR for a specialized static invoker of a generic lambda, it forwards emission to the corresponding call operator. This patch has been reviewed in person both by Doug and Richard. Richard gave me the LGTM. A few minor changes: - per Richard's request i added a simple check to gracefully inform that captures (init, explicit or default) have not been added to generic lambdas just yet (instead of the assertion violation). - I removed a few lines of code that added the call operators instantiated parameters to the currentinstantiationscope. Not only did it not handle parameter packs, but it is more relevant in the patch for nested lambdas which will follow this one, and fix that problem more comprehensively. - Doug had commented that the original implementation strategy of using the TypeSourceInfo of the call operator to create the static-invoker was flawed and allowed const as a member qualifier to creep into the type of the static-invoker. I currently kludge around it - but after my initial discussion with Doug, with a follow up session with Richard, I have added a FIXME so that a more elegant solution that involves the use of TrivialTypeSourceInfo call followed by the correct wiring of the template parameters to the functionprototypeloc is forthcoming. Thanks! llvm-svn: 191634
2013-09-29 16:45:24 +08:00
Sema::DeduceTemplateArguments(FunctionTemplateDecl *ConversionTemplate,
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
QualType ToType,
CXXConversionDecl *&Specialization,
TemplateDeductionInfo &Info) {
Implement conversion to function pointer for generic lambdas without captures. The general strategy is to create template versions of the conversion function and static invoker and then during template argument deduction of the conversion function, create the corresponding call-operator and static invoker specializations, and when the conversion function is marked referenced generate the body of the conversion function using the corresponding static-invoker specialization. Similarly, Codegen does something similar - when asked to emit the IR for a specialized static invoker of a generic lambda, it forwards emission to the corresponding call operator. This patch has been reviewed in person both by Doug and Richard. Richard gave me the LGTM. A few minor changes: - per Richard's request i added a simple check to gracefully inform that captures (init, explicit or default) have not been added to generic lambdas just yet (instead of the assertion violation). - I removed a few lines of code that added the call operators instantiated parameters to the currentinstantiationscope. Not only did it not handle parameter packs, but it is more relevant in the patch for nested lambdas which will follow this one, and fix that problem more comprehensively. - Doug had commented that the original implementation strategy of using the TypeSourceInfo of the call operator to create the static-invoker was flawed and allowed const as a member qualifier to creep into the type of the static-invoker. I currently kludge around it - but after my initial discussion with Doug, with a follow up session with Richard, I have added a FIXME so that a more elegant solution that involves the use of TrivialTypeSourceInfo call followed by the correct wiring of the template parameters to the functionprototypeloc is forthcoming. Thanks! llvm-svn: 191634
2013-09-29 16:45:24 +08:00
if (ConversionTemplate->isInvalidDecl())
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
return TDK_Invalid;
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
CXXConversionDecl *ConversionGeneric
Implement conversion to function pointer for generic lambdas without captures. The general strategy is to create template versions of the conversion function and static invoker and then during template argument deduction of the conversion function, create the corresponding call-operator and static invoker specializations, and when the conversion function is marked referenced generate the body of the conversion function using the corresponding static-invoker specialization. Similarly, Codegen does something similar - when asked to emit the IR for a specialized static invoker of a generic lambda, it forwards emission to the corresponding call operator. This patch has been reviewed in person both by Doug and Richard. Richard gave me the LGTM. A few minor changes: - per Richard's request i added a simple check to gracefully inform that captures (init, explicit or default) have not been added to generic lambdas just yet (instead of the assertion violation). - I removed a few lines of code that added the call operators instantiated parameters to the currentinstantiationscope. Not only did it not handle parameter packs, but it is more relevant in the patch for nested lambdas which will follow this one, and fix that problem more comprehensively. - Doug had commented that the original implementation strategy of using the TypeSourceInfo of the call operator to create the static-invoker was flawed and allowed const as a member qualifier to creep into the type of the static-invoker. I currently kludge around it - but after my initial discussion with Doug, with a follow up session with Richard, I have added a FIXME so that a more elegant solution that involves the use of TrivialTypeSourceInfo call followed by the correct wiring of the template parameters to the functionprototypeloc is forthcoming. Thanks! llvm-svn: 191634
2013-09-29 16:45:24 +08:00
= cast<CXXConversionDecl>(ConversionTemplate->getTemplatedDecl());
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
QualType FromType = ConversionGeneric->getConversionType();
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
// 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
Wrap to 80 columns. No behavior change. llvm-svn: 214059
2014-07-28 08:02:09 +08:00
// type are ignored for type deduction. If A is a reference type, the type
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
// 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.
[NFC, Scoped Enum] Convert Sema::ExpressionEvaluationContext into a scoped Enum - also replace direct equality checks against the ConstantEvaluated enumerator with isConstantEvaluted(), in anticipation of adding finer granularity to the various ConstantEvaluated contexts and reinstating certain restrictions on where lambda expressions can occur in C++17. - update the clang tablegen backend that uses these Enumerators, and add the relevant scope where needed. llvm-svn: 299316
2017-04-02 05:30:49 +08:00
EnterExpressionEvaluationContext Unevaluated(
*this, Sema::ExpressionEvaluationContext::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
Implement conversion to function pointer for generic lambdas without captures. The general strategy is to create template versions of the conversion function and static invoker and then during template argument deduction of the conversion function, create the corresponding call-operator and static invoker specializations, and when the conversion function is marked referenced generate the body of the conversion function using the corresponding static-invoker specialization. Similarly, Codegen does something similar - when asked to emit the IR for a specialized static invoker of a generic lambda, it forwards emission to the corresponding call operator. This patch has been reviewed in person both by Doug and Richard. Richard gave me the LGTM. A few minor changes: - per Richard's request i added a simple check to gracefully inform that captures (init, explicit or default) have not been added to generic lambdas just yet (instead of the assertion violation). - I removed a few lines of code that added the call operators instantiated parameters to the currentinstantiationscope. Not only did it not handle parameter packs, but it is more relevant in the patch for nested lambdas which will follow this one, and fix that problem more comprehensively. - Doug had commented that the original implementation strategy of using the TypeSourceInfo of the call operator to create the static-invoker was flawed and allowed const as a member qualifier to creep into the type of the static-invoker. I currently kludge around it - but after my initial discussion with Doug, with a follow up session with Richard, I have added a FIXME so that a more elegant solution that involves the use of TrivialTypeSourceInfo call followed by the correct wiring of the template parameters to the functionprototypeloc is forthcoming. Thanks! llvm-svn: 191634
2013-09-29 16:45:24 +08:00
= ConversionTemplate->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;
Fix windows newlines :( llvm-svn: 191641
2013-09-30 01:08:32 +08:00
// Create an Instantiation Scope for finalizing the operator.
LocalInstantiationScope InstScope(*this);
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
// Finish template argument deduction.
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
FunctionDecl *ConversionSpecialized = nullptr;
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
TemplateDeductionResult Result
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
= FinishTemplateArgumentDeduction(ConversionTemplate, Deduced, 0,
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
ConversionSpecialized, Info);
Specialization = cast_or_null<CXXConversionDecl>(ConversionSpecialized);
// If the conversion operator is being invoked on a lambda closure to convert
Wrap to 80 columns. No behavior change. llvm-svn: 214059
2014-07-28 08:02:09 +08:00
// to a ptr-to-function, use the deduced arguments from the conversion
// function to specialize the corresponding call operator.
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
// e.g., int (*fp)(int) = [](auto a) { return a; };
if (Result == TDK_Success && isLambdaConversionOperator(ConversionGeneric)) {
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
// Get the return type of the destination ptr-to-function we are converting
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
// to. This is necessary for matching the lambda call operator's return
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
// type to that of the destination ptr-to-function's return type.
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
assert(A->isPointerType() &&
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
"Can only convert from lambda to ptr-to-function");
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
const FunctionType *ToFunType =
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
A->getPointeeType().getTypePtr()->getAs<FunctionType>();
Rename getResultType() on function and method declarations to getReturnType() A return type is the declared or deduced part of the function type specified in the declaration. A result type is the (potentially adjusted) type of the value of an expression that calls the function. Rule of thumb: * Declarations have return types and parameters. * Expressions have result types and arguments. llvm-svn: 200082
2014-01-26 00:55:45 +08:00
const QualType DestFunctionPtrReturnType = ToFunType->getReturnType();
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
// Create the corresponding specializations of the call operator and
// the static-invoker; and if the return type is auto,
// deduce the return type and check if it matches the
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
// DestFunctionPtrReturnType.
// For instance:
// auto L = [](auto a) { return f(a); };
// int (*fp)(int) = L;
// char (*fp2)(int) = L; <-- Not OK.
Result = SpecializeCorrespondingLambdaCallOperatorAndInvoker(
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
Specialization, Deduced, DestFunctionPtrReturnType,
Refactor: Extract specializing the generic lambda call operator during conversion to fptr deduction into its own function. No functionality change. All clang regression tests pass. Thanks! llvm-svn: 193383
2013-10-25 07:40:02 +08:00
Info, *this);
Implement conversion to function pointer for generic lambdas without captures. The general strategy is to create template versions of the conversion function and static invoker and then during template argument deduction of the conversion function, create the corresponding call-operator and static invoker specializations, and when the conversion function is marked referenced generate the body of the conversion function using the corresponding static-invoker specialization. Similarly, Codegen does something similar - when asked to emit the IR for a specialized static invoker of a generic lambda, it forwards emission to the corresponding call operator. This patch has been reviewed in person both by Doug and Richard. Richard gave me the LGTM. A few minor changes: - per Richard's request i added a simple check to gracefully inform that captures (init, explicit or default) have not been added to generic lambdas just yet (instead of the assertion violation). - I removed a few lines of code that added the call operators instantiated parameters to the currentinstantiationscope. Not only did it not handle parameter packs, but it is more relevant in the patch for nested lambdas which will follow this one, and fix that problem more comprehensively. - Doug had commented that the original implementation strategy of using the TypeSourceInfo of the call operator to create the static-invoker was flawed and allowed const as a member qualifier to creep into the type of the static-invoker. I currently kludge around it - but after my initial discussion with Doug, with a follow up session with Richard, I have added a FIXME so that a more elegant solution that involves the use of TrivialTypeSourceInfo call followed by the correct wiring of the template parameters to the functionprototypeloc is forthcoming. Thanks! llvm-svn: 191634
2013-09-29 16:45:24 +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
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.
///
PR31081: ignore exception specifications when deducing function template arguments from a declaration; despite what the standard says, this form of deduction should not be considering exception specifications. llvm-svn: 288301
2016-12-01 10:11:49 +08:00
/// \param IsAddressOfFunction If \c true, we are deducing as part of taking
/// the address of a function template in a context where we do not have a
/// target type, per [over.over]. If \c false, we are looking up a function
/// template specialization based on its signature, which only happens when
/// deducing a function parameter type from an argument that is a template-id
/// naming a function template specialization.
///
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
/// \returns the result of template argument deduction.
PR31081: ignore exception specifications when deducing function template arguments from a declaration; despite what the standard says, this form of deduction should not be considering exception specifications. llvm-svn: 288301
2016-12-01 10:11:49 +08:00
Sema::TemplateDeductionResult Sema::DeduceTemplateArguments(
FunctionTemplateDecl *FunctionTemplate,
TemplateArgumentListInfo *ExplicitTemplateArgs,
FunctionDecl *&Specialization, TemplateDeductionInfo &Info,
bool IsAddressOfFunction) {
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,
PR31081: ignore exception specifications when deducing function template arguments from a declaration; despite what the standard says, this form of deduction should not be considering exception specifications. llvm-svn: 288301
2016-12-01 10:11:49 +08:00
IsAddressOfFunction);
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 {
[c++1z] P0091R3: Basic support for deducing class template arguments via deduction-guides. llvm-svn: 294613
2017-02-10 03:17:44 +08:00
/// Substitute the 'auto' specifier or deduced template specialization type
/// specifier within a type for a given replacement type.
class SubstituteDeducedTypeTransform :
public TreeTransform<SubstituteDeducedTypeTransform> {
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 Replacement;
[c++1z] P0091R3: Basic support for deducing class template arguments via deduction-guides. llvm-svn: 294613
2017-02-10 03:17:44 +08:00
bool UseTypeSugar;
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
public:
[c++1z] P0091R3: Basic support for deducing class template arguments via deduction-guides. llvm-svn: 294613
2017-02-10 03:17:44 +08:00
SubstituteDeducedTypeTransform(Sema &SemaRef, QualType Replacement,
bool UseTypeSugar = true)
: TreeTransform<SubstituteDeducedTypeTransform>(SemaRef),
Replacement(Replacement), UseTypeSugar(UseTypeSugar) {}
QualType TransformDesugared(TypeLocBuilder &TLB, DeducedTypeLoc TL) {
assert(isa<TemplateTypeParmType>(Replacement) &&
"unexpected unsugared replacement kind");
QualType Result = Replacement;
TemplateTypeParmTypeLoc NewTL = TLB.push<TemplateTypeParmTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());
return Result;
}
Wrap to 80 columns. No behavior change. llvm-svn: 214059
2014-07-28 08:02:09 +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
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.
[c++1z] P0091R3: Basic support for deducing class template arguments via deduction-guides. llvm-svn: 294613
2017-02-10 03:17:44 +08:00
//
// FIXME: Is this still necessary?
if (!UseTypeSugar)
return TransformDesugared(TLB, TL);
QualType Result = SemaRef.Context.getAutoType(
Replacement, TL.getTypePtr()->getKeyword(), Replacement.isNull());
auto NewTL = TLB.push<AutoTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());
return Result;
}
QualType TransformDeducedTemplateSpecializationType(
TypeLocBuilder &TLB, DeducedTemplateSpecializationTypeLoc TL) {
if (!UseTypeSugar)
return TransformDesugared(TLB, TL);
QualType Result = SemaRef.Context.getDeducedTemplateSpecializationType(
TL.getTypePtr()->getTemplateName(),
Replacement, Replacement.isNull());
auto NewTL = TLB.push<DeducedTemplateSpecializationTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());
return 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
}
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
};
Revert r240270 ("Fixed/added namespace ending comments using clang-tidy"). llvm-svn: 240353
2015-06-23 07:07:51 +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
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
Sema::DeduceAutoType(TypeSourceInfo *Type, Expr *&Init, QualType &Result,
Optional<unsigned> DependentDeductionDepth) {
return DeduceAutoType(Type->getTypeLoc(), Init, Result,
DependentDeductionDepth);
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 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
///
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
/// Note that this is done even if the initializer is dependent. (This is
/// necessary to support partial ordering of templates using 'auto'.)
/// A dependent type will be produced when deducing from a dependent type.
///
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.
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
/// \param DependentDeductionDepth Set if we should permit deduction in
/// dependent cases. This is necessary for template partial ordering with
/// 'auto' template parameters. The value specified is the template
/// parameter depth at which we should perform 'auto' deduction.
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
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
Sema::DeduceAutoType(TypeLoc Type, Expr *&Init, QualType &Result,
Optional<unsigned> DependentDeductionDepth) {
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;
Refactoring. Remove release and take methods from ActionResult. Rename takeAs to getAs. llvm-svn: 209800
2014-05-29 18:55:11 +08:00
Init = NonPlaceholder.get();
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
}
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
if (!DependentDeductionDepth &&
(Type.getType()->isDependentType() || Init->isTypeDependent())) {
[c++1z] P0091R3: Basic support for deducing class template arguments via deduction-guides. llvm-svn: 294613
2017-02-10 03:17:44 +08:00
Result = SubstituteDeducedTypeTransform(*this, QualType()).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
}
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
// Find the depth of template parameter to synthesize.
unsigned Depth = DependentDeductionDepth.getValueOr(0);
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;
}
Adding a -Wunused-value warning for expressions with side effects used in an unevaluated expression context, such as sizeof(), or decltype(). Also adds a similar warning when the expression passed to typeid() *is* evaluated, since it is equally likely that the user would expect the expression operand to be unevaluated in that case. llvm-svn: 224465
2014-12-18 05:57:17 +08:00
QualType Deduced = BuildDecltypeType(Init, Init->getLocStart(), false);
[Sema] Don't crash when deduction fails for decltype(auto) We didn't check the return result of BuildDecltypeType, resulting in us crashing when we tried to grab the canonical version of the type. This fixes PR23995. llvm-svn: 241131
2015-07-01 08:29:28 +08:00
if (Deduced.isNull())
return DAR_FailedAlreadyDiagnosed;
Implement C++1y decltype(auto). llvm-svn: 180610
2013-04-27 00:15:35 +08:00
// FIXME: Support a non-canonical deduced type for 'auto'.
Deduced = Context.getCanonicalType(Deduced);
[c++1z] P0091R3: Basic support for deducing class template arguments via deduction-guides. llvm-svn: 294613
2017-02-10 03:17:44 +08:00
Result = SubstituteDeducedTypeTransform(*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;
Add support for GCC's '__auto_type' extension, per the GCC manual: https://gcc.gnu.org/onlinedocs/gcc/Typeof.html Differences from the GCC extension: * __auto_type is also permitted in C++ (but only in places where it could appear in C), allowing its use in headers that might be shared across C and C++, or used from C++98 * __auto_type can be combined with a declarator, as with C++ auto (for instance, "__auto_type *p") * multiple variables can be declared in a single __auto_type declaration, with the C++ semantics (the deduced type must be the same in each case) This patch also adds a missing restriction on applying typeof to a bit-field, which GCC has historically rejected in C (due to lack of clarity as to whether the operand should be promoted). The same restriction also applies to __auto_type in C (in both GCC and Clang). This also fixes PR25449. Patch by Nicholas Allegra! llvm-svn: 252690
2015-11-11 10:02:15 +08:00
} else if (!getLangOpts().CPlusPlus) {
if (isa<InitListExpr>(Init)) {
Diag(Init->getLocStart(), diag::err_auto_init_list_from_c);
return DAR_FailedAlreadyDiagnosed;
}
Implement C++1y decltype(auto). llvm-svn: 180610
2013-04-27 00:15:35 +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
SourceLocation Loc = Init->getExprLoc();
LocalInstantiationScope InstScope(*this);
// Build template<class TemplParam> void Func(FuncParam);
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
TemplateTypeParmDecl *TemplParam = TemplateTypeParmDecl::Create(
Context, nullptr, SourceLocation(), Loc, Depth, 0, nullptr, false, false);
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
QualType TemplArg = QualType(TemplParam->getTypeForDecl(), 0);
NamedDecl *TemplParamPtr = TemplParam;
Reapply r276069 with workaround for MSVC 2013 llvm-svn: 277286
2016-07-31 06:33:34 +08:00
FixedSizeTemplateParameterListStorage<1, false> TemplateParamsSt(
Loc, Loc, TemplParamPtr, Loc, nullptr);
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
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
QualType FuncParam =
[c++1z] P0091R3: Basic support for deducing class template arguments via deduction-guides. llvm-svn: 294613
2017-02-10 03:17:44 +08:00
SubstituteDeducedTypeTransform(*this, TemplArg, /*UseTypeSugar*/false)
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
.Apply(Type);
When deducing an 'auto' type, don't modify the type-as-written. llvm-svn: 180808
2013-05-01 05:23:01 +08:00
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);
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
TemplateDeductionInfo Info(Loc, Depth);
// If deduction failed, don't diagnose if the initializer is dependent; it
// might acquire a matching type in the instantiation.
auto DeductionFailed = [&]() -> DeduceAutoResult {
if (Init->isTypeDependent()) {
[c++1z] P0091R3: Basic support for deducing class template arguments via deduction-guides. llvm-svn: 294613
2017-02-10 03:17:44 +08:00
Result = SubstituteDeducedTypeTransform(*this, QualType()).Apply(Type);
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
assert(!Result.isNull() && "substituting DependentTy can't fail");
return DAR_Succeeded;
}
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
Factor out more common logic in template argument deduction from function call arguments. No functionality change intended. llvm-svn: 291074
2017-01-05 12:08:31 +08:00
SmallVector<OriginalCallArg, 4> OriginalCallArgs;
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) {
Fix bug where types other than 'cv auto', 'cv auto &', and 'cv auto &&' could incorrectly be deduced from an initializer list in pathological cases. llvm-svn: 291191
2017-01-06 07:12:16 +08:00
// Notionally, we substitute std::initializer_list<T> for 'auto' and deduce
// against that. Such deduction only succeeds if removing cv-qualifiers and
// references results in std::initializer_list<T>.
if (!Type.getType().getNonReferenceType()->getAs<AutoType>())
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
for (unsigned i = 0, e = InitList->getNumInits(); i < e; ++i) {
Factor out more common logic in template argument deduction from function call arguments. No functionality change intended. llvm-svn: 291074
2017-01-05 12:08:31 +08:00
if (DeduceTemplateArgumentsFromCallArgument(
[c++1z] Synthesize implicit deduction guides from constructors on demand. Rank such guides below explicit ones, and ensure that references to the class's template parameters are not treated as forwarding references. We make a few tweaks to the wording in the current standard: 1) The constructor parameter list is copied faithfully to the deduction guide, without losing default arguments or a varargs ellipsis (which the standard wording loses by omission). 2) If the class template declares no constructors, we add a T() -> T<...> guide (which will only ever work if T has default arguments for all non-pack template parameters). 3) If the class template declares nothing that looks like a copy or move constructor, we add a T(T<...>) -> T<...> guide. #2 and #3 follow from the "pretend we had a class type with these constructors" philosophy for deduction guides. llvm-svn: 295007
2017-02-14 08:25:28 +08:00
*this, TemplateParamsSt.get(), 0, TemplArg, InitList->getInit(i),
Add missing "original call argument has same type as deduced parameter type" check for deductions from elements of a braced-init-list. llvm-svn: 291190
2017-01-06 07:02:44 +08:00
Info, Deduced, OriginalCallArgs, /*Decomposed*/ true,
/*ArgIdx*/ 0, /*TDF*/ 0))
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
return DeductionFailed();
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 {
Add support for GCC's '__auto_type' extension, per the GCC manual: https://gcc.gnu.org/onlinedocs/gcc/Typeof.html Differences from the GCC extension: * __auto_type is also permitted in C++ (but only in places where it could appear in C), allowing its use in headers that might be shared across C and C++, or used from C++98 * __auto_type can be combined with a declarator, as with C++ auto (for instance, "__auto_type *p") * multiple variables can be declared in a single __auto_type declaration, with the C++ semantics (the deduced type must be the same in each case) This patch also adds a missing restriction on applying typeof to a bit-field, which GCC has historically rejected in C (due to lack of clarity as to whether the operand should be promoted). The same restriction also applies to __auto_type in C (in both GCC and Clang). This also fixes PR25449. Patch by Nicholas Allegra! llvm-svn: 252690
2015-11-11 10:02:15 +08:00
if (!getLangOpts().CPlusPlus && Init->refersToBitField()) {
Diag(Loc, diag::err_auto_bitfield);
return DAR_FailedAlreadyDiagnosed;
}
Factor out more common logic in template argument deduction from function call arguments. No functionality change intended. llvm-svn: 291074
2017-01-05 12:08:31 +08:00
if (DeduceTemplateArgumentsFromCallArgument(
[c++1z] Synthesize implicit deduction guides from constructors on demand. Rank such guides below explicit ones, and ensure that references to the class's template parameters are not treated as forwarding references. We make a few tweaks to the wording in the current standard: 1) The constructor parameter list is copied faithfully to the deduction guide, without losing default arguments or a varargs ellipsis (which the standard wording loses by omission). 2) If the class template declares no constructors, we add a T() -> T<...> guide (which will only ever work if T has default arguments for all non-pack template parameters). 3) If the class template declares nothing that looks like a copy or move constructor, we add a T(T<...>) -> T<...> guide. #2 and #3 follow from the "pretend we had a class type with these constructors" philosophy for deduction guides. llvm-svn: 295007
2017-02-14 08:25:28 +08:00
*this, TemplateParamsSt.get(), 0, FuncParam, Init, Info, Deduced,
Add missing "original call argument has same type as deduced parameter type" check for deductions from elements of a braced-init-list. llvm-svn: 291190
2017-01-06 07:02:44 +08:00
OriginalCallArgs, /*Decomposed*/ false, /*ArgIdx*/ 0, /*TDF*/ 0))
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
return DeductionFailed();
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 some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
// Could be null if somehow 'auto' appears in a non-deduced context.
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)
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
return DeductionFailed();
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
}
[c++1z] P0091R3: Basic support for deducing class template arguments via deduction-guides. llvm-svn: 294613
2017-02-10 03:17:44 +08:00
Result = SubstituteDeducedTypeTransform(*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())
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +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
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.
Add missing "original call argument has same type as deduced parameter type" check for deductions from elements of a braced-init-list. llvm-svn: 291190
2017-01-06 07:02:44 +08:00
QualType DeducedA = InitList ? Deduced[0].getAsType() : Result;
Factor out more common logic in template argument deduction from function call arguments. No functionality change intended. llvm-svn: 291074
2017-01-05 12:08:31 +08:00
for (const OriginalCallArg &OriginalArg : OriginalCallArgs) {
Add missing "original call argument has same type as deduced parameter type" check for deductions from elements of a braced-init-list. llvm-svn: 291190
2017-01-06 07:02:44 +08:00
assert((bool)InitList == OriginalArg.DecomposedParam &&
"decomposed non-init-list in auto deduction?");
if (CheckOriginalCallArgDeduction(*this, OriginalArg, DeducedA)) {
Factor out more common logic in template argument deduction from function call arguments. No functionality change intended. llvm-svn: 291074
2017-01-05 12:08:31 +08:00
Result = QualType();
return DeductionFailed();
}
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
}
Fix Wdocumentation unknown parameter warning llvm-svn: 278503
2016-08-12 19:43:57 +08:00
QualType Sema::SubstAutoType(QualType TypeWithAuto,
Implement a rudimentary form of generic lambdas. Specifically, the following features are not included in this commit: - any sort of capturing within generic lambdas - generic lambdas within template functions and nested within other generic lambdas - conversion operator for captureless lambdas - ensuring all visitors are generic lambda aware (Although I have gotten some useful feedback on my patches of the above and will be incorporating that as I submit those patches for commit) As an example of what compiles through this commit: template <class F1, class F2> struct overload : F1, F2 { using F1::operator(); using F2::operator(); overload(F1 f1, F2 f2) : F1(f1), F2(f2) { } }; auto Recursive = [](auto Self, auto h, auto ... rest) { return 1 + Self(Self, rest...); }; auto Base = [](auto Self, auto h) { return 1; }; overload<decltype(Base), decltype(Recursive)> O(Base, Recursive); int num_params = O(O, 5, 3, "abc", 3.14, 'a'); Please see attached tests for more examples. This patch has been reviewed by Doug and Richard. Minor changes (non-functionality affecting) have been made since both of them formally looked at it, but the changes involve removal of supernumerary return type deduction changes (since they are now redundant, with richard having committed a recent patch to address return type deduction for C++11 lambdas using C++14 semantics). Some implementation notes: - Add a new Declarator context => LambdaExprParameterContext to clang::Declarator to allow the use of 'auto' in declaring generic lambda parameters - Add various helpers to CXXRecordDecl to facilitate identifying and querying a closure class - LambdaScopeInfo (which maintains the current lambda's Sema state) was augmented to house the current depth of the template being parsed (id est the Parser calls Sema::RecordParsingTemplateParameterDepth) so that SemaType.cpp::ConvertDeclSpecToType may use it to immediately generate a template-parameter-type when 'auto' is parsed in a generic lambda parameter context. (i.e we do NOT use AutoType deduced to a template parameter type - Richard seemed ok with this approach). We encode that this template type was generated from an auto by simply adding $auto to the name which can be used for better diagnostics if needed. - SemaLambda.h was added to hold some common lambda utility functions (this file is likely to grow ...) - Teach Sema::ActOnStartOfFunctionDef to check whether it is being called to instantiate a generic lambda's call operator, and if so, push an appropriately prepared LambdaScopeInfo object on the stack. - various tests were added - but much more will be needed. There is obviously more work to be done, and both Richard (weakly) and Doug (strongly) have requested that LambdaExpr be removed form the CXXRecordDecl LambdaDefinitionaData in a future patch which is forthcoming. A greatful thanks to all reviewers including Eli Friedman, James Dennett, and especially the two gracious wizards (Richard Smith and Doug Gregor) who spent hours providing feedback (in person in Chicago and on the mailing lists). And yet I am certain that I have allowed unidentified bugs to creep in; bugs, that I will do my best to slay, once identified! Thanks! llvm-svn: 191453
2013-09-27 03:54:12 +08:00
QualType TypeToReplaceAuto) {
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
if (TypeToReplaceAuto->isDependentType())
TypeToReplaceAuto = QualType();
[c++1z] P0091R3: Basic support for deducing class template arguments via deduction-guides. llvm-svn: 294613
2017-02-10 03:17:44 +08:00
return SubstituteDeducedTypeTransform(*this, TypeToReplaceAuto)
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
.TransformType(TypeWithAuto);
Implement a rudimentary form of generic lambdas. Specifically, the following features are not included in this commit: - any sort of capturing within generic lambdas - generic lambdas within template functions and nested within other generic lambdas - conversion operator for captureless lambdas - ensuring all visitors are generic lambda aware (Although I have gotten some useful feedback on my patches of the above and will be incorporating that as I submit those patches for commit) As an example of what compiles through this commit: template <class F1, class F2> struct overload : F1, F2 { using F1::operator(); using F2::operator(); overload(F1 f1, F2 f2) : F1(f1), F2(f2) { } }; auto Recursive = [](auto Self, auto h, auto ... rest) { return 1 + Self(Self, rest...); }; auto Base = [](auto Self, auto h) { return 1; }; overload<decltype(Base), decltype(Recursive)> O(Base, Recursive); int num_params = O(O, 5, 3, "abc", 3.14, 'a'); Please see attached tests for more examples. This patch has been reviewed by Doug and Richard. Minor changes (non-functionality affecting) have been made since both of them formally looked at it, but the changes involve removal of supernumerary return type deduction changes (since they are now redundant, with richard having committed a recent patch to address return type deduction for C++11 lambdas using C++14 semantics). Some implementation notes: - Add a new Declarator context => LambdaExprParameterContext to clang::Declarator to allow the use of 'auto' in declaring generic lambda parameters - Add various helpers to CXXRecordDecl to facilitate identifying and querying a closure class - LambdaScopeInfo (which maintains the current lambda's Sema state) was augmented to house the current depth of the template being parsed (id est the Parser calls Sema::RecordParsingTemplateParameterDepth) so that SemaType.cpp::ConvertDeclSpecToType may use it to immediately generate a template-parameter-type when 'auto' is parsed in a generic lambda parameter context. (i.e we do NOT use AutoType deduced to a template parameter type - Richard seemed ok with this approach). We encode that this template type was generated from an auto by simply adding $auto to the name which can be used for better diagnostics if needed. - SemaLambda.h was added to hold some common lambda utility functions (this file is likely to grow ...) - Teach Sema::ActOnStartOfFunctionDef to check whether it is being called to instantiate a generic lambda's call operator, and if so, push an appropriately prepared LambdaScopeInfo object on the stack. - various tests were added - but much more will be needed. There is obviously more work to be done, and both Richard (weakly) and Doug (strongly) have requested that LambdaExpr be removed form the CXXRecordDecl LambdaDefinitionaData in a future patch which is forthcoming. A greatful thanks to all reviewers including Eli Friedman, James Dennett, and especially the two gracious wizards (Richard Smith and Doug Gregor) who spent hours providing feedback (in person in Chicago and on the mailing lists). And yet I am certain that I have allowed unidentified bugs to creep in; bugs, that I will do my best to slay, once identified! Thanks! llvm-svn: 191453
2013-09-27 03:54:12 +08:00
}
[c++1z] P0091R3: Basic support for deducing class template arguments via deduction-guides. llvm-svn: 294613
2017-02-10 03:17:44 +08:00
TypeSourceInfo *Sema::SubstAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto,
QualType TypeToReplaceAuto) {
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
if (TypeToReplaceAuto->isDependentType())
TypeToReplaceAuto = QualType();
[c++1z] P0091R3: Basic support for deducing class template arguments via deduction-guides. llvm-svn: 294613
2017-02-10 03:17:44 +08:00
return SubstituteDeducedTypeTransform(*this, TypeToReplaceAuto)
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
.TransformType(TypeWithAuto);
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
}
PR31846: Don't replace 'auto' type with a template parameter type in a generic lambda until after we've checked whether 'auto' is valid in the current language mode. llvm-svn: 294078
2017-02-04 09:28:01 +08:00
QualType Sema::ReplaceAutoType(QualType TypeWithAuto,
QualType TypeToReplaceAuto) {
[c++1z] P0091R3: Basic support for deducing class template arguments via deduction-guides. llvm-svn: 294613
2017-02-10 03:17:44 +08:00
return SubstituteDeducedTypeTransform(*this, TypeToReplaceAuto,
/*UseTypeSugar*/ false)
PR31846: Don't replace 'auto' type with a template parameter type in a generic lambda until after we've checked whether 'auto' is valid in the current language mode. llvm-svn: 294078
2017-02-04 09:28:01 +08:00
.TransformType(TypeWithAuto);
}
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(),
Per latest drafting, switch to implementing init-captures as if by declaring and capturing a variable declaration, and complete the implementation of them. llvm-svn: 191605
2013-09-28 12:02:39 +08:00
VDecl->isInitCapture()
? diag::err_init_capture_deduction_failure_from_init_list
: diag::err_auto_var_deduction_failure_from_init_list)
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
<< VDecl->getDeclName() << VDecl->getType() << Init->getSourceRange();
else
Per latest drafting, switch to implementing init-captures as if by declaring and capturing a variable declaration, and complete the implementation of them. llvm-svn: 191605
2013-09-28 12:02:39 +08:00
Diag(VDecl->getLocation(),
VDecl->isInitCapture() ? diag::err_init_capture_deduction_failure
: diag::err_auto_var_deduction_failure)
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
<< 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) {
Rename getResultType() on function and method declarations to getReturnType() A return type is the declared or deduced part of the function type specified in the declaration. A result type is the (potentially adjusted) type of the value of an expression that calls the function. Rule of thumb: * Declarations have return types and parameters. * Expressions have result types and arguments. llvm-svn: 200082
2014-01-26 00:55:45 +08:00
assert(FD->getReturnType()->isUndeducedType());
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 (FD->getTemplateInstantiationPattern())
InstantiateFunctionDefinition(Loc, FD);
Rename getResultType() on function and method declarations to getReturnType() A return type is the declared or deduced part of the function type specified in the declaration. A result type is the (potentially adjusted) type of the value of an expression that calls the function. Rule of thumb: * Declarations have return types and parameters. * Expressions have result types and arguments. llvm-svn: 200082
2014-01-26 00:55:45 +08:00
bool StillUndeduced = FD->getReturnType()->isUndeducedType();
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 (StillUndeduced && Diagnose && !FD->isInvalidDecl()) {
Diag(Loc, diag::err_auto_fn_used_before_defined) << FD;
Diag(FD->getLocation(), diag::note_callee_decl) << FD;
}
return StillUndeduced;
}
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,
PR22435: Correctly implement tiebreaker for reference ordering in function template partial ordering rules. This rule applies per pair of types being compared, not per pair of function templates being compared. llvm-svn: 229965
2015-02-20 12:45:22 +08:00
unsigned NumCallArguments1) {
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);
PR17075: When performing partial ordering of a member function against a non-member function, the number of arguments in the two candidate calls will be different (the non-member call will have one extra argument). We used to get confused by this, and fail to compare the last argument when testing whether the member is better, resulting in us always thinking it is, even if the non-member is more specialized in the last argument. llvm-svn: 190470
2013-09-11 08:52:39 +08:00
SmallVector<QualType, 4> Args2;
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.
PR17075: When performing partial ordering of a member function against a non-member function, the number of arguments in the two candidate calls will be different (the non-member call will have one extra argument). We used to get confused by this, and fail to compare the last argument when testing whether the member is better, resulting in us always thinking it is, even if the non-member is more specialized in the last argument. llvm-svn: 190470
2013-09-11 08:52:39 +08:00
CXXMethodDecl *Method1 = dyn_cast<CXXMethodDecl>(FD1);
CXXMethodDecl *Method2 = dyn_cast<CXXMethodDecl>(FD2);
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
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.
//
PR12961 - Extend DR532 to cover C++98/03. llvm-svn: 209955
2014-05-31 10:10:59 +08:00
// C++98/03 doesn't have this provision but we've extended DR532 to cover
// it as wording was broken prior to it.
Revert r295277 to fix buildbot. llvm-svn: 295281
2017-02-16 12:22:56 +08:00
SmallVector<QualType, 4> Args1;
PR17075: When performing partial ordering of a member function against a non-member function, the number of arguments in the two candidate calls will be different (the non-member call will have one extra argument). We used to get confused by this, and fail to compare the last argument when testing whether the member is better, resulting in us always thinking it is, even if the non-member is more specialized in the last argument. llvm-svn: 190470
2013-09-11 08:52:39 +08:00
unsigned NumComparedArguments = NumCallArguments1;
if (!Method2 && Method1 && !Method1->isStatic()) {
PR12961 - Extend DR532 to cover C++98/03. llvm-svn: 209955
2014-05-31 10:10:59 +08:00
// Compare 'this' from Method1 against first parameter from Method2.
AddImplicitObjectParameterType(S.Context, Method1, Args1);
++NumComparedArguments;
PR17075: When performing partial ordering of a member function against a non-member function, the number of arguments in the two candidate calls will be different (the non-member call will have one extra argument). We used to get confused by this, and fail to compare the last argument when testing whether the member is better, resulting in us always thinking it is, even if the non-member is more specialized in the last argument. llvm-svn: 190470
2013-09-11 08:52:39 +08:00
} else if (!Method1 && Method2 && !Method2->isStatic()) {
PR12961 - Extend DR532 to cover C++98/03. llvm-svn: 209955
2014-05-31 10:10:59 +08:00
// Compare 'this' from Method2 against first parameter from Method1.
AddImplicitObjectParameterType(S.Context, Method2, Args2);
PR17075: When performing partial ordering of a member function against a non-member function, the number of arguments in the two candidate calls will be different (the non-member call will have one extra argument). We used to get confused by this, and fail to compare the last argument when testing whether the member is better, resulting in us always thinking it is, even if the non-member is more specialized in the last argument. llvm-svn: 190470
2013-09-11 08:52:39 +08:00
}
PR12961 - Extend DR532 to cover C++98/03. llvm-svn: 209955
2014-05-31 10:10:59 +08:00
Args1.insert(Args1.end(), Proto1->param_type_begin(),
Rename FunctionProtoType accessors from 'arguments' to 'parameters' Fix a perennial source of confusion in the clang type system: Declarations and function prototypes have parameters to which arguments are supplied, so calling these 'arguments' was a stretch even in C mode, let alone C++ where default arguments, templates and overloading make the distinction important to get right. Readability win across the board, especially in the casting, ADL and overloading implementations which make a lot more sense at a glance now. Will keep an eye on the builders and update dependent projects shortly. No functional change. llvm-svn: 199686
2014-01-21 04:26:09 +08:00
Proto1->param_type_end());
PR12961 - Extend DR532 to cover C++98/03. llvm-svn: 209955
2014-05-31 10:10:59 +08:00
Args2.insert(Args2.end(), Proto2->param_type_begin(),
Rename FunctionProtoType accessors from 'arguments' to 'parameters' Fix a perennial source of confusion in the clang type system: Declarations and function prototypes have parameters to which arguments are supplied, so calling these 'arguments' was a stretch even in C mode, let alone C++ where default arguments, templates and overloading make the distinction important to get right. Readability win across the board, especially in the casting, ADL and overloading implementations which make a lot more sense at a glance now. Will keep an eye on the builders and update dependent projects shortly. No functional change. llvm-svn: 199686
2014-01-21 04:26:09 +08:00
Proto2->param_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.
PR17075: When performing partial ordering of a member function against a non-member function, the number of arguments in the two candidate calls will be different (the non-member call will have one extra argument). We used to get confused by this, and fail to compare the last argument when testing whether the member is better, resulting in us always thinking it is, even if the non-member is more specialized in the last argument. llvm-svn: 190470
2013-09-11 08:52:39 +08:00
if (Args1.size() > NumComparedArguments)
Args1.resize(NumComparedArguments);
if (Args2.size() > NumComparedArguments)
Args2.resize(NumComparedArguments);
Revert r295277 to fix buildbot. llvm-svn: 295281
2017-02-16 12:22:56 +08:00
if (DeduceTemplateArguments(S, TemplateParams, Args2.data(), Args2.size(),
Args1.data(), Args1.size(), Info, Deduced,
TDF_None, /*PartialOrdering=*/true))
return false;
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.
Revert r295277 to fix buildbot. llvm-svn: 295281
2017-02-16 12:22:56 +08:00
if (DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, Proto2->getReturnType(), Proto1->getReturnType(),
Info, Deduced, TDF_None,
/*PartialOrdering=*/true))
return false;
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:
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.
Revert r295277 to fix buildbot. llvm-svn: 295281
2017-02-16 12:22:56 +08:00
if (DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
FD2->getType(), FD1->getType(),
Info, Deduced, TDF_None,
/*PartialOrdering=*/true))
return false;
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
// 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;
Revert r295277 to fix buildbot. llvm-svn: 295281
2017-02-16 12:22:56 +08:00
// FIXME: We fail to implement [temp.deduct.type]p1 along this path. We need
// to substitute the deduced arguments back into the template and check that
// we get the right type.
Add missing "deduced A == A" check for function template partial ordering. This appears to be the only template argument deduction context where we were missing this check. Surprisingly, other implementations also appear to miss the check in this case; it may turn out that important code is relying on the widespread non-conformance here, in which case we'll need to reconsider. llvm-svn: 295277
2017-02-16 11:49:44 +08:00
Revert r295277 to fix buildbot. llvm-svn: 295281
2017-02-16 12:22:56 +08:00
if (ArgIdx == NumArgs) {
// All template arguments were deduced. FT1 is at least as specialized
// as FT2.
return true;
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +08:00
}
Revert r295277 to fix buildbot. llvm-svn: 295281
2017-02-16 12:22:56 +08:00
// Figure out which template parameters were used.
llvm::SmallBitVector UsedParameters(TemplateParams->size());
switch (TPOC) {
case TPOC_Call:
for (unsigned I = 0, N = Args2.size(); I != N; ++I)
::MarkUsedTemplateParameters(S.Context, Args2[I], false,
TemplateParams->getDepth(),
UsedParameters);
break;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Revert r295277 to fix buildbot. llvm-svn: 295281
2017-02-16 12:22:56 +08:00
case TPOC_Conversion:
::MarkUsedTemplateParameters(S.Context, Proto2->getReturnType(), false,
TemplateParams->getDepth(), UsedParameters);
break;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Revert r295277 to fix buildbot. llvm-svn: 295281
2017-02-16 12:22:56 +08:00
case TPOC_Other:
::MarkUsedTemplateParameters(S.Context, FD2->getType(), false,
TemplateParams->getDepth(),
UsedParameters);
break;
}
Add missing "deduced A == A" check for function template partial ordering. This appears to be the only template argument deduction context where we were missing this check. Surprisingly, other implementations also appear to miss the check in this case; it may turn out that important code is relying on the widespread non-conformance here, in which case we'll need to reconsider. llvm-svn: 295277
2017-02-16 11:49:44 +08:00
Revert r295277 to fix buildbot. llvm-svn: 295281
2017-02-16 12:22:56 +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])
Add missing "deduced A == A" check for function template partial ordering. This appears to be the only template argument deduction context where we were missing this check. Surprisingly, other implementations also appear to miss the check in this case; it may turn out that important code is relying on the widespread non-conformance here, in which case we'll need to reconsider. llvm-svn: 295277
2017-02-16 11:49:44 +08:00
return false;
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
///
PR17075: When performing partial ordering of a member function against a non-member function, the number of arguments in the two candidate calls will be different (the non-member call will have one extra argument). We used to get confused by this, and fail to compare the last argument when testing whether the member is better, resulting in us always thinking it is, even if the non-member is more specialized in the last argument. llvm-svn: 190470
2013-09-11 08:52:39 +08:00
/// \param NumCallArguments1 The number of arguments in the call to FT1, used
/// only when \c TPOC is \c TPOC_Call.
///
/// \param NumCallArguments2 The number of arguments in the call to FT2, used
/// only when \c TPOC is \c TPOC_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
///
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,
PR17075: When performing partial ordering of a member function against a non-member function, the number of arguments in the two candidate calls will be different (the non-member call will have one extra argument). We used to get confused by this, and fail to compare the last argument when testing whether the member is better, resulting in us always thinking it is, even if the non-member is more specialized in the last argument. llvm-svn: 190470
2013-09-11 08:52:39 +08:00
unsigned NumCallArguments1,
unsigned NumCallArguments2) {
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
bool Better1 = isAtLeastAsSpecializedAs(*this, Loc, FT1, FT2, TPOC,
PR22435: Correctly implement tiebreaker for reference ordering in function template partial ordering rules. This rule applies per pair of types being compared, not per pair of function templates being compared. llvm-svn: 229965
2015-02-20 12:45:22 +08:00
NumCallArguments1);
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
bool Better2 = isAtLeastAsSpecializedAs(*this, Loc, FT2, FT1, TPOC,
PR22435: Correctly implement tiebreaker for reference ordering in function template partial ordering rules. This rule applies per pair of types being compared, not per pair of function templates being compared. llvm-svn: 229965
2015-02-20 12:45:22 +08:00
NumCallArguments2);
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
PR22435: Correctly implement tiebreaker for reference ordering in function template partial ordering rules. This rule applies per pair of types being compared, not per pair of function templates being compared. llvm-svn: 229965
2015-02-20 12:45:22 +08:00
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
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
return nullptr;
Implement partial ordering of function template specializations (C++ [temp.func.order]). llvm-svn: 81777
2009-09-15 02:39:43 +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
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
return nullptr;
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
///
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,
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,
PR17075: When performing partial ordering of a member function against a non-member function, the number of arguments in the two candidate calls will be different (the non-member call will have one extra argument). We used to get confused by this, and fail to compare the last argument when testing whether the member is better, resulting in us always thinking it is, even if the non-member is more specialized in the last argument. llvm-svn: 190470
2013-09-11 08:52:39 +08:00
Loc, TPOC_Other, 0, 0),
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,
PR17075: When performing partial ordering of a member function against a non-member function, the number of arguments in the two candidate calls will be different (the non-member call will have one extra argument). We used to get confused by this, and fail to compare the last argument when testing whether the member is better, resulting in us always thinking it is, even if the non-member is more specialized in the last argument. llvm-svn: 190470
2013-09-11 08:52:39 +08:00
Loc, TPOC_Other, 0, 0),
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;
Sema: print qualified name for overload candidates Print the fully qualified names for the overload candidates. This makes it easier to tell what the ambiguity is. Especially if a template is instantiated after a using namespace, it will not inherit the namespace where it was declared. The specialization will give a message about a partial order being ambiguous for the same (unqualified) name, which does not help identify the failure. Addresses PR31450! llvm-svn: 290315
2016-12-22 12:26:57 +08:00
const auto *FD = cast<FunctionDecl>(*I);
PD << FD << getTemplateArgumentBindingsText(
FD->getPrimaryTemplate()->getTemplateParameters(),
*FD->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())
Sema: print qualified name for overload candidates Print the fully qualified names for the overload candidates. This makes it easier to tell what the ambiguity is. Especially if a template is instantiated after a using namespace, it will not inherit the namespace where it was declared. The specialization will give a message about a partial order being ambiguous for the same (unqualified) name, which does not help identify the failure. Addresses PR31450! llvm-svn: 290315
2016-12-22 12:26:57 +08:00
HandleFunctionTypeMismatch(PD, FD->getType(), TargetType);
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
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
}
Factor out duplication between partial ordering for class template partial specializations and variable template partial specializations. llvm-svn: 290497
2016-12-25 00:40:51 +08:00
/// Determine whether one partial specialization, P1, is at least as
/// specialized than another, P2.
Implement partial ordering of class template partial specializations (C++ [temp.class.order]). llvm-svn: 81866
2009-09-16 00:23:51 +08:00
///
[c++17] Implement P0522R0 as written. This allows a template template argument to be specified for a template template parameter whenever the parameter is at least as specialized as the argument (when there's an obvious and correct mapping from uses of the parameter to uses of the argument). For example, a template with more parameters can be passed to a template template parameter with fewer, if those trailing parameters have default arguments. This is disabled by default, despite being a DR resolution, as it's fairly broken in its current state: there are no partial ordering rules to cope with template template parameters that have different parameter lists, meaning that code that attempts to decompose template-ids based on arity can hit unavoidable ambiguity issues. The diagnostics produced on a non-matching argument are also pretty bad right now, but I aim to improve them in a subsequent commit. llvm-svn: 290792
2017-01-01 05:41:23 +08:00
/// \tparam TemplateLikeDecl The kind of P2, which must be a
/// TemplateDecl or {Class,Var}TemplatePartialSpecializationDecl.
Factor out duplication between partial ordering for class template partial specializations and variable template partial specializations. llvm-svn: 290497
2016-12-25 00:40:51 +08:00
/// \param T1 The injected-class-name of P1 (faked for a variable template).
/// \param T2 The injected-class-name of P2 (faked for a variable template).
[c++17] Implement P0522R0 as written. This allows a template template argument to be specified for a template template parameter whenever the parameter is at least as specialized as the argument (when there's an obvious and correct mapping from uses of the parameter to uses of the argument). For example, a template with more parameters can be passed to a template template parameter with fewer, if those trailing parameters have default arguments. This is disabled by default, despite being a DR resolution, as it's fairly broken in its current state: there are no partial ordering rules to cope with template template parameters that have different parameter lists, meaning that code that attempts to decompose template-ids based on arity can hit unavoidable ambiguity issues. The diagnostics produced on a non-matching argument are also pretty bad right now, but I aim to improve them in a subsequent commit. llvm-svn: 290792
2017-01-01 05:41:23 +08:00
template<typename TemplateLikeDecl>
Factor out duplication between partial ordering for class template partial specializations and variable template partial specializations. llvm-svn: 290497
2016-12-25 00:40:51 +08:00
static bool isAtLeastAsSpecializedAs(Sema &S, QualType T1, QualType T2,
[c++17] Implement P0522R0 as written. This allows a template template argument to be specified for a template template parameter whenever the parameter is at least as specialized as the argument (when there's an obvious and correct mapping from uses of the parameter to uses of the argument). For example, a template with more parameters can be passed to a template template parameter with fewer, if those trailing parameters have default arguments. This is disabled by default, despite being a DR resolution, as it's fairly broken in its current state: there are no partial ordering rules to cope with template template parameters that have different parameter lists, meaning that code that attempts to decompose template-ids based on arity can hit unavoidable ambiguity issues. The diagnostics produced on a non-matching argument are also pretty bad right now, but I aim to improve them in a subsequent commit. llvm-svn: 290792
2017-01-01 05:41:23 +08:00
TemplateLikeDecl *P2,
DR1495: A partial specialization is ill-formed if it is not (strictly) more specialized than the primary template. (Put another way, if we imagine there were a partial specialization matching the primary template, we should never select it if some other partial specialization also matches.) llvm-svn: 290593
2016-12-27 15:56:27 +08:00
TemplateDeductionInfo &Info) {
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;
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
Factor out duplication between partial ordering for class template partial specializations and variable template partial specializations. llvm-svn: 290497
2016-12-25 00:40:51 +08:00
// Determine whether P1 is at least as specialized as P2.
Deduced.resize(P2->getTemplateParameters()->size());
if (DeduceTemplateArgumentsByTypeMatch(S, P2->getTemplateParameters(),
T2, T1, Info, Deduced, TDF_None,
/*PartialOrdering=*/true))
return false;
SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),
Deduced.end());
DR1495: A partial specialization is ill-formed if it is not (strictly) more specialized than the primary template. (Put another way, if we imagine there were a partial specialization matching the primary template, we should never select it if some other partial specialization also matches.) llvm-svn: 290593
2016-12-27 15:56:27 +08:00
Sema::InstantiatingTemplate Inst(S, Info.getLocation(), P2, DeducedArgs,
Info);
Factor out duplication between partial ordering for class template partial specializations and variable template partial specializations. llvm-svn: 290497
2016-12-25 00:40:51 +08:00
auto *TST1 = T1->castAs<TemplateSpecializationType>();
if (FinishTemplateArgumentDeduction(
Fix some subtle wrong partial ordering bugs particularly with C++1z auto-typed non-type template parameters. During partial ordering, when checking the substituted deduced template arguments match the original, check the types of non-type template arguments match even if they're dependent. The only way we get dependent types here is if they really represent types of the other template (which are supposed to be modeled as being substituted for unique, non-dependent types). In order to make this work for auto-typed non-type template arguments, we need to be able to perform auto deduction even when the initializer and (potentially) the auto type are dependent, support for which is the bulk of this patch. (Note that this requires the ability to deduce only a single level of a multi-level dependent type.) llvm-svn: 290511
2016-12-25 16:05:23 +08:00
S, P2, /*PartialOrdering=*/true,
TemplateArgumentList(TemplateArgumentList::OnStack,
TST1->template_arguments()),
Factor out duplication between partial ordering for class template partial specializations and variable template partial specializations. llvm-svn: 290497
2016-12-25 00:40:51 +08:00
Deduced, Info))
return false;
return true;
}
/// \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,
ClassTemplatePartialSpecializationDecl *PS2,
SourceLocation 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
DR1495: A partial specialization is ill-formed if it is not (strictly) more specialized than the primary template. (Put another way, if we imagine there were a partial specialization matching the primary template, we should never select it if some other partial specialization also matches.) llvm-svn: 290593
2016-12-27 15:56:27 +08:00
TemplateDeductionInfo Info(Loc);
bool Better1 = isAtLeastAsSpecializedAs(*this, PT1, PT2, PS2, Info);
bool Better2 = isAtLeastAsSpecializedAs(*this, PT2, PT1, PS1, Info);
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
if (Better1 == Better2)
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
return nullptr;
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
return Better1 ? PS1 : PS2;
}
DR1495: A partial specialization is ill-formed if it is not (strictly) more specialized than the primary template. (Put another way, if we imagine there were a partial specialization matching the primary template, we should never select it if some other partial specialization also matches.) llvm-svn: 290593
2016-12-27 15:56:27 +08:00
bool Sema::isMoreSpecializedThanPrimary(
ClassTemplatePartialSpecializationDecl *Spec, TemplateDeductionInfo &Info) {
ClassTemplateDecl *Primary = Spec->getSpecializedTemplate();
QualType PrimaryT = Primary->getInjectedClassNameSpecialization();
QualType PartialT = Spec->getInjectedSpecializationType();
if (!isAtLeastAsSpecializedAs(*this, PartialT, PrimaryT, Primary, Info))
return false;
if (isAtLeastAsSpecializedAs(*this, PrimaryT, PartialT, Spec, Info)) {
Info.clearSFINAEDiagnostic();
return false;
}
return true;
}
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
VarTemplatePartialSpecializationDecl *
Sema::getMoreSpecializedPartialSpecialization(
VarTemplatePartialSpecializationDecl *PS1,
VarTemplatePartialSpecializationDecl *PS2, SourceLocation Loc) {
Factor out duplication between partial ordering for class template partial specializations and variable template partial specializations. llvm-svn: 290497
2016-12-25 00:40:51 +08:00
// Pretend the variable template specializations are class template
// specializations and form a fake injected class name type for comparison.
PR18229: Fix typo in assert condition. llvm-svn: 197185
2013-12-13 07:14:16 +08:00
assert(PS1->getSpecializedTemplate() == PS2->getSpecializedTemplate() &&
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
"the partial specializations being compared should specialize"
" the same template.");
TemplateName Name(PS1->getSpecializedTemplate());
TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
QualType PT1 = Context.getTemplateSpecializationType(
[AST] Use ArrayRef in more interfaces ArrayRef is a little better than passing around a pointer/length pair. No functional change is intended. llvm-svn: 274732
2016-07-07 12:43:07 +08:00
CanonTemplate, PS1->getTemplateArgs().asArray());
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
QualType PT2 = Context.getTemplateSpecializationType(
[AST] Use ArrayRef in more interfaces ArrayRef is a little better than passing around a pointer/length pair. No functional change is intended. llvm-svn: 274732
2016-07-07 12:43:07 +08:00
CanonTemplate, PS2->getTemplateArgs().asArray());
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
DR1495: A partial specialization is ill-formed if it is not (strictly) more specialized than the primary template. (Put another way, if we imagine there were a partial specialization matching the primary template, we should never select it if some other partial specialization also matches.) llvm-svn: 290593
2016-12-27 15:56:27 +08:00
TemplateDeductionInfo Info(Loc);
bool Better1 = isAtLeastAsSpecializedAs(*this, PT1, PT2, PS2, Info);
bool Better2 = isAtLeastAsSpecializedAs(*this, PT2, PT1, PS1, Info);
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)
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
return nullptr;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Factor out duplication between partial ordering for class template partial specializations and variable template partial specializations. llvm-svn: 290497
2016-12-25 00:40:51 +08:00
return Better1 ? PS1 : PS2;
Implement partial ordering of class template partial specializations (C++ [temp.class.order]). llvm-svn: 81866
2009-09-16 00:23:51 +08:00
}
DR1495: A partial specialization is ill-formed if it is not (strictly) more specialized than the primary template. (Put another way, if we imagine there were a partial specialization matching the primary template, we should never select it if some other partial specialization also matches.) llvm-svn: 290593
2016-12-27 15:56:27 +08:00
bool Sema::isMoreSpecializedThanPrimary(
VarTemplatePartialSpecializationDecl *Spec, TemplateDeductionInfo &Info) {
TemplateDecl *Primary = Spec->getSpecializedTemplate();
// FIXME: Cache the injected template arguments rather than recomputing
// them for each partial specialization.
SmallVector<TemplateArgument, 8> PrimaryArgs;
Context.getInjectedTemplateArgs(Primary->getTemplateParameters(),
PrimaryArgs);
TemplateName CanonTemplate =
Context.getCanonicalTemplateName(TemplateName(Primary));
QualType PrimaryT = Context.getTemplateSpecializationType(
CanonTemplate, PrimaryArgs);
QualType PartialT = Context.getTemplateSpecializationType(
CanonTemplate, Spec->getTemplateArgs().asArray());
if (!isAtLeastAsSpecializedAs(*this, PartialT, PrimaryT, Primary, Info))
return false;
if (isAtLeastAsSpecializedAs(*this, PrimaryT, PartialT, Spec, Info)) {
Info.clearSFINAEDiagnostic();
return false;
}
return true;
}
[c++17] Implement P0522R0 as written. This allows a template template argument to be specified for a template template parameter whenever the parameter is at least as specialized as the argument (when there's an obvious and correct mapping from uses of the parameter to uses of the argument). For example, a template with more parameters can be passed to a template template parameter with fewer, if those trailing parameters have default arguments. This is disabled by default, despite being a DR resolution, as it's fairly broken in its current state: there are no partial ordering rules to cope with template template parameters that have different parameter lists, meaning that code that attempts to decompose template-ids based on arity can hit unavoidable ambiguity issues. The diagnostics produced on a non-matching argument are also pretty bad right now, but I aim to improve them in a subsequent commit. llvm-svn: 290792
2017-01-01 05:41:23 +08:00
bool Sema::isTemplateTemplateParameterAtLeastAsSpecializedAs(
TemplateParameterList *P, TemplateDecl *AArg, SourceLocation Loc) {
// C++1z [temp.arg.template]p4: (DR 150)
// A template template-parameter P is at least as specialized as a
// template template-argument A if, given the following rewrite to two
// function templates...
// Rather than synthesize function templates, we merely perform the
// equivalent partial ordering by performing deduction directly on
// the template parameter lists of the template template parameters.
//
// Given an invented class template X with the template parameter list of
// A (including default arguments):
TemplateName X = Context.getCanonicalTemplateName(TemplateName(AArg));
TemplateParameterList *A = AArg->getTemplateParameters();
// - Each function template has a single function parameter whose type is
// a specialization of X with template arguments corresponding to the
// template parameters from the respective function template
SmallVector<TemplateArgument, 8> AArgs;
Context.getInjectedTemplateArgs(A, AArgs);
// Check P's arguments against A's parameter list. This will fill in default
// template arguments as needed. AArgs are already correct by construction.
// We can't just use CheckTemplateIdType because that will expand alias
// templates.
SmallVector<TemplateArgument, 4> PArgs;
{
SFINAETrap Trap(*this);
Context.getInjectedTemplateArgs(P, PArgs);
TemplateArgumentListInfo PArgList(P->getLAngleLoc(), P->getRAngleLoc());
for (unsigned I = 0, N = P->size(); I != N; ++I) {
// Unwrap packs that getInjectedTemplateArgs wrapped around pack
// expansions, to form an "as written" argument list.
TemplateArgument Arg = PArgs[I];
if (Arg.getKind() == TemplateArgument::Pack) {
assert(Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion());
Arg = *Arg.pack_begin();
}
PArgList.addArgument(getTrivialTemplateArgumentLoc(
Arg, QualType(), P->getParam(I)->getLocation()));
}
PArgs.clear();
// C++1z [temp.arg.template]p3:
// If the rewrite produces an invalid type, then P is not at least as
// specialized as A.
if (CheckTemplateArgumentList(AArg, Loc, PArgList, false, PArgs) ||
Trap.hasErrorOccurred())
return false;
}
QualType AType = Context.getTemplateSpecializationType(X, AArgs);
QualType PType = Context.getTemplateSpecializationType(X, PArgs);
// ... the function template corresponding to P is at least as specialized
// as the function template corresponding to A according to the partial
// ordering rules for function templates.
TemplateDeductionInfo Info(Loc, A->getDepth());
return isAtLeastAsSpecializedAs(*this, PType, AType, AArg, Info);
}
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;
P0127R2: Support type deduction for types of non-type template parameters in C++1z. Patch by James Touton! Some bugfixes and rebasing by me. llvm-svn: 282651
2016-09-29 07:55:27 +08:00
// In C++1z mode, additional arguments may be deduced from the type of a
// non-type argument.
if (Ctx.getLangOpts().CPlusPlus1z)
MarkUsedTemplateParameters(Ctx, NTTP->getType(), 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
}
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
Added LLVM_FALLTHROUGH to address warning: this statement may fall through. NFC. llvm-svn: 304651
2017-06-03 14:35:06 +08:00
LLVM_FALLTHROUGH;
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::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);
Rename getResultType() on function and method declarations to getReturnType() A return type is the declared or deduced part of the function type specified in the declaration. A result type is the (potentially adjusted) type of the value of an expression that calls the function. Rule of thumb: * Declarations have return types and parameters. * Expressions have result types and arguments. llvm-svn: 200082
2014-01-26 00:55:45 +08:00
MarkUsedTemplateParameters(Ctx, Proto->getReturnType(), OnlyDeduced, Depth,
Used);
Rename FunctionProtoType accessors from 'arguments' to 'parameters' Fix a perennial source of confusion in the clang type system: Declarations and function prototypes have parameters to which arguments are supplied, so calling these 'arguments' was a stretch even in C mode, let alone C++ where default arguments, templates and overloading make the distinction important to get right. Readability win across the board, especially in the casting, ADL and overloading implementations which make a lot more sense at a glance now. Will keep an eye on the builders and update dependent projects shortly. No functional change. llvm-svn: 199686
2014-01-21 04:26:09 +08:00
for (unsigned I = 0, N = Proto->getNumParams(); I != N; ++I)
MarkUsedTemplateParameters(Ctx, Proto->getParamType(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);
[c++1z] Support deducing B in noexcept(B). This is not required by the standard (yet), but there seems to be reasonable support for this being a defect according to CWG discussion, and libstdc++ 7.1 relies on it working. llvm-svn: 304946
2017-06-08 05:46:22 +08:00
if (auto *E = Proto->getNoexceptExpr())
MarkUsedTemplateParameters(Ctx, E, 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;
}
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:
Wrap to 80 columns. No behavior change. llvm-svn: 214059
2014-07-28 08:02:09 +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 &&
ArrayRefize lists of TemplateArguments in template argument deduction. llvm-svn: 290461
2016-12-24 07:46:56 +08:00
hasPackExpansionBeforeEnd(Spec->template_arguments()))
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
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: {
Implement [temp.deduct.type]p6: if the nested-name-specifier of a type is dependent, the type is a non-deduced context. llvm-svn: 256651
2015-12-31 04:56:05 +08:00
// C++14 [temp.deduct.type]p5:
// The non-deduced contexts are:
// -- The nested-name-specifier of a type that was specified using a
// qualified-id
//
// C++14 [temp.deduct.type]p6:
// When a type name is specified in a way that includes a non-deduced
// context, all of the types that comprise that type name are also
// non-deduced.
if (OnlyDeduced)
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
const DependentTemplateSpecializationType *Spec
= cast<DependentTemplateSpecializationType>(T);
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Implement [temp.deduct.type]p6: if the nested-name-specifier of a type is dependent, the type is a non-deduced context. llvm-svn: 256651
2015-12-31 04:56:05 +08:00
MarkUsedTemplateParameters(Ctx, Spec->getQualifier(),
OnlyDeduced, Depth, 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
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,
P0127R2: Support type deduction for types of non-type template parameters in C++1z. Patch by James Touton! Some bugfixes and rebasing by me. llvm-svn: 282651
2016-09-29 07:55:27 +08:00
cast<UnaryTransformType>(T)->getUnderlyingType(),
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
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:
PR0091R3: Implement parsing support for using templates as types. This change adds a new type node, DeducedTemplateSpecializationType, to represent a type template name that has been used as a type. This is modeled around AutoType, and shares a common base class for representing a deduced placeholder type. We allow deduced class template types in a few more places than the standard does: in conditions and for-range-declarators, and in new-type-ids. This is consistent with GCC and with discussion on the core reflector. This patch does not yet support deduced class template types being named in typename specifiers. llvm-svn: 293207
2017-01-27 04:40:47 +08:00
case Type::DeducedTemplateSpecialization:
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,
PR0091R3: Implement parsing support for using templates as types. This change adds a new type node, DeducedTemplateSpecializationType, to represent a type template name that has been used as a type. This is modeled around AutoType, and shares a common base class for representing a deduced placeholder type. We allow deduced class template types in a few more places than the standard does: in conditions and for-range-declarators, and in new-type-ids. This is consistent with GCC and with discussion on the core reflector. This patch does not yet support deduced class template types being named in typename specifiers. llvm-svn: 293207
2017-01-27 04:40:47 +08:00
cast<DeducedType>(T)->getDeducedType(),
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
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:
[OpenCL] Pipe type support Summary: Support for OpenCL 2.0 pipe type. This is a bug-fix version for bader's patch reviews.llvm.org/D14441 Reviewers: pekka.jaaskelainen, Anastasia Subscribers: bader, Anastasia, cfe-commits Differential Revision: http://reviews.llvm.org/D15603 llvm-svn: 257254
2016-01-09 20:53:17 +08:00
case Type::Pipe:
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:
Added the pack_elements range accessor. Refactoring some for loops to use range-based for loops instead. No functional changes intended. llvm-svn: 213095
2014-07-16 05:32:31 +08:00
for (const auto &P : TemplateArg.pack_elements())
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 &&
ArrayRefize lists of TemplateArguments in template argument deduction. llvm-svn: 290461
2016-12-24 07:46:56 +08:00
hasPackExpansionBeforeEnd(TemplateArgs.asArray()))
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;
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.
Wrap to 80 columns. No behavior change. llvm-svn: 214059
2014-07-28 08:02:09 +08:00
void Sema::MarkDeducedTemplateParameters(
ASTContext &Ctx, const FunctionTemplateDecl *FunctionTemplate,
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
Revert r295277 to fix buildbot. llvm-svn: 295281
2017-02-16 12:22:56 +08:00
bool hasDeducibleTemplateParameters(Sema &S,
FunctionTemplateDecl *FunctionTemplate,
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 T) {
if (!T->isDependentType())
return false;
Revert r295277 to fix buildbot. llvm-svn: 295281
2017-02-16 12:22:56 +08:00
TemplateParameterList *TemplateParams
= FunctionTemplate->getTemplateParameters();
llvm::SmallBitVector Deduced(TemplateParams->size());
::MarkUsedTemplateParameters(S.Context, T, true, TemplateParams->getDepth(),
Deduced);
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
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
}