================
Comment at: lib/AST/ASTDiagnostic.cpp:70-81
@@ -69,5 +69,14 @@
+ // or decltype appears anywhere in the type.
if (const TemplateSpecializationType *TST
- = dyn_cast<TemplateSpecializationType>(Ty))
- if (!TST->isTypeAlias())
+ = dyn_cast<TemplateSpecializationType>(Ty)) {
+ for (auto Arg : *TST) {
+ if (Arg.getKind() == TemplateArgument::Type)
+ Desugar(Context, Arg.getAsType(), ShouldAKA);
+ if (ShouldAKA)
+ break;
+ }
+
+ if (!ShouldAKA && !TST->isTypeAlias())
break;
+ }
----------------
Nikola Smiljanić wrote:
> Richard Smith wrote:
> > Nikola Smiljanić wrote:
> > > Richard Smith wrote:
> > > > It'd be better here to rebuild a TemplateSpecializationType that has
> > > > the desugared template arguments in it.
> > > What exactly do you mean by **rebuild**?
> > I mean, ask the ASTContext to create a new TemplateSpecializationType with
> > the desugared template arguments.
> I thought it'd be obvious why I was doing this after I did it but I guess I
> should have asked. At first I though this was an optimization, create this
> QualType now as it will certainly be created later on. But I've noticed that
> getting the canonical type from sugared type returns a different type object
> with same 'spelling'. I know that we're supposed to have only one QualType
> per type and I'm lost... Is this what you had in mind, and more importantly
> why?
>
>
> ```
> if (const TemplateSpecializationType *TST =
> dyn_cast<TemplateSpecializationType>(Ty)) {
> SmallVector<TemplateArgument, 4> Args;
> for (TemplateSpecializationType::iterator I = TST->args_begin(),
> E = TST->args_end();
> I != E; ++I) {
> if (I->getKind() == TemplateArgument::Type)
> Args.push_back(Desugar(Context, I->getAsType(), ShouldAKA));
> else
> Args.push_back(*I);
> }
>
> if (ShouldAKA || TST->isTypeAlias()) {
> QT = Context.getTemplateSpecializationType(
> TST->getTemplateName(), Args.data(), Args.size(), QT);
> break;
> }
> }
> ```
Yes, that's approximately what I had in mind. This way, we should perform an
appropriate amount of desugaring on template arguments, and not just flatten
them straight to their canonical types.
Comments on that code:
* `ShouldAKA` might have been set by something already; track your own
variable to determine if you desugared any arguments
* It would be useful to also desugar non-type template arguments; maybe pick
up the canonical TST's template argument if the non-type template argument is
in `Expression` form?
http://reviews.llvm.org/D3588
_______________________________________________
cfe-commits mailing list
cfe-commits@cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
