[libclang] Check for a record declaration before a template specialization.

[emilio]

Summary

This allows us to see the default template parameters too.

This is a regression in clang 4.0, so uplifting to a dot release would be neat (but not required, I guess).

The regression was caused by https://reviews.llvm.org/D26663.

Fixes bug 32539 (https://bugs.llvm.org//show_bug.cgi?id=32539).

[arphaman]

Please post the diff with full context (git diff -U9999).

[emilio]

Full diff, thanks @arphaman :)

[arphaman]

clang/test/Index/print-type.cpp

118

Hmm, that's an interesting change. I assume the test passed prior to this patch, right? Did this output change purely because of the change in GetTemplateArguments?

[emilio]

clang/test/Index/print-type.cpp

118

Yup, that's right. This makes the type and the canonical type match in this case. In this case we lose a tiny bit of information (mainly, that the template argument was used through a typedef), but the alternative is to lose information about default template parameters, which seems worse to me (and is a regression, while template argument packs haven't been inspectionable until libclang 4.0).

[arphaman]

I see, thanks for explaining. LGTM. Do you need someone to commit it?

[emilio]

Yes, please! I've submitted a few patches, but still no commit access.

Thanks!

[arphaman]

Sure. You can ask Chris Lattner for commit access for future patches :)

[arphaman]

@emilio, you can request to merge this into 4.0.1 by using a script called merge-request.sh (http://lists.llvm.org/pipermail/llvm-dev/2017-March/111530.html).

[rsmith]

This change looks like it introduces a regression itself: given

template<typename T> struct A {};
template<typename T> using B = A<T*>;
B<int> bi;

... requesting the template arguments for the type B<int> changes from producing int to producing int* with this patch, which seems to directly oppose the intentions of D26663.

If the intent of this libclang function is to request the template arguments of the type as written, this change is wrong. If the intent is to request the template arguments of the desugared type, then D26663 is wrong. But either way, it seems that reversing the order of these checks causes us to produce inconsistent results. Another example of the inconsistency:

template<typename T> using C = T;

With this patch, requesting the template arguments for C<int> gives int but requesting the template arguments of C<A<void>> gives void rather than A<void>.

[emilio]

In D32348#738704, @rsmith wrote:

This change looks like it introduces a regression itself: given

template<typename T> struct A {};
template<typename T> using B = A<T*>;
B<int> bi;

... requesting the template arguments for the type B<int> changes from producing int to producing int* with this patch, which seems to directly oppose the intentions of D26663.

FWIW when I wrote D26663, I did it because arguments weren't inspectionable at all for using declarations. Actually both of them would've worked for me.

template<typename T> using C = T;

With this patch, requesting the template arguments for C<int> gives int but requesting the template arguments of C<A<void>> gives void rather than A<void>.

That being said, that is _specially_ annoying (good catch btw). Annoying enough to justify reverting this change I'd say...

I'll submit something with the test-cases. I guess people that depended on the old translation will just need to live with it... shrug.

I guess I could do something clever like: If it's both a ClassTemplateSpecializationDecl, and a TemplateSpecializationType, and the template arguments of the second happen to not be a template specialization, then use the ClassTemplateSpecializationDecl, otherwise the other, but that seems fairly tricky to maintain, so I'd rather just do the former.

Thanks for looking through it, btw.

[emilio]

Revert + tests @ https://reviews.llvm.org/D32566

[emilio]

FWIW when I wrote D26663, I did it because arguments weren't inspectionable at all for using declarations. Actually both of them would've worked for me.

Also, this bit was not completely accurate, and you could inspect ones, but not others (you could inspect the ones that desugared into a RecordDecl that happened to be a template specialization, as shown by the bug you pointed out).

clang/test/Index/print-type.cpp

 Specialization<Specialization<bool>& > templRefParam;
 auto autoTemplRefParam = templRefParam;
 
+template<typename T, typename U = int>
+struct DefaultedTypeExample {};
+
+typedef DefaultedTypeExample<int> DefaultedTypeAlias;
+
 // RUN: c-index-test -test-print-type %s -std=c++14 | FileCheck %s
 // CHECK: Namespace=outer:1:11 (Definition) [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: ClassTemplate=Foo:4:8 (Definition) [type=] [typekind=Invalid] [isPOD=0]

 // CHECK: TemplateRef=Baz:9:8 [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: IntegerLiteral= [type=int] [typekind=Int] [isPOD=1]
 // CHECK: TemplateRef=Foo:4:8 [type=] [typekind=Invalid] [isPOD=0]
-// CHECK: FieldDecl=qux:29:38 (Definition) [type=Qux<int, char *, Foo<int>, outer::inner::Bar::FooType>] [typekind=Unexposed] [templateargs/4= [type=int] [typekind=Int] [type=char *] [typekind=Pointer] [type=Foo<int>] [typekind=Unexposed] [type=outer::inner::Bar::FooType] [typekind=Typedef]] [canonicaltype=outer::Qux<int, char *, outer::Foo<int>, int>] [canonicaltypekind=Record] [canonicaltemplateargs/4= [type=int] [typekind=Int] [type=char *] [typekind=Pointer] [type=outer::Foo<int>] [typekind=Record] [type=int] [typekind=Int]] [isPOD=1]
+// CHECK: FieldDecl=qux:29:38 (Definition) [type=Qux<int, char *, Foo<int>, outer::inner::Bar::FooType>] [typekind=Unexposed] [templateargs/4= [type=int] [typekind=Int] [type=char *] [typekind=Pointer] [type=outer::Foo<int>] [typekind=Record] [type=int] [typekind=Int]] [canonicaltype=outer::Qux<int, char *, outer::Foo<int>, int>] [canonicaltypekind=Record] [canonicaltemplateargs/4= [type=int] [typekind=Int] [type=char *] [typekind=Pointer] [type=outer::Foo<int>] [typekind=Record] [type=int] [typekind=Int]] [isPOD=1]
 // CHECK: TemplateRef=Qux:12:8 [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: TemplateRef=Foo:4:8 [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: FunctionTemplate=tbar:36:3 [type=T (int)] [typekind=FunctionProto] [canonicaltype=type-parameter-0-0 (int)] [canonicaltypekind=FunctionProto] [resulttype=T] [resulttypekind=Unexposed] [isPOD=0]

 // CHECK: VarDecl=autoTemplRefParam:72:6 (Definition) [type=Specialization<Specialization<bool> &>] [typekind=Auto] [templateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [canonicaltype=Specialization<Specialization<bool> &>] [canonicaltypekind=Record] [canonicaltemplateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [isPOD=1]
 // CHECK: UnexposedExpr=templRefParam:71:40 [type=const Specialization<Specialization<bool> &>] [typekind=Unexposed] const [templateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [canonicaltype=const Specialization<Specialization<bool> &>] [canonicaltypekind=Record] [canonicaltemplateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [isPOD=1]
 // CHECK: DeclRefExpr=templRefParam:71:40 [type=Specialization<Specialization<bool> &>] [typekind=Unexposed] [templateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [canonicaltype=Specialization<Specialization<bool> &>] [canonicaltypekind=Record] [canonicaltemplateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [isPOD=1]
+// CHECK: TypedefDecl=DefaultedTypeAlias:77:35 (Definition) [type=DefaultedTypeAlias] [typekind=Typedef] [templateargs/2= [type=int] [typekind=Int] [type=int] [typekind=Int]] [canonicaltype=DefaultedTypeExample<int, int>] [canonicaltypekind=Record] [canonicaltemplateargs/2= [type=int] [typekind=Int] [type=int] [typekind=Int]] [isPOD=0]

clang/tools/libclang/CXType.cpp

 static Optional<ArrayRef<TemplateArgument>>
 GetTemplateArguments(QualType Type) {
   assert(!Type.isNull());
-  if (const auto *Specialization = Type->getAs<TemplateSpecializationType>())
-    return Specialization->template_arguments();
-
   if (const auto *RecordDecl = Type->getAsCXXRecordDecl()) {
     const auto *TemplateDecl =
       dyn_cast<ClassTemplateSpecializationDecl>(RecordDecl);

       return TemplateDecl->getTemplateArgs().asArray();
   }
 
+  if (const auto *Specialization = Type->getAs<TemplateSpecializationType>())
+    return Specialization->template_arguments();
+
   return None;
 }