summaryrefslogtreecommitdiffstats
path: root/clang/lib/Sema
diff options
context:
space:
mode:
Diffstat (limited to 'clang/lib/Sema')
-rw-r--r--clang/lib/Sema/Sema.h24
-rw-r--r--clang/lib/Sema/SemaTemplate.cpp12
-rw-r--r--clang/lib/Sema/SemaTemplateInstantiate.cpp67
-rw-r--r--clang/lib/Sema/SemaTemplateInstantiateDecl.cpp40
-rw-r--r--clang/lib/Sema/SemaTemplateInstantiateExpr.cpp20
-rw-r--r--clang/lib/Sema/SemaType.cpp4
6 files changed, 63 insertions, 104 deletions
diff --git a/clang/lib/Sema/Sema.h b/clang/lib/Sema/Sema.h
index 21aca40c7d2..83565095509 100644
--- a/clang/lib/Sema/Sema.h
+++ b/clang/lib/Sema/Sema.h
@@ -65,6 +65,7 @@ namespace clang {
class TypedefDecl;
class TemplateDecl;
class TemplateArgument;
+ class TemplateArgumentList;
class TemplateParameterList;
class TemplateTemplateParmDecl;
class ClassTemplateDecl;
@@ -1974,7 +1975,7 @@ public:
uintptr_t Entity;
// \brief If this the instantiation of a default template
- // argument, the list of tempalte arguments.
+ // argument, the list of template arguments.
const TemplateArgument *TemplateArgs;
/// \brief The number of template arguments in TemplateArgs.
@@ -2074,29 +2075,24 @@ public:
void PrintInstantiationStack();
- QualType InstantiateType(QualType T, const TemplateArgument *TemplateArgs,
- unsigned NumTemplateArgs,
+ QualType InstantiateType(QualType T, const TemplateArgumentList &TemplateArgs,
SourceLocation Loc, DeclarationName Entity);
OwningExprResult InstantiateExpr(Expr *E,
- const TemplateArgument *TemplateArgs,
- unsigned NumTemplateArgs);
+ const TemplateArgumentList &TemplateArgs);
Decl *InstantiateDecl(Decl *D, DeclContext *Owner,
- const TemplateArgument *TemplateArgs,
- unsigned NumTemplateArgs);
+ const TemplateArgumentList &TemplateArgs);
bool
InstantiateBaseSpecifiers(CXXRecordDecl *Instantiation,
CXXRecordDecl *Pattern,
- const TemplateArgument *TemplateArgs,
- unsigned NumTemplateArgs);
+ const TemplateArgumentList &TemplateArgs);
bool
InstantiateClass(SourceLocation PointOfInstantiation,
CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,
- const TemplateArgument *TemplateArgs,
- unsigned NumTemplateArgs);
+ const TemplateArgumentList &TemplateArgs);
bool
InstantiateClassTemplateSpecialization(
@@ -2106,13 +2102,11 @@ public:
NestedNameSpecifier *
InstantiateNestedNameSpecifier(NestedNameSpecifier *NNS,
SourceRange Range,
- const TemplateArgument *TemplateArgs,
- unsigned NumTemplateArgs);
+ const TemplateArgumentList &TemplateArgs);
TemplateName
InstantiateTemplateName(TemplateName Name, SourceLocation Loc,
- const TemplateArgument *TemplateArgs,
- unsigned NumTemplateArgs);
+ const TemplateArgumentList &TemplateArgs);
// Simple function for cloning expressions.
template<typename T>
diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp
index 3938978dfd5..fc44217252a 100644
--- a/clang/lib/Sema/SemaTemplate.cpp
+++ b/clang/lib/Sema/SemaTemplate.cpp
@@ -993,7 +993,11 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template,
Template, &Converted[0],
Converted.size(),
SourceRange(TemplateLoc, RAngleLoc));
- ArgType = InstantiateType(ArgType, &Converted[0], Converted.size(),
+
+ TemplateArgumentList TemplateArgs(Context, &Converted[0],
+ Converted.size(),
+ /*CopyArgs=*/false);
+ ArgType = InstantiateType(ArgType, TemplateArgs,
TTP->getDefaultArgumentLoc(),
TTP->getDeclName());
}
@@ -1061,8 +1065,10 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template,
Converted.size(),
SourceRange(TemplateLoc, RAngleLoc));
- NTTPType = InstantiateType(NTTPType,
- &Converted[0], Converted.size(),
+ TemplateArgumentList TemplateArgs(Context, &Converted[0],
+ Converted.size(),
+ /*CopyArgs=*/false);
+ NTTPType = InstantiateType(NTTPType, TemplateArgs,
NTTP->getLocation(),
NTTP->getDeclName());
// If that worked, check the non-type template parameter type
diff --git a/clang/lib/Sema/SemaTemplateInstantiate.cpp b/clang/lib/Sema/SemaTemplateInstantiate.cpp
index ac8f293a803..0fe6cee882c 100644
--- a/clang/lib/Sema/SemaTemplateInstantiate.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp
@@ -133,19 +133,17 @@ void Sema::PrintInstantiationStack() {
namespace {
class VISIBILITY_HIDDEN TemplateTypeInstantiator {
Sema &SemaRef;
- const TemplateArgument *TemplateArgs;
- unsigned NumTemplateArgs;
+ const TemplateArgumentList &TemplateArgs;
SourceLocation Loc;
DeclarationName Entity;
public:
TemplateTypeInstantiator(Sema &SemaRef,
- const TemplateArgument *TemplateArgs,
- unsigned NumTemplateArgs,
+ const TemplateArgumentList &TemplateArgs,
SourceLocation Loc,
DeclarationName Entity)
: SemaRef(SemaRef), TemplateArgs(TemplateArgs),
- NumTemplateArgs(NumTemplateArgs), Loc(Loc), Entity(Entity) { }
+ Loc(Loc), Entity(Entity) { }
QualType operator()(QualType T) const { return Instantiate(T); }
@@ -298,7 +296,7 @@ InstantiateDependentSizedArrayType(const DependentSizedArrayType *T,
// Instantiate the size expression
Sema::OwningExprResult InstantiatedArraySize =
- SemaRef.InstantiateExpr(ArraySize, TemplateArgs, NumTemplateArgs);
+ SemaRef.InstantiateExpr(ArraySize, TemplateArgs);
if (InstantiatedArraySize.isInvalid())
return QualType();
@@ -403,7 +401,6 @@ InstantiateTemplateTypeParmType(const TemplateTypeParmType *T,
if (T->getDepth() == 0) {
// Replace the template type parameter with its corresponding
// template argument.
- assert(T->getIndex() < NumTemplateArgs && "Wrong # of template args");
assert(TemplateArgs[T->getIndex()].getKind() == TemplateArgument::Type &&
"Template argument kind mismatch");
QualType Result = TemplateArgs[T->getIndex()].getAsType();
@@ -443,7 +440,7 @@ InstantiateTemplateSpecializationType(
switch (Arg->getKind()) {
case TemplateArgument::Type: {
QualType T = SemaRef.InstantiateType(Arg->getAsType(),
- TemplateArgs, NumTemplateArgs,
+ TemplateArgs,
Arg->getLocation(),
DeclarationName());
if (T.isNull())
@@ -461,8 +458,7 @@ InstantiateTemplateSpecializationType(
case TemplateArgument::Expression:
Sema::OwningExprResult E
- = SemaRef.InstantiateExpr(Arg->getAsExpr(), TemplateArgs,
- NumTemplateArgs);
+ = SemaRef.InstantiateExpr(Arg->getAsExpr(), TemplateArgs);
if (E.isInvalid())
return QualType();
InstantiatedTemplateArgs.push_back(E.takeAs<Expr>());
@@ -475,8 +471,7 @@ InstantiateTemplateSpecializationType(
TemplateName Name = SemaRef.InstantiateTemplateName(T->getTemplateName(),
Loc,
- TemplateArgs,
- NumTemplateArgs);
+ TemplateArgs);
return SemaRef.CheckTemplateIdType(Name, Loc, SourceLocation(),
&InstantiatedTemplateArgs[0],
@@ -509,7 +504,7 @@ InstantiateTypenameType(const TypenameType *T, unsigned Quals) const {
NestedNameSpecifier *NNS
= SemaRef.InstantiateNestedNameSpecifier(T->getQualifier(),
SourceRange(Loc),
- TemplateArgs, NumTemplateArgs);
+ TemplateArgs);
if (!NNS)
return QualType();
@@ -571,9 +566,6 @@ QualType TemplateTypeInstantiator::Instantiate(QualType T) const {
/// \param TemplateArgs the template arguments that will be
/// substituted for the top-level template parameters within T.
///
-/// \param NumTemplateArgs the number of template arguments provided
-/// by TemplateArgs.
-///
/// \param Loc the location in the source code where this substitution
/// is being performed. It will typically be the location of the
/// declarator (if we're instantiating the type of some declaration)
@@ -589,8 +581,7 @@ QualType TemplateTypeInstantiator::Instantiate(QualType T) const {
/// \returns If the instantiation succeeds, the instantiated
/// type. Otherwise, produces diagnostics and returns a NULL type.
QualType Sema::InstantiateType(QualType T,
- const TemplateArgument *TemplateArgs,
- unsigned NumTemplateArgs,
+ const TemplateArgumentList &TemplateArgs,
SourceLocation Loc, DeclarationName Entity) {
assert(!ActiveTemplateInstantiations.empty() &&
"Cannot perform an instantiation without some context on the "
@@ -600,8 +591,7 @@ QualType Sema::InstantiateType(QualType T,
if (!T->isDependentType())
return T;
- TemplateTypeInstantiator Instantiator(*this, TemplateArgs, NumTemplateArgs,
- Loc, Entity);
+ TemplateTypeInstantiator Instantiator(*this, TemplateArgs, Loc, Entity);
return Instantiator(T);
}
@@ -614,8 +604,7 @@ QualType Sema::InstantiateType(QualType T,
bool
Sema::InstantiateBaseSpecifiers(CXXRecordDecl *Instantiation,
CXXRecordDecl *Pattern,
- const TemplateArgument *TemplateArgs,
- unsigned NumTemplateArgs) {
+ const TemplateArgumentList &TemplateArgs) {
bool Invalid = false;
llvm::SmallVector<CXXBaseSpecifier*, 8> InstantiatedBases;
for (ClassTemplateSpecializationDecl::base_class_iterator
@@ -628,7 +617,7 @@ Sema::InstantiateBaseSpecifiers(CXXRecordDecl *Instantiation,
}
QualType BaseType = InstantiateType(Base->getType(),
- TemplateArgs, NumTemplateArgs,
+ TemplateArgs,
Base->getSourceRange().getBegin(),
DeclarationName());
if (BaseType.isNull()) {
@@ -673,15 +662,11 @@ Sema::InstantiateBaseSpecifiers(CXXRecordDecl *Instantiation,
/// \param TemplateArgs The template arguments to be substituted into
/// the pattern.
///
-/// \param NumTemplateArgs The number of templates arguments in
-/// TemplateArgs.
-///
/// \returns true if an error occurred, false otherwise.
bool
Sema::InstantiateClass(SourceLocation PointOfInstantiation,
CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,
- const TemplateArgument *TemplateArgs,
- unsigned NumTemplateArgs) {
+ const TemplateArgumentList &TemplateArgs) {
bool Invalid = false;
CXXRecordDecl *PatternDef
@@ -715,16 +700,14 @@ Sema::InstantiateClass(SourceLocation PointOfInstantiation,
Instantiation->startDefinition();
// Instantiate the base class specifiers.
- if (InstantiateBaseSpecifiers(Instantiation, Pattern, TemplateArgs,
- NumTemplateArgs))
+ if (InstantiateBaseSpecifiers(Instantiation, Pattern, TemplateArgs))
Invalid = true;
llvm::SmallVector<DeclPtrTy, 32> Fields;
for (RecordDecl::decl_iterator Member = Pattern->decls_begin(Context),
MemberEnd = Pattern->decls_end(Context);
Member != MemberEnd; ++Member) {
- Decl *NewMember = InstantiateDecl(*Member, Instantiation,
- TemplateArgs, NumTemplateArgs);
+ Decl *NewMember = InstantiateDecl(*Member, Instantiation, TemplateArgs);
if (NewMember) {
if (NewMember->isInvalidDecl())
Invalid = true;
@@ -783,21 +766,18 @@ Sema::InstantiateClassTemplateSpecialization(
return InstantiateClass(ClassTemplateSpec->getLocation(),
ClassTemplateSpec, Pattern,
- ClassTemplateSpec->getTemplateArgs(),
- ClassTemplateSpec->getNumTemplateArgs());
+ ClassTemplateSpec->getTemplateArgs());
}
/// \brief Instantiate a nested-name-specifier.
NestedNameSpecifier *
Sema::InstantiateNestedNameSpecifier(NestedNameSpecifier *NNS,
SourceRange Range,
- const TemplateArgument *TemplateArgs,
- unsigned NumTemplateArgs) {
+ const TemplateArgumentList &TemplateArgs) {
// Instantiate the prefix of this nested name specifier.
NestedNameSpecifier *Prefix = NNS->getPrefix();
if (Prefix) {
- Prefix = InstantiateNestedNameSpecifier(Prefix, Range, TemplateArgs,
- NumTemplateArgs);
+ Prefix = InstantiateNestedNameSpecifier(Prefix, Range, TemplateArgs);
if (!Prefix)
return 0;
}
@@ -828,8 +808,7 @@ Sema::InstantiateNestedNameSpecifier(NestedNameSpecifier *NNS,
if (!T->isDependentType())
return NNS;
- T = InstantiateType(T, TemplateArgs, NumTemplateArgs, Range.getBegin(),
- DeclarationName());
+ T = InstantiateType(T, TemplateArgs, Range.getBegin(), DeclarationName());
if (T.isNull())
return 0;
@@ -852,14 +831,12 @@ Sema::InstantiateNestedNameSpecifier(NestedNameSpecifier *NNS,
TemplateName
Sema::InstantiateTemplateName(TemplateName Name, SourceLocation Loc,
- const TemplateArgument *TemplateArgs,
- unsigned NumTemplateArgs) {
+ const TemplateArgumentList &TemplateArgs) {
if (TemplateTemplateParmDecl *TTP
= dyn_cast_or_null<TemplateTemplateParmDecl>(
Name.getAsTemplateDecl())) {
assert(TTP->getDepth() == 0 &&
"Cannot reduce depth of a template template parameter");
- assert(TTP->getPosition() < NumTemplateArgs && "Wrong # of template args");
assert(TemplateArgs[TTP->getPosition()].getAsDecl() &&
"Wrong kind of template template argument");
ClassTemplateDecl *ClassTemplate
@@ -870,7 +847,7 @@ Sema::InstantiateTemplateName(TemplateName Name, SourceLocation Loc,
NestedNameSpecifier *NNS
= InstantiateNestedNameSpecifier(QTN->getQualifier(),
/*FIXME=*/SourceRange(Loc),
- TemplateArgs, NumTemplateArgs);
+ TemplateArgs);
if (NNS)
return Context.getQualifiedTemplateName(NNS,
QTN->hasTemplateKeyword(),
@@ -882,7 +859,7 @@ Sema::InstantiateTemplateName(TemplateName Name, SourceLocation Loc,
NestedNameSpecifier *NNS
= InstantiateNestedNameSpecifier(DTN->getQualifier(),
/*FIXME=*/SourceRange(Loc),
- TemplateArgs, NumTemplateArgs);
+ TemplateArgs);
if (!NNS) // FIXME: Not the best recovery strategy.
return Name;
diff --git a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
index a075ea938d0..b254a40da71 100644
--- a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
@@ -23,17 +23,14 @@ namespace {
: public DeclVisitor<TemplateDeclInstantiator, Decl *> {
Sema &SemaRef;
DeclContext *Owner;
- const TemplateArgument *TemplateArgs;
- unsigned NumTemplateArgs;
+ const TemplateArgumentList &TemplateArgs;
public:
typedef Sema::OwningExprResult OwningExprResult;
TemplateDeclInstantiator(Sema &SemaRef, DeclContext *Owner,
- const TemplateArgument *TemplateArgs,
- unsigned NumTemplateArgs)
- : SemaRef(SemaRef), Owner(Owner), TemplateArgs(TemplateArgs),
- NumTemplateArgs(NumTemplateArgs) { }
+ const TemplateArgumentList &TemplateArgs)
+ : SemaRef(SemaRef), Owner(Owner), TemplateArgs(TemplateArgs) { }
// FIXME: Once we get closer to completion, replace these
// manually-written declarations with automatically-generated ones
@@ -83,8 +80,7 @@ Decl *TemplateDeclInstantiator::VisitTypedefDecl(TypedefDecl *D) {
bool Invalid = false;
QualType T = D->getUnderlyingType();
if (T->isDependentType()) {
- T = SemaRef.InstantiateType(T, TemplateArgs, NumTemplateArgs,
- D->getLocation(),
+ T = SemaRef.InstantiateType(T, TemplateArgs, D->getLocation(),
D->getDeclName());
if (T.isNull()) {
Invalid = true;
@@ -106,7 +102,6 @@ Decl *TemplateDeclInstantiator::VisitTypedefDecl(TypedefDecl *D) {
Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D) {
// Instantiate the type of the declaration
QualType T = SemaRef.InstantiateType(D->getType(), TemplateArgs,
- NumTemplateArgs,
D->getTypeSpecStartLoc(),
D->getDeclName());
if (T.isNull())
@@ -129,7 +124,7 @@ Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D) {
if (D->getInit()) {
OwningExprResult Init
- = SemaRef.InstantiateExpr(D->getInit(), TemplateArgs, NumTemplateArgs);
+ = SemaRef.InstantiateExpr(D->getInit(), TemplateArgs);
if (Init.isInvalid())
Var->setInvalidDecl();
else
@@ -144,8 +139,7 @@ Decl *TemplateDeclInstantiator::VisitFieldDecl(FieldDecl *D) {
bool Invalid = false;
QualType T = D->getType();
if (T->isDependentType()) {
- T = SemaRef.InstantiateType(T, TemplateArgs, NumTemplateArgs,
- D->getLocation(),
+ T = SemaRef.InstantiateType(T, TemplateArgs, D->getLocation(),
D->getDeclName());
if (!T.isNull() && T->isFunctionType()) {
// C++ [temp.arg.type]p3:
@@ -166,7 +160,7 @@ Decl *TemplateDeclInstantiator::VisitFieldDecl(FieldDecl *D) {
BitWidth = 0;
else if (BitWidth) {
OwningExprResult InstantiatedBitWidth
- = SemaRef.InstantiateExpr(BitWidth, TemplateArgs, NumTemplateArgs);
+ = SemaRef.InstantiateExpr(BitWidth, TemplateArgs);
if (InstantiatedBitWidth.isInvalid()) {
Invalid = true;
BitWidth = 0;
@@ -195,7 +189,7 @@ Decl *TemplateDeclInstantiator::VisitStaticAssertDecl(StaticAssertDecl *D) {
Expr *AssertExpr = D->getAssertExpr();
OwningExprResult InstantiatedAssertExpr
- = SemaRef.InstantiateExpr(AssertExpr, TemplateArgs, NumTemplateArgs);
+ = SemaRef.InstantiateExpr(AssertExpr, TemplateArgs);
if (InstantiatedAssertExpr.isInvalid())
return 0;
@@ -224,8 +218,7 @@ Decl *TemplateDeclInstantiator::VisitEnumDecl(EnumDecl *D) {
// The specified value for the enumerator.
OwningExprResult Value = SemaRef.Owned((Expr *)0);
if (Expr *UninstValue = EC->getInitExpr())
- Value = SemaRef.InstantiateExpr(UninstValue,
- TemplateArgs, NumTemplateArgs);
+ Value = SemaRef.InstantiateExpr(UninstValue, TemplateArgs);
// Drop the initial value and continue.
bool isInvalid = false;
@@ -425,8 +418,7 @@ Decl *TemplateDeclInstantiator::VisitCXXConversionDecl(CXXConversionDecl *D) {
ParmVarDecl *TemplateDeclInstantiator::VisitParmVarDecl(ParmVarDecl *D) {
QualType OrigT = SemaRef.InstantiateType(D->getOriginalType(), TemplateArgs,
- NumTemplateArgs, D->getLocation(),
- D->getDeclName());
+ D->getLocation(), D->getDeclName());
if (OrigT.isNull())
return 0;
@@ -469,10 +461,8 @@ TemplateDeclInstantiator::VisitOriginalParmVarDecl(OriginalParmVarDecl *D) {
}
Decl *Sema::InstantiateDecl(Decl *D, DeclContext *Owner,
- const TemplateArgument *TemplateArgs,
- unsigned NumTemplateArgs) {
- TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs,
- NumTemplateArgs);
+ const TemplateArgumentList &TemplateArgs) {
+ TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs);
return Instantiator.Visit(D);
}
@@ -491,8 +481,7 @@ TemplateDeclInstantiator::InstantiateFunctionType(FunctionDecl *D,
bool InvalidDecl = false;
// Instantiate the function parameters
- TemplateDeclInstantiator ParamInstantiator(SemaRef, 0,
- TemplateArgs, NumTemplateArgs);
+ TemplateDeclInstantiator ParamInstantiator(SemaRef, 0, TemplateArgs);
llvm::SmallVector<QualType, 16> ParamTys;
for (FunctionDecl::param_iterator P = D->param_begin(),
PEnd = D->param_end();
@@ -524,8 +513,7 @@ TemplateDeclInstantiator::InstantiateFunctionType(FunctionDecl *D,
const FunctionProtoType *Proto = D->getType()->getAsFunctionProtoType();
assert(Proto && "Missing prototype?");
QualType ResultType
- = SemaRef.InstantiateType(Proto->getResultType(),
- TemplateArgs, NumTemplateArgs,
+ = SemaRef.InstantiateType(Proto->getResultType(), TemplateArgs,
D->getLocation(), D->getDeclName());
if (ResultType.isNull())
return QualType();
diff --git a/clang/lib/Sema/SemaTemplateInstantiateExpr.cpp b/clang/lib/Sema/SemaTemplateInstantiateExpr.cpp
index 5476ad3502b..89d88ff76ec 100644
--- a/clang/lib/Sema/SemaTemplateInstantiateExpr.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiateExpr.cpp
@@ -24,17 +24,14 @@ namespace {
class VISIBILITY_HIDDEN TemplateExprInstantiator
: public StmtVisitor<TemplateExprInstantiator, Sema::OwningExprResult> {
Sema &SemaRef;
- const TemplateArgument *TemplateArgs;
- unsigned NumTemplateArgs;
+ const TemplateArgumentList &TemplateArgs;
public:
typedef Sema::OwningExprResult OwningExprResult;
TemplateExprInstantiator(Sema &SemaRef,
- const TemplateArgument *TemplateArgs,
- unsigned NumTemplateArgs)
- : SemaRef(SemaRef), TemplateArgs(TemplateArgs),
- NumTemplateArgs(NumTemplateArgs) { }
+ const TemplateArgumentList &TemplateArgs)
+ : SemaRef(SemaRef), TemplateArgs(TemplateArgs) { }
// FIXME: Once we get closer to completion, replace these
// manually-written declarations with automatically-generated ones
@@ -294,7 +291,7 @@ TemplateExprInstantiator::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) {
if (E->isArgumentType()) {
QualType T = E->getArgumentType();
if (T->isDependentType()) {
- T = SemaRef.InstantiateType(T, TemplateArgs, NumTemplateArgs,
+ T = SemaRef.InstantiateType(T, TemplateArgs,
/*FIXME*/E->getOperatorLoc(),
&SemaRef.PP.getIdentifierTable().get("sizeof"));
if (T.isNull())
@@ -324,7 +321,7 @@ TemplateExprInstantiator::VisitUnresolvedDeclRefExpr(UnresolvedDeclRefExpr *E) {
NestedNameSpecifier *NNS
= SemaRef.InstantiateNestedNameSpecifier(E->getQualifier(),
E->getQualifierRange(),
- TemplateArgs, NumTemplateArgs);
+ TemplateArgs);
if (!NNS)
return SemaRef.ExprError();
@@ -348,7 +345,7 @@ TemplateExprInstantiator::VisitCXXTemporaryObjectExpr(
CXXTemporaryObjectExpr *E) {
QualType T = E->getType();
if (T->isDependentType()) {
- T = SemaRef.InstantiateType(T, TemplateArgs, NumTemplateArgs,
+ T = SemaRef.InstantiateType(T, TemplateArgs,
E->getTypeBeginLoc(), DeclarationName());
if (T.isNull())
return SemaRef.ExprError();
@@ -413,8 +410,7 @@ Sema::OwningExprResult TemplateExprInstantiator::VisitImplicitCastExpr(
}
Sema::OwningExprResult
-Sema::InstantiateExpr(Expr *E, const TemplateArgument *TemplateArgs,
- unsigned NumTemplateArgs) {
- TemplateExprInstantiator Instantiator(*this, TemplateArgs, NumTemplateArgs);
+Sema::InstantiateExpr(Expr *E, const TemplateArgumentList &TemplateArgs) {
+ TemplateExprInstantiator Instantiator(*this, TemplateArgs);
return Instantiator.Visit(E);
}
diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp
index 08a5770196f..f3a31ea0deb 100644
--- a/clang/lib/Sema/SemaType.cpp
+++ b/clang/lib/Sema/SemaType.cpp
@@ -1115,9 +1115,7 @@ bool Sema::RequireCompleteType(SourceLocation Loc, QualType T, unsigned diag,
Parent && !Spec; Parent = Parent->getParent())
Spec = dyn_cast<ClassTemplateSpecializationDecl>(Parent);
assert(Spec && "Not a member of a class template specialization?");
- return InstantiateClass(Loc, Rec, Pattern,
- Spec->getTemplateArgs(),
- Spec->getNumTemplateArgs());
+ return InstantiateClass(Loc, Rec, Pattern, Spec->getTemplateArgs());
}
}
}
OpenPOWER on IntegriCloud