static vector<QualType> typesFromTemplateArguments(const TemplateArgumentList &templateArgs)
{
vector<QualType> result;
const int numArgs = templateArgs.size();
result.reserve(numArgs);
for (int i = 0; i < numArgs; ++i) {
const TemplateArgument &arg = templateArgs.get(i);
if (arg.getKind() == TemplateArgument::Type)
result.push_back(arg.getAsType());
}
return result;
}
void InstantiateTemplateParam::handleOneTemplateSpecialization(
const TemplateDecl *D, const TemplateArgumentList & ArgList)
{
if (isInIncludedFile(D))
return;
NamedDecl *ND = D->getTemplatedDecl();
TemplateParameterSet ParamsSet;
TemplateParameterVisitor ParameterVisitor(ParamsSet);
ParameterVisitor.TraverseDecl(ND);
if (ParamsSet.size() == 0)
return;
unsigned NumArgs = ArgList.size(); (void)NumArgs;
unsigned Idx = 0;
TemplateParameterList *TPList = D->getTemplateParameters();
for (TemplateParameterList::const_iterator I = TPList->begin(),
E = TPList->end(); I != E; ++I) {
const NamedDecl *ND = (*I);
// make it simple, skip NonTypeTemplateParmDecl and
// TemplateTemplateParmDecl for now
const TemplateTypeParmDecl *TyParmDecl =
dyn_cast<TemplateTypeParmDecl>(ND);
if (!TyParmDecl || TyParmDecl->isParameterPack() || !ParamsSet.count(ND)) {
Idx++;
continue;
}
TransAssert((Idx < NumArgs) && "Invalid Idx!");
const TemplateArgument &Arg = ArgList.get(Idx);
std::string ArgStr;
std::string ForwardStr;
if (!getTemplateArgumentString(Arg, ArgStr, ForwardStr))
continue;
ValidInstanceNum++;
if (ValidInstanceNum == TransformationCounter) {
TheInstantiationString = ArgStr;
TheParameter = ND;
TheTemplateDecl = D;
TheForwardDeclString = ForwardStr;
}
}
}
void DeclPrinter::printTemplateArguments(const TemplateArgumentList &Args,
const TemplateParameterList *Params) {
Out << "<";
for (size_t I = 0, E = Args.size(); I < E; ++I) {
const TemplateArgument &A = Args[I];
if (I)
Out << ", ";
if (Params) {
if (A.getKind() == TemplateArgument::Type)
if (auto T = A.getAsType()->getAs<TemplateTypeParmType>()) {
auto P = cast<TemplateTypeParmDecl>(Params->getParam(T->getIndex()));
Out << *P;
continue;
}
if (A.getKind() == TemplateArgument::Template) {
if (auto T = A.getAsTemplate().getAsTemplateDecl())
if (auto TD = dyn_cast<TemplateTemplateParmDecl>(T)) {
auto P = cast<TemplateTemplateParmDecl>(
Params->getParam(TD->getIndex()));
Out << *P;
continue;
}
}
if (A.getKind() == TemplateArgument::Expression) {
if (auto E = dyn_cast<DeclRefExpr>(A.getAsExpr()))
if (auto N = dyn_cast<NonTypeTemplateParmDecl>(E->getDecl())) {
auto P = cast<NonTypeTemplateParmDecl>(
Params->getParam(N->getIndex()));
Out << *P;
continue;
}
}
}
A.print(Policy, Out);
}
Out << ">";
}
void ASTDumper::dumpTemplateArgumentList(const TemplateArgumentList &TAL) {
for (unsigned i = 0, e = TAL.size(); i < e; ++i)
dumpTemplateArgument(TAL[i]);
}
TemplateArgumentList::TemplateArgumentList(const TemplateArgumentList &Other)
: FlatArguments(Other.FlatArguments.getPointer(), 1),
NumFlatArguments(Other.flat_size()),
StructuredArguments(Other.StructuredArguments.getPointer(), 1),
NumStructuredArguments(Other.NumStructuredArguments) { }