2009-06-04 04:03:07 +04: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-13 00:07:10 +04:00
|
|
|
#include "clang/Sema/Sema.h"
|
2010-08-20 22:27:03 +04:00
|
|
|
#include "clang/Sema/DeclSpec.h"
|
2010-08-24 11:21:54 +04:00
|
|
|
#include "clang/Sema/Template.h"
|
2010-08-25 09:32:35 +04:00
|
|
|
#include "clang/Sema/TemplateDeduction.h"
|
2009-06-04 04:03:07 +04:00
|
|
|
#include "clang/AST/ASTContext.h"
|
2010-08-24 11:21:54 +04:00
|
|
|
#include "clang/AST/DeclObjC.h"
|
2009-06-04 04:03:07 +04:00
|
|
|
#include "clang/AST/DeclTemplate.h"
|
|
|
|
#include "clang/AST/StmtVisitor.h"
|
|
|
|
#include "clang/AST/Expr.h"
|
|
|
|
#include "clang/AST/ExprCXX.h"
|
2010-12-23 00:19:48 +03:00
|
|
|
#include "llvm/ADT/BitVector.h"
|
2011-02-20 06:19:35 +03:00
|
|
|
#include "TreeTransform.h"
|
2009-09-14 22:39:43 +04:00
|
|
|
#include <algorithm>
|
2009-06-27 03:10:12 +04:00
|
|
|
|
|
|
|
namespace clang {
|
2010-08-25 09:32:35 +04:00
|
|
|
using namespace sema;
|
|
|
|
|
2009-06-27 03:10:12 +04: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 03:27:24 +04:00
|
|
|
/// deduction from a template-id of a derived class of the argument type.
|
2009-09-15 00:00:47 +04: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-25 20:19:08 +03:00
|
|
|
TDF_SkipNonDependent = 0x08,
|
|
|
|
/// \brief Whether we are performing template argument deduction for
|
2011-01-27 10:10:08 +03:00
|
|
|
/// parameters and arguments in a top-level template argument
|
2011-01-25 20:19:08 +03:00
|
|
|
TDF_TopLevelParameterTypeList = 0x10
|
2009-06-27 03:10:12 +04:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2009-06-04 04:03:07 +04:00
|
|
|
using namespace clang;
|
|
|
|
|
2010-03-26 08:50:28 +03: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 11:25:34 +03:00
|
|
|
X = X.extend(Y.getBitWidth());
|
2010-03-26 08:50:28 +03:00
|
|
|
else if (Y.getBitWidth() < X.getBitWidth())
|
2010-12-07 11:25:34 +03:00
|
|
|
Y = Y.extend(X.getBitWidth());
|
2010-03-26 08:50:28 +03: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-12 22:26:56 +04:00
|
|
|
static Sema::TemplateDeductionResult
|
2010-02-08 00:33:28 +03:00
|
|
|
DeduceTemplateArguments(Sema &S,
|
2009-06-12 22:26:56 +04:00
|
|
|
TemplateParameterList *TemplateParams,
|
|
|
|
const TemplateArgument &Param,
|
2011-01-12 01:21:24 +03:00
|
|
|
TemplateArgument Arg,
|
2010-08-25 09:32:35 +04:00
|
|
|
TemplateDeductionInfo &Info,
|
2010-12-22 21:55:49 +03:00
|
|
|
llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced);
|
2009-06-09 20:35:58 +04:00
|
|
|
|
2011-01-21 20:29:42 +03:00
|
|
|
/// \brief Whether template argument deduction for two reference parameters
|
|
|
|
/// resulted in the argument type, parameter type, or neither type being more
|
|
|
|
/// qualified than the other.
|
2011-01-27 10:10:08 +03:00
|
|
|
enum DeductionQualifierComparison {
|
|
|
|
NeitherMoreQualified = 0,
|
|
|
|
ParamMoreQualified,
|
|
|
|
ArgMoreQualified
|
2011-01-11 20:34:58 +03:00
|
|
|
};
|
|
|
|
|
2011-01-21 20:29:42 +03:00
|
|
|
/// \brief Stores the result of comparing two reference parameters while
|
|
|
|
/// performing template argument deduction for partial ordering of function
|
2011-01-27 10:10:08 +03:00
|
|
|
/// templates.
|
2011-01-21 20:29:42 +03:00
|
|
|
struct RefParamPartialOrderingComparison {
|
|
|
|
/// \brief Whether the parameter type is an rvalue reference type.
|
|
|
|
bool ParamIsRvalueRef;
|
|
|
|
/// \brief Whether the argument type is an rvalue reference type.
|
|
|
|
bool ArgIsRvalueRef;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-21 20:29:42 +03:00
|
|
|
/// \brief Whether the parameter or argument (or neither) is more qualified.
|
|
|
|
DeductionQualifierComparison Qualifiers;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2011-01-11 20:34:58 +03:00
|
|
|
|
2011-01-06 02:12:31 +03:00
|
|
|
static Sema::TemplateDeductionResult
|
|
|
|
DeduceTemplateArguments(Sema &S,
|
|
|
|
TemplateParameterList *TemplateParams,
|
|
|
|
QualType Param,
|
|
|
|
QualType Arg,
|
|
|
|
TemplateDeductionInfo &Info,
|
|
|
|
llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced,
|
2011-01-11 20:34:58 +03:00
|
|
|
unsigned TDF,
|
|
|
|
bool PartialOrdering = false,
|
2011-01-21 20:29:42 +03:00
|
|
|
llvm::SmallVectorImpl<RefParamPartialOrderingComparison> *
|
|
|
|
RefParamComparisons = 0);
|
2011-01-06 02:12:31 +03:00
|
|
|
|
2010-12-22 21:17:10 +03:00
|
|
|
static Sema::TemplateDeductionResult
|
|
|
|
DeduceTemplateArguments(Sema &S,
|
|
|
|
TemplateParameterList *TemplateParams,
|
|
|
|
const TemplateArgument *Params, unsigned NumParams,
|
|
|
|
const TemplateArgument *Args, unsigned NumArgs,
|
|
|
|
TemplateDeductionInfo &Info,
|
2010-12-22 21:55:49 +03:00
|
|
|
llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced,
|
|
|
|
bool NumberOfArgumentsMustMatch = true);
|
2010-12-22 21:17:10 +03:00
|
|
|
|
2009-06-05 04:53:49 +04: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) {
|
|
|
|
if (ImplicitCastExpr *IC = dyn_cast<ImplicitCastExpr>(E))
|
|
|
|
E = IC->getSubExpr();
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-06-05 04:53:49 +04:00
|
|
|
if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
|
|
|
|
return dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl());
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-06-05 04:53:49 +04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-12-23 02:09:49 +03:00
|
|
|
/// \brief Determine whether two declaration pointers refer to the same
|
|
|
|
/// declaration.
|
|
|
|
static bool isSameDeclaration(Decl *X, Decl *Y) {
|
|
|
|
if (!X || !Y)
|
|
|
|
return !X && !Y;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 02:09:49 +03:00
|
|
|
if (NamedDecl *NX = dyn_cast<NamedDecl>(X))
|
|
|
|
X = NX->getUnderlyingDecl();
|
|
|
|
if (NamedDecl *NY = dyn_cast<NamedDecl>(Y))
|
|
|
|
Y = NY->getUnderlyingDecl();
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 02:09:49 +03: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 10:10:08 +03:00
|
|
|
static DeducedTemplateArgument
|
2010-12-23 02:09:49 +03: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 10:10:08 +03:00
|
|
|
return X;
|
2010-12-23 02:09:49 +03: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 10:10:08 +03:00
|
|
|
|
2010-12-23 02:09:49 +03:00
|
|
|
return DeducedTemplateArgument();
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 02:09:49 +03: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 &&
|
|
|
|
hasSameExtendedValue(*X.getAsIntegral(), *Y.getAsIntegral())))
|
2011-01-27 10:10:08 +03:00
|
|
|
return DeducedTemplateArgument(X,
|
2010-12-23 02:09:49 +03:00
|
|
|
X.wasDeducedFromArrayBound() &&
|
|
|
|
Y.wasDeducedFromArrayBound());
|
|
|
|
|
|
|
|
// All other combinations are incompatible.
|
|
|
|
return DeducedTemplateArgument();
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 02:09:49 +03:00
|
|
|
case TemplateArgument::Template:
|
|
|
|
if (Y.getKind() == TemplateArgument::Template &&
|
|
|
|
Context.hasSameTemplateName(X.getAsTemplate(), Y.getAsTemplate()))
|
|
|
|
return X;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 02:09:49 +03:00
|
|
|
// All other combinations are incompatible.
|
2011-01-27 10:10:08 +03:00
|
|
|
return DeducedTemplateArgument();
|
2011-01-05 21:58:31 +03:00
|
|
|
|
|
|
|
case TemplateArgument::TemplateExpansion:
|
|
|
|
if (Y.getKind() == TemplateArgument::TemplateExpansion &&
|
2011-01-27 10:10:08 +03:00
|
|
|
Context.hasSameTemplateName(X.getAsTemplateOrTemplatePattern(),
|
2011-01-05 21:58:31 +03:00
|
|
|
Y.getAsTemplateOrTemplatePattern()))
|
|
|
|
return X;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-05 21:58:31 +03:00
|
|
|
// All other combinations are incompatible.
|
2011-01-27 10:10:08 +03:00
|
|
|
return DeducedTemplateArgument();
|
2011-01-05 21:58:31 +03:00
|
|
|
|
2010-12-23 02:09:49 +03:00
|
|
|
case TemplateArgument::Expression:
|
2011-01-27 10:10:08 +03: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 02:09:49 +03:00
|
|
|
// or declaration.
|
|
|
|
if (Y.getKind() == TemplateArgument::Integral ||
|
|
|
|
Y.getKind() == TemplateArgument::Declaration)
|
|
|
|
return DeducedTemplateArgument(Y, X.wasDeducedFromArrayBound() &&
|
|
|
|
Y.wasDeducedFromArrayBound());
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 02:09:49 +03: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 10:10:08 +03:00
|
|
|
|
2010-12-23 02:09:49 +03:00
|
|
|
// All other combinations are incompatible.
|
|
|
|
return DeducedTemplateArgument();
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 02:09:49 +03: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 10:10:08 +03:00
|
|
|
|
2010-12-23 02:09:49 +03:00
|
|
|
// If we deduced a declaration and an integral constant, keep the
|
|
|
|
// integral constant.
|
|
|
|
if (Y.getKind() == TemplateArgument::Integral)
|
|
|
|
return Y;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 02:09:49 +03:00
|
|
|
// If we deduced two declarations, make sure they they refer to the
|
|
|
|
// same declaration.
|
|
|
|
if (Y.getKind() == TemplateArgument::Declaration &&
|
|
|
|
isSameDeclaration(X.getAsDecl(), Y.getAsDecl()))
|
|
|
|
return X;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 02:09:49 +03:00
|
|
|
// All other combinations are incompatible.
|
|
|
|
return DeducedTemplateArgument();
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 02:09:49 +03:00
|
|
|
case TemplateArgument::Pack:
|
|
|
|
if (Y.getKind() != TemplateArgument::Pack ||
|
|
|
|
X.pack_size() != Y.pack_size())
|
|
|
|
return DeducedTemplateArgument();
|
2011-01-27 10:10:08 +03:00
|
|
|
|
|
|
|
for (TemplateArgument::pack_iterator XA = X.pack_begin(),
|
2010-12-23 02:09:49 +03:00
|
|
|
XAEnd = X.pack_end(),
|
|
|
|
YA = Y.pack_begin();
|
|
|
|
XA != XAEnd; ++XA, ++YA) {
|
2011-01-27 10:10:08 +03:00
|
|
|
if (checkDeducedTemplateArguments(Context,
|
|
|
|
DeducedTemplateArgument(*XA, X.wasDeducedFromArrayBound()),
|
2011-01-06 00:00:53 +03:00
|
|
|
DeducedTemplateArgument(*YA, Y.wasDeducedFromArrayBound()))
|
|
|
|
.isNull())
|
2010-12-23 02:09:49 +03:00
|
|
|
return DeducedTemplateArgument();
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 02:09:49 +03:00
|
|
|
return X;
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 02:09:49 +03:00
|
|
|
return DeducedTemplateArgument();
|
|
|
|
}
|
|
|
|
|
2009-09-09 19:08:12 +04:00
|
|
|
/// \brief Deduce the value of the given non-type template parameter
|
2009-06-05 04:53:49 +04:00
|
|
|
/// from the given constant.
|
2009-06-12 22:26:56 +04:00
|
|
|
static Sema::TemplateDeductionResult
|
2010-02-08 00:33:28 +03:00
|
|
|
DeduceNonTypeTemplateArgument(Sema &S,
|
2009-09-09 19:08:12 +04:00
|
|
|
NonTypeTemplateParmDecl *NTTP,
|
2010-03-26 08:50:28 +03:00
|
|
|
llvm::APSInt Value, QualType ValueType,
|
2010-03-28 06:42:43 +04:00
|
|
|
bool DeducedFromArrayBound,
|
2010-08-25 09:32:35 +04:00
|
|
|
TemplateDeductionInfo &Info,
|
2010-03-28 06:42:43 +04:00
|
|
|
llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
|
2009-09-09 19:08:12 +04:00
|
|
|
assert(NTTP->getDepth() == 0 &&
|
2009-06-05 04:53:49 +04:00
|
|
|
"Cannot deduce non-type template argument with depth > 0");
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2010-12-23 02:09:49 +03:00
|
|
|
DeducedTemplateArgument NewDeduced(Value, ValueType, DeducedFromArrayBound);
|
2011-01-27 10:10:08 +03:00
|
|
|
DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
|
2010-12-23 02:09:49 +03:00
|
|
|
Deduced[NTTP->getIndex()],
|
|
|
|
NewDeduced);
|
|
|
|
if (Result.isNull()) {
|
2009-06-12 22:26:56 +04:00
|
|
|
Info.Param = NTTP;
|
|
|
|
Info.FirstArg = Deduced[NTTP->getIndex()];
|
2010-12-23 02:09:49 +03:00
|
|
|
Info.SecondArg = NewDeduced;
|
2011-01-27 10:10:08 +03:00
|
|
|
return Sema::TDK_Inconsistent;
|
2009-06-12 22:26:56 +04:00
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 02:09:49 +03:00
|
|
|
Deduced[NTTP->getIndex()] = Result;
|
2009-06-12 22:26:56 +04:00
|
|
|
return Sema::TDK_Success;
|
2009-06-05 04:53:49 +04:00
|
|
|
}
|
|
|
|
|
2009-09-09 19:08:12 +04:00
|
|
|
/// \brief Deduce the value of the given non-type template parameter
|
2009-06-05 04:53:49 +04:00
|
|
|
/// from the given type- or value-dependent expression.
|
|
|
|
///
|
|
|
|
/// \returns true if deduction succeeded, false otherwise.
|
2009-06-12 22:26:56 +04:00
|
|
|
static Sema::TemplateDeductionResult
|
2010-02-08 00:33:28 +03:00
|
|
|
DeduceNonTypeTemplateArgument(Sema &S,
|
2009-06-12 22:26:56 +04:00
|
|
|
NonTypeTemplateParmDecl *NTTP,
|
|
|
|
Expr *Value,
|
2010-08-25 09:32:35 +04:00
|
|
|
TemplateDeductionInfo &Info,
|
2010-03-28 06:42:43 +04:00
|
|
|
llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
|
2009-09-09 19:08:12 +04:00
|
|
|
assert(NTTP->getDepth() == 0 &&
|
2009-06-05 04:53:49 +04: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 19:08:12 +04:00
|
|
|
|
2010-12-23 02:09:49 +03:00
|
|
|
DeducedTemplateArgument NewDeduced(Value);
|
2011-01-27 10:10:08 +03:00
|
|
|
DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
|
|
|
|
Deduced[NTTP->getIndex()],
|
2010-12-23 02:09:49 +03:00
|
|
|
NewDeduced);
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 02:09:49 +03:00
|
|
|
if (Result.isNull()) {
|
|
|
|
Info.Param = NTTP;
|
|
|
|
Info.FirstArg = Deduced[NTTP->getIndex()];
|
|
|
|
Info.SecondArg = NewDeduced;
|
2011-01-27 10:10:08 +03:00
|
|
|
return Sema::TDK_Inconsistent;
|
2009-09-15 20:51:42 +04:00
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 02:09:49 +03:00
|
|
|
Deduced[NTTP->getIndex()] = Result;
|
2009-06-12 22:26:56 +04:00
|
|
|
return Sema::TDK_Success;
|
2009-06-05 04:53:49 +04:00
|
|
|
}
|
|
|
|
|
2009-11-14 02:45:44 +03: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 00:33:28 +03:00
|
|
|
DeduceNonTypeTemplateArgument(Sema &S,
|
2009-11-14 02:45:44 +03:00
|
|
|
NonTypeTemplateParmDecl *NTTP,
|
|
|
|
Decl *D,
|
2010-08-25 09:32:35 +04:00
|
|
|
TemplateDeductionInfo &Info,
|
2010-03-28 06:42:43 +04:00
|
|
|
llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
|
2009-11-14 02:45:44 +03:00
|
|
|
assert(NTTP->getDepth() == 0 &&
|
|
|
|
"Cannot deduce non-type template argument with depth > 0");
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 02:09:49 +03:00
|
|
|
DeducedTemplateArgument NewDeduced(D? D->getCanonicalDecl() : 0);
|
2011-01-27 10:10:08 +03:00
|
|
|
DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
|
2010-12-23 02:09:49 +03:00
|
|
|
Deduced[NTTP->getIndex()],
|
|
|
|
NewDeduced);
|
|
|
|
if (Result.isNull()) {
|
|
|
|
Info.Param = NTTP;
|
|
|
|
Info.FirstArg = Deduced[NTTP->getIndex()];
|
|
|
|
Info.SecondArg = NewDeduced;
|
2011-01-27 10:10:08 +03:00
|
|
|
return Sema::TDK_Inconsistent;
|
2009-11-14 02:45:44 +03:00
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 02:09:49 +03:00
|
|
|
Deduced[NTTP->getIndex()] = Result;
|
2009-11-14 02:45:44 +03:00
|
|
|
return Sema::TDK_Success;
|
|
|
|
}
|
|
|
|
|
2009-06-12 22:26:56 +04:00
|
|
|
static Sema::TemplateDeductionResult
|
2010-02-08 00:33:28 +03:00
|
|
|
DeduceTemplateArguments(Sema &S,
|
2009-11-12 02:06:43 +03:00
|
|
|
TemplateParameterList *TemplateParams,
|
2009-06-12 22:26:56 +04:00
|
|
|
TemplateName Param,
|
|
|
|
TemplateName Arg,
|
2010-08-25 09:32:35 +04:00
|
|
|
TemplateDeductionInfo &Info,
|
2010-03-28 06:42:43 +04:00
|
|
|
llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
|
2009-06-09 20:35:58 +04:00
|
|
|
TemplateDecl *ParamDecl = Param.getAsTemplateDecl();
|
2009-11-12 02:06:43 +03: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-12 22:26:56 +04:00
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-11-12 02:06:43 +03:00
|
|
|
if (TemplateTemplateParmDecl *TempParam
|
|
|
|
= dyn_cast<TemplateTemplateParmDecl>(ParamDecl)) {
|
2010-12-23 02:09:49 +03:00
|
|
|
DeducedTemplateArgument NewDeduced(S.Context.getCanonicalTemplateName(Arg));
|
2011-01-27 10:10:08 +03:00
|
|
|
DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
|
2010-12-23 02:09:49 +03:00
|
|
|
Deduced[TempParam->getIndex()],
|
|
|
|
NewDeduced);
|
|
|
|
if (Result.isNull()) {
|
|
|
|
Info.Param = TempParam;
|
|
|
|
Info.FirstArg = Deduced[TempParam->getIndex()];
|
|
|
|
Info.SecondArg = NewDeduced;
|
2011-01-27 10:10:08 +03:00
|
|
|
return Sema::TDK_Inconsistent;
|
2009-11-12 02:06:43 +03:00
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 02:09:49 +03:00
|
|
|
Deduced[TempParam->getIndex()] = Result;
|
2011-01-27 10:10:08 +03:00
|
|
|
return Sema::TDK_Success;
|
2009-06-12 22:26:56 +04:00
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-11-12 02:06:43 +03:00
|
|
|
// Verify that the two template names are equivalent.
|
2010-02-08 00:33:28 +03:00
|
|
|
if (S.Context.hasSameTemplateName(Param, Arg))
|
2009-11-12 02:06:43 +03:00
|
|
|
return Sema::TDK_Success;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-11-12 02:06:43 +03:00
|
|
|
// Mismatch of non-dependent template parameter to argument.
|
|
|
|
Info.FirstArg = TemplateArgument(Param);
|
|
|
|
Info.SecondArg = TemplateArgument(Arg);
|
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-06-09 20:35:58 +04:00
|
|
|
}
|
|
|
|
|
2009-09-09 19:08:12 +04:00
|
|
|
/// \brief Deduce the template arguments by comparing the template parameter
|
2009-07-08 03:09:34 +04:00
|
|
|
/// type (which is a template-id) with the template argument type.
|
|
|
|
///
|
2010-02-08 00:33:28 +03:00
|
|
|
/// \param S the Sema
|
2009-07-08 03:09:34 +04: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 00:33:28 +03:00
|
|
|
DeduceTemplateArguments(Sema &S,
|
2009-07-08 03:09:34 +04:00
|
|
|
TemplateParameterList *TemplateParams,
|
|
|
|
const TemplateSpecializationType *Param,
|
|
|
|
QualType Arg,
|
2010-08-25 09:32:35 +04:00
|
|
|
TemplateDeductionInfo &Info,
|
2010-03-28 06:42:43 +04:00
|
|
|
llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
|
2009-10-23 00:10:53 +04:00
|
|
|
assert(Arg.isCanonical() && "Argument type must be canonical");
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-07-08 03:09:34 +04:00
|
|
|
// Check whether the template argument is a dependent template-id.
|
2009-09-09 19:08:12 +04:00
|
|
|
if (const TemplateSpecializationType *SpecArg
|
2009-07-08 03:09:34 +04:00
|
|
|
= dyn_cast<TemplateSpecializationType>(Arg)) {
|
|
|
|
// Perform template argument deduction for the template name.
|
|
|
|
if (Sema::TemplateDeductionResult Result
|
2010-02-08 00:33:28 +03:00
|
|
|
= DeduceTemplateArguments(S, TemplateParams,
|
2009-07-08 03:09:34 +04:00
|
|
|
Param->getTemplateName(),
|
|
|
|
SpecArg->getTemplateName(),
|
|
|
|
Info, Deduced))
|
|
|
|
return Result;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
|
|
|
|
2009-07-08 03:09:34 +04:00
|
|
|
// Perform template argument deduction on each template
|
2010-12-22 21:55:49 +03:00
|
|
|
// argument. Ignore any missing/extra arguments, since they could be
|
|
|
|
// filled in by default arguments.
|
2011-01-27 10:10:08 +03:00
|
|
|
return DeduceTemplateArguments(S, TemplateParams,
|
|
|
|
Param->getArgs(), Param->getNumArgs(),
|
2010-12-22 21:55:49 +03:00
|
|
|
SpecArg->getArgs(), SpecArg->getNumArgs(),
|
|
|
|
Info, Deduced,
|
|
|
|
/*NumberOfArgumentsMustMatch=*/false);
|
2009-07-08 03:09:34 +04:00
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-07-08 03:09:34 +04: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);
|
|
|
|
if (!RecordArg)
|
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
|
|
|
ClassTemplateSpecializationDecl *SpecArg
|
2009-07-08 03:09:34 +04:00
|
|
|
= dyn_cast<ClassTemplateSpecializationDecl>(RecordArg->getDecl());
|
|
|
|
if (!SpecArg)
|
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-07-08 03:09:34 +04:00
|
|
|
// Perform template argument deduction for the template name.
|
|
|
|
if (Sema::TemplateDeductionResult Result
|
2010-02-08 00:33:28 +03:00
|
|
|
= DeduceTemplateArguments(S,
|
2009-11-12 02:06:43 +03:00
|
|
|
TemplateParams,
|
2009-07-08 03:09:34 +04:00
|
|
|
Param->getTemplateName(),
|
|
|
|
TemplateName(SpecArg->getSpecializedTemplate()),
|
|
|
|
Info, Deduced))
|
|
|
|
return Result;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2010-12-22 21:17:10 +03:00
|
|
|
// Perform template argument deduction for the template arguments.
|
2011-01-27 10:10:08 +03:00
|
|
|
return DeduceTemplateArguments(S, TemplateParams,
|
2010-12-22 21:17:10 +03:00
|
|
|
Param->getArgs(), Param->getNumArgs(),
|
|
|
|
SpecArg->getTemplateArgs().data(),
|
|
|
|
SpecArg->getTemplateArgs().size(),
|
|
|
|
Info, Deduced);
|
2009-07-08 03:09:34 +04:00
|
|
|
}
|
|
|
|
|
2010-08-29 02:14:41 +04: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 10:41:22 +03:00
|
|
|
case Type::TemplateTypeParm:
|
2010-08-29 02:14:41 +04: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.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@123163 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-10 10:32:04 +03:00
|
|
|
/// \brief Retrieve the depth and index of a template parameter.
|
2011-01-27 10:10:08 +03: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.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@123163 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-10 10:32:04 +03:00
|
|
|
getDepthAndIndex(NamedDecl *ND) {
|
2011-01-06 02:12:31 +03:00
|
|
|
if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ND))
|
|
|
|
return std::make_pair(TTP->getDepth(), TTP->getIndex());
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-06 02:12:31 +03:00
|
|
|
if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(ND))
|
|
|
|
return std::make_pair(NTTP->getDepth(), NTTP->getIndex());
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-06 02:12:31 +03: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.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@123163 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-10 10:32:04 +03:00
|
|
|
/// \brief Retrieve the depth and index of an unexpanded parameter pack.
|
2011-01-27 10:10:08 +03: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.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@123163 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-10 10:32:04 +03: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 10:10:08 +03: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.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@123163 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-10 10:32:04 +03:00
|
|
|
return getDepthAndIndex(UPP.first.get<NamedDecl *>());
|
|
|
|
}
|
|
|
|
|
2011-01-06 02:12:31 +03: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);
|
|
|
|
else if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D))
|
|
|
|
return TemplateParameter(NTTP);
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-06 02:12:31 +03:00
|
|
|
return TemplateParameter(cast<TemplateTemplateParmDecl>(D));
|
|
|
|
}
|
|
|
|
|
2011-01-10 20:35:05 +03:00
|
|
|
/// \brief Prepare to perform template argument deduction for all of the
|
|
|
|
/// arguments in a set of argument packs.
|
2011-01-27 10:10:08 +03:00
|
|
|
static void PrepareArgumentPackDeduction(Sema &S,
|
|
|
|
llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced,
|
2011-01-10 20:35:05 +03:00
|
|
|
const llvm::SmallVectorImpl<unsigned> &PackIndices,
|
2011-01-27 10:10:08 +03:00
|
|
|
llvm::SmallVectorImpl<DeducedTemplateArgument> &SavedPacks,
|
2011-01-10 20:35:05 +03:00
|
|
|
llvm::SmallVectorImpl<
|
|
|
|
llvm::SmallVector<DeducedTemplateArgument, 4> > &NewlyDeducedPacks) {
|
|
|
|
// Save the deduced template arguments for each parameter pack expanded
|
|
|
|
// by this pack expansion, then clear out the deduction.
|
|
|
|
for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) {
|
|
|
|
// Save the previously-deduced argument pack, then clear it out so that we
|
|
|
|
// can deduce a new argument pack.
|
|
|
|
SavedPacks[I] = Deduced[PackIndices[I]];
|
2011-01-27 10:10:08 +03:00
|
|
|
Deduced[PackIndices[I]] = TemplateArgument();
|
|
|
|
|
2011-01-10 20:35:05 +03:00
|
|
|
// If the template arugment pack was explicitly specified, add that to
|
|
|
|
// the set of deduced arguments.
|
|
|
|
const TemplateArgument *ExplicitArgs;
|
|
|
|
unsigned NumExplicitArgs;
|
2011-01-27 10:10:08 +03:00
|
|
|
if (NamedDecl *PartiallySubstitutedPack
|
2011-01-10 20:35:05 +03:00
|
|
|
= S.CurrentInstantiationScope->getPartiallySubstitutedPack(
|
|
|
|
&ExplicitArgs,
|
|
|
|
&NumExplicitArgs)) {
|
|
|
|
if (getDepthAndIndex(PartiallySubstitutedPack).second == PackIndices[I])
|
2011-01-27 10:10:08 +03:00
|
|
|
NewlyDeducedPacks[I].append(ExplicitArgs,
|
2011-01-10 20:35:05 +03:00
|
|
|
ExplicitArgs + NumExplicitArgs);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-01-10 20:53:52 +03:00
|
|
|
/// \brief Finish template argument deduction for a set of argument packs,
|
|
|
|
/// producing the argument packs and checking for consistency with prior
|
|
|
|
/// deductions.
|
|
|
|
static Sema::TemplateDeductionResult
|
|
|
|
FinishArgumentPackDeduction(Sema &S,
|
|
|
|
TemplateParameterList *TemplateParams,
|
|
|
|
bool HasAnyArguments,
|
2011-01-27 10:10:08 +03:00
|
|
|
llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced,
|
2011-01-10 20:53:52 +03:00
|
|
|
const llvm::SmallVectorImpl<unsigned> &PackIndices,
|
2011-01-27 10:10:08 +03:00
|
|
|
llvm::SmallVectorImpl<DeducedTemplateArgument> &SavedPacks,
|
2011-01-10 20:53:52 +03:00
|
|
|
llvm::SmallVectorImpl<
|
|
|
|
llvm::SmallVector<DeducedTemplateArgument, 4> > &NewlyDeducedPacks,
|
|
|
|
TemplateDeductionInfo &Info) {
|
|
|
|
// Build argument packs for each of the parameter packs expanded by this
|
|
|
|
// pack expansion.
|
|
|
|
for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) {
|
|
|
|
if (HasAnyArguments && NewlyDeducedPacks[I].empty()) {
|
|
|
|
// We were not able to deduce anything for this parameter pack,
|
|
|
|
// so just restore the saved argument pack.
|
|
|
|
Deduced[PackIndices[I]] = SavedPacks[I];
|
|
|
|
continue;
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-10 20:53:52 +03:00
|
|
|
DeducedTemplateArgument NewPack;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-10 20:53:52 +03:00
|
|
|
if (NewlyDeducedPacks[I].empty()) {
|
|
|
|
// If we deduced an empty argument pack, create it now.
|
|
|
|
NewPack = DeducedTemplateArgument(TemplateArgument(0, 0));
|
|
|
|
} else {
|
|
|
|
TemplateArgument *ArgumentPack
|
2011-01-12 02:09:57 +03:00
|
|
|
= new (S.Context) TemplateArgument [NewlyDeducedPacks[I].size()];
|
2011-01-10 20:53:52 +03:00
|
|
|
std::copy(NewlyDeducedPacks[I].begin(), NewlyDeducedPacks[I].end(),
|
|
|
|
ArgumentPack);
|
|
|
|
NewPack
|
2011-01-12 02:09:57 +03:00
|
|
|
= DeducedTemplateArgument(TemplateArgument(ArgumentPack,
|
|
|
|
NewlyDeducedPacks[I].size()),
|
2011-01-27 10:10:08 +03:00
|
|
|
NewlyDeducedPacks[I][0].wasDeducedFromArrayBound());
|
2011-01-10 20:53:52 +03:00
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-10 20:53:52 +03:00
|
|
|
DeducedTemplateArgument Result
|
|
|
|
= checkDeducedTemplateArguments(S.Context, SavedPacks[I], NewPack);
|
|
|
|
if (Result.isNull()) {
|
|
|
|
Info.Param
|
|
|
|
= makeTemplateParameter(TemplateParams->getParam(PackIndices[I]));
|
|
|
|
Info.FirstArg = SavedPacks[I];
|
|
|
|
Info.SecondArg = NewPack;
|
|
|
|
return Sema::TDK_Inconsistent;
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-10 20:53:52 +03:00
|
|
|
Deduced[PackIndices[I]] = Result;
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-10 20:53:52 +03:00
|
|
|
return Sema::TDK_Success;
|
|
|
|
}
|
|
|
|
|
2011-01-06 02:12:31 +03:00
|
|
|
/// \brief Deduce the template arguments by comparing the list of parameter
|
2011-01-27 10:10:08 +03: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 02:12:31 +03: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-11 20:34:58 +03:00
|
|
|
/// \param PartialOrdering If true, we are performing template argument
|
2011-01-27 10:10:08 +03:00
|
|
|
/// deduction for during partial ordering for a call
|
2011-01-11 20:34:58 +03:00
|
|
|
/// (C++0x [temp.deduct.partial]).
|
|
|
|
///
|
2011-01-21 20:29:42 +03:00
|
|
|
/// \param RefParamComparisons If we're performing template argument deduction
|
2011-01-11 20:34:58 +03:00
|
|
|
/// in the context of partial ordering, the set of qualifier comparisons.
|
|
|
|
///
|
2011-01-06 02:12:31 +03: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,
|
|
|
|
llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced,
|
2011-01-11 20:34:58 +03:00
|
|
|
unsigned TDF,
|
|
|
|
bool PartialOrdering = false,
|
2011-01-21 20:29:42 +03:00
|
|
|
llvm::SmallVectorImpl<RefParamPartialOrderingComparison> *
|
|
|
|
RefParamComparisons = 0) {
|
2011-01-06 02:23:17 +03: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])))
|
2011-01-10 23:53:55 +03:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-06 02:12:31 +03:00
|
|
|
// C++0x [temp.deduct.type]p10:
|
2011-01-27 10:10:08 +03: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 02:12:31 +03:00
|
|
|
unsigned ArgIdx = 0, ParamIdx = 0;
|
|
|
|
for (; ParamIdx != NumParams; ++ParamIdx) {
|
|
|
|
// Check argument types.
|
2011-01-27 10:10:08 +03:00
|
|
|
const PackExpansionType *Expansion
|
2011-01-06 02:12:31 +03:00
|
|
|
= dyn_cast<PackExpansionType>(Params[ParamIdx]);
|
|
|
|
if (!Expansion) {
|
|
|
|
// Simple case: compare the parameter and argument types at this point.
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-06 02:12:31 +03:00
|
|
|
// Make sure we have an argument.
|
|
|
|
if (ArgIdx >= NumArgs)
|
2011-01-10 23:53:55 +03:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-12 01:21:24 +03: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.
|
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-06 02:12:31 +03:00
|
|
|
if (Sema::TemplateDeductionResult Result
|
2011-01-11 20:34:58 +03:00
|
|
|
= DeduceTemplateArguments(S, TemplateParams,
|
|
|
|
Params[ParamIdx],
|
|
|
|
Args[ArgIdx],
|
|
|
|
Info, Deduced, TDF,
|
|
|
|
PartialOrdering,
|
2011-01-21 20:29:42 +03:00
|
|
|
RefParamComparisons))
|
2011-01-06 02:12:31 +03:00
|
|
|
return Result;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-06 02:12:31 +03:00
|
|
|
++ArgIdx;
|
|
|
|
continue;
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-11 04:52:23 +03:00
|
|
|
// C++0x [temp.deduct.type]p5:
|
|
|
|
// The non-deduced contexts are:
|
2011-01-27 10:10:08 +03:00
|
|
|
// - A function parameter pack that does not occur at the end of the
|
2011-01-11 04:52:23 +03:00
|
|
|
// parameter-declaration-clause.
|
|
|
|
if (ParamIdx + 1 < NumParams)
|
|
|
|
return Sema::TDK_Success;
|
|
|
|
|
2011-01-06 02:12:31 +03:00
|
|
|
// C++0x [temp.deduct.type]p10:
|
2011-01-27 10:10:08 +03:00
|
|
|
// If the parameter-declaration corresponding to Pi is a function
|
2011-01-06 02:12:31 +03:00
|
|
|
// parameter pack, then the type of its declarator- id is compared with
|
2011-01-27 10:10:08 +03:00
|
|
|
// each remaining parameter type in the parameter-type-list of A. Each
|
2011-01-06 02:12:31 +03:00
|
|
|
// comparison deduces template arguments for subsequent positions in the
|
|
|
|
// template parameter packs expanded by the function parameter pack.
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-06 02:12:31 +03:00
|
|
|
// Compute the set of template parameter indices that correspond to
|
|
|
|
// parameter packs expanded by the pack expansion.
|
|
|
|
llvm::SmallVector<unsigned, 2> PackIndices;
|
|
|
|
QualType Pattern = Expansion->getPattern();
|
|
|
|
{
|
|
|
|
llvm::BitVector SawIndices(TemplateParams->size());
|
|
|
|
llvm::SmallVector<UnexpandedParameterPack, 2> Unexpanded;
|
|
|
|
S.collectUnexpandedParameterPacks(Pattern, Unexpanded);
|
|
|
|
for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
|
|
|
|
unsigned Depth, Index;
|
|
|
|
llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]);
|
|
|
|
if (Depth == 0 && !SawIndices[Index]) {
|
|
|
|
SawIndices[Index] = true;
|
|
|
|
PackIndices.push_back(Index);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?");
|
|
|
|
|
Work-in-progress implementation of C++0x [temp.arg.explicit]p9, which
allows an argument pack determines via explicit specification of
function template arguments to be extended by further, deduced
arguments. For example:
template<class ... Types> void f(Types ... values);
void g() {
f<int*, float*>(0, 0, 0); // Types is deduced to the sequence int*, float*, int
}
There are a number of FIXMEs in here that indicate places where we
need to implement + test retained expansions, plus a number of other
places in deduction where we need to correctly cope with the
explicitly-specified arguments when deducing an argument
pack. Furthermore, it appears that the RecursiveASTVisitor needs to be
auditied; it's missing some traversals (especially w.r.t. template
arguments) that cause it not to find unexpanded parameter packs when
it should.
The good news, however, is that the tr1::tuple implementation now
works fully, and the tr1::bind example (both from N2080) is actually
working now.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@123163 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-10 10:32:04 +03:00
|
|
|
// Keep track of the deduced template arguments for each parameter pack
|
2011-01-27 10:10:08 +03:00
|
|
|
// expanded by this pack expansion (the outer index) and for each
|
Work-in-progress implementation of C++0x [temp.arg.explicit]p9, which
allows an argument pack determines via explicit specification of
function template arguments to be extended by further, deduced
arguments. For example:
template<class ... Types> void f(Types ... values);
void g() {
f<int*, float*>(0, 0, 0); // Types is deduced to the sequence int*, float*, int
}
There are a number of FIXMEs in here that indicate places where we
need to implement + test retained expansions, plus a number of other
places in deduction where we need to correctly cope with the
explicitly-specified arguments when deducing an argument
pack. Furthermore, it appears that the RecursiveASTVisitor needs to be
auditied; it's missing some traversals (especially w.r.t. template
arguments) that cause it not to find unexpanded parameter packs when
it should.
The good news, however, is that the tr1::tuple implementation now
works fully, and the tr1::bind example (both from N2080) is actually
working now.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@123163 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-10 10:32:04 +03:00
|
|
|
// template argument (the inner SmallVectors).
|
|
|
|
llvm::SmallVector<llvm::SmallVector<DeducedTemplateArgument, 4>, 2>
|
|
|
|
NewlyDeducedPacks(PackIndices.size());
|
2011-01-27 10:10:08 +03:00
|
|
|
llvm::SmallVector<DeducedTemplateArgument, 2>
|
2011-01-10 20:35:05 +03:00
|
|
|
SavedPacks(PackIndices.size());
|
2011-01-27 10:10:08 +03:00
|
|
|
PrepareArgumentPackDeduction(S, Deduced, PackIndices, SavedPacks,
|
2011-01-10 20:35:05 +03:00
|
|
|
NewlyDeducedPacks);
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-06 02:12:31 +03:00
|
|
|
bool HasAnyArguments = false;
|
|
|
|
for (; ArgIdx < NumArgs; ++ArgIdx) {
|
|
|
|
HasAnyArguments = true;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-06 02:12:31 +03:00
|
|
|
// Deduce template arguments from the pattern.
|
2011-01-27 10:10:08 +03:00
|
|
|
if (Sema::TemplateDeductionResult Result
|
2011-01-25 20:19:08 +03:00
|
|
|
= DeduceTemplateArguments(S, TemplateParams, Pattern, Args[ArgIdx],
|
|
|
|
Info, Deduced, TDF, PartialOrdering,
|
|
|
|
RefParamComparisons))
|
2011-01-06 02:12:31 +03:00
|
|
|
return Result;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-06 02:12:31 +03:00
|
|
|
// Capture the deduced template arguments for each parameter pack expanded
|
|
|
|
// by this pack expansion, add them to the list of arguments we've deduced
|
|
|
|
// for that pack, then clear out the deduced argument.
|
|
|
|
for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) {
|
|
|
|
DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]];
|
|
|
|
if (!DeducedArg.isNull()) {
|
|
|
|
NewlyDeducedPacks[I].push_back(DeducedArg);
|
|
|
|
DeducedArg = DeducedTemplateArgument();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-06 02:12:31 +03:00
|
|
|
// Build argument packs for each of the parameter packs expanded by this
|
|
|
|
// pack expansion.
|
2011-01-10 20:53:52 +03:00
|
|
|
if (Sema::TemplateDeductionResult Result
|
2011-01-27 10:10:08 +03:00
|
|
|
= FinishArgumentPackDeduction(S, TemplateParams, HasAnyArguments,
|
2011-01-10 20:53:52 +03:00
|
|
|
Deduced, PackIndices, SavedPacks,
|
|
|
|
NewlyDeducedPacks, Info))
|
2011-01-27 10:10:08 +03:00
|
|
|
return Result;
|
2011-01-06 02:12:31 +03:00
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-06 02:12:31 +03:00
|
|
|
// Make sure we don't have any extra arguments.
|
|
|
|
if (ArgIdx < NumArgs)
|
2011-01-10 23:53:55 +03:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-06 02:12:31 +03:00
|
|
|
return Sema::TDK_Success;
|
|
|
|
}
|
|
|
|
|
2011-04-28 04:56:09 +04:00
|
|
|
/// \brief Determine whether the parameter has qualifiers that are either
|
|
|
|
/// inconsistent with or a superset of the argument's qualifiers.
|
|
|
|
static bool hasInconsistentOrSupersetQualifiersOf(QualType ParamType,
|
|
|
|
QualType ArgType) {
|
|
|
|
Qualifiers ParamQs = ParamType.getQualifiers();
|
|
|
|
Qualifiers ArgQs = ArgType.getQualifiers();
|
|
|
|
|
|
|
|
if (ParamQs == ArgQs)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Mismatched (but not missing) Objective-C GC attributes.
|
|
|
|
if (ParamQs.getObjCGCAttr() != ArgQs.getObjCGCAttr() &&
|
|
|
|
ParamQs.hasObjCGCAttr())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// Mismatched (but not missing) address spaces.
|
|
|
|
if (ParamQs.getAddressSpace() != ArgQs.getAddressSpace() &&
|
|
|
|
ParamQs.hasAddressSpace())
|
|
|
|
return true;
|
|
|
|
|
2011-06-16 03:02:42 +04:00
|
|
|
// Mismatched (but not missing) Objective-C lifetime qualifiers.
|
|
|
|
if (ParamQs.getObjCLifetime() != ArgQs.getObjCLifetime() &&
|
|
|
|
ParamQs.hasObjCLifetime())
|
|
|
|
return true;
|
|
|
|
|
2011-04-28 04:56:09 +04:00
|
|
|
// CVR qualifier superset.
|
|
|
|
return (ParamQs.getCVRQualifiers() != ArgQs.getCVRQualifiers()) &&
|
|
|
|
((ParamQs.getCVRQualifiers() | ArgQs.getCVRQualifiers())
|
|
|
|
== ParamQs.getCVRQualifiers());
|
|
|
|
}
|
|
|
|
|
2009-06-26 22:27:22 +04:00
|
|
|
/// \brief Deduce the template arguments by comparing the parameter type and
|
|
|
|
/// the argument type (C++ [temp.deduct.type]).
|
|
|
|
///
|
2010-02-08 00:33:28 +03:00
|
|
|
/// \param S the semantic analysis object within which we are deducing
|
2009-06-26 22:27:22 +04: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 03:10:12 +04:00
|
|
|
/// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe
|
2009-09-09 19:08:12 +04:00
|
|
|
/// how template argument deduction is performed.
|
2009-06-26 22:27:22 +04:00
|
|
|
///
|
2011-01-11 20:34:58 +03:00
|
|
|
/// \param PartialOrdering Whether we're performing template argument deduction
|
|
|
|
/// in the context of partial ordering (C++0x [temp.deduct.partial]).
|
|
|
|
///
|
2011-01-21 20:29:42 +03:00
|
|
|
/// \param RefParamComparisons If we're performing template argument deduction
|
2011-01-11 20:34:58 +03:00
|
|
|
/// in the context of partial ordering, the set of qualifier comparisons.
|
|
|
|
///
|
2009-06-26 22:27:22 +04: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-12 22:26:56 +04:00
|
|
|
static Sema::TemplateDeductionResult
|
2010-02-08 00:33:28 +03:00
|
|
|
DeduceTemplateArguments(Sema &S,
|
2009-06-12 22:26:56 +04:00
|
|
|
TemplateParameterList *TemplateParams,
|
|
|
|
QualType ParamIn, QualType ArgIn,
|
2010-08-25 09:32:35 +04:00
|
|
|
TemplateDeductionInfo &Info,
|
2010-03-28 06:42:43 +04:00
|
|
|
llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced,
|
2011-01-11 20:34:58 +03:00
|
|
|
unsigned TDF,
|
|
|
|
bool PartialOrdering,
|
2011-01-21 20:29:42 +03:00
|
|
|
llvm::SmallVectorImpl<RefParamPartialOrderingComparison> *RefParamComparisons) {
|
2009-06-04 04:03:07 +04:00
|
|
|
// We only want to look at the canonical types, since typedefs and
|
|
|
|
// sugar are not part of template argument deduction.
|
2010-02-08 00:33:28 +03:00
|
|
|
QualType Param = S.Context.getCanonicalType(ParamIn);
|
|
|
|
QualType Arg = S.Context.getCanonicalType(ArgIn);
|
2009-06-04 04:03:07 +04:00
|
|
|
|
2011-01-12 01:21:24 +03:00
|
|
|
// If the argument type is a pack expansion, look at its pattern.
|
2011-01-27 10:10:08 +03:00
|
|
|
// This isn't explicitly called out
|
2011-01-12 01:21:24 +03:00
|
|
|
if (const PackExpansionType *ArgExpansion
|
|
|
|
= dyn_cast<PackExpansionType>(Arg))
|
|
|
|
Arg = ArgExpansion->getPattern();
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-11 20:34:58 +03:00
|
|
|
if (PartialOrdering) {
|
|
|
|
// C++0x [temp.deduct.partial]p5:
|
2011-01-27 10:10:08 +03: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-11 20:34:58 +03:00
|
|
|
const ReferenceType *ParamRef = Param->getAs<ReferenceType>();
|
|
|
|
if (ParamRef)
|
|
|
|
Param = ParamRef->getPointeeType();
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-11 20:34:58 +03: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 10:10:08 +03:00
|
|
|
|
2011-01-21 20:29:42 +03:00
|
|
|
if (RefParamComparisons && ParamRef && ArgRef) {
|
2011-01-11 20:34:58 +03:00
|
|
|
// C++0x [temp.deduct.partial]p6:
|
2011-01-27 10:10:08 +03:00
|
|
|
// If both P and A were reference types (before being replaced with the
|
|
|
|
// type referred to above), determine which of the two types (if any) is
|
2011-01-11 20:34:58 +03:00
|
|
|
// more cv-qualified than the other; otherwise the types are considered
|
2011-01-27 10:10:08 +03:00
|
|
|
// to be equally cv-qualified for partial ordering purposes. The result
|
2011-01-11 20:34:58 +03:00
|
|
|
// of this determination will be used below.
|
|
|
|
//
|
2011-01-27 10:10:08 +03:00
|
|
|
// We save this information for later, using it only when deduction
|
2011-01-11 20:34:58 +03:00
|
|
|
// succeeds in both directions.
|
2011-01-21 20:29:42 +03:00
|
|
|
RefParamPartialOrderingComparison Comparison;
|
|
|
|
Comparison.ParamIsRvalueRef = ParamRef->getAs<RValueReferenceType>();
|
|
|
|
Comparison.ArgIsRvalueRef = ArgRef->getAs<RValueReferenceType>();
|
|
|
|
Comparison.Qualifiers = NeitherMoreQualified;
|
2011-04-30 21:07:52 +04:00
|
|
|
|
|
|
|
Qualifiers ParamQuals = Param.getQualifiers();
|
|
|
|
Qualifiers ArgQuals = Arg.getQualifiers();
|
|
|
|
if (ParamQuals.isStrictSupersetOf(ArgQuals))
|
2011-01-21 20:29:42 +03:00
|
|
|
Comparison.Qualifiers = ParamMoreQualified;
|
2011-04-30 21:07:52 +04:00
|
|
|
else if (ArgQuals.isStrictSupersetOf(ParamQuals))
|
2011-01-21 20:29:42 +03:00
|
|
|
Comparison.Qualifiers = ArgMoreQualified;
|
|
|
|
RefParamComparisons->push_back(Comparison);
|
2011-01-11 20:34:58 +03:00
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-11 20:34:58 +03:00
|
|
|
// C++0x [temp.deduct.partial]p7:
|
|
|
|
// Remove any top-level cv-qualifiers:
|
2011-01-27 10:10:08 +03:00
|
|
|
// - If P is a cv-qualified type, P is replaced by the cv-unqualified
|
2011-01-11 20:34:58 +03:00
|
|
|
// version of P.
|
|
|
|
Param = Param.getUnqualifiedType();
|
2011-01-27 10:10:08 +03:00
|
|
|
// - If A is a cv-qualified type, A is replaced by the cv-unqualified
|
2011-01-11 20:34:58 +03: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 10:41:22 +03:00
|
|
|
Arg.getCVRQualifiers());
|
2011-01-11 20:34:58 +03:00
|
|
|
Param = S.Context.getQualifiedType(UnqualParam, Quals);
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-25 20:19:08 +03: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 10:10:08 +03: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-25 20:19:08 +03: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 10:09:49 +03:00
|
|
|
// deduced as X&. - end note ]
|
2011-01-25 20:19:08 +03:00
|
|
|
TDF &= ~TDF_TopLevelParameterTypeList;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-25 20:19:08 +03:00
|
|
|
if (const RValueReferenceType *ParamRef
|
|
|
|
= Param->getAs<RValueReferenceType>()) {
|
|
|
|
if (isa<TemplateTypeParmType>(ParamRef->getPointeeType()) &&
|
|
|
|
!ParamRef->getPointeeType().getQualifiers())
|
|
|
|
if (Arg->isLValueReferenceType())
|
|
|
|
Param = ParamRef->getPointeeType();
|
|
|
|
}
|
|
|
|
}
|
2009-06-26 22:27:22 +04:00
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-06-27 00:57:09 +04:00
|
|
|
// If the parameter type is not dependent, there is nothing to deduce.
|
2009-09-15 00:00:47 +04:00
|
|
|
if (!Param->isDependentType()) {
|
2011-01-10 23:53:55 +03:00
|
|
|
if (!(TDF & TDF_SkipNonDependent) && Param != Arg)
|
2009-09-15 00:00:47 +04:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-06-27 00:57:09 +04:00
|
|
|
return Sema::TDK_Success;
|
2009-09-15 00:00:47 +04:00
|
|
|
}
|
2009-06-04 04:03:07 +04:00
|
|
|
|
2009-06-05 04:53:49 +04:00
|
|
|
// C++ [temp.deduct.type]p9:
|
2009-09-09 19:08:12 +04: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 04:53:49 +04:00
|
|
|
// the following forms:
|
|
|
|
//
|
|
|
|
// T
|
|
|
|
// cv-list T
|
2009-09-09 19:08:12 +04:00
|
|
|
if (const TemplateTypeParmType *TemplateTypeParm
|
2009-09-22 03:43:11 +04:00
|
|
|
= Param->getAs<TemplateTypeParmType>()) {
|
2009-06-12 22:26:56 +04:00
|
|
|
unsigned Index = TemplateTypeParm->getIndex();
|
2009-07-23 01:30:48 +04:00
|
|
|
bool RecanonicalizeArg = false;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-07-23 00:02:25 +04: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 01:30:48 +04:00
|
|
|
if (isa<ArrayType>(Arg)) {
|
2009-09-24 23:53:00 +04:00
|
|
|
Qualifiers Quals;
|
2010-02-08 00:33:28 +03:00
|
|
|
Arg = S.Context.getUnqualifiedArrayType(Arg, Quals);
|
2009-09-24 23:53:00 +04:00
|
|
|
if (Quals) {
|
2010-02-08 00:33:28 +03:00
|
|
|
Arg = S.Context.getQualifiedType(Arg, Quals);
|
2009-07-23 01:30:48 +04:00
|
|
|
RecanonicalizeArg = true;
|
|
|
|
}
|
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-06-04 04:03:07 +04:00
|
|
|
// The argument type can not be less qualified than the parameter
|
|
|
|
// type.
|
2011-04-28 04:56:09 +04:00
|
|
|
if (!(TDF & TDF_IgnoreQualifiers) &&
|
|
|
|
hasInconsistentOrSupersetQualifiersOf(Param, Arg)) {
|
2009-06-12 22:26:56 +04:00
|
|
|
Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index));
|
2010-08-05 13:05:08 +04:00
|
|
|
Info.FirstArg = TemplateArgument(Param);
|
2009-10-29 11:12:44 +03:00
|
|
|
Info.SecondArg = TemplateArgument(Arg);
|
2010-08-05 13:05:08 +04:00
|
|
|
return Sema::TDK_Underqualified;
|
2009-06-12 22:26:56 +04:00
|
|
|
}
|
2009-06-04 04:03:07 +04:00
|
|
|
|
|
|
|
assert(TemplateTypeParm->getDepth() == 0 && "Can't deduce with depth > 0");
|
2010-02-08 00:33:28 +03:00
|
|
|
assert(Arg != S.Context.OverloadTy && "Unresolved overloaded function");
|
2009-09-24 23:53:00 +04:00
|
|
|
QualType DeducedType = Arg;
|
2010-12-10 14:01:00 +03:00
|
|
|
|
2011-04-28 04:56:09 +04: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 03:02:42 +04:00
|
|
|
if (ParamQs.hasObjCLifetime())
|
|
|
|
DeducedQs.removeObjCLifetime();
|
2011-04-28 04:56:09 +04:00
|
|
|
DeducedType = S.Context.getQualifiedType(DeducedType.getUnqualifiedType(),
|
|
|
|
DeducedQs);
|
|
|
|
|
2009-07-23 01:30:48 +04:00
|
|
|
if (RecanonicalizeArg)
|
2010-02-08 00:33:28 +03:00
|
|
|
DeducedType = S.Context.getCanonicalType(DeducedType);
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2010-12-23 02:09:49 +03:00
|
|
|
DeducedTemplateArgument NewDeduced(DeducedType);
|
2011-01-27 10:10:08 +03:00
|
|
|
DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
|
2010-12-23 02:09:49 +03:00
|
|
|
Deduced[Index],
|
|
|
|
NewDeduced);
|
|
|
|
if (Result.isNull()) {
|
|
|
|
Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index));
|
|
|
|
Info.FirstArg = Deduced[Index];
|
|
|
|
Info.SecondArg = NewDeduced;
|
2011-01-27 10:10:08 +03:00
|
|
|
return Sema::TDK_Inconsistent;
|
2009-06-04 04:03:07 +04:00
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 02:09:49 +03:00
|
|
|
Deduced[Index] = Result;
|
2011-01-27 10:10:08 +03:00
|
|
|
return Sema::TDK_Success;
|
2009-06-04 04:03:07 +04:00
|
|
|
}
|
|
|
|
|
2009-06-12 22:26:56 +04:00
|
|
|
// Set up the template argument deduction information for a failure.
|
2009-10-29 11:12:44 +03:00
|
|
|
Info.FirstArg = TemplateArgument(ParamIn);
|
|
|
|
Info.SecondArg = TemplateArgument(ArgIn);
|
2009-06-12 22:26:56 +04:00
|
|
|
|
2011-01-14 08:11:40 +03: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 03:10:12 +04:00
|
|
|
// Check the cv-qualifiers on the parameter and argument types.
|
|
|
|
if (!(TDF & TDF_IgnoreQualifiers)) {
|
|
|
|
if (TDF & TDF_ParamWithReferenceType) {
|
2011-04-28 04:56:09 +04:00
|
|
|
if (hasInconsistentOrSupersetQualifiersOf(Param, Arg))
|
2009-06-27 03:10:12 +04:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2010-08-29 02:14:41 +04:00
|
|
|
} else if (!IsPossiblyOpaquelyQualifiedType(Param)) {
|
2009-06-27 03:10:12 +04:00
|
|
|
if (Param.getCVRQualifiers() != Arg.getCVRQualifiers())
|
2009-09-09 19:08:12 +04:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-06-27 03:10:12 +04:00
|
|
|
}
|
|
|
|
}
|
2009-06-04 04:03:07 +04:00
|
|
|
|
2009-06-04 04:21:18 +04:00
|
|
|
switch (Param->getTypeClass()) {
|
2011-06-15 20:02:29 +04:00
|
|
|
// Non-canonical types cannot appear here.
|
|
|
|
#define NON_CANONICAL_TYPE(Class, Base) \
|
|
|
|
case Type::Class: llvm_unreachable("deducing non-canonical type: " #Class);
|
|
|
|
#define TYPE(Class, Base)
|
|
|
|
#include "clang/AST/TypeNodes.def"
|
|
|
|
|
|
|
|
case Type::TemplateTypeParm:
|
|
|
|
case Type::SubstTemplateTypeParmPack:
|
|
|
|
llvm_unreachable("Type nodes handled above");
|
|
|
|
|
|
|
|
// These types cannot be used in templates or cannot be dependent, so
|
|
|
|
// deduction always fails.
|
2009-06-05 04:53:49 +04:00
|
|
|
case Type::Builtin:
|
2011-06-15 20:02:29 +04:00
|
|
|
case Type::VariableArray:
|
|
|
|
case Type::Vector:
|
|
|
|
case Type::FunctionNoProto:
|
|
|
|
case Type::Record:
|
|
|
|
case Type::Enum:
|
|
|
|
case Type::ObjCObject:
|
|
|
|
case Type::ObjCInterface:
|
|
|
|
case Type::ObjCObjectPointer:
|
2009-06-12 22:26:56 +04:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2011-06-15 20:02:29 +04:00
|
|
|
// _Complex T [placeholder extension]
|
|
|
|
case Type::Complex:
|
|
|
|
if (const ComplexType *ComplexArg = Arg->getAs<ComplexType>())
|
|
|
|
return DeduceTemplateArguments(S, TemplateParams,
|
|
|
|
cast<ComplexType>(Param)->getElementType(),
|
|
|
|
ComplexArg->getElementType(),
|
|
|
|
Info, Deduced, TDF);
|
|
|
|
|
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
|
|
|
|
2009-06-05 04:53:49 +04:00
|
|
|
// T *
|
2009-06-04 04:21:18 +04:00
|
|
|
case Type::Pointer: {
|
2010-05-13 11:48:05 +04: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-12 22:26:56 +04:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2010-05-13 11:48:05 +04:00
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-06-27 03:27:24 +04:00
|
|
|
unsigned SubTDF = TDF & (TDF_IgnoreQualifiers | TDF_DerivedClass);
|
2010-02-08 00:33:28 +03:00
|
|
|
return DeduceTemplateArguments(S, TemplateParams,
|
2009-06-04 04:21:18 +04:00
|
|
|
cast<PointerType>(Param)->getPointeeType(),
|
2010-05-13 11:48:05 +04:00
|
|
|
PointeeType,
|
2009-06-27 03:27:24 +04:00
|
|
|
Info, Deduced, SubTDF);
|
2009-06-04 04:21:18 +04:00
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-06-05 04:53:49 +04:00
|
|
|
// T &
|
2009-06-04 04:21:18 +04:00
|
|
|
case Type::LValueReference: {
|
2009-07-30 01:53:49 +04:00
|
|
|
const LValueReferenceType *ReferenceArg = Arg->getAs<LValueReferenceType>();
|
2009-06-04 04:21:18 +04:00
|
|
|
if (!ReferenceArg)
|
2009-06-12 22:26:56 +04:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2010-02-08 00:33:28 +03:00
|
|
|
return DeduceTemplateArguments(S, TemplateParams,
|
2009-06-04 04:21:18 +04:00
|
|
|
cast<LValueReferenceType>(Param)->getPointeeType(),
|
|
|
|
ReferenceArg->getPointeeType(),
|
2009-06-27 03:10:12 +04:00
|
|
|
Info, Deduced, 0);
|
2009-06-04 04:21:18 +04:00
|
|
|
}
|
2009-06-04 04:03:07 +04:00
|
|
|
|
2009-06-05 04:53:49 +04:00
|
|
|
// T && [C++0x]
|
2009-06-04 04:21:18 +04:00
|
|
|
case Type::RValueReference: {
|
2009-07-30 01:53:49 +04:00
|
|
|
const RValueReferenceType *ReferenceArg = Arg->getAs<RValueReferenceType>();
|
2009-06-04 04:21:18 +04:00
|
|
|
if (!ReferenceArg)
|
2009-06-12 22:26:56 +04:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2010-02-08 00:33:28 +03:00
|
|
|
return DeduceTemplateArguments(S, TemplateParams,
|
2009-06-04 04:21:18 +04:00
|
|
|
cast<RValueReferenceType>(Param)->getPointeeType(),
|
|
|
|
ReferenceArg->getPointeeType(),
|
2009-06-27 03:10:12 +04:00
|
|
|
Info, Deduced, 0);
|
2009-06-04 04:21:18 +04:00
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-06-05 04:53:49 +04:00
|
|
|
// T [] (implied, but not stated explicitly)
|
2009-06-04 08:11:30 +04:00
|
|
|
case Type::IncompleteArray: {
|
2009-09-09 19:08:12 +04:00
|
|
|
const IncompleteArrayType *IncompleteArrayArg =
|
2010-02-08 00:33:28 +03:00
|
|
|
S.Context.getAsIncompleteArrayType(Arg);
|
2009-06-04 08:11:30 +04:00
|
|
|
if (!IncompleteArrayArg)
|
2009-06-12 22:26:56 +04:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2010-08-19 04:20:19 +04:00
|
|
|
unsigned SubTDF = TDF & TDF_IgnoreQualifiers;
|
2010-02-08 00:33:28 +03:00
|
|
|
return DeduceTemplateArguments(S, TemplateParams,
|
|
|
|
S.Context.getAsIncompleteArrayType(Param)->getElementType(),
|
2009-06-04 08:11:30 +04:00
|
|
|
IncompleteArrayArg->getElementType(),
|
2010-08-19 04:20:19 +04:00
|
|
|
Info, Deduced, SubTDF);
|
2009-06-04 08:11:30 +04:00
|
|
|
}
|
2009-06-05 04:53:49 +04:00
|
|
|
|
|
|
|
// T [integer-constant]
|
2009-06-04 08:11:30 +04:00
|
|
|
case Type::ConstantArray: {
|
2009-09-09 19:08:12 +04:00
|
|
|
const ConstantArrayType *ConstantArrayArg =
|
2010-02-08 00:33:28 +03:00
|
|
|
S.Context.getAsConstantArrayType(Arg);
|
2009-06-04 08:11:30 +04:00
|
|
|
if (!ConstantArrayArg)
|
2009-06-12 22:26:56 +04:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
|
|
|
const ConstantArrayType *ConstantArrayParm =
|
2010-02-08 00:33:28 +03:00
|
|
|
S.Context.getAsConstantArrayType(Param);
|
2009-06-04 08:11:30 +04:00
|
|
|
if (ConstantArrayArg->getSize() != ConstantArrayParm->getSize())
|
2009-06-12 22:26:56 +04:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2010-08-19 04:20:19 +04:00
|
|
|
unsigned SubTDF = TDF & TDF_IgnoreQualifiers;
|
2010-02-08 00:33:28 +03:00
|
|
|
return DeduceTemplateArguments(S, TemplateParams,
|
2009-06-04 08:11:30 +04:00
|
|
|
ConstantArrayParm->getElementType(),
|
|
|
|
ConstantArrayArg->getElementType(),
|
2010-08-19 04:20:19 +04:00
|
|
|
Info, Deduced, SubTDF);
|
2009-06-04 08:11:30 +04:00
|
|
|
}
|
|
|
|
|
2009-06-05 04:53:49 +04:00
|
|
|
// type [i]
|
|
|
|
case Type::DependentSizedArray: {
|
2010-02-08 00:33:28 +03:00
|
|
|
const ArrayType *ArrayArg = S.Context.getAsArrayType(Arg);
|
2009-06-05 04:53:49 +04:00
|
|
|
if (!ArrayArg)
|
2009-06-12 22:26:56 +04:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2010-08-19 04:20:19 +04:00
|
|
|
unsigned SubTDF = TDF & TDF_IgnoreQualifiers;
|
|
|
|
|
2009-06-05 04:53:49 +04:00
|
|
|
// Check the element type of the arrays
|
|
|
|
const DependentSizedArrayType *DependentArrayParm
|
2010-02-08 00:33:28 +03:00
|
|
|
= S.Context.getAsDependentSizedArrayType(Param);
|
2009-06-12 22:26:56 +04:00
|
|
|
if (Sema::TemplateDeductionResult Result
|
2010-02-08 00:33:28 +03:00
|
|
|
= DeduceTemplateArguments(S, TemplateParams,
|
2009-06-12 22:26:56 +04:00
|
|
|
DependentArrayParm->getElementType(),
|
|
|
|
ArrayArg->getElementType(),
|
2010-08-19 04:20:19 +04:00
|
|
|
Info, Deduced, SubTDF))
|
2009-06-12 22:26:56 +04:00
|
|
|
return Result;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-06-05 04:53:49 +04:00
|
|
|
// Determine the array bound is something we can deduce.
|
2009-09-09 19:08:12 +04:00
|
|
|
NonTypeTemplateParmDecl *NTTP
|
2009-06-05 04:53:49 +04:00
|
|
|
= getDeducedParameterFromExpr(DependentArrayParm->getSizeExpr());
|
|
|
|
if (!NTTP)
|
2009-06-12 22:26:56 +04:00
|
|
|
return Sema::TDK_Success;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
|
|
|
// We can perform template argument deduction for the given non-type
|
2009-06-05 04:53:49 +04:00
|
|
|
// template parameter.
|
2009-09-09 19:08:12 +04:00
|
|
|
assert(NTTP->getDepth() == 0 &&
|
2009-06-05 04:53:49 +04:00
|
|
|
"Cannot deduce non-type template argument at depth > 0");
|
2009-09-09 19:08:12 +04:00
|
|
|
if (const ConstantArrayType *ConstantArrayArg
|
2009-06-17 02:44:31 +04:00
|
|
|
= dyn_cast<ConstantArrayType>(ArrayArg)) {
|
|
|
|
llvm::APSInt Size(ConstantArrayArg->getSize());
|
2011-01-27 10:10:08 +03:00
|
|
|
return DeduceNonTypeTemplateArgument(S, NTTP, Size,
|
2010-03-26 08:50:28 +03:00
|
|
|
S.Context.getSizeType(),
|
2010-03-28 06:42:43 +04:00
|
|
|
/*ArrayBound=*/true,
|
2009-06-12 22:26:56 +04:00
|
|
|
Info, Deduced);
|
2009-06-17 02:44:31 +04:00
|
|
|
}
|
2009-06-05 04:53:49 +04:00
|
|
|
if (const DependentSizedArrayType *DependentArrayArg
|
|
|
|
= dyn_cast<DependentSizedArrayType>(ArrayArg))
|
2010-12-23 02:15:38 +03:00
|
|
|
if (DependentArrayArg->getSizeExpr())
|
|
|
|
return DeduceNonTypeTemplateArgument(S, NTTP,
|
|
|
|
DependentArrayArg->getSizeExpr(),
|
|
|
|
Info, Deduced);
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-06-05 04:53:49 +04:00
|
|
|
// Incomplete type does not match a dependently-sized array type
|
2009-06-12 22:26:56 +04:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-06-05 04:53:49 +04:00
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
|
|
|
// type(*)(T)
|
|
|
|
// T(*)()
|
|
|
|
// T(*)(T)
|
2009-06-08 19:19:08 +04:00
|
|
|
case Type::FunctionProto: {
|
2011-01-25 20:19:08 +03:00
|
|
|
unsigned SubTDF = TDF & TDF_TopLevelParameterTypeList;
|
2009-09-09 19:08:12 +04:00
|
|
|
const FunctionProtoType *FunctionProtoArg =
|
2009-06-08 19:19:08 +04:00
|
|
|
dyn_cast<FunctionProtoType>(Arg);
|
|
|
|
if (!FunctionProtoArg)
|
2009-06-12 22:26:56 +04:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
|
|
|
const FunctionProtoType *FunctionProtoParam =
|
2009-06-08 19:19:08 +04:00
|
|
|
cast<FunctionProtoType>(Param);
|
2009-06-08 23:22:23 +04:00
|
|
|
|
2011-01-27 10:10:08 +03:00
|
|
|
if (FunctionProtoParam->getTypeQuals()
|
2011-01-26 19:50:54 +03:00
|
|
|
!= FunctionProtoArg->getTypeQuals() ||
|
2011-01-27 10:10:08 +03:00
|
|
|
FunctionProtoParam->getRefQualifier()
|
2011-01-26 19:50:54 +03:00
|
|
|
!= FunctionProtoArg->getRefQualifier() ||
|
|
|
|
FunctionProtoParam->isVariadic() != FunctionProtoArg->isVariadic())
|
2009-06-12 22:26:56 +04:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-06-08 23:22:23 +04:00
|
|
|
|
2009-06-08 19:19:08 +04:00
|
|
|
// Check return types.
|
2009-06-12 22:26:56 +04:00
|
|
|
if (Sema::TemplateDeductionResult Result
|
2010-02-08 00:33:28 +03:00
|
|
|
= DeduceTemplateArguments(S, TemplateParams,
|
2009-06-12 22:26:56 +04:00
|
|
|
FunctionProtoParam->getResultType(),
|
|
|
|
FunctionProtoArg->getResultType(),
|
2009-06-27 03:10:12 +04:00
|
|
|
Info, Deduced, 0))
|
2009-06-12 22:26:56 +04:00
|
|
|
return Result;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2011-01-06 02:12:31 +03:00
|
|
|
return DeduceTemplateArguments(S, TemplateParams,
|
|
|
|
FunctionProtoParam->arg_type_begin(),
|
|
|
|
FunctionProtoParam->getNumArgs(),
|
|
|
|
FunctionProtoArg->arg_type_begin(),
|
|
|
|
FunctionProtoArg->getNumArgs(),
|
2011-01-25 20:19:08 +03:00
|
|
|
Info, Deduced, SubTDF);
|
2009-06-08 19:19:08 +04:00
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2010-03-10 06:28:59 +03:00
|
|
|
case Type::InjectedClassName: {
|
|
|
|
// Treat a template's injected-class-name as if the template
|
|
|
|
// specialization type had been used.
|
2010-04-27 04:57:59 +04:00
|
|
|
Param = cast<InjectedClassNameType>(Param)
|
|
|
|
->getInjectedSpecializationType();
|
2010-03-10 06:28:59 +03:00
|
|
|
assert(isa<TemplateSpecializationType>(Param) &&
|
|
|
|
"injected class name is not a template specialization type");
|
|
|
|
// fall through
|
|
|
|
}
|
|
|
|
|
2009-06-27 00:57:09 +04:00
|
|
|
// template-name<T> (where template-name refers to a class template)
|
2009-06-09 20:35:58 +04:00
|
|
|
// template-name<i>
|
2009-11-12 02:06:43 +03:00
|
|
|
// TT<T>
|
|
|
|
// TT<i>
|
|
|
|
// TT<>
|
2009-06-09 20:35:58 +04:00
|
|
|
case Type::TemplateSpecialization: {
|
|
|
|
const TemplateSpecializationType *SpecParam
|
|
|
|
= cast<TemplateSpecializationType>(Param);
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-07-08 03:09:34 +04:00
|
|
|
// Try to deduce template arguments from the template-id.
|
|
|
|
Sema::TemplateDeductionResult Result
|
2010-02-08 00:33:28 +03:00
|
|
|
= DeduceTemplateArguments(S, TemplateParams, SpecParam, Arg,
|
2009-07-08 03:09:34 +04:00
|
|
|
Info, Deduced);
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-10-01 02:13:51 +04:00
|
|
|
if (Result && (TDF & TDF_DerivedClass)) {
|
2009-07-08 03:09:34 +04:00
|
|
|
// C++ [temp.deduct.call]p3b3:
|
|
|
|
// If P is a class, and P has the form template-id, then A can be a
|
|
|
|
// derived class of the deduced A. Likewise, if P is a pointer to a
|
2009-09-09 19:08:12 +04:00
|
|
|
// class of the form template-id, A can be a pointer to a derived
|
2009-07-08 03:09:34 +04:00
|
|
|
// class pointed to by the deduced A.
|
|
|
|
//
|
|
|
|
// More importantly:
|
2009-09-09 19:08:12 +04:00
|
|
|
// These alternatives are considered only if type deduction would
|
2009-07-08 03:09:34 +04:00
|
|
|
// otherwise fail.
|
2010-02-08 00:33:28 +03:00
|
|
|
if (const RecordType *RecordT = Arg->getAs<RecordType>()) {
|
|
|
|
// We cannot inspect base classes as part of deduction when the type
|
|
|
|
// is incomplete, so either instantiate any templates necessary to
|
|
|
|
// complete the type, or skip over it if it cannot be completed.
|
2010-02-09 02:07:23 +03:00
|
|
|
if (S.RequireCompleteType(Info.getLocation(), Arg, 0))
|
2010-02-08 00:33:28 +03:00
|
|
|
return Result;
|
|
|
|
|
2009-07-08 03:09:34 +04:00
|
|
|
// Use data recursion to crawl through the list of base classes.
|
2009-09-09 19:08:12 +04:00
|
|
|
// Visited contains the set of nodes we have already visited, while
|
2009-07-08 03:09:34 +04:00
|
|
|
// ToVisit is our stack of records that we still need to visit.
|
|
|
|
llvm::SmallPtrSet<const RecordType *, 8> Visited;
|
|
|
|
llvm::SmallVector<const RecordType *, 8> ToVisit;
|
|
|
|
ToVisit.push_back(RecordT);
|
|
|
|
bool Successful = false;
|
2010-11-02 03:02:34 +03:00
|
|
|
llvm::SmallVectorImpl<DeducedTemplateArgument> DeducedOrig(0);
|
|
|
|
DeducedOrig = Deduced;
|
2009-07-08 03:09:34 +04:00
|
|
|
while (!ToVisit.empty()) {
|
|
|
|
// Retrieve the next class in the inheritance hierarchy.
|
|
|
|
const RecordType *NextT = ToVisit.back();
|
|
|
|
ToVisit.pop_back();
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-07-08 03:09:34 +04:00
|
|
|
// If we have already seen this type, skip it.
|
|
|
|
if (!Visited.insert(NextT))
|
|
|
|
continue;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-07-08 03:09:34 +04:00
|
|
|
// If this is a base class, try to perform template argument
|
|
|
|
// deduction from it.
|
|
|
|
if (NextT != RecordT) {
|
|
|
|
Sema::TemplateDeductionResult BaseResult
|
2010-02-08 00:33:28 +03:00
|
|
|
= DeduceTemplateArguments(S, TemplateParams, SpecParam,
|
2009-07-08 03:09:34 +04:00
|
|
|
QualType(NextT, 0), Info, Deduced);
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-07-08 03:09:34 +04:00
|
|
|
// If template argument deduction for this base was successful,
|
2010-11-02 03:02:34 +03:00
|
|
|
// note that we had some success. Otherwise, ignore any deductions
|
|
|
|
// from this base class.
|
|
|
|
if (BaseResult == Sema::TDK_Success) {
|
2009-07-08 03:09:34 +04:00
|
|
|
Successful = true;
|
2010-11-02 03:02:34 +03:00
|
|
|
DeducedOrig = Deduced;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
Deduced = DeducedOrig;
|
2009-07-08 03:09:34 +04:00
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-07-08 03:09:34 +04:00
|
|
|
// Visit base classes
|
|
|
|
CXXRecordDecl *Next = cast<CXXRecordDecl>(NextT->getDecl());
|
|
|
|
for (CXXRecordDecl::base_class_iterator Base = Next->bases_begin(),
|
|
|
|
BaseEnd = Next->bases_end();
|
2009-10-25 20:03:50 +03:00
|
|
|
Base != BaseEnd; ++Base) {
|
2009-09-09 19:08:12 +04:00
|
|
|
assert(Base->getType()->isRecordType() &&
|
2009-07-08 03:09:34 +04:00
|
|
|
"Base class that isn't a record?");
|
2009-07-30 01:53:49 +04:00
|
|
|
ToVisit.push_back(Base->getType()->getAs<RecordType>());
|
2009-07-08 03:09:34 +04:00
|
|
|
}
|
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-07-08 03:09:34 +04:00
|
|
|
if (Successful)
|
|
|
|
return Sema::TDK_Success;
|
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-07-08 03:09:34 +04:00
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-07-08 03:09:34 +04:00
|
|
|
return Result;
|
2009-06-09 20:35:58 +04:00
|
|
|
}
|
|
|
|
|
2009-06-11 03:47:09 +04: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-12 22:26:56 +04:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
|
|
|
|
|
|
|
if (Sema::TemplateDeductionResult Result
|
2010-02-08 00:33:28 +03:00
|
|
|
= DeduceTemplateArguments(S, TemplateParams,
|
2009-06-12 22:26:56 +04:00
|
|
|
MemPtrParam->getPointeeType(),
|
|
|
|
MemPtrArg->getPointeeType(),
|
2009-06-27 03:10:12 +04:00
|
|
|
Info, Deduced,
|
|
|
|
TDF & TDF_IgnoreQualifiers))
|
2009-06-12 22:26:56 +04:00
|
|
|
return Result;
|
|
|
|
|
2010-02-08 00:33:28 +03:00
|
|
|
return DeduceTemplateArguments(S, TemplateParams,
|
2009-06-12 22:26:56 +04:00
|
|
|
QualType(MemPtrParam->getClass(), 0),
|
|
|
|
QualType(MemPtrArg->getClass(), 0),
|
2009-06-27 03:10:12 +04:00
|
|
|
Info, Deduced, 0);
|
2009-06-11 03:47:09 +04:00
|
|
|
}
|
|
|
|
|
2009-06-13 02:56:54 +04:00
|
|
|
// (clang extension)
|
|
|
|
//
|
2009-09-09 19:08:12 +04:00
|
|
|
// type(^)(T)
|
|
|
|
// T(^)()
|
|
|
|
// T(^)(T)
|
2009-06-12 20:23:10 +04:00
|
|
|
case Type::BlockPointer: {
|
|
|
|
const BlockPointerType *BlockPtrParam = cast<BlockPointerType>(Param);
|
|
|
|
const BlockPointerType *BlockPtrArg = dyn_cast<BlockPointerType>(Arg);
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-06-12 20:23:10 +04:00
|
|
|
if (!BlockPtrArg)
|
2009-06-12 22:26:56 +04:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2010-02-08 00:33:28 +03:00
|
|
|
return DeduceTemplateArguments(S, TemplateParams,
|
2009-06-12 20:23:10 +04:00
|
|
|
BlockPtrParam->getPointeeType(),
|
2009-06-12 22:26:56 +04:00
|
|
|
BlockPtrArg->getPointeeType(), Info,
|
2009-06-27 03:10:12 +04:00
|
|
|
Deduced, 0);
|
2009-06-12 20:23:10 +04:00
|
|
|
}
|
|
|
|
|
2011-06-15 20:02:29 +04:00
|
|
|
// (clang extension)
|
|
|
|
//
|
|
|
|
// T __attribute__(((ext_vector_type(<integral constant>))))
|
|
|
|
case Type::ExtVector: {
|
|
|
|
const ExtVectorType *VectorParam = cast<ExtVectorType>(Param);
|
|
|
|
if (const ExtVectorType *VectorArg = dyn_cast<ExtVectorType>(Arg)) {
|
|
|
|
// Make sure that the vectors have the same number of elements.
|
|
|
|
if (VectorParam->getNumElements() != VectorArg->getNumElements())
|
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
|
|
|
|
|
|
|
// Perform deduction on the element types.
|
|
|
|
return DeduceTemplateArguments(S, TemplateParams,
|
|
|
|
VectorParam->getElementType(),
|
|
|
|
VectorArg->getElementType(),
|
|
|
|
Info, Deduced,
|
|
|
|
TDF);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (const DependentSizedExtVectorType *VectorArg
|
|
|
|
= dyn_cast<DependentSizedExtVectorType>(Arg)) {
|
|
|
|
// We can't check the number of elements, since the argument has a
|
|
|
|
// dependent number of elements. This can only occur during partial
|
|
|
|
// ordering.
|
|
|
|
|
|
|
|
// Perform deduction on the element types.
|
|
|
|
return DeduceTemplateArguments(S, TemplateParams,
|
|
|
|
VectorParam->getElementType(),
|
|
|
|
VectorArg->getElementType(),
|
|
|
|
Info, Deduced,
|
|
|
|
TDF);
|
|
|
|
}
|
|
|
|
|
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
|
|
|
}
|
|
|
|
|
|
|
|
// (clang extension)
|
|
|
|
//
|
|
|
|
// T __attribute__(((ext_vector_type(N))))
|
|
|
|
case Type::DependentSizedExtVector: {
|
|
|
|
const DependentSizedExtVectorType *VectorParam
|
|
|
|
= cast<DependentSizedExtVectorType>(Param);
|
|
|
|
|
|
|
|
if (const ExtVectorType *VectorArg = dyn_cast<ExtVectorType>(Arg)) {
|
|
|
|
// Perform deduction on the element types.
|
|
|
|
if (Sema::TemplateDeductionResult Result
|
|
|
|
= DeduceTemplateArguments(S, TemplateParams,
|
|
|
|
VectorParam->getElementType(),
|
|
|
|
VectorArg->getElementType(),
|
|
|
|
Info, Deduced,
|
|
|
|
TDF))
|
|
|
|
return Result;
|
|
|
|
|
|
|
|
// Perform deduction on the vector size, if we can.
|
|
|
|
NonTypeTemplateParmDecl *NTTP
|
|
|
|
= getDeducedParameterFromExpr(VectorParam->getSizeExpr());
|
|
|
|
if (!NTTP)
|
|
|
|
return Sema::TDK_Success;
|
|
|
|
|
|
|
|
llvm::APSInt ArgSize(S.Context.getTypeSize(S.Context.IntTy), false);
|
|
|
|
ArgSize = VectorArg->getNumElements();
|
|
|
|
return DeduceNonTypeTemplateArgument(S, NTTP, ArgSize, S.Context.IntTy,
|
|
|
|
false, Info, Deduced);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (const DependentSizedExtVectorType *VectorArg
|
|
|
|
= dyn_cast<DependentSizedExtVectorType>(Arg)) {
|
|
|
|
// Perform deduction on the element types.
|
|
|
|
if (Sema::TemplateDeductionResult Result
|
|
|
|
= DeduceTemplateArguments(S, TemplateParams,
|
|
|
|
VectorParam->getElementType(),
|
|
|
|
VectorArg->getElementType(),
|
|
|
|
Info, Deduced,
|
|
|
|
TDF))
|
|
|
|
return Result;
|
|
|
|
|
|
|
|
// Perform deduction on the vector size, if we can.
|
|
|
|
NonTypeTemplateParmDecl *NTTP
|
|
|
|
= getDeducedParameterFromExpr(VectorParam->getSizeExpr());
|
|
|
|
if (!NTTP)
|
|
|
|
return Sema::TDK_Success;
|
|
|
|
|
|
|
|
return DeduceNonTypeTemplateArgument(S, NTTP, VectorArg->getSizeExpr(),
|
|
|
|
Info, Deduced);
|
|
|
|
}
|
|
|
|
|
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
|
|
|
}
|
|
|
|
|
2009-06-11 03:47:09 +04:00
|
|
|
case Type::TypeOfExpr:
|
|
|
|
case Type::TypeOf:
|
2010-03-31 21:34:00 +04:00
|
|
|
case Type::DependentName:
|
2011-06-15 20:02:29 +04:00
|
|
|
case Type::UnresolvedUsing:
|
|
|
|
case Type::Decltype:
|
|
|
|
case Type::UnaryTransform:
|
|
|
|
case Type::Auto:
|
|
|
|
case Type::DependentTemplateSpecialization:
|
|
|
|
case Type::PackExpansion:
|
2009-06-11 03:47:09 +04:00
|
|
|
// No template argument deduction for these types
|
2009-06-12 22:26:56 +04:00
|
|
|
return Sema::TDK_Success;
|
2009-06-04 04:03:07 +04:00
|
|
|
}
|
|
|
|
|
2009-06-27 00:57:09 +04:00
|
|
|
return Sema::TDK_Success;
|
2009-06-04 04:03:07 +04:00
|
|
|
}
|
|
|
|
|
2009-06-12 22:26:56 +04:00
|
|
|
static Sema::TemplateDeductionResult
|
2010-02-08 00:33:28 +03:00
|
|
|
DeduceTemplateArguments(Sema &S,
|
2009-06-12 22:26:56 +04:00
|
|
|
TemplateParameterList *TemplateParams,
|
|
|
|
const TemplateArgument &Param,
|
2011-01-12 01:21:24 +03:00
|
|
|
TemplateArgument Arg,
|
2010-08-25 09:32:35 +04:00
|
|
|
TemplateDeductionInfo &Info,
|
2010-03-28 06:42:43 +04:00
|
|
|
llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
|
2011-01-12 01:21:24 +03: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 10:10:08 +03:00
|
|
|
|
2009-06-04 04:03:07 +04:00
|
|
|
switch (Param.getKind()) {
|
2009-06-05 04:53:49 +04:00
|
|
|
case TemplateArgument::Null:
|
|
|
|
assert(false && "Null template argument in parameter list");
|
|
|
|
break;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
|
|
|
case TemplateArgument::Type:
|
2009-11-11 04:00:40 +03:00
|
|
|
if (Arg.getKind() == TemplateArgument::Type)
|
2010-02-08 00:33:28 +03:00
|
|
|
return DeduceTemplateArguments(S, TemplateParams, Param.getAsType(),
|
2009-11-11 04:00:40 +03:00
|
|
|
Arg.getAsType(), Info, Deduced, 0);
|
|
|
|
Info.FirstArg = Param;
|
|
|
|
Info.SecondArg = Arg;
|
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2011-01-05 21:58:31 +03:00
|
|
|
|
2009-11-11 04:00:40 +03:00
|
|
|
case TemplateArgument::Template:
|
2009-11-12 02:06:43 +03:00
|
|
|
if (Arg.getKind() == TemplateArgument::Template)
|
2011-01-27 10:10:08 +03:00
|
|
|
return DeduceTemplateArguments(S, TemplateParams,
|
2009-11-11 04:00:40 +03:00
|
|
|
Param.getAsTemplate(),
|
2009-11-12 02:06:43 +03:00
|
|
|
Arg.getAsTemplate(), Info, Deduced);
|
2009-11-11 04:00:40 +03:00
|
|
|
Info.FirstArg = Param;
|
|
|
|
Info.SecondArg = Arg;
|
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2011-01-05 21:58:31 +03:00
|
|
|
|
|
|
|
case TemplateArgument::TemplateExpansion:
|
|
|
|
llvm_unreachable("caller should handle pack expansions");
|
|
|
|
break;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-06-05 04:53:49 +04:00
|
|
|
case TemplateArgument::Declaration:
|
2009-11-11 04:00:40 +03:00
|
|
|
if (Arg.getKind() == TemplateArgument::Declaration &&
|
|
|
|
Param.getAsDecl()->getCanonicalDecl() ==
|
|
|
|
Arg.getAsDecl()->getCanonicalDecl())
|
|
|
|
return Sema::TDK_Success;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-06-12 22:26:56 +04:00
|
|
|
Info.FirstArg = Param;
|
|
|
|
Info.SecondArg = Arg;
|
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-06-05 04:53:49 +04:00
|
|
|
case TemplateArgument::Integral:
|
|
|
|
if (Arg.getKind() == TemplateArgument::Integral) {
|
2010-03-26 08:50:28 +03:00
|
|
|
if (hasSameExtendedValue(*Param.getAsIntegral(), *Arg.getAsIntegral()))
|
2009-06-12 22:26:56 +04: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 04:53:49 +04:00
|
|
|
}
|
|
|
|
|
2009-06-12 22:26:56 +04:00
|
|
|
Info.FirstArg = Param;
|
|
|
|
Info.SecondArg = Arg;
|
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-06-05 04:53:49 +04:00
|
|
|
case TemplateArgument::Expression: {
|
2009-09-09 19:08:12 +04:00
|
|
|
if (NonTypeTemplateParmDecl *NTTP
|
2009-06-05 04:53:49 +04:00
|
|
|
= getDeducedParameterFromExpr(Param.getAsExpr())) {
|
|
|
|
if (Arg.getKind() == TemplateArgument::Integral)
|
2010-02-08 00:33:28 +03:00
|
|
|
return DeduceNonTypeTemplateArgument(S, NTTP,
|
2009-09-09 19:08:12 +04:00
|
|
|
*Arg.getAsIntegral(),
|
2010-03-26 08:50:28 +03:00
|
|
|
Arg.getIntegralType(),
|
2010-03-28 06:42:43 +04:00
|
|
|
/*ArrayBound=*/false,
|
2009-06-12 22:26:56 +04:00
|
|
|
Info, Deduced);
|
2009-06-05 04:53:49 +04:00
|
|
|
if (Arg.getKind() == TemplateArgument::Expression)
|
2010-02-08 00:33:28 +03:00
|
|
|
return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsExpr(),
|
2009-06-12 22:26:56 +04:00
|
|
|
Info, Deduced);
|
2009-11-14 02:45:44 +03:00
|
|
|
if (Arg.getKind() == TemplateArgument::Declaration)
|
2010-02-08 00:33:28 +03:00
|
|
|
return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsDecl(),
|
2009-11-14 02:45:44 +03:00
|
|
|
Info, Deduced);
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-06-12 22:26:56 +04:00
|
|
|
Info.FirstArg = Param;
|
|
|
|
Info.SecondArg = Arg;
|
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-06-05 04:53:49 +04:00
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-06-05 04:53:49 +04:00
|
|
|
// Can't deduce anything, but that's okay.
|
2009-06-12 22:26:56 +04:00
|
|
|
return Sema::TDK_Success;
|
2009-06-05 04:53:49 +04:00
|
|
|
}
|
2009-06-15 21:04:53 +04:00
|
|
|
case TemplateArgument::Pack:
|
2010-12-22 21:17:10 +03:00
|
|
|
llvm_unreachable("Argument packs should be expanded by the caller!");
|
2009-06-04 04:03:07 +04:00
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-06-12 22:26:56 +04:00
|
|
|
return Sema::TDK_Success;
|
2009-06-04 04:03:07 +04:00
|
|
|
}
|
|
|
|
|
2010-12-22 21:17:10 +03: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 10:10:08 +03:00
|
|
|
static bool hasTemplateArgumentForDeduction(const TemplateArgument *&Args,
|
2010-12-22 21:17:10 +03:00
|
|
|
unsigned &ArgIdx,
|
|
|
|
unsigned &NumArgs) {
|
|
|
|
if (ArgIdx == NumArgs)
|
|
|
|
return false;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-22 21:17:10 +03: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 04:24:45 +03: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 10:10:08 +03:00
|
|
|
|
2010-12-23 04:24:45 +03:00
|
|
|
// Unwrap argument packs.
|
|
|
|
if (Args[ArgIdx].getKind() == TemplateArgument::Pack) {
|
|
|
|
Args = Arg.pack_begin();
|
|
|
|
NumArgs = Arg.pack_size();
|
|
|
|
ArgIdx = 0;
|
|
|
|
continue;
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 04:24:45 +03:00
|
|
|
++ArgIdx;
|
|
|
|
if (ArgIdx == NumArgs)
|
|
|
|
return false;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 04:24:45 +03:00
|
|
|
if (Arg.isPackExpansion())
|
|
|
|
return true;
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 04:24:45 +03:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-09-09 19:08:12 +04:00
|
|
|
static Sema::TemplateDeductionResult
|
2010-02-08 00:33:28 +03:00
|
|
|
DeduceTemplateArguments(Sema &S,
|
2009-06-12 22:26:56 +04:00
|
|
|
TemplateParameterList *TemplateParams,
|
2010-12-22 21:17:10 +03:00
|
|
|
const TemplateArgument *Params, unsigned NumParams,
|
|
|
|
const TemplateArgument *Args, unsigned NumArgs,
|
2010-08-25 09:32:35 +04:00
|
|
|
TemplateDeductionInfo &Info,
|
2010-12-22 21:55:49 +03:00
|
|
|
llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced,
|
|
|
|
bool NumberOfArgumentsMustMatch) {
|
2010-12-23 00:19:48 +03:00
|
|
|
// C++0x [temp.deduct.type]p9:
|
2011-01-27 10:10:08 +03: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 00:19:48 +03:00
|
|
|
// non-deduced context.
|
2010-12-23 04:24:45 +03:00
|
|
|
if (hasPackExpansionBeforeEnd(Params, NumParams))
|
|
|
|
return Sema::TDK_Success;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 00:19:48 +03:00
|
|
|
// C++0x [temp.deduct.type]p9:
|
2011-01-27 10:10:08 +03: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 00:19:48 +03:00
|
|
|
// argument Ai of the corresponding template argument list of A.
|
2010-12-22 21:17:10 +03:00
|
|
|
unsigned ArgIdx = 0, ParamIdx = 0;
|
2011-01-27 10:10:08 +03:00
|
|
|
for (; hasTemplateArgumentForDeduction(Params, ParamIdx, NumParams);
|
2010-12-22 21:17:10 +03:00
|
|
|
++ParamIdx) {
|
|
|
|
if (!Params[ParamIdx].isPackExpansion()) {
|
2010-12-23 00:19:48 +03:00
|
|
|
// The simple case: deduce template arguments by matching Pi and Ai.
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-22 21:17:10 +03:00
|
|
|
// Check whether we have enough arguments.
|
|
|
|
if (!hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs))
|
2011-01-10 23:53:55 +03:00
|
|
|
return NumberOfArgumentsMustMatch? Sema::TDK_NonDeducedMismatch
|
2010-12-22 21:55:49 +03:00
|
|
|
: Sema::TDK_Success;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-12 01:21:24 +03: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.
|
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 00:19:48 +03:00
|
|
|
// Perform deduction for this Pi/Ai pair.
|
2010-12-22 21:17:10 +03:00
|
|
|
if (Sema::TemplateDeductionResult Result
|
2011-01-12 01:21:24 +03:00
|
|
|
= DeduceTemplateArguments(S, TemplateParams,
|
|
|
|
Params[ParamIdx], Args[ArgIdx],
|
|
|
|
Info, Deduced))
|
2011-01-27 10:10:08 +03:00
|
|
|
return Result;
|
|
|
|
|
2010-12-22 21:17:10 +03:00
|
|
|
// Move to the next argument.
|
|
|
|
++ArgIdx;
|
|
|
|
continue;
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 00:19:48 +03:00
|
|
|
// The parameter is a pack expansion.
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 00:19:48 +03:00
|
|
|
// C++0x [temp.deduct.type]p9:
|
2011-01-27 10:10:08 +03: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 00:19:48 +03:00
|
|
|
// template parameter packs expanded by Pi.
|
|
|
|
TemplateArgument Pattern = Params[ParamIdx].getPackExpansionPattern();
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 00:19:48 +03:00
|
|
|
// Compute the set of template parameter indices that correspond to
|
|
|
|
// parameter packs expanded by the pack expansion.
|
|
|
|
llvm::SmallVector<unsigned, 2> PackIndices;
|
|
|
|
{
|
|
|
|
llvm::BitVector SawIndices(TemplateParams->size());
|
|
|
|
llvm::SmallVector<UnexpandedParameterPack, 2> Unexpanded;
|
|
|
|
S.collectUnexpandedParameterPacks(Pattern, Unexpanded);
|
|
|
|
for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
|
|
|
|
unsigned Depth, Index;
|
|
|
|
llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]);
|
|
|
|
if (Depth == 0 && !SawIndices[Index]) {
|
|
|
|
SawIndices[Index] = true;
|
|
|
|
PackIndices.push_back(Index);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?");
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 00:19:48 +03: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 10:10:08 +03:00
|
|
|
|
2010-12-23 00:19:48 +03:00
|
|
|
// Save the deduced template arguments for each parameter pack expanded
|
|
|
|
// by this pack expansion, then clear out the deduction.
|
2011-01-27 10:10:08 +03:00
|
|
|
llvm::SmallVector<DeducedTemplateArgument, 2>
|
2010-12-23 00:19:48 +03:00
|
|
|
SavedPacks(PackIndices.size());
|
2011-01-10 20:35:05 +03:00
|
|
|
llvm::SmallVector<llvm::SmallVector<DeducedTemplateArgument, 4>, 2>
|
|
|
|
NewlyDeducedPacks(PackIndices.size());
|
2011-01-27 10:10:08 +03:00
|
|
|
PrepareArgumentPackDeduction(S, Deduced, PackIndices, SavedPacks,
|
2011-01-10 20:35:05 +03:00
|
|
|
NewlyDeducedPacks);
|
2010-12-23 00:19:48 +03:00
|
|
|
|
|
|
|
// Keep track of the deduced template arguments for each parameter pack
|
2011-01-27 10:10:08 +03:00
|
|
|
// expanded by this pack expansion (the outer index) and for each
|
2010-12-23 00:19:48 +03:00
|
|
|
// template argument (the inner SmallVectors).
|
|
|
|
bool HasAnyArguments = false;
|
|
|
|
while (hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs)) {
|
|
|
|
HasAnyArguments = true;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 00:19:48 +03:00
|
|
|
// Deduce template arguments from the pattern.
|
2011-01-27 10:10:08 +03:00
|
|
|
if (Sema::TemplateDeductionResult Result
|
2010-12-23 00:19:48 +03:00
|
|
|
= DeduceTemplateArguments(S, TemplateParams, Pattern, Args[ArgIdx],
|
|
|
|
Info, Deduced))
|
|
|
|
return Result;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 00:19:48 +03:00
|
|
|
// Capture the deduced template arguments for each parameter pack expanded
|
|
|
|
// by this pack expansion, add them to the list of arguments we've deduced
|
|
|
|
// for that pack, then clear out the deduced argument.
|
|
|
|
for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) {
|
|
|
|
DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]];
|
|
|
|
if (!DeducedArg.isNull()) {
|
|
|
|
NewlyDeducedPacks[I].push_back(DeducedArg);
|
|
|
|
DeducedArg = DeducedTemplateArgument();
|
|
|
|
}
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 00:19:48 +03:00
|
|
|
++ArgIdx;
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 00:19:48 +03:00
|
|
|
// Build argument packs for each of the parameter packs expanded by this
|
|
|
|
// pack expansion.
|
2011-01-10 20:53:52 +03:00
|
|
|
if (Sema::TemplateDeductionResult Result
|
2011-01-27 10:10:08 +03:00
|
|
|
= FinishArgumentPackDeduction(S, TemplateParams, HasAnyArguments,
|
2011-01-10 20:53:52 +03:00
|
|
|
Deduced, PackIndices, SavedPacks,
|
|
|
|
NewlyDeducedPacks, Info))
|
2011-01-27 10:10:08 +03:00
|
|
|
return Result;
|
2009-06-04 04:03:07 +04:00
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-22 21:17:10 +03:00
|
|
|
// If there is an argument remaining, then we had too many arguments.
|
2010-12-22 21:55:49 +03:00
|
|
|
if (NumberOfArgumentsMustMatch &&
|
|
|
|
hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs))
|
2011-01-10 23:53:55 +03:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-06-12 22:26:56 +04:00
|
|
|
return Sema::TDK_Success;
|
2009-06-04 04:03:07 +04:00
|
|
|
}
|
|
|
|
|
2010-12-22 21:17:10 +03:00
|
|
|
static Sema::TemplateDeductionResult
|
|
|
|
DeduceTemplateArguments(Sema &S,
|
|
|
|
TemplateParameterList *TemplateParams,
|
|
|
|
const TemplateArgumentList &ParamList,
|
|
|
|
const TemplateArgumentList &ArgList,
|
|
|
|
TemplateDeductionInfo &Info,
|
|
|
|
llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
|
2011-01-27 10:10:08 +03:00
|
|
|
return DeduceTemplateArguments(S, TemplateParams,
|
2010-12-22 21:17:10 +03:00
|
|
|
ParamList.data(), ParamList.size(),
|
|
|
|
ArgList.data(), ArgList.size(),
|
|
|
|
Info, Deduced);
|
|
|
|
}
|
|
|
|
|
2009-06-27 00:57:09 +04:00
|
|
|
/// \brief Determine whether two template arguments are the same.
|
2009-09-09 19:08:12 +04:00
|
|
|
static bool isSameTemplateArg(ASTContext &Context,
|
2009-06-27 00:57:09 +04:00
|
|
|
const TemplateArgument &X,
|
|
|
|
const TemplateArgument &Y) {
|
|
|
|
if (X.getKind() != Y.getKind())
|
|
|
|
return false;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-06-27 00:57:09 +04:00
|
|
|
switch (X.getKind()) {
|
|
|
|
case TemplateArgument::Null:
|
|
|
|
assert(false && "Comparing NULL template argument");
|
|
|
|
break;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-06-27 00:57:09 +04:00
|
|
|
case TemplateArgument::Type:
|
|
|
|
return Context.getCanonicalType(X.getAsType()) ==
|
|
|
|
Context.getCanonicalType(Y.getAsType());
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-06-27 00:57:09 +04:00
|
|
|
case TemplateArgument::Declaration:
|
2009-07-18 04:34:25 +04:00
|
|
|
return X.getAsDecl()->getCanonicalDecl() ==
|
|
|
|
Y.getAsDecl()->getCanonicalDecl();
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-11-11 04:00:40 +03:00
|
|
|
case TemplateArgument::Template:
|
2011-01-05 21:58:31 +03:00
|
|
|
case TemplateArgument::TemplateExpansion:
|
|
|
|
return Context.getCanonicalTemplateName(
|
|
|
|
X.getAsTemplateOrTemplatePattern()).getAsVoidPointer() ==
|
|
|
|
Context.getCanonicalTemplateName(
|
|
|
|
Y.getAsTemplateOrTemplatePattern()).getAsVoidPointer();
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-06-27 00:57:09 +04:00
|
|
|
case TemplateArgument::Integral:
|
|
|
|
return *X.getAsIntegral() == *Y.getAsIntegral();
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-11-11 04:00:40 +03:00
|
|
|
case TemplateArgument::Expression: {
|
|
|
|
llvm::FoldingSetNodeID XID, YID;
|
|
|
|
X.getAsExpr()->Profile(XID, Context, true);
|
2011-01-27 10:10:08 +03:00
|
|
|
Y.getAsExpr()->Profile(YID, Context, true);
|
2009-11-11 04:00:40 +03:00
|
|
|
return XID == YID;
|
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-06-27 00:57:09 +04:00
|
|
|
case TemplateArgument::Pack:
|
|
|
|
if (X.pack_size() != Y.pack_size())
|
|
|
|
return false;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
|
|
|
for (TemplateArgument::pack_iterator XP = X.pack_begin(),
|
|
|
|
XPEnd = X.pack_end(),
|
2009-06-27 00:57:09 +04:00
|
|
|
YP = Y.pack_begin();
|
2009-09-09 19:08:12 +04:00
|
|
|
XP != XPEnd; ++XP, ++YP)
|
2009-06-27 00:57:09 +04:00
|
|
|
if (!isSameTemplateArg(Context, *XP, *YP))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-01-05 02:35:54 +03:00
|
|
|
/// \brief Allocate a TemplateArgumentLoc where all locations have
|
|
|
|
/// been initialized to the given location.
|
|
|
|
///
|
|
|
|
/// \param S The semantic analysis object.
|
|
|
|
///
|
|
|
|
/// \param The template argument we are producing template argument
|
|
|
|
/// 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.
|
2011-01-27 10:10:08 +03:00
|
|
|
static TemplateArgumentLoc
|
2011-01-05 02:35:54 +03:00
|
|
|
getTrivialTemplateArgumentLoc(Sema &S,
|
2011-01-27 10:10:08 +03:00
|
|
|
const TemplateArgument &Arg,
|
2011-01-05 02:35:54 +03:00
|
|
|
QualType NTTPType,
|
|
|
|
SourceLocation Loc) {
|
|
|
|
switch (Arg.getKind()) {
|
|
|
|
case TemplateArgument::Null:
|
|
|
|
llvm_unreachable("Can't get a NULL template argument here");
|
|
|
|
break;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-05 02:35:54 +03:00
|
|
|
case TemplateArgument::Type:
|
2011-01-27 10:10:08 +03:00
|
|
|
return TemplateArgumentLoc(Arg,
|
2011-01-05 02:35:54 +03:00
|
|
|
S.Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc));
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-05 02:35:54 +03:00
|
|
|
case TemplateArgument::Declaration: {
|
|
|
|
Expr *E
|
2011-01-05 20:40:24 +03:00
|
|
|
= S.BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc)
|
2011-01-05 02:35:54 +03:00
|
|
|
.takeAs<Expr>();
|
|
|
|
return TemplateArgumentLoc(TemplateArgument(E), E);
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-05 02:35:54 +03:00
|
|
|
case TemplateArgument::Integral: {
|
|
|
|
Expr *E
|
2011-01-05 20:40:24 +03:00
|
|
|
= S.BuildExpressionFromIntegralTemplateArgument(Arg, Loc).takeAs<Expr>();
|
2011-01-05 02:35:54 +03:00
|
|
|
return TemplateArgumentLoc(TemplateArgument(E), E);
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-03-02 20:09:35 +03:00
|
|
|
case TemplateArgument::Template:
|
|
|
|
case TemplateArgument::TemplateExpansion: {
|
|
|
|
NestedNameSpecifierLocBuilder Builder;
|
|
|
|
TemplateName Template = Arg.getAsTemplate();
|
|
|
|
if (DependentTemplateName *DTN = Template.getAsDependentTemplateName())
|
|
|
|
Builder.MakeTrivial(S.Context, DTN->getQualifier(), Loc);
|
|
|
|
else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
|
|
|
|
Builder.MakeTrivial(S.Context, QTN->getQualifier(), Loc);
|
|
|
|
|
|
|
|
if (Arg.getKind() == TemplateArgument::Template)
|
|
|
|
return TemplateArgumentLoc(Arg,
|
|
|
|
Builder.getWithLocInContext(S.Context),
|
|
|
|
Loc);
|
|
|
|
|
|
|
|
|
|
|
|
return TemplateArgumentLoc(Arg, Builder.getWithLocInContext(S.Context),
|
|
|
|
Loc, Loc);
|
|
|
|
}
|
2011-01-05 21:58:31 +03:00
|
|
|
|
2011-01-05 02:35:54 +03:00
|
|
|
case TemplateArgument::Expression:
|
|
|
|
return TemplateArgumentLoc(Arg, Arg.getAsExpr());
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-05 02:35:54 +03:00
|
|
|
case TemplateArgument::Pack:
|
|
|
|
return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo());
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-05 02:35:54 +03:00
|
|
|
return TemplateArgumentLoc();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// \brief Convert the given deduced template argument and add it to the set of
|
|
|
|
/// fully-converted template arguments.
|
2011-01-27 10:10:08 +03:00
|
|
|
static bool ConvertDeducedTemplateArgument(Sema &S, NamedDecl *Param,
|
2011-01-05 02:35:54 +03:00
|
|
|
DeducedTemplateArgument Arg,
|
2011-01-27 10:10:08 +03:00
|
|
|
NamedDecl *Template,
|
|
|
|
QualType NTTPType,
|
2011-01-19 23:10:05 +03:00
|
|
|
unsigned ArgumentPackIndex,
|
2011-01-05 02:35:54 +03:00
|
|
|
TemplateDeductionInfo &Info,
|
|
|
|
bool InFunctionTemplate,
|
|
|
|
llvm::SmallVectorImpl<TemplateArgument> &Output) {
|
|
|
|
if (Arg.getKind() == TemplateArgument::Pack) {
|
|
|
|
// This is a template argument pack, so check each of its arguments against
|
|
|
|
// the template parameter.
|
|
|
|
llvm::SmallVector<TemplateArgument, 2> PackedArgsBuilder;
|
2011-01-27 10:10:08 +03:00
|
|
|
for (TemplateArgument::pack_iterator PA = Arg.pack_begin(),
|
2011-01-06 00:00:53 +03:00
|
|
|
PAEnd = Arg.pack_end();
|
2011-01-05 02:35:54 +03:00
|
|
|
PA != PAEnd; ++PA) {
|
2011-01-05 23:52:18 +03: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.
|
2011-01-05 02:35:54 +03:00
|
|
|
DeducedTemplateArgument InnerArg(*PA);
|
|
|
|
InnerArg.setDeducedFromArrayBound(Arg.wasDeducedFromArrayBound());
|
2011-01-27 10:10:08 +03:00
|
|
|
if (ConvertDeducedTemplateArgument(S, Param, InnerArg, Template,
|
2011-01-19 23:10:05 +03:00
|
|
|
NTTPType, PackedArgsBuilder.size(),
|
|
|
|
Info, InFunctionTemplate, Output))
|
2011-01-05 02:35:54 +03:00
|
|
|
return true;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-05 23:52:18 +03:00
|
|
|
// Move the converted template argument into our argument pack.
|
|
|
|
PackedArgsBuilder.push_back(Output.back());
|
|
|
|
Output.pop_back();
|
2011-01-05 02:35:54 +03:00
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-05 02:35:54 +03:00
|
|
|
// Create the resulting argument pack.
|
2011-01-27 10:10:08 +03:00
|
|
|
Output.push_back(TemplateArgument::CreatePackCopy(S.Context,
|
2011-01-12 02:09:57 +03:00
|
|
|
PackedArgsBuilder.data(),
|
|
|
|
PackedArgsBuilder.size()));
|
2011-01-05 02:35:54 +03:00
|
|
|
return false;
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-05 02:35:54 +03:00
|
|
|
// Convert the deduced template argument into a template
|
|
|
|
// argument that we can check, almost as if the user had written
|
|
|
|
// the template argument explicitly.
|
|
|
|
TemplateArgumentLoc ArgLoc = getTrivialTemplateArgumentLoc(S, Arg, NTTPType,
|
|
|
|
Info.getLocation());
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-05 02:35:54 +03:00
|
|
|
// Check the template argument, converting it as necessary.
|
|
|
|
return S.CheckTemplateArgument(Param, ArgLoc,
|
|
|
|
Template,
|
|
|
|
Template->getLocation(),
|
|
|
|
Template->getSourceRange().getEnd(),
|
2011-01-19 23:10:05 +03:00
|
|
|
ArgumentPackIndex,
|
2011-01-05 02:35:54 +03:00
|
|
|
Output,
|
|
|
|
InFunctionTemplate
|
|
|
|
? (Arg.wasDeducedFromArrayBound()
|
2011-01-27 10:10:08 +03:00
|
|
|
? Sema::CTAK_DeducedFromArrayBound
|
2011-01-05 02:35:54 +03:00
|
|
|
: Sema::CTAK_Deduced)
|
|
|
|
: Sema::CTAK_Specified);
|
|
|
|
}
|
|
|
|
|
2010-04-29 10:21:43 +04:00
|
|
|
/// Complete template argument deduction for a class template partial
|
|
|
|
/// specialization.
|
|
|
|
static Sema::TemplateDeductionResult
|
2011-01-27 10:10:08 +03:00
|
|
|
FinishTemplateArgumentDeduction(Sema &S,
|
2010-04-29 10:21:43 +04:00
|
|
|
ClassTemplatePartialSpecializationDecl *Partial,
|
|
|
|
const TemplateArgumentList &TemplateArgs,
|
|
|
|
llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced,
|
2010-08-25 09:32:35 +04:00
|
|
|
TemplateDeductionInfo &Info) {
|
2010-04-29 10:21:43 +04:00
|
|
|
// Trap errors.
|
|
|
|
Sema::SFINAETrap Trap(S);
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-04-29 10:21:43 +04:00
|
|
|
Sema::ContextRAII SavedContext(S, Partial);
|
2010-04-29 04:35:03 +04:00
|
|
|
|
2009-06-11 22:10:32 +04:00
|
|
|
// C++ [temp.deduct.type]p2:
|
|
|
|
// [...] or if any template argument remains neither deduced nor
|
|
|
|
// explicitly specified, template argument deduction fails.
|
2010-11-08 02:05:16 +03:00
|
|
|
llvm::SmallVector<TemplateArgument, 4> Builder;
|
2011-01-05 01:23:38 +03:00
|
|
|
TemplateParameterList *PartialParams = Partial->getTemplateParameters();
|
|
|
|
for (unsigned I = 0, N = PartialParams->size(); I != N; ++I) {
|
2011-01-05 02:35:54 +03:00
|
|
|
NamedDecl *Param = PartialParams->getParam(I);
|
2009-06-12 22:26:56 +04:00
|
|
|
if (Deduced[I].isNull()) {
|
2011-01-05 02:35:54 +03:00
|
|
|
Info.Param = makeTemplateParameter(Param);
|
2010-04-29 10:21:43 +04:00
|
|
|
return Sema::TDK_Incomplete;
|
2009-06-12 22:26:56 +04:00
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-05 02:35:54 +03:00
|
|
|
// We have deduced this argument, so it still needs to be
|
|
|
|
// checked and converted.
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-05 02:35:54 +03: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;
|
2011-01-27 10:10:08 +03:00
|
|
|
if (NonTypeTemplateParmDecl *NTTP
|
2011-01-05 23:52:18 +03:00
|
|
|
= dyn_cast<NonTypeTemplateParmDecl>(Param)) {
|
2011-01-05 02:35:54 +03:00
|
|
|
NTTPType = NTTP->getType();
|
2011-01-05 23:52:18 +03:00
|
|
|
if (NTTPType->isDependentType()) {
|
2011-01-27 10:10:08 +03:00
|
|
|
TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack,
|
2011-01-05 23:52:18 +03:00
|
|
|
Builder.data(), Builder.size());
|
|
|
|
NTTPType = S.SubstType(NTTPType,
|
|
|
|
MultiLevelTemplateArgumentList(TemplateArgs),
|
|
|
|
NTTP->getLocation(),
|
|
|
|
NTTP->getDeclName());
|
|
|
|
if (NTTPType.isNull()) {
|
|
|
|
Info.Param = makeTemplateParameter(Param);
|
|
|
|
// FIXME: These template arguments are temporary. Free them!
|
2011-01-27 10:10:08 +03:00
|
|
|
Info.reset(TemplateArgumentList::CreateCopy(S.Context,
|
|
|
|
Builder.data(),
|
2011-01-05 23:52:18 +03:00
|
|
|
Builder.size()));
|
|
|
|
return Sema::TDK_SubstitutionFailure;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-01-05 02:35:54 +03:00
|
|
|
if (ConvertDeducedTemplateArgument(S, Param, Deduced[I],
|
2011-01-19 23:10:05 +03:00
|
|
|
Partial, NTTPType, 0, Info, false,
|
2011-01-05 02:35:54 +03:00
|
|
|
Builder)) {
|
|
|
|
Info.Param = makeTemplateParameter(Param);
|
|
|
|
// FIXME: These template arguments are temporary. Free them!
|
2011-01-27 10:10:08 +03:00
|
|
|
Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder.data(),
|
|
|
|
Builder.size()));
|
2011-01-05 02:35:54 +03:00
|
|
|
return Sema::TDK_SubstitutionFailure;
|
|
|
|
}
|
2009-06-11 22:10:32 +04:00
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-06-11 22:10:32 +04:00
|
|
|
// Form the template argument list from the deduced template arguments.
|
2009-09-09 19:08:12 +04:00
|
|
|
TemplateArgumentList *DeducedArgumentList
|
2011-01-27 10:10:08 +03:00
|
|
|
= TemplateArgumentList::CreateCopy(S.Context, Builder.data(),
|
2010-11-08 02:05:16 +03:00
|
|
|
Builder.size());
|
|
|
|
|
2009-06-12 22:26:56 +04:00
|
|
|
Info.reset(DeducedArgumentList);
|
2009-06-11 22:10:32 +04: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 19:08:12 +04:00
|
|
|
// to the class template.
|
2010-08-25 09:32:35 +04:00
|
|
|
LocalInstantiationScope InstScope(S);
|
2009-06-11 22:10:32 +04:00
|
|
|
ClassTemplateDecl *ClassTemplate = Partial->getSpecializedTemplate();
|
2009-10-29 11:12:44 +03:00
|
|
|
const TemplateArgumentLoc *PartialTemplateArgs
|
|
|
|
= Partial->getTemplateArgsAsWritten();
|
2009-11-23 04:53:49 +03:00
|
|
|
|
|
|
|
// Note that we don't provide the langle and rangle locations.
|
|
|
|
TemplateArgumentListInfo InstArgs;
|
|
|
|
|
2010-12-23 00:19:48 +03:00
|
|
|
if (S.Subst(PartialTemplateArgs,
|
|
|
|
Partial->getNumTemplateArgsAsWritten(),
|
|
|
|
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 11:12:44 +03:00
|
|
|
}
|
|
|
|
|
2010-11-08 02:05:16 +03:00
|
|
|
llvm::SmallVector<TemplateArgument, 4> ConvertedInstArgs;
|
2010-04-29 10:21:43 +04:00
|
|
|
if (S.CheckTemplateArgumentList(ClassTemplate, Partial->getLocation(),
|
2011-01-05 02:35:54 +03:00
|
|
|
InstArgs, false, ConvertedInstArgs))
|
2010-04-29 10:21:43 +04:00
|
|
|
return Sema::TDK_SubstitutionFailure;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-05 02:35:54 +03:00
|
|
|
TemplateParameterList *TemplateParams
|
|
|
|
= ClassTemplate->getTemplateParameters();
|
|
|
|
for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) {
|
2010-11-08 02:05:16 +03:00
|
|
|
TemplateArgument InstArg = ConvertedInstArgs.data()[I];
|
2010-04-29 10:21:43 +04:00
|
|
|
if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg)) {
|
2011-01-05 03:13:17 +03:00
|
|
|
Info.Param = makeTemplateParameter(TemplateParams->getParam(I));
|
2009-06-27 00:57:09 +04:00
|
|
|
Info.FirstArg = TemplateArgs[I];
|
|
|
|
Info.SecondArg = InstArg;
|
2010-04-29 10:21:43 +04:00
|
|
|
return Sema::TDK_NonDeducedMismatch;
|
2009-06-27 00:57:09 +04:00
|
|
|
}
|
2009-06-11 22:10:32 +04:00
|
|
|
}
|
|
|
|
|
2009-06-14 12:02:22 +04:00
|
|
|
if (Trap.hasErrorOccurred())
|
2010-04-29 10:21:43 +04:00
|
|
|
return Sema::TDK_SubstitutionFailure;
|
2009-06-14 12:02:22 +04:00
|
|
|
|
2010-04-29 10:21:43 +04:00
|
|
|
return Sema::TDK_Success;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief Perform template argument deduction to determine whether
|
|
|
|
/// the given template arguments match the given class template
|
|
|
|
/// partial specialization per C++ [temp.class.spec.match].
|
|
|
|
Sema::TemplateDeductionResult
|
|
|
|
Sema::DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial,
|
|
|
|
const TemplateArgumentList &TemplateArgs,
|
|
|
|
TemplateDeductionInfo &Info) {
|
|
|
|
// 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).
|
|
|
|
SFINAETrap Trap(*this);
|
|
|
|
llvm::SmallVector<DeducedTemplateArgument, 4> Deduced;
|
|
|
|
Deduced.resize(Partial->getTemplateParameters()->size());
|
|
|
|
if (TemplateDeductionResult Result
|
|
|
|
= ::DeduceTemplateArguments(*this,
|
|
|
|
Partial->getTemplateParameters(),
|
|
|
|
Partial->getTemplateArgs(),
|
|
|
|
TemplateArgs, Info, Deduced))
|
|
|
|
return Result;
|
|
|
|
|
|
|
|
InstantiatingTemplate Inst(*this, Partial->getLocation(), Partial,
|
2010-10-13 03:32:35 +04:00
|
|
|
Deduced.data(), Deduced.size(), Info);
|
2010-04-29 10:21:43 +04:00
|
|
|
if (Inst)
|
|
|
|
return TDK_InstantiationDepth;
|
|
|
|
|
|
|
|
if (Trap.hasErrorOccurred())
|
|
|
|
return Sema::TDK_SubstitutionFailure;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
|
|
|
return ::FinishTemplateArgumentDeduction(*this, Partial, TemplateArgs,
|
2010-04-29 10:21:43 +04:00
|
|
|
Deduced, Info);
|
2009-06-04 04:03:07 +04:00
|
|
|
}
|
2009-06-13 04:26:55 +04:00
|
|
|
|
2009-06-27 03:27:24 +04:00
|
|
|
/// \brief Determine whether the given type T is a simple-template-id type.
|
|
|
|
static bool isSimpleTemplateIdType(QualType T) {
|
2009-09-09 19:08:12 +04:00
|
|
|
if (const TemplateSpecializationType *Spec
|
2009-09-22 03:43:11 +04:00
|
|
|
= T->getAs<TemplateSpecializationType>())
|
2009-06-27 03:27:24 +04:00
|
|
|
return Spec->getTemplateName().getAsTemplateDecl() != 0;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-06-27 03:27:24 +04:00
|
|
|
return false;
|
|
|
|
}
|
2009-07-09 00:55:45 +04: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.
|
|
|
|
///
|
2009-09-09 19:08:12 +04:00
|
|
|
/// \param ExplicitTemplateArguments the explicitly-specified template
|
2009-07-09 00:55:45 +04:00
|
|
|
/// arguments.
|
|
|
|
///
|
2009-09-09 19:08:12 +04:00
|
|
|
/// \param Deduced the deduced template arguments, which will be populated
|
2009-07-09 00:55:45 +04:00
|
|
|
/// with the converted and checked explicit template arguments.
|
|
|
|
///
|
2009-09-09 19:08:12 +04:00
|
|
|
/// \param ParamTypes will be populated with the instantiated function
|
2009-07-09 00:55:45 +04: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 05:41:12 +03:00
|
|
|
TemplateArgumentListInfo &ExplicitTemplateArgs,
|
2010-03-28 06:42:43 +04:00
|
|
|
llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced,
|
2009-07-09 00:55:45 +04:00
|
|
|
llvm::SmallVectorImpl<QualType> &ParamTypes,
|
|
|
|
QualType *FunctionType,
|
|
|
|
TemplateDeductionInfo &Info) {
|
|
|
|
FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
|
|
|
|
TemplateParameterList *TemplateParams
|
|
|
|
= FunctionTemplate->getTemplateParameters();
|
|
|
|
|
2009-11-23 04:53:49 +03:00
|
|
|
if (ExplicitTemplateArgs.size() == 0) {
|
2009-07-09 00:55:45 +04:00
|
|
|
// No arguments to substitute; just copy over the parameter types and
|
|
|
|
// fill in the function type.
|
|
|
|
for (FunctionDecl::param_iterator P = Function->param_begin(),
|
|
|
|
PEnd = Function->param_end();
|
|
|
|
P != PEnd;
|
|
|
|
++P)
|
|
|
|
ParamTypes.push_back((*P)->getType());
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-07-09 00:55:45 +04:00
|
|
|
if (FunctionType)
|
|
|
|
*FunctionType = Function->getType();
|
|
|
|
return TDK_Success;
|
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-07-09 00:55:45 +04:00
|
|
|
// Substitution of the explicit template arguments into a function template
|
|
|
|
/// is a SFINAE context. Trap any errors that might occur.
|
2009-09-09 19:08:12 +04:00
|
|
|
SFINAETrap Trap(*this);
|
|
|
|
|
2009-07-09 00:55:45 +04:00
|
|
|
// C++ [temp.arg.explicit]p3:
|
2009-09-09 19:08:12 +04:00
|
|
|
// Template arguments that are present shall be specified in the
|
|
|
|
// declaration order of their corresponding template-parameters. The
|
2009-07-09 00:55:45 +04:00
|
|
|
// template argument list shall not specify more template-arguments than
|
2009-09-09 19:08:12 +04:00
|
|
|
// there are corresponding template-parameters.
|
2010-11-08 02:05:16 +03:00
|
|
|
llvm::SmallVector<TemplateArgument, 4> Builder;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
|
|
|
// Enter a new template instantiation context where we check the
|
2009-07-09 00:55:45 +04:00
|
|
|
// explicitly-specified template arguments against this function template,
|
|
|
|
// and then substitute them into the function parameter types.
|
2009-09-09 19:08:12 +04:00
|
|
|
InstantiatingTemplate Inst(*this, FunctionTemplate->getLocation(),
|
2009-07-09 00:55:45 +04:00
|
|
|
FunctionTemplate, Deduced.data(), Deduced.size(),
|
2010-10-13 03:32:35 +04:00
|
|
|
ActiveTemplateInstantiation::ExplicitTemplateArgumentSubstitution,
|
|
|
|
Info);
|
2009-07-09 00:55:45 +04:00
|
|
|
if (Inst)
|
|
|
|
return TDK_InstantiationDepth;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-07-09 00:55:45 +04:00
|
|
|
if (CheckTemplateArgumentList(FunctionTemplate,
|
|
|
|
SourceLocation(),
|
2009-11-23 04:53:49 +03:00
|
|
|
ExplicitTemplateArgs,
|
2009-07-09 00:55:45 +04:00
|
|
|
true,
|
2010-05-08 23:15:54 +04:00
|
|
|
Builder) || Trap.hasErrorOccurred()) {
|
2010-11-08 02:05:16 +03:00
|
|
|
unsigned Index = Builder.size();
|
2010-05-09 05:26:06 +04:00
|
|
|
if (Index >= TemplateParams->size())
|
|
|
|
Index = TemplateParams->size() - 1;
|
|
|
|
Info.Param = makeTemplateParameter(TemplateParams->getParam(Index));
|
2009-07-09 00:55:45 +04:00
|
|
|
return TDK_InvalidExplicitArguments;
|
2010-05-08 23:15:54 +04:00
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-07-09 00:55:45 +04:00
|
|
|
// Form the template argument list from the explicitly-specified
|
|
|
|
// template arguments.
|
2009-09-09 19:08:12 +04:00
|
|
|
TemplateArgumentList *ExplicitArgumentList
|
2010-11-08 02:05:16 +03:00
|
|
|
= TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size());
|
2009-07-09 00:55:45 +04:00
|
|
|
Info.reset(ExplicitArgumentList);
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-10-12 23:40:14 +04: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 10:10:08 +03: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.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@123163 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-10 10:32:04 +03: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 10:10:08 +03: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.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@123163 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-10 10:32:04 +03:00
|
|
|
Arg.pack_begin(),
|
|
|
|
Arg.pack_size());
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-09 00:55:45 +04:00
|
|
|
// Instantiate the types of each of the function parameters given the
|
|
|
|
// explicitly-specified template arguments.
|
2011-01-27 10:10:08 +03:00
|
|
|
if (SubstParmTypes(Function->getLocation(),
|
2011-01-07 03:20:55 +03:00
|
|
|
Function->param_begin(), Function->getNumParams(),
|
|
|
|
MultiLevelTemplateArgumentList(*ExplicitArgumentList),
|
|
|
|
ParamTypes))
|
|
|
|
return TDK_SubstitutionFailure;
|
2009-07-09 00:55:45 +04:00
|
|
|
|
|
|
|
// If the caller wants a full function type back, instantiate the return
|
|
|
|
// type and form that function type.
|
|
|
|
if (FunctionType) {
|
|
|
|
// FIXME: exception-specifications?
|
2009-09-09 19:08:12 +04:00
|
|
|
const FunctionProtoType *Proto
|
2009-09-22 03:43:11 +04:00
|
|
|
= Function->getType()->getAs<FunctionProtoType>();
|
2009-07-09 00:55:45 +04:00
|
|
|
assert(Proto && "Function template does not have a prototype?");
|
2009-09-09 19:08:12 +04:00
|
|
|
|
|
|
|
QualType ResultType
|
2009-08-29 00:50:45 +04:00
|
|
|
= SubstType(Proto->getResultType(),
|
|
|
|
MultiLevelTemplateArgumentList(*ExplicitArgumentList),
|
|
|
|
Function->getTypeSpecStartLoc(),
|
|
|
|
Function->getDeclName());
|
2009-07-09 00:55:45 +04:00
|
|
|
if (ResultType.isNull() || Trap.hasErrorOccurred())
|
|
|
|
return TDK_SubstitutionFailure;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
|
|
|
*FunctionType = BuildFunctionType(ResultType,
|
2009-07-09 00:55:45 +04:00
|
|
|
ParamTypes.data(), ParamTypes.size(),
|
|
|
|
Proto->isVariadic(),
|
|
|
|
Proto->getTypeQuals(),
|
2011-01-26 08:01:58 +03:00
|
|
|
Proto->getRefQualifier(),
|
2009-07-09 00:55:45 +04:00
|
|
|
Function->getLocation(),
|
2010-08-05 06:54:05 +04:00
|
|
|
Function->getDeclName(),
|
|
|
|
Proto->getExtInfo());
|
2009-07-09 00:55:45 +04:00
|
|
|
if (FunctionType->isNull() || Trap.hasErrorOccurred())
|
|
|
|
return TDK_SubstitutionFailure;
|
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-07-09 00:55:45 +04:00
|
|
|
// C++ [temp.arg.explicit]p2:
|
2009-09-09 19:08:12 +04: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 00:55:45 +04: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.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@123163 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-10 10:32:04 +03: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 00:55:45 +04: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.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@123163 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-10 10:32:04 +03: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 19:08:12 +04:00
|
|
|
|
2009-07-09 00:55:45 +04:00
|
|
|
return TDK_Success;
|
|
|
|
}
|
|
|
|
|
2009-09-09 19:08:12 +04:00
|
|
|
/// \brief Finish template argument deduction for a function template,
|
2009-07-09 00:55:45 +04:00
|
|
|
/// checking the deduced template arguments for completeness and forming
|
|
|
|
/// the function template specialization.
|
2011-06-16 20:50:48 +04:00
|
|
|
///
|
|
|
|
/// \param OriginalCallArgs If non-NULL, the original call arguments against
|
|
|
|
/// which the deduced argument types should be compared.
|
2009-09-09 19:08:12 +04:00
|
|
|
Sema::TemplateDeductionResult
|
2009-07-09 00:55:45 +04:00
|
|
|
Sema::FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate,
|
2010-03-28 06:42:43 +04:00
|
|
|
llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced,
|
|
|
|
unsigned NumExplicitlySpecified,
|
2009-07-09 00:55:45 +04:00
|
|
|
FunctionDecl *&Specialization,
|
2011-06-16 20:50:48 +04:00
|
|
|
TemplateDeductionInfo &Info,
|
|
|
|
llvm::SmallVectorImpl<OriginalCallArg> const *OriginalCallArgs) {
|
2009-07-09 00:55:45 +04:00
|
|
|
TemplateParameterList *TemplateParams
|
|
|
|
= FunctionTemplate->getTemplateParameters();
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-11-25 21:55:14 +03:00
|
|
|
// Template argument deduction for function templates in a SFINAE context.
|
|
|
|
// Trap any errors that might occur.
|
|
|
|
SFINAETrap Trap(*this);
|
|
|
|
|
|
|
|
// Enter a new template instantiation context while we instantiate the
|
|
|
|
// actual function declaration.
|
|
|
|
InstantiatingTemplate Inst(*this, FunctionTemplate->getLocation(),
|
|
|
|
FunctionTemplate, Deduced.data(), Deduced.size(),
|
2010-10-13 03:32:35 +04:00
|
|
|
ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution,
|
|
|
|
Info);
|
2009-11-25 21:55:14 +03:00
|
|
|
if (Inst)
|
|
|
|
return TDK_InstantiationDepth;
|
|
|
|
|
2010-04-29 05:18:58 +04:00
|
|
|
ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl());
|
2010-04-29 04:35:03 +04:00
|
|
|
|
2009-07-09 00:55:45 +04:00
|
|
|
// C++ [temp.deduct.type]p2:
|
|
|
|
// [...] or if any template argument remains neither deduced nor
|
|
|
|
// explicitly specified, template argument deduction fails.
|
2010-11-08 02:05:16 +03:00
|
|
|
llvm::SmallVector<TemplateArgument, 4> Builder;
|
2011-01-05 01:13:36 +03:00
|
|
|
for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
|
|
|
|
NamedDecl *Param = TemplateParams->getParam(I);
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-11-25 21:55:14 +03:00
|
|
|
if (!Deduced[I].isNull()) {
|
2010-10-12 22:51:08 +04:00
|
|
|
if (I < NumExplicitlySpecified) {
|
2010-03-28 06:42:43 +04:00
|
|
|
// We have already fully type-checked and converted this
|
2011-01-27 10:10:08 +03:00
|
|
|
// argument, because it was explicitly-specified. Just record the
|
2010-10-12 22:51:08 +04:00
|
|
|
// presence of this argument.
|
2010-11-08 02:05:16 +03:00
|
|
|
Builder.push_back(Deduced[I]);
|
2010-03-28 06:42:43 +04:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// We have deduced this argument, so it still needs to be
|
|
|
|
// checked and converted.
|
|
|
|
|
|
|
|
// First, for a non-type template parameter type that is
|
|
|
|
// initialized by a declaration, we need the type of the
|
|
|
|
// corresponding non-type template parameter.
|
|
|
|
QualType NTTPType;
|
2011-01-27 10:10:08 +03:00
|
|
|
if (NonTypeTemplateParmDecl *NTTP
|
|
|
|
= dyn_cast<NonTypeTemplateParmDecl>(Param)) {
|
2011-01-05 01:13:36 +03:00
|
|
|
NTTPType = NTTP->getType();
|
|
|
|
if (NTTPType->isDependentType()) {
|
2011-01-27 10:10:08 +03:00
|
|
|
TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack,
|
2011-01-05 01:13:36 +03:00
|
|
|
Builder.data(), Builder.size());
|
|
|
|
NTTPType = SubstType(NTTPType,
|
|
|
|
MultiLevelTemplateArgumentList(TemplateArgs),
|
|
|
|
NTTP->getLocation(),
|
|
|
|
NTTP->getDeclName());
|
|
|
|
if (NTTPType.isNull()) {
|
|
|
|
Info.Param = makeTemplateParameter(Param);
|
|
|
|
// FIXME: These template arguments are temporary. Free them!
|
2011-01-27 10:10:08 +03:00
|
|
|
Info.reset(TemplateArgumentList::CreateCopy(Context,
|
|
|
|
Builder.data(),
|
2011-01-05 01:13:36 +03:00
|
|
|
Builder.size()));
|
|
|
|
return TDK_SubstitutionFailure;
|
2010-03-28 06:42:43 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-01-05 01:13:36 +03:00
|
|
|
if (ConvertDeducedTemplateArgument(*this, Param, Deduced[I],
|
2011-01-19 23:10:05 +03:00
|
|
|
FunctionTemplate, NTTPType, 0, Info,
|
2011-01-05 02:35:54 +03:00
|
|
|
true, Builder)) {
|
2011-01-05 01:13:36 +03:00
|
|
|
Info.Param = makeTemplateParameter(Param);
|
2010-11-08 02:05:16 +03:00
|
|
|
// FIXME: These template arguments are temporary. Free them!
|
2011-01-27 10:10:08 +03:00
|
|
|
Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(),
|
|
|
|
Builder.size()));
|
2010-03-28 06:42:43 +04:00
|
|
|
return TDK_SubstitutionFailure;
|
|
|
|
}
|
|
|
|
|
2009-11-25 21:55:14 +03:00
|
|
|
continue;
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 04:52:01 +03:00
|
|
|
// C++0x [temp.arg.explicit]p3:
|
2011-01-27 10:10:08 +03:00
|
|
|
// A trailing template parameter pack (14.5.3) not otherwise deduced will
|
2010-12-23 04:52:01 +03: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.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@123163 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-10 10:32:04 +03: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;
|
|
|
|
if (CurrentInstantiationScope->getPartiallySubstitutedPack(&ExplicitArgs,
|
|
|
|
&NumExplicitArgs)
|
|
|
|
== Param)
|
|
|
|
Builder.push_back(TemplateArgument(ExplicitArgs, NumExplicitArgs));
|
2011-01-27 10:10:08 +03:00
|
|
|
else
|
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.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@123163 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-10 10:32:04 +03:00
|
|
|
Builder.push_back(TemplateArgument(0, 0));
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 04:52:01 +03:00
|
|
|
continue;
|
|
|
|
}
|
2009-11-25 21:55:14 +03:00
|
|
|
|
2011-01-27 10:10:08 +03:00
|
|
|
// Substitute into the default template argument, if available.
|
2009-11-25 21:55:14 +03:00
|
|
|
TemplateArgumentLoc DefArg
|
|
|
|
= SubstDefaultTemplateArgumentIfAvailable(FunctionTemplate,
|
|
|
|
FunctionTemplate->getLocation(),
|
|
|
|
FunctionTemplate->getSourceRange().getEnd(),
|
|
|
|
Param,
|
|
|
|
Builder);
|
|
|
|
|
|
|
|
// If there was no default argument, deduction is incomplete.
|
|
|
|
if (DefArg.getArgument().isNull()) {
|
2009-07-09 00:55:45 +04:00
|
|
|
Info.Param = makeTemplateParameter(
|
2009-11-25 21:55:14 +03:00
|
|
|
const_cast<NamedDecl *>(TemplateParams->getParam(I)));
|
2009-07-09 00:55:45 +04:00
|
|
|
return TDK_Incomplete;
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-11-25 21:55:14 +03:00
|
|
|
// Check whether we can actually use the default argument.
|
|
|
|
if (CheckTemplateArgument(Param, DefArg,
|
|
|
|
FunctionTemplate,
|
|
|
|
FunctionTemplate->getLocation(),
|
|
|
|
FunctionTemplate->getSourceRange().getEnd(),
|
2011-01-19 23:10:05 +03:00
|
|
|
0, Builder,
|
2011-06-03 06:59:40 +04:00
|
|
|
CTAK_Specified)) {
|
2009-11-25 21:55:14 +03:00
|
|
|
Info.Param = makeTemplateParameter(
|
|
|
|
const_cast<NamedDecl *>(TemplateParams->getParam(I)));
|
2010-11-08 02:05:16 +03:00
|
|
|
// FIXME: These template arguments are temporary. Free them!
|
2011-01-27 10:10:08 +03:00
|
|
|
Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(),
|
2010-11-08 02:05:16 +03:00
|
|
|
Builder.size()));
|
2009-11-25 21:55:14 +03:00
|
|
|
return TDK_SubstitutionFailure;
|
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-11-25 21:55:14 +03:00
|
|
|
// If we get here, we successfully used the default template argument.
|
2009-07-09 00:55:45 +04:00
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-07-09 00:55:45 +04:00
|
|
|
// Form the template argument list from the deduced template arguments.
|
2009-09-09 19:08:12 +04:00
|
|
|
TemplateArgumentList *DeducedArgumentList
|
2010-11-08 02:05:16 +03:00
|
|
|
= TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size());
|
2009-07-09 00:55:45 +04:00
|
|
|
Info.reset(DeducedArgumentList);
|
2009-09-09 19:08:12 +04:00
|
|
|
|
|
|
|
// Substitute the deduced template arguments into the function template
|
2009-07-09 00:55:45 +04:00
|
|
|
// declaration to produce the function template specialization.
|
2010-04-28 08:52:24 +04:00
|
|
|
DeclContext *Owner = FunctionTemplate->getDeclContext();
|
|
|
|
if (FunctionTemplate->getFriendObjectKind())
|
|
|
|
Owner = FunctionTemplate->getLexicalDeclContext();
|
2009-07-09 00:55:45 +04:00
|
|
|
Specialization = cast_or_null<FunctionDecl>(
|
2010-04-28 08:52:24 +04:00
|
|
|
SubstDecl(FunctionTemplate->getTemplatedDecl(), Owner,
|
2009-08-29 00:50:45 +04:00
|
|
|
MultiLevelTemplateArgumentList(*DeducedArgumentList)));
|
2009-07-09 00:55:45 +04:00
|
|
|
if (!Specialization)
|
|
|
|
return TDK_SubstitutionFailure;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2011-01-27 10:10:08 +03:00
|
|
|
assert(Specialization->getPrimaryTemplate()->getCanonicalDecl() ==
|
2009-09-15 22:26:13 +04:00
|
|
|
FunctionTemplate->getCanonicalDecl());
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-09-09 19:08:12 +04:00
|
|
|
// If the template argument list is owned by the function template
|
2009-07-09 00:55:45 +04:00
|
|
|
// specialization, release it.
|
2010-05-09 00:07:26 +04:00
|
|
|
if (Specialization->getTemplateSpecializationArgs() == DeducedArgumentList &&
|
|
|
|
!Trap.hasErrorOccurred())
|
2009-07-09 00:55:45 +04:00
|
|
|
Info.take();
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2011-06-16 20:50:48 +04:00
|
|
|
if (OriginalCallArgs) {
|
|
|
|
// C++ [temp.deduct.call]p4:
|
|
|
|
// In general, the deduction process attempts to find template argument
|
|
|
|
// values that will make the deduced A identical to A (after the type A
|
|
|
|
// is transformed as described above). [...]
|
|
|
|
for (unsigned I = 0, N = OriginalCallArgs->size(); I != N; ++I) {
|
|
|
|
OriginalCallArg OriginalArg = (*OriginalCallArgs)[I];
|
|
|
|
QualType A = OriginalArg.OriginalArgType;
|
|
|
|
unsigned ParamIdx = OriginalArg.ArgIdx;
|
|
|
|
|
|
|
|
if (ParamIdx >= Specialization->getNumParams())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
QualType DeducedA = Specialization->getParamDecl(ParamIdx)->getType();
|
|
|
|
QualType OriginalParamType = OriginalArg.OriginalParamType;
|
|
|
|
|
|
|
|
// Check for type equality (top-level cv-qualifiers are ignored).
|
|
|
|
if (Context.hasSameUnqualifiedType(A, DeducedA))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Strip off references on the argument types; they aren't needed for
|
|
|
|
// the following checks.
|
|
|
|
if (const ReferenceType *DeducedARef = DeducedA->getAs<ReferenceType>())
|
|
|
|
DeducedA = DeducedARef->getPointeeType();
|
|
|
|
if (const ReferenceType *ARef = A->getAs<ReferenceType>())
|
|
|
|
A = ARef->getPointeeType();
|
|
|
|
|
|
|
|
// C++ [temp.deduct.call]p4:
|
|
|
|
// [...] However, there are three cases that allow a difference:
|
|
|
|
// - If the original P is a reference type, the deduced A (i.e., the
|
|
|
|
// type referred to by the reference) can be more cv-qualified than
|
|
|
|
// the transformed A.
|
|
|
|
if (const ReferenceType *OriginalParamRef
|
|
|
|
= OriginalParamType->getAs<ReferenceType>()) {
|
|
|
|
// We don't want to keep the reference around any more.
|
|
|
|
OriginalParamType = OriginalParamRef->getPointeeType();
|
|
|
|
|
|
|
|
Qualifiers AQuals = A.getQualifiers();
|
|
|
|
Qualifiers DeducedAQuals = DeducedA.getQualifiers();
|
|
|
|
if (AQuals == DeducedAQuals) {
|
|
|
|
// Qualifiers match; there's nothing to do.
|
|
|
|
} else if (!DeducedAQuals.compatiblyIncludes(AQuals)) {
|
|
|
|
return Sema::TDK_SubstitutionFailure;
|
|
|
|
} else {
|
|
|
|
// Qualifiers are compatible, so have the argument type adopt the
|
|
|
|
// deduced argument type's qualifiers as if we had performed the
|
|
|
|
// qualification conversion.
|
|
|
|
A = Context.getQualifiedType(A.getUnqualifiedType(), DeducedAQuals);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// - The transformed A can be another pointer or pointer to member
|
|
|
|
// type that can be converted to the deduced A via a qualification
|
|
|
|
// conversion.
|
|
|
|
bool ObjCLifetimeConversion = false;
|
|
|
|
if ((A->isAnyPointerType() || A->isMemberPointerType()) &&
|
|
|
|
IsQualificationConversion(A, DeducedA, false, ObjCLifetimeConversion))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
|
|
// - If P is a class and P has the form simple-template-id, then the
|
|
|
|
// transformed A can be a derived class of the deduced A. [...]
|
|
|
|
// [...] Likewise, if P is a pointer to a class of the form
|
|
|
|
// simple-template-id, the transformed A can be a pointer to a
|
|
|
|
// derived class pointed to by the deduced A.
|
|
|
|
if (const PointerType *OriginalParamPtr
|
|
|
|
= OriginalParamType->getAs<PointerType>()) {
|
|
|
|
if (const PointerType *DeducedAPtr = DeducedA->getAs<PointerType>()) {
|
|
|
|
if (const PointerType *APtr = A->getAs<PointerType>()) {
|
|
|
|
if (A->getPointeeType()->isRecordType()) {
|
|
|
|
OriginalParamType = OriginalParamPtr->getPointeeType();
|
|
|
|
DeducedA = DeducedAPtr->getPointeeType();
|
|
|
|
A = APtr->getPointeeType();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Context.hasSameUnqualifiedType(A, DeducedA))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (A->isRecordType() && isSimpleTemplateIdType(OriginalParamType) &&
|
|
|
|
IsDerivedFrom(A, DeducedA))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
return Sema::TDK_SubstitutionFailure;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-09 00:55:45 +04: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;
|
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2010-10-13 03:32:35 +04: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()) {
|
|
|
|
llvm::DenseMap<Decl *, llvm::SmallVector<PartialDiagnosticAt, 1> >::iterator
|
|
|
|
Pos = SuppressedDiagnostics.find(Specialization->getCanonicalDecl());
|
|
|
|
if (Pos == SuppressedDiagnostics.end())
|
|
|
|
SuppressedDiagnostics[Specialization->getCanonicalDecl()]
|
|
|
|
.append(Info.diag_begin(), Info.diag_end());
|
2011-01-27 10:10:08 +03:00
|
|
|
}
|
2010-10-13 03:32:35 +04:00
|
|
|
|
2009-09-09 19:08:12 +04:00
|
|
|
return TDK_Success;
|
2009-07-09 00:55:45 +04:00
|
|
|
}
|
|
|
|
|
2010-08-27 13:08:28 +04:00
|
|
|
/// Gets the type of a function for template-argument-deducton
|
|
|
|
/// purposes when it's considered as part of an overload set.
|
2010-02-02 05:21:27 +03:00
|
|
|
static QualType GetTypeOfFunction(ASTContext &Context,
|
2010-08-27 13:08:28 +04:00
|
|
|
const OverloadExpr::FindResult &R,
|
2010-02-02 05:21:27 +03:00
|
|
|
FunctionDecl *Fn) {
|
|
|
|
if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn))
|
2010-08-27 13:08:28 +04: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();
|
|
|
|
|
2010-02-02 05:21:27 +03:00
|
|
|
return Context.getMemberPointerType(Fn->getType(),
|
|
|
|
Context.getTypeDeclType(Method->getParent()).getTypePtr());
|
2010-08-27 13:08:28 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!R.IsAddressOfOperand) return Fn->getType();
|
2010-02-02 05:21:27 +03:00
|
|
|
return Context.getPointerType(Fn->getType());
|
|
|
|
}
|
|
|
|
|
|
|
|
/// 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 01:04:23 +04:00
|
|
|
Expr *Arg, QualType ParamType,
|
|
|
|
bool ParamWasReference) {
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-08-27 13:08:28 +04:00
|
|
|
OverloadExpr::FindResult R = OverloadExpr::find(Arg);
|
2010-02-02 05:21:27 +03:00
|
|
|
|
2010-08-27 13:08:28 +04:00
|
|
|
OverloadExpr *Ovl = R.Expression;
|
2010-02-02 05:21:27 +03:00
|
|
|
|
2010-08-31 01:04:23 +04:00
|
|
|
// C++0x [temp.deduct.call]p4
|
|
|
|
unsigned TDF = 0;
|
|
|
|
if (ParamWasReference)
|
|
|
|
TDF |= TDF_ParamWithReferenceType;
|
|
|
|
if (R.IsAddressOfOperand)
|
|
|
|
TDF |= TDF_IgnoreQualifiers;
|
|
|
|
|
2010-02-02 05:21:27 +03:00
|
|
|
// If there were explicit template arguments, we can only find
|
|
|
|
// something via C++ [temp.arg.explicit]p3, i.e. if the arguments
|
|
|
|
// unambiguously name a full specialization.
|
2010-02-02 09:20:04 +03:00
|
|
|
if (Ovl->hasExplicitTemplateArgs()) {
|
2010-02-02 05:21:27 +03:00
|
|
|
// But we can still look for an explicit specialization.
|
|
|
|
if (FunctionDecl *ExplicitSpec
|
2010-02-02 09:20:04 +03:00
|
|
|
= S.ResolveSingleFunctionTemplateSpecialization(Ovl))
|
2010-08-27 13:08:28 +04:00
|
|
|
return GetTypeOfFunction(S.Context, R, ExplicitSpec);
|
2010-02-02 05:21:27 +03:00
|
|
|
return QualType();
|
|
|
|
}
|
|
|
|
|
|
|
|
// 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() &&
|
|
|
|
!ParamType->isMemberFunctionPointerType())
|
|
|
|
return QualType();
|
|
|
|
|
|
|
|
QualType Match;
|
2010-02-02 09:20:04 +03:00
|
|
|
for (UnresolvedSetIterator I = Ovl->decls_begin(),
|
|
|
|
E = Ovl->decls_end(); I != E; ++I) {
|
2010-02-02 05:21:27 +03:00
|
|
|
NamedDecl *D = (*I)->getUnderlyingDecl();
|
|
|
|
|
|
|
|
// - If the argument is an overload set containing one or more
|
|
|
|
// function templates, the parameter is treated as a
|
|
|
|
// non-deduced context.
|
|
|
|
if (isa<FunctionTemplateDecl>(D))
|
|
|
|
return QualType();
|
|
|
|
|
|
|
|
FunctionDecl *Fn = cast<FunctionDecl>(D);
|
2010-08-27 13:08:28 +04:00
|
|
|
QualType ArgType = GetTypeOfFunction(S.Context, R, Fn);
|
|
|
|
if (ArgType.isNull()) continue;
|
2010-02-02 05:21:27 +03:00
|
|
|
|
2010-08-31 01:04:23 +04:00
|
|
|
// Function-to-pointer conversion.
|
2011-01-27 10:10:08 +03:00
|
|
|
if (!ParamWasReference && ParamType->isPointerType() &&
|
2010-08-31 01:04:23 +04:00
|
|
|
ArgType->isFunctionType())
|
|
|
|
ArgType = S.Context.getPointerType(ArgType);
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-02-02 05:21:27 +03: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-01-27 10:10:08 +03:00
|
|
|
llvm::SmallVector<DeducedTemplateArgument, 8>
|
2010-03-28 06:42:43 +04:00
|
|
|
Deduced(TemplateParams->size());
|
2010-08-25 09:32:35 +04:00
|
|
|
TemplateDeductionInfo Info(S.Context, Ovl->getNameLoc());
|
2010-02-02 05:21:27 +03:00
|
|
|
Sema::TemplateDeductionResult Result
|
2010-02-08 00:33:28 +03:00
|
|
|
= DeduceTemplateArguments(S, TemplateParams,
|
2010-02-02 05:21:27 +03:00
|
|
|
ParamType, ArgType,
|
|
|
|
Info, Deduced, TDF);
|
|
|
|
if (Result) continue;
|
|
|
|
if (!Match.isNull()) return QualType();
|
|
|
|
Match = ArgType;
|
|
|
|
}
|
|
|
|
|
|
|
|
return Match;
|
|
|
|
}
|
|
|
|
|
2011-01-27 10:10:08 +03:00
|
|
|
/// \brief Perform the adjustments to the parameter and argument types
|
2011-01-07 01:09:01 +03:00
|
|
|
/// described in C++ [temp.deduct.call].
|
|
|
|
///
|
|
|
|
/// \returns true if the caller should not attempt to perform any template
|
|
|
|
/// argument deduction based on this P/A pair.
|
|
|
|
static bool AdjustFunctionParmAndArgTypesForDeduction(Sema &S,
|
|
|
|
TemplateParameterList *TemplateParams,
|
|
|
|
QualType &ParamType,
|
|
|
|
QualType &ArgType,
|
|
|
|
Expr *Arg,
|
|
|
|
unsigned &TDF) {
|
|
|
|
// C++0x [temp.deduct.call]p3:
|
2011-01-27 10:09:49 +03:00
|
|
|
// If P is a cv-qualified type, the top level cv-qualifiers of P's type
|
2011-01-07 01:09:01 +03:00
|
|
|
// are ignored for type deduction.
|
2011-04-28 03:34:22 +04:00
|
|
|
if (ParamType.hasQualifiers())
|
|
|
|
ParamType = ParamType.getUnqualifiedType();
|
2011-01-07 01:09:01 +03:00
|
|
|
const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>();
|
|
|
|
if (ParamRefType) {
|
2011-02-20 06:19:35 +03:00
|
|
|
QualType PointeeType = ParamRefType->getPointeeType();
|
|
|
|
|
2011-06-03 07:35:07 +04:00
|
|
|
// If the argument has incomplete array type, try to complete it's type.
|
|
|
|
if (ArgType->isIncompleteArrayType() &&
|
|
|
|
!S.RequireCompleteExprType(Arg, S.PDiag(),
|
|
|
|
std::make_pair(SourceLocation(), S.PDiag())))
|
|
|
|
ArgType = Arg->getType();
|
|
|
|
|
2011-01-21 08:18:22 +03:00
|
|
|
// [C++0x] If P is an rvalue reference to a cv-unqualified
|
|
|
|
// template parameter and the argument is an lvalue, the type
|
|
|
|
// "lvalue reference to A" is used in place of A for type
|
|
|
|
// deduction.
|
2011-02-20 06:19:35 +03:00
|
|
|
if (isa<RValueReferenceType>(ParamType)) {
|
|
|
|
if (!PointeeType.getQualifiers() &&
|
|
|
|
isa<TemplateTypeParmType>(PointeeType) &&
|
2011-05-22 02:16:50 +04:00
|
|
|
Arg->Classify(S.Context).isLValue() &&
|
|
|
|
Arg->getType() != S.Context.OverloadTy &&
|
|
|
|
Arg->getType() != S.Context.BoundMemberTy)
|
2011-01-21 08:18:22 +03:00
|
|
|
ArgType = S.Context.getLValueReferenceType(ArgType);
|
|
|
|
}
|
|
|
|
|
2011-01-07 01:09:01 +03:00
|
|
|
// [...] If P is a reference type, the type referred to by P is used
|
|
|
|
// for type deduction.
|
2011-02-20 06:19:35 +03:00
|
|
|
ParamType = PointeeType;
|
2011-01-07 01:09:01 +03:00
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-07 01:09:01 +03:00
|
|
|
// Overload sets usually make this parameter an undeduced
|
|
|
|
// context, but there are sometimes special circumstances.
|
|
|
|
if (ArgType == S.Context.OverloadTy) {
|
|
|
|
ArgType = ResolveOverloadForDeduction(S, TemplateParams,
|
|
|
|
Arg, ParamType,
|
|
|
|
ParamRefType != 0);
|
|
|
|
if (ArgType.isNull())
|
|
|
|
return true;
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-07 01:09:01 +03:00
|
|
|
if (ParamRefType) {
|
|
|
|
// C++0x [temp.deduct.call]p3:
|
|
|
|
// [...] If P is of the form T&&, where T is a template parameter, and
|
|
|
|
// the argument is an lvalue, the type A& is used in place of A for
|
|
|
|
// type deduction.
|
|
|
|
if (ParamRefType->isRValueReferenceType() &&
|
|
|
|
ParamRefType->getAs<TemplateTypeParmType>() &&
|
|
|
|
Arg->isLValue())
|
|
|
|
ArgType = S.Context.getLValueReferenceType(ArgType);
|
|
|
|
} else {
|
|
|
|
// C++ [temp.deduct.call]p2:
|
|
|
|
// If P is not a reference type:
|
|
|
|
// - If A is an array type, the pointer type produced by the
|
|
|
|
// array-to-pointer standard conversion (4.2) is used in place of
|
|
|
|
// A for type deduction; otherwise,
|
|
|
|
if (ArgType->isArrayType())
|
|
|
|
ArgType = S.Context.getArrayDecayedType(ArgType);
|
|
|
|
// - If A is a function type, the pointer type produced by the
|
|
|
|
// function-to-pointer standard conversion (4.3) is used in place
|
|
|
|
// of A for type deduction; otherwise,
|
|
|
|
else if (ArgType->isFunctionType())
|
|
|
|
ArgType = S.Context.getPointerType(ArgType);
|
|
|
|
else {
|
2011-01-27 10:09:49 +03:00
|
|
|
// - If A is a cv-qualified type, the top level cv-qualifiers of A's
|
2011-01-07 01:09:01 +03:00
|
|
|
// type are ignored for type deduction.
|
2011-04-28 03:34:22 +04:00
|
|
|
ArgType = ArgType.getUnqualifiedType();
|
2011-01-07 01:09:01 +03:00
|
|
|
}
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-07 01:09:01 +03: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 10:10:08 +03:00
|
|
|
|
2011-01-07 01:09:01 +03: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 10:10:08 +03:00
|
|
|
|
2011-01-07 01:09:01 +03:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-06-16 20:50:48 +04:00
|
|
|
static bool hasDeducibleTemplateParameters(Sema &S,
|
|
|
|
FunctionTemplateDecl *FunctionTemplate,
|
|
|
|
QualType T);
|
|
|
|
|
2009-06-26 02:08:12 +04: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.
|
|
|
|
///
|
2010-01-11 21:40:55 +03:00
|
|
|
/// \param ExplicitTemplateArguments the explicit template arguments provided
|
|
|
|
/// for this call.
|
2009-07-01 03:57:56 +04:00
|
|
|
///
|
2009-06-26 02:08:12 +04:00
|
|
|
/// \param Args the function call arguments
|
|
|
|
///
|
|
|
|
/// \param NumArgs the number of arguments in Args
|
|
|
|
///
|
2010-01-11 21:40:55 +03:00
|
|
|
/// \param Name the name of the function being called. This is only significant
|
|
|
|
/// when the function template is a conversion function template, in which
|
|
|
|
/// case this routine will also perform template argument deduction based on
|
2011-01-27 10:10:08 +03:00
|
|
|
/// the function to which
|
2010-01-11 21:40:55 +03:00
|
|
|
///
|
2009-06-26 02:08:12 +04:00
|
|
|
/// \param Specialization if template argument deduction was successful,
|
2009-09-09 19:08:12 +04:00
|
|
|
/// this will be set to the function template specialization produced by
|
2009-06-26 02:08:12 +04: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 05:41:12 +03:00
|
|
|
TemplateArgumentListInfo *ExplicitTemplateArgs,
|
2009-06-26 02:08:12 +04:00
|
|
|
Expr **Args, unsigned NumArgs,
|
|
|
|
FunctionDecl *&Specialization,
|
|
|
|
TemplateDeductionInfo &Info) {
|
|
|
|
FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
|
2009-07-01 03:57:56 +04:00
|
|
|
|
2009-06-26 02:08:12 +04: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.
|
|
|
|
unsigned CheckArgs = NumArgs;
|
2009-07-01 03:57:56 +04:00
|
|
|
if (NumArgs < Function->getMinRequiredArguments())
|
2009-06-26 02:08:12 +04:00
|
|
|
return TDK_TooFewArguments;
|
|
|
|
else if (NumArgs > Function->getNumParams()) {
|
2009-09-09 19:08:12 +04:00
|
|
|
const FunctionProtoType *Proto
|
2009-09-22 03:43:11 +04:00
|
|
|
= Function->getType()->getAs<FunctionProtoType>();
|
2011-01-07 01:09:01 +03:00
|
|
|
if (Proto->isTemplateVariadic())
|
|
|
|
/* Do nothing */;
|
|
|
|
else if (Proto->isVariadic())
|
|
|
|
CheckArgs = Function->getNumParams();
|
2011-01-27 10:10:08 +03:00
|
|
|
else
|
2009-06-26 02:08:12 +04:00
|
|
|
return TDK_TooManyArguments;
|
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-07-01 03:57:56 +04:00
|
|
|
// The types of the parameters from which we will perform template argument
|
|
|
|
// deduction.
|
2010-08-25 09:32:35 +04:00
|
|
|
LocalInstantiationScope InstScope(*this);
|
2009-06-26 02:08:12 +04:00
|
|
|
TemplateParameterList *TemplateParams
|
|
|
|
= FunctionTemplate->getTemplateParameters();
|
2010-03-28 06:42:43 +04:00
|
|
|
llvm::SmallVector<DeducedTemplateArgument, 4> Deduced;
|
2009-07-01 03:57:56 +04:00
|
|
|
llvm::SmallVector<QualType, 4> ParamTypes;
|
2010-03-28 06:42:43 +04:00
|
|
|
unsigned NumExplicitlySpecified = 0;
|
2009-11-23 04:53:49 +03:00
|
|
|
if (ExplicitTemplateArgs) {
|
2009-07-09 00:55:45 +04:00
|
|
|
TemplateDeductionResult Result =
|
|
|
|
SubstituteExplicitTemplateArguments(FunctionTemplate,
|
2009-11-23 04:53:49 +03:00
|
|
|
*ExplicitTemplateArgs,
|
2009-07-09 00:55:45 +04:00
|
|
|
Deduced,
|
|
|
|
ParamTypes,
|
|
|
|
0,
|
|
|
|
Info);
|
|
|
|
if (Result)
|
|
|
|
return Result;
|
2010-03-28 06:42:43 +04:00
|
|
|
|
|
|
|
NumExplicitlySpecified = Deduced.size();
|
2009-07-01 03:57:56 +04:00
|
|
|
} else {
|
|
|
|
// Just fill in the parameter types from the function declaration.
|
2011-01-07 01:09:01 +03:00
|
|
|
for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I)
|
2009-07-01 03:57:56 +04:00
|
|
|
ParamTypes.push_back(Function->getParamDecl(I)->getType());
|
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-07-01 03:57:56 +04:00
|
|
|
// Deduce template arguments from the function parameters.
|
2009-09-09 19:08:12 +04:00
|
|
|
Deduced.resize(TemplateParams->size());
|
2011-01-07 01:09:01 +03:00
|
|
|
unsigned ArgIdx = 0;
|
2011-06-16 20:50:48 +04:00
|
|
|
llvm::SmallVector<OriginalCallArg, 4> OriginalCallArgs;
|
2011-01-27 10:10:08 +03:00
|
|
|
for (unsigned ParamIdx = 0, NumParams = ParamTypes.size();
|
2011-01-07 01:09:01 +03:00
|
|
|
ParamIdx != NumParams; ++ParamIdx) {
|
2011-06-16 20:50:48 +04:00
|
|
|
QualType OrigParamType = ParamTypes[ParamIdx];
|
|
|
|
QualType ParamType = OrigParamType;
|
|
|
|
|
2011-01-27 10:10:08 +03:00
|
|
|
const PackExpansionType *ParamExpansion
|
2011-01-07 01:09:01 +03:00
|
|
|
= dyn_cast<PackExpansionType>(ParamType);
|
|
|
|
if (!ParamExpansion) {
|
|
|
|
// Simple case: matching a function parameter to a function argument.
|
|
|
|
if (ArgIdx >= CheckArgs)
|
|
|
|
break;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-07 01:09:01 +03:00
|
|
|
Expr *Arg = Args[ArgIdx++];
|
|
|
|
QualType ArgType = Arg->getType();
|
2011-06-16 20:50:48 +04:00
|
|
|
|
2011-01-07 01:09:01 +03:00
|
|
|
unsigned TDF = 0;
|
|
|
|
if (AdjustFunctionParmAndArgTypesForDeduction(*this, TemplateParams,
|
|
|
|
ParamType, ArgType, Arg,
|
|
|
|
TDF))
|
|
|
|
continue;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-06-16 20:50:48 +04:00
|
|
|
// Keep track of the argument type and corresponding parameter index,
|
|
|
|
// so we can check for compatibility between the deduced A and A.
|
|
|
|
if (hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType))
|
|
|
|
OriginalCallArgs.push_back(OriginalCallArg(OrigParamType, ArgIdx-1,
|
|
|
|
ArgType));
|
|
|
|
|
2011-01-07 01:09:01 +03:00
|
|
|
if (TemplateDeductionResult Result
|
|
|
|
= ::DeduceTemplateArguments(*this, TemplateParams,
|
|
|
|
ParamType, ArgType, Info, Deduced,
|
|
|
|
TDF))
|
|
|
|
return Result;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2011-01-07 01:09:01 +03:00
|
|
|
continue;
|
2010-08-31 01:04:23 +04:00
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-07 01:09:01 +03:00
|
|
|
// C++0x [temp.deduct.call]p1:
|
2011-01-27 10:10:08 +03: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 04:52:23 +03:00
|
|
|
// the function parameter pack. For a function parameter pack that does
|
2011-01-27 10:10:08 +03:00
|
|
|
// not occur at the end of the parameter-declaration-list, the type of
|
2011-01-11 04:52:23 +03:00
|
|
|
// the parameter pack is a non-deduced context.
|
|
|
|
if (ParamIdx + 1 < NumParams)
|
|
|
|
break;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-07 01:09:01 +03:00
|
|
|
QualType ParamPattern = ParamExpansion->getPattern();
|
|
|
|
llvm::SmallVector<unsigned, 2> PackIndices;
|
|
|
|
{
|
|
|
|
llvm::BitVector SawIndices(TemplateParams->size());
|
|
|
|
llvm::SmallVector<UnexpandedParameterPack, 2> Unexpanded;
|
|
|
|
collectUnexpandedParameterPacks(ParamPattern, Unexpanded);
|
|
|
|
for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
|
|
|
|
unsigned Depth, Index;
|
|
|
|
llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]);
|
|
|
|
if (Depth == 0 && !SawIndices[Index]) {
|
|
|
|
SawIndices[Index] = true;
|
|
|
|
PackIndices.push_back(Index);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?");
|
2011-01-27 10:10:08 +03: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.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@123163 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-10 10:32:04 +03:00
|
|
|
// Keep track of the deduced template arguments for each parameter pack
|
2011-01-27 10:10:08 +03:00
|
|
|
// expanded by this pack expansion (the outer index) and for each
|
Work-in-progress implementation of C++0x [temp.arg.explicit]p9, which
allows an argument pack determines via explicit specification of
function template arguments to be extended by further, deduced
arguments. For example:
template<class ... Types> void f(Types ... values);
void g() {
f<int*, float*>(0, 0, 0); // Types is deduced to the sequence int*, float*, int
}
There are a number of FIXMEs in here that indicate places where we
need to implement + test retained expansions, plus a number of other
places in deduction where we need to correctly cope with the
explicitly-specified arguments when deducing an argument
pack. Furthermore, it appears that the RecursiveASTVisitor needs to be
auditied; it's missing some traversals (especially w.r.t. template
arguments) that cause it not to find unexpanded parameter packs when
it should.
The good news, however, is that the tr1::tuple implementation now
works fully, and the tr1::bind example (both from N2080) is actually
working now.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@123163 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-10 10:32:04 +03:00
|
|
|
// template argument (the inner SmallVectors).
|
|
|
|
llvm::SmallVector<llvm::SmallVector<DeducedTemplateArgument, 4>, 2>
|
|
|
|
NewlyDeducedPacks(PackIndices.size());
|
2011-01-27 10:10:08 +03:00
|
|
|
llvm::SmallVector<DeducedTemplateArgument, 2>
|
Work-in-progress implementation of C++0x [temp.arg.explicit]p9, which
allows an argument pack determines via explicit specification of
function template arguments to be extended by further, deduced
arguments. For example:
template<class ... Types> void f(Types ... values);
void g() {
f<int*, float*>(0, 0, 0); // Types is deduced to the sequence int*, float*, int
}
There are a number of FIXMEs in here that indicate places where we
need to implement + test retained expansions, plus a number of other
places in deduction where we need to correctly cope with the
explicitly-specified arguments when deducing an argument
pack. Furthermore, it appears that the RecursiveASTVisitor needs to be
auditied; it's missing some traversals (especially w.r.t. template
arguments) that cause it not to find unexpanded parameter packs when
it should.
The good news, however, is that the tr1::tuple implementation now
works fully, and the tr1::bind example (both from N2080) is actually
working now.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@123163 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-10 10:32:04 +03:00
|
|
|
SavedPacks(PackIndices.size());
|
2011-01-10 20:35:05 +03:00
|
|
|
PrepareArgumentPackDeduction(*this, Deduced, PackIndices, SavedPacks,
|
2011-01-27 10:10:08 +03:00
|
|
|
NewlyDeducedPacks);
|
2011-01-07 01:09:01 +03:00
|
|
|
bool HasAnyArguments = false;
|
|
|
|
for (; ArgIdx < NumArgs; ++ArgIdx) {
|
|
|
|
HasAnyArguments = true;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-06-16 20:50:48 +04:00
|
|
|
QualType OrigParamType = ParamPattern;
|
|
|
|
ParamType = OrigParamType;
|
2011-01-07 01:09:01 +03:00
|
|
|
Expr *Arg = Args[ArgIdx];
|
|
|
|
QualType ArgType = Arg->getType();
|
2011-06-16 20:50:48 +04:00
|
|
|
|
2011-01-07 01:09:01 +03: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 10:10:08 +03:00
|
|
|
|
2011-06-16 20:50:48 +04:00
|
|
|
// Keep track of the argument type and corresponding argument index,
|
|
|
|
// so we can check for compatibility between the deduced A and A.
|
|
|
|
if (hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType))
|
|
|
|
OriginalCallArgs.push_back(OriginalCallArg(OrigParamType, ArgIdx,
|
|
|
|
ArgType));
|
|
|
|
|
2011-01-07 01:09:01 +03:00
|
|
|
if (TemplateDeductionResult Result
|
|
|
|
= ::DeduceTemplateArguments(*this, TemplateParams,
|
|
|
|
ParamType, ArgType, Info, Deduced,
|
|
|
|
TDF))
|
|
|
|
return Result;
|
2010-02-02 05:21:27 +03:00
|
|
|
|
2011-01-07 01:09:01 +03:00
|
|
|
// Capture the deduced template arguments for each parameter pack expanded
|
|
|
|
// by this pack expansion, add them to the list of arguments we've deduced
|
|
|
|
// for that pack, then clear out the deduced argument.
|
|
|
|
for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) {
|
|
|
|
DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]];
|
|
|
|
if (!DeducedArg.isNull()) {
|
|
|
|
NewlyDeducedPacks[I].push_back(DeducedArg);
|
|
|
|
DeducedArg = DeducedTemplateArgument();
|
|
|
|
}
|
2009-06-26 02:08:12 +04:00
|
|
|
}
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-07 01:09:01 +03:00
|
|
|
// Build argument packs for each of the parameter packs expanded by this
|
|
|
|
// pack expansion.
|
2011-01-10 20:53:52 +03:00
|
|
|
if (Sema::TemplateDeductionResult Result
|
2011-01-27 10:10:08 +03:00
|
|
|
= FinishArgumentPackDeduction(*this, TemplateParams, HasAnyArguments,
|
2011-01-10 20:53:52 +03:00
|
|
|
Deduced, PackIndices, SavedPacks,
|
|
|
|
NewlyDeducedPacks, Info))
|
2011-01-27 10:10:08 +03:00
|
|
|
return Result;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2011-01-07 01:09:01 +03:00
|
|
|
// After we've matching against a parameter pack, we're done.
|
|
|
|
break;
|
2009-06-26 02:08:12 +04:00
|
|
|
}
|
2009-08-22 03:19:43 +04:00
|
|
|
|
2009-09-09 19:08:12 +04:00
|
|
|
return FinishTemplateArgumentDeduction(FunctionTemplate, Deduced,
|
2010-03-28 06:42:43 +04:00
|
|
|
NumExplicitlySpecified,
|
2011-06-16 20:50:48 +04:00
|
|
|
Specialization, Info, &OriginalCallArgs);
|
2009-07-09 00:55:45 +04:00
|
|
|
}
|
2009-06-30 00:59:39 +04:00
|
|
|
|
2009-07-09 00:55:45 +04:00
|
|
|
/// \brief Deduce template arguments when taking the address of a function
|
2009-12-22 02:17:24 +03:00
|
|
|
/// template (C++ [temp.deduct.funcaddr]) or matching a specialization to
|
|
|
|
/// a template.
|
2009-07-09 00:55:45 +04:00
|
|
|
///
|
|
|
|
/// \param FunctionTemplate the function template for which we are performing
|
|
|
|
/// template argument deduction.
|
|
|
|
///
|
2011-01-27 10:10:08 +03:00
|
|
|
/// \param ExplicitTemplateArguments the explicitly-specified template
|
2009-12-22 02:17:24 +03:00
|
|
|
/// arguments.
|
2009-07-09 00:55:45 +04: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 02:17:24 +03: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 00:55:45 +04:00
|
|
|
///
|
|
|
|
/// \param Specialization if template argument deduction was successful,
|
2009-09-09 19:08:12 +04:00
|
|
|
/// this will be set to the function template specialization produced by
|
2009-07-09 00:55:45 +04: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 05:41:12 +03:00
|
|
|
TemplateArgumentListInfo *ExplicitTemplateArgs,
|
2009-07-09 00:55:45 +04:00
|
|
|
QualType ArgFunctionType,
|
|
|
|
FunctionDecl *&Specialization,
|
|
|
|
TemplateDeductionInfo &Info) {
|
|
|
|
FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
|
|
|
|
TemplateParameterList *TemplateParams
|
|
|
|
= FunctionTemplate->getTemplateParameters();
|
|
|
|
QualType FunctionType = Function->getType();
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-07-09 00:55:45 +04:00
|
|
|
// Substitute any explicit template arguments.
|
2010-08-25 09:32:35 +04:00
|
|
|
LocalInstantiationScope InstScope(*this);
|
2010-03-28 06:42:43 +04:00
|
|
|
llvm::SmallVector<DeducedTemplateArgument, 4> Deduced;
|
|
|
|
unsigned NumExplicitlySpecified = 0;
|
2009-07-09 00:55:45 +04:00
|
|
|
llvm::SmallVector<QualType, 4> ParamTypes;
|
2009-11-23 04:53:49 +03:00
|
|
|
if (ExplicitTemplateArgs) {
|
2009-09-09 19:08:12 +04:00
|
|
|
if (TemplateDeductionResult Result
|
|
|
|
= SubstituteExplicitTemplateArguments(FunctionTemplate,
|
2009-11-23 04:53:49 +03:00
|
|
|
*ExplicitTemplateArgs,
|
2009-09-09 19:08:12 +04:00
|
|
|
Deduced, ParamTypes,
|
2009-07-09 00:55:45 +04:00
|
|
|
&FunctionType, Info))
|
|
|
|
return Result;
|
2010-03-28 06:42:43 +04:00
|
|
|
|
|
|
|
NumExplicitlySpecified = Deduced.size();
|
2009-06-30 00:59:39 +04:00
|
|
|
}
|
2009-07-09 00:55:45 +04:00
|
|
|
|
|
|
|
// Template argument deduction for function templates in a SFINAE context.
|
|
|
|
// Trap any errors that might occur.
|
2009-09-09 19:08:12 +04:00
|
|
|
SFINAETrap Trap(*this);
|
|
|
|
|
2010-02-02 05:21:27 +03:00
|
|
|
Deduced.resize(TemplateParams->size());
|
|
|
|
|
2009-12-22 02:17:24 +03:00
|
|
|
if (!ArgFunctionType.isNull()) {
|
|
|
|
// Deduce template arguments from the function type.
|
|
|
|
if (TemplateDeductionResult Result
|
2010-02-08 00:33:28 +03:00
|
|
|
= ::DeduceTemplateArguments(*this, TemplateParams,
|
2009-12-22 02:17:24 +03:00
|
|
|
FunctionType, ArgFunctionType, Info,
|
2011-01-25 20:19:08 +03:00
|
|
|
Deduced, TDF_TopLevelParameterTypeList))
|
2009-12-22 02:17:24 +03:00
|
|
|
return Result;
|
|
|
|
}
|
2010-09-30 01:14:36 +04:00
|
|
|
|
2011-01-27 10:10:08 +03:00
|
|
|
if (TemplateDeductionResult Result
|
2010-09-30 01:14:36 +04:00
|
|
|
= FinishTemplateArgumentDeduction(FunctionTemplate, Deduced,
|
|
|
|
NumExplicitlySpecified,
|
|
|
|
Specialization, Info))
|
|
|
|
return Result;
|
|
|
|
|
|
|
|
// If the requested function type does not match the actual type of the
|
|
|
|
// specialization, template argument deduction fails.
|
|
|
|
if (!ArgFunctionType.isNull() &&
|
|
|
|
!Context.hasSameType(ArgFunctionType, Specialization->getType()))
|
|
|
|
return TDK_NonDeducedMismatch;
|
|
|
|
|
|
|
|
return TDK_Success;
|
2009-06-26 02:08:12 +04:00
|
|
|
}
|
|
|
|
|
2009-08-22 03:19:43 +04:00
|
|
|
/// \brief Deduce template arguments for a templated conversion
|
|
|
|
/// function (C++ [temp.deduct.conv]) and, if successful, produce a
|
|
|
|
/// conversion function template specialization.
|
|
|
|
Sema::TemplateDeductionResult
|
|
|
|
Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
|
|
|
|
QualType ToType,
|
|
|
|
CXXConversionDecl *&Specialization,
|
|
|
|
TemplateDeductionInfo &Info) {
|
2009-09-09 19:08:12 +04:00
|
|
|
CXXConversionDecl *Conv
|
2009-08-22 03:19:43 +04:00
|
|
|
= cast<CXXConversionDecl>(FunctionTemplate->getTemplatedDecl());
|
|
|
|
QualType FromType = Conv->getConversionType();
|
|
|
|
|
|
|
|
// Canonicalize the types for deduction.
|
|
|
|
QualType P = Context.getCanonicalType(FromType);
|
|
|
|
QualType A = Context.getCanonicalType(ToType);
|
|
|
|
|
2011-03-06 12:03:20 +03:00
|
|
|
// C++0x [temp.deduct.conv]p2:
|
2009-08-22 03:19:43 +04: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 12:03:20 +03:00
|
|
|
// C++0x [temp.deduct.conv]p4:
|
|
|
|
// [...] If A is a reference type, the type referred to by A is used
|
2009-08-22 03:19:43 +04:00
|
|
|
// for type deduction.
|
|
|
|
if (const ReferenceType *ARef = A->getAs<ReferenceType>())
|
2011-03-06 12:03:20 +03:00
|
|
|
A = ARef->getPointeeType().getUnqualifiedType();
|
|
|
|
// C++ [temp.deduct.conv]p3:
|
2009-08-22 03:19:43 +04:00
|
|
|
//
|
2009-09-09 19:08:12 +04:00
|
|
|
// If A is not a reference type:
|
2009-08-22 03:19:43 +04: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 19:08:12 +04:00
|
|
|
// array-to-pointer standard conversion (4.2) is used in place
|
2009-08-22 03:19:43 +04: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 10:09:49 +03:00
|
|
|
// P's type are ignored for type deduction.
|
2009-08-22 03:19:43 +04:00
|
|
|
else
|
|
|
|
P = P.getUnqualifiedType();
|
|
|
|
|
2011-03-06 12:03:20 +03:00
|
|
|
// C++0x [temp.deduct.conv]p4:
|
2011-01-27 10:09:49 +03:00
|
|
|
// If A is a cv-qualified type, the top level cv-qualifiers of A's
|
2011-03-06 12:03:20 +03:00
|
|
|
// type are ignored for type deduction. If A is a reference type, the type
|
|
|
|
// referred to by A is used for type deduction.
|
2009-08-22 03:19:43 +04:00
|
|
|
A = A.getUnqualifiedType();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Template argument deduction for function templates in a SFINAE context.
|
|
|
|
// Trap any errors that might occur.
|
2009-09-09 19:08:12 +04:00
|
|
|
SFINAETrap Trap(*this);
|
2009-08-22 03:19:43 +04:00
|
|
|
|
|
|
|
// C++ [temp.deduct.conv]p1:
|
|
|
|
// Template argument deduction is done by comparing the return
|
|
|
|
// type of the template conversion function (call it P) with the
|
|
|
|
// type that is required as the result of the conversion (call it
|
|
|
|
// A) as described in 14.8.2.4.
|
|
|
|
TemplateParameterList *TemplateParams
|
|
|
|
= FunctionTemplate->getTemplateParameters();
|
2010-03-28 06:42:43 +04:00
|
|
|
llvm::SmallVector<DeducedTemplateArgument, 4> Deduced;
|
2009-09-09 19:08:12 +04:00
|
|
|
Deduced.resize(TemplateParams->size());
|
2009-08-22 03:19:43 +04: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 10:09:49 +03:00
|
|
|
// type that can be converted to A via a qualification
|
2009-08-22 03:19:43 +04: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()) ||
|
|
|
|
(P->isMemberPointerType() && P->isMemberPointerType()))
|
|
|
|
TDF |= TDF_IgnoreQualifiers;
|
|
|
|
if (TemplateDeductionResult Result
|
2010-02-08 00:33:28 +03:00
|
|
|
= ::DeduceTemplateArguments(*this, TemplateParams,
|
2009-08-22 03:19:43 +04:00
|
|
|
P, A, Info, Deduced, TDF))
|
|
|
|
return Result;
|
|
|
|
|
|
|
|
// Finish template argument deduction.
|
2010-08-25 09:32:35 +04:00
|
|
|
LocalInstantiationScope InstScope(*this);
|
2009-08-22 03:19:43 +04:00
|
|
|
FunctionDecl *Spec = 0;
|
|
|
|
TemplateDeductionResult Result
|
2011-01-27 10:10:08 +03:00
|
|
|
= FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, 0, Spec,
|
2010-03-28 06:42:43 +04:00
|
|
|
Info);
|
2009-08-22 03:19:43 +04:00
|
|
|
Specialization = cast_or_null<CXXConversionDecl>(Spec);
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
2009-12-22 02:17:24 +03: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.
|
|
|
|
///
|
2011-01-27 10:10:08 +03:00
|
|
|
/// \param ExplicitTemplateArguments the explicitly-specified template
|
2009-12-22 02:17:24 +03: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 05:41:12 +03:00
|
|
|
TemplateArgumentListInfo *ExplicitTemplateArgs,
|
2009-12-22 02:17:24 +03:00
|
|
|
FunctionDecl *&Specialization,
|
|
|
|
TemplateDeductionInfo &Info) {
|
|
|
|
return DeduceTemplateArguments(FunctionTemplate, ExplicitTemplateArgs,
|
|
|
|
QualType(), Specialization, Info);
|
|
|
|
}
|
|
|
|
|
2011-02-20 06:19:35 +03:00
|
|
|
namespace {
|
|
|
|
/// Substitute the 'auto' type specifier within a type for a given replacement
|
|
|
|
/// type.
|
|
|
|
class SubstituteAutoTransform :
|
|
|
|
public TreeTransform<SubstituteAutoTransform> {
|
|
|
|
QualType Replacement;
|
|
|
|
public:
|
|
|
|
SubstituteAutoTransform(Sema &SemaRef, QualType Replacement) :
|
|
|
|
TreeTransform<SubstituteAutoTransform>(SemaRef), Replacement(Replacement) {
|
|
|
|
}
|
|
|
|
QualType TransformAutoType(TypeLocBuilder &TLB, AutoTypeLoc TL) {
|
|
|
|
// If we're building the type pattern to deduce against, don't wrap the
|
|
|
|
// substituted type in an AutoType. Certain template deduction rules
|
|
|
|
// apply only when a template type parameter appears directly (and not if
|
|
|
|
// the parameter is found through desugaring). For instance:
|
|
|
|
// auto &&lref = lvalue;
|
|
|
|
// must transform into "rvalue reference to T" not "rvalue reference to
|
|
|
|
// auto type deduced as T" in order for [temp.deduct.call]p3 to apply.
|
|
|
|
if (isa<TemplateTypeParmType>(Replacement)) {
|
|
|
|
QualType Result = Replacement;
|
|
|
|
TemplateTypeParmTypeLoc NewTL = TLB.push<TemplateTypeParmTypeLoc>(Result);
|
|
|
|
NewTL.setNameLoc(TL.getNameLoc());
|
|
|
|
return Result;
|
|
|
|
} else {
|
|
|
|
QualType Result = RebuildAutoType(Replacement);
|
|
|
|
AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result);
|
|
|
|
NewTL.setNameLoc(TL.getNameLoc());
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief Deduce the type for an auto type-specifier (C++0x [dcl.spec.auto]p6)
|
|
|
|
///
|
|
|
|
/// \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
|
|
|
|
/// deduced type. This may still contain undeduced autos if the type is
|
2011-03-17 19:11:59 +03:00
|
|
|
/// dependent. This will be set to null if deduction succeeded, but auto
|
|
|
|
/// substitution failed; the appropriate diagnostic will already have been
|
|
|
|
/// produced in that case.
|
2011-02-20 06:19:35 +03:00
|
|
|
///
|
|
|
|
/// \returns true if deduction succeeded, false if it failed.
|
|
|
|
bool
|
2011-03-17 19:11:59 +03:00
|
|
|
Sema::DeduceAutoType(TypeSourceInfo *Type, Expr *Init,
|
|
|
|
TypeSourceInfo *&Result) {
|
2011-02-20 06:19:35 +03:00
|
|
|
if (Init->isTypeDependent()) {
|
|
|
|
Result = Type;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
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.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@130628 91177308-0d34-0410-b5e6-96231b3b80d8
2011-05-01 04:51:33 +04:00
|
|
|
TemplateTypeParmDecl *TemplParam =
|
|
|
|
TemplateTypeParmDecl::Create(Context, 0, SourceLocation(), Loc, 0, 0, 0,
|
|
|
|
false, false);
|
|
|
|
QualType TemplArg = QualType(TemplParam->getTypeForDecl(), 0);
|
|
|
|
NamedDecl *TemplParamPtr = TemplParam;
|
2011-02-21 23:05:19 +03:00
|
|
|
FixedSizeTemplateParameterList<1> TemplateParams(Loc, Loc, &TemplParamPtr,
|
|
|
|
Loc);
|
|
|
|
|
2011-03-17 19:11:59 +03:00
|
|
|
TypeSourceInfo *FuncParamInfo =
|
2011-02-20 06:19:35 +03:00
|
|
|
SubstituteAutoTransform(*this, TemplArg).TransformType(Type);
|
2011-03-17 19:11:59 +03:00
|
|
|
assert(FuncParamInfo && "substituting template parameter for 'auto' failed");
|
|
|
|
QualType FuncParam = FuncParamInfo->getType();
|
2011-02-20 06:19:35 +03:00
|
|
|
|
|
|
|
// Deduce type of TemplParam in Func(Init)
|
|
|
|
llvm::SmallVector<DeducedTemplateArgument, 1> Deduced;
|
|
|
|
Deduced.resize(1);
|
|
|
|
QualType InitType = Init->getType();
|
|
|
|
unsigned TDF = 0;
|
2011-02-21 23:05:19 +03:00
|
|
|
if (AdjustFunctionParmAndArgTypesForDeduction(*this, &TemplateParams,
|
2011-02-20 06:19:35 +03:00
|
|
|
FuncParam, InitType, Init,
|
|
|
|
TDF))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
TemplateDeductionInfo Info(Context, Loc);
|
2011-02-21 23:05:19 +03:00
|
|
|
if (::DeduceTemplateArguments(*this, &TemplateParams,
|
2011-02-20 06:19:35 +03:00
|
|
|
FuncParam, InitType, Info, Deduced,
|
|
|
|
TDF))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
QualType DeducedType = Deduced[0].getAsType();
|
|
|
|
if (DeducedType.isNull())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Result = SubstituteAutoTransform(*this, DeducedType).TransformType(Type);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2009-09-14 22:39:43 +04:00
|
|
|
static void
|
2009-09-15 01:25:05 +04:00
|
|
|
MarkUsedTemplateParameters(Sema &SemaRef, QualType T,
|
|
|
|
bool OnlyDeduced,
|
2009-10-29 03:04:11 +03:00
|
|
|
unsigned Level,
|
2009-09-15 01:25:05 +04:00
|
|
|
llvm::SmallVectorImpl<bool> &Deduced);
|
2011-01-27 10:10:08 +03:00
|
|
|
|
|
|
|
/// \brief If this is a non-static member function,
|
2010-11-13 02:44:13 +03:00
|
|
|
static void MaybeAddImplicitObjectParameterType(ASTContext &Context,
|
|
|
|
CXXMethodDecl *Method,
|
|
|
|
llvm::SmallVectorImpl<QualType> &ArgTypes) {
|
|
|
|
if (Method->isStatic())
|
|
|
|
return;
|
|
|
|
|
|
|
|
// C++ [over.match.funcs]p4:
|
|
|
|
//
|
|
|
|
// For non-static member functions, the type of the implicit
|
|
|
|
// object parameter is
|
2011-01-27 10:09:49 +03:00
|
|
|
// - "lvalue reference to cv X" for functions declared without a
|
2010-11-13 02:44:13 +03:00
|
|
|
// ref-qualifier or with the & ref-qualifier
|
|
|
|
// - "rvalue reference to cv X" for functions declared with the
|
|
|
|
// && ref-qualifier
|
|
|
|
//
|
|
|
|
// FIXME: We don't have ref-qualifiers yet, so we don't do that part.
|
|
|
|
QualType ArgTy = Context.getTypeDeclType(Method->getParent());
|
|
|
|
ArgTy = Context.getQualifiedType(ArgTy,
|
|
|
|
Qualifiers::fromCVRMask(Method->getTypeQualifiers()));
|
|
|
|
ArgTy = Context.getLValueReferenceType(ArgTy);
|
|
|
|
ArgTypes.push_back(ArgTy);
|
|
|
|
}
|
|
|
|
|
2009-09-14 22:39:43 +04: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 02:07:23 +03:00
|
|
|
SourceLocation Loc,
|
2009-09-14 22:39:43 +04:00
|
|
|
FunctionTemplateDecl *FT1,
|
|
|
|
FunctionTemplateDecl *FT2,
|
|
|
|
TemplatePartialOrderingContext TPOC,
|
2011-01-27 10:10:08 +03:00
|
|
|
unsigned NumCallArguments,
|
2011-01-21 20:29:42 +03:00
|
|
|
llvm::SmallVectorImpl<RefParamPartialOrderingComparison> *RefParamComparisons) {
|
2009-09-14 22:39:43 +04:00
|
|
|
FunctionDecl *FD1 = FT1->getTemplatedDecl();
|
2011-01-27 10:10:08 +03:00
|
|
|
FunctionDecl *FD2 = FT2->getTemplatedDecl();
|
2009-09-14 22:39:43 +04:00
|
|
|
const FunctionProtoType *Proto1 = FD1->getType()->getAs<FunctionProtoType>();
|
|
|
|
const FunctionProtoType *Proto2 = FD2->getType()->getAs<FunctionProtoType>();
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-09-14 22:39:43 +04:00
|
|
|
assert(Proto1 && Proto2 && "Function templates must have prototypes");
|
|
|
|
TemplateParameterList *TemplateParams = FT2->getTemplateParameters();
|
2010-03-28 06:42:43 +04:00
|
|
|
llvm::SmallVector<DeducedTemplateArgument, 4> Deduced;
|
2009-09-14 22:39:43 +04: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:
|
2010-08-25 09:32:35 +04:00
|
|
|
TemplateDeductionInfo Info(S.Context, Loc);
|
2010-11-15 18:41:16 +03:00
|
|
|
CXXMethodDecl *Method1 = 0;
|
|
|
|
CXXMethodDecl *Method2 = 0;
|
|
|
|
bool IsNonStatic2 = false;
|
|
|
|
bool IsNonStatic1 = false;
|
|
|
|
unsigned Skip2 = 0;
|
2009-09-14 22:39:43 +04:00
|
|
|
switch (TPOC) {
|
|
|
|
case TPOC_Call: {
|
|
|
|
// - In the context of a function call, the function parameter types are
|
|
|
|
// used.
|
2010-11-15 18:41:16 +03:00
|
|
|
Method1 = dyn_cast<CXXMethodDecl>(FD1);
|
|
|
|
Method2 = dyn_cast<CXXMethodDecl>(FD2);
|
|
|
|
IsNonStatic1 = Method1 && !Method1->isStatic();
|
|
|
|
IsNonStatic2 = Method2 && !Method2->isStatic();
|
|
|
|
|
|
|
|
// C++0x [temp.func.order]p3:
|
|
|
|
// [...] 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.
|
|
|
|
//
|
|
|
|
// C++98/03 doesn't have this provision, so instead we drop the
|
|
|
|
// first argument of the free function or static member, which
|
|
|
|
// seems to match existing practice.
|
2010-11-13 02:44:13 +03:00
|
|
|
llvm::SmallVector<QualType, 4> Args1;
|
2011-01-27 10:10:08 +03:00
|
|
|
unsigned Skip1 = !S.getLangOptions().CPlusPlus0x &&
|
2010-11-15 18:41:16 +03:00
|
|
|
IsNonStatic2 && !IsNonStatic1;
|
|
|
|
if (S.getLangOptions().CPlusPlus0x && IsNonStatic1 && !IsNonStatic2)
|
2011-01-27 10:10:08 +03:00
|
|
|
MaybeAddImplicitObjectParameterType(S.Context, Method1, Args1);
|
|
|
|
Args1.insert(Args1.end(),
|
2010-11-15 18:41:16 +03:00
|
|
|
Proto1->arg_type_begin() + Skip1, Proto1->arg_type_end());
|
2010-11-13 02:44:13 +03:00
|
|
|
|
|
|
|
llvm::SmallVector<QualType, 4> Args2;
|
2011-01-27 10:10:08 +03:00
|
|
|
Skip2 = !S.getLangOptions().CPlusPlus0x &&
|
2010-11-15 18:41:16 +03:00
|
|
|
IsNonStatic1 && !IsNonStatic2;
|
|
|
|
if (S.getLangOptions().CPlusPlus0x && IsNonStatic2 && !IsNonStatic1)
|
2010-11-13 02:44:13 +03:00
|
|
|
MaybeAddImplicitObjectParameterType(S.Context, Method2, Args2);
|
2011-01-27 10:10:08 +03:00
|
|
|
Args2.insert(Args2.end(),
|
2010-11-15 18:41:16 +03:00
|
|
|
Proto2->arg_type_begin() + Skip2, Proto2->arg_type_end());
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-11 20:34:58 +03:00
|
|
|
// C++ [temp.func.order]p5:
|
|
|
|
// The presence of unused ellipsis and default arguments has no effect on
|
|
|
|
// the partial ordering of function templates.
|
|
|
|
if (Args1.size() > NumCallArguments)
|
|
|
|
Args1.resize(NumCallArguments);
|
|
|
|
if (Args2.size() > NumCallArguments)
|
|
|
|
Args2.resize(NumCallArguments);
|
|
|
|
if (DeduceTemplateArguments(S, TemplateParams, Args2.data(), Args2.size(),
|
|
|
|
Args1.data(), Args1.size(), Info, Deduced,
|
|
|
|
TDF_None, /*PartialOrdering=*/true,
|
2011-01-21 20:29:42 +03:00
|
|
|
RefParamComparisons))
|
2009-09-14 22:39:43 +04:00
|
|
|
return false;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-09-14 22:39:43 +04:00
|
|
|
break;
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-09-14 22:39:43 +04:00
|
|
|
case TPOC_Conversion:
|
|
|
|
// - In the context of a call to a conversion operator, the return types
|
|
|
|
// of the conversion function templates are used.
|
2011-01-11 20:34:58 +03:00
|
|
|
if (DeduceTemplateArguments(S, TemplateParams, Proto2->getResultType(),
|
|
|
|
Proto1->getResultType(), Info, Deduced,
|
|
|
|
TDF_None, /*PartialOrdering=*/true,
|
2011-01-21 20:29:42 +03:00
|
|
|
RefParamComparisons))
|
2009-09-14 22:39:43 +04:00
|
|
|
return false;
|
|
|
|
break;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-09-14 22:39:43 +04:00
|
|
|
case TPOC_Other:
|
2011-01-27 10:09:49 +03:00
|
|
|
// - In other contexts (14.6.6.2) the function template's function type
|
2009-09-14 22:39:43 +04:00
|
|
|
// is used.
|
2011-01-27 10:10:08 +03:00
|
|
|
if (DeduceTemplateArguments(S, TemplateParams, FD2->getType(),
|
2011-01-11 20:34:58 +03:00
|
|
|
FD1->getType(), Info, Deduced, TDF_None,
|
2011-01-21 20:29:42 +03:00
|
|
|
/*PartialOrdering=*/true, RefParamComparisons))
|
2009-09-14 22:39:43 +04:00
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-09-14 22:39:43 +04:00
|
|
|
// C++0x [temp.deduct.partial]p11:
|
2011-01-27 10:10:08 +03: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-14 22:39:43 +04: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 10:10:08 +03:00
|
|
|
// All template arguments were deduced. FT1 is at least as specialized
|
2009-09-14 22:39:43 +04:00
|
|
|
// as FT2.
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2009-09-15 01:25:05 +04:00
|
|
|
// Figure out which template parameters were used.
|
2009-09-14 22:39:43 +04:00
|
|
|
llvm::SmallVector<bool, 4> UsedParameters;
|
|
|
|
UsedParameters.resize(TemplateParams->size());
|
|
|
|
switch (TPOC) {
|
|
|
|
case TPOC_Call: {
|
2011-01-27 10:10:08 +03:00
|
|
|
unsigned NumParams = std::min(NumCallArguments,
|
|
|
|
std::min(Proto1->getNumArgs(),
|
2011-01-11 20:34:58 +03:00
|
|
|
Proto2->getNumArgs()));
|
2010-11-15 18:41:16 +03:00
|
|
|
if (S.getLangOptions().CPlusPlus0x && IsNonStatic2 && !IsNonStatic1)
|
2011-01-27 10:10:08 +03:00
|
|
|
::MarkUsedTemplateParameters(S, Method2->getThisType(S.Context), false,
|
2010-11-15 18:41:16 +03:00
|
|
|
TemplateParams->getDepth(), UsedParameters);
|
|
|
|
for (unsigned I = Skip2; I < NumParams; ++I)
|
2011-01-27 10:10:08 +03:00
|
|
|
::MarkUsedTemplateParameters(S, Proto2->getArgType(I), false,
|
2009-10-29 03:04:11 +03:00
|
|
|
TemplateParams->getDepth(),
|
2009-09-15 01:25:05 +04:00
|
|
|
UsedParameters);
|
2009-09-14 22:39:43 +04:00
|
|
|
break;
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-09-14 22:39:43 +04:00
|
|
|
case TPOC_Conversion:
|
2011-01-27 10:10:08 +03:00
|
|
|
::MarkUsedTemplateParameters(S, Proto2->getResultType(), false,
|
2009-10-29 03:04:11 +03:00
|
|
|
TemplateParams->getDepth(),
|
2009-09-15 01:25:05 +04:00
|
|
|
UsedParameters);
|
2009-09-14 22:39:43 +04:00
|
|
|
break;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-09-14 22:39:43 +04:00
|
|
|
case TPOC_Other:
|
2011-01-27 10:10:08 +03:00
|
|
|
::MarkUsedTemplateParameters(S, FD2->getType(), false,
|
2009-10-29 03:04:11 +03:00
|
|
|
TemplateParams->getDepth(),
|
|
|
|
UsedParameters);
|
2009-09-14 22:39:43 +04:00
|
|
|
break;
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-09-14 22:39:43 +04: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 10:10:08 +03:00
|
|
|
|
2009-09-14 22:39:43 +04:00
|
|
|
return true;
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-16 19:03:23 +03: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 10:10:08 +03:00
|
|
|
|
2011-01-16 19:03:23 +03:00
|
|
|
ParmVarDecl *Last = Function->getParamDecl(NumParams - 1);
|
|
|
|
if (!Last->isParameterPack())
|
|
|
|
return false;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-16 19:03:23 +03: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 10:10:08 +03:00
|
|
|
|
2011-01-16 19:03:23 +03:00
|
|
|
return true;
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-09-15 20:23:51 +04:00
|
|
|
/// \brief Returns the more specialized function template according
|
2009-08-22 03:19:43 +04: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-14 22:39:43 +04:00
|
|
|
/// \param TPOC the context in which we are performing partial ordering of
|
|
|
|
/// function templates.
|
2009-09-09 19:08:12 +04:00
|
|
|
///
|
2011-01-11 20:34:58 +03:00
|
|
|
/// \param NumCallArguments The number of arguments in a call, used only
|
|
|
|
/// when \c TPOC is \c TPOC_Call.
|
|
|
|
///
|
2009-09-15 20:23:51 +04:00
|
|
|
/// \returns the more specialized function template. If neither
|
2009-08-22 03:19:43 +04:00
|
|
|
/// template is more specialized, returns NULL.
|
|
|
|
FunctionTemplateDecl *
|
|
|
|
Sema::getMoreSpecializedTemplate(FunctionTemplateDecl *FT1,
|
|
|
|
FunctionTemplateDecl *FT2,
|
2010-02-09 02:07:23 +03:00
|
|
|
SourceLocation Loc,
|
2011-01-11 20:34:58 +03:00
|
|
|
TemplatePartialOrderingContext TPOC,
|
|
|
|
unsigned NumCallArguments) {
|
2011-01-21 20:29:42 +03:00
|
|
|
llvm::SmallVector<RefParamPartialOrderingComparison, 4> RefParamComparisons;
|
2011-01-27 10:10:08 +03:00
|
|
|
bool Better1 = isAtLeastAsSpecializedAs(*this, Loc, FT1, FT2, TPOC,
|
2011-01-11 20:34:58 +03:00
|
|
|
NumCallArguments, 0);
|
2011-01-27 10:10:08 +03:00
|
|
|
bool Better2 = isAtLeastAsSpecializedAs(*this, Loc, FT2, FT1, TPOC,
|
2011-01-11 20:34:58 +03:00
|
|
|
NumCallArguments,
|
2011-01-21 20:29:42 +03:00
|
|
|
&RefParamComparisons);
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-09-14 22:39:43 +04:00
|
|
|
if (Better1 != Better2) // We have a clear winner
|
|
|
|
return Better1? FT1 : FT2;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-09-14 22:39:43 +04:00
|
|
|
if (!Better1 && !Better2) // Neither is better than the other
|
2009-08-22 03:19:43 +04:00
|
|
|
return 0;
|
2009-09-14 22:39:43 +04:00
|
|
|
|
|
|
|
// C++0x [temp.deduct.partial]p10:
|
2011-01-27 10:10:08 +03:00
|
|
|
// If for each type being considered a given template is at least as
|
2009-09-14 22:39:43 +04:00
|
|
|
// specialized for all types and more specialized for some set of types and
|
2011-01-27 10:10:08 +03:00
|
|
|
// the other template is not more specialized for any types or is not at
|
2009-09-14 22:39:43 +04:00
|
|
|
// least as specialized for any types, then the given template is more
|
|
|
|
// specialized than the other template. Otherwise, neither template is more
|
|
|
|
// specialized than the other.
|
|
|
|
Better1 = false;
|
|
|
|
Better2 = false;
|
2011-01-21 20:29:42 +03:00
|
|
|
for (unsigned I = 0, N = RefParamComparisons.size(); I != N; ++I) {
|
2009-09-14 22:39:43 +04:00
|
|
|
// C++0x [temp.deduct.partial]p9:
|
|
|
|
// If, for a given type, deduction succeeds in both directions (i.e., the
|
2011-01-21 20:29:42 +03:00
|
|
|
// types are identical after the transformations above) and both P and A
|
|
|
|
// were reference types (before being replaced with the type referred to
|
|
|
|
// above):
|
|
|
|
|
2011-01-27 10:10:08 +03:00
|
|
|
// -- if the type from the argument template was an lvalue reference
|
2011-01-21 20:29:42 +03:00
|
|
|
// and the type from the parameter template was not, the argument
|
|
|
|
// type is considered to be more specialized than the other;
|
|
|
|
// otherwise,
|
|
|
|
if (!RefParamComparisons[I].ArgIsRvalueRef &&
|
|
|
|
RefParamComparisons[I].ParamIsRvalueRef) {
|
|
|
|
Better2 = true;
|
|
|
|
if (Better1)
|
|
|
|
return 0;
|
|
|
|
continue;
|
|
|
|
} else if (!RefParamComparisons[I].ParamIsRvalueRef &&
|
|
|
|
RefParamComparisons[I].ArgIsRvalueRef) {
|
|
|
|
Better1 = true;
|
|
|
|
if (Better2)
|
|
|
|
return 0;
|
|
|
|
continue;
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-21 20:29:42 +03:00
|
|
|
// -- if the type from the argument template is more cv-qualified than
|
|
|
|
// the type from the parameter template (as described above), the
|
|
|
|
// argument type is considered to be more specialized than the
|
|
|
|
// other; otherwise,
|
|
|
|
switch (RefParamComparisons[I].Qualifiers) {
|
|
|
|
case NeitherMoreQualified:
|
|
|
|
break;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-21 20:29:42 +03:00
|
|
|
case ParamMoreQualified:
|
|
|
|
Better1 = true;
|
|
|
|
if (Better2)
|
|
|
|
return 0;
|
|
|
|
continue;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-21 20:29:42 +03:00
|
|
|
case ArgMoreQualified:
|
|
|
|
Better2 = true;
|
|
|
|
if (Better1)
|
|
|
|
return 0;
|
|
|
|
continue;
|
2009-09-14 22:39:43 +04:00
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-21 20:29:42 +03:00
|
|
|
// -- neither type is more specialized than the other.
|
2009-09-14 22:39:43 +04:00
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-09-14 22:39:43 +04:00
|
|
|
assert(!(Better1 && Better2) && "Should have broken out in the loop above");
|
2009-08-22 03:19:43 +04:00
|
|
|
if (Better1)
|
|
|
|
return FT1;
|
2009-09-14 22:39:43 +04:00
|
|
|
else if (Better2)
|
|
|
|
return FT2;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-16 19:03:23 +03: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 10:10:08 +03:00
|
|
|
|
2011-01-16 19:03:23 +03:00
|
|
|
return 0;
|
2009-08-22 03:19:43 +04:00
|
|
|
}
|
2009-07-09 00:55:45 +04:00
|
|
|
|
2009-09-25 22:43:00 +04:00
|
|
|
/// \brief Determine if the two templates are equivalent.
|
|
|
|
static bool isSameTemplate(TemplateDecl *T1, TemplateDecl *T2) {
|
|
|
|
if (T1 == T2)
|
|
|
|
return true;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-09-25 22:43:00 +04:00
|
|
|
if (!T1 || !T2)
|
|
|
|
return false;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-09-25 22:43:00 +04:00
|
|
|
return T1->getCanonicalDecl() == T2->getCanonicalDecl();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief Retrieve the most specialized of the given function template
|
|
|
|
/// specializations.
|
|
|
|
///
|
2010-01-27 04:50:18 +03:00
|
|
|
/// \param SpecBegin the start iterator of the function template
|
|
|
|
/// specializations that we will be comparing.
|
2009-09-25 22:43:00 +04:00
|
|
|
///
|
2010-01-27 04:50:18 +03:00
|
|
|
/// \param SpecEnd the end iterator of the function template
|
|
|
|
/// specializations, paired with \p SpecBegin.
|
2009-09-25 22:43:00 +04:00
|
|
|
///
|
|
|
|
/// \param TPOC the partial ordering context to use to compare the function
|
|
|
|
/// template specializations.
|
|
|
|
///
|
2011-01-11 20:34:58 +03:00
|
|
|
/// \param NumCallArguments The number of arguments in a call, used only
|
|
|
|
/// when \c TPOC is \c TPOC_Call.
|
|
|
|
///
|
2011-01-27 10:10:08 +03:00
|
|
|
/// \param Loc the location where the ambiguity or no-specializations
|
2009-09-25 22:43:00 +04: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 10:10:08 +03:00
|
|
|
/// \param Index if non-NULL and the result of this function is non-nULL,
|
2009-09-25 22:43:00 +04:00
|
|
|
/// receives the index corresponding to the resulting function template
|
|
|
|
/// specialization.
|
|
|
|
///
|
2011-01-27 10:10:08 +03:00
|
|
|
/// \returns the most specialized function template specialization, if
|
2010-01-27 04:50:18 +03:00
|
|
|
/// found. Otherwise, returns SpecEnd.
|
2009-09-25 22:43:00 +04:00
|
|
|
///
|
2011-01-27 10:10:08 +03:00
|
|
|
/// \todo FIXME: Consider passing in the "also-ran" candidates that failed
|
2009-09-25 22:43:00 +04:00
|
|
|
/// template argument deduction.
|
2010-01-27 04:50:18 +03:00
|
|
|
UnresolvedSetIterator
|
|
|
|
Sema::getMostSpecialized(UnresolvedSetIterator SpecBegin,
|
2011-01-11 20:34:58 +03:00
|
|
|
UnresolvedSetIterator SpecEnd,
|
2010-01-27 04:50:18 +03:00
|
|
|
TemplatePartialOrderingContext TPOC,
|
2011-01-11 20:34:58 +03:00
|
|
|
unsigned NumCallArguments,
|
2010-01-27 04:50:18 +03:00
|
|
|
SourceLocation Loc,
|
|
|
|
const PartialDiagnostic &NoneDiag,
|
|
|
|
const PartialDiagnostic &AmbigDiag,
|
2011-02-20 00:32:49 +03:00
|
|
|
const PartialDiagnostic &CandidateDiag,
|
|
|
|
bool Complain) {
|
2010-01-27 04:50:18 +03:00
|
|
|
if (SpecBegin == SpecEnd) {
|
2011-02-20 00:32:49 +03:00
|
|
|
if (Complain)
|
|
|
|
Diag(Loc, NoneDiag);
|
2010-01-27 04:50:18 +03:00
|
|
|
return SpecEnd;
|
2009-09-25 22:43:00 +04:00
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
|
|
|
if (SpecBegin + 1 == SpecEnd)
|
2010-01-27 04:50:18 +03:00
|
|
|
return SpecBegin;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-09-25 22:43:00 +04:00
|
|
|
// Find the function template that is better than all of the templates it
|
|
|
|
// has been compared to.
|
2010-01-27 04:50:18 +03:00
|
|
|
UnresolvedSetIterator Best = SpecBegin;
|
2011-01-27 10:10:08 +03:00
|
|
|
FunctionTemplateDecl *BestTemplate
|
2010-01-27 04:50:18 +03:00
|
|
|
= cast<FunctionDecl>(*Best)->getPrimaryTemplate();
|
2009-09-25 22:43:00 +04:00
|
|
|
assert(BestTemplate && "Not a function template specialization?");
|
2010-01-27 04:50:18 +03:00
|
|
|
for (UnresolvedSetIterator I = SpecBegin + 1; I != SpecEnd; ++I) {
|
|
|
|
FunctionTemplateDecl *Challenger
|
|
|
|
= cast<FunctionDecl>(*I)->getPrimaryTemplate();
|
2009-09-25 22:43:00 +04:00
|
|
|
assert(Challenger && "Not a function template specialization?");
|
2010-01-27 04:50:18 +03:00
|
|
|
if (isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger,
|
2011-01-11 20:34:58 +03:00
|
|
|
Loc, TPOC, NumCallArguments),
|
2009-09-25 22:43:00 +04:00
|
|
|
Challenger)) {
|
|
|
|
Best = I;
|
|
|
|
BestTemplate = Challenger;
|
|
|
|
}
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-09-25 22:43:00 +04:00
|
|
|
// Make sure that the "best" function template is more specialized than all
|
|
|
|
// of the others.
|
|
|
|
bool Ambiguous = false;
|
2010-01-27 04:50:18 +03:00
|
|
|
for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) {
|
|
|
|
FunctionTemplateDecl *Challenger
|
|
|
|
= cast<FunctionDecl>(*I)->getPrimaryTemplate();
|
2009-09-25 22:43:00 +04:00
|
|
|
if (I != Best &&
|
2011-01-27 10:10:08 +03:00
|
|
|
!isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger,
|
2011-01-11 20:34:58 +03:00
|
|
|
Loc, TPOC, NumCallArguments),
|
2009-09-25 22:43:00 +04:00
|
|
|
BestTemplate)) {
|
|
|
|
Ambiguous = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-09-25 22:43:00 +04:00
|
|
|
if (!Ambiguous) {
|
|
|
|
// We found an answer. Return it.
|
2010-01-27 04:50:18 +03:00
|
|
|
return Best;
|
2009-09-25 22:43:00 +04:00
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-09-25 22:43:00 +04:00
|
|
|
// Diagnose the ambiguity.
|
2011-02-20 00:32:49 +03:00
|
|
|
if (Complain)
|
|
|
|
Diag(Loc, AmbigDiag);
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-02-20 00:32:49 +03:00
|
|
|
if (Complain)
|
2009-09-25 22:43:00 +04:00
|
|
|
// FIXME: Can we order the candidates in some sane way?
|
2011-02-20 00:32:49 +03:00
|
|
|
for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I)
|
|
|
|
Diag((*I)->getLocation(), CandidateDiag)
|
|
|
|
<< getTemplateArgumentBindingsText(
|
|
|
|
cast<FunctionDecl>(*I)->getPrimaryTemplate()->getTemplateParameters(),
|
2010-01-27 04:50:18 +03:00
|
|
|
*cast<FunctionDecl>(*I)->getTemplateSpecializationArgs());
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-01-27 04:50:18 +03:00
|
|
|
return SpecEnd;
|
2009-09-25 22:43:00 +04:00
|
|
|
}
|
|
|
|
|
2009-09-15 20:23:51 +04: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 02:07:23 +03:00
|
|
|
ClassTemplatePartialSpecializationDecl *PS2,
|
|
|
|
SourceLocation Loc) {
|
2009-09-15 20:23:51 +04:00
|
|
|
// C++ [temp.class.order]p1:
|
|
|
|
// For two class template partial specializations, the first is at least as
|
2011-01-27 10:10:08 +03: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-15 20:23:51 +04:00
|
|
|
// templates (14.6.6.2):
|
|
|
|
// - the first function template has the same template parameters as the
|
2011-01-27 10:10:08 +03:00
|
|
|
// first partial specialization and has a single function parameter
|
|
|
|
// whose type is a class template specialization with the template
|
2009-09-15 20:23:51 +04:00
|
|
|
// arguments of the first partial specialization, and
|
|
|
|
// - the second function template has the same template parameters as the
|
2011-01-27 10:10:08 +03:00
|
|
|
// second partial specialization and has a single function parameter
|
|
|
|
// whose type is a class template specialization with the template
|
2009-09-15 20:23:51 +04:00
|
|
|
// arguments of the second partial specialization.
|
|
|
|
//
|
2010-04-29 10:21:43 +04: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.
|
2010-03-28 06:42:43 +04:00
|
|
|
llvm::SmallVector<DeducedTemplateArgument, 4> Deduced;
|
2010-08-25 09:32:35 +04:00
|
|
|
TemplateDeductionInfo Info(Context, Loc);
|
2010-04-27 04:57:59 +04:00
|
|
|
|
|
|
|
QualType PT1 = PS1->getInjectedSpecializationType();
|
|
|
|
QualType PT2 = PS2->getInjectedSpecializationType();
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-09-15 20:23:51 +04:00
|
|
|
// Determine whether PS1 is at least as specialized as PS2
|
|
|
|
Deduced.resize(PS2->getTemplateParameters()->size());
|
2011-01-11 20:34:58 +03:00
|
|
|
bool Better1 = !::DeduceTemplateArguments(*this, PS2->getTemplateParameters(),
|
|
|
|
PT2, PT1, Info, Deduced, TDF_None,
|
2011-01-27 10:10:08 +03:00
|
|
|
/*PartialOrdering=*/true,
|
2011-01-21 20:29:42 +03:00
|
|
|
/*RefParamComparisons=*/0);
|
2010-11-06 02:25:18 +03:00
|
|
|
if (Better1) {
|
|
|
|
InstantiatingTemplate Inst(*this, PS2->getLocation(), PS2,
|
|
|
|
Deduced.data(), Deduced.size(), Info);
|
2011-01-27 10:10:08 +03:00
|
|
|
Better1 = !::FinishTemplateArgumentDeduction(*this, PS2,
|
|
|
|
PS1->getTemplateArgs(),
|
2010-04-29 10:31:36 +04:00
|
|
|
Deduced, Info);
|
2010-11-06 02:25:18 +03:00
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-09-15 20:23:51 +04:00
|
|
|
// Determine whether PS2 is at least as specialized as PS1
|
2009-11-12 02:06:43 +03:00
|
|
|
Deduced.clear();
|
2009-09-15 20:23:51 +04:00
|
|
|
Deduced.resize(PS1->getTemplateParameters()->size());
|
2011-01-11 20:34:58 +03:00
|
|
|
bool Better2 = !::DeduceTemplateArguments(*this, PS1->getTemplateParameters(),
|
|
|
|
PT1, PT2, Info, Deduced, TDF_None,
|
|
|
|
/*PartialOrdering=*/true,
|
2011-01-21 20:29:42 +03:00
|
|
|
/*RefParamComparisons=*/0);
|
2010-11-06 02:25:18 +03:00
|
|
|
if (Better2) {
|
|
|
|
InstantiatingTemplate Inst(*this, PS1->getLocation(), PS1,
|
|
|
|
Deduced.data(), Deduced.size(), Info);
|
2011-01-27 10:10:08 +03:00
|
|
|
Better2 = !::FinishTemplateArgumentDeduction(*this, PS1,
|
|
|
|
PS2->getTemplateArgs(),
|
2010-04-29 10:31:36 +04:00
|
|
|
Deduced, Info);
|
2010-11-06 02:25:18 +03:00
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-09-15 20:23:51 +04:00
|
|
|
if (Better1 == Better2)
|
|
|
|
return 0;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-09-15 20:23:51 +04:00
|
|
|
return Better1? PS1 : PS2;
|
|
|
|
}
|
|
|
|
|
2009-09-09 19:08:12 +04:00
|
|
|
static void
|
2009-09-15 01:25:05 +04:00
|
|
|
MarkUsedTemplateParameters(Sema &SemaRef,
|
|
|
|
const TemplateArgument &TemplateArg,
|
|
|
|
bool OnlyDeduced,
|
2009-10-29 03:04:11 +03:00
|
|
|
unsigned Depth,
|
2009-09-15 01:25:05 +04:00
|
|
|
llvm::SmallVectorImpl<bool> &Used);
|
2009-06-13 04:26:55 +04:00
|
|
|
|
2009-09-15 01:25:05 +04:00
|
|
|
/// \brief Mark the template parameters that are used by the given
|
2009-06-13 04:26:55 +04:00
|
|
|
/// expression.
|
2009-09-09 19:08:12 +04:00
|
|
|
static void
|
2009-09-15 01:25:05 +04:00
|
|
|
MarkUsedTemplateParameters(Sema &SemaRef,
|
|
|
|
const Expr *E,
|
|
|
|
bool OnlyDeduced,
|
2009-10-29 03:04:11 +03:00
|
|
|
unsigned Depth,
|
2009-09-15 01:25:05 +04:00
|
|
|
llvm::SmallVectorImpl<bool> &Used) {
|
2011-01-03 20:17:50 +03:00
|
|
|
// We can deduce from a pack expansion.
|
|
|
|
if (const PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(E))
|
|
|
|
E = Expansion->getPattern();
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2011-01-05 02:35:54 +03:00
|
|
|
// Skip through any implicit casts we added while type-checking.
|
|
|
|
while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
|
|
|
|
E = ICE->getSubExpr();
|
2011-01-27 10:10:08 +03:00
|
|
|
|
|
|
|
// FIXME: if !OnlyDeduced, we have to walk the whole subexpression to
|
2009-09-15 01:25:05 +04:00
|
|
|
// find other occurrences of template parameters.
|
2009-06-18 22:45:36 +04:00
|
|
|
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E);
|
2010-01-14 21:13:22 +03:00
|
|
|
if (!DRE)
|
2009-06-13 04:26:55 +04:00
|
|
|
return;
|
|
|
|
|
2009-09-09 19:08:12 +04:00
|
|
|
const NonTypeTemplateParmDecl *NTTP
|
2009-06-13 04:26:55 +04:00
|
|
|
= dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl());
|
|
|
|
if (!NTTP)
|
|
|
|
return;
|
|
|
|
|
2009-10-29 03:04:11 +03:00
|
|
|
if (NTTP->getDepth() == Depth)
|
|
|
|
Used[NTTP->getIndex()] = true;
|
2009-06-13 04:26:55 +04:00
|
|
|
}
|
|
|
|
|
2009-09-15 01:25:05 +04:00
|
|
|
/// \brief Mark the template parameters that are used by the given
|
|
|
|
/// nested name specifier.
|
|
|
|
static void
|
|
|
|
MarkUsedTemplateParameters(Sema &SemaRef,
|
|
|
|
NestedNameSpecifier *NNS,
|
|
|
|
bool OnlyDeduced,
|
2009-10-29 03:04:11 +03:00
|
|
|
unsigned Depth,
|
2009-09-15 01:25:05 +04:00
|
|
|
llvm::SmallVectorImpl<bool> &Used) {
|
|
|
|
if (!NNS)
|
|
|
|
return;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-10-29 03:04:11 +03:00
|
|
|
MarkUsedTemplateParameters(SemaRef, NNS->getPrefix(), OnlyDeduced, Depth,
|
|
|
|
Used);
|
2011-01-27 10:10:08 +03:00
|
|
|
MarkUsedTemplateParameters(SemaRef, QualType(NNS->getAsType(), 0),
|
2009-10-29 03:04:11 +03:00
|
|
|
OnlyDeduced, Depth, Used);
|
2009-09-15 01:25:05 +04:00
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-09-15 01:25:05 +04:00
|
|
|
/// \brief Mark the template parameters that are used by the given
|
|
|
|
/// template name.
|
|
|
|
static void
|
|
|
|
MarkUsedTemplateParameters(Sema &SemaRef,
|
|
|
|
TemplateName Name,
|
|
|
|
bool OnlyDeduced,
|
2009-10-29 03:04:11 +03:00
|
|
|
unsigned Depth,
|
2009-09-15 01:25:05 +04:00
|
|
|
llvm::SmallVectorImpl<bool> &Used) {
|
|
|
|
if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
|
|
|
|
if (TemplateTemplateParmDecl *TTP
|
2009-10-29 03:04:11 +03:00
|
|
|
= dyn_cast<TemplateTemplateParmDecl>(Template)) {
|
|
|
|
if (TTP->getDepth() == Depth)
|
|
|
|
Used[TTP->getIndex()] = true;
|
|
|
|
}
|
2009-09-15 01:25:05 +04:00
|
|
|
return;
|
|
|
|
}
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-11-11 04:00:40 +03:00
|
|
|
if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName())
|
2011-01-27 10:10:08 +03:00
|
|
|
MarkUsedTemplateParameters(SemaRef, QTN->getQualifier(), OnlyDeduced,
|
2009-11-11 04:00:40 +03:00
|
|
|
Depth, Used);
|
2009-09-15 01:25:05 +04:00
|
|
|
if (DependentTemplateName *DTN = Name.getAsDependentTemplateName())
|
2011-01-27 10:10:08 +03:00
|
|
|
MarkUsedTemplateParameters(SemaRef, DTN->getQualifier(), OnlyDeduced,
|
2009-10-29 03:04:11 +03:00
|
|
|
Depth, Used);
|
2009-09-15 01:25:05 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief Mark the template parameters that are used by the given
|
2009-06-13 04:26:55 +04:00
|
|
|
/// type.
|
2009-09-09 19:08:12 +04:00
|
|
|
static void
|
2009-09-15 01:25:05 +04:00
|
|
|
MarkUsedTemplateParameters(Sema &SemaRef, QualType T,
|
|
|
|
bool OnlyDeduced,
|
2009-10-29 03:04:11 +03:00
|
|
|
unsigned Depth,
|
2009-09-15 01:25:05 +04:00
|
|
|
llvm::SmallVectorImpl<bool> &Used) {
|
|
|
|
if (T.isNull())
|
|
|
|
return;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-06-13 04:26:55 +04:00
|
|
|
// Non-dependent types have nothing deducible
|
|
|
|
if (!T->isDependentType())
|
|
|
|
return;
|
|
|
|
|
|
|
|
T = SemaRef.Context.getCanonicalType(T);
|
|
|
|
switch (T->getTypeClass()) {
|
|
|
|
case Type::Pointer:
|
2009-09-15 01:25:05 +04:00
|
|
|
MarkUsedTemplateParameters(SemaRef,
|
|
|
|
cast<PointerType>(T)->getPointeeType(),
|
|
|
|
OnlyDeduced,
|
2009-10-29 03:04:11 +03:00
|
|
|
Depth,
|
2009-09-15 01:25:05 +04:00
|
|
|
Used);
|
2009-06-13 04:26:55 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case Type::BlockPointer:
|
2009-09-15 01:25:05 +04:00
|
|
|
MarkUsedTemplateParameters(SemaRef,
|
|
|
|
cast<BlockPointerType>(T)->getPointeeType(),
|
|
|
|
OnlyDeduced,
|
2009-10-29 03:04:11 +03:00
|
|
|
Depth,
|
2009-09-15 01:25:05 +04:00
|
|
|
Used);
|
2009-06-13 04:26:55 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case Type::LValueReference:
|
|
|
|
case Type::RValueReference:
|
2009-09-15 01:25:05 +04:00
|
|
|
MarkUsedTemplateParameters(SemaRef,
|
|
|
|
cast<ReferenceType>(T)->getPointeeType(),
|
|
|
|
OnlyDeduced,
|
2009-10-29 03:04:11 +03:00
|
|
|
Depth,
|
2009-09-15 01:25:05 +04:00
|
|
|
Used);
|
2009-06-13 04:26:55 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case Type::MemberPointer: {
|
|
|
|
const MemberPointerType *MemPtr = cast<MemberPointerType>(T.getTypePtr());
|
2009-09-15 01:25:05 +04:00
|
|
|
MarkUsedTemplateParameters(SemaRef, MemPtr->getPointeeType(), OnlyDeduced,
|
2009-10-29 03:04:11 +03:00
|
|
|
Depth, Used);
|
2009-09-15 01:25:05 +04:00
|
|
|
MarkUsedTemplateParameters(SemaRef, QualType(MemPtr->getClass(), 0),
|
2009-10-29 03:04:11 +03:00
|
|
|
OnlyDeduced, Depth, Used);
|
2009-06-13 04:26:55 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case Type::DependentSizedArray:
|
2009-09-15 01:25:05 +04:00
|
|
|
MarkUsedTemplateParameters(SemaRef,
|
|
|
|
cast<DependentSizedArrayType>(T)->getSizeExpr(),
|
2009-10-29 03:04:11 +03:00
|
|
|
OnlyDeduced, Depth, Used);
|
2009-06-13 04:26:55 +04:00
|
|
|
// Fall through to check the element type
|
|
|
|
|
|
|
|
case Type::ConstantArray:
|
|
|
|
case Type::IncompleteArray:
|
2009-09-15 01:25:05 +04:00
|
|
|
MarkUsedTemplateParameters(SemaRef,
|
|
|
|
cast<ArrayType>(T)->getElementType(),
|
2009-10-29 03:04:11 +03:00
|
|
|
OnlyDeduced, Depth, Used);
|
2009-06-13 04:26:55 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case Type::Vector:
|
|
|
|
case Type::ExtVector:
|
2009-09-15 01:25:05 +04:00
|
|
|
MarkUsedTemplateParameters(SemaRef,
|
|
|
|
cast<VectorType>(T)->getElementType(),
|
2009-10-29 03:04:11 +03:00
|
|
|
OnlyDeduced, Depth, Used);
|
2009-06-13 04:26:55 +04:00
|
|
|
break;
|
|
|
|
|
2009-06-18 01:51:59 +04:00
|
|
|
case Type::DependentSizedExtVector: {
|
|
|
|
const DependentSizedExtVectorType *VecType
|
2009-06-18 22:45:36 +04:00
|
|
|
= cast<DependentSizedExtVectorType>(T);
|
2009-09-15 01:25:05 +04:00
|
|
|
MarkUsedTemplateParameters(SemaRef, VecType->getElementType(), OnlyDeduced,
|
2009-10-29 03:04:11 +03:00
|
|
|
Depth, Used);
|
2011-01-27 10:10:08 +03:00
|
|
|
MarkUsedTemplateParameters(SemaRef, VecType->getSizeExpr(), OnlyDeduced,
|
2009-10-29 03:04:11 +03:00
|
|
|
Depth, Used);
|
2009-06-18 01:51:59 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-06-13 04:26:55 +04:00
|
|
|
case Type::FunctionProto: {
|
2009-06-18 22:45:36 +04:00
|
|
|
const FunctionProtoType *Proto = cast<FunctionProtoType>(T);
|
2009-09-15 01:25:05 +04:00
|
|
|
MarkUsedTemplateParameters(SemaRef, Proto->getResultType(), OnlyDeduced,
|
2009-10-29 03:04:11 +03:00
|
|
|
Depth, Used);
|
2009-06-13 04:26:55 +04:00
|
|
|
for (unsigned I = 0, N = Proto->getNumArgs(); I != N; ++I)
|
2009-09-15 01:25:05 +04:00
|
|
|
MarkUsedTemplateParameters(SemaRef, Proto->getArgType(I), OnlyDeduced,
|
2009-10-29 03:04:11 +03:00
|
|
|
Depth, Used);
|
2009-06-13 04:26:55 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-10-29 03:04:11 +03:00
|
|
|
case Type::TemplateTypeParm: {
|
|
|
|
const TemplateTypeParmType *TTP = cast<TemplateTypeParmType>(T);
|
|
|
|
if (TTP->getDepth() == Depth)
|
|
|
|
Used[TTP->getIndex()] = true;
|
2009-06-13 04:26:55 +04:00
|
|
|
break;
|
2009-10-29 03:04:11 +03:00
|
|
|
}
|
2009-06-13 04:26:55 +04:00
|
|
|
|
2011-01-14 08:11:40 +03:00
|
|
|
case Type::SubstTemplateTypeParmPack: {
|
|
|
|
const SubstTemplateTypeParmPackType *Subst
|
|
|
|
= cast<SubstTemplateTypeParmPackType>(T);
|
2011-01-27 10:10:08 +03:00
|
|
|
MarkUsedTemplateParameters(SemaRef,
|
2011-01-14 08:11:40 +03:00
|
|
|
QualType(Subst->getReplacedParameter(), 0),
|
|
|
|
OnlyDeduced, Depth, Used);
|
|
|
|
MarkUsedTemplateParameters(SemaRef, Subst->getArgumentPack(),
|
|
|
|
OnlyDeduced, Depth, Used);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-04-27 04:57:59 +04:00
|
|
|
case Type::InjectedClassName:
|
|
|
|
T = cast<InjectedClassNameType>(T)->getInjectedSpecializationType();
|
|
|
|
// fall through
|
|
|
|
|
2009-06-13 04:26:55 +04:00
|
|
|
case Type::TemplateSpecialization: {
|
2009-09-09 19:08:12 +04:00
|
|
|
const TemplateSpecializationType *Spec
|
2009-06-18 22:45:36 +04:00
|
|
|
= cast<TemplateSpecializationType>(T);
|
2009-09-15 01:25:05 +04:00
|
|
|
MarkUsedTemplateParameters(SemaRef, Spec->getTemplateName(), OnlyDeduced,
|
2009-10-29 03:04:11 +03:00
|
|
|
Depth, Used);
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 04:24:45 +03:00
|
|
|
// C++0x [temp.deduct.type]p9:
|
2011-01-27 10:10:08 +03: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 04:24:45 +03:00
|
|
|
// non-deduced context.
|
2011-01-27 10:10:08 +03:00
|
|
|
if (OnlyDeduced &&
|
2010-12-23 04:24:45 +03:00
|
|
|
hasPackExpansionBeforeEnd(Spec->getArgs(), Spec->getNumArgs()))
|
|
|
|
break;
|
|
|
|
|
2009-09-15 01:25:05 +04:00
|
|
|
for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I)
|
2009-10-29 03:04:11 +03:00
|
|
|
MarkUsedTemplateParameters(SemaRef, Spec->getArg(I), OnlyDeduced, Depth,
|
|
|
|
Used);
|
2009-09-15 01:25:05 +04:00
|
|
|
break;
|
|
|
|
}
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-09-15 01:25:05 +04:00
|
|
|
case Type::Complex:
|
|
|
|
if (!OnlyDeduced)
|
2011-01-27 10:10:08 +03:00
|
|
|
MarkUsedTemplateParameters(SemaRef,
|
2009-09-15 01:25:05 +04:00
|
|
|
cast<ComplexType>(T)->getElementType(),
|
2009-10-29 03:04:11 +03:00
|
|
|
OnlyDeduced, Depth, Used);
|
2009-09-15 01:25:05 +04:00
|
|
|
break;
|
2009-06-13 04:26:55 +04:00
|
|
|
|
2010-03-31 21:34:00 +04:00
|
|
|
case Type::DependentName:
|
2009-09-15 01:25:05 +04:00
|
|
|
if (!OnlyDeduced)
|
|
|
|
MarkUsedTemplateParameters(SemaRef,
|
2010-03-31 21:34:00 +04:00
|
|
|
cast<DependentNameType>(T)->getQualifier(),
|
2009-10-29 03:04:11 +03:00
|
|
|
OnlyDeduced, Depth, Used);
|
2009-06-13 04:26:55 +04:00
|
|
|
break;
|
|
|
|
|
2010-06-11 04:33:02 +04:00
|
|
|
case Type::DependentTemplateSpecialization: {
|
|
|
|
const DependentTemplateSpecializationType *Spec
|
|
|
|
= cast<DependentTemplateSpecializationType>(T);
|
|
|
|
if (!OnlyDeduced)
|
|
|
|
MarkUsedTemplateParameters(SemaRef, Spec->getQualifier(),
|
|
|
|
OnlyDeduced, Depth, Used);
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2010-12-23 04:24:45 +03:00
|
|
|
// C++0x [temp.deduct.type]p9:
|
2011-01-27 10:10:08 +03: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 04:24:45 +03:00
|
|
|
// non-deduced context.
|
2011-01-27 10:10:08 +03:00
|
|
|
if (OnlyDeduced &&
|
2010-12-23 04:24:45 +03:00
|
|
|
hasPackExpansionBeforeEnd(Spec->getArgs(), Spec->getNumArgs()))
|
|
|
|
break;
|
|
|
|
|
2010-06-11 04:33:02 +04:00
|
|
|
for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I)
|
|
|
|
MarkUsedTemplateParameters(SemaRef, Spec->getArg(I), OnlyDeduced, Depth,
|
|
|
|
Used);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-03-02 02:49:17 +03:00
|
|
|
case Type::TypeOf:
|
|
|
|
if (!OnlyDeduced)
|
|
|
|
MarkUsedTemplateParameters(SemaRef,
|
|
|
|
cast<TypeOfType>(T)->getUnderlyingType(),
|
|
|
|
OnlyDeduced, Depth, Used);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Type::TypeOfExpr:
|
|
|
|
if (!OnlyDeduced)
|
|
|
|
MarkUsedTemplateParameters(SemaRef,
|
|
|
|
cast<TypeOfExprType>(T)->getUnderlyingExpr(),
|
|
|
|
OnlyDeduced, Depth, Used);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Type::Decltype:
|
|
|
|
if (!OnlyDeduced)
|
|
|
|
MarkUsedTemplateParameters(SemaRef,
|
|
|
|
cast<DecltypeType>(T)->getUnderlyingExpr(),
|
|
|
|
OnlyDeduced, Depth, Used);
|
|
|
|
break;
|
2011-05-25 02:41:36 +04:00
|
|
|
|
|
|
|
case Type::UnaryTransform:
|
|
|
|
if (!OnlyDeduced)
|
|
|
|
MarkUsedTemplateParameters(SemaRef,
|
|
|
|
cast<UnaryTransformType>(T)->getUnderlyingType(),
|
|
|
|
OnlyDeduced, Depth, Used);
|
|
|
|
break;
|
2010-03-02 02:49:17 +03:00
|
|
|
|
2010-12-20 05:24:11 +03:00
|
|
|
case Type::PackExpansion:
|
2011-01-27 10:10:08 +03:00
|
|
|
MarkUsedTemplateParameters(SemaRef,
|
2010-12-20 05:24:11 +03:00
|
|
|
cast<PackExpansionType>(T)->getPattern(),
|
|
|
|
OnlyDeduced, Depth, Used);
|
|
|
|
break;
|
|
|
|
|
2011-02-20 06:19:35 +03:00
|
|
|
case Type::Auto:
|
|
|
|
MarkUsedTemplateParameters(SemaRef,
|
|
|
|
cast<AutoType>(T)->getDeducedType(),
|
|
|
|
OnlyDeduced, Depth, Used);
|
|
|
|
|
2009-09-15 01:25:05 +04:00
|
|
|
// None of these types have any template parameters in them.
|
2009-06-13 04:26:55 +04:00
|
|
|
case Type::Builtin:
|
|
|
|
case Type::VariableArray:
|
|
|
|
case Type::FunctionNoProto:
|
|
|
|
case Type::Record:
|
|
|
|
case Type::Enum:
|
|
|
|
case Type::ObjCInterface:
|
2010-05-15 15:32:37 +04:00
|
|
|
case Type::ObjCObject:
|
2009-06-18 02:40:22 +04:00
|
|
|
case Type::ObjCObjectPointer:
|
2009-12-05 01:46:56 +03:00
|
|
|
case Type::UnresolvedUsing:
|
2009-06-13 04:26:55 +04: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 01:25:05 +04:00
|
|
|
/// \brief Mark the template parameters that are used by this
|
2009-06-13 04:26:55 +04:00
|
|
|
/// template argument.
|
2009-09-09 19:08:12 +04:00
|
|
|
static void
|
2009-09-15 01:25:05 +04:00
|
|
|
MarkUsedTemplateParameters(Sema &SemaRef,
|
|
|
|
const TemplateArgument &TemplateArg,
|
|
|
|
bool OnlyDeduced,
|
2009-10-29 03:04:11 +03:00
|
|
|
unsigned Depth,
|
2009-09-15 01:25:05 +04:00
|
|
|
llvm::SmallVectorImpl<bool> &Used) {
|
2009-06-13 04:26:55 +04:00
|
|
|
switch (TemplateArg.getKind()) {
|
|
|
|
case TemplateArgument::Null:
|
|
|
|
case TemplateArgument::Integral:
|
2009-11-11 04:00:40 +03:00
|
|
|
case TemplateArgument::Declaration:
|
2009-06-13 04:26:55 +04:00
|
|
|
break;
|
2009-09-09 19:08:12 +04:00
|
|
|
|
2009-06-13 04:26:55 +04:00
|
|
|
case TemplateArgument::Type:
|
2009-09-15 01:25:05 +04:00
|
|
|
MarkUsedTemplateParameters(SemaRef, TemplateArg.getAsType(), OnlyDeduced,
|
2009-10-29 03:04:11 +03:00
|
|
|
Depth, Used);
|
2009-06-13 04:26:55 +04:00
|
|
|
break;
|
|
|
|
|
2009-11-11 04:00:40 +03:00
|
|
|
case TemplateArgument::Template:
|
2011-01-05 21:58:31 +03:00
|
|
|
case TemplateArgument::TemplateExpansion:
|
2011-01-27 10:10:08 +03:00
|
|
|
MarkUsedTemplateParameters(SemaRef,
|
|
|
|
TemplateArg.getAsTemplateOrTemplatePattern(),
|
2009-11-11 04:00:40 +03:00
|
|
|
OnlyDeduced, Depth, Used);
|
2009-06-13 04:26:55 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TemplateArgument::Expression:
|
2011-01-27 10:10:08 +03:00
|
|
|
MarkUsedTemplateParameters(SemaRef, TemplateArg.getAsExpr(), OnlyDeduced,
|
2009-10-29 03:04:11 +03:00
|
|
|
Depth, Used);
|
2009-06-13 04:26:55 +04:00
|
|
|
break;
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-06-15 21:04:53 +04:00
|
|
|
case TemplateArgument::Pack:
|
2009-09-15 01:25:05 +04:00
|
|
|
for (TemplateArgument::pack_iterator P = TemplateArg.pack_begin(),
|
|
|
|
PEnd = TemplateArg.pack_end();
|
|
|
|
P != PEnd; ++P)
|
2009-10-29 03:04:11 +03:00
|
|
|
MarkUsedTemplateParameters(SemaRef, *P, OnlyDeduced, Depth, Used);
|
2009-06-15 21:04:53 +04:00
|
|
|
break;
|
2009-06-13 04:26:55 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief Mark the template parameters can be deduced by the given
|
|
|
|
/// template argument list.
|
|
|
|
///
|
|
|
|
/// \param TemplateArgs the template argument list from which template
|
|
|
|
/// parameters will be deduced.
|
|
|
|
///
|
|
|
|
/// \param Deduced a bit vector whose elements will be set to \c true
|
|
|
|
/// to indicate when the corresponding template parameter will be
|
|
|
|
/// deduced.
|
2009-09-09 19:08:12 +04:00
|
|
|
void
|
2009-09-15 01:25:05 +04:00
|
|
|
Sema::MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs,
|
2009-10-29 03:04:11 +03:00
|
|
|
bool OnlyDeduced, unsigned Depth,
|
2009-09-15 01:25:05 +04:00
|
|
|
llvm::SmallVectorImpl<bool> &Used) {
|
2010-12-23 04:24:45 +03:00
|
|
|
// C++0x [temp.deduct.type]p9:
|
2011-01-27 10:10:08 +03: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 04:24:45 +03:00
|
|
|
// non-deduced context.
|
2011-01-27 10:10:08 +03:00
|
|
|
if (OnlyDeduced &&
|
2010-12-23 04:24:45 +03:00
|
|
|
hasPackExpansionBeforeEnd(TemplateArgs.data(), TemplateArgs.size()))
|
|
|
|
return;
|
|
|
|
|
2009-06-13 04:26:55 +04:00
|
|
|
for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
|
2011-01-27 10:10:08 +03:00
|
|
|
::MarkUsedTemplateParameters(*this, TemplateArgs[I], OnlyDeduced,
|
2009-10-29 03:04:11 +03:00
|
|
|
Depth, Used);
|
2009-06-13 04:26:55 +04:00
|
|
|
}
|
2009-09-19 03:21:38 +04:00
|
|
|
|
|
|
|
/// \brief Marks all of the template parameters that will be deduced by a
|
|
|
|
/// call to the given function template.
|
2011-01-27 10:10:08 +03:00
|
|
|
void
|
2010-03-28 06:42:43 +04:00
|
|
|
Sema::MarkDeducedTemplateParameters(FunctionTemplateDecl *FunctionTemplate,
|
|
|
|
llvm::SmallVectorImpl<bool> &Deduced) {
|
2011-01-27 10:10:08 +03:00
|
|
|
TemplateParameterList *TemplateParams
|
2009-09-19 03:21:38 +04:00
|
|
|
= FunctionTemplate->getTemplateParameters();
|
|
|
|
Deduced.clear();
|
|
|
|
Deduced.resize(TemplateParams->size());
|
2011-01-27 10:10:08 +03:00
|
|
|
|
2009-09-19 03:21:38 +04:00
|
|
|
FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
|
|
|
|
for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I)
|
|
|
|
::MarkUsedTemplateParameters(*this, Function->getParamDecl(I)->getType(),
|
2009-10-29 03:04:11 +03:00
|
|
|
true, TemplateParams->getDepth(), Deduced);
|
2009-09-19 03:21:38 +04:00
|
|
|
}
|
2011-06-16 20:50:48 +04:00
|
|
|
|
|
|
|
bool hasDeducibleTemplateParameters(Sema &S,
|
|
|
|
FunctionTemplateDecl *FunctionTemplate,
|
|
|
|
QualType T) {
|
|
|
|
if (!T->isDependentType())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
TemplateParameterList *TemplateParams
|
|
|
|
= FunctionTemplate->getTemplateParameters();
|
|
|
|
llvm::SmallVector<bool, 4> Deduced;
|
|
|
|
Deduced.resize(TemplateParams->size());
|
|
|
|
::MarkUsedTemplateParameters(S, T, true, TemplateParams->getDepth(),
|
|
|
|
Deduced);
|
|
|
|
|
|
|
|
for (unsigned I = 0, N = Deduced.size(); I != N; ++I)
|
|
|
|
if (Deduced[I])
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|