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.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===/
|
|
|
|
|
2010-08-25 13:32:35 +08:00
|
|
|
#include "clang/Sema/TemplateDeduction.h"
|
2012-12-04 17:13:33 +08:00
|
|
|
#include "TreeTransform.h"
|
2009-06-04 08:03:07 +08:00
|
|
|
#include "clang/AST/ASTContext.h"
|
2013-09-29 16:45:24 +08:00
|
|
|
#include "clang/AST/ASTLambda.h"
|
2010-08-24 15:21:54 +08:00
|
|
|
#include "clang/AST/DeclObjC.h"
|
2009-06-04 08:03:07 +08:00
|
|
|
#include "clang/AST/DeclTemplate.h"
|
|
|
|
#include "clang/AST/Expr.h"
|
|
|
|
#include "clang/AST/ExprCXX.h"
|
2012-12-04 17:13:33 +08:00
|
|
|
#include "clang/AST/StmtVisitor.h"
|
|
|
|
#include "clang/Sema/DeclSpec.h"
|
|
|
|
#include "clang/Sema/Sema.h"
|
|
|
|
#include "clang/Sema/Template.h"
|
2012-01-31 00:17:39 +08:00
|
|
|
#include "llvm/ADT/SmallBitVector.h"
|
2009-09-15 02:39:43 +08:00
|
|
|
#include <algorithm>
|
2009-06-27 07:10:12 +08:00
|
|
|
|
|
|
|
namespace clang {
|
2010-08-25 13:32:35 +08:00
|
|
|
using namespace sema;
|
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
|
2009-06-27 07:27:24 +08:00
|
|
|
/// deduction from a template-id of a derived class of the argument type.
|
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.
|
2011-01-26 01:19:08 +08:00
|
|
|
TDF_SkipNonDependent = 0x08,
|
|
|
|
/// \brief Whether we are performing template argument deduction for
|
2011-01-27 15:10:08 +08:00
|
|
|
/// parameters and arguments in a top-level template argument
|
2013-04-17 16:45:07 +08:00
|
|
|
TDF_TopLevelParameterTypeList = 0x10,
|
|
|
|
/// \brief Within template argument deduction from overload resolution per
|
|
|
|
/// C++ [over.over] allow matching function types that are compatible in
|
|
|
|
/// terms of noreturn and default calling convention adjustments.
|
|
|
|
TDF_InOverloadResolution = 0x20
|
2009-06-27 07:10:12 +08:00
|
|
|
};
|
2015-06-23 07:07:51 +08:00
|
|
|
}
|
2009-06-27 07:10:12 +08:00
|
|
|
|
2009-06-04 08:03:07 +08:00
|
|
|
using namespace clang;
|
|
|
|
|
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())
|
2010-12-07 16:25:34 +08:00
|
|
|
X = X.extend(Y.getBitWidth());
|
2010-03-26 13:50:28 +08:00
|
|
|
else if (Y.getBitWidth() < X.getBitWidth())
|
2010-12-07 16:25:34 +08:00
|
|
|
Y = Y.extend(X.getBitWidth());
|
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;
|
|
|
|
}
|
|
|
|
|
2009-06-13 02:26:56 +08:00
|
|
|
static Sema::TemplateDeductionResult
|
2010-02-08 05:33:28 +08:00
|
|
|
DeduceTemplateArguments(Sema &S,
|
2009-06-13 02:26:56 +08:00
|
|
|
TemplateParameterList *TemplateParams,
|
|
|
|
const TemplateArgument &Param,
|
2011-01-12 06:21:24 +08:00
|
|
|
TemplateArgument Arg,
|
2010-08-25 13:32:35 +08:00
|
|
|
TemplateDeductionInfo &Info,
|
2013-07-08 12:13:06 +08:00
|
|
|
SmallVectorImpl<DeducedTemplateArgument> &Deduced);
|
2009-06-10 00:35:58 +08:00
|
|
|
|
2011-01-06 07:12:31 +08:00
|
|
|
static Sema::TemplateDeductionResult
|
2012-01-18 06:49:52 +08:00
|
|
|
DeduceTemplateArgumentsByTypeMatch(Sema &S,
|
|
|
|
TemplateParameterList *TemplateParams,
|
|
|
|
QualType Param,
|
|
|
|
QualType Arg,
|
|
|
|
TemplateDeductionInfo &Info,
|
|
|
|
SmallVectorImpl<DeducedTemplateArgument> &
|
|
|
|
Deduced,
|
|
|
|
unsigned TDF,
|
2016-09-29 07:55:27 +08:00
|
|
|
bool PartialOrdering = false,
|
|
|
|
bool DeducedFromArrayBound = false);
|
2011-01-06 07:12:31 +08:00
|
|
|
|
2010-12-23 02:17:10 +08:00
|
|
|
static Sema::TemplateDeductionResult
|
2016-06-29 07:05:09 +08:00
|
|
|
DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
|
2010-12-23 02:17:10 +08:00
|
|
|
const TemplateArgument *Params, unsigned NumParams,
|
|
|
|
const TemplateArgument *Args, unsigned NumArgs,
|
|
|
|
TemplateDeductionInfo &Info,
|
2016-06-29 07:05:09 +08:00
|
|
|
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
|
|
|
|
bool NumberOfArgumentsMustMatch);
|
2010-12-23 02:17:10 +08:00
|
|
|
|
2009-06-05 08:53:49 +08:00
|
|
|
/// \brief If the given expression is of a form that permits the deduction
|
|
|
|
/// of a non-type template parameter, return the declaration of that
|
|
|
|
/// non-type template parameter.
|
|
|
|
static NonTypeTemplateParmDecl *getDeducedParameterFromExpr(Expr *E) {
|
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;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-05 08:53:49 +08:00
|
|
|
if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
|
|
|
|
return dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl());
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2014-05-26 14:22:03 +08:00
|
|
|
return nullptr;
|
2009-06-05 08:53:49 +08:00
|
|
|
}
|
|
|
|
|
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();
|
2011-01-27 15:10:08 +08:00
|
|
|
|
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.
|
2011-01-27 15:10:08 +08:00
|
|
|
static DeducedTemplateArgument
|
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())
|
2011-01-27 15:10:08 +08:00
|
|
|
return X;
|
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;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
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.
|
2010-12-23 07:09:49 +08:00
|
|
|
return DeducedTemplateArgument();
|
2011-01-27 15:10:08 +08:00
|
|
|
|
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 &&
|
2012-06-07 23:09:51 +08:00
|
|
|
hasSameExtendedValue(X.getAsIntegral(), Y.getAsIntegral())))
|
2011-01-27 15:10:08 +08:00
|
|
|
return DeducedTemplateArgument(X,
|
2010-12-23 07:09:49 +08:00
|
|
|
X.wasDeducedFromArrayBound() &&
|
|
|
|
Y.wasDeducedFromArrayBound());
|
|
|
|
|
|
|
|
// All other combinations are incompatible.
|
|
|
|
return DeducedTemplateArgument();
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-12-23 07:09:49 +08:00
|
|
|
case TemplateArgument::Template:
|
|
|
|
if (Y.getKind() == TemplateArgument::Template &&
|
|
|
|
Context.hasSameTemplateName(X.getAsTemplate(), Y.getAsTemplate()))
|
|
|
|
return X;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-12-23 07:09:49 +08:00
|
|
|
// All other combinations are incompatible.
|
2011-01-27 15:10:08 +08:00
|
|
|
return DeducedTemplateArgument();
|
2011-01-06 02:58:31 +08:00
|
|
|
|
|
|
|
case TemplateArgument::TemplateExpansion:
|
|
|
|
if (Y.getKind() == TemplateArgument::TemplateExpansion &&
|
2011-01-27 15:10:08 +08:00
|
|
|
Context.hasSameTemplateName(X.getAsTemplateOrTemplatePattern(),
|
2011-01-06 02:58:31 +08:00
|
|
|
Y.getAsTemplateOrTemplatePattern()))
|
|
|
|
return X;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-06 02:58:31 +08:00
|
|
|
// All other combinations are incompatible.
|
2011-01-27 15:10:08 +08:00
|
|
|
return DeducedTemplateArgument();
|
2011-01-06 02:58:31 +08:00
|
|
|
|
2010-12-23 07:09:49 +08:00
|
|
|
case TemplateArgument::Expression:
|
2011-01-27 15:10:08 +08:00
|
|
|
// If we deduced a dependent expression in one case and either an integral
|
|
|
|
// constant or a declaration in another case, keep the integral constant
|
2010-12-23 07:09:49 +08:00
|
|
|
// or declaration.
|
|
|
|
if (Y.getKind() == TemplateArgument::Integral ||
|
|
|
|
Y.getKind() == TemplateArgument::Declaration)
|
|
|
|
return DeducedTemplateArgument(Y, X.wasDeducedFromArrayBound() &&
|
|
|
|
Y.wasDeducedFromArrayBound());
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-12-23 07:09:49 +08:00
|
|
|
if (Y.getKind() == TemplateArgument::Expression) {
|
|
|
|
// Compare the expressions for equality
|
|
|
|
llvm::FoldingSetNodeID ID1, ID2;
|
|
|
|
X.getAsExpr()->Profile(ID1, Context, true);
|
|
|
|
Y.getAsExpr()->Profile(ID2, Context, true);
|
|
|
|
if (ID1 == ID2)
|
|
|
|
return X;
|
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-12-23 07:09:49 +08:00
|
|
|
// All other combinations are incompatible.
|
|
|
|
return DeducedTemplateArgument();
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-12-23 07:09:49 +08:00
|
|
|
case TemplateArgument::Declaration:
|
|
|
|
// If we deduced a declaration and a dependent expression, keep the
|
|
|
|
// declaration.
|
|
|
|
if (Y.getKind() == TemplateArgument::Expression)
|
|
|
|
return X;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-12-23 07:09:49 +08:00
|
|
|
// If we deduced a declaration and an integral constant, keep the
|
|
|
|
// integral constant.
|
|
|
|
if (Y.getKind() == TemplateArgument::Integral)
|
|
|
|
return Y;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
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 &&
|
2014-10-16 12:21:25 +08:00
|
|
|
isSameDeclaration(X.getAsDecl(), Y.getAsDecl()))
|
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;
|
|
|
|
|
|
|
|
// If we deduced two null pointers, make sure they have the same type.
|
|
|
|
if (Y.getKind() == TemplateArgument::NullPtr &&
|
|
|
|
Context.hasSameType(X.getNullPtrType(), Y.getNullPtrType()))
|
2010-12-23 07:09:49 +08:00
|
|
|
return X;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-12-23 07:09:49 +08:00
|
|
|
// All other combinations are incompatible.
|
|
|
|
return DeducedTemplateArgument();
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-12-23 07:09:49 +08:00
|
|
|
case TemplateArgument::Pack:
|
|
|
|
if (Y.getKind() != TemplateArgument::Pack ||
|
|
|
|
X.pack_size() != Y.pack_size())
|
|
|
|
return DeducedTemplateArgument();
|
2011-01-27 15:10:08 +08:00
|
|
|
|
|
|
|
for (TemplateArgument::pack_iterator XA = X.pack_begin(),
|
2010-12-23 07:09:49 +08:00
|
|
|
XAEnd = X.pack_end(),
|
|
|
|
YA = Y.pack_begin();
|
|
|
|
XA != XAEnd; ++XA, ++YA) {
|
2014-05-29 09:12:14 +08:00
|
|
|
// FIXME: Do we need to merge the results together here?
|
2011-01-27 15:10:08 +08:00
|
|
|
if (checkDeducedTemplateArguments(Context,
|
|
|
|
DeducedTemplateArgument(*XA, X.wasDeducedFromArrayBound()),
|
2011-01-06 05:00:53 +08:00
|
|
|
DeducedTemplateArgument(*YA, Y.wasDeducedFromArrayBound()))
|
|
|
|
.isNull())
|
2010-12-23 07:09:49 +08:00
|
|
|
return DeducedTemplateArgument();
|
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-12-23 07:09:49 +08:00
|
|
|
return X;
|
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2012-01-21 05:50:17 +08:00
|
|
|
llvm_unreachable("Invalid TemplateArgument Kind!");
|
2010-12-23 07:09:49 +08:00
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
/// \brief Deduce the value of the given non-type template parameter
|
2016-09-29 06:08:38 +08:00
|
|
|
/// from the given integral constant.
|
2016-06-15 22:20:56 +08:00
|
|
|
static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument(
|
2016-09-29 07:55:27 +08:00
|
|
|
Sema &S, TemplateParameterList *TemplateParams,
|
|
|
|
NonTypeTemplateParmDecl *NTTP, const llvm::APSInt &Value,
|
2016-06-15 22:20:56 +08:00
|
|
|
QualType ValueType, bool DeducedFromArrayBound, TemplateDeductionInfo &Info,
|
|
|
|
SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
|
2009-09-09 23:08:12 +08:00
|
|
|
assert(NTTP->getDepth() == 0 &&
|
2009-06-05 08:53:49 +08:00
|
|
|
"Cannot deduce non-type template argument with depth > 0");
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2012-06-07 23:09:51 +08:00
|
|
|
DeducedTemplateArgument NewDeduced(S.Context, Value, ValueType,
|
|
|
|
DeducedFromArrayBound);
|
2011-01-27 15:10:08 +08:00
|
|
|
DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
|
2010-12-23 07:09:49 +08:00
|
|
|
Deduced[NTTP->getIndex()],
|
|
|
|
NewDeduced);
|
|
|
|
if (Result.isNull()) {
|
2009-06-13 02:26:56 +08:00
|
|
|
Info.Param = NTTP;
|
|
|
|
Info.FirstArg = Deduced[NTTP->getIndex()];
|
2010-12-23 07:09:49 +08:00
|
|
|
Info.SecondArg = NewDeduced;
|
2011-01-27 15:10:08 +08:00
|
|
|
return Sema::TDK_Inconsistent;
|
2009-06-13 02:26:56 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-12-23 07:09:49 +08:00
|
|
|
Deduced[NTTP->getIndex()] = Result;
|
2016-09-29 07:55:27 +08:00
|
|
|
return S.getLangOpts().CPlusPlus1z
|
|
|
|
? DeduceTemplateArgumentsByTypeMatch(
|
|
|
|
S, TemplateParams, NTTP->getType(), ValueType, Info, Deduced,
|
|
|
|
TDF_ParamWithReferenceType | TDF_SkipNonDependent,
|
|
|
|
/*PartialOrdering=*/false,
|
|
|
|
/*ArrayBound=*/DeducedFromArrayBound)
|
|
|
|
: Sema::TDK_Success;
|
2009-06-05 08:53:49 +08:00
|
|
|
}
|
|
|
|
|
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(
|
2016-09-29 07:55:27 +08:00
|
|
|
Sema &S, TemplateParameterList *TemplateParams,
|
|
|
|
NonTypeTemplateParmDecl *NTTP, QualType NullPtrType,
|
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();
|
|
|
|
DeducedTemplateArgument NewDeduced(Value);
|
|
|
|
DeducedTemplateArgument Result = checkDeducedTemplateArguments(
|
|
|
|
S.Context, Deduced[NTTP->getIndex()], NewDeduced);
|
|
|
|
|
|
|
|
if (Result.isNull()) {
|
|
|
|
Info.Param = NTTP;
|
|
|
|
Info.FirstArg = Deduced[NTTP->getIndex()];
|
|
|
|
Info.SecondArg = NewDeduced;
|
|
|
|
return Sema::TDK_Inconsistent;
|
|
|
|
}
|
|
|
|
|
|
|
|
Deduced[NTTP->getIndex()] = Result;
|
2016-09-29 07:55:27 +08:00
|
|
|
return S.getLangOpts().CPlusPlus1z
|
|
|
|
? DeduceTemplateArgumentsByTypeMatch(
|
|
|
|
S, TemplateParams, NTTP->getType(), Value->getType(), Info,
|
|
|
|
Deduced, TDF_ParamWithReferenceType | TDF_SkipNonDependent)
|
|
|
|
: Sema::TDK_Success;
|
2016-09-29 06:08:38 +08:00
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
/// \brief Deduce the value of the given non-type template parameter
|
2009-06-05 08:53:49 +08:00
|
|
|
/// from the given type- or value-dependent expression.
|
|
|
|
///
|
|
|
|
/// \returns true if deduction succeeded, false otherwise.
|
2009-06-13 02:26:56 +08:00
|
|
|
static Sema::TemplateDeductionResult
|
2010-02-08 05:33:28 +08:00
|
|
|
DeduceNonTypeTemplateArgument(Sema &S,
|
2016-09-29 07:55:27 +08:00
|
|
|
TemplateParameterList *TemplateParams,
|
2009-06-13 02:26:56 +08:00
|
|
|
NonTypeTemplateParmDecl *NTTP,
|
|
|
|
Expr *Value,
|
2010-08-25 13:32:35 +08:00
|
|
|
TemplateDeductionInfo &Info,
|
2011-07-23 18:55:15 +08:00
|
|
|
SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
|
2009-09-09 23:08:12 +08:00
|
|
|
assert(NTTP->getDepth() == 0 &&
|
2009-06-05 08:53:49 +08:00
|
|
|
"Cannot deduce non-type template argument with depth > 0");
|
|
|
|
assert((Value->isTypeDependent() || Value->isValueDependent()) &&
|
|
|
|
"Expression template argument must be type- or value-dependent.");
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2010-12-23 07:09:49 +08:00
|
|
|
DeducedTemplateArgument NewDeduced(Value);
|
2011-01-27 15:10:08 +08:00
|
|
|
DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
|
|
|
|
Deduced[NTTP->getIndex()],
|
2010-12-23 07:09:49 +08:00
|
|
|
NewDeduced);
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-12-23 07:09:49 +08:00
|
|
|
if (Result.isNull()) {
|
|
|
|
Info.Param = NTTP;
|
|
|
|
Info.FirstArg = Deduced[NTTP->getIndex()];
|
|
|
|
Info.SecondArg = NewDeduced;
|
2011-01-27 15:10:08 +08:00
|
|
|
return Sema::TDK_Inconsistent;
|
2009-09-16 00:51:42 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-12-23 07:09:49 +08:00
|
|
|
Deduced[NTTP->getIndex()] = Result;
|
2016-09-29 07:55:27 +08:00
|
|
|
return S.getLangOpts().CPlusPlus1z
|
|
|
|
? DeduceTemplateArgumentsByTypeMatch(
|
|
|
|
S, TemplateParams, NTTP->getType(), Value->getType(), Info,
|
|
|
|
Deduced, TDF_ParamWithReferenceType | TDF_SkipNonDependent)
|
|
|
|
: Sema::TDK_Success;
|
2009-06-05 08:53:49 +08:00
|
|
|
}
|
|
|
|
|
2009-11-14 07:45:44 +08:00
|
|
|
/// \brief Deduce the value of the given non-type template parameter
|
|
|
|
/// from the given declaration.
|
|
|
|
///
|
|
|
|
/// \returns true if deduction succeeded, false otherwise.
|
|
|
|
static Sema::TemplateDeductionResult
|
2010-02-08 05:33:28 +08:00
|
|
|
DeduceNonTypeTemplateArgument(Sema &S,
|
2016-09-29 07:55:27 +08:00
|
|
|
TemplateParameterList *TemplateParams,
|
2013-07-08 12:16:49 +08:00
|
|
|
NonTypeTemplateParmDecl *NTTP,
|
2016-09-29 07:55:27 +08:00
|
|
|
ValueDecl *D, QualType T,
|
2013-07-08 12:16:49 +08:00
|
|
|
TemplateDeductionInfo &Info,
|
|
|
|
SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
|
2009-11-14 07:45:44 +08:00
|
|
|
assert(NTTP->getDepth() == 0 &&
|
|
|
|
"Cannot deduce non-type template argument with depth > 0");
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2014-05-26 14:22:03 +08:00
|
|
|
D = D ? cast<ValueDecl>(D->getCanonicalDecl()) : nullptr;
|
2014-10-16 12:21:25 +08:00
|
|
|
TemplateArgument New(D, NTTP->getType());
|
2012-09-26 10:36:12 +08:00
|
|
|
DeducedTemplateArgument NewDeduced(New);
|
2011-01-27 15:10:08 +08:00
|
|
|
DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
|
2010-12-23 07:09:49 +08:00
|
|
|
Deduced[NTTP->getIndex()],
|
|
|
|
NewDeduced);
|
|
|
|
if (Result.isNull()) {
|
|
|
|
Info.Param = NTTP;
|
|
|
|
Info.FirstArg = Deduced[NTTP->getIndex()];
|
|
|
|
Info.SecondArg = NewDeduced;
|
2011-01-27 15:10:08 +08:00
|
|
|
return Sema::TDK_Inconsistent;
|
2009-11-14 07:45:44 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-12-23 07:09:49 +08:00
|
|
|
Deduced[NTTP->getIndex()] = Result;
|
2016-09-29 07:55:27 +08:00
|
|
|
return S.getLangOpts().CPlusPlus1z
|
|
|
|
? DeduceTemplateArgumentsByTypeMatch(
|
|
|
|
S, TemplateParams, NTTP->getType(), T, Info, Deduced,
|
|
|
|
TDF_ParamWithReferenceType | TDF_SkipNonDependent)
|
|
|
|
: Sema::TDK_Success;
|
2009-11-14 07:45:44 +08:00
|
|
|
}
|
|
|
|
|
2009-06-13 02:26:56 +08:00
|
|
|
static Sema::TemplateDeductionResult
|
2010-02-08 05:33:28 +08:00
|
|
|
DeduceTemplateArguments(Sema &S,
|
2009-11-12 07:06:43 +08:00
|
|
|
TemplateParameterList *TemplateParams,
|
2009-06-13 02:26:56 +08:00
|
|
|
TemplateName Param,
|
|
|
|
TemplateName Arg,
|
2010-08-25 13:32:35 +08:00
|
|
|
TemplateDeductionInfo &Info,
|
2013-07-08 12:16:49 +08:00
|
|
|
SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
|
2009-06-10 00:35:58 +08:00
|
|
|
TemplateDecl *ParamDecl = Param.getAsTemplateDecl();
|
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;
|
2009-06-13 02:26:56 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-11-12 07:06:43 +08:00
|
|
|
if (TemplateTemplateParmDecl *TempParam
|
|
|
|
= dyn_cast<TemplateTemplateParmDecl>(ParamDecl)) {
|
2010-12-23 07:09:49 +08:00
|
|
|
DeducedTemplateArgument NewDeduced(S.Context.getCanonicalTemplateName(Arg));
|
2011-01-27 15:10:08 +08:00
|
|
|
DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
|
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;
|
2011-01-27 15:10:08 +08:00
|
|
|
return Sema::TDK_Inconsistent;
|
2009-11-12 07:06:43 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-12-23 07:09:49 +08:00
|
|
|
Deduced[TempParam->getIndex()] = Result;
|
2011-01-27 15:10:08 +08:00
|
|
|
return Sema::TDK_Success;
|
2009-06-13 02:26:56 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-11-12 07:06:43 +08:00
|
|
|
// Verify that the two template names are equivalent.
|
2010-02-08 05:33:28 +08:00
|
|
|
if (S.Context.hasSameTemplateName(Param, Arg))
|
2009-11-12 07:06:43 +08:00
|
|
|
return Sema::TDK_Success;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
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;
|
2009-06-10 00:35:58 +08:00
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
/// \brief Deduce the template arguments by comparing the template parameter
|
2009-07-08 07:09:34 +08:00
|
|
|
/// type (which is a template-id) with the template argument type.
|
|
|
|
///
|
2010-02-08 05:33:28 +08:00
|
|
|
/// \param S the Sema
|
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
|
2010-02-08 05:33:28 +08:00
|
|
|
DeduceTemplateArguments(Sema &S,
|
2009-07-08 07:09:34 +08:00
|
|
|
TemplateParameterList *TemplateParams,
|
|
|
|
const TemplateSpecializationType *Param,
|
|
|
|
QualType Arg,
|
2010-08-25 13:32:35 +08:00
|
|
|
TemplateDeductionInfo &Info,
|
2013-07-08 12:13:06 +08:00
|
|
|
SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
|
2009-10-23 04:10:53 +08:00
|
|
|
assert(Arg.isCanonical() && "Argument type must be canonical");
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-08 07:09:34 +08:00
|
|
|
// Check whether the template argument is a dependent template-id.
|
2009-09-09 23:08:12 +08:00
|
|
|
if (const TemplateSpecializationType *SpecArg
|
2009-07-08 07:09:34 +08:00
|
|
|
= dyn_cast<TemplateSpecializationType>(Arg)) {
|
|
|
|
// Perform template argument deduction for the template name.
|
|
|
|
if (Sema::TemplateDeductionResult Result
|
2010-02-08 05:33:28 +08:00
|
|
|
= DeduceTemplateArguments(S, TemplateParams,
|
2009-07-08 07:09:34 +08:00
|
|
|
Param->getTemplateName(),
|
|
|
|
SpecArg->getTemplateName(),
|
|
|
|
Info, Deduced))
|
|
|
|
return Result;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
|
|
|
|
2009-07-08 07:09:34 +08:00
|
|
|
// Perform template argument deduction on each template
|
2010-12-23 02:55:49 +08:00
|
|
|
// argument. Ignore any missing/extra arguments, since they could be
|
|
|
|
// filled in by default arguments.
|
2016-06-29 07:05:09 +08:00
|
|
|
return DeduceTemplateArguments(S, TemplateParams, Param->getArgs(),
|
|
|
|
Param->getNumArgs(), SpecArg->getArgs(),
|
|
|
|
SpecArg->getNumArgs(), Info, Deduced,
|
|
|
|
/*NumberOfArgumentsMustMatch=*/false);
|
2009-07-08 07:09:34 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
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);
|
2013-01-31 13:19:49 +08:00
|
|
|
if (!RecordArg) {
|
|
|
|
Info.FirstArg = TemplateArgument(QualType(Param, 0));
|
|
|
|
Info.SecondArg = TemplateArgument(Arg);
|
2009-07-08 07:09:34 +08:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2013-01-31 13:19:49 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
|
|
|
ClassTemplateSpecializationDecl *SpecArg
|
2009-07-08 07:09:34 +08:00
|
|
|
= dyn_cast<ClassTemplateSpecializationDecl>(RecordArg->getDecl());
|
2013-01-31 13:19:49 +08:00
|
|
|
if (!SpecArg) {
|
|
|
|
Info.FirstArg = TemplateArgument(QualType(Param, 0));
|
|
|
|
Info.SecondArg = TemplateArgument(Arg);
|
2009-07-08 07:09:34 +08:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2013-01-31 13:19:49 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-08 07:09:34 +08:00
|
|
|
// Perform template argument deduction for the template name.
|
|
|
|
if (Sema::TemplateDeductionResult Result
|
2010-02-08 05:33:28 +08:00
|
|
|
= DeduceTemplateArguments(S,
|
2009-11-12 07:06:43 +08:00
|
|
|
TemplateParams,
|
2009-07-08 07:09:34 +08:00
|
|
|
Param->getTemplateName(),
|
|
|
|
TemplateName(SpecArg->getSpecializedTemplate()),
|
|
|
|
Info, Deduced))
|
|
|
|
return Result;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2010-12-23 02:17:10 +08:00
|
|
|
// Perform template argument deduction for the template arguments.
|
2016-06-29 07:05:09 +08:00
|
|
|
return DeduceTemplateArguments(
|
|
|
|
S, TemplateParams, Param->getArgs(), Param->getNumArgs(),
|
|
|
|
SpecArg->getTemplateArgs().data(), SpecArg->getTemplateArgs().size(),
|
|
|
|
Info, Deduced, /*NumberOfArgumentsMustMatch=*/true);
|
2009-07-08 07:09:34 +08:00
|
|
|
}
|
|
|
|
|
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:
|
2011-01-18 15:41:22 +08:00
|
|
|
case Type::TemplateTypeParm:
|
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.
|
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) {
|
2011-01-06 07:12:31 +08:00
|
|
|
if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ND))
|
|
|
|
return std::make_pair(TTP->getDepth(), TTP->getIndex());
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-06 07:12:31 +08:00
|
|
|
if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(ND))
|
|
|
|
return std::make_pair(NTTP->getDepth(), NTTP->getIndex());
|
2011-01-27 15:10:08 +08:00
|
|
|
|
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.
|
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());
|
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 *>());
|
|
|
|
}
|
|
|
|
|
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);
|
2013-07-08 12:24:47 +08:00
|
|
|
if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D))
|
2011-01-06 07:12:31 +08:00
|
|
|
return TemplateParameter(NTTP);
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-06 07:12:31 +08:00
|
|
|
return TemplateParameter(cast<TemplateTemplateParmDecl>(D));
|
|
|
|
}
|
|
|
|
|
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) {}
|
2013-07-08 12:44:01 +08:00
|
|
|
|
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;
|
|
|
|
};
|
|
|
|
|
2015-03-23 20:31:05 +08:00
|
|
|
namespace {
|
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) {
|
|
|
|
// Compute the set of template parameter indices that correspond to
|
|
|
|
// parameter packs expanded by the pack expansion.
|
|
|
|
{
|
|
|
|
llvm::SmallBitVector SawIndices(TemplateParams->size());
|
|
|
|
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]);
|
|
|
|
if (Depth == 0 && !SawIndices[Index]) {
|
|
|
|
SawIndices[Index] = true;
|
2012-08-23 14:16:52 +08:00
|
|
|
|
2014-05-29 09:12:14 +08:00
|
|
|
// 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);
|
|
|
|
}
|
|
|
|
}
|
2011-01-11 01:35:05 +08:00
|
|
|
}
|
2014-05-29 09:12:14 +08:00
|
|
|
assert(!Packs.empty() && "Pack expansion without unexpanded packs?");
|
2011-01-11 01:35:05 +08:00
|
|
|
|
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;
|
|
|
|
|
|
|
|
if (S.CurrentInstantiationScope) {
|
|
|
|
// If the template argument pack was explicitly specified, add that to
|
|
|
|
// the set of deduced arguments.
|
|
|
|
const TemplateArgument *ExplicitArgs;
|
|
|
|
unsigned NumExplicitArgs;
|
|
|
|
NamedDecl *PartiallySubstitutedPack =
|
|
|
|
S.CurrentInstantiationScope->getPartiallySubstitutedPack(
|
|
|
|
&ExplicitArgs, &NumExplicitArgs);
|
|
|
|
if (PartiallySubstitutedPack &&
|
|
|
|
getDepthAndIndex(PartiallySubstitutedPack).second == Pack.Index)
|
|
|
|
Pack.New.append(ExplicitArgs, ExplicitArgs + NumExplicitArgs);
|
|
|
|
}
|
2011-01-11 01:53:52 +08:00
|
|
|
}
|
2014-05-29 09:12:14 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
~PackDeductionScope() {
|
|
|
|
for (auto &Pack : Packs)
|
|
|
|
Info.PendingDeducedPacks[Pack.Index] = Pack.Outer;
|
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
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];
|
|
|
|
if (!DeducedArg.isNull()) {
|
|
|
|
Pack.New.push_back(DeducedArg);
|
|
|
|
DeducedArg = DeducedTemplateArgument();
|
|
|
|
}
|
2011-01-11 01:53:52 +08:00
|
|
|
}
|
2014-05-29 09:12:14 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
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.
|
|
|
|
Sema::TemplateDeductionResult finish(bool HasAnyArguments) {
|
|
|
|
// 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;
|
|
|
|
if (HasAnyArguments && Pack.New.empty()) {
|
|
|
|
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(
|
2015-08-05 17:40:22 +08:00
|
|
|
TemplateArgument(llvm::makeArrayRef(ArgumentPack, Pack.New.size())),
|
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;
|
2011-01-11 01:53:52 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2014-05-29 09:12:14 +08:00
|
|
|
return Sema::TDK_Success;
|
2011-01-11 01:53:52 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2014-05-29 09:12:14 +08:00
|
|
|
private:
|
|
|
|
Sema &S;
|
|
|
|
TemplateParameterList *TemplateParams;
|
|
|
|
SmallVectorImpl<DeducedTemplateArgument> &Deduced;
|
|
|
|
TemplateDeductionInfo &Info;
|
|
|
|
|
|
|
|
SmallVector<DeducedPack, 2> Packs;
|
|
|
|
};
|
2015-03-23 20:31:05 +08:00
|
|
|
} // namespace
|
2011-01-11 01:53:52 +08:00
|
|
|
|
2011-01-06 07:12:31 +08:00
|
|
|
/// \brief Deduce the template arguments by comparing the list of parameter
|
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).
|
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.
|
|
|
|
///
|
2011-01-12 01:34:58 +08:00
|
|
|
/// \param PartialOrdering If true, we are performing template argument
|
2011-01-27 15:10:08 +08:00
|
|
|
/// deduction for during partial ordering for a call
|
2011-01-12 01:34:58 +08:00
|
|
|
/// (C++0x [temp.deduct.partial]).
|
|
|
|
///
|
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,
|
2013-07-08 12:16:49 +08:00
|
|
|
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
|
2011-01-12 01:34:58 +08:00
|
|
|
unsigned TDF,
|
2015-02-20 12:45:22 +08:00
|
|
|
bool PartialOrdering = false) {
|
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])))
|
2013-01-31 13:19:49 +08:00
|
|
|
return Sema::TDK_MiscellaneousDeductionFailure;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-06 07:12:31 +08:00
|
|
|
// C++0x [temp.deduct.type]p10:
|
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. [...]
|
2011-01-06 07:12:31 +08:00
|
|
|
unsigned ArgIdx = 0, ParamIdx = 0;
|
|
|
|
for (; ParamIdx != NumParams; ++ParamIdx) {
|
|
|
|
// Check argument types.
|
2011-01-27 15:10:08 +08:00
|
|
|
const PackExpansionType *Expansion
|
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.
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-06 07:12:31 +08:00
|
|
|
// Make sure we have an argument.
|
|
|
|
if (ArgIdx >= NumArgs)
|
2013-01-31 13:19:49 +08:00
|
|
|
return Sema::TDK_MiscellaneousDeductionFailure;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
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.
|
2013-01-31 13:19:49 +08:00
|
|
|
return Sema::TDK_MiscellaneousDeductionFailure;
|
2011-01-12 06:21:24 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-06 07:12:31 +08:00
|
|
|
if (Sema::TemplateDeductionResult Result
|
2012-01-18 06:49:52 +08:00
|
|
|
= DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
|
|
|
|
Params[ParamIdx], Args[ArgIdx],
|
|
|
|
Info, Deduced, TDF,
|
2015-02-20 12:45:22 +08:00
|
|
|
PartialOrdering))
|
2011-01-06 07:12:31 +08:00
|
|
|
return Result;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-06 07:12:31 +08:00
|
|
|
++ArgIdx;
|
|
|
|
continue;
|
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-11 09:52:23 +08:00
|
|
|
// C++0x [temp.deduct.type]p5:
|
|
|
|
// The non-deduced contexts are:
|
2011-01-27 15:10:08 +08:00
|
|
|
// - A function parameter pack that does not occur at the end of the
|
2011-01-11 09:52:23 +08:00
|
|
|
// parameter-declaration-clause.
|
|
|
|
if (ParamIdx + 1 < NumParams)
|
|
|
|
return Sema::TDK_Success;
|
|
|
|
|
2011-01-06 07:12:31 +08:00
|
|
|
// C++0x [temp.deduct.type]p10:
|
2011-01-27 15:10:08 +08:00
|
|
|
// If the parameter-declaration corresponding to Pi is a function
|
2011-01-06 07:12:31 +08:00
|
|
|
// parameter pack, then the type of its declarator- id is compared with
|
2011-01-27 15:10:08 +08:00
|
|
|
// each remaining parameter type in the parameter-type-list of A. Each
|
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.
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-06 07:12:31 +08:00
|
|
|
QualType Pattern = Expansion->getPattern();
|
2014-05-29 09:12:14 +08:00
|
|
|
PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern);
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-06 07:12:31 +08:00
|
|
|
bool HasAnyArguments = false;
|
|
|
|
for (; ArgIdx < NumArgs; ++ArgIdx) {
|
|
|
|
HasAnyArguments = true;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-06 07:12:31 +08:00
|
|
|
// Deduce template arguments from the pattern.
|
2011-01-27 15:10:08 +08:00
|
|
|
if (Sema::TemplateDeductionResult Result
|
2012-01-18 06:49:52 +08:00
|
|
|
= DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, Pattern,
|
|
|
|
Args[ArgIdx], Info, Deduced,
|
2015-02-20 12:45:22 +08:00
|
|
|
TDF, PartialOrdering))
|
2011-01-06 07:12:31 +08:00
|
|
|
return Result;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2014-05-29 09:12:14 +08:00
|
|
|
PackScope.nextPackElement();
|
2011-01-06 07:12:31 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-06 07:12:31 +08:00
|
|
|
// Build argument packs for each of the parameter packs expanded by this
|
|
|
|
// pack expansion.
|
2014-05-29 09:12:14 +08:00
|
|
|
if (auto Result = PackScope.finish(HasAnyArguments))
|
2011-01-27 15:10:08 +08:00
|
|
|
return Result;
|
2011-01-06 07:12:31 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-06 07:12:31 +08:00
|
|
|
// Make sure we don't have any extra arguments.
|
|
|
|
if (ArgIdx < NumArgs)
|
2013-01-31 13:19:49 +08:00
|
|
|
return Sema::TDK_MiscellaneousDeductionFailure;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-06 07:12:31 +08:00
|
|
|
return Sema::TDK_Success;
|
|
|
|
}
|
|
|
|
|
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;
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2011-04-28 08:56:09 +08:00
|
|
|
// Mismatched (but not missing) Objective-C GC attributes.
|
2016-08-12 19:43:57 +08:00
|
|
|
if (ParamQs.getObjCGCAttr() != ArgQs.getObjCGCAttr() &&
|
2011-04-28 08:56:09 +08:00
|
|
|
ParamQs.hasObjCGCAttr())
|
|
|
|
return true;
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2011-04-28 08:56:09 +08:00
|
|
|
// Mismatched (but not missing) address spaces.
|
|
|
|
if (ParamQs.getAddressSpace() != ArgQs.getAddressSpace() &&
|
|
|
|
ParamQs.hasAddressSpace())
|
|
|
|
return true;
|
|
|
|
|
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;
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2011-04-28 08:56:09 +08:00
|
|
|
// CVR qualifier superset.
|
|
|
|
return (ParamQs.getCVRQualifiers() != ArgQs.getCVRQualifiers()) &&
|
|
|
|
((ParamQs.getCVRQualifiers() | ArgQs.getCVRQualifiers())
|
|
|
|
== ParamQs.getCVRQualifiers());
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
|
2016-10-17 01:54:23 +08:00
|
|
|
// Noreturn and noexcept adjustment.
|
2013-04-17 16:45:07 +08:00
|
|
|
QualType AdjustedParam;
|
2016-10-17 01:54:23 +08:00
|
|
|
if (IsFunctionConversion(Param, Arg, AdjustedParam))
|
2013-04-17 16:45:07 +08:00
|
|
|
return Arg == Context.getCanonicalType(AdjustedParam);
|
|
|
|
|
|
|
|
// FIXME: Compatible calling conventions.
|
|
|
|
|
|
|
|
return Param == Arg;
|
|
|
|
}
|
|
|
|
|
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]).
|
|
|
|
///
|
2010-02-08 05:33:28 +08:00
|
|
|
/// \param S the semantic analysis object within which we are deducing
|
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
|
|
|
|
///
|
2009-06-27 07:10:12 +08:00
|
|
|
/// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe
|
2009-09-09 23:08:12 +08:00
|
|
|
/// how template argument deduction is performed.
|
2009-06-27 02:27:22 +08:00
|
|
|
///
|
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]).
|
|
|
|
///
|
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.
|
2009-06-13 02:26:56 +08:00
|
|
|
static Sema::TemplateDeductionResult
|
2012-01-18 06:49:52 +08:00
|
|
|
DeduceTemplateArgumentsByTypeMatch(Sema &S,
|
|
|
|
TemplateParameterList *TemplateParams,
|
|
|
|
QualType ParamIn, QualType ArgIn,
|
|
|
|
TemplateDeductionInfo &Info,
|
|
|
|
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
|
|
|
|
unsigned TDF,
|
2016-09-29 07:55:27 +08:00
|
|
|
bool PartialOrdering,
|
|
|
|
bool DeducedFromArrayBound) {
|
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.
|
2010-02-08 05:33:28 +08:00
|
|
|
QualType Param = S.Context.getCanonicalType(ParamIn);
|
|
|
|
QualType Arg = S.Context.getCanonicalType(ArgIn);
|
2009-06-04 08:03:07 +08:00
|
|
|
|
2011-01-12 06:21:24 +08:00
|
|
|
// If the argument type is a pack expansion, look at its pattern.
|
2011-01-27 15:10:08 +08:00
|
|
|
// This isn't explicitly called out
|
2011-01-12 06:21:24 +08:00
|
|
|
if (const PackExpansionType *ArgExpansion
|
|
|
|
= dyn_cast<PackExpansionType>(Arg))
|
|
|
|
Arg = ArgExpansion->getPattern();
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-12 01:34:58 +08:00
|
|
|
if (PartialOrdering) {
|
2015-02-20 12:45:22 +08:00
|
|
|
// C++11 [temp.deduct.partial]p5:
|
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.
|
2011-01-12 01:34:58 +08:00
|
|
|
const ReferenceType *ParamRef = Param->getAs<ReferenceType>();
|
|
|
|
if (ParamRef)
|
|
|
|
Param = ParamRef->getPointeeType();
|
2011-01-27 15:10:08 +08:00
|
|
|
|
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();
|
2011-01-27 15:10:08 +08:00
|
|
|
|
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
|
2011-01-12 01:34:58 +08:00
|
|
|
//
|
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.
|
2011-05-01 01:07:52 +08:00
|
|
|
Qualifiers ParamQuals = Param.getQualifiers();
|
|
|
|
Qualifiers ArgQuals = Arg.getQualifiers();
|
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;
|
2014-01-03 03:42:02 +08:00
|
|
|
}
|
2011-01-12 01:34:58 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2015-02-20 12:45:22 +08:00
|
|
|
// C++11 [temp.deduct.partial]p7:
|
2011-01-12 01:34:58 +08:00
|
|
|
// Remove any top-level cv-qualifiers:
|
2011-01-27 15:10:08 +08:00
|
|
|
// - If P is a cv-qualified type, P is replaced by the cv-unqualified
|
2011-01-12 01:34:58 +08:00
|
|
|
// version of P.
|
|
|
|
Param = Param.getUnqualifiedType();
|
2011-01-27 15:10:08 +08:00
|
|
|
// - If A is a cv-qualified type, A is replaced by the cv-unqualified
|
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() &
|
2011-01-18 15:41:22 +08:00
|
|
|
Arg.getCVRQualifiers());
|
2011-01-12 01:34:58 +08:00
|
|
|
Param = S.Context.getQualifiedType(UnqualParam, Quals);
|
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
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
|
2011-01-27 15:10:08 +08:00
|
|
|
// Ai are parameters of the top-level parameter-type-list of P and A,
|
|
|
|
// respectively, Pi is adjusted if it is an rvalue reference to a
|
|
|
|
// cv-unqualified template parameter and Ai is an lvalue reference, in
|
|
|
|
// which case the type of Pi is changed to be the template parameter
|
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
|
2011-01-27 15:09:49 +08:00
|
|
|
// deduced as X&. - end note ]
|
2011-01-26 01:19:08 +08:00
|
|
|
TDF &= ~TDF_TopLevelParameterTypeList;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-26 01:19:08 +08:00
|
|
|
if (const RValueReferenceType *ParamRef
|
|
|
|
= Param->getAs<RValueReferenceType>()) {
|
|
|
|
if (isa<TemplateTypeParmType>(ParamRef->getPointeeType()) &&
|
|
|
|
!ParamRef->getPointeeType().getQualifiers())
|
|
|
|
if (Arg->isLValueReferenceType())
|
|
|
|
Param = ParamRef->getPointeeType();
|
|
|
|
}
|
|
|
|
}
|
2009-06-27 02:27:22 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-06-05 08:53:49 +08:00
|
|
|
// C++ [temp.deduct.type]p9:
|
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
|
2009-06-05 08:53:49 +08:00
|
|
|
// the following forms:
|
|
|
|
//
|
|
|
|
// T
|
|
|
|
// cv-list T
|
2009-09-09 23:08:12 +08:00
|
|
|
if (const TemplateTypeParmType *TemplateTypeParm
|
2009-09-22 07:43:11 +08:00
|
|
|
= Param->getAs<TemplateTypeParmType>()) {
|
2011-09-22 23:57:07 +08:00
|
|
|
// Just skip any attempts to deduce from a placeholder type.
|
|
|
|
if (Arg->isPlaceholderType())
|
|
|
|
return Sema::TDK_Success;
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2009-06-13 02:26:56 +08:00
|
|
|
unsigned Index = TemplateTypeParm->getIndex();
|
2009-07-23 05:30:48 +08:00
|
|
|
bool RecanonicalizeArg = false;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
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.
|
2009-07-23 05:30:48 +08:00
|
|
|
if (isa<ArrayType>(Arg)) {
|
2009-09-25 03:53:00 +08:00
|
|
|
Qualifiers Quals;
|
2010-02-08 05:33:28 +08:00
|
|
|
Arg = S.Context.getUnqualifiedArrayType(Arg, Quals);
|
2009-09-25 03:53:00 +08:00
|
|
|
if (Quals) {
|
2010-02-08 05:33:28 +08:00
|
|
|
Arg = S.Context.getQualifiedType(Arg, Quals);
|
2009-07-23 05:30:48 +08:00
|
|
|
RecanonicalizeArg = true;
|
|
|
|
}
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-04 08:03:07 +08:00
|
|
|
// The argument type can not be less qualified than the parameter
|
|
|
|
// type.
|
2011-04-28 08:56:09 +08:00
|
|
|
if (!(TDF & TDF_IgnoreQualifiers) &&
|
|
|
|
hasInconsistentOrSupersetQualifiersOf(Param, Arg)) {
|
2009-06-13 02:26:56 +08:00
|
|
|
Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index));
|
2010-08-05 17:05:08 +08:00
|
|
|
Info.FirstArg = TemplateArgument(Param);
|
2009-10-29 16:12:44 +08:00
|
|
|
Info.SecondArg = TemplateArgument(Arg);
|
2010-08-05 17:05:08 +08:00
|
|
|
return Sema::TDK_Underqualified;
|
2009-06-13 02:26:56 +08:00
|
|
|
}
|
2009-06-04 08:03:07 +08:00
|
|
|
|
|
|
|
assert(TemplateTypeParm->getDepth() == 0 && "Can't deduce with depth > 0");
|
2010-02-08 05:33:28 +08:00
|
|
|
assert(Arg != S.Context.OverloadTy && "Unresolved overloaded function");
|
2009-09-25 03:53:00 +08:00
|
|
|
QualType DeducedType = Arg;
|
2010-12-10 19:01:00 +08:00
|
|
|
|
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();
|
2011-06-16 07:02:42 +08:00
|
|
|
if (ParamQs.hasObjCLifetime())
|
|
|
|
DeducedQs.removeObjCLifetime();
|
2016-08-12 19:43:57 +08:00
|
|
|
|
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);
|
2016-08-12 19:43:57 +08:00
|
|
|
return Sema::TDK_Underqualified;
|
2011-07-26 22:53:44 +08:00
|
|
|
}
|
2016-08-12 19:43:57 +08:00
|
|
|
|
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.
|
2012-03-11 15:00:24 +08:00
|
|
|
if (S.getLangOpts().ObjCAutoRefCount &&
|
2011-06-18 06:11:49 +08:00
|
|
|
DeducedType->isObjCLifetimeType() &&
|
|
|
|
!DeducedQs.hasObjCLifetime())
|
|
|
|
DeducedQs.setObjCLifetime(Qualifiers::OCL_Strong);
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2011-04-28 08:56:09 +08:00
|
|
|
DeducedType = S.Context.getQualifiedType(DeducedType.getUnqualifiedType(),
|
|
|
|
DeducedQs);
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2009-07-23 05:30:48 +08:00
|
|
|
if (RecanonicalizeArg)
|
2010-02-08 05:33:28 +08:00
|
|
|
DeducedType = S.Context.getCanonicalType(DeducedType);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2016-09-29 07:55:27 +08:00
|
|
|
DeducedTemplateArgument NewDeduced(DeducedType, DeducedFromArrayBound);
|
2011-01-27 15:10:08 +08:00
|
|
|
DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
|
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;
|
2011-01-27 15:10:08 +08:00
|
|
|
return Sema::TDK_Inconsistent;
|
2009-06-04 08:03:07 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-12-23 07:09:49 +08:00
|
|
|
Deduced[Index] = Result;
|
2011-01-27 15:10:08 +08:00
|
|
|
return Sema::TDK_Success;
|
2009-06-04 08:03:07 +08:00
|
|
|
}
|
|
|
|
|
2009-06-13 02:26:56 +08:00
|
|
|
// Set up the template argument deduction information for a failure.
|
2009-10-29 16:12:44 +08:00
|
|
|
Info.FirstArg = TemplateArgument(ParamIn);
|
|
|
|
Info.SecondArg = TemplateArgument(ArgIn);
|
2009-06-13 02:26:56 +08:00
|
|
|
|
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;
|
|
|
|
|
2009-06-27 07:10:12 +08:00
|
|
|
// Check the cv-qualifiers on the parameter and argument types.
|
2013-04-17 16:45:07 +08:00
|
|
|
CanQualType CanParam = S.Context.getCanonicalType(Param);
|
|
|
|
CanQualType CanArg = S.Context.getCanonicalType(Arg);
|
2009-06-27 07:10:12 +08:00
|
|
|
if (!(TDF & TDF_IgnoreQualifiers)) {
|
|
|
|
if (TDF & TDF_ParamWithReferenceType) {
|
2011-04-28 08:56:09 +08:00
|
|
|
if (hasInconsistentOrSupersetQualifiersOf(Param, Arg))
|
2009-06-27 07:10:12 +08:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2010-08-29 06:14:41 +08:00
|
|
|
} else if (!IsPossiblyOpaquelyQualifiedType(Param)) {
|
2009-06-27 07:10:12 +08:00
|
|
|
if (Param.getCVRQualifiers() != Arg.getCVRQualifiers())
|
2009-09-09 23:08:12 +08:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-06-27 07:10:12 +08:00
|
|
|
}
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2012-03-11 11:29:50 +08:00
|
|
|
// If the parameter type is not dependent, there is nothing to deduce.
|
|
|
|
if (!Param->isDependentType()) {
|
2013-04-17 16:45:07 +08:00
|
|
|
if (!(TDF & TDF_SkipNonDependent)) {
|
|
|
|
bool NonDeduced = (TDF & TDF_InOverloadResolution)?
|
|
|
|
!S.isSameOrCompatibleFunctionType(CanParam, CanArg) :
|
|
|
|
Param != Arg;
|
|
|
|
if (NonDeduced) {
|
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
|
|
|
}
|
|
|
|
}
|
2012-03-11 11:29:50 +08:00
|
|
|
return Sema::TDK_Success;
|
|
|
|
}
|
2013-04-17 16:45:07 +08:00
|
|
|
} else if (!Param->isDependentType()) {
|
|
|
|
CanQualType ParamUnqualType = CanParam.getUnqualifiedType(),
|
|
|
|
ArgUnqualType = CanArg.getUnqualifiedType();
|
|
|
|
bool Success = (TDF & TDF_InOverloadResolution)?
|
|
|
|
S.isSameOrCompatibleFunctionType(ParamUnqualType,
|
|
|
|
ArgUnqualType) :
|
|
|
|
ParamUnqualType == ArgUnqualType;
|
|
|
|
if (Success)
|
|
|
|
return Sema::TDK_Success;
|
2009-06-27 07:10:12 +08:00
|
|
|
}
|
2009-06-04 08:03:07 +08:00
|
|
|
|
2009-06-04 08:21:18 +08:00
|
|
|
switch (Param->getTypeClass()) {
|
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"
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2011-06-16 00:02:29 +08:00
|
|
|
case Type::TemplateTypeParm:
|
|
|
|
case Type::SubstTemplateTypeParmPack:
|
|
|
|
llvm_unreachable("Type nodes handled above");
|
2012-03-11 11:29:50 +08:00
|
|
|
|
|
|
|
// These types cannot be dependent, so simply check whether the types are
|
|
|
|
// the same.
|
2009-06-05 08:53:49 +08:00
|
|
|
case Type::Builtin:
|
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:
|
2012-03-11 11:29:50 +08:00
|
|
|
case Type::ObjCObjectPointer: {
|
|
|
|
if (TDF & TDF_SkipNonDependent)
|
|
|
|
return Sema::TDK_Success;
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2012-03-11 11:29:50 +08:00
|
|
|
if (TDF & TDF_IgnoreQualifiers) {
|
|
|
|
Param = Param.getUnqualifiedType();
|
|
|
|
Arg = Arg.getUnqualifiedType();
|
|
|
|
}
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2012-03-11 11:29:50 +08:00
|
|
|
return Param == Arg? Sema::TDK_Success : Sema::TDK_NonDeducedMismatch;
|
|
|
|
}
|
2016-08-12 19:43:57 +08:00
|
|
|
|
|
|
|
// _Complex T [placeholder extension]
|
2011-06-16 00:02:29 +08:00
|
|
|
case Type::Complex:
|
|
|
|
if (const ComplexType *ComplexArg = Arg->getAs<ComplexType>())
|
2016-08-12 19:43:57 +08:00
|
|
|
return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
|
|
|
|
cast<ComplexType>(Param)->getElementType(),
|
2012-01-18 06:49:52 +08:00
|
|
|
ComplexArg->getElementType(),
|
|
|
|
Info, Deduced, TDF);
|
2011-06-16 00:02:29 +08:00
|
|
|
|
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2011-10-07 07:00:33 +08:00
|
|
|
|
|
|
|
// _Atomic T [extension]
|
|
|
|
case Type::Atomic:
|
|
|
|
if (const AtomicType *AtomicArg = Arg->getAs<AtomicType>())
|
2012-01-18 06:49:52 +08:00
|
|
|
return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
|
2011-10-07 07:00:33 +08:00
|
|
|
cast<AtomicType>(Param)->getValueType(),
|
|
|
|
AtomicArg->getValueType(),
|
|
|
|
Info, Deduced, TDF);
|
|
|
|
|
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
|
|
|
|
2009-06-05 08:53:49 +08:00
|
|
|
// T *
|
2009-06-04 08:21:18 +08:00
|
|
|
case Type::Pointer: {
|
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 {
|
2009-06-13 02:26:56 +08:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2010-05-13 15:48:05 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-27 07:27:24 +08:00
|
|
|
unsigned SubTDF = TDF & (TDF_IgnoreQualifiers | TDF_DerivedClass);
|
2012-01-18 06:49:52 +08:00
|
|
|
return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
|
|
|
|
cast<PointerType>(Param)->getPointeeType(),
|
2010-05-13 15:48:05 +08:00
|
|
|
PointeeType,
|
2009-06-27 07:27:24 +08:00
|
|
|
Info, Deduced, SubTDF);
|
2009-06-04 08:21:18 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-05 08:53:49 +08:00
|
|
|
// T &
|
2009-06-04 08:21:18 +08:00
|
|
|
case Type::LValueReference: {
|
2014-07-28 08:02:09 +08:00
|
|
|
const LValueReferenceType *ReferenceArg =
|
|
|
|
Arg->getAs<LValueReferenceType>();
|
2009-06-04 08:21:18 +08:00
|
|
|
if (!ReferenceArg)
|
2009-06-13 02:26:56 +08:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2012-01-18 06:49:52 +08:00
|
|
|
return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
|
2009-06-04 08:21:18 +08:00
|
|
|
cast<LValueReferenceType>(Param)->getPointeeType(),
|
2012-01-18 06:49:52 +08:00
|
|
|
ReferenceArg->getPointeeType(), Info, Deduced, 0);
|
2009-06-04 08:21:18 +08:00
|
|
|
}
|
2009-06-04 08:03:07 +08:00
|
|
|
|
2009-06-05 08:53:49 +08:00
|
|
|
// T && [C++0x]
|
2009-06-04 08:21:18 +08:00
|
|
|
case Type::RValueReference: {
|
2014-07-28 08:02:09 +08:00
|
|
|
const RValueReferenceType *ReferenceArg =
|
|
|
|
Arg->getAs<RValueReferenceType>();
|
2009-06-04 08:21:18 +08:00
|
|
|
if (!ReferenceArg)
|
2009-06-13 02:26:56 +08:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2012-01-18 06:49:52 +08:00
|
|
|
return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
|
|
|
|
cast<RValueReferenceType>(Param)->getPointeeType(),
|
|
|
|
ReferenceArg->getPointeeType(),
|
|
|
|
Info, Deduced, 0);
|
2009-06-04 08:21:18 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-05 08:53:49 +08:00
|
|
|
// T [] (implied, but not stated explicitly)
|
2009-06-04 12:11:30 +08:00
|
|
|
case Type::IncompleteArray: {
|
2009-09-09 23:08:12 +08:00
|
|
|
const IncompleteArrayType *IncompleteArrayArg =
|
2010-02-08 05:33:28 +08:00
|
|
|
S.Context.getAsIncompleteArrayType(Arg);
|
2009-06-04 12:11:30 +08:00
|
|
|
if (!IncompleteArrayArg)
|
2009-06-13 02:26:56 +08:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2010-08-19 08:20:19 +08:00
|
|
|
unsigned SubTDF = TDF & TDF_IgnoreQualifiers;
|
2012-01-18 06:49:52 +08:00
|
|
|
return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
|
|
|
|
S.Context.getAsIncompleteArrayType(Param)->getElementType(),
|
|
|
|
IncompleteArrayArg->getElementType(),
|
|
|
|
Info, Deduced, SubTDF);
|
2009-06-04 12:11:30 +08:00
|
|
|
}
|
2009-06-05 08:53:49 +08:00
|
|
|
|
|
|
|
// T [integer-constant]
|
2009-06-04 12:11:30 +08:00
|
|
|
case Type::ConstantArray: {
|
2009-09-09 23:08:12 +08:00
|
|
|
const ConstantArrayType *ConstantArrayArg =
|
2010-02-08 05:33:28 +08:00
|
|
|
S.Context.getAsConstantArrayType(Arg);
|
2009-06-04 12:11:30 +08:00
|
|
|
if (!ConstantArrayArg)
|
2009-06-13 02:26:56 +08:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
|
|
|
const ConstantArrayType *ConstantArrayParm =
|
2010-02-08 05:33:28 +08:00
|
|
|
S.Context.getAsConstantArrayType(Param);
|
2009-06-04 12:11:30 +08:00
|
|
|
if (ConstantArrayArg->getSize() != ConstantArrayParm->getSize())
|
2009-06-13 02:26:56 +08:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2010-08-19 08:20:19 +08:00
|
|
|
unsigned SubTDF = TDF & TDF_IgnoreQualifiers;
|
2012-01-18 06:49:52 +08:00
|
|
|
return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
|
|
|
|
ConstantArrayParm->getElementType(),
|
|
|
|
ConstantArrayArg->getElementType(),
|
|
|
|
Info, Deduced, SubTDF);
|
2009-06-04 12:11:30 +08:00
|
|
|
}
|
|
|
|
|
2009-06-05 08:53:49 +08:00
|
|
|
// type [i]
|
|
|
|
case Type::DependentSizedArray: {
|
2010-02-08 05:33:28 +08:00
|
|
|
const ArrayType *ArrayArg = S.Context.getAsArrayType(Arg);
|
2009-06-05 08:53:49 +08:00
|
|
|
if (!ArrayArg)
|
2009-06-13 02:26:56 +08:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2010-08-19 08:20:19 +08:00
|
|
|
unsigned SubTDF = TDF & TDF_IgnoreQualifiers;
|
|
|
|
|
2009-06-05 08:53:49 +08:00
|
|
|
// Check the element type of the arrays
|
|
|
|
const DependentSizedArrayType *DependentArrayParm
|
2010-02-08 05:33:28 +08:00
|
|
|
= S.Context.getAsDependentSizedArrayType(Param);
|
2009-06-13 02:26:56 +08:00
|
|
|
if (Sema::TemplateDeductionResult Result
|
2012-01-18 06:49:52 +08:00
|
|
|
= DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
|
|
|
|
DependentArrayParm->getElementType(),
|
|
|
|
ArrayArg->getElementType(),
|
|
|
|
Info, Deduced, SubTDF))
|
2009-06-13 02:26:56 +08:00
|
|
|
return Result;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-05 08:53:49 +08:00
|
|
|
// Determine the array bound is something we can deduce.
|
2009-09-09 23:08:12 +08:00
|
|
|
NonTypeTemplateParmDecl *NTTP
|
2009-06-05 08:53:49 +08:00
|
|
|
= getDeducedParameterFromExpr(DependentArrayParm->getSizeExpr());
|
|
|
|
if (!NTTP)
|
2009-06-13 02:26:56 +08:00
|
|
|
return Sema::TDK_Success;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
|
|
|
// We can perform template argument deduction for the given non-type
|
2009-06-05 08:53:49 +08:00
|
|
|
// template parameter.
|
2009-09-09 23:08:12 +08:00
|
|
|
assert(NTTP->getDepth() == 0 &&
|
2009-06-05 08:53:49 +08:00
|
|
|
"Cannot deduce non-type template argument at depth > 0");
|
2009-09-09 23:08:12 +08:00
|
|
|
if (const ConstantArrayType *ConstantArrayArg
|
2009-06-17 06:44:31 +08:00
|
|
|
= dyn_cast<ConstantArrayType>(ArrayArg)) {
|
|
|
|
llvm::APSInt Size(ConstantArrayArg->getSize());
|
2016-09-29 07:55:27 +08:00
|
|
|
return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, Size,
|
2010-03-26 13:50:28 +08:00
|
|
|
S.Context.getSizeType(),
|
2010-03-28 10:42:43 +08:00
|
|
|
/*ArrayBound=*/true,
|
2009-06-13 02:26:56 +08:00
|
|
|
Info, Deduced);
|
2009-06-17 06:44:31 +08:00
|
|
|
}
|
2009-06-05 08:53:49 +08:00
|
|
|
if (const DependentSizedArrayType *DependentArrayArg
|
|
|
|
= dyn_cast<DependentSizedArrayType>(ArrayArg))
|
2010-12-23 07:15:38 +08:00
|
|
|
if (DependentArrayArg->getSizeExpr())
|
2016-09-29 07:55:27 +08:00
|
|
|
return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
|
2010-12-23 07:15:38 +08:00
|
|
|
DependentArrayArg->getSizeExpr(),
|
|
|
|
Info, Deduced);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-05 08:53:49 +08:00
|
|
|
// Incomplete type does not match a dependently-sized array type
|
2009-06-13 02:26:56 +08:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-06-05 08:53:49 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
|
|
|
// type(*)(T)
|
|
|
|
// T(*)()
|
|
|
|
// T(*)(T)
|
2009-06-08 23:19:08 +08:00
|
|
|
case Type::FunctionProto: {
|
2011-01-26 01:19:08 +08:00
|
|
|
unsigned SubTDF = TDF & TDF_TopLevelParameterTypeList;
|
2009-09-09 23:08:12 +08:00
|
|
|
const FunctionProtoType *FunctionProtoArg =
|
2009-06-08 23:19:08 +08:00
|
|
|
dyn_cast<FunctionProtoType>(Arg);
|
|
|
|
if (!FunctionProtoArg)
|
2009-06-13 02:26:56 +08:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
|
|
|
const FunctionProtoType *FunctionProtoParam =
|
2009-06-08 23:19:08 +08:00
|
|
|
cast<FunctionProtoType>(Param);
|
2009-06-09 03:22:23 +08:00
|
|
|
|
2011-01-27 15:10:08 +08:00
|
|
|
if (FunctionProtoParam->getTypeQuals()
|
2011-01-27 00:50:54 +08:00
|
|
|
!= FunctionProtoArg->getTypeQuals() ||
|
2011-01-27 15:10:08 +08:00
|
|
|
FunctionProtoParam->getRefQualifier()
|
2011-01-27 00:50:54 +08:00
|
|
|
!= FunctionProtoArg->getRefQualifier() ||
|
|
|
|
FunctionProtoParam->isVariadic() != FunctionProtoArg->isVariadic())
|
2009-06-13 02:26:56 +08:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-06-09 03:22:23 +08:00
|
|
|
|
2009-06-08 23:19:08 +08:00
|
|
|
// Check return types.
|
2014-01-26 00:55:45 +08:00
|
|
|
if (Sema::TemplateDeductionResult Result =
|
|
|
|
DeduceTemplateArgumentsByTypeMatch(
|
|
|
|
S, TemplateParams, FunctionProtoParam->getReturnType(),
|
|
|
|
FunctionProtoArg->getReturnType(), Info, Deduced, 0))
|
2009-06-13 02:26:56 +08:00
|
|
|
return Result;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2014-01-21 04:26:09 +08:00
|
|
|
return DeduceTemplateArguments(
|
|
|
|
S, TemplateParams, FunctionProtoParam->param_type_begin(),
|
|
|
|
FunctionProtoParam->getNumParams(),
|
|
|
|
FunctionProtoArg->param_type_begin(),
|
|
|
|
FunctionProtoArg->getNumParams(), Info, Deduced, SubTDF);
|
2009-06-08 23:19:08 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
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.
|
2010-04-27 08:57:59 +08:00
|
|
|
Param = cast<InjectedClassNameType>(Param)
|
|
|
|
->getInjectedSpecializationType();
|
2010-03-10 11:28:59 +08:00
|
|
|
assert(isa<TemplateSpecializationType>(Param) &&
|
|
|
|
"injected class name is not a template specialization type");
|
|
|
|
// fall through
|
|
|
|
}
|
|
|
|
|
2009-06-27 04:57:09 +08:00
|
|
|
// template-name<T> (where template-name refers to a class template)
|
2009-06-10 00:35:58 +08:00
|
|
|
// template-name<i>
|
2009-11-12 07:06:43 +08:00
|
|
|
// TT<T>
|
|
|
|
// TT<i>
|
|
|
|
// TT<>
|
2009-06-10 00:35:58 +08:00
|
|
|
case Type::TemplateSpecialization: {
|
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.
|
|
|
|
|
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);
|
2016-04-26 03:09:05 +08:00
|
|
|
bool Successful = false;
|
2016-06-29 07:05:09 +08:00
|
|
|
SmallVector<DeducedTemplateArgument, 8> SuccessfulDeduced;
|
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) {
|
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;
|
|
|
|
|
2016-05-19 10:28:21 +08:00
|
|
|
Successful = true;
|
2016-06-29 07:05:09 +08:00
|
|
|
std::swap(SuccessfulDeduced, Deduced);
|
|
|
|
|
2016-05-19 10:28:21 +08:00
|
|
|
Info.Param = BaseInfo.Param;
|
|
|
|
Info.FirstArg = BaseInfo.FirstArg;
|
|
|
|
Info.SecondArg = BaseInfo.SecondArg;
|
2016-06-29 07:05:09 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
Deduced = DeducedOrig;
|
2009-07-08 07:09:34 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
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>());
|
|
|
|
}
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2016-06-29 07:05:09 +08:00
|
|
|
if (Successful) {
|
|
|
|
std::swap(SuccessfulDeduced, Deduced);
|
2016-04-26 03:09:05 +08:00
|
|
|
return Sema::TDK_Success;
|
2016-06-29 07:05:09 +08:00
|
|
|
}
|
2016-04-26 03:09:05 +08:00
|
|
|
|
2009-07-08 07:09:34 +08:00
|
|
|
return Result;
|
2009-06-10 00:35:58 +08:00
|
|
|
}
|
|
|
|
|
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)
|
2009-06-13 02:26:56 +08:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
|
|
|
|
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());
|
|
|
|
|
2009-06-13 02:26:56 +08:00
|
|
|
if (Sema::TemplateDeductionResult Result
|
2012-01-18 06:49:52 +08:00
|
|
|
= DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
|
2015-12-01 04:34:28 +08:00
|
|
|
ParamPointeeType,
|
|
|
|
ArgPointeeType,
|
2012-01-18 06:49:52 +08:00
|
|
|
Info, Deduced,
|
|
|
|
TDF & TDF_IgnoreQualifiers))
|
2009-06-13 02:26:56 +08:00
|
|
|
return Result;
|
|
|
|
|
2012-01-18 06:49:52 +08:00
|
|
|
return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
|
|
|
|
QualType(MemPtrParam->getClass(), 0),
|
|
|
|
QualType(MemPtrArg->getClass(), 0),
|
2016-08-12 19:43:57 +08:00
|
|
|
Info, Deduced,
|
2012-03-11 11:29:50 +08:00
|
|
|
TDF & TDF_IgnoreQualifiers);
|
2009-06-11 07:47:09 +08:00
|
|
|
}
|
|
|
|
|
2009-06-13 06:56:54 +08:00
|
|
|
// (clang extension)
|
|
|
|
//
|
2009-09-09 23:08:12 +08:00
|
|
|
// type(^)(T)
|
|
|
|
// T(^)()
|
|
|
|
// T(^)(T)
|
2009-06-13 00:23:10 +08:00
|
|
|
case Type::BlockPointer: {
|
|
|
|
const BlockPointerType *BlockPtrParam = cast<BlockPointerType>(Param);
|
|
|
|
const BlockPointerType *BlockPtrArg = dyn_cast<BlockPointerType>(Arg);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-13 00:23:10 +08:00
|
|
|
if (!BlockPtrArg)
|
2009-06-13 02:26:56 +08:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2012-01-18 06:49:52 +08:00
|
|
|
return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
|
|
|
|
BlockPtrParam->getPointeeType(),
|
|
|
|
BlockPtrArg->getPointeeType(),
|
|
|
|
Info, Deduced, 0);
|
2009-06-13 00:23:10 +08:00
|
|
|
}
|
|
|
|
|
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;
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2011-06-16 00:02:29 +08:00
|
|
|
// Perform deduction on the element types.
|
2012-01-18 06:49:52 +08:00
|
|
|
return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
|
|
|
|
VectorParam->getElementType(),
|
|
|
|
VectorArg->getElementType(),
|
|
|
|
Info, Deduced, TDF);
|
2011-06-16 00:02:29 +08:00
|
|
|
}
|
2016-08-12 19:43:57 +08:00
|
|
|
|
|
|
|
if (const DependentSizedExtVectorType *VectorArg
|
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.
|
2012-01-18 06:49:52 +08:00
|
|
|
return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
|
|
|
|
VectorParam->getElementType(),
|
|
|
|
VectorArg->getElementType(),
|
|
|
|
Info, Deduced, TDF);
|
2011-06-16 00:02:29 +08:00
|
|
|
}
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2011-06-16 00:02:29 +08:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
|
|
|
}
|
2016-08-12 19:43:57 +08:00
|
|
|
|
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
|
2012-01-18 06:49:52 +08:00
|
|
|
= DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
|
|
|
|
VectorParam->getElementType(),
|
|
|
|
VectorArg->getElementType(),
|
|
|
|
Info, Deduced, TDF))
|
2011-06-16 00:02:29 +08:00
|
|
|
return Result;
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2011-06-16 00:02:29 +08:00
|
|
|
// Perform deduction on the vector size, if we can.
|
|
|
|
NonTypeTemplateParmDecl *NTTP
|
|
|
|
= getDeducedParameterFromExpr(VectorParam->getSizeExpr());
|
|
|
|
if (!NTTP)
|
|
|
|
return Sema::TDK_Success;
|
|
|
|
|
|
|
|
llvm::APSInt ArgSize(S.Context.getTypeSize(S.Context.IntTy), false);
|
|
|
|
ArgSize = VectorArg->getNumElements();
|
2016-09-29 07:55:27 +08:00
|
|
|
return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, ArgSize,
|
|
|
|
S.Context.IntTy, false, Info, Deduced);
|
2011-06-16 00:02:29 +08:00
|
|
|
}
|
2016-08-12 19:43:57 +08:00
|
|
|
|
|
|
|
if (const DependentSizedExtVectorType *VectorArg
|
2011-06-16 00:02:29 +08:00
|
|
|
= dyn_cast<DependentSizedExtVectorType>(Arg)) {
|
|
|
|
// Perform deduction on the element types.
|
|
|
|
if (Sema::TemplateDeductionResult Result
|
2012-01-18 06:49:52 +08:00
|
|
|
= DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
|
|
|
|
VectorParam->getElementType(),
|
|
|
|
VectorArg->getElementType(),
|
|
|
|
Info, Deduced, TDF))
|
2011-06-16 00:02:29 +08:00
|
|
|
return Result;
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2011-06-16 00:02:29 +08:00
|
|
|
// Perform deduction on the vector size, if we can.
|
|
|
|
NonTypeTemplateParmDecl *NTTP
|
|
|
|
= getDeducedParameterFromExpr(VectorParam->getSizeExpr());
|
|
|
|
if (!NTTP)
|
|
|
|
return Sema::TDK_Success;
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2016-09-29 07:55:27 +08:00
|
|
|
return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
|
|
|
|
VectorArg->getSizeExpr(),
|
2011-06-16 00:02:29 +08:00
|
|
|
Info, Deduced);
|
|
|
|
}
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2011-06-16 00:02:29 +08:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
|
|
|
}
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2009-06-11 07:47:09 +08:00
|
|
|
case Type::TypeOfExpr:
|
|
|
|
case Type::TypeOf:
|
2010-04-01 01:34:00 +08:00
|
|
|
case Type::DependentName:
|
2011-06-16 00:02:29 +08:00
|
|
|
case Type::UnresolvedUsing:
|
|
|
|
case Type::Decltype:
|
|
|
|
case Type::UnaryTransform:
|
|
|
|
case Type::Auto:
|
|
|
|
case Type::DependentTemplateSpecialization:
|
|
|
|
case Type::PackExpansion:
|
2016-01-09 20:53:17 +08:00
|
|
|
case Type::Pipe:
|
2009-06-11 07:47:09 +08:00
|
|
|
// No template argument deduction for these types
|
2009-06-13 02:26:56 +08:00
|
|
|
return Sema::TDK_Success;
|
2009-06-04 08:03:07 +08:00
|
|
|
}
|
|
|
|
|
2012-01-21 05:50:17 +08:00
|
|
|
llvm_unreachable("Invalid Type Class!");
|
2009-06-04 08:03:07 +08:00
|
|
|
}
|
|
|
|
|
2009-06-13 02:26:56 +08:00
|
|
|
static Sema::TemplateDeductionResult
|
2010-02-08 05:33:28 +08:00
|
|
|
DeduceTemplateArguments(Sema &S,
|
2009-06-13 02:26:56 +08:00
|
|
|
TemplateParameterList *TemplateParams,
|
|
|
|
const TemplateArgument &Param,
|
2011-01-12 06:21:24 +08:00
|
|
|
TemplateArgument Arg,
|
2010-08-25 13:32:35 +08:00
|
|
|
TemplateDeductionInfo &Info,
|
2013-07-08 12:13:06 +08:00
|
|
|
SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
|
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();
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-06-04 08:03:07 +08:00
|
|
|
switch (Param.getKind()) {
|
2009-06-05 08:53:49 +08:00
|
|
|
case TemplateArgument::Null:
|
2011-09-23 13:06:16 +08:00
|
|
|
llvm_unreachable("Null template argument in parameter list");
|
2009-09-09 23:08:12 +08:00
|
|
|
|
|
|
|
case TemplateArgument::Type:
|
2009-11-11 09:00:40 +08:00
|
|
|
if (Arg.getKind() == TemplateArgument::Type)
|
2012-01-18 06:49:52 +08:00
|
|
|
return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
|
|
|
|
Param.getAsType(),
|
|
|
|
Arg.getAsType(),
|
|
|
|
Info, Deduced, 0);
|
2009-11-11 09:00:40 +08:00
|
|
|
Info.FirstArg = Param;
|
|
|
|
Info.SecondArg = Arg;
|
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2011-01-06 02:58:31 +08:00
|
|
|
|
2009-11-11 09:00:40 +08:00
|
|
|
case TemplateArgument::Template:
|
2009-11-12 07:06:43 +08:00
|
|
|
if (Arg.getKind() == TemplateArgument::Template)
|
2011-01-27 15:10:08 +08:00
|
|
|
return DeduceTemplateArguments(S, TemplateParams,
|
2009-11-11 09:00:40 +08:00
|
|
|
Param.getAsTemplate(),
|
2009-11-12 07:06:43 +08:00
|
|
|
Arg.getAsTemplate(), Info, Deduced);
|
2009-11-11 09:00:40 +08:00
|
|
|
Info.FirstArg = Param;
|
|
|
|
Info.SecondArg = Arg;
|
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2011-01-06 02:58:31 +08:00
|
|
|
|
|
|
|
case TemplateArgument::TemplateExpansion:
|
|
|
|
llvm_unreachable("caller should handle pack expansions");
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-06-05 08:53:49 +08:00
|
|
|
case TemplateArgument::Declaration:
|
2009-11-11 09:00:40 +08:00
|
|
|
if (Arg.getKind() == TemplateArgument::Declaration &&
|
2014-10-16 12:21:25 +08:00
|
|
|
isSameDeclaration(Param.getAsDecl(), Arg.getAsDecl()))
|
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()))
|
2009-11-11 09:00:40 +08:00
|
|
|
return Sema::TDK_Success;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-06-13 02:26:56 +08:00
|
|
|
Info.FirstArg = Param;
|
|
|
|
Info.SecondArg = Arg;
|
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-05 08:53:49 +08:00
|
|
|
case TemplateArgument::Integral:
|
|
|
|
if (Arg.getKind() == TemplateArgument::Integral) {
|
2012-06-07 23:09:51 +08:00
|
|
|
if (hasSameExtendedValue(Param.getAsIntegral(), Arg.getAsIntegral()))
|
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;
|
2009-06-05 08:53:49 +08:00
|
|
|
}
|
|
|
|
|
2009-06-13 02:26:56 +08:00
|
|
|
Info.FirstArg = Param;
|
|
|
|
Info.SecondArg = Arg;
|
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-05 08:53:49 +08:00
|
|
|
case TemplateArgument::Expression: {
|
2009-09-09 23:08:12 +08:00
|
|
|
if (NonTypeTemplateParmDecl *NTTP
|
2009-06-05 08:53:49 +08:00
|
|
|
= getDeducedParameterFromExpr(Param.getAsExpr())) {
|
|
|
|
if (Arg.getKind() == TemplateArgument::Integral)
|
2016-09-29 07:55:27 +08:00
|
|
|
return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
|
2012-06-07 23:09:51 +08:00
|
|
|
Arg.getAsIntegral(),
|
2010-03-26 13:50:28 +08:00
|
|
|
Arg.getIntegralType(),
|
2010-03-28 10:42:43 +08:00
|
|
|
/*ArrayBound=*/false,
|
2009-06-13 02:26:56 +08:00
|
|
|
Info, Deduced);
|
2016-09-29 06:08:38 +08:00
|
|
|
if (Arg.getKind() == TemplateArgument::NullPtr)
|
2016-09-29 07:55:27 +08:00
|
|
|
return DeduceNullPtrTemplateArgument(S, TemplateParams, NTTP,
|
|
|
|
Arg.getNullPtrType(),
|
2016-09-29 06:08:38 +08:00
|
|
|
Info, Deduced);
|
2009-06-05 08:53:49 +08:00
|
|
|
if (Arg.getKind() == TemplateArgument::Expression)
|
2016-09-29 07:55:27 +08:00
|
|
|
return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
|
|
|
|
Arg.getAsExpr(), Info, Deduced);
|
2009-11-14 07:45:44 +08:00
|
|
|
if (Arg.getKind() == TemplateArgument::Declaration)
|
2016-09-29 07:55:27 +08:00
|
|
|
return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
|
|
|
|
Arg.getAsDecl(),
|
|
|
|
Arg.getParamTypeForDecl(),
|
2009-11-14 07:45:44 +08:00
|
|
|
Info, Deduced);
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-06-13 02:26:56 +08:00
|
|
|
Info.FirstArg = Param;
|
|
|
|
Info.SecondArg = Arg;
|
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-06-05 08:53:49 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-05 08:53:49 +08:00
|
|
|
// Can't deduce anything, but that's okay.
|
2009-06-13 02:26:56 +08:00
|
|
|
return Sema::TDK_Success;
|
2009-06-05 08:53:49 +08:00
|
|
|
}
|
2009-06-16 01:04:53 +08:00
|
|
|
case TemplateArgument::Pack:
|
2010-12-23 02:17:10 +08:00
|
|
|
llvm_unreachable("Argument packs should be expanded by the caller!");
|
2009-06-04 08:03:07 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2012-01-21 05:50:17 +08:00
|
|
|
llvm_unreachable("Invalid TemplateArgument Kind!");
|
2009-06-04 08:03:07 +08:00
|
|
|
}
|
|
|
|
|
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.
|
2011-01-27 15:10:08 +08:00
|
|
|
static bool hasTemplateArgumentForDeduction(const TemplateArgument *&Args,
|
2010-12-23 02:17:10 +08:00
|
|
|
unsigned &ArgIdx,
|
|
|
|
unsigned &NumArgs) {
|
|
|
|
if (ArgIdx == NumArgs)
|
|
|
|
return false;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-12-23 02:17:10 +08:00
|
|
|
const TemplateArgument &Arg = Args[ArgIdx];
|
|
|
|
if (Arg.getKind() != TemplateArgument::Pack)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
assert(ArgIdx == NumArgs - 1 && "Pack not at the end of argument list?");
|
|
|
|
Args = Arg.pack_begin();
|
|
|
|
NumArgs = Arg.pack_size();
|
|
|
|
ArgIdx = 0;
|
|
|
|
return ArgIdx < NumArgs;
|
|
|
|
}
|
|
|
|
|
2010-12-23 09:24:45 +08:00
|
|
|
/// \brief Determine whether the given set of template arguments has a pack
|
|
|
|
/// expansion that is not the last template argument.
|
|
|
|
static bool hasPackExpansionBeforeEnd(const TemplateArgument *Args,
|
|
|
|
unsigned NumArgs) {
|
|
|
|
unsigned ArgIdx = 0;
|
|
|
|
while (ArgIdx < NumArgs) {
|
|
|
|
const TemplateArgument &Arg = Args[ArgIdx];
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-12-23 09:24:45 +08:00
|
|
|
// Unwrap argument packs.
|
|
|
|
if (Args[ArgIdx].getKind() == TemplateArgument::Pack) {
|
|
|
|
Args = Arg.pack_begin();
|
|
|
|
NumArgs = Arg.pack_size();
|
|
|
|
ArgIdx = 0;
|
|
|
|
continue;
|
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-12-23 09:24:45 +08:00
|
|
|
++ArgIdx;
|
|
|
|
if (ArgIdx == NumArgs)
|
|
|
|
return false;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-12-23 09:24:45 +08:00
|
|
|
if (Arg.isPackExpansion())
|
|
|
|
return true;
|
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-12-23 09:24:45 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
static Sema::TemplateDeductionResult
|
2016-06-29 07:05:09 +08:00
|
|
|
DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
|
2010-12-23 02:17:10 +08:00
|
|
|
const TemplateArgument *Params, unsigned NumParams,
|
|
|
|
const TemplateArgument *Args, unsigned NumArgs,
|
2010-08-25 13:32:35 +08:00
|
|
|
TemplateDeductionInfo &Info,
|
2016-06-29 07:05:09 +08:00
|
|
|
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
|
|
|
|
bool NumberOfArgumentsMustMatch) {
|
2010-12-23 05:19:48 +08:00
|
|
|
// C++0x [temp.deduct.type]p9:
|
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
|
2010-12-23 05:19:48 +08:00
|
|
|
// non-deduced context.
|
2010-12-23 09:24:45 +08:00
|
|
|
if (hasPackExpansionBeforeEnd(Params, NumParams))
|
|
|
|
return Sema::TDK_Success;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-12-23 05:19:48 +08:00
|
|
|
// C++0x [temp.deduct.type]p9:
|
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
|
2010-12-23 05:19:48 +08:00
|
|
|
// argument Ai of the corresponding template argument list of A.
|
2010-12-23 02:17:10 +08:00
|
|
|
unsigned ArgIdx = 0, ParamIdx = 0;
|
2011-01-27 15:10:08 +08:00
|
|
|
for (; hasTemplateArgumentForDeduction(Params, ParamIdx, NumParams);
|
2010-12-23 02:17:10 +08:00
|
|
|
++ParamIdx) {
|
|
|
|
if (!Params[ParamIdx].isPackExpansion()) {
|
2010-12-23 05:19:48 +08:00
|
|
|
// The simple case: deduce template arguments by matching Pi and Ai.
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-12-23 02:17:10 +08:00
|
|
|
// Check whether we have enough arguments.
|
|
|
|
if (!hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs))
|
2016-06-29 07:05:09 +08:00
|
|
|
return NumberOfArgumentsMustMatch ? Sema::TDK_TooFewArguments
|
|
|
|
: Sema::TDK_Success;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-12 06:21:24 +08:00
|
|
|
if (Args[ArgIdx].isPackExpansion()) {
|
|
|
|
// FIXME: We follow the logic of C++0x [temp.deduct.type]p22 here,
|
|
|
|
// but applied to pack expansions that are template arguments.
|
2013-01-31 13:19:49 +08:00
|
|
|
return Sema::TDK_MiscellaneousDeductionFailure;
|
2011-01-12 06:21:24 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-12-23 05:19:48 +08:00
|
|
|
// Perform deduction for this Pi/Ai pair.
|
2010-12-23 02:17:10 +08:00
|
|
|
if (Sema::TemplateDeductionResult Result
|
2011-01-12 06:21:24 +08:00
|
|
|
= DeduceTemplateArguments(S, TemplateParams,
|
|
|
|
Params[ParamIdx], Args[ArgIdx],
|
|
|
|
Info, Deduced))
|
2011-01-27 15:10:08 +08:00
|
|
|
return Result;
|
|
|
|
|
2010-12-23 02:17:10 +08:00
|
|
|
// Move to the next argument.
|
|
|
|
++ArgIdx;
|
|
|
|
continue;
|
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-12-23 05:19:48 +08:00
|
|
|
// The parameter is a pack expansion.
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-12-23 05:19:48 +08:00
|
|
|
// C++0x [temp.deduct.type]p9:
|
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
|
2010-12-23 05:19:48 +08:00
|
|
|
// template parameter packs expanded by Pi.
|
|
|
|
TemplateArgument Pattern = Params[ParamIdx].getPackExpansionPattern();
|
2011-01-27 15:10:08 +08:00
|
|
|
|
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.
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2014-05-29 09:12:14 +08:00
|
|
|
// Prepare to deduce the packs within the pattern.
|
|
|
|
PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern);
|
2010-12-23 05:19:48 +08:00
|
|
|
|
|
|
|
// Keep track of the deduced template arguments for each parameter pack
|
2011-01-27 15:10:08 +08:00
|
|
|
// expanded by this pack expansion (the outer index) and for each
|
2010-12-23 05:19:48 +08:00
|
|
|
// template argument (the inner SmallVectors).
|
|
|
|
bool HasAnyArguments = false;
|
2014-05-29 09:12:14 +08:00
|
|
|
for (; hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs); ++ArgIdx) {
|
2010-12-23 05:19:48 +08:00
|
|
|
HasAnyArguments = true;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-12-23 05:19:48 +08:00
|
|
|
// Deduce template arguments from the pattern.
|
2011-01-27 15:10:08 +08:00
|
|
|
if (Sema::TemplateDeductionResult Result
|
2010-12-23 05:19:48 +08:00
|
|
|
= DeduceTemplateArguments(S, TemplateParams, Pattern, Args[ArgIdx],
|
|
|
|
Info, Deduced))
|
|
|
|
return Result;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2014-05-29 09:12:14 +08:00
|
|
|
PackScope.nextPackElement();
|
2010-12-23 05:19:48 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-12-23 05:19:48 +08:00
|
|
|
// Build argument packs for each of the parameter packs expanded by this
|
|
|
|
// pack expansion.
|
2014-05-29 09:12:14 +08:00
|
|
|
if (auto Result = PackScope.finish(HasAnyArguments))
|
2011-01-27 15:10:08 +08:00
|
|
|
return Result;
|
2009-06-04 08:03:07 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-06-13 02:26:56 +08:00
|
|
|
return Sema::TDK_Success;
|
2009-06-04 08:03:07 +08:00
|
|
|
}
|
|
|
|
|
2010-12-23 02:17:10 +08:00
|
|
|
static Sema::TemplateDeductionResult
|
|
|
|
DeduceTemplateArguments(Sema &S,
|
|
|
|
TemplateParameterList *TemplateParams,
|
|
|
|
const TemplateArgumentList &ParamList,
|
|
|
|
const TemplateArgumentList &ArgList,
|
|
|
|
TemplateDeductionInfo &Info,
|
2013-07-08 12:13:06 +08:00
|
|
|
SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
|
2011-01-27 15:10:08 +08:00
|
|
|
return DeduceTemplateArguments(S, TemplateParams,
|
2010-12-23 02:17:10 +08:00
|
|
|
ParamList.data(), ParamList.size(),
|
|
|
|
ArgList.data(), ArgList.size(),
|
2016-06-29 07:05:09 +08:00
|
|
|
Info, Deduced, false);
|
2010-12-23 02:17:10 +08:00
|
|
|
}
|
|
|
|
|
2009-06-27 04:57:09 +08:00
|
|
|
/// \brief Determine whether two template arguments are the same.
|
2009-09-09 23:08:12 +08:00
|
|
|
static bool isSameTemplateArg(ASTContext &Context,
|
2009-06-27 04:57:09 +08:00
|
|
|
const TemplateArgument &X,
|
|
|
|
const TemplateArgument &Y) {
|
|
|
|
if (X.getKind() != Y.getKind())
|
|
|
|
return false;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-27 04:57:09 +08:00
|
|
|
switch (X.getKind()) {
|
|
|
|
case TemplateArgument::Null:
|
2011-09-23 13:06:16 +08:00
|
|
|
llvm_unreachable("Comparing NULL template argument");
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-27 04:57:09 +08:00
|
|
|
case TemplateArgument::Type:
|
|
|
|
return Context.getCanonicalType(X.getAsType()) ==
|
|
|
|
Context.getCanonicalType(Y.getAsType());
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-27 04:57:09 +08:00
|
|
|
case TemplateArgument::Declaration:
|
2014-10-16 12:21:25 +08:00
|
|
|
return isSameDeclaration(X.getAsDecl(), Y.getAsDecl());
|
2012-09-26 10:36:12 +08:00
|
|
|
|
|
|
|
case TemplateArgument::NullPtr:
|
|
|
|
return Context.hasSameType(X.getNullPtrType(), Y.getNullPtrType());
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-11-11 09:00:40 +08:00
|
|
|
case TemplateArgument::Template:
|
2011-01-06 02:58:31 +08:00
|
|
|
case TemplateArgument::TemplateExpansion:
|
|
|
|
return Context.getCanonicalTemplateName(
|
|
|
|
X.getAsTemplateOrTemplatePattern()).getAsVoidPointer() ==
|
|
|
|
Context.getCanonicalTemplateName(
|
|
|
|
Y.getAsTemplateOrTemplatePattern()).getAsVoidPointer();
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-06-27 04:57:09 +08:00
|
|
|
case TemplateArgument::Integral:
|
2012-06-07 23:09:51 +08:00
|
|
|
return X.getAsIntegral() == Y.getAsIntegral();
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-11-11 09:00:40 +08:00
|
|
|
case TemplateArgument::Expression: {
|
|
|
|
llvm::FoldingSetNodeID XID, YID;
|
|
|
|
X.getAsExpr()->Profile(XID, Context, true);
|
2011-01-27 15:10:08 +08:00
|
|
|
Y.getAsExpr()->Profile(YID, Context, true);
|
2009-11-11 09:00:40 +08:00
|
|
|
return XID == YID;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-27 04:57:09 +08:00
|
|
|
case TemplateArgument::Pack:
|
|
|
|
if (X.pack_size() != Y.pack_size())
|
|
|
|
return false;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
|
|
|
for (TemplateArgument::pack_iterator XP = X.pack_begin(),
|
|
|
|
XPEnd = X.pack_end(),
|
2009-06-27 04:57:09 +08:00
|
|
|
YP = Y.pack_begin();
|
2009-09-09 23:08:12 +08:00
|
|
|
XP != XPEnd; ++XP, ++YP)
|
2009-06-27 04:57:09 +08:00
|
|
|
if (!isSameTemplateArg(Context, *XP, *YP))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-01-21 05:50:17 +08:00
|
|
|
llvm_unreachable("Invalid TemplateArgument Kind!");
|
2009-06-27 04:57:09 +08:00
|
|
|
}
|
|
|
|
|
2011-01-05 07:35:54 +08:00
|
|
|
/// \brief Allocate a TemplateArgumentLoc where all locations have
|
|
|
|
/// been initialized to the given location.
|
|
|
|
///
|
2012-06-15 05:40:34 +08:00
|
|
|
/// \param Arg The template argument we are producing template argument
|
2011-01-05 07:35:54 +08:00
|
|
|
/// location information for.
|
|
|
|
///
|
|
|
|
/// \param NTTPType For a declaration template argument, the type of
|
|
|
|
/// the non-type template parameter that corresponds to this template
|
|
|
|
/// argument.
|
|
|
|
///
|
|
|
|
/// \param Loc The source location to use for the resulting template
|
|
|
|
/// argument.
|
2016-08-12 06:25:46 +08:00
|
|
|
TemplateArgumentLoc
|
|
|
|
Sema::getTrivialTemplateArgumentLoc(const TemplateArgument &Arg,
|
|
|
|
QualType NTTPType, SourceLocation Loc) {
|
2011-01-05 07:35:54 +08:00
|
|
|
switch (Arg.getKind()) {
|
|
|
|
case TemplateArgument::Null:
|
|
|
|
llvm_unreachable("Can't get a NULL template argument here");
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-05 07:35:54 +08:00
|
|
|
case TemplateArgument::Type:
|
2016-08-12 06:25:46 +08:00
|
|
|
return TemplateArgumentLoc(
|
|
|
|
Arg, Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc));
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-05 07:35:54 +08:00
|
|
|
case TemplateArgument::Declaration: {
|
2016-08-12 06:25:46 +08:00
|
|
|
Expr *E = BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc)
|
|
|
|
.getAs<Expr>();
|
2011-01-05 07:35:54 +08:00
|
|
|
return TemplateArgumentLoc(TemplateArgument(E), E);
|
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2012-09-26 10:36:12 +08:00
|
|
|
case TemplateArgument::NullPtr: {
|
2016-08-12 06:25:46 +08:00
|
|
|
Expr *E = BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc)
|
|
|
|
.getAs<Expr>();
|
2012-09-26 10:36:12 +08:00
|
|
|
return TemplateArgumentLoc(TemplateArgument(NTTPType, /*isNullPtr*/true),
|
|
|
|
E);
|
|
|
|
}
|
|
|
|
|
2011-01-05 07:35:54 +08:00
|
|
|
case TemplateArgument::Integral: {
|
2016-08-12 06:25:46 +08:00
|
|
|
Expr *E =
|
|
|
|
BuildExpressionFromIntegralTemplateArgument(Arg, Loc).getAs<Expr>();
|
2011-01-05 07:35:54 +08:00
|
|
|
return TemplateArgumentLoc(TemplateArgument(E), E);
|
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
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())
|
2016-08-12 06:25:46 +08:00
|
|
|
Builder.MakeTrivial(Context, DTN->getQualifier(), Loc);
|
2014-07-28 08:02:09 +08:00
|
|
|
else if (QualifiedTemplateName *QTN =
|
|
|
|
Template.getAsQualifiedTemplateName())
|
2016-08-12 06:25:46 +08:00
|
|
|
Builder.MakeTrivial(Context, QTN->getQualifier(), Loc);
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2011-03-03 01:09:35 +08:00
|
|
|
if (Arg.getKind() == TemplateArgument::Template)
|
2016-08-12 06:25:46 +08:00
|
|
|
return TemplateArgumentLoc(Arg, Builder.getWithLocInContext(Context),
|
2011-03-03 01:09:35 +08:00
|
|
|
Loc);
|
2016-08-12 06:25:46 +08:00
|
|
|
|
|
|
|
return TemplateArgumentLoc(Arg, Builder.getWithLocInContext(Context),
|
2011-03-03 01:09:35 +08:00
|
|
|
Loc, Loc);
|
|
|
|
}
|
2011-01-06 02:58:31 +08:00
|
|
|
|
2011-01-05 07:35:54 +08:00
|
|
|
case TemplateArgument::Expression:
|
|
|
|
return TemplateArgumentLoc(Arg, Arg.getAsExpr());
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-05 07:35:54 +08:00
|
|
|
case TemplateArgument::Pack:
|
|
|
|
return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo());
|
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2012-01-21 05:50:17 +08:00
|
|
|
llvm_unreachable("Invalid TemplateArgument Kind!");
|
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.
|
2013-07-08 12:13:06 +08:00
|
|
|
static bool
|
|
|
|
ConvertDeducedTemplateArgument(Sema &S, NamedDecl *Param,
|
|
|
|
DeducedTemplateArgument Arg,
|
|
|
|
NamedDecl *Template,
|
|
|
|
TemplateDeductionInfo &Info,
|
|
|
|
bool InFunctionTemplate,
|
|
|
|
SmallVectorImpl<TemplateArgument> &Output) {
|
2016-02-04 04:15:01 +08:00
|
|
|
// First, for a non-type template parameter type that is
|
|
|
|
// initialized by a declaration, we need the type of the
|
|
|
|
// corresponding non-type template parameter.
|
|
|
|
QualType NTTPType;
|
|
|
|
if (NonTypeTemplateParmDecl *NTTP =
|
|
|
|
dyn_cast<NonTypeTemplateParmDecl>(Param)) {
|
|
|
|
NTTPType = NTTP->getType();
|
|
|
|
if (NTTPType->isDependentType()) {
|
2016-07-04 05:17:51 +08:00
|
|
|
TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Output);
|
2016-02-04 04:15:01 +08:00
|
|
|
NTTPType = S.SubstType(NTTPType,
|
|
|
|
MultiLevelTemplateArgumentList(TemplateArgs),
|
|
|
|
NTTP->getLocation(),
|
|
|
|
NTTP->getDeclName());
|
|
|
|
if (NTTPType.isNull())
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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 =
|
2016-08-12 06:25:46 +08:00
|
|
|
S.getTrivialTemplateArgumentLoc(Arg, NTTPType, Info.getLocation());
|
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,
|
|
|
|
InFunctionTemplate
|
|
|
|
? (Arg.wasDeducedFromArrayBound() ? Sema::CTAK_DeducedFromArrayBound
|
|
|
|
: Sema::CTAK_Deduced)
|
|
|
|
: Sema::CTAK_Specified);
|
|
|
|
};
|
|
|
|
|
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.
|
2011-07-23 18:55:15 +08:00
|
|
|
SmallVector<TemplateArgument, 2> PackedArgsBuilder;
|
2014-07-16 05:32:31 +08:00
|
|
|
for (const auto &P : Arg.pack_elements()) {
|
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.
|
2014-07-16 05:32:31 +08:00
|
|
|
DeducedTemplateArgument InnerArg(P);
|
2011-01-05 07:35:54 +08:00
|
|
|
InnerArg.setDeducedFromArrayBound(Arg.wasDeducedFromArrayBound());
|
2016-02-04 04:15:01 +08:00
|
|
|
assert(InnerArg.getKind() != TemplateArgument::Pack &&
|
|
|
|
"deduced nested pack");
|
|
|
|
if (ConvertArg(InnerArg, PackedArgsBuilder.size()))
|
2011-01-05 07:35:54 +08:00
|
|
|
return true;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-06 04:52:18 +08:00
|
|
|
// Move the converted template argument into our argument pack.
|
2013-08-24 00:11:15 +08:00
|
|
|
PackedArgsBuilder.push_back(Output.pop_back_val());
|
2011-01-05 07:35:54 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2016-02-04 04:40:30 +08:00
|
|
|
// If the pack is empty, we still need to substitute into the parameter
|
|
|
|
// itself, in case that substitution fails. For non-type parameters, we did
|
|
|
|
// this above. For type parameters, no substitution is ever required.
|
|
|
|
auto *TTP = dyn_cast<TemplateTemplateParmDecl>(Param);
|
|
|
|
if (TTP && PackedArgsBuilder.empty()) {
|
|
|
|
// Set up a template instantiation context.
|
|
|
|
LocalInstantiationScope Scope(S);
|
|
|
|
Sema::InstantiatingTemplate Inst(S, Template->getLocation(), Template,
|
|
|
|
TTP, Output,
|
|
|
|
Template->getSourceRange());
|
|
|
|
if (Inst.isInvalid())
|
|
|
|
return true;
|
|
|
|
|
2016-07-04 05:17:51 +08:00
|
|
|
TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Output);
|
2016-02-04 04:40:30 +08:00
|
|
|
if (!S.SubstDecl(TTP, S.CurContext,
|
|
|
|
MultiLevelTemplateArgumentList(TemplateArgs)))
|
|
|
|
return true;
|
|
|
|
}
|
2016-02-04 04:15:01 +08:00
|
|
|
|
2011-01-05 07:35:54 +08:00
|
|
|
// Create the resulting argument pack.
|
2015-08-05 17:40:22 +08:00
|
|
|
Output.push_back(
|
|
|
|
TemplateArgument::CreatePackCopy(S.Context, PackedArgsBuilder));
|
2011-01-05 07:35:54 +08:00
|
|
|
return false;
|
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2016-02-04 04:15:01 +08:00
|
|
|
return ConvertArg(Arg, 0);
|
2011-01-05 07:35:54 +08:00
|
|
|
}
|
|
|
|
|
2010-04-29 14:21:43 +08:00
|
|
|
/// Complete template argument deduction for a class template partial
|
|
|
|
/// specialization.
|
|
|
|
static Sema::TemplateDeductionResult
|
2011-01-27 15:10:08 +08:00
|
|
|
FinishTemplateArgumentDeduction(Sema &S,
|
2010-04-29 14:21:43 +08:00
|
|
|
ClassTemplatePartialSpecializationDecl *Partial,
|
|
|
|
const TemplateArgumentList &TemplateArgs,
|
2011-07-23 18:55:15 +08:00
|
|
|
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
|
2010-08-25 13:32:35 +08:00
|
|
|
TemplateDeductionInfo &Info) {
|
2012-02-08 11:07:05 +08:00
|
|
|
// Unevaluated SFINAE context.
|
|
|
|
EnterExpressionEvaluationContext Unevaluated(S, Sema::Unevaluated);
|
2010-04-29 14:21:43 +08:00
|
|
|
Sema::SFINAETrap Trap(S);
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-04-29 14:21:43 +08:00
|
|
|
Sema::ContextRAII SavedContext(S, Partial);
|
2010-04-29 08:35:03 +08:00
|
|
|
|
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.
|
2011-07-23 18:55:15 +08:00
|
|
|
SmallVector<TemplateArgument, 4> Builder;
|
2011-01-05 06:23:38 +08:00
|
|
|
TemplateParameterList *PartialParams = Partial->getTemplateParameters();
|
|
|
|
for (unsigned I = 0, N = PartialParams->size(); I != N; ++I) {
|
2011-01-05 07:35:54 +08:00
|
|
|
NamedDecl *Param = PartialParams->getParam(I);
|
2009-06-13 02:26:56 +08:00
|
|
|
if (Deduced[I].isNull()) {
|
2011-01-05 07:35:54 +08:00
|
|
|
Info.Param = makeTemplateParameter(Param);
|
2010-04-29 14:21:43 +08:00
|
|
|
return Sema::TDK_Incomplete;
|
2009-06-13 02:26:56 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-05 07:35:54 +08:00
|
|
|
// We have deduced this argument, so it still needs to be
|
|
|
|
// checked and converted.
|
|
|
|
if (ConvertDeducedTemplateArgument(S, Param, Deduced[I],
|
2016-02-04 04:15:01 +08:00
|
|
|
Partial, Info, false,
|
2011-01-05 07:35:54 +08:00
|
|
|
Builder)) {
|
|
|
|
Info.Param = makeTemplateParameter(Param);
|
|
|
|
// FIXME: These template arguments are temporary. Free them!
|
2016-07-04 05:17:51 +08:00
|
|
|
Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder));
|
2011-01-05 07:35:54 +08:00
|
|
|
return Sema::TDK_SubstitutionFailure;
|
|
|
|
}
|
2009-06-12 02:10:32 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-06-12 02:10:32 +08:00
|
|
|
// Form the template argument list from the deduced template arguments.
|
2009-09-09 23:08:12 +08:00
|
|
|
TemplateArgumentList *DeducedArgumentList
|
2016-07-04 05:17:51 +08:00
|
|
|
= TemplateArgumentList::CreateCopy(S.Context, Builder);
|
2010-11-08 07:05:16 +08:00
|
|
|
|
2009-06-13 02:26:56 +08:00
|
|
|
Info.reset(DeducedArgumentList);
|
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
|
2009-09-09 23:08:12 +08:00
|
|
|
// to the class template.
|
2010-08-25 13:32:35 +08:00
|
|
|
LocalInstantiationScope InstScope(S);
|
2009-06-12 02:10:32 +08:00
|
|
|
ClassTemplateDecl *ClassTemplate = Partial->getSpecializedTemplate();
|
2013-08-10 15:24:53 +08:00
|
|
|
const ASTTemplateArgumentListInfo *PartialTemplArgInfo
|
2009-10-29 16:12:44 +08:00
|
|
|
= Partial->getTemplateArgsAsWritten();
|
2013-08-10 15:24:53 +08:00
|
|
|
const TemplateArgumentLoc *PartialTemplateArgs
|
|
|
|
= PartialTemplArgInfo->getTemplateArgs();
|
2009-11-23 09:53:49 +08:00
|
|
|
|
2013-08-10 15:24:53 +08:00
|
|
|
TemplateArgumentListInfo InstArgs(PartialTemplArgInfo->LAngleLoc,
|
|
|
|
PartialTemplArgInfo->RAngleLoc);
|
2009-11-23 09:53:49 +08:00
|
|
|
|
2013-08-10 15:24:53 +08:00
|
|
|
if (S.Subst(PartialTemplateArgs, PartialTemplArgInfo->NumTemplateArgs,
|
2010-12-23 05:19:48 +08:00
|
|
|
InstArgs, MultiLevelTemplateArgumentList(*DeducedArgumentList))) {
|
|
|
|
unsigned ArgIdx = InstArgs.size(), ParamIdx = ArgIdx;
|
|
|
|
if (ParamIdx >= Partial->getTemplateParameters()->size())
|
|
|
|
ParamIdx = Partial->getTemplateParameters()->size() - 1;
|
|
|
|
|
|
|
|
Decl *Param
|
|
|
|
= const_cast<NamedDecl *>(
|
|
|
|
Partial->getTemplateParameters()->getParam(ParamIdx));
|
|
|
|
Info.Param = makeTemplateParameter(Param);
|
|
|
|
Info.FirstArg = PartialTemplateArgs[ArgIdx].getArgument();
|
|
|
|
return Sema::TDK_SubstitutionFailure;
|
2009-10-29 16:12:44 +08:00
|
|
|
}
|
|
|
|
|
2011-07-23 18:55:15 +08:00
|
|
|
SmallVector<TemplateArgument, 4> ConvertedInstArgs;
|
2010-04-29 14:21:43 +08:00
|
|
|
if (S.CheckTemplateArgumentList(ClassTemplate, Partial->getLocation(),
|
2011-01-05 07:35:54 +08:00
|
|
|
InstArgs, false, ConvertedInstArgs))
|
2010-04-29 14:21:43 +08:00
|
|
|
return Sema::TDK_SubstitutionFailure;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-05 07:35:54 +08:00
|
|
|
TemplateParameterList *TemplateParams
|
|
|
|
= ClassTemplate->getTemplateParameters();
|
|
|
|
for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) {
|
2010-11-08 07:05:16 +08:00
|
|
|
TemplateArgument InstArg = ConvertedInstArgs.data()[I];
|
2010-04-29 14:21:43 +08:00
|
|
|
if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg)) {
|
2011-01-05 08:13:17 +08:00
|
|
|
Info.Param = makeTemplateParameter(TemplateParams->getParam(I));
|
2009-06-27 04:57:09 +08:00
|
|
|
Info.FirstArg = TemplateArgs[I];
|
|
|
|
Info.SecondArg = InstArg;
|
2010-04-29 14:21:43 +08:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-06-27 04:57:09 +08:00
|
|
|
}
|
2009-06-12 02:10:32 +08:00
|
|
|
}
|
|
|
|
|
2009-06-14 16:02:22 +08:00
|
|
|
if (Trap.hasErrorOccurred())
|
2010-04-29 14:21:43 +08:00
|
|
|
return Sema::TDK_SubstitutionFailure;
|
2009-06-14 16:02:22 +08:00
|
|
|
|
2010-04-29 14:21:43 +08:00
|
|
|
return Sema::TDK_Success;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief Perform template argument deduction to determine whether
|
2013-08-06 15:33:00 +08:00
|
|
|
/// the given template arguments match the given class template
|
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) {
|
2012-09-14 05:01:57 +08:00
|
|
|
if (Partial->isInvalidDecl())
|
|
|
|
return TDK_Invalid;
|
|
|
|
|
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).
|
2012-02-08 11:07:05 +08:00
|
|
|
|
|
|
|
// Unevaluated SFINAE context.
|
|
|
|
EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
|
2010-04-29 14:21:43 +08:00
|
|
|
SFINAETrap Trap(*this);
|
2012-02-08 11:07:05 +08:00
|
|
|
|
2011-07-23 18:55:15 +08:00
|
|
|
SmallVector<DeducedTemplateArgument, 4> Deduced;
|
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;
|
|
|
|
|
2012-07-16 09:09:10 +08:00
|
|
|
SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end());
|
2014-01-11 10:37:12 +08:00
|
|
|
InstantiatingTemplate Inst(*this, Info.getLocation(), Partial, DeducedArgs,
|
|
|
|
Info);
|
2013-10-08 16:09:04 +08:00
|
|
|
if (Inst.isInvalid())
|
2010-04-29 14:21:43 +08:00
|
|
|
return TDK_InstantiationDepth;
|
|
|
|
|
|
|
|
if (Trap.hasErrorOccurred())
|
|
|
|
return Sema::TDK_SubstitutionFailure;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
|
|
|
return ::FinishTemplateArgumentDeduction(*this, Partial, TemplateArgs,
|
2010-04-29 14:21:43 +08:00
|
|
|
Deduced, Info);
|
2009-06-04 08:03:07 +08:00
|
|
|
}
|
2009-06-13 08:26:55 +08:00
|
|
|
|
2013-08-06 09:03:05 +08:00
|
|
|
/// Complete template argument deduction for a variable template partial
|
|
|
|
/// specialization.
|
2013-08-24 06:21:36 +08:00
|
|
|
/// TODO: Unify with ClassTemplatePartialSpecializationDecl version?
|
|
|
|
/// May require unifying ClassTemplate(Partial)SpecializationDecl and
|
|
|
|
/// VarTemplate(Partial)SpecializationDecl with a new data
|
|
|
|
/// structure Template(Partial)SpecializationDecl, and
|
|
|
|
/// using Template(Partial)SpecializationDecl as input type.
|
2013-08-06 09:03:05 +08:00
|
|
|
static Sema::TemplateDeductionResult FinishTemplateArgumentDeduction(
|
|
|
|
Sema &S, VarTemplatePartialSpecializationDecl *Partial,
|
|
|
|
const TemplateArgumentList &TemplateArgs,
|
|
|
|
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
|
|
|
|
TemplateDeductionInfo &Info) {
|
|
|
|
// Unevaluated SFINAE context.
|
|
|
|
EnterExpressionEvaluationContext Unevaluated(S, Sema::Unevaluated);
|
|
|
|
Sema::SFINAETrap Trap(S);
|
|
|
|
|
|
|
|
// C++ [temp.deduct.type]p2:
|
|
|
|
// [...] or if any template argument remains neither deduced nor
|
|
|
|
// explicitly specified, template argument deduction fails.
|
|
|
|
SmallVector<TemplateArgument, 4> Builder;
|
|
|
|
TemplateParameterList *PartialParams = Partial->getTemplateParameters();
|
|
|
|
for (unsigned I = 0, N = PartialParams->size(); I != N; ++I) {
|
|
|
|
NamedDecl *Param = PartialParams->getParam(I);
|
|
|
|
if (Deduced[I].isNull()) {
|
|
|
|
Info.Param = makeTemplateParameter(Param);
|
|
|
|
return Sema::TDK_Incomplete;
|
|
|
|
}
|
|
|
|
|
|
|
|
// We have deduced this argument, so it still needs to be
|
|
|
|
// checked and converted.
|
2016-02-04 04:15:01 +08:00
|
|
|
if (ConvertDeducedTemplateArgument(S, Param, Deduced[I], Partial,
|
|
|
|
Info, false, Builder)) {
|
2013-08-06 09:03:05 +08:00
|
|
|
Info.Param = makeTemplateParameter(Param);
|
|
|
|
// FIXME: These template arguments are temporary. Free them!
|
2016-07-04 05:17:51 +08:00
|
|
|
Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder));
|
2013-08-06 09:03:05 +08:00
|
|
|
return Sema::TDK_SubstitutionFailure;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Form the template argument list from the deduced template arguments.
|
|
|
|
TemplateArgumentList *DeducedArgumentList = TemplateArgumentList::CreateCopy(
|
2016-07-04 05:17:51 +08:00
|
|
|
S.Context, Builder);
|
2013-08-06 09:03:05 +08:00
|
|
|
|
|
|
|
Info.reset(DeducedArgumentList);
|
|
|
|
|
|
|
|
// Substitute the deduced template arguments into the template
|
|
|
|
// arguments of the class template partial specialization, and
|
|
|
|
// verify that the instantiated template arguments are both valid
|
|
|
|
// and are equivalent to the template arguments originally provided
|
|
|
|
// to the class template.
|
|
|
|
LocalInstantiationScope InstScope(S);
|
|
|
|
VarTemplateDecl *VarTemplate = Partial->getSpecializedTemplate();
|
2013-08-10 15:24:53 +08:00
|
|
|
const ASTTemplateArgumentListInfo *PartialTemplArgInfo
|
|
|
|
= Partial->getTemplateArgsAsWritten();
|
|
|
|
const TemplateArgumentLoc *PartialTemplateArgs
|
|
|
|
= PartialTemplArgInfo->getTemplateArgs();
|
2013-08-06 09:03:05 +08:00
|
|
|
|
2013-08-10 15:24:53 +08:00
|
|
|
TemplateArgumentListInfo InstArgs(PartialTemplArgInfo->LAngleLoc,
|
|
|
|
PartialTemplArgInfo->RAngleLoc);
|
2013-08-06 09:03:05 +08:00
|
|
|
|
2013-08-10 15:24:53 +08:00
|
|
|
if (S.Subst(PartialTemplateArgs, PartialTemplArgInfo->NumTemplateArgs,
|
2013-08-06 09:03:05 +08:00
|
|
|
InstArgs, MultiLevelTemplateArgumentList(*DeducedArgumentList))) {
|
|
|
|
unsigned ArgIdx = InstArgs.size(), ParamIdx = ArgIdx;
|
|
|
|
if (ParamIdx >= Partial->getTemplateParameters()->size())
|
|
|
|
ParamIdx = Partial->getTemplateParameters()->size() - 1;
|
|
|
|
|
|
|
|
Decl *Param = const_cast<NamedDecl *>(
|
|
|
|
Partial->getTemplateParameters()->getParam(ParamIdx));
|
|
|
|
Info.Param = makeTemplateParameter(Param);
|
|
|
|
Info.FirstArg = PartialTemplateArgs[ArgIdx].getArgument();
|
|
|
|
return Sema::TDK_SubstitutionFailure;
|
|
|
|
}
|
|
|
|
SmallVector<TemplateArgument, 4> ConvertedInstArgs;
|
|
|
|
if (S.CheckTemplateArgumentList(VarTemplate, Partial->getLocation(), InstArgs,
|
|
|
|
false, ConvertedInstArgs))
|
|
|
|
return Sema::TDK_SubstitutionFailure;
|
|
|
|
|
|
|
|
TemplateParameterList *TemplateParams = VarTemplate->getTemplateParameters();
|
|
|
|
for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) {
|
|
|
|
TemplateArgument InstArg = ConvertedInstArgs.data()[I];
|
|
|
|
if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg)) {
|
|
|
|
Info.Param = makeTemplateParameter(TemplateParams->getParam(I));
|
|
|
|
Info.FirstArg = TemplateArgs[I];
|
|
|
|
Info.SecondArg = InstArg;
|
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Trap.hasErrorOccurred())
|
|
|
|
return Sema::TDK_SubstitutionFailure;
|
|
|
|
|
|
|
|
return Sema::TDK_Success;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief Perform template argument deduction to determine whether
|
|
|
|
/// the given template arguments match the given variable template
|
|
|
|
/// partial specialization per C++ [temp.class.spec.match].
|
2013-08-24 06:21:36 +08:00
|
|
|
/// TODO: Unify with ClassTemplatePartialSpecializationDecl version?
|
|
|
|
/// May require unifying ClassTemplate(Partial)SpecializationDecl and
|
|
|
|
/// VarTemplate(Partial)SpecializationDecl with a new data
|
|
|
|
/// structure Template(Partial)SpecializationDecl, and
|
|
|
|
/// using Template(Partial)SpecializationDecl as input type.
|
2013-08-06 09:03:05 +08:00
|
|
|
Sema::TemplateDeductionResult
|
|
|
|
Sema::DeduceTemplateArguments(VarTemplatePartialSpecializationDecl *Partial,
|
|
|
|
const TemplateArgumentList &TemplateArgs,
|
|
|
|
TemplateDeductionInfo &Info) {
|
|
|
|
if (Partial->isInvalidDecl())
|
|
|
|
return TDK_Invalid;
|
|
|
|
|
|
|
|
// C++ [temp.class.spec.match]p2:
|
|
|
|
// A partial specialization matches a given actual template
|
|
|
|
// argument list if the template arguments of the partial
|
|
|
|
// specialization can be deduced from the actual template argument
|
|
|
|
// list (14.8.2).
|
|
|
|
|
|
|
|
// Unevaluated SFINAE context.
|
|
|
|
EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
|
|
|
|
SFINAETrap Trap(*this);
|
|
|
|
|
|
|
|
SmallVector<DeducedTemplateArgument, 4> Deduced;
|
|
|
|
Deduced.resize(Partial->getTemplateParameters()->size());
|
|
|
|
if (TemplateDeductionResult Result = ::DeduceTemplateArguments(
|
|
|
|
*this, Partial->getTemplateParameters(), Partial->getTemplateArgs(),
|
|
|
|
TemplateArgs, Info, Deduced))
|
|
|
|
return Result;
|
|
|
|
|
|
|
|
SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end());
|
2014-01-11 10:37:12 +08:00
|
|
|
InstantiatingTemplate Inst(*this, Info.getLocation(), Partial, DeducedArgs,
|
|
|
|
Info);
|
2013-10-08 16:09:04 +08:00
|
|
|
if (Inst.isInvalid())
|
2013-08-06 09:03:05 +08:00
|
|
|
return TDK_InstantiationDepth;
|
|
|
|
|
|
|
|
if (Trap.hasErrorOccurred())
|
|
|
|
return Sema::TDK_SubstitutionFailure;
|
|
|
|
|
|
|
|
return ::FinishTemplateArgumentDeduction(*this, Partial, TemplateArgs,
|
|
|
|
Deduced, Info);
|
|
|
|
}
|
|
|
|
|
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) {
|
2009-09-09 23:08:12 +08:00
|
|
|
if (const TemplateSpecializationType *Spec
|
2009-09-22 07:43:11 +08:00
|
|
|
= T->getAs<TemplateSpecializationType>())
|
2014-05-26 14:22:03 +08:00
|
|
|
return Spec->getTemplateName().getAsTemplateDecl() != nullptr;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-27 07:27:24 +08:00
|
|
|
return false;
|
|
|
|
}
|
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.
|
|
|
|
///
|
2012-06-15 05:40:34 +08:00
|
|
|
/// \param ExplicitTemplateArgs the explicitly-specified template
|
2009-07-09 04:55:45 +08:00
|
|
|
/// arguments.
|
|
|
|
///
|
2009-09-09 23:08:12 +08:00
|
|
|
/// \param Deduced the deduced template arguments, which will be populated
|
2009-07-09 04:55:45 +08:00
|
|
|
/// with the converted and checked explicit template arguments.
|
|
|
|
///
|
2009-09-09 23:08:12 +08:00
|
|
|
/// \param ParamTypes will be populated with the instantiated function
|
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,
|
2011-03-03 10:41:12 +08:00
|
|
|
TemplateArgumentListInfo &ExplicitTemplateArgs,
|
2011-07-23 18:55:15 +08:00
|
|
|
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
|
|
|
|
SmallVectorImpl<QualType> &ParamTypes,
|
2009-07-09 04:55:45 +08:00
|
|
|
QualType *FunctionType,
|
|
|
|
TemplateDeductionInfo &Info) {
|
|
|
|
FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
|
|
|
|
TemplateParameterList *TemplateParams
|
|
|
|
= FunctionTemplate->getTemplateParameters();
|
|
|
|
|
2009-11-23 09:53:49 +08:00
|
|
|
if (ExplicitTemplateArgs.size() == 0) {
|
2009-07-09 04:55:45 +08:00
|
|
|
// No arguments to substitute; just copy over the parameter types and
|
|
|
|
// fill in the function type.
|
2016-06-24 12:05:48 +08:00
|
|
|
for (auto P : Function->parameters())
|
2014-03-07 23:12:56 +08:00
|
|
|
ParamTypes.push_back(P->getType());
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-09 04:55:45 +08:00
|
|
|
if (FunctionType)
|
|
|
|
*FunctionType = Function->getType();
|
|
|
|
return TDK_Success;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2012-02-08 11:07:05 +08:00
|
|
|
// Unevaluated SFINAE context.
|
|
|
|
EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
|
2009-09-09 23:08:12 +08:00
|
|
|
SFINAETrap Trap(*this);
|
|
|
|
|
2009-07-09 04:55:45 +08:00
|
|
|
// C++ [temp.arg.explicit]p3:
|
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
|
2009-07-09 04:55:45 +08:00
|
|
|
// template argument list shall not specify more template-arguments than
|
2009-09-09 23:08:12 +08:00
|
|
|
// there are corresponding template-parameters.
|
2011-07-23 18:55:15 +08:00
|
|
|
SmallVector<TemplateArgument, 4> Builder;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
|
|
|
// Enter a new template instantiation context where we check the
|
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.
|
2012-07-16 09:09:10 +08:00
|
|
|
SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end());
|
2014-01-11 10:37:12 +08:00
|
|
|
InstantiatingTemplate Inst(*this, Info.getLocation(), FunctionTemplate,
|
|
|
|
DeducedArgs,
|
2010-10-13 07:32:35 +08:00
|
|
|
ActiveTemplateInstantiation::ExplicitTemplateArgumentSubstitution,
|
|
|
|
Info);
|
2013-10-08 16:09:04 +08:00
|
|
|
if (Inst.isInvalid())
|
2009-07-09 04:55:45 +08:00
|
|
|
return TDK_InstantiationDepth;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-09 04:55:45 +08:00
|
|
|
if (CheckTemplateArgumentList(FunctionTemplate,
|
|
|
|
SourceLocation(),
|
2009-11-23 09:53:49 +08:00
|
|
|
ExplicitTemplateArgs,
|
2009-07-09 04:55:45 +08:00
|
|
|
true,
|
2010-05-09 03:15:54 +08:00
|
|
|
Builder) || Trap.hasErrorOccurred()) {
|
2010-11-08 07:05:16 +08:00
|
|
|
unsigned Index = Builder.size();
|
2010-05-09 09:26:06 +08:00
|
|
|
if (Index >= TemplateParams->size())
|
|
|
|
Index = TemplateParams->size() - 1;
|
|
|
|
Info.Param = makeTemplateParameter(TemplateParams->getParam(Index));
|
2009-07-09 04:55:45 +08:00
|
|
|
return TDK_InvalidExplicitArguments;
|
2010-05-09 03:15:54 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-09 04:55:45 +08:00
|
|
|
// Form the template argument list from the explicitly-specified
|
|
|
|
// template arguments.
|
2009-09-09 23:08:12 +08:00
|
|
|
TemplateArgumentList *ExplicitArgumentList
|
2016-07-04 05:17:51 +08:00
|
|
|
= TemplateArgumentList::CreateCopy(Context, Builder);
|
2009-07-09 04:55:45 +08:00
|
|
|
Info.reset(ExplicitArgumentList);
|
2011-01-27 15:10:08 +08:00
|
|
|
|
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());
|
|
|
|
|
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(
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-02-10 17:58:53 +08:00
|
|
|
const FunctionProtoType *Proto
|
|
|
|
= Function->getType()->getAs<FunctionProtoType>();
|
|
|
|
assert(Proto && "Function template does not have a prototype?");
|
|
|
|
|
2015-01-09 09:19:56 +08:00
|
|
|
// Isolate our substituted parameters from our caller.
|
|
|
|
LocalInstantiationScope InstScope(*this, /*MergeWithOuterScope*/true);
|
|
|
|
|
2016-03-01 10:09:25 +08:00
|
|
|
ExtParameterInfoBuilder ExtParamInfos;
|
|
|
|
|
2009-07-09 04:55:45 +08:00
|
|
|
// Instantiate the types of each of the function parameters given the
|
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.
|
2012-04-16 15:05:22 +08:00
|
|
|
if (Proto->hasTrailingReturn()) {
|
2016-06-24 12:05:48 +08:00
|
|
|
if (SubstParmTypes(Function->getLocation(), Function->parameters(),
|
2016-03-01 10:09:25 +08:00
|
|
|
Proto->getExtParameterInfosOrNull(),
|
2012-04-16 15:05:22 +08:00
|
|
|
MultiLevelTemplateArgumentList(*ExplicitArgumentList),
|
2016-03-01 10:09:25 +08:00
|
|
|
ParamTypes, /*params*/ nullptr, ExtParamInfos))
|
2012-04-16 15:05:22 +08:00
|
|
|
return TDK_SubstitutionFailure;
|
|
|
|
}
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2012-02-10 17:58:53 +08:00
|
|
|
// Instantiate the return type.
|
2012-04-16 15:05:22 +08:00
|
|
|
QualType ResultType;
|
|
|
|
{
|
|
|
|
// C++11 [expr.prim.general]p3:
|
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
|
2012-04-16 15:05:22 +08:00
|
|
|
// "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq
|
2016-08-12 19:43:57 +08:00
|
|
|
// and the end of the function-definition, member-declarator, or
|
2012-04-16 15:05:22 +08:00
|
|
|
// declarator.
|
|
|
|
unsigned ThisTypeQuals = 0;
|
2014-05-26 14:22:03 +08:00
|
|
|
CXXRecordDecl *ThisContext = nullptr;
|
2012-04-16 15:05:22 +08:00
|
|
|
if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) {
|
|
|
|
ThisContext = Method->getParent();
|
|
|
|
ThisTypeQuals = Method->getTypeQualifiers();
|
|
|
|
}
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2012-04-16 15:05:22 +08:00
|
|
|
CXXThisScopeRAII ThisScope(*this, ThisContext, ThisTypeQuals,
|
2013-01-02 19:42:31 +08:00
|
|
|
getLangOpts().CPlusPlus11);
|
2014-01-26 00:55:45 +08:00
|
|
|
|
|
|
|
ResultType =
|
|
|
|
SubstType(Proto->getReturnType(),
|
|
|
|
MultiLevelTemplateArgumentList(*ExplicitArgumentList),
|
|
|
|
Function->getTypeSpecStartLoc(), Function->getDeclName());
|
2012-04-16 15:05:22 +08:00
|
|
|
if (ResultType.isNull() || Trap.hasErrorOccurred())
|
|
|
|
return TDK_SubstitutionFailure;
|
|
|
|
}
|
2016-03-01 10:09:25 +08:00
|
|
|
|
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() &&
|
2016-06-24 12:05:48 +08:00
|
|
|
SubstParmTypes(Function->getLocation(), Function->parameters(),
|
2016-03-01 10:09:25 +08:00
|
|
|
Proto->getExtParameterInfosOrNull(),
|
2012-02-10 17:58:53 +08:00
|
|
|
MultiLevelTemplateArgumentList(*ExplicitArgumentList),
|
2016-03-01 10:09:25 +08:00
|
|
|
ParamTypes, /*params*/ nullptr, ExtParamInfos))
|
2012-02-10 17:58:53 +08:00
|
|
|
return TDK_SubstitutionFailure;
|
|
|
|
|
|
|
|
if (FunctionType) {
|
2016-03-01 10:09:25 +08:00
|
|
|
auto EPI = Proto->getExtProtoInfo();
|
|
|
|
EPI.ExtParameterInfos = ExtParamInfos.getPointerOrNull(ParamTypes.size());
|
2013-03-09 05:51:21 +08:00
|
|
|
*FunctionType = BuildFunctionType(ResultType, ParamTypes,
|
2009-07-09 04:55:45 +08:00
|
|
|
Function->getLocation(),
|
2010-08-05 10:54:05 +08:00
|
|
|
Function->getDeclName(),
|
2016-03-01 10:09:25 +08:00
|
|
|
EPI);
|
2009-07-09 04:55:45 +08:00
|
|
|
if (FunctionType->isNull() || Trap.hasErrorOccurred())
|
|
|
|
return TDK_SubstitutionFailure;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-09 04:55:45 +08:00
|
|
|
// C++ [temp.arg.explicit]p2:
|
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
|
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.
|
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);
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-09 04:55:45 +08:00
|
|
|
return TDK_Success;
|
|
|
|
}
|
|
|
|
|
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.
|
2016-08-12 19:43:57 +08:00
|
|
|
static bool
|
|
|
|
CheckOriginalCallArgDeduction(Sema &S, Sema::OriginalCallArg OriginalArg,
|
2011-06-17 13:18:17 +08:00
|
|
|
QualType DeducedA) {
|
|
|
|
ASTContext &Context = S.Context;
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2011-06-17 13:18:17 +08:00
|
|
|
QualType A = OriginalArg.OriginalArgType;
|
|
|
|
QualType OriginalParamType = OriginalArg.OriginalParamType;
|
2016-08-12 19:43:57 +08:00
|
|
|
|
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;
|
2016-08-12 19:43:57 +08:00
|
|
|
|
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();
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2011-06-17 13:18:17 +08:00
|
|
|
// C++ [temp.deduct.call]p4:
|
|
|
|
// [...] However, there are three cases that allow a difference:
|
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
|
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();
|
2016-08-12 19:43:57 +08:00
|
|
|
|
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;
|
|
|
|
|
2011-06-17 13:18:17 +08:00
|
|
|
Qualifiers AQuals = A.getQualifiers();
|
|
|
|
Qualifiers DeducedAQuals = DeducedA.getQualifiers();
|
2012-07-18 08:14:59 +08:00
|
|
|
|
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.
|
2012-07-18 08:14:59 +08:00
|
|
|
if (S.getLangOpts().ObjCAutoRefCount &&
|
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());
|
2012-07-18 08:14:59 +08:00
|
|
|
}
|
|
|
|
|
2011-06-17 13:18:17 +08:00
|
|
|
if (AQuals == DeducedAQuals) {
|
|
|
|
// Qualifiers match; there's nothing to do.
|
|
|
|
} else if (!DeducedAQuals.compatiblyIncludes(AQuals)) {
|
2011-06-17 22:36:00 +08:00
|
|
|
return true;
|
2016-08-12 19:43:57 +08:00
|
|
|
} else {
|
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);
|
|
|
|
}
|
|
|
|
}
|
2016-08-12 19:43:57 +08:00
|
|
|
|
|
|
|
// - The transformed A can be another pointer or pointer to member
|
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.
|
2011-06-18 09:19:03 +08:00
|
|
|
//
|
2016-10-22 09:32:19 +08:00
|
|
|
// Also allow conversions which merely strip __attribute__((noreturn)) from
|
|
|
|
// function types (recursively).
|
2011-06-17 13:18:17 +08:00
|
|
|
bool ObjCLifetimeConversion = false;
|
2011-06-18 09:19:03 +08:00
|
|
|
QualType ResultTy;
|
2011-06-17 13:18:17 +08:00
|
|
|
if ((A->isAnyPointerType() || A->isMemberPointerType()) &&
|
2011-06-18 09:19:03 +08:00
|
|
|
(S.IsQualificationConversion(A, DeducedA, false,
|
|
|
|
ObjCLifetimeConversion) ||
|
2016-10-17 01:54:23 +08:00
|
|
|
S.IsFunctionConversion(A, DeducedA, ResultTy)))
|
2011-06-17 13:18:17 +08:00
|
|
|
return false;
|
2016-08-12 19:43:57 +08:00
|
|
|
|
|
|
|
// - If P is a class and P has the form simple-template-id, then the
|
2011-06-17 13:18:17 +08:00
|
|
|
// transformed A can be a derived class of the deduced A. [...]
|
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
|
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();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2011-06-17 13:18:17 +08:00
|
|
|
if (Context.hasSameUnqualifiedType(A, DeducedA))
|
|
|
|
return false;
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2011-06-17 13:18:17 +08:00
|
|
|
if (A->isRecordType() && isSimpleTemplateIdType(OriginalParamType) &&
|
2015-12-19 05:45:41 +08:00
|
|
|
S.IsDerivedFrom(SourceLocation(), A, DeducedA))
|
2011-06-17 13:18:17 +08:00
|
|
|
return false;
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2011-06-17 13:18:17 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
/// \brief Finish template argument deduction for a function template,
|
2009-07-09 04:55:45 +08:00
|
|
|
/// checking the deduced template arguments for completeness and forming
|
|
|
|
/// the function template specialization.
|
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.
|
2009-09-09 23:08:12 +08:00
|
|
|
Sema::TemplateDeductionResult
|
2009-07-09 04:55:45 +08:00
|
|
|
Sema::FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate,
|
2011-07-23 18:55:15 +08:00
|
|
|
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
|
2010-03-28 10:42:43 +08:00
|
|
|
unsigned NumExplicitlySpecified,
|
2009-07-09 04:55:45 +08:00
|
|
|
FunctionDecl *&Specialization,
|
2011-06-17 00:50:48 +08:00
|
|
|
TemplateDeductionInfo &Info,
|
2015-01-22 00:24:11 +08:00
|
|
|
SmallVectorImpl<OriginalCallArg> const *OriginalCallArgs,
|
|
|
|
bool PartialOverloading) {
|
2009-07-09 04:55:45 +08:00
|
|
|
TemplateParameterList *TemplateParams
|
|
|
|
= FunctionTemplate->getTemplateParameters();
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2012-02-08 11:07:05 +08:00
|
|
|
// Unevaluated SFINAE context.
|
|
|
|
EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
|
2009-11-26 02:55:14 +08:00
|
|
|
SFINAETrap Trap(*this);
|
|
|
|
|
|
|
|
// Enter a new template instantiation context while we instantiate the
|
|
|
|
// actual function declaration.
|
2012-07-16 09:09:10 +08:00
|
|
|
SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end());
|
2014-01-11 10:37:12 +08:00
|
|
|
InstantiatingTemplate Inst(*this, Info.getLocation(), FunctionTemplate,
|
|
|
|
DeducedArgs,
|
2010-10-13 07:32:35 +08:00
|
|
|
ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution,
|
|
|
|
Info);
|
2013-10-08 16:09:04 +08:00
|
|
|
if (Inst.isInvalid())
|
2009-11-26 02:55:14 +08:00
|
|
|
return TDK_InstantiationDepth;
|
|
|
|
|
2010-04-29 09:18:58 +08:00
|
|
|
ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl());
|
2010-04-29 08:35:03 +08:00
|
|
|
|
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.
|
2011-07-23 18:55:15 +08:00
|
|
|
SmallVector<TemplateArgument, 4> Builder;
|
2011-01-05 06:13:36 +08:00
|
|
|
for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
|
|
|
|
NamedDecl *Param = TemplateParams->getParam(I);
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-11-26 02:55:14 +08:00
|
|
|
if (!Deduced[I].isNull()) {
|
2010-10-13 02:51:08 +08:00
|
|
|
if (I < NumExplicitlySpecified) {
|
2010-03-28 10:42:43 +08:00
|
|
|
// We have already fully type-checked and converted this
|
2011-01-27 15:10:08 +08:00
|
|
|
// argument, because it was explicitly-specified. Just record the
|
2010-10-13 02:51:08 +08:00
|
|
|
// presence of this argument.
|
2010-11-08 07:05:16 +08:00
|
|
|
Builder.push_back(Deduced[I]);
|
2014-06-02 00:11:54 +08:00
|
|
|
// 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 (Param->isParameterPack() && CurrentInstantiationScope) {
|
|
|
|
if (CurrentInstantiationScope->getPartiallySubstitutedPack() ==
|
|
|
|
Param) {
|
|
|
|
// Forget the partially-substituted pack; its substitution is now
|
|
|
|
// complete.
|
|
|
|
CurrentInstantiationScope->ResetPartiallySubstitutedPack();
|
|
|
|
}
|
|
|
|
}
|
2010-03-28 10:42:43 +08:00
|
|
|
continue;
|
|
|
|
}
|
2016-02-04 04:15:01 +08:00
|
|
|
|
2010-03-28 10:42:43 +08:00
|
|
|
// We have deduced this argument, so it still needs to be
|
|
|
|
// checked and converted.
|
2011-01-05 06:13:36 +08:00
|
|
|
if (ConvertDeducedTemplateArgument(*this, Param, Deduced[I],
|
2016-02-04 04:15:01 +08:00
|
|
|
FunctionTemplate, Info,
|
2011-01-05 07:35:54 +08:00
|
|
|
true, Builder)) {
|
2011-01-05 06:13:36 +08:00
|
|
|
Info.Param = makeTemplateParameter(Param);
|
2010-11-08 07:05:16 +08:00
|
|
|
// FIXME: These template arguments are temporary. Free them!
|
2016-07-04 05:17:51 +08:00
|
|
|
Info.reset(TemplateArgumentList::CreateCopy(Context, Builder));
|
2010-03-28 10:42:43 +08:00
|
|
|
return TDK_SubstitutionFailure;
|
|
|
|
}
|
|
|
|
|
2009-11-26 02:55:14 +08:00
|
|
|
continue;
|
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-12-23 09:52:01 +08:00
|
|
|
// C++0x [temp.arg.explicit]p3:
|
2011-01-27 15:10:08 +08:00
|
|
|
// A trailing template parameter pack (14.5.3) not otherwise deduced will
|
2010-12-23 09:52:01 +08:00
|
|
|
// be deduced to an empty sequence of template arguments.
|
|
|
|
// FIXME: Where did the word "trailing" come from?
|
|
|
|
if (Param->isTemplateParameterPack()) {
|
Work-in-progress implementation of C++0x [temp.arg.explicit]p9, which
allows an argument pack determines via explicit specification of
function template arguments to be extended by further, deduced
arguments. For example:
template<class ... Types> void f(Types ... values);
void g() {
f<int*, float*>(0, 0, 0); // Types is deduced to the sequence int*, float*, int
}
There are a number of FIXMEs in here that indicate places where we
need to implement + test retained expansions, plus a number of other
places in deduction where we need to correctly cope with the
explicitly-specified arguments when deducing an argument
pack. Furthermore, it appears that the RecursiveASTVisitor needs to be
auditied; it's missing some traversals (especially w.r.t. template
arguments) that cause it not to find unexpanded parameter packs when
it should.
The good news, however, is that the tr1::tuple implementation now
works fully, and the tr1::bind example (both from N2080) is actually
working now.
llvm-svn: 123163
2011-01-10 15:32:04 +08:00
|
|
|
// We may have had explicitly-specified template arguments for this
|
|
|
|
// template parameter pack. If so, our empty deduction extends the
|
|
|
|
// explicitly-specified set (C++0x [temp.arg.explicit]p9).
|
|
|
|
const TemplateArgument *ExplicitArgs;
|
|
|
|
unsigned NumExplicitArgs;
|
2012-08-23 14:16:52 +08:00
|
|
|
if (CurrentInstantiationScope &&
|
|
|
|
CurrentInstantiationScope->getPartiallySubstitutedPack(&ExplicitArgs,
|
Work-in-progress implementation of C++0x [temp.arg.explicit]p9, which
allows an argument pack determines via explicit specification of
function template arguments to be extended by further, deduced
arguments. For example:
template<class ... Types> void f(Types ... values);
void g() {
f<int*, float*>(0, 0, 0); // Types is deduced to the sequence int*, float*, int
}
There are a number of FIXMEs in here that indicate places where we
need to implement + test retained expansions, plus a number of other
places in deduction where we need to correctly cope with the
explicitly-specified arguments when deducing an argument
pack. Furthermore, it appears that the RecursiveASTVisitor needs to be
auditied; it's missing some traversals (especially w.r.t. template
arguments) that cause it not to find unexpanded parameter packs when
it should.
The good news, however, is that the tr1::tuple implementation now
works fully, and the tr1::bind example (both from N2080) is actually
working now.
llvm-svn: 123163
2011-01-10 15:32:04 +08:00
|
|
|
&NumExplicitArgs)
|
2013-01-19 06:27:09 +08:00
|
|
|
== Param) {
|
2015-08-05 17:40:22 +08:00
|
|
|
Builder.push_back(TemplateArgument(
|
|
|
|
llvm::makeArrayRef(ExplicitArgs, NumExplicitArgs)));
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2016-02-04 04:40:30 +08:00
|
|
|
// Forget the partially-substituted pack; its substitution is now
|
2013-01-19 06:27:09 +08:00
|
|
|
// complete.
|
|
|
|
CurrentInstantiationScope->ResetPartiallySubstitutedPack();
|
|
|
|
} else {
|
2016-02-04 04:40:30 +08:00
|
|
|
// Go through the motions of checking the empty argument pack against
|
|
|
|
// the parameter pack.
|
|
|
|
DeducedTemplateArgument DeducedPack(TemplateArgument::getEmptyPack());
|
|
|
|
if (ConvertDeducedTemplateArgument(*this, Param, DeducedPack,
|
|
|
|
FunctionTemplate, Info, true,
|
|
|
|
Builder)) {
|
|
|
|
Info.Param = makeTemplateParameter(Param);
|
|
|
|
// FIXME: These template arguments are temporary. Free them!
|
2016-07-04 05:17:51 +08:00
|
|
|
Info.reset(TemplateArgumentList::CreateCopy(Context, Builder));
|
2016-02-04 04:40:30 +08:00
|
|
|
return TDK_SubstitutionFailure;
|
|
|
|
}
|
2013-01-19 06:27:09 +08:00
|
|
|
}
|
2010-12-23 09:52:01 +08:00
|
|
|
continue;
|
|
|
|
}
|
2009-11-26 02:55:14 +08:00
|
|
|
|
2011-01-27 15:10:08 +08:00
|
|
|
// Substitute into the default template argument, if available.
|
2013-07-04 09:01:24 +08:00
|
|
|
bool HasDefaultArg = false;
|
2009-11-26 02:55:14 +08:00
|
|
|
TemplateArgumentLoc DefArg
|
|
|
|
= SubstDefaultTemplateArgumentIfAvailable(FunctionTemplate,
|
|
|
|
FunctionTemplate->getLocation(),
|
|
|
|
FunctionTemplate->getSourceRange().getEnd(),
|
|
|
|
Param,
|
2013-07-04 09:01:24 +08:00
|
|
|
Builder, HasDefaultArg);
|
2009-11-26 02:55:14 +08:00
|
|
|
|
|
|
|
// If there was no default argument, deduction is incomplete.
|
|
|
|
if (DefArg.getArgument().isNull()) {
|
2009-07-09 04:55:45 +08:00
|
|
|
Info.Param = makeTemplateParameter(
|
2009-11-26 02:55:14 +08:00
|
|
|
const_cast<NamedDecl *>(TemplateParams->getParam(I)));
|
2016-07-04 05:17:51 +08:00
|
|
|
Info.reset(TemplateArgumentList::CreateCopy(Context, Builder));
|
2015-01-22 00:24:11 +08:00
|
|
|
if (PartialOverloading) break;
|
|
|
|
|
2013-07-04 09:01:24 +08:00
|
|
|
return HasDefaultArg ? TDK_SubstitutionFailure : TDK_Incomplete;
|
2009-07-09 04:55:45 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-11-26 02:55:14 +08:00
|
|
|
// Check whether we can actually use the default argument.
|
|
|
|
if (CheckTemplateArgument(Param, DefArg,
|
|
|
|
FunctionTemplate,
|
|
|
|
FunctionTemplate->getLocation(),
|
|
|
|
FunctionTemplate->getSourceRange().getEnd(),
|
2011-01-20 04:10:05 +08:00
|
|
|
0, Builder,
|
2011-06-03 10:59:40 +08:00
|
|
|
CTAK_Specified)) {
|
2009-11-26 02:55:14 +08:00
|
|
|
Info.Param = makeTemplateParameter(
|
|
|
|
const_cast<NamedDecl *>(TemplateParams->getParam(I)));
|
2010-11-08 07:05:16 +08:00
|
|
|
// FIXME: These template arguments are temporary. Free them!
|
2016-07-04 05:17:51 +08:00
|
|
|
Info.reset(TemplateArgumentList::CreateCopy(Context, Builder));
|
2009-11-26 02:55:14 +08:00
|
|
|
return TDK_SubstitutionFailure;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-11-26 02:55:14 +08:00
|
|
|
// If we get here, we successfully used the default template argument.
|
2009-07-09 04:55:45 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-09 04:55:45 +08:00
|
|
|
// Form the template argument list from the deduced template arguments.
|
2009-09-09 23:08:12 +08:00
|
|
|
TemplateArgumentList *DeducedArgumentList
|
2016-07-04 05:17:51 +08:00
|
|
|
= TemplateArgumentList::CreateCopy(Context, Builder);
|
2009-07-09 04:55:45 +08:00
|
|
|
Info.reset(DeducedArgumentList);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
|
|
|
// Substitute the deduced template arguments into the function template
|
2009-07-09 04:55:45 +08:00
|
|
|
// declaration to produce the function template specialization.
|
2010-04-28 12:52:24 +08:00
|
|
|
DeclContext *Owner = FunctionTemplate->getDeclContext();
|
|
|
|
if (FunctionTemplate->getFriendObjectKind())
|
|
|
|
Owner = FunctionTemplate->getLexicalDeclContext();
|
2009-07-09 04:55:45 +08:00
|
|
|
Specialization = cast_or_null<FunctionDecl>(
|
2010-04-28 12:52:24 +08:00
|
|
|
SubstDecl(FunctionTemplate->getTemplatedDecl(), Owner,
|
2009-08-29 04:50:45 +08:00
|
|
|
MultiLevelTemplateArgumentList(*DeducedArgumentList)));
|
2011-10-13 04:35:48 +08:00
|
|
|
if (!Specialization || Specialization->isInvalidDecl())
|
2009-07-09 04:55:45 +08:00
|
|
|
return TDK_SubstitutionFailure;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2011-01-27 15:10:08 +08:00
|
|
|
assert(Specialization->getPrimaryTemplate()->getCanonicalDecl() ==
|
2009-09-16 02:26:13 +08:00
|
|
|
FunctionTemplate->getCanonicalDecl());
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
// If the template argument list is owned by the function template
|
2009-07-09 04:55:45 +08:00
|
|
|
// specialization, release it.
|
2010-05-09 04:07:26 +08:00
|
|
|
if (Specialization->getTemplateSpecializationArgs() == DeducedArgumentList &&
|
|
|
|
!Trap.hasErrorOccurred())
|
2009-07-09 04:55:45 +08:00
|
|
|
Info.take();
|
2009-09-09 23:08:12 +08:00
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
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
|
2016-08-12 19:43:57 +08:00
|
|
|
// values that will make the deduced A identical to A (after the type A
|
2011-06-17 00:50:48 +08:00
|
|
|
// is transformed as described above). [...]
|
|
|
|
for (unsigned I = 0, N = OriginalCallArgs->size(); I != N; ++I) {
|
|
|
|
OriginalCallArg OriginalArg = (*OriginalCallArgs)[I];
|
|
|
|
unsigned ParamIdx = OriginalArg.ArgIdx;
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2011-06-17 00:50:48 +08:00
|
|
|
if (ParamIdx >= Specialization->getNumParams())
|
|
|
|
continue;
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2011-06-17 00:50:48 +08:00
|
|
|
QualType DeducedA = Specialization->getParamDecl(ParamIdx)->getType();
|
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;
|
|
|
|
return TDK_DeducedMismatch;
|
|
|
|
}
|
2011-06-17 00:50:48 +08:00
|
|
|
}
|
|
|
|
}
|
2016-08-12 19:43:57 +08:00
|
|
|
|
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()) {
|
2013-07-05 12:33:53 +08:00
|
|
|
SuppressedDiagnosticsMap::iterator
|
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());
|
2011-01-27 15:10:08 +08:00
|
|
|
}
|
2010-10-13 07:32:35 +08:00
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
return TDK_Success;
|
2009-07-09 04:55:45 +08:00
|
|
|
}
|
|
|
|
|
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.
|
2013-05-04 15:00:32 +08:00
|
|
|
static QualType GetTypeOfFunction(Sema &S, const OverloadExpr::FindResult &R,
|
2010-02-02 10:21:27 +08:00
|
|
|
FunctionDecl *Fn) {
|
2013-05-04 15:00:32 +08:00
|
|
|
// We may need to deduce the return type of the function now.
|
2014-08-19 23:55:55 +08:00
|
|
|
if (S.getLangOpts().CPlusPlus14 && Fn->getReturnType()->isUndeducedType() &&
|
2014-01-26 00:55:45 +08:00
|
|
|
S.DeduceReturnType(Fn, R.Expression->getExprLoc(), /*Diagnose*/ false))
|
2013-05-04 15:00:32 +08:00
|
|
|
return QualType();
|
|
|
|
|
2010-02-02 10:21:27 +08:00
|
|
|
if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn))
|
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();
|
|
|
|
|
2013-05-04 15:00:32 +08:00
|
|
|
return S.Context.getMemberPointerType(Fn->getType(),
|
|
|
|
S.Context.getTypeDeclType(Method->getParent()).getTypePtr());
|
2010-08-27 17:08:28 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!R.IsAddressOfOperand) return Fn->getType();
|
2013-05-04 15:00:32 +08:00
|
|
|
return S.Context.getPointerType(Fn->getType());
|
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,
|
2010-08-31 05:04:23 +08:00
|
|
|
Expr *Arg, QualType ParamType,
|
|
|
|
bool ParamWasReference) {
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-08-27 17:08:28 +08:00
|
|
|
OverloadExpr::FindResult R = OverloadExpr::find(Arg);
|
2010-02-02 10:21:27 +08:00
|
|
|
|
2010-08-27 17:08:28 +08:00
|
|
|
OverloadExpr *Ovl = R.Expression;
|
2010-02-02 10:21:27 +08:00
|
|
|
|
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;
|
|
|
|
|
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() &&
|
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))
|
2013-05-04 15:00:32 +08:00
|
|
|
return GetTypeOfFunction(S, R, ExplicitSpec);
|
2012-03-13 05:09:16 +08:00
|
|
|
}
|
2010-02-02 10:21:27 +08:00
|
|
|
|
2016-03-20 05:51:45 +08:00
|
|
|
DeclAccessPair DAP;
|
|
|
|
if (FunctionDecl *Viable =
|
|
|
|
S.resolveAddressOfOnlyViableOverloadCandidate(Arg, DAP))
|
|
|
|
return GetTypeOfFunction(S, R, Viable);
|
|
|
|
|
2012-03-13 05:09:16 +08:00
|
|
|
return QualType();
|
|
|
|
}
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2012-03-13 05:09:16 +08:00
|
|
|
// Gather the explicit template arguments, if any.
|
|
|
|
TemplateArgumentListInfo ExplicitTemplateArgs;
|
|
|
|
if (Ovl->hasExplicitTemplateArgs())
|
2015-12-24 10:59:37 +08:00
|
|
|
Ovl->copyTemplateArgumentsInto(ExplicitTemplateArgs);
|
2010-02-02 10:21:27 +08:00
|
|
|
QualType Match;
|
2010-02-02 14:20:04 +08:00
|
|
|
for (UnresolvedSetIterator I = Ovl->decls_begin(),
|
|
|
|
E = Ovl->decls_end(); I != E; ++I) {
|
2010-02-02 10:21:27 +08:00
|
|
|
NamedDecl *D = (*I)->getUnderlyingDecl();
|
|
|
|
|
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();
|
2016-08-12 19:43:57 +08:00
|
|
|
|
|
|
|
// Otherwise, see if we can resolve a function type
|
2014-05-26 14:22:03 +08:00
|
|
|
FunctionDecl *Specialization = nullptr;
|
2012-09-19 10:26:47 +08:00
|
|
|
TemplateDeductionInfo Info(Ovl->getNameLoc());
|
2012-03-13 05:09:16 +08:00
|
|
|
if (S.DeduceTemplateArguments(FunTmpl, &ExplicitTemplateArgs,
|
|
|
|
Specialization, Info))
|
|
|
|
continue;
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2012-03-13 05:09:16 +08:00
|
|
|
D = Specialization;
|
|
|
|
}
|
2010-02-02 10:21:27 +08:00
|
|
|
|
|
|
|
FunctionDecl *Fn = cast<FunctionDecl>(D);
|
2013-05-04 15:00:32 +08:00
|
|
|
QualType ArgType = GetTypeOfFunction(S, R, Fn);
|
2010-08-27 17:08:28 +08:00
|
|
|
if (ArgType.isNull()) continue;
|
2010-02-02 10:21:27 +08:00
|
|
|
|
2010-08-31 05:04:23 +08:00
|
|
|
// Function-to-pointer conversion.
|
2011-01-27 15:10:08 +08:00
|
|
|
if (!ParamWasReference && ParamType->isPointerType() &&
|
2010-08-31 05:04:23 +08:00
|
|
|
ArgType->isFunctionType())
|
|
|
|
ArgType = S.Context.getPointerType(ArgType);
|
2011-01-27 15:10:08 +08:00
|
|
|
|
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.
|
2011-07-23 18:55:15 +08:00
|
|
|
SmallVector<DeducedTemplateArgument, 8>
|
2010-03-28 10:42:43 +08:00
|
|
|
Deduced(TemplateParams->size());
|
2012-09-19 10:26:47 +08:00
|
|
|
TemplateDeductionInfo Info(Ovl->getNameLoc());
|
2010-02-02 10:21:27 +08:00
|
|
|
Sema::TemplateDeductionResult Result
|
2012-01-18 06:49:52 +08:00
|
|
|
= DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ParamType,
|
|
|
|
ArgType, Info, Deduced, TDF);
|
2010-02-02 10:21:27 +08:00
|
|
|
if (Result) continue;
|
|
|
|
if (!Match.isNull()) return QualType();
|
|
|
|
Match = ArgType;
|
|
|
|
}
|
|
|
|
|
|
|
|
return Match;
|
|
|
|
}
|
|
|
|
|
2011-01-27 15:10:08 +08:00
|
|
|
/// \brief Perform the adjustments to the parameter and argument types
|
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
|
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.
|
2011-01-07 06:09:01 +08:00
|
|
|
static bool AdjustFunctionParmAndArgTypesForDeduction(Sema &S,
|
|
|
|
TemplateParameterList *TemplateParams,
|
|
|
|
QualType &ParamType,
|
|
|
|
QualType &ArgType,
|
|
|
|
Expr *Arg,
|
|
|
|
unsigned &TDF) {
|
|
|
|
// C++0x [temp.deduct.call]p3:
|
2011-01-27 15:09:49 +08:00
|
|
|
// If P is a cv-qualified type, the top level cv-qualifiers of P's type
|
2011-01-07 06:09:01 +08:00
|
|
|
// are ignored for type deduction.
|
2011-04-28 07:34:22 +08:00
|
|
|
if (ParamType.hasQualifiers())
|
|
|
|
ParamType = ParamType.getUnqualifiedType();
|
2015-01-13 04:13:20 +08:00
|
|
|
|
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();
|
2011-01-27 15:10:08 +08:00
|
|
|
|
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.
|
2011-01-07 06:09:01 +08:00
|
|
|
if (ArgType == S.Context.OverloadTy) {
|
|
|
|
ArgType = ResolveOverloadForDeduction(S, TemplateParams,
|
|
|
|
Arg, ParamType,
|
2014-05-26 14:22:03 +08:00
|
|
|
ParamRefType != nullptr);
|
2011-01-07 06:09:01 +08:00
|
|
|
if (ArgType.isNull())
|
|
|
|
return true;
|
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-07 06:09:01 +08:00
|
|
|
if (ParamRefType) {
|
2015-01-16 23:20:14 +08:00
|
|
|
// If the argument has incomplete array type, try to complete its type.
|
2015-12-19 06:40:25 +08:00
|
|
|
if (ArgType->isIncompleteArrayType()) {
|
|
|
|
S.completeExprArrayBound(Arg);
|
2015-01-16 23:20:14 +08:00
|
|
|
ArgType = Arg->getType();
|
2015-12-19 06:40:25 +08:00
|
|
|
}
|
2015-01-16 23:20:14 +08:00
|
|
|
|
2011-01-07 06:09:01 +08:00
|
|
|
// C++0x [temp.deduct.call]p3:
|
2015-01-16 23:20:14 +08:00
|
|
|
// If P is an rvalue reference to a cv-unqualified template
|
|
|
|
// parameter and the argument is an lvalue, the type "lvalue
|
|
|
|
// reference to A" is used in place of A for type deduction.
|
2011-01-07 06:09:01 +08:00
|
|
|
if (ParamRefType->isRValueReferenceType() &&
|
2015-01-16 23:20:14 +08:00
|
|
|
!ParamType.getQualifiers() &&
|
|
|
|
isa<TemplateTypeParmType>(ParamType) &&
|
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 {
|
2011-01-27 15:09:49 +08:00
|
|
|
// - If A is a cv-qualified type, the top level cv-qualifiers of A's
|
2011-01-07 06:09:01 +08:00
|
|
|
// type are ignored for type deduction.
|
2011-04-28 07:34:22 +08:00
|
|
|
ArgType = ArgType.getUnqualifiedType();
|
2011-01-07 06:09:01 +08:00
|
|
|
}
|
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
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;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
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;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-07 06:09:01 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-07-28 08:02:09 +08:00
|
|
|
static bool
|
|
|
|
hasDeducibleTemplateParameters(Sema &S, FunctionTemplateDecl *FunctionTemplate,
|
|
|
|
QualType T);
|
2011-06-17 00:50:48 +08:00
|
|
|
|
2015-06-25 08:25:49 +08:00
|
|
|
static Sema::TemplateDeductionResult DeduceTemplateArgumentByListElement(
|
|
|
|
Sema &S, TemplateParameterList *TemplateParams, QualType ParamType,
|
|
|
|
Expr *Arg, TemplateDeductionInfo &Info,
|
|
|
|
SmallVectorImpl<DeducedTemplateArgument> &Deduced, unsigned TDF);
|
|
|
|
|
|
|
|
/// \brief Attempt template argument deduction from an initializer list
|
|
|
|
/// deemed to be an argument in a function call.
|
|
|
|
static bool
|
|
|
|
DeduceFromInitializerList(Sema &S, TemplateParameterList *TemplateParams,
|
|
|
|
QualType AdjustedParamType, InitListExpr *ILE,
|
|
|
|
TemplateDeductionInfo &Info,
|
|
|
|
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
|
|
|
|
unsigned TDF, Sema::TemplateDeductionResult &Result) {
|
2015-12-10 13:36:39 +08:00
|
|
|
|
|
|
|
// [temp.deduct.call] p1 (post 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 (8.5.4), 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, and in the
|
|
|
|
// P0[N] case, if N is a non-type template parameter, N is deduced from the
|
|
|
|
// length of the initializer list. Otherwise, an initializer list argument
|
|
|
|
// causes the parameter to be considered a non-deduced context
|
|
|
|
|
|
|
|
const bool IsConstSizedArray = AdjustedParamType->isConstantArrayType();
|
|
|
|
|
|
|
|
const bool IsDependentSizedArray =
|
|
|
|
!IsConstSizedArray && AdjustedParamType->isDependentSizedArrayType();
|
|
|
|
|
2015-12-10 20:29:11 +08:00
|
|
|
QualType ElTy; // The element type of the std::initializer_list or the array.
|
2015-12-10 13:36:39 +08:00
|
|
|
|
|
|
|
const bool IsSTDList = !IsConstSizedArray && !IsDependentSizedArray &&
|
|
|
|
S.isStdInitializerList(AdjustedParamType, &ElTy);
|
|
|
|
|
|
|
|
if (!IsConstSizedArray && !IsDependentSizedArray && !IsSTDList)
|
2015-06-25 08:25:49 +08:00
|
|
|
return false;
|
|
|
|
|
|
|
|
Result = Sema::TDK_Success;
|
2015-12-10 13:36:39 +08:00
|
|
|
// If we are not deducing against the 'T' in a std::initializer_list<T> then
|
|
|
|
// deduce against the 'T' in T[N].
|
|
|
|
if (ElTy.isNull()) {
|
|
|
|
assert(!IsSTDList);
|
|
|
|
ElTy = S.Context.getAsArrayType(AdjustedParamType)->getElementType();
|
|
|
|
}
|
|
|
|
// Deduction only needs to be done for dependent types.
|
|
|
|
if (ElTy->isDependentType()) {
|
|
|
|
for (Expr *E : ILE->inits()) {
|
2015-12-10 16:49:55 +08:00
|
|
|
if ((Result = DeduceTemplateArgumentByListElement(S, TemplateParams, ElTy,
|
|
|
|
E, Info, Deduced, TDF)))
|
2015-12-10 13:36:39 +08:00
|
|
|
return true;
|
|
|
|
}
|
2015-06-25 08:25:49 +08:00
|
|
|
}
|
2015-12-10 13:36:39 +08:00
|
|
|
if (IsDependentSizedArray) {
|
|
|
|
const DependentSizedArrayType *ArrTy =
|
|
|
|
S.Context.getAsDependentSizedArrayType(AdjustedParamType);
|
|
|
|
// Determine the array bound is something we can deduce.
|
|
|
|
if (NonTypeTemplateParmDecl *NTTP =
|
|
|
|
getDeducedParameterFromExpr(ArrTy->getSizeExpr())) {
|
|
|
|
// We can perform template argument deduction for the given non-type
|
|
|
|
// template parameter.
|
|
|
|
assert(NTTP->getDepth() == 0 &&
|
|
|
|
"Cannot deduce non-type template argument at depth > 0");
|
|
|
|
llvm::APInt Size(S.Context.getIntWidth(NTTP->getType()),
|
|
|
|
ILE->getNumInits());
|
2015-06-25 08:25:49 +08:00
|
|
|
|
2015-12-10 13:36:39 +08:00
|
|
|
Result = DeduceNonTypeTemplateArgument(
|
2016-09-29 07:55:27 +08:00
|
|
|
S, TemplateParams, NTTP, llvm::APSInt(Size), NTTP->getType(),
|
2015-12-10 13:36:39 +08:00
|
|
|
/*ArrayBound=*/true, Info, Deduced);
|
|
|
|
}
|
|
|
|
}
|
2015-06-25 08:25:49 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-03-16 05:40:51 +08:00
|
|
|
/// \brief Perform template argument deduction by matching a parameter type
|
|
|
|
/// against a single expression, where the expression is an element of
|
2013-01-31 12:03:12 +08:00
|
|
|
/// an initializer list that was originally matched against a parameter
|
|
|
|
/// of type \c initializer_list\<ParamType\>.
|
2012-03-16 05:40:51 +08:00
|
|
|
static Sema::TemplateDeductionResult
|
|
|
|
DeduceTemplateArgumentByListElement(Sema &S,
|
|
|
|
TemplateParameterList *TemplateParams,
|
|
|
|
QualType ParamType, Expr *Arg,
|
|
|
|
TemplateDeductionInfo &Info,
|
|
|
|
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
|
|
|
|
unsigned TDF) {
|
|
|
|
// Handle the case where an init list contains another init list as the
|
|
|
|
// element.
|
|
|
|
if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) {
|
2015-06-25 08:25:49 +08:00
|
|
|
Sema::TemplateDeductionResult Result;
|
|
|
|
if (!DeduceFromInitializerList(S, TemplateParams,
|
|
|
|
ParamType.getNonReferenceType(), ILE, Info,
|
|
|
|
Deduced, TDF, Result))
|
2012-03-16 05:40:51 +08:00
|
|
|
return Sema::TDK_Success; // Just ignore this expression.
|
|
|
|
|
2015-06-25 08:25:49 +08:00
|
|
|
return Result;
|
2012-03-16 05:40:51 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// For all other cases, just match by type.
|
2012-04-04 13:10:53 +08:00
|
|
|
QualType ArgType = Arg->getType();
|
2016-08-12 19:43:57 +08:00
|
|
|
if (AdjustFunctionParmAndArgTypesForDeduction(S, TemplateParams, ParamType,
|
2013-01-31 12:03:12 +08:00
|
|
|
ArgType, Arg, TDF)) {
|
|
|
|
Info.Expression = Arg;
|
2012-04-04 13:10:53 +08:00
|
|
|
return Sema::TDK_FailedOverloadResolution;
|
2013-01-31 12:03:12 +08:00
|
|
|
}
|
2012-03-16 05:40:51 +08:00
|
|
|
return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ParamType,
|
2012-04-04 13:10:53 +08:00
|
|
|
ArgType, Info, Deduced, TDF);
|
2012-03-16 05:40:51 +08:00
|
|
|
}
|
|
|
|
|
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.
|
|
|
|
///
|
2012-06-22 16:52:37 +08:00
|
|
|
/// \param ExplicitTemplateArgs the explicit template arguments provided
|
2010-01-12 02:40:55 +08:00
|
|
|
/// for this call.
|
2009-07-01 07:57:56 +08:00
|
|
|
///
|
2009-06-26 06:08:12 +08:00
|
|
|
/// \param Args the function call arguments
|
|
|
|
///
|
|
|
|
/// \param Specialization if template argument deduction was successful,
|
2009-09-09 23:08:12 +08:00
|
|
|
/// this will be set to the function template specialization produced by
|
2009-06-26 06:08:12 +08:00
|
|
|
/// template argument deduction.
|
|
|
|
///
|
|
|
|
/// \param Info the argument will be updated to provide additional information
|
|
|
|
/// about template argument deduction.
|
|
|
|
///
|
|
|
|
/// \returns the result of template argument deduction.
|
2013-08-10 02:02:13 +08:00
|
|
|
Sema::TemplateDeductionResult Sema::DeduceTemplateArguments(
|
|
|
|
FunctionTemplateDecl *FunctionTemplate,
|
|
|
|
TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
|
2015-01-22 00:24:11 +08:00
|
|
|
FunctionDecl *&Specialization, TemplateDeductionInfo &Info,
|
|
|
|
bool PartialOverloading) {
|
2012-09-14 05:01:57 +08:00
|
|
|
if (FunctionTemplate->isInvalidDecl())
|
|
|
|
return TDK_Invalid;
|
|
|
|
|
2009-06-26 06:08:12 +08:00
|
|
|
FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
|
2015-01-22 00:24:11 +08:00
|
|
|
unsigned NumParams = Function->getNumParams();
|
2009-07-01 07:57:56 +08:00
|
|
|
|
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.
|
2012-02-25 19:00:22 +08:00
|
|
|
unsigned CheckArgs = Args.size();
|
2015-01-22 00:24:11 +08:00
|
|
|
if (Args.size() < Function->getMinRequiredArguments() && !PartialOverloading)
|
2009-06-26 06:08:12 +08:00
|
|
|
return TDK_TooFewArguments;
|
2015-01-22 00:24:11 +08:00
|
|
|
else if (TooManyArguments(NumParams, Args.size(), PartialOverloading)) {
|
2009-09-09 23:08:12 +08:00
|
|
|
const FunctionProtoType *Proto
|
2009-09-22 07:43:11 +08:00
|
|
|
= Function->getType()->getAs<FunctionProtoType>();
|
2011-01-07 06:09:01 +08:00
|
|
|
if (Proto->isTemplateVariadic())
|
|
|
|
/* Do nothing */;
|
|
|
|
else if (Proto->isVariadic())
|
2015-01-22 00:24:11 +08:00
|
|
|
CheckArgs = NumParams;
|
2011-01-27 15:10:08 +08:00
|
|
|
else
|
2009-06-26 06:08:12 +08:00
|
|
|
return TDK_TooManyArguments;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-01 07:57:56 +08:00
|
|
|
// The types of the parameters from which we will perform template argument
|
|
|
|
// deduction.
|
2010-08-25 13:32:35 +08:00
|
|
|
LocalInstantiationScope InstScope(*this);
|
2009-06-26 06:08:12 +08:00
|
|
|
TemplateParameterList *TemplateParams
|
|
|
|
= FunctionTemplate->getTemplateParameters();
|
2011-07-23 18:55:15 +08:00
|
|
|
SmallVector<DeducedTemplateArgument, 4> Deduced;
|
|
|
|
SmallVector<QualType, 4> ParamTypes;
|
2010-03-28 10:42:43 +08:00
|
|
|
unsigned NumExplicitlySpecified = 0;
|
2009-11-23 09:53:49 +08:00
|
|
|
if (ExplicitTemplateArgs) {
|
2009-07-09 04:55:45 +08:00
|
|
|
TemplateDeductionResult Result =
|
|
|
|
SubstituteExplicitTemplateArguments(FunctionTemplate,
|
2009-11-23 09:53:49 +08:00
|
|
|
*ExplicitTemplateArgs,
|
2009-07-09 04:55:45 +08:00
|
|
|
Deduced,
|
|
|
|
ParamTypes,
|
2014-05-26 14:22:03 +08:00
|
|
|
nullptr,
|
2009-07-09 04:55:45 +08:00
|
|
|
Info);
|
|
|
|
if (Result)
|
|
|
|
return Result;
|
2010-03-28 10:42:43 +08:00
|
|
|
|
|
|
|
NumExplicitlySpecified = Deduced.size();
|
2009-07-01 07:57:56 +08:00
|
|
|
} else {
|
|
|
|
// Just fill in the parameter types from the function declaration.
|
2015-01-22 00:24:11 +08:00
|
|
|
for (unsigned I = 0; I != NumParams; ++I)
|
2009-07-01 07:57:56 +08:00
|
|
|
ParamTypes.push_back(Function->getParamDecl(I)->getType());
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-01 07:57:56 +08:00
|
|
|
// Deduce template arguments from the function parameters.
|
2009-09-09 23:08:12 +08:00
|
|
|
Deduced.resize(TemplateParams->size());
|
2011-01-07 06:09:01 +08:00
|
|
|
unsigned ArgIdx = 0;
|
2011-07-23 18:55:15 +08:00
|
|
|
SmallVector<OriginalCallArg, 4> OriginalCallArgs;
|
2015-01-22 00:24:11 +08:00
|
|
|
for (unsigned ParamIdx = 0, NumParamTypes = ParamTypes.size();
|
|
|
|
ParamIdx != NumParamTypes; ++ParamIdx) {
|
2011-06-17 00:50:48 +08:00
|
|
|
QualType OrigParamType = ParamTypes[ParamIdx];
|
|
|
|
QualType ParamType = OrigParamType;
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2011-01-27 15:10:08 +08:00
|
|
|
const PackExpansionType *ParamExpansion
|
2011-01-07 06:09:01 +08:00
|
|
|
= dyn_cast<PackExpansionType>(ParamType);
|
|
|
|
if (!ParamExpansion) {
|
|
|
|
// Simple case: matching a function parameter to a function argument.
|
|
|
|
if (ArgIdx >= CheckArgs)
|
|
|
|
break;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-07 06:09:01 +08:00
|
|
|
Expr *Arg = Args[ArgIdx++];
|
|
|
|
QualType ArgType = Arg->getType();
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2011-01-07 06:09:01 +08:00
|
|
|
unsigned TDF = 0;
|
|
|
|
if (AdjustFunctionParmAndArgTypesForDeduction(*this, TemplateParams,
|
|
|
|
ParamType, ArgType, Arg,
|
|
|
|
TDF))
|
|
|
|
continue;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-10-10 06:06:46 +08:00
|
|
|
// If we have nothing to deduce, we're done.
|
|
|
|
if (!hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType))
|
|
|
|
continue;
|
|
|
|
|
2012-01-18 06:49:58 +08:00
|
|
|
// If the argument is an initializer list ...
|
|
|
|
if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) {
|
2015-06-25 08:25:49 +08:00
|
|
|
TemplateDeductionResult Result;
|
2012-01-18 06:49:58 +08:00
|
|
|
// Removing references was already done.
|
2015-06-25 08:25:49 +08:00
|
|
|
if (!DeduceFromInitializerList(*this, TemplateParams, ParamType, ILE,
|
|
|
|
Info, Deduced, TDF, Result))
|
2012-01-18 06:49:58 +08:00
|
|
|
continue;
|
|
|
|
|
2015-06-25 08:25:49 +08:00
|
|
|
if (Result)
|
|
|
|
return Result;
|
2012-01-18 06:49:58 +08:00
|
|
|
// Don't track the argument type, since an initializer list has none.
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2011-06-17 00:50:48 +08:00
|
|
|
// Keep track of the argument type and corresponding parameter index,
|
|
|
|
// so we can check for compatibility between the deduced A and A.
|
2016-08-12 19:43:57 +08:00
|
|
|
OriginalCallArgs.push_back(OriginalCallArg(OrigParamType, ArgIdx-1,
|
2011-10-10 06:06:46 +08:00
|
|
|
ArgType));
|
2011-06-17 00:50:48 +08:00
|
|
|
|
2011-01-07 06:09:01 +08:00
|
|
|
if (TemplateDeductionResult Result
|
2012-01-18 06:49:52 +08:00
|
|
|
= DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams,
|
|
|
|
ParamType, ArgType,
|
|
|
|
Info, Deduced, TDF))
|
2011-01-07 06:09:01 +08:00
|
|
|
return Result;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2011-01-07 06:09:01 +08:00
|
|
|
continue;
|
2010-08-31 05:04:23 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-07 06:09:01 +08:00
|
|
|
// C++0x [temp.deduct.call]p1:
|
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
|
2011-01-11 09:52:23 +08:00
|
|
|
// the function parameter pack. For a function parameter pack that does
|
2011-01-27 15:10:08 +08:00
|
|
|
// not occur at the end of the parameter-declaration-list, the type of
|
2011-01-11 09:52:23 +08:00
|
|
|
// the parameter pack is a non-deduced context.
|
2015-01-22 00:24:11 +08:00
|
|
|
if (ParamIdx + 1 < NumParamTypes)
|
2011-01-11 09:52:23 +08:00
|
|
|
break;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-07 06:09:01 +08:00
|
|
|
QualType ParamPattern = ParamExpansion->getPattern();
|
2014-05-29 09:12:14 +08:00
|
|
|
PackDeductionScope PackScope(*this, TemplateParams, Deduced, Info,
|
|
|
|
ParamPattern);
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-07 06:09:01 +08:00
|
|
|
bool HasAnyArguments = false;
|
2012-02-25 19:00:22 +08:00
|
|
|
for (; ArgIdx < Args.size(); ++ArgIdx) {
|
2011-01-07 06:09:01 +08:00
|
|
|
HasAnyArguments = true;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-06-17 00:50:48 +08:00
|
|
|
QualType OrigParamType = ParamPattern;
|
|
|
|
ParamType = OrigParamType;
|
2011-01-07 06:09:01 +08:00
|
|
|
Expr *Arg = Args[ArgIdx];
|
|
|
|
QualType ArgType = Arg->getType();
|
2014-05-29 09:12:14 +08:00
|
|
|
|
2011-01-07 06:09:01 +08:00
|
|
|
unsigned TDF = 0;
|
|
|
|
if (AdjustFunctionParmAndArgTypesForDeduction(*this, TemplateParams,
|
|
|
|
ParamType, ArgType, Arg,
|
|
|
|
TDF)) {
|
|
|
|
// We can't actually perform any deduction for this argument, so stop
|
|
|
|
// deduction at this point.
|
|
|
|
++ArgIdx;
|
|
|
|
break;
|
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2012-01-18 06:49:58 +08:00
|
|
|
// As above, initializer lists need special handling.
|
|
|
|
if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) {
|
2015-06-25 08:25:49 +08:00
|
|
|
TemplateDeductionResult Result;
|
|
|
|
if (!DeduceFromInitializerList(*this, TemplateParams, ParamType, ILE,
|
|
|
|
Info, Deduced, TDF, Result)) {
|
2012-01-18 06:49:58 +08:00
|
|
|
++ArgIdx;
|
|
|
|
break;
|
|
|
|
}
|
2011-06-17 00:50:48 +08:00
|
|
|
|
2015-06-25 08:25:49 +08:00
|
|
|
if (Result)
|
|
|
|
return Result;
|
2012-01-18 06:49:58 +08:00
|
|
|
} else {
|
|
|
|
|
|
|
|
// Keep track of the argument type and corresponding argument index,
|
|
|
|
// so we can check for compatibility between the deduced A and A.
|
|
|
|
if (hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType))
|
2016-08-12 19:43:57 +08:00
|
|
|
OriginalCallArgs.push_back(OriginalCallArg(OrigParamType, ArgIdx,
|
2012-01-18 06:49:58 +08:00
|
|
|
ArgType));
|
|
|
|
|
|
|
|
if (TemplateDeductionResult Result
|
|
|
|
= DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams,
|
|
|
|
ParamType, ArgType, Info,
|
|
|
|
Deduced, TDF))
|
|
|
|
return Result;
|
|
|
|
}
|
2010-02-02 10:21:27 +08:00
|
|
|
|
2014-05-29 09:12:14 +08:00
|
|
|
PackScope.nextPackElement();
|
2009-06-26 06:08:12 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-07 06:09:01 +08:00
|
|
|
// Build argument packs for each of the parameter packs expanded by this
|
|
|
|
// pack expansion.
|
2014-05-29 09:12:14 +08:00
|
|
|
if (auto Result = PackScope.finish(HasAnyArguments))
|
2011-01-27 15:10:08 +08:00
|
|
|
return Result;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2011-01-07 06:09:01 +08:00
|
|
|
// After we've matching against a parameter pack, we're done.
|
|
|
|
break;
|
2009-06-26 06:08:12 +08:00
|
|
|
}
|
2009-08-22 07:19:43 +08:00
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
return FinishTemplateArgumentDeduction(FunctionTemplate, Deduced,
|
2014-07-28 08:02:09 +08:00
|
|
|
NumExplicitlySpecified, Specialization,
|
2015-01-22 00:24:11 +08:00
|
|
|
Info, &OriginalCallArgs,
|
|
|
|
PartialOverloading);
|
2009-07-09 04:55:45 +08:00
|
|
|
}
|
2009-06-30 04:59:39 +08:00
|
|
|
|
2013-12-02 00:54:29 +08:00
|
|
|
QualType Sema::adjustCCAndNoReturn(QualType ArgFunctionType,
|
|
|
|
QualType FunctionType) {
|
|
|
|
if (ArgFunctionType.isNull())
|
|
|
|
return ArgFunctionType;
|
|
|
|
|
|
|
|
const FunctionProtoType *FunctionTypeP =
|
|
|
|
FunctionType->castAs<FunctionProtoType>();
|
|
|
|
CallingConv CC = FunctionTypeP->getCallConv();
|
|
|
|
bool NoReturn = FunctionTypeP->getNoReturnAttr();
|
|
|
|
const FunctionProtoType *ArgFunctionTypeP =
|
|
|
|
ArgFunctionType->getAs<FunctionProtoType>();
|
|
|
|
if (ArgFunctionTypeP->getCallConv() == CC &&
|
|
|
|
ArgFunctionTypeP->getNoReturnAttr() == NoReturn)
|
|
|
|
return ArgFunctionType;
|
|
|
|
|
|
|
|
FunctionType::ExtInfo EI = ArgFunctionTypeP->getExtInfo().withCallingConv(CC);
|
|
|
|
EI = EI.withNoReturn(NoReturn);
|
|
|
|
ArgFunctionTypeP =
|
|
|
|
cast<FunctionProtoType>(Context.adjustFunctionType(ArgFunctionTypeP, EI));
|
|
|
|
return QualType(ArgFunctionTypeP, 0);
|
|
|
|
}
|
|
|
|
|
2009-07-09 04:55:45 +08:00
|
|
|
/// \brief Deduce template arguments when taking the address of a function
|
2009-12-22 07:17:24 +08:00
|
|
|
/// template (C++ [temp.deduct.funcaddr]) or matching a specialization to
|
|
|
|
/// a template.
|
2009-07-09 04:55:45 +08:00
|
|
|
///
|
|
|
|
/// \param FunctionTemplate the function template for which we are performing
|
|
|
|
/// template argument deduction.
|
|
|
|
///
|
2012-06-22 16:52:37 +08:00
|
|
|
/// \param ExplicitTemplateArgs the explicitly-specified template
|
2009-12-22 07:17:24 +08:00
|
|
|
/// arguments.
|
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
|
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.
|
2009-07-09 04:55:45 +08:00
|
|
|
///
|
|
|
|
/// \param Specialization if template argument deduction was successful,
|
2009-09-09 23:08:12 +08:00
|
|
|
/// this will be set to the function template specialization produced by
|
2009-07-09 04:55:45 +08:00
|
|
|
/// template argument deduction.
|
|
|
|
///
|
|
|
|
/// \param Info the argument will be updated to provide additional information
|
|
|
|
/// about template argument deduction.
|
|
|
|
///
|
|
|
|
/// \returns the result of template argument deduction.
|
|
|
|
Sema::TemplateDeductionResult
|
|
|
|
Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
|
2011-03-03 10:41:12 +08:00
|
|
|
TemplateArgumentListInfo *ExplicitTemplateArgs,
|
2009-07-09 04:55:45 +08:00
|
|
|
QualType ArgFunctionType,
|
|
|
|
FunctionDecl *&Specialization,
|
2013-04-17 16:45:07 +08:00
|
|
|
TemplateDeductionInfo &Info,
|
|
|
|
bool InOverloadResolution) {
|
2012-09-14 05:01:57 +08:00
|
|
|
if (FunctionTemplate->isInvalidDecl())
|
|
|
|
return TDK_Invalid;
|
|
|
|
|
2009-07-09 04:55:45 +08:00
|
|
|
FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
|
|
|
|
TemplateParameterList *TemplateParams
|
|
|
|
= FunctionTemplate->getTemplateParameters();
|
|
|
|
QualType FunctionType = Function->getType();
|
2013-12-02 00:54:29 +08:00
|
|
|
if (!InOverloadResolution)
|
|
|
|
ArgFunctionType = adjustCCAndNoReturn(ArgFunctionType, FunctionType);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-09 04:55:45 +08:00
|
|
|
// Substitute any explicit template arguments.
|
2010-08-25 13:32:35 +08:00
|
|
|
LocalInstantiationScope InstScope(*this);
|
2011-07-23 18:55:15 +08:00
|
|
|
SmallVector<DeducedTemplateArgument, 4> Deduced;
|
2010-03-28 10:42:43 +08:00
|
|
|
unsigned NumExplicitlySpecified = 0;
|
2011-07-23 18:55:15 +08:00
|
|
|
SmallVector<QualType, 4> ParamTypes;
|
2009-11-23 09:53:49 +08:00
|
|
|
if (ExplicitTemplateArgs) {
|
2009-09-09 23:08:12 +08:00
|
|
|
if (TemplateDeductionResult Result
|
|
|
|
= SubstituteExplicitTemplateArguments(FunctionTemplate,
|
2009-11-23 09:53:49 +08:00
|
|
|
*ExplicitTemplateArgs,
|
2009-09-09 23:08:12 +08:00
|
|
|
Deduced, ParamTypes,
|
2009-07-09 04:55:45 +08:00
|
|
|
&FunctionType, Info))
|
|
|
|
return Result;
|
2010-03-28 10:42:43 +08:00
|
|
|
|
|
|
|
NumExplicitlySpecified = Deduced.size();
|
2009-06-30 04:59:39 +08:00
|
|
|
}
|
2009-07-09 04:55:45 +08:00
|
|
|
|
2012-02-08 11:07:05 +08:00
|
|
|
// Unevaluated SFINAE context.
|
|
|
|
EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
|
2009-09-09 23:08:12 +08:00
|
|
|
SFINAETrap Trap(*this);
|
|
|
|
|
2010-02-02 10:21:27 +08:00
|
|
|
Deduced.resize(TemplateParams->size());
|
|
|
|
|
2013-05-04 15:00:32 +08:00
|
|
|
// If the function has a deduced return type, substitute it for a dependent
|
|
|
|
// type so that we treat it as a non-deduced context in what follows.
|
2013-08-15 04:16:31 +08:00
|
|
|
bool HasDeducedReturnType = false;
|
2014-08-19 23:55:55 +08:00
|
|
|
if (getLangOpts().CPlusPlus14 && InOverloadResolution &&
|
2014-01-26 00:55:45 +08:00
|
|
|
Function->getReturnType()->getContainedAutoType()) {
|
2013-05-04 15:00:32 +08:00
|
|
|
FunctionType = SubstAutoType(FunctionType, Context.DependentTy);
|
2013-08-15 04:16:31 +08:00
|
|
|
HasDeducedReturnType = true;
|
2013-05-04 15:00:32 +08:00
|
|
|
}
|
|
|
|
|
2009-12-22 07:17:24 +08:00
|
|
|
if (!ArgFunctionType.isNull()) {
|
2013-04-17 16:45:07 +08:00
|
|
|
unsigned TDF = TDF_TopLevelParameterTypeList;
|
|
|
|
if (InOverloadResolution) TDF |= TDF_InOverloadResolution;
|
2009-12-22 07:17:24 +08:00
|
|
|
// Deduce template arguments from the function type.
|
|
|
|
if (TemplateDeductionResult Result
|
2012-01-18 06:49:52 +08:00
|
|
|
= DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams,
|
2013-04-17 16:45:07 +08:00
|
|
|
FunctionType, ArgFunctionType,
|
|
|
|
Info, Deduced, TDF))
|
2009-12-22 07:17:24 +08:00
|
|
|
return Result;
|
|
|
|
}
|
2010-09-30 05:14:36 +08:00
|
|
|
|
2011-01-27 15:10:08 +08:00
|
|
|
if (TemplateDeductionResult Result
|
2010-09-30 05:14:36 +08:00
|
|
|
= FinishTemplateArgumentDeduction(FunctionTemplate, Deduced,
|
|
|
|
NumExplicitlySpecified,
|
|
|
|
Specialization, Info))
|
|
|
|
return Result;
|
|
|
|
|
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.
|
2013-08-15 04:16:31 +08:00
|
|
|
if (HasDeducedReturnType &&
|
2014-01-26 00:55:45 +08:00
|
|
|
Specialization->getReturnType()->isUndeducedType() &&
|
2013-05-04 15:00:32 +08:00
|
|
|
DeduceReturnType(Specialization, Info.getLocation(), false))
|
|
|
|
return TDK_MiscellaneousDeductionFailure;
|
|
|
|
|
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;
|
|
|
|
|
2010-09-30 05:14:36 +08:00
|
|
|
// If the requested function type does not match the actual type of the
|
2013-04-17 16:45:07 +08:00
|
|
|
// specialization with respect to arguments of compatible pointer to function
|
|
|
|
// types, template argument deduction fails.
|
|
|
|
if (!ArgFunctionType.isNull()) {
|
|
|
|
if (InOverloadResolution && !isSameOrCompatibleFunctionType(
|
|
|
|
Context.getCanonicalType(Specialization->getType()),
|
|
|
|
Context.getCanonicalType(ArgFunctionType)))
|
|
|
|
return TDK_MiscellaneousDeductionFailure;
|
|
|
|
else if(!InOverloadResolution &&
|
|
|
|
!Context.hasSameType(Specialization->getType(), ArgFunctionType))
|
|
|
|
return TDK_MiscellaneousDeductionFailure;
|
|
|
|
}
|
2010-09-30 05:14:36 +08:00
|
|
|
|
|
|
|
return TDK_Success;
|
2009-06-26 06:08:12 +08:00
|
|
|
}
|
|
|
|
|
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
|
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.
|
2016-08-12 19:43:57 +08:00
|
|
|
static inline void
|
|
|
|
SubstAutoWithinFunctionReturnType(FunctionDecl *F,
|
2013-09-29 16:45:24 +08:00
|
|
|
QualType TypeToReplaceAutoWith, Sema &S) {
|
2013-10-25 07:40:02 +08:00
|
|
|
assert(!TypeToReplaceAutoWith->getContainedAutoType());
|
2014-01-26 00:55:45 +08:00
|
|
|
QualType AutoResultType = F->getReturnType();
|
2016-08-12 19:43:57 +08:00
|
|
|
assert(AutoResultType->getContainedAutoType());
|
|
|
|
QualType DeducedResultType = S.SubstAutoType(AutoResultType,
|
2013-09-29 16:45:24 +08:00
|
|
|
TypeToReplaceAutoWith);
|
|
|
|
S.Context.adjustDeducedFunctionResultType(F, DeducedResultType);
|
|
|
|
}
|
2013-10-25 07:40:02 +08:00
|
|
|
|
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
|
2013-10-25 07:40:02 +08:00
|
|
|
/// return type of the destination function ptr.
|
|
|
|
|
2016-08-12 19:43:57 +08:00
|
|
|
static inline Sema::TemplateDeductionResult
|
2013-10-25 07:40:02 +08:00
|
|
|
SpecializeCorrespondingLambdaCallOperatorAndInvoker(
|
|
|
|
CXXConversionDecl *ConversionSpecialized,
|
|
|
|
SmallVectorImpl<DeducedTemplateArgument> &DeducedArguments,
|
|
|
|
QualType ReturnTypeOfDestFunctionPtr,
|
|
|
|
TemplateDeductionInfo &TDInfo,
|
|
|
|
Sema &S) {
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2013-10-25 07:40:02 +08:00
|
|
|
CXXRecordDecl *LambdaClass = ConversionSpecialized->getParent();
|
2016-08-12 19:43:57 +08:00
|
|
|
assert(LambdaClass && LambdaClass->isGenericLambda());
|
|
|
|
|
2013-10-25 07:40:02 +08:00
|
|
|
CXXMethodDecl *CallOpGeneric = LambdaClass->getLambdaCallOperator();
|
2014-01-26 00:55:45 +08:00
|
|
|
QualType CallOpResultType = CallOpGeneric->getReturnType();
|
2016-08-12 19:43:57 +08:00
|
|
|
const bool GenericLambdaCallOperatorHasDeducedReturnType =
|
2013-10-25 07:40:02 +08:00
|
|
|
CallOpResultType->getContainedAutoType();
|
2016-08-12 19:43:57 +08:00
|
|
|
|
|
|
|
FunctionTemplateDecl *CallOpTemplate =
|
2013-10-25 07:40:02 +08:00
|
|
|
CallOpGeneric->getDescribedFunctionTemplate();
|
|
|
|
|
2014-05-26 14:22:03 +08:00
|
|
|
FunctionDecl *CallOpSpecialized = nullptr;
|
2016-08-12 19:43:57 +08:00
|
|
|
// Use the deduced arguments of the conversion function, to specialize our
|
2013-10-25 07:40:02 +08:00
|
|
|
// generic lambda's call operator.
|
|
|
|
if (Sema::TemplateDeductionResult Result
|
2016-08-12 19:43:57 +08:00
|
|
|
= S.FinishTemplateArgumentDeduction(CallOpTemplate,
|
|
|
|
DeducedArguments,
|
2013-10-25 07:40:02 +08:00
|
|
|
0, CallOpSpecialized, TDInfo))
|
|
|
|
return Result;
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2013-10-25 07:40:02 +08:00
|
|
|
// If we need to deduce the return type, do so (instantiates the callop).
|
2014-01-26 00:55:45 +08:00
|
|
|
if (GenericLambdaCallOperatorHasDeducedReturnType &&
|
|
|
|
CallOpSpecialized->getReturnType()->isUndeducedType())
|
2016-08-12 19:43:57 +08:00
|
|
|
S.DeduceReturnType(CallOpSpecialized,
|
2013-10-25 07:40:02 +08:00
|
|
|
CallOpSpecialized->getPointOfInstantiation(),
|
|
|
|
/*Diagnose*/ true);
|
2016-08-12 19:43:57 +08:00
|
|
|
|
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.
|
2014-01-26 00:55:45 +08:00
|
|
|
if (!S.Context.hasSameType(CallOpSpecialized->getReturnType(),
|
2013-10-25 07:40:02 +08:00
|
|
|
ReturnTypeOfDestFunctionPtr))
|
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
|
|
|
// Since we have succeeded in matching the source and destination
|
2016-08-12 19:43:57 +08:00
|
|
|
// ptr-to-functions (now including return type), and have successfully
|
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.
|
2014-05-26 14:22:03 +08:00
|
|
|
FunctionDecl *InvokerSpecialized = nullptr;
|
2013-10-25 07:40:02 +08:00
|
|
|
FunctionTemplateDecl *InvokerTemplate = LambdaClass->
|
|
|
|
getLambdaStaticInvoker()->getDescribedFunctionTemplate();
|
|
|
|
|
2015-05-14 01:56:46 +08:00
|
|
|
#ifndef NDEBUG
|
|
|
|
Sema::TemplateDeductionResult LLVM_ATTRIBUTE_UNUSED Result =
|
|
|
|
#endif
|
2016-08-12 19:43:57 +08:00
|
|
|
S.FinishTemplateArgumentDeduction(InvokerTemplate, DeducedArguments, 0,
|
2013-10-25 07:40:02 +08:00
|
|
|
InvokerSpecialized, TDInfo);
|
2016-08-12 19:43:57 +08:00
|
|
|
assert(Result == Sema::TDK_Success &&
|
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.
|
2014-01-26 00:55:45 +08:00
|
|
|
if (GenericLambdaCallOperatorHasDeducedReturnType &&
|
|
|
|
InvokerSpecialized->getReturnType()->isUndeducedType()) {
|
2013-10-25 07:40:02 +08:00
|
|
|
// Be sure to get the type to replace 'auto' with and not
|
2016-08-12 19:43:57 +08:00
|
|
|
// the full result type of the call op specialization
|
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**.
|
|
|
|
|
2014-01-26 00:55:45 +08:00
|
|
|
QualType TypeToReplaceAutoWith = CallOpSpecialized->getReturnType()
|
|
|
|
->getContainedAutoType()
|
|
|
|
->getDeducedType();
|
2013-10-25 07:40:02 +08:00
|
|
|
SubstAutoWithinFunctionReturnType(InvokerSpecialized,
|
|
|
|
TypeToReplaceAutoWith, S);
|
2016-08-12 19:43:57 +08:00
|
|
|
SubstAutoWithinFunctionReturnType(ConversionSpecialized,
|
2013-10-25 07:40:02 +08:00
|
|
|
TypeToReplaceAutoWith, S);
|
|
|
|
}
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2013-10-25 07:40:02 +08:00
|
|
|
// Ensure that static invoker doesn't have a const qualifier.
|
2016-08-12 19:43:57 +08:00
|
|
|
// FIXME: When creating the InvokerTemplate in SemaLambda.cpp
|
2013-10-25 07:40:02 +08:00
|
|
|
// do not use the CallOperator's TypeSourceInfo which allows
|
2016-08-12 19:43:57 +08:00
|
|
|
// the const qualifier to leak through.
|
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(
|
2014-01-26 00:55:45 +08:00
|
|
|
InvokerFPT->getReturnType(), InvokerFPT->getParamTypes(), EPI));
|
2013-10-25 07:40:02 +08:00
|
|
|
return Sema::TDK_Success;
|
|
|
|
}
|
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
|
2013-09-29 16:45:24 +08:00
|
|
|
Sema::DeduceTemplateArguments(FunctionTemplateDecl *ConversionTemplate,
|
2009-08-22 07:19:43 +08:00
|
|
|
QualType ToType,
|
|
|
|
CXXConversionDecl *&Specialization,
|
|
|
|
TemplateDeductionInfo &Info) {
|
2013-09-29 16:45:24 +08:00
|
|
|
if (ConversionTemplate->isInvalidDecl())
|
2012-09-14 05:01:57 +08:00
|
|
|
return TDK_Invalid;
|
|
|
|
|
2013-10-25 07:40:02 +08:00
|
|
|
CXXConversionDecl *ConversionGeneric
|
2013-09-29 16:45:24 +08:00
|
|
|
= cast<CXXConversionDecl>(ConversionTemplate->getTemplatedDecl());
|
|
|
|
|
2013-10-25 07:40:02 +08:00
|
|
|
QualType FromType = ConversionGeneric->getConversionType();
|
2009-08-22 07:19:43 +08:00
|
|
|
|
|
|
|
// Canonicalize the types for deduction.
|
|
|
|
QualType P = Context.getCanonicalType(FromType);
|
|
|
|
QualType A = Context.getCanonicalType(ToType);
|
|
|
|
|
2011-03-06 17:03:20 +08:00
|
|
|
// C++0x [temp.deduct.conv]p2:
|
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();
|
|
|
|
|
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
|
2009-08-22 07:19:43 +08:00
|
|
|
// for type deduction.
|
|
|
|
if (const ReferenceType *ARef = A->getAs<ReferenceType>())
|
2011-03-06 17:03:20 +08:00
|
|
|
A = ARef->getPointeeType().getUnqualifiedType();
|
|
|
|
// C++ [temp.deduct.conv]p3:
|
2009-08-22 07:19:43 +08:00
|
|
|
//
|
2009-09-09 23:08:12 +08:00
|
|
|
// If A is not a reference type:
|
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
|
2009-09-09 23:08:12 +08:00
|
|
|
// array-to-pointer standard conversion (4.2) is used in place
|
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
|
2011-01-27 15:09:49 +08:00
|
|
|
// P's type are ignored for type deduction.
|
2009-08-22 07:19:43 +08:00
|
|
|
else
|
|
|
|
P = P.getUnqualifiedType();
|
|
|
|
|
2011-03-06 17:03:20 +08:00
|
|
|
// C++0x [temp.deduct.conv]p4:
|
2011-01-27 15:09:49 +08:00
|
|
|
// If A is a cv-qualified type, the top level cv-qualifiers of A's
|
2014-07-28 08:02:09 +08:00
|
|
|
// type are ignored for type deduction. If A is a reference type, the type
|
2011-03-06 17:03:20 +08:00
|
|
|
// referred to by A is used for type deduction.
|
2009-08-22 07:19:43 +08:00
|
|
|
A = A.getUnqualifiedType();
|
|
|
|
}
|
|
|
|
|
2012-02-08 11:07:05 +08:00
|
|
|
// Unevaluated SFINAE context.
|
|
|
|
EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
|
2009-09-09 23:08:12 +08:00
|
|
|
SFINAETrap Trap(*this);
|
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
|
2013-09-29 16:45:24 +08:00
|
|
|
= ConversionTemplate->getTemplateParameters();
|
2011-07-23 18:55:15 +08:00
|
|
|
SmallVector<DeducedTemplateArgument, 4> Deduced;
|
2009-09-09 23:08:12 +08:00
|
|
|
Deduced.resize(TemplateParams->size());
|
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
|
2011-01-27 15:09:49 +08:00
|
|
|
// type that can be converted to A via a qualification
|
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()) ||
|
2011-08-30 08:37:54 +08:00
|
|
|
(P->isMemberPointerType() && A->isMemberPointerType()))
|
2009-08-22 07:19:43 +08:00
|
|
|
TDF |= TDF_IgnoreQualifiers;
|
|
|
|
if (TemplateDeductionResult Result
|
2012-01-18 06:49:52 +08:00
|
|
|
= DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams,
|
|
|
|
P, A, Info, Deduced, TDF))
|
2009-08-22 07:19:43 +08:00
|
|
|
return Result;
|
2013-09-30 01:08:32 +08:00
|
|
|
|
|
|
|
// Create an Instantiation Scope for finalizing the operator.
|
|
|
|
LocalInstantiationScope InstScope(*this);
|
2013-10-25 07:40:02 +08:00
|
|
|
// Finish template argument deduction.
|
2014-05-26 14:22:03 +08:00
|
|
|
FunctionDecl *ConversionSpecialized = nullptr;
|
2013-10-25 07:40:02 +08:00
|
|
|
TemplateDeductionResult Result
|
2016-08-12 19:43:57 +08:00
|
|
|
= FinishTemplateArgumentDeduction(ConversionTemplate, Deduced, 0,
|
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
|
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.
|
2013-10-25 07:40:02 +08:00
|
|
|
// e.g., int (*fp)(int) = [](auto a) { return a; };
|
|
|
|
if (Result == TDK_Success && isLambdaConversionOperator(ConversionGeneric)) {
|
2016-08-12 19:43:57 +08:00
|
|
|
|
2013-10-25 07:40:02 +08:00
|
|
|
// Get the return type of the destination ptr-to-function we are converting
|
2016-08-12 19:43:57 +08:00
|
|
|
// to. This is necessary for matching the lambda call operator's return
|
2013-10-25 07:40:02 +08:00
|
|
|
// type to that of the destination ptr-to-function's return type.
|
2016-08-12 19:43:57 +08:00
|
|
|
assert(A->isPointerType() &&
|
2013-10-25 07:40:02 +08:00
|
|
|
"Can only convert from lambda to ptr-to-function");
|
2016-08-12 19:43:57 +08:00
|
|
|
const FunctionType *ToFunType =
|
2013-10-25 07:40:02 +08:00
|
|
|
A->getPointeeType().getTypePtr()->getAs<FunctionType>();
|
2014-01-26 00:55:45 +08:00
|
|
|
const QualType DestFunctionPtrReturnType = ToFunType->getReturnType();
|
|
|
|
|
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
|
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(
|
2016-08-12 19:43:57 +08:00
|
|
|
Specialization, Deduced, DestFunctionPtrReturnType,
|
2013-10-25 07:40:02 +08:00
|
|
|
Info, *this);
|
2013-09-29 16:45:24 +08:00
|
|
|
}
|
2009-08-22 07:19:43 +08:00
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
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.
|
|
|
|
///
|
2012-06-22 16:52:37 +08:00
|
|
|
/// \param ExplicitTemplateArgs the explicitly-specified template
|
2009-12-22 07:17:24 +08:00
|
|
|
/// arguments.
|
|
|
|
///
|
|
|
|
/// \param Specialization if template argument deduction was successful,
|
|
|
|
/// this will be set to the function template specialization produced by
|
|
|
|
/// template argument deduction.
|
|
|
|
///
|
|
|
|
/// \param Info the argument will be updated to provide additional information
|
|
|
|
/// about template argument deduction.
|
|
|
|
///
|
|
|
|
/// \returns the result of template argument deduction.
|
|
|
|
Sema::TemplateDeductionResult
|
|
|
|
Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
|
2011-03-03 10:41:12 +08:00
|
|
|
TemplateArgumentListInfo *ExplicitTemplateArgs,
|
2009-12-22 07:17:24 +08:00
|
|
|
FunctionDecl *&Specialization,
|
2013-04-17 16:45:07 +08:00
|
|
|
TemplateDeductionInfo &Info,
|
|
|
|
bool InOverloadResolution) {
|
2009-12-22 07:17:24 +08:00
|
|
|
return DeduceTemplateArguments(FunctionTemplate, ExplicitTemplateArgs,
|
2013-04-17 16:45:07 +08:00
|
|
|
QualType(), Specialization, Info,
|
|
|
|
InOverloadResolution);
|
2009-12-22 07:17:24 +08:00
|
|
|
}
|
|
|
|
|
2011-02-20 11:19:35 +08:00
|
|
|
namespace {
|
|
|
|
/// Substitute the 'auto' type specifier within a type for a given replacement
|
|
|
|
/// type.
|
|
|
|
class SubstituteAutoTransform :
|
|
|
|
public TreeTransform<SubstituteAutoTransform> {
|
|
|
|
QualType Replacement;
|
|
|
|
public:
|
2014-07-28 08:02:09 +08:00
|
|
|
SubstituteAutoTransform(Sema &SemaRef, QualType Replacement)
|
|
|
|
: TreeTransform<SubstituteAutoTransform>(SemaRef),
|
|
|
|
Replacement(Replacement) {}
|
|
|
|
|
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.
|
2013-05-04 15:00:32 +08:00
|
|
|
if (!Replacement.isNull() && isa<TemplateTypeParmType>(Replacement)) {
|
2011-02-20 11:19:35 +08:00
|
|
|
QualType Result = Replacement;
|
2013-04-27 00:15:35 +08:00
|
|
|
TemplateTypeParmTypeLoc NewTL =
|
|
|
|
TLB.push<TemplateTypeParmTypeLoc>(Result);
|
2011-02-20 11:19:35 +08:00
|
|
|
NewTL.setNameLoc(TL.getNameLoc());
|
|
|
|
return Result;
|
|
|
|
} else {
|
2013-04-30 21:56:41 +08:00
|
|
|
bool Dependent =
|
|
|
|
!Replacement.isNull() && Replacement->isDependentType();
|
|
|
|
QualType Result =
|
|
|
|
SemaRef.Context.getAutoType(Dependent ? QualType() : Replacement,
|
2015-11-11 10:02:15 +08:00
|
|
|
TL.getTypePtr()->getKeyword(),
|
2013-08-22 20:12:24 +08:00
|
|
|
Dependent);
|
2011-02-20 11:19:35 +08:00
|
|
|
AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result);
|
|
|
|
NewTL.setNameLoc(TL.getNameLoc());
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
}
|
2012-02-14 06:00:16 +08:00
|
|
|
|
|
|
|
ExprResult TransformLambdaExpr(LambdaExpr *E) {
|
|
|
|
// Lambdas never need to be transformed.
|
|
|
|
return E;
|
|
|
|
}
|
2013-05-01 05:23:01 +08:00
|
|
|
|
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);
|
2013-05-01 05:23:01 +08:00
|
|
|
}
|
2011-02-20 11:19:35 +08:00
|
|
|
};
|
2015-06-23 07:07:51 +08:00
|
|
|
}
|
2011-02-20 11:19:35 +08:00
|
|
|
|
2013-05-04 15:00:32 +08:00
|
|
|
Sema::DeduceAutoResult
|
|
|
|
Sema::DeduceAutoType(TypeSourceInfo *Type, Expr *&Init, QualType &Result) {
|
|
|
|
return DeduceAutoType(Type->getTypeLoc(), Init, Result);
|
|
|
|
}
|
|
|
|
|
2013-05-01 05:23:01 +08:00
|
|
|
/// \brief Deduce the type for an auto type-specifier (C++11 [dcl.spec.auto]p6)
|
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
|
2013-05-01 05:23:01 +08:00
|
|
|
/// deduced type.
|
2012-01-24 06:09:39 +08:00
|
|
|
Sema::DeduceAutoResult
|
2013-05-04 15:00:32 +08:00
|
|
|
Sema::DeduceAutoType(TypeLoc Type, Expr *&Init, QualType &Result) {
|
2011-11-15 09:35:18 +08:00
|
|
|
if (Init->getType()->isNonOverloadPlaceholderType()) {
|
2013-05-01 05:23:01 +08:00
|
|
|
ExprResult NonPlaceholder = CheckPlaceholderExpr(Init);
|
|
|
|
if (NonPlaceholder.isInvalid())
|
|
|
|
return DAR_FailedAlreadyDiagnosed;
|
2014-05-29 18:55:11 +08:00
|
|
|
Init = NonPlaceholder.get();
|
2011-11-15 09:35:18 +08:00
|
|
|
}
|
|
|
|
|
2013-05-04 15:00:32 +08:00
|
|
|
if (Init->isTypeDependent() || Type.getType()->isDependentType()) {
|
2013-05-01 05:23:01 +08:00
|
|
|
Result = SubstituteAutoTransform(*this, Context.DependentTy).Apply(Type);
|
2013-05-04 15:00:32 +08:00
|
|
|
assert(!Result.isNull() && "substituting DependentTy can't fail");
|
2012-01-24 06:09:39 +08:00
|
|
|
return DAR_Succeeded;
|
2011-02-20 11:19:35 +08:00
|
|
|
}
|
|
|
|
|
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.
|
2013-05-04 15:00:32 +08:00
|
|
|
if (const AutoType *AT = Type.getType()->getAs<AutoType>()) {
|
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;
|
|
|
|
}
|
|
|
|
|
2014-12-18 05:57:17 +08:00
|
|
|
QualType Deduced = BuildDecltypeType(Init, Init->getLocStart(), false);
|
2015-07-01 08:29:28 +08:00
|
|
|
if (Deduced.isNull())
|
|
|
|
return DAR_FailedAlreadyDiagnosed;
|
2013-04-27 00:15:35 +08:00
|
|
|
// FIXME: Support a non-canonical deduced type for 'auto'.
|
|
|
|
Deduced = Context.getCanonicalType(Deduced);
|
2013-05-01 05:23:01 +08:00
|
|
|
Result = SubstituteAutoTransform(*this, Deduced).Apply(Type);
|
2013-05-04 15:00:32 +08:00
|
|
|
if (Result.isNull())
|
|
|
|
return DAR_FailedAlreadyDiagnosed;
|
2013-04-27 00:15:35 +08:00
|
|
|
return DAR_Succeeded;
|
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;
|
|
|
|
}
|
2013-04-27 00:15:35 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-02-20 11:19:35 +08:00
|
|
|
SourceLocation Loc = Init->getExprLoc();
|
|
|
|
|
|
|
|
LocalInstantiationScope InstScope(*this);
|
|
|
|
|
|
|
|
// Build template<class TemplParam> void Func(FuncParam);
|
Re-applies the patch first applied way back in r106099, with
accompanying fixes to make it work today.
The core of this patch is to provide a link from a TemplateTypeParmType
back to the TemplateTypeParmDecl node which declared it. This in turn
provides much more precise information about the type, where it came
from, and how it functions for AST consumers.
To make the patch work almost a year after its first attempt, it needed
serialization support, and it now retains the old getName() interface.
Finally, it requires us to not attempt to instantiate the type in an
unsupported friend decl -- specifically those coming from template
friend decls but which refer to a specific type through a dependent
name.
A cleaner representation of the last item would be to build
FriendTemplateDecl nodes for these, storing their template parameters
etc, and to perform proper instantation of them like any other template
declaration. They can still be flagged as unsupported for the purpose of
access checking, etc.
This passed an asserts-enabled bootstrap for me, and the reduced test
case mentioned in the original review thread no longer causes issues,
likely fixed at somewhere amidst the 24k revisions that have elapsed.
llvm-svn: 130628
2011-05-01 08:51:33 +08:00
|
|
|
TemplateTypeParmDecl *TemplParam =
|
2014-05-26 14:22:03 +08:00
|
|
|
TemplateTypeParmDecl::Create(Context, nullptr, SourceLocation(), Loc, 0, 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;
|
2016-07-31 06:33:34 +08:00
|
|
|
FixedSizeTemplateParameterListStorage<1, false> TemplateParamsSt(
|
|
|
|
Loc, Loc, TemplParamPtr, Loc, nullptr);
|
2011-02-22 04:05:19 +08:00
|
|
|
|
2013-05-01 05:23:01 +08:00
|
|
|
QualType FuncParam = SubstituteAutoTransform(*this, TemplArg).Apply(Type);
|
|
|
|
assert(!FuncParam.isNull() &&
|
|
|
|
"substituting template parameter for 'auto' failed");
|
2011-02-20 11:19:35 +08:00
|
|
|
|
|
|
|
// Deduce type of TemplParam in Func(Init)
|
2011-07-23 18:55:15 +08:00
|
|
|
SmallVector<DeducedTemplateArgument, 1> Deduced;
|
2011-02-20 11:19:35 +08:00
|
|
|
Deduced.resize(1);
|
|
|
|
QualType InitType = Init->getType();
|
|
|
|
unsigned TDF = 0;
|
|
|
|
|
2012-09-19 10:26:47 +08:00
|
|
|
TemplateDeductionInfo Info(Loc);
|
2012-01-18 06:50:08 +08:00
|
|
|
|
2012-07-08 12:13:07 +08:00
|
|
|
InitListExpr *InitList = dyn_cast<InitListExpr>(Init);
|
2012-01-18 06:50:08 +08:00
|
|
|
if (InitList) {
|
|
|
|
for (unsigned i = 0, e = InitList->getNumInits(); i < e; ++i) {
|
2015-08-07 04:26:32 +08:00
|
|
|
if (DeduceTemplateArgumentByListElement(*this, TemplateParamsSt.get(),
|
|
|
|
TemplArg, InitList->getInit(i),
|
2012-04-04 13:10:53 +08:00
|
|
|
Info, Deduced, TDF))
|
2012-01-24 06:09:39 +08:00
|
|
|
return DAR_Failed;
|
2012-01-18 06:50:08 +08:00
|
|
|
}
|
|
|
|
} else {
|
2015-11-11 10:02:15 +08:00
|
|
|
if (!getLangOpts().CPlusPlus && Init->refersToBitField()) {
|
|
|
|
Diag(Loc, diag::err_auto_bitfield);
|
|
|
|
return DAR_FailedAlreadyDiagnosed;
|
|
|
|
}
|
|
|
|
|
2015-08-07 04:26:32 +08:00
|
|
|
if (AdjustFunctionParmAndArgTypesForDeduction(
|
|
|
|
*this, TemplateParamsSt.get(), FuncParam, InitType, Init, TDF))
|
2012-04-04 13:10:53 +08:00
|
|
|
return DAR_Failed;
|
2012-07-08 12:13:07 +08:00
|
|
|
|
2015-08-07 04:26:32 +08:00
|
|
|
if (DeduceTemplateArgumentsByTypeMatch(*this, TemplateParamsSt.get(),
|
|
|
|
FuncParam, InitType, Info, Deduced,
|
|
|
|
TDF))
|
2012-01-24 06:09:39 +08:00
|
|
|
return DAR_Failed;
|
2012-01-18 06:50:08 +08:00
|
|
|
}
|
2011-02-20 11:19:35 +08:00
|
|
|
|
2012-11-07 07:56:42 +08:00
|
|
|
if (Deduced[0].getKind() != TemplateArgument::Type)
|
2012-01-24 06:09:39 +08:00
|
|
|
return DAR_Failed;
|
2012-01-18 06:50:08 +08:00
|
|
|
|
2012-11-07 07:56:42 +08:00
|
|
|
QualType DeducedType = Deduced[0].getAsType();
|
|
|
|
|
2012-01-18 06:50:08 +08:00
|
|
|
if (InitList) {
|
|
|
|
DeducedType = BuildStdInitializerList(DeducedType, Loc);
|
|
|
|
if (DeducedType.isNull())
|
2012-01-24 06:09:39 +08:00
|
|
|
return DAR_FailedAlreadyDiagnosed;
|
2012-01-18 06:50:08 +08:00
|
|
|
}
|
|
|
|
|
2013-05-01 05:23:01 +08:00
|
|
|
Result = SubstituteAutoTransform(*this, DeducedType).Apply(Type);
|
2013-05-04 15:00:32 +08:00
|
|
|
if (Result.isNull())
|
|
|
|
return DAR_FailedAlreadyDiagnosed;
|
2012-01-18 06:50:08 +08:00
|
|
|
|
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.
|
2013-05-01 05:23:01 +08:00
|
|
|
if (!InitList && !Result.isNull() &&
|
|
|
|
CheckOriginalCallArgDeduction(*this,
|
2011-06-17 13:31:46 +08:00
|
|
|
Sema::OriginalCallArg(FuncParam,0,InitType),
|
2013-05-01 05:23:01 +08:00
|
|
|
Result)) {
|
|
|
|
Result = QualType();
|
2012-01-24 06:09:39 +08:00
|
|
|
return DAR_Failed;
|
2011-06-17 13:31:46 +08:00
|
|
|
}
|
|
|
|
|
2012-01-24 06:09:39 +08:00
|
|
|
return DAR_Succeeded;
|
2011-02-20 11:19:35 +08:00
|
|
|
}
|
|
|
|
|
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) {
|
|
|
|
return SubstituteAutoTransform(*this, TypeToReplaceAuto).
|
|
|
|
TransformType(TypeWithAuto);
|
|
|
|
}
|
|
|
|
|
2016-08-12 19:43:57 +08:00
|
|
|
TypeSourceInfo* Sema::SubstAutoTypeSourceInfo(TypeSourceInfo *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) {
|
|
|
|
return SubstituteAutoTransform(*this, TypeToReplaceAuto).
|
|
|
|
TransformType(TypeWithAuto);
|
2013-04-30 21:56:41 +08:00
|
|
|
}
|
|
|
|
|
2012-01-18 06:50:08 +08:00
|
|
|
void Sema::DiagnoseAutoDeductionFailure(VarDecl *VDecl, Expr *Init) {
|
|
|
|
if (isa<InitListExpr>(Init))
|
|
|
|
Diag(VDecl->getLocation(),
|
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)
|
2012-01-18 06:50:08 +08:00
|
|
|
<< VDecl->getDeclName() << VDecl->getType() << Init->getSourceRange();
|
|
|
|
else
|
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)
|
2012-01-18 06:50:08 +08:00
|
|
|
<< VDecl->getDeclName() << VDecl->getType() << Init->getType()
|
|
|
|
<< Init->getSourceRange();
|
|
|
|
}
|
|
|
|
|
2013-05-04 15:00:32 +08:00
|
|
|
bool Sema::DeduceReturnType(FunctionDecl *FD, SourceLocation Loc,
|
|
|
|
bool Diagnose) {
|
2014-01-26 00:55:45 +08:00
|
|
|
assert(FD->getReturnType()->isUndeducedType());
|
2013-05-04 15:00:32 +08:00
|
|
|
|
|
|
|
if (FD->getTemplateInstantiationPattern())
|
|
|
|
InstantiateFunctionDefinition(Loc, FD);
|
|
|
|
|
2014-01-26 00:55:45 +08:00
|
|
|
bool StillUndeduced = FD->getReturnType()->isUndeducedType();
|
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;
|
|
|
|
}
|
|
|
|
|
2009-09-15 02:39:43 +08:00
|
|
|
static void
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(ASTContext &Ctx, QualType T,
|
2009-09-15 05:25:05 +08:00
|
|
|
bool OnlyDeduced,
|
2009-10-29 08:04:11 +08:00
|
|
|
unsigned Level,
|
2012-01-31 00:17:39 +08:00
|
|
|
llvm::SmallBitVector &Deduced);
|
2011-01-27 15:10:08 +08:00
|
|
|
|
|
|
|
/// \brief If this is a non-static member function,
|
2013-07-08 12:13:06 +08:00
|
|
|
static void
|
|
|
|
AddImplicitObjectParameterType(ASTContext &Context,
|
|
|
|
CXXMethodDecl *Method,
|
|
|
|
SmallVectorImpl<QualType> &ArgTypes) {
|
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.
|
2010-11-13 07:44:13 +08:00
|
|
|
//
|
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.
|
2010-11-13 07:44:13 +08:00
|
|
|
QualType ArgTy = Context.getTypeDeclType(Method->getParent());
|
|
|
|
ArgTy = Context.getQualifiedType(ArgTy,
|
|
|
|
Qualifiers::fromCVRMask(Method->getTypeQualifiers()));
|
2012-09-20 07:52:13 +08:00
|
|
|
if (Method->getRefQualifier() == RQ_RValue)
|
|
|
|
ArgTy = Context.getRValueReferenceType(ArgTy);
|
|
|
|
else
|
|
|
|
ArgTy = Context.getLValueReferenceType(ArgTy);
|
2010-11-13 07:44:13 +08:00
|
|
|
ArgTypes.push_back(ArgTy);
|
|
|
|
}
|
|
|
|
|
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,
|
2010-02-09 07:07:23 +08:00
|
|
|
SourceLocation Loc,
|
2009-09-15 02:39:43 +08:00
|
|
|
FunctionTemplateDecl *FT1,
|
|
|
|
FunctionTemplateDecl *FT2,
|
|
|
|
TemplatePartialOrderingContext TPOC,
|
2015-02-20 12:45:22 +08:00
|
|
|
unsigned NumCallArguments1) {
|
2009-09-15 02:39:43 +08:00
|
|
|
FunctionDecl *FD1 = FT1->getTemplatedDecl();
|
2011-01-27 15:10:08 +08:00
|
|
|
FunctionDecl *FD2 = FT2->getTemplatedDecl();
|
2009-09-15 02:39:43 +08:00
|
|
|
const FunctionProtoType *Proto1 = FD1->getType()->getAs<FunctionProtoType>();
|
|
|
|
const FunctionProtoType *Proto2 = FD2->getType()->getAs<FunctionProtoType>();
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-09-15 02:39:43 +08:00
|
|
|
assert(Proto1 && Proto2 && "Function templates must have prototypes");
|
|
|
|
TemplateParameterList *TemplateParams = FT2->getTemplateParameters();
|
2011-07-23 18:55:15 +08:00
|
|
|
SmallVector<DeducedTemplateArgument, 4> Deduced;
|
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:
|
2012-09-19 10:26:47 +08:00
|
|
|
TemplateDeductionInfo Info(Loc);
|
2013-09-11 08:52:39 +08:00
|
|
|
SmallVector<QualType, 4> Args2;
|
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.
|
2013-09-11 08:52:39 +08:00
|
|
|
CXXMethodDecl *Method1 = dyn_cast<CXXMethodDecl>(FD1);
|
|
|
|
CXXMethodDecl *Method2 = dyn_cast<CXXMethodDecl>(FD2);
|
2010-11-15 23:41:16 +08:00
|
|
|
|
2012-09-20 07:27:04 +08:00
|
|
|
// C++11 [temp.func.order]p3:
|
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.
|
|
|
|
//
|
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.
|
|
|
|
//
|
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.
|
2011-07-23 18:55:15 +08:00
|
|
|
SmallVector<QualType, 4> Args1;
|
2013-09-11 08:52:39 +08:00
|
|
|
|
|
|
|
unsigned NumComparedArguments = NumCallArguments1;
|
|
|
|
|
|
|
|
if (!Method2 && Method1 && !Method1->isStatic()) {
|
2014-05-31 10:10:59 +08:00
|
|
|
// Compare 'this' from Method1 against first parameter from Method2.
|
|
|
|
AddImplicitObjectParameterType(S.Context, Method1, Args1);
|
|
|
|
++NumComparedArguments;
|
2013-09-11 08:52:39 +08:00
|
|
|
} else if (!Method1 && Method2 && !Method2->isStatic()) {
|
2014-05-31 10:10:59 +08:00
|
|
|
// Compare 'this' from Method2 against first parameter from Method1.
|
|
|
|
AddImplicitObjectParameterType(S.Context, Method2, Args2);
|
2013-09-11 08:52:39 +08:00
|
|
|
}
|
|
|
|
|
2014-05-31 10:10:59 +08:00
|
|
|
Args1.insert(Args1.end(), Proto1->param_type_begin(),
|
2014-01-21 04:26:09 +08:00
|
|
|
Proto1->param_type_end());
|
2014-05-31 10:10:59 +08:00
|
|
|
Args2.insert(Args2.end(), Proto2->param_type_begin(),
|
2014-01-21 04:26:09 +08:00
|
|
|
Proto2->param_type_end());
|
2011-01-27 15:10:08 +08:00
|
|
|
|
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.
|
2013-09-11 08:52:39 +08:00
|
|
|
if (Args1.size() > NumComparedArguments)
|
|
|
|
Args1.resize(NumComparedArguments);
|
|
|
|
if (Args2.size() > NumComparedArguments)
|
|
|
|
Args2.resize(NumComparedArguments);
|
2011-01-12 01:34:58 +08:00
|
|
|
if (DeduceTemplateArguments(S, TemplateParams, Args2.data(), Args2.size(),
|
|
|
|
Args1.data(), Args1.size(), Info, Deduced,
|
2015-02-20 12:45:22 +08:00
|
|
|
TDF_None, /*PartialOrdering=*/true))
|
2014-05-29 09:12:14 +08:00
|
|
|
return false;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-09-15 02:39:43 +08:00
|
|
|
break;
|
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
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.
|
2014-01-26 00:55:45 +08:00
|
|
|
if (DeduceTemplateArgumentsByTypeMatch(
|
|
|
|
S, TemplateParams, Proto2->getReturnType(), Proto1->getReturnType(),
|
|
|
|
Info, Deduced, TDF_None,
|
2015-02-20 12:45:22 +08:00
|
|
|
/*PartialOrdering=*/true))
|
2009-09-15 02:39:43 +08:00
|
|
|
return false;
|
|
|
|
break;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-09-15 02:39:43 +08:00
|
|
|
case TPOC_Other:
|
2011-01-27 15:09:49 +08:00
|
|
|
// - In other contexts (14.6.6.2) the function template's function type
|
2009-09-15 02:39:43 +08:00
|
|
|
// is used.
|
2012-01-18 06:49:52 +08:00
|
|
|
if (DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
|
|
|
|
FD2->getType(), FD1->getType(),
|
|
|
|
Info, Deduced, TDF_None,
|
2015-02-20 12:45:22 +08:00
|
|
|
/*PartialOrdering=*/true))
|
2009-09-15 02:39:43 +08:00
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-09-15 02:39:43 +08:00
|
|
|
// C++0x [temp.deduct.partial]p11:
|
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
|
2009-09-15 02:39:43 +08:00
|
|
|
// types being used for partial ordering. [ Note: a template parameter used
|
|
|
|
// in a non-deduced context is considered used. -end note]
|
|
|
|
unsigned ArgIdx = 0, NumArgs = Deduced.size();
|
|
|
|
for (; ArgIdx != NumArgs; ++ArgIdx)
|
|
|
|
if (Deduced[ArgIdx].isNull())
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (ArgIdx == NumArgs) {
|
2011-01-27 15:10:08 +08:00
|
|
|
// All template arguments were deduced. FT1 is at least as specialized
|
2009-09-15 02:39:43 +08:00
|
|
|
// as FT2.
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2009-09-15 05:25:05 +08:00
|
|
|
// Figure out which template parameters were used.
|
2012-01-31 00:17:39 +08:00
|
|
|
llvm::SmallBitVector UsedParameters(TemplateParams->size());
|
2009-09-15 02:39:43 +08:00
|
|
|
switch (TPOC) {
|
2013-09-11 08:52:39 +08:00
|
|
|
case TPOC_Call:
|
|
|
|
for (unsigned I = 0, N = Args2.size(); I != N; ++I)
|
|
|
|
::MarkUsedTemplateParameters(S.Context, Args2[I], false,
|
2009-10-29 08:04:11 +08:00
|
|
|
TemplateParams->getDepth(),
|
2009-09-15 05:25:05 +08:00
|
|
|
UsedParameters);
|
2009-09-15 02:39:43 +08:00
|
|
|
break;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-09-15 02:39:43 +08:00
|
|
|
case TPOC_Conversion:
|
2014-01-26 00:55:45 +08:00
|
|
|
::MarkUsedTemplateParameters(S.Context, Proto2->getReturnType(), false,
|
|
|
|
TemplateParams->getDepth(), UsedParameters);
|
2009-09-15 02:39:43 +08:00
|
|
|
break;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-09-15 02:39:43 +08:00
|
|
|
case TPOC_Other:
|
2012-01-17 10:15:41 +08:00
|
|
|
::MarkUsedTemplateParameters(S.Context, FD2->getType(), false,
|
2009-10-29 08:04:11 +08:00
|
|
|
TemplateParams->getDepth(),
|
|
|
|
UsedParameters);
|
2009-09-15 02:39:43 +08:00
|
|
|
break;
|
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-09-15 02:39:43 +08:00
|
|
|
for (; ArgIdx != NumArgs; ++ArgIdx)
|
|
|
|
// If this argument had no value deduced but was used in one of the types
|
|
|
|
// used for partial ordering, then deduction fails.
|
|
|
|
if (Deduced[ArgIdx].isNull() && UsedParameters[ArgIdx])
|
|
|
|
return false;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-09-15 02:39:43 +08:00
|
|
|
return true;
|
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
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;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-17 00:03:23 +08:00
|
|
|
ParmVarDecl *Last = Function->getParamDecl(NumParams - 1);
|
|
|
|
if (!Last->isParameterPack())
|
|
|
|
return false;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
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;
|
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2011-01-17 00:03:23 +08:00
|
|
|
return true;
|
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-09-16 00:23:51 +08:00
|
|
|
/// \brief Returns the more specialized function template according
|
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
|
|
|
|
///
|
2009-09-15 02:39:43 +08:00
|
|
|
/// \param TPOC the context in which we are performing partial ordering of
|
|
|
|
/// function templates.
|
2009-09-09 23:08:12 +08:00
|
|
|
///
|
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.
|
2011-01-12 01:34:58 +08:00
|
|
|
///
|
2009-09-16 00:23:51 +08:00
|
|
|
/// \returns the more specialized function template. If neither
|
2009-08-22 07:19:43 +08:00
|
|
|
/// template is more specialized, returns NULL.
|
|
|
|
FunctionTemplateDecl *
|
|
|
|
Sema::getMoreSpecializedTemplate(FunctionTemplateDecl *FT1,
|
|
|
|
FunctionTemplateDecl *FT2,
|
2010-02-09 07:07:23 +08:00
|
|
|
SourceLocation Loc,
|
2011-01-12 01:34:58 +08:00
|
|
|
TemplatePartialOrderingContext TPOC,
|
2013-09-11 08:52:39 +08:00
|
|
|
unsigned NumCallArguments1,
|
|
|
|
unsigned NumCallArguments2) {
|
2011-01-27 15:10:08 +08:00
|
|
|
bool Better1 = isAtLeastAsSpecializedAs(*this, Loc, FT1, FT2, TPOC,
|
2015-02-20 12:45:22 +08:00
|
|
|
NumCallArguments1);
|
2011-01-27 15:10:08 +08:00
|
|
|
bool Better2 = isAtLeastAsSpecializedAs(*this, Loc, FT2, FT1, TPOC,
|
2015-02-20 12:45:22 +08:00
|
|
|
NumCallArguments2);
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-09-15 02:39:43 +08:00
|
|
|
if (Better1 != Better2) // We have a clear winner
|
2015-02-20 12:45:22 +08:00
|
|
|
return Better1 ? FT1 : FT2;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-09-15 02:39:43 +08:00
|
|
|
if (!Better1 && !Better2) // Neither is better than the other
|
2014-05-26 14:22:03 +08:00
|
|
|
return nullptr;
|
2009-09-15 02:39:43 +08:00
|
|
|
|
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;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2014-05-26 14:22:03 +08:00
|
|
|
return nullptr;
|
2009-08-22 07:19:43 +08:00
|
|
|
}
|
2009-07-09 04:55:45 +08:00
|
|
|
|
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;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-09-26 02:43:00 +08:00
|
|
|
if (!T1 || !T2)
|
|
|
|
return false;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-09-26 02:43:00 +08:00
|
|
|
return T1->getCanonicalDecl() == T2->getCanonicalDecl();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief Retrieve the most specialized of the given function template
|
|
|
|
/// specializations.
|
|
|
|
///
|
2010-01-27 09:50:18 +08:00
|
|
|
/// \param SpecBegin the start iterator of the function template
|
|
|
|
/// specializations that we will be comparing.
|
2009-09-26 02:43:00 +08:00
|
|
|
///
|
2010-01-27 09:50:18 +08:00
|
|
|
/// \param SpecEnd the end iterator of the function template
|
|
|
|
/// specializations, paired with \p SpecBegin.
|
2009-09-26 02:43:00 +08:00
|
|
|
///
|
2011-01-27 15:10:08 +08:00
|
|
|
/// \param Loc the location where the ambiguity or no-specializations
|
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.
|
|
|
|
///
|
2011-01-27 15:10:08 +08:00
|
|
|
/// \returns the most specialized function template specialization, if
|
2010-01-27 09:50:18 +08:00
|
|
|
/// found. Otherwise, returns SpecEnd.
|
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) {
|
2010-01-27 09:50:18 +08:00
|
|
|
if (SpecBegin == SpecEnd) {
|
2013-07-20 07:00:19 +08:00
|
|
|
if (Complain) {
|
2011-02-20 05:32:49 +08:00
|
|
|
Diag(Loc, NoneDiag);
|
2013-07-20 07:00:19 +08:00
|
|
|
FailedCandidates.NoteCandidates(*this, Loc);
|
|
|
|
}
|
2010-01-27 09:50:18 +08:00
|
|
|
return SpecEnd;
|
2009-09-26 02:43:00 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
|
|
|
if (SpecBegin + 1 == SpecEnd)
|
2010-01-27 09:50:18 +08:00
|
|
|
return SpecBegin;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
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.
|
2010-01-27 09:50:18 +08:00
|
|
|
UnresolvedSetIterator Best = SpecBegin;
|
2011-01-27 15:10:08 +08:00
|
|
|
FunctionTemplateDecl *BestTemplate
|
2010-01-27 09:50:18 +08:00
|
|
|
= cast<FunctionDecl>(*Best)->getPrimaryTemplate();
|
2009-09-26 02:43:00 +08:00
|
|
|
assert(BestTemplate && "Not a function template specialization?");
|
2010-01-27 09:50:18 +08:00
|
|
|
for (UnresolvedSetIterator I = SpecBegin + 1; I != SpecEnd; ++I) {
|
|
|
|
FunctionTemplateDecl *Challenger
|
|
|
|
= cast<FunctionDecl>(*I)->getPrimaryTemplate();
|
2009-09-26 02:43:00 +08:00
|
|
|
assert(Challenger && "Not a function template specialization?");
|
2010-01-27 09:50:18 +08:00
|
|
|
if (isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger,
|
2013-09-11 08:52:39 +08:00
|
|
|
Loc, TPOC_Other, 0, 0),
|
2009-09-26 02:43:00 +08:00
|
|
|
Challenger)) {
|
|
|
|
Best = I;
|
|
|
|
BestTemplate = Challenger;
|
|
|
|
}
|
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
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;
|
2010-01-27 09:50:18 +08:00
|
|
|
for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) {
|
|
|
|
FunctionTemplateDecl *Challenger
|
|
|
|
= cast<FunctionDecl>(*I)->getPrimaryTemplate();
|
2009-09-26 02:43:00 +08:00
|
|
|
if (I != Best &&
|
2011-01-27 15:10:08 +08:00
|
|
|
!isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger,
|
2013-09-11 08:52:39 +08:00
|
|
|
Loc, TPOC_Other, 0, 0),
|
2009-09-26 02:43:00 +08:00
|
|
|
BestTemplate)) {
|
|
|
|
Ambiguous = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-09-26 02:43:00 +08:00
|
|
|
if (!Ambiguous) {
|
|
|
|
// We found an answer. Return it.
|
2010-01-27 09:50:18 +08:00
|
|
|
return Best;
|
2009-09-26 02:43:00 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-09-26 02:43:00 +08:00
|
|
|
// Diagnose the ambiguity.
|
2013-05-04 09:51:08 +08:00
|
|
|
if (Complain) {
|
2011-02-20 05:32:49 +08:00
|
|
|
Diag(Loc, AmbigDiag);
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2013-05-04 09:51:08 +08:00
|
|
|
// FIXME: Can we order the candidates in some sane way?
|
2011-11-24 06:32:32 +08:00
|
|
|
for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) {
|
|
|
|
PartialDiagnostic PD = CandidateDiag;
|
|
|
|
PD << getTemplateArgumentBindingsText(
|
2011-02-20 05:32:49 +08:00
|
|
|
cast<FunctionDecl>(*I)->getPrimaryTemplate()->getTemplateParameters(),
|
2010-01-27 09:50:18 +08:00
|
|
|
*cast<FunctionDecl>(*I)->getTemplateSpecializationArgs());
|
2011-11-24 06:32:32 +08:00
|
|
|
if (!TargetType.isNull())
|
|
|
|
HandleFunctionTypeMismatch(PD, cast<FunctionDecl>(*I)->getType(),
|
|
|
|
TargetType);
|
|
|
|
Diag((*I)->getLocation(), PD);
|
|
|
|
}
|
2013-05-04 09:51:08 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-01-27 09:50:18 +08:00
|
|
|
return SpecEnd;
|
2009-09-26 02:43:00 +08:00
|
|
|
}
|
|
|
|
|
2009-09-16 00:23:51 +08:00
|
|
|
/// \brief Returns the more specialized class template partial specialization
|
|
|
|
/// according to the rules of partial ordering of class template partial
|
|
|
|
/// specializations (C++ [temp.class.order]).
|
|
|
|
///
|
|
|
|
/// \param PS1 the first class template partial specialization
|
|
|
|
///
|
|
|
|
/// \param PS2 the second class template partial specialization
|
|
|
|
///
|
|
|
|
/// \returns the more specialized class template partial specialization. If
|
|
|
|
/// neither partial specialization is more specialized, returns NULL.
|
|
|
|
ClassTemplatePartialSpecializationDecl *
|
|
|
|
Sema::getMoreSpecializedPartialSpecialization(
|
|
|
|
ClassTemplatePartialSpecializationDecl *PS1,
|
2010-02-09 07:07:23 +08:00
|
|
|
ClassTemplatePartialSpecializationDecl *PS2,
|
|
|
|
SourceLocation Loc) {
|
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
|
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
|
2009-09-16 00:23:51 +08:00
|
|
|
// templates (14.6.6.2):
|
|
|
|
// - the first function template has the same template parameters as the
|
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
|
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
|
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
|
2009-09-16 00:23:51 +08:00
|
|
|
// arguments of the second partial specialization.
|
|
|
|
//
|
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.
|
2011-07-23 18:55:15 +08:00
|
|
|
SmallVector<DeducedTemplateArgument, 4> Deduced;
|
2012-09-19 10:26:47 +08:00
|
|
|
TemplateDeductionInfo Info(Loc);
|
2010-04-27 08:57:59 +08:00
|
|
|
|
|
|
|
QualType PT1 = PS1->getInjectedSpecializationType();
|
|
|
|
QualType PT2 = PS2->getInjectedSpecializationType();
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-09-16 00:23:51 +08:00
|
|
|
// Determine whether PS1 is at least as specialized as PS2
|
|
|
|
Deduced.resize(PS2->getTemplateParameters()->size());
|
2012-01-18 06:49:52 +08:00
|
|
|
bool Better1 = !DeduceTemplateArgumentsByTypeMatch(*this,
|
|
|
|
PS2->getTemplateParameters(),
|
2011-01-12 01:34:58 +08:00
|
|
|
PT2, PT1, Info, Deduced, TDF_None,
|
2015-02-20 12:45:22 +08:00
|
|
|
/*PartialOrdering=*/true);
|
2010-11-06 07:25:18 +08:00
|
|
|
if (Better1) {
|
2012-07-16 09:09:10 +08:00
|
|
|
SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),Deduced.end());
|
2014-01-11 10:37:12 +08:00
|
|
|
InstantiatingTemplate Inst(*this, Loc, PS2, DeducedArgs, Info);
|
2013-08-06 09:03:05 +08:00
|
|
|
Better1 = !::FinishTemplateArgumentDeduction(
|
|
|
|
*this, PS2, PS1->getTemplateArgs(), Deduced, Info);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Determine whether PS2 is at least as specialized as PS1
|
|
|
|
Deduced.clear();
|
|
|
|
Deduced.resize(PS1->getTemplateParameters()->size());
|
|
|
|
bool Better2 = !DeduceTemplateArgumentsByTypeMatch(
|
|
|
|
*this, PS1->getTemplateParameters(), PT1, PT2, Info, Deduced, TDF_None,
|
2015-02-20 12:45:22 +08:00
|
|
|
/*PartialOrdering=*/true);
|
2013-08-06 09:03:05 +08:00
|
|
|
if (Better2) {
|
|
|
|
SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),
|
|
|
|
Deduced.end());
|
2014-01-11 10:37:12 +08:00
|
|
|
InstantiatingTemplate Inst(*this, Loc, PS1, DeducedArgs, Info);
|
2013-08-06 09:03:05 +08:00
|
|
|
Better2 = !::FinishTemplateArgumentDeduction(
|
|
|
|
*this, PS1, PS2->getTemplateArgs(), Deduced, Info);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Better1 == Better2)
|
2014-05-26 14:22:03 +08:00
|
|
|
return nullptr;
|
2013-08-06 09:03:05 +08:00
|
|
|
|
|
|
|
return Better1 ? PS1 : PS2;
|
|
|
|
}
|
|
|
|
|
2013-08-24 06:21:36 +08:00
|
|
|
/// TODO: Unify with ClassTemplatePartialSpecializationDecl version?
|
|
|
|
/// May require unifying ClassTemplate(Partial)SpecializationDecl and
|
|
|
|
/// VarTemplate(Partial)SpecializationDecl with a new data
|
|
|
|
/// structure Template(Partial)SpecializationDecl, and
|
|
|
|
/// using Template(Partial)SpecializationDecl as input type.
|
2013-08-06 09:03:05 +08:00
|
|
|
VarTemplatePartialSpecializationDecl *
|
|
|
|
Sema::getMoreSpecializedPartialSpecialization(
|
|
|
|
VarTemplatePartialSpecializationDecl *PS1,
|
|
|
|
VarTemplatePartialSpecializationDecl *PS2, SourceLocation Loc) {
|
|
|
|
SmallVector<DeducedTemplateArgument, 4> Deduced;
|
|
|
|
TemplateDeductionInfo Info(Loc);
|
|
|
|
|
2013-12-13 07:14:16 +08:00
|
|
|
assert(PS1->getSpecializedTemplate() == PS2->getSpecializedTemplate() &&
|
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(
|
2016-07-07 12:43:07 +08:00
|
|
|
CanonTemplate, PS1->getTemplateArgs().asArray());
|
2013-08-06 09:03:05 +08:00
|
|
|
QualType PT2 = Context.getTemplateSpecializationType(
|
2016-07-07 12:43:07 +08:00
|
|
|
CanonTemplate, PS2->getTemplateArgs().asArray());
|
2013-08-06 09:03:05 +08:00
|
|
|
|
|
|
|
// Determine whether PS1 is at least as specialized as PS2
|
|
|
|
Deduced.resize(PS2->getTemplateParameters()->size());
|
|
|
|
bool Better1 = !DeduceTemplateArgumentsByTypeMatch(
|
|
|
|
*this, PS2->getTemplateParameters(), PT2, PT1, Info, Deduced, TDF_None,
|
2015-02-20 12:45:22 +08:00
|
|
|
/*PartialOrdering=*/true);
|
2013-08-06 09:03:05 +08:00
|
|
|
if (Better1) {
|
|
|
|
SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),
|
|
|
|
Deduced.end());
|
2014-01-11 10:37:12 +08:00
|
|
|
InstantiatingTemplate Inst(*this, Loc, PS2, DeducedArgs, Info);
|
2011-01-27 15:10:08 +08:00
|
|
|
Better1 = !::FinishTemplateArgumentDeduction(*this, PS2,
|
|
|
|
PS1->getTemplateArgs(),
|
2010-04-29 14:31:36 +08:00
|
|
|
Deduced, Info);
|
2010-11-06 07:25:18 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-09-16 00:23:51 +08:00
|
|
|
// Determine whether PS2 is at least as specialized as PS1
|
2009-11-12 07:06:43 +08:00
|
|
|
Deduced.clear();
|
2009-09-16 00:23:51 +08:00
|
|
|
Deduced.resize(PS1->getTemplateParameters()->size());
|
2012-01-18 06:49:52 +08:00
|
|
|
bool Better2 = !DeduceTemplateArgumentsByTypeMatch(*this,
|
|
|
|
PS1->getTemplateParameters(),
|
2011-01-12 01:34:58 +08:00
|
|
|
PT1, PT2, Info, Deduced, TDF_None,
|
2015-02-20 12:45:22 +08:00
|
|
|
/*PartialOrdering=*/true);
|
2010-11-06 07:25:18 +08:00
|
|
|
if (Better2) {
|
2012-07-16 09:09:10 +08:00
|
|
|
SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),Deduced.end());
|
2014-01-11 10:37:12 +08:00
|
|
|
InstantiatingTemplate Inst(*this, Loc, PS1, DeducedArgs, Info);
|
2011-01-27 15:10:08 +08:00
|
|
|
Better2 = !::FinishTemplateArgumentDeduction(*this, PS1,
|
|
|
|
PS2->getTemplateArgs(),
|
2010-04-29 14:31:36 +08:00
|
|
|
Deduced, Info);
|
2010-11-06 07:25:18 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-09-16 00:23:51 +08:00
|
|
|
if (Better1 == Better2)
|
2014-05-26 14:22:03 +08:00
|
|
|
return nullptr;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-09-16 00:23:51 +08:00
|
|
|
return Better1? PS1 : PS2;
|
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
static void
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(ASTContext &Ctx,
|
2009-09-15 05:25:05 +08:00
|
|
|
const TemplateArgument &TemplateArg,
|
|
|
|
bool OnlyDeduced,
|
2009-10-29 08:04:11 +08:00
|
|
|
unsigned Depth,
|
2012-01-31 00:17:39 +08:00
|
|
|
llvm::SmallBitVector &Used);
|
2009-06-13 08:26:55 +08:00
|
|
|
|
2009-09-15 05:25:05 +08:00
|
|
|
/// \brief Mark the template parameters that are used by the given
|
2009-06-13 08:26:55 +08:00
|
|
|
/// expression.
|
2009-09-09 23:08:12 +08:00
|
|
|
static void
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(ASTContext &Ctx,
|
2009-09-15 05:25:05 +08:00
|
|
|
const Expr *E,
|
|
|
|
bool OnlyDeduced,
|
2009-10-29 08:04:11 +08:00
|
|
|
unsigned Depth,
|
2012-01-31 00:17:39 +08:00
|
|
|
llvm::SmallBitVector &Used) {
|
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();
|
2011-01-27 15:10:08 +08:00
|
|
|
|
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;
|
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
|
|
|
// FIXME: if !OnlyDeduced, we have to walk the whole subexpression to
|
2009-09-15 05:25:05 +08:00
|
|
|
// find other occurrences of template parameters.
|
2009-06-19 02:45:36 +08:00
|
|
|
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E);
|
2010-01-15 02:13:22 +08:00
|
|
|
if (!DRE)
|
2009-06-13 08:26:55 +08:00
|
|
|
return;
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
const NonTypeTemplateParmDecl *NTTP
|
2009-06-13 08:26:55 +08:00
|
|
|
= dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl());
|
|
|
|
if (!NTTP)
|
|
|
|
return;
|
|
|
|
|
2009-10-29 08:04:11 +08:00
|
|
|
if (NTTP->getDepth() == Depth)
|
|
|
|
Used[NTTP->getIndex()] = true;
|
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);
|
2009-06-13 08:26:55 +08:00
|
|
|
}
|
|
|
|
|
2009-09-15 05:25:05 +08:00
|
|
|
/// \brief Mark the template parameters that are used by the given
|
|
|
|
/// nested name specifier.
|
|
|
|
static void
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(ASTContext &Ctx,
|
2009-09-15 05:25:05 +08:00
|
|
|
NestedNameSpecifier *NNS,
|
|
|
|
bool OnlyDeduced,
|
2009-10-29 08:04:11 +08:00
|
|
|
unsigned Depth,
|
2012-01-31 00:17:39 +08:00
|
|
|
llvm::SmallBitVector &Used) {
|
2009-09-15 05:25:05 +08:00
|
|
|
if (!NNS)
|
|
|
|
return;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx, NNS->getPrefix(), OnlyDeduced, Depth,
|
2009-10-29 08:04:11 +08:00
|
|
|
Used);
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx, QualType(NNS->getAsType(), 0),
|
2009-10-29 08:04:11 +08:00
|
|
|
OnlyDeduced, Depth, Used);
|
2009-09-15 05:25:05 +08:00
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-09-15 05:25:05 +08:00
|
|
|
/// \brief Mark the template parameters that are used by the given
|
|
|
|
/// template name.
|
|
|
|
static void
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(ASTContext &Ctx,
|
2009-09-15 05:25:05 +08:00
|
|
|
TemplateName Name,
|
|
|
|
bool OnlyDeduced,
|
2009-10-29 08:04:11 +08:00
|
|
|
unsigned Depth,
|
2012-01-31 00:17:39 +08:00
|
|
|
llvm::SmallBitVector &Used) {
|
2009-09-15 05:25:05 +08:00
|
|
|
if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
|
|
|
|
if (TemplateTemplateParmDecl *TTP
|
2009-10-29 08:04:11 +08:00
|
|
|
= dyn_cast<TemplateTemplateParmDecl>(Template)) {
|
|
|
|
if (TTP->getDepth() == Depth)
|
|
|
|
Used[TTP->getIndex()] = true;
|
|
|
|
}
|
2009-09-15 05:25:05 +08:00
|
|
|
return;
|
|
|
|
}
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-11-11 09:00:40 +08:00
|
|
|
if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName())
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx, QTN->getQualifier(), OnlyDeduced,
|
2009-11-11 09:00:40 +08:00
|
|
|
Depth, Used);
|
2009-09-15 05:25:05 +08:00
|
|
|
if (DependentTemplateName *DTN = Name.getAsDependentTemplateName())
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx, DTN->getQualifier(), OnlyDeduced,
|
2009-10-29 08:04:11 +08:00
|
|
|
Depth, Used);
|
2009-09-15 05:25:05 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief Mark the template parameters that are used by the given
|
2009-06-13 08:26:55 +08:00
|
|
|
/// type.
|
2009-09-09 23:08:12 +08:00
|
|
|
static void
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(ASTContext &Ctx, QualType T,
|
2009-09-15 05:25:05 +08:00
|
|
|
bool OnlyDeduced,
|
2009-10-29 08:04:11 +08:00
|
|
|
unsigned Depth,
|
2012-01-31 00:17:39 +08:00
|
|
|
llvm::SmallBitVector &Used) {
|
2009-09-15 05:25:05 +08:00
|
|
|
if (T.isNull())
|
|
|
|
return;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-06-13 08:26:55 +08:00
|
|
|
// Non-dependent types have nothing deducible
|
|
|
|
if (!T->isDependentType())
|
|
|
|
return;
|
|
|
|
|
2012-01-17 10:15:41 +08:00
|
|
|
T = Ctx.getCanonicalType(T);
|
2009-06-13 08:26:55 +08:00
|
|
|
switch (T->getTypeClass()) {
|
|
|
|
case Type::Pointer:
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx,
|
2009-09-15 05:25:05 +08:00
|
|
|
cast<PointerType>(T)->getPointeeType(),
|
|
|
|
OnlyDeduced,
|
2009-10-29 08:04:11 +08:00
|
|
|
Depth,
|
2009-09-15 05:25:05 +08:00
|
|
|
Used);
|
2009-06-13 08:26:55 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case Type::BlockPointer:
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx,
|
2009-09-15 05:25:05 +08:00
|
|
|
cast<BlockPointerType>(T)->getPointeeType(),
|
|
|
|
OnlyDeduced,
|
2009-10-29 08:04:11 +08:00
|
|
|
Depth,
|
2009-09-15 05:25:05 +08:00
|
|
|
Used);
|
2009-06-13 08:26:55 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case Type::LValueReference:
|
|
|
|
case Type::RValueReference:
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx,
|
2009-09-15 05:25:05 +08:00
|
|
|
cast<ReferenceType>(T)->getPointeeType(),
|
|
|
|
OnlyDeduced,
|
2009-10-29 08:04:11 +08:00
|
|
|
Depth,
|
2009-09-15 05:25:05 +08:00
|
|
|
Used);
|
2009-06-13 08:26:55 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case Type::MemberPointer: {
|
|
|
|
const MemberPointerType *MemPtr = cast<MemberPointerType>(T.getTypePtr());
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx, MemPtr->getPointeeType(), OnlyDeduced,
|
2009-10-29 08:04:11 +08:00
|
|
|
Depth, Used);
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx, QualType(MemPtr->getClass(), 0),
|
2009-10-29 08:04:11 +08:00
|
|
|
OnlyDeduced, Depth, Used);
|
2009-06-13 08:26:55 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case Type::DependentSizedArray:
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx,
|
2009-09-15 05:25:05 +08:00
|
|
|
cast<DependentSizedArrayType>(T)->getSizeExpr(),
|
2009-10-29 08:04:11 +08:00
|
|
|
OnlyDeduced, Depth, Used);
|
2009-06-13 08:26:55 +08:00
|
|
|
// Fall through to check the element type
|
|
|
|
|
|
|
|
case Type::ConstantArray:
|
|
|
|
case Type::IncompleteArray:
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx,
|
2009-09-15 05:25:05 +08:00
|
|
|
cast<ArrayType>(T)->getElementType(),
|
2009-10-29 08:04:11 +08:00
|
|
|
OnlyDeduced, Depth, Used);
|
2009-06-13 08:26:55 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case Type::Vector:
|
|
|
|
case Type::ExtVector:
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx,
|
2009-09-15 05:25:05 +08:00
|
|
|
cast<VectorType>(T)->getElementType(),
|
2009-10-29 08:04:11 +08:00
|
|
|
OnlyDeduced, Depth, Used);
|
2009-06-13 08:26:55 +08:00
|
|
|
break;
|
|
|
|
|
2009-06-18 05:51:59 +08:00
|
|
|
case Type::DependentSizedExtVector: {
|
|
|
|
const DependentSizedExtVectorType *VecType
|
2009-06-19 02:45:36 +08:00
|
|
|
= cast<DependentSizedExtVectorType>(T);
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx, VecType->getElementType(), OnlyDeduced,
|
2009-10-29 08:04:11 +08:00
|
|
|
Depth, Used);
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx, VecType->getSizeExpr(), OnlyDeduced,
|
2009-10-29 08:04:11 +08:00
|
|
|
Depth, Used);
|
2009-06-18 05:51:59 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-06-13 08:26:55 +08:00
|
|
|
case Type::FunctionProto: {
|
2009-06-19 02:45:36 +08:00
|
|
|
const FunctionProtoType *Proto = cast<FunctionProtoType>(T);
|
2014-01-26 00:55:45 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx, Proto->getReturnType(), OnlyDeduced, Depth,
|
|
|
|
Used);
|
2014-01-21 04:26:09 +08:00
|
|
|
for (unsigned I = 0, N = Proto->getNumParams(); I != N; ++I)
|
|
|
|
MarkUsedTemplateParameters(Ctx, Proto->getParamType(I), OnlyDeduced,
|
2009-10-29 08:04:11 +08:00
|
|
|
Depth, Used);
|
2009-06-13 08:26:55 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
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;
|
2009-06-13 08:26:55 +08:00
|
|
|
break;
|
2009-10-29 08:04:11 +08:00
|
|
|
}
|
2009-06-13 08:26:55 +08:00
|
|
|
|
2011-01-14 13:11:40 +08:00
|
|
|
case Type::SubstTemplateTypeParmPack: {
|
|
|
|
const SubstTemplateTypeParmPackType *Subst
|
|
|
|
= cast<SubstTemplateTypeParmPackType>(T);
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx,
|
2011-01-14 13:11:40 +08:00
|
|
|
QualType(Subst->getReplacedParameter(), 0),
|
|
|
|
OnlyDeduced, Depth, Used);
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx, Subst->getArgumentPack(),
|
2011-01-14 13:11:40 +08:00
|
|
|
OnlyDeduced, Depth, Used);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-04-27 08:57:59 +08:00
|
|
|
case Type::InjectedClassName:
|
|
|
|
T = cast<InjectedClassNameType>(T)->getInjectedSpecializationType();
|
|
|
|
// fall through
|
|
|
|
|
2009-06-13 08:26:55 +08:00
|
|
|
case Type::TemplateSpecialization: {
|
2009-09-09 23:08:12 +08:00
|
|
|
const TemplateSpecializationType *Spec
|
2009-06-19 02:45:36 +08:00
|
|
|
= cast<TemplateSpecializationType>(T);
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx, Spec->getTemplateName(), OnlyDeduced,
|
2009-10-29 08:04:11 +08:00
|
|
|
Depth, Used);
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2010-12-23 09:24:45 +08:00
|
|
|
// C++0x [temp.deduct.type]p9:
|
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
|
2010-12-23 09:24:45 +08:00
|
|
|
// non-deduced context.
|
2011-01-27 15:10:08 +08:00
|
|
|
if (OnlyDeduced &&
|
2010-12-23 09:24:45 +08:00
|
|
|
hasPackExpansionBeforeEnd(Spec->getArgs(), Spec->getNumArgs()))
|
|
|
|
break;
|
|
|
|
|
2009-09-15 05:25:05 +08:00
|
|
|
for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I)
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx, Spec->getArg(I), OnlyDeduced, Depth,
|
2009-10-29 08:04:11 +08:00
|
|
|
Used);
|
2009-09-15 05:25:05 +08:00
|
|
|
break;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-09-15 05:25:05 +08:00
|
|
|
case Type::Complex:
|
|
|
|
if (!OnlyDeduced)
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx,
|
2009-09-15 05:25:05 +08:00
|
|
|
cast<ComplexType>(T)->getElementType(),
|
2009-10-29 08:04:11 +08:00
|
|
|
OnlyDeduced, Depth, Used);
|
2009-09-15 05:25:05 +08:00
|
|
|
break;
|
2009-06-13 08:26:55 +08:00
|
|
|
|
2011-10-07 07:00:33 +08:00
|
|
|
case Type::Atomic:
|
|
|
|
if (!OnlyDeduced)
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx,
|
2011-10-07 07:00:33 +08:00
|
|
|
cast<AtomicType>(T)->getValueType(),
|
|
|
|
OnlyDeduced, Depth, Used);
|
|
|
|
break;
|
|
|
|
|
2010-04-01 01:34:00 +08:00
|
|
|
case Type::DependentName:
|
2009-09-15 05:25:05 +08:00
|
|
|
if (!OnlyDeduced)
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx,
|
2010-04-01 01:34:00 +08:00
|
|
|
cast<DependentNameType>(T)->getQualifier(),
|
2009-10-29 08:04:11 +08:00
|
|
|
OnlyDeduced, Depth, Used);
|
2009-06-13 08:26:55 +08:00
|
|
|
break;
|
|
|
|
|
2010-06-11 08:33:02 +08:00
|
|
|
case Type::DependentTemplateSpecialization: {
|
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;
|
|
|
|
|
2010-06-11 08:33:02 +08:00
|
|
|
const DependentTemplateSpecializationType *Spec
|
|
|
|
= cast<DependentTemplateSpecializationType>(T);
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2015-12-31 04:56:05 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx, Spec->getQualifier(),
|
|
|
|
OnlyDeduced, Depth, Used);
|
2010-12-23 09:24:45 +08:00
|
|
|
|
2010-06-11 08:33:02 +08:00
|
|
|
for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I)
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx, Spec->getArg(I), OnlyDeduced, Depth,
|
2010-06-11 08:33:02 +08:00
|
|
|
Used);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-03-02 07:49:17 +08:00
|
|
|
case Type::TypeOf:
|
|
|
|
if (!OnlyDeduced)
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx,
|
2010-03-02 07:49:17 +08:00
|
|
|
cast<TypeOfType>(T)->getUnderlyingType(),
|
|
|
|
OnlyDeduced, Depth, Used);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Type::TypeOfExpr:
|
|
|
|
if (!OnlyDeduced)
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx,
|
2010-03-02 07:49:17 +08:00
|
|
|
cast<TypeOfExprType>(T)->getUnderlyingExpr(),
|
|
|
|
OnlyDeduced, Depth, Used);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Type::Decltype:
|
|
|
|
if (!OnlyDeduced)
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx,
|
2010-03-02 07:49:17 +08:00
|
|
|
cast<DecltypeType>(T)->getUnderlyingExpr(),
|
|
|
|
OnlyDeduced, Depth, Used);
|
|
|
|
break;
|
2011-05-25 06:41:36 +08:00
|
|
|
|
|
|
|
case Type::UnaryTransform:
|
|
|
|
if (!OnlyDeduced)
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx,
|
2016-09-29 07:55:27 +08:00
|
|
|
cast<UnaryTransformType>(T)->getUnderlyingType(),
|
2011-05-25 06:41:36 +08:00
|
|
|
OnlyDeduced, Depth, Used);
|
|
|
|
break;
|
2010-03-02 07:49:17 +08:00
|
|
|
|
2010-12-20 10:24:11 +08:00
|
|
|
case Type::PackExpansion:
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx,
|
2010-12-20 10:24:11 +08:00
|
|
|
cast<PackExpansionType>(T)->getPattern(),
|
|
|
|
OnlyDeduced, Depth, Used);
|
|
|
|
break;
|
|
|
|
|
2011-02-20 11:19:35 +08:00
|
|
|
case Type::Auto:
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx,
|
2011-02-20 11:19:35 +08:00
|
|
|
cast<AutoType>(T)->getDeducedType(),
|
|
|
|
OnlyDeduced, Depth, Used);
|
|
|
|
|
2009-09-15 05:25:05 +08:00
|
|
|
// None of these types have any template parameters in them.
|
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:
|
2010-05-15 19:32:37 +08:00
|
|
|
case Type::ObjCObject:
|
2009-06-18 06:40:22 +08:00
|
|
|
case Type::ObjCObjectPointer:
|
2009-12-05 06:46:56 +08:00
|
|
|
case Type::UnresolvedUsing:
|
2016-01-09 20:53:17 +08:00
|
|
|
case Type::Pipe:
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-15 05:25:05 +08:00
|
|
|
/// \brief Mark the template parameters that are used by this
|
2009-06-13 08:26:55 +08:00
|
|
|
/// template argument.
|
2009-09-09 23:08:12 +08:00
|
|
|
static void
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(ASTContext &Ctx,
|
2009-09-15 05:25:05 +08:00
|
|
|
const TemplateArgument &TemplateArg,
|
|
|
|
bool OnlyDeduced,
|
2009-10-29 08:04:11 +08:00
|
|
|
unsigned Depth,
|
2012-01-31 00:17:39 +08:00
|
|
|
llvm::SmallBitVector &Used) {
|
2009-06-13 08:26:55 +08:00
|
|
|
switch (TemplateArg.getKind()) {
|
|
|
|
case TemplateArgument::Null:
|
|
|
|
case TemplateArgument::Integral:
|
2012-04-07 06:40:38 +08:00
|
|
|
case TemplateArgument::Declaration:
|
2009-06-13 08:26:55 +08:00
|
|
|
break;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2012-09-26 10:36:12 +08:00
|
|
|
case TemplateArgument::NullPtr:
|
|
|
|
MarkUsedTemplateParameters(Ctx, TemplateArg.getNullPtrType(), OnlyDeduced,
|
|
|
|
Depth, Used);
|
|
|
|
break;
|
|
|
|
|
2009-06-13 08:26:55 +08:00
|
|
|
case TemplateArgument::Type:
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx, TemplateArg.getAsType(), OnlyDeduced,
|
2009-10-29 08:04:11 +08:00
|
|
|
Depth, Used);
|
2009-06-13 08:26:55 +08:00
|
|
|
break;
|
|
|
|
|
2009-11-11 09:00:40 +08:00
|
|
|
case TemplateArgument::Template:
|
2011-01-06 02:58:31 +08:00
|
|
|
case TemplateArgument::TemplateExpansion:
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx,
|
2011-01-27 15:10:08 +08:00
|
|
|
TemplateArg.getAsTemplateOrTemplatePattern(),
|
2009-11-11 09:00:40 +08:00
|
|
|
OnlyDeduced, Depth, Used);
|
2009-06-13 08:26:55 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TemplateArgument::Expression:
|
2012-01-17 10:15:41 +08:00
|
|
|
MarkUsedTemplateParameters(Ctx, TemplateArg.getAsExpr(), OnlyDeduced,
|
2009-10-29 08:04:11 +08:00
|
|
|
Depth, Used);
|
2009-06-13 08:26:55 +08:00
|
|
|
break;
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-06-16 01:04:53 +08:00
|
|
|
case TemplateArgument::Pack:
|
2014-07-16 05:32:31 +08:00
|
|
|
for (const auto &P : TemplateArg.pack_elements())
|
|
|
|
MarkUsedTemplateParameters(Ctx, P, OnlyDeduced, Depth, Used);
|
2009-06-16 01:04:53 +08:00
|
|
|
break;
|
2009-06-13 08:26:55 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-06-22 18:16:05 +08:00
|
|
|
/// \brief Mark which template parameters can be deduced from a given
|
2009-06-13 08:26:55 +08:00
|
|
|
/// template argument list.
|
|
|
|
///
|
|
|
|
/// \param TemplateArgs the template argument list from which template
|
|
|
|
/// parameters will be deduced.
|
|
|
|
///
|
2012-06-22 18:16:05 +08:00
|
|
|
/// \param Used a bit vector whose elements will be set to \c true
|
2009-06-13 08:26:55 +08:00
|
|
|
/// to indicate when the corresponding template parameter will be
|
|
|
|
/// deduced.
|
2009-09-09 23:08:12 +08:00
|
|
|
void
|
2009-09-15 05:25:05 +08:00
|
|
|
Sema::MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs,
|
2009-10-29 08:04:11 +08:00
|
|
|
bool OnlyDeduced, unsigned Depth,
|
2012-01-31 00:17:39 +08:00
|
|
|
llvm::SmallBitVector &Used) {
|
2010-12-23 09:24:45 +08:00
|
|
|
// C++0x [temp.deduct.type]p9:
|
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
|
2010-12-23 09:24:45 +08:00
|
|
|
// non-deduced context.
|
2011-01-27 15:10:08 +08:00
|
|
|
if (OnlyDeduced &&
|
2010-12-23 09:24:45 +08:00
|
|
|
hasPackExpansionBeforeEnd(TemplateArgs.data(), TemplateArgs.size()))
|
|
|
|
return;
|
|
|
|
|
2009-06-13 08:26:55 +08:00
|
|
|
for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
|
2012-01-17 10:15:41 +08:00
|
|
|
::MarkUsedTemplateParameters(Context, TemplateArgs[I], OnlyDeduced,
|
2009-10-29 08:04:11 +08:00
|
|
|
Depth, Used);
|
2009-06-13 08:26:55 +08:00
|
|
|
}
|
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.
|
2014-07-28 08:02:09 +08:00
|
|
|
void Sema::MarkDeducedTemplateParameters(
|
|
|
|
ASTContext &Ctx, const FunctionTemplateDecl *FunctionTemplate,
|
|
|
|
llvm::SmallBitVector &Deduced) {
|
2011-01-27 15:10:08 +08:00
|
|
|
TemplateParameterList *TemplateParams
|
2009-09-19 07:21:38 +08:00
|
|
|
= FunctionTemplate->getTemplateParameters();
|
|
|
|
Deduced.clear();
|
|
|
|
Deduced.resize(TemplateParams->size());
|
2011-01-27 15:10:08 +08:00
|
|
|
|
2009-09-19 07:21:38 +08:00
|
|
|
FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
|
|
|
|
for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I)
|
2012-01-17 10:15:41 +08:00
|
|
|
::MarkUsedTemplateParameters(Ctx, Function->getParamDecl(I)->getType(),
|
2009-10-29 08:04:11 +08:00
|
|
|
true, TemplateParams->getDepth(), Deduced);
|
2009-09-19 07:21:38 +08:00
|
|
|
}
|
2011-06-17 00:50:48 +08:00
|
|
|
|
|
|
|
bool hasDeducibleTemplateParameters(Sema &S,
|
|
|
|
FunctionTemplateDecl *FunctionTemplate,
|
|
|
|
QualType T) {
|
|
|
|
if (!T->isDependentType())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
TemplateParameterList *TemplateParams
|
|
|
|
= FunctionTemplate->getTemplateParameters();
|
2012-01-31 00:17:39 +08:00
|
|
|
llvm::SmallBitVector Deduced(TemplateParams->size());
|
2016-08-12 19:43:57 +08:00
|
|
|
::MarkUsedTemplateParameters(S.Context, T, true, TemplateParams->getDepth(),
|
2011-06-17 00:50:48 +08:00
|
|
|
Deduced);
|
|
|
|
|
2012-01-31 00:17:39 +08:00
|
|
|
return Deduced.any();
|
2011-06-17 00:50:48 +08:00
|
|
|
}
|