[libclang] Expose using shadow types and declarations in libclang.

[emilio]

Summary

This allows tools like rust-bindgen to detect typedefs properly.

See https://github.com/rust-lang/rust-bindgen/pull/2372 (which relies on
this patch) for an example.

[emilio]

(As in my previous commit, picking based on git log, please review / forward as appropriate. Thanks again!)

[emilio]

Fix test

[emilio]

rebase

[serge-sans-paille]

clang/tools/libclang/CXCursor.cpp

1281

In which case can this be null?

[aaron.ballman]

clang/tools/libclang/CXCursor.cpp

1279–1281

Hmm, we're exposing CXType_Using but here we're not giving back a cursor to the UsingType but instead looking through that type to get down to a declaration and are returning that.

Should we split these in two different cursors?

clang/include/clang-c/Index.h

enum CXTypeKind {
   CXType_OCLIntelSubgroupAVCImeResultSingleRefStreamout = 172,
   CXType_OCLIntelSubgroupAVCImeResultDualRefStreamout = 173,
   CXType_OCLIntelSubgroupAVCImeSingleRefStreamin = 174,
 
   CXType_OCLIntelSubgroupAVCImeDualRefStreamin = 175,
 
   CXType_ExtVector = 176,
   CXType_Atomic = 177,
-  CXType_BTFTagAttributed = 178
+  CXType_BTFTagAttributed = 178,
+
+  CXType_Using = 179
 };
 
 /**
  * Describes the calling convention of a function type
  */
 enum CXCallingConv {
   CXCallingConv_Default = 0,
   CXCallingConv_C = 1,

clang/lib/Sema/SemaCodeComplete.cpp

CXCursorKind clang::getCursorKindForDecl(const Decl *D) {
   case Decl::StaticAssert:
     return CXCursor_StaticAssert;
   case Decl::Friend:
     return CXCursor_FriendDecl;
   case Decl::TranslationUnit:
     return CXCursor_TranslationUnit;
 
   case Decl::Using:
+  case Decl::UsingShadow:
   case Decl::UnresolvedUsingValue:
   case Decl::UnresolvedUsingTypename:
     return CXCursor_UsingDeclaration;
 
   case Decl::UsingEnum:
     return CXCursor_EnumDecl;
 
   case Decl::ObjCPropertyImpl:

clang/test/Index/print-type.cpp

class X {
   enum { Test };
 };
 
 namespace {
   int a;
 }
 
 inline namespace InlineNS {}
+
+namespace ToBeExported {
+  typedef int ToBeExportedType;
+}
+
+using ToBeExported::ToBeExportedType;
+void UseToBeExported(ToBeExportedType f);
+
 // 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: TemplateTypeParameter=T:3:19 (Definition) [type=T] [typekind=Unexposed] [canonicaltype=type-parameter-0-0] [canonicaltypekind=Unexposed] [isPOD=0]
 // CHECK: FieldDecl=t:5:5 (Definition) [type=T] [typekind=Unexposed] [canonicaltype=type-parameter-0-0] [canonicaltypekind=Unexposed] [isPOD=0]
 // CHECK: TypeRef=T:3:19 [type=T] [typekind=Unexposed] [canonicaltype=type-parameter-0-0] [canonicaltypekind=Unexposed] [isPOD=0]
 // CHECK: ClassTemplate=Baz:9:8 (Definition) [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: TemplateTypeParameter=T:8:20 (Definition) [type=T] [typekind=Unexposed] [canonicaltype=type-parameter-0-0] [canonicaltypekind=Unexposed] [isPOD=0]

 // CHECK: VarDecl=autoTemplPointer:78:6 (Definition) [type=Specialization<Specialization<bool> &> *] [typekind=Auto] [canonicaltype=Specialization<Specialization<bool> &> *] [canonicaltypekind=Pointer] [isPOD=1] [pointeetype=Specialization<Specialization<bool> &>] [pointeekind=Auto]
 // CHECK: CallExpr=Bar:17:3 [type=outer::inner::Bar] [typekind=Elaborated] [canonicaltype=outer::inner::Bar] [canonicaltypekind=Record] [args= [outer::Foo<bool> *] [Pointer]] [isPOD=0] [nbFields=3]
 // CHECK: StructDecl=(anonymous struct at {{.*}}):84:3 (Definition) [type=X::(anonymous struct at {{.*}}print-type.cpp:84:3)] [typekind=Record] [isPOD=1] [nbFields=1] [isAnon=1]
 // CHECK: ClassDecl=(anonymous class at {{.*}}:85:3 (Definition) [type=X::(anonymous class at {{.*}}print-type.cpp:85:3)] [typekind=Record] [isPOD=1] [nbFields=1] [isAnon=1]
 // CHECK: UnionDecl=(anonymous union at {{.*}}:86:3 (Definition) [type=X::(anonymous union at {{.*}}print-type.cpp:86:3)] [typekind=Record] [isPOD=1] [nbFields=2] [isAnon=1]
 // CHECK: EnumDecl=(unnamed enum at {{.*}}:87:3 (Definition) [type=X::(unnamed enum at {{.*}}print-type.cpp:87:3)] [typekind=Enum] [isPOD=1] [isAnon=1]
 // CHECK: Namespace=:90:11 (Definition) [type=] [typekind=Invalid] [isPOD=0] [isAnon=1]
 // CHECK: Namespace=InlineNS:94:18 (Definition) [type=] [typekind=Invalid] [isPOD=0] [isAnonRecDecl=0] [isInlineNamespace=1]
+// CHECK: UsingDeclaration=ToBeExportedType[97:15] [type=] [typekind=Invalid] [isPOD=0] [isAnonRecDecl=0]
+// CHECK: ParmDecl=f:101:39 (Definition) [type=ToBeExportedType] [typekind=Elaborated] [canonicaltype=int] [canonicaltypekind=Int] [isPOD=1] [isAnonRecDecl=0]

clang/tools/libclang/CXCursor.cpp

CXCursor cxcursor::getTypeRefCursor(CXCursor cursor) {
   }
 
   if (const TypedefType *Typedef = Ty->getAs<TypedefType>())
     return MakeCursorTypeRef(Typedef->getDecl(), Loc, TU);
   if (const TagType *Tag = Ty->getAs<TagType>())
     return MakeCursorTypeRef(Tag->getDecl(), Loc, TU);
   if (const TemplateTypeParmType *TemplP = Ty->getAs<TemplateTypeParmType>())
     return MakeCursorTypeRef(TemplP->getDecl(), Loc, TU);
+  if (const UsingType *Using = Ty->getAs<UsingType>())
+    if (const UsingShadowDecl *Shadow = Using->getFoundDecl())
+      if (const auto *TD = dyn_cast_or_null<TypeDecl>(Shadow->getTargetDecl()))
+        return MakeCursorTypeRef(TD, Loc, TU);
 
   return cursor;
 }
 
 bool cxcursor::operator==(CXCursor X, CXCursor Y) {
   return X.kind == Y.kind && X.data[0] == Y.data[0] && X.data[1] == Y.data[1] &&
          X.data[2] == Y.data[2];
 }

clang/tools/libclang/CXType.cpp

switch (TP->getTypeClass()) {
     TKCASE(Complex);
     TKCASE(Pointer);
     TKCASE(BlockPointer);
     TKCASE(LValueReference);
     TKCASE(RValueReference);
     TKCASE(Record);
     TKCASE(Enum);
     TKCASE(Typedef);
+    TKCASE(Using);
     TKCASE(ObjCInterface);
     TKCASE(ObjCObject);
     TKCASE(ObjCObjectPointer);
     TKCASE(ObjCTypeParam);
     TKCASE(FunctionNoProto);
     TKCASE(FunctionProto);
     TKCASE(ConstantArray);
     TKCASE(IncompleteArray);
for (const auto &A : TA) {
     }
     if (current == index)
       return TemplateArgumentToQualType(A);
     current++;
   }
   return std::nullopt;
 }
 
-CXType clang_getCursorType(CXCursor C) {
-  using namespace cxcursor;
-
-  CXTranslationUnit TU = cxcursor::getCursorTU(C);
-  if (!TU)
-    return MakeCXType(QualType(), TU);
-
-  ASTContext &Context = cxtu::getASTUnit(TU)->getASTContext();
-  if (clang_isExpression(C.kind)) {
-    QualType T = cxcursor::getCursorExpr(C)->getType();
-    return MakeCXType(T, TU);
-  }
-
-  if (clang_isDeclaration(C.kind)) {
-    const Decl *D = cxcursor::getCursorDecl(C);
+static CXType getDeclType(const Decl* D, CXTranslationUnit TU, ASTContext &Context) {
     if (!D)
       return MakeCXType(QualType(), TU);
-
     if (const TypeDecl *TD = dyn_cast<TypeDecl>(D))
       return MakeCXType(Context.getTypeDeclType(TD), TU);
     if (const ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D))
       return MakeCXType(Context.getObjCInterfaceType(ID), TU);
     if (const DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D))
       return MakeCXType(DD->getType(), TU);
     if (const ValueDecl *VD = dyn_cast<ValueDecl>(D))
       return MakeCXType(VD->getType(), TU);
     if (const ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D))
       return MakeCXType(PD->getType(), TU);
     if (const FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(D))
       return MakeCXType(FTD->getTemplatedDecl()->getType(), TU);
+    if (const auto *UD = dyn_cast<UsingShadowDecl>(D))
+      return getDeclType(UD->getTargetDecl(), TU, Context);
     return MakeCXType(QualType(), TU);
-  }
 
+CXType clang_getCursorType(CXCursor C) {
+  using namespace cxcursor;
+
+  CXTranslationUnit TU = cxcursor::getCursorTU(C);
+  if (!TU)
+    return MakeCXType(QualType(), TU);
+
+  ASTContext &Context = cxtu::getASTUnit(TU)->getASTContext();
+  if (clang_isExpression(C.kind)) {
+    QualType T = cxcursor::getCursorExpr(C)->getType();
+    return MakeCXType(T, TU);
+  }
+
+  if (clang_isDeclaration(C.kind))
+    return getDeclType(cxcursor::getCursorDecl(C), TU, Context);
+
   if (clang_isReference(C.kind)) {
     switch (C.kind) {
     case CXCursor_ObjCSuperClassRef: {
       QualType T
         = Context.getObjCInterfaceType(getCursorObjCSuperClassRef(C).first);
       return MakeCXType(T, TU);
     }
 
CXCursor clang_getTypeDeclaration(CXType CT) {
 
   Decl *D = nullptr;
 
 try_again:
   switch (TP->getTypeClass()) {
   case Type::Typedef:
     D = cast<TypedefType>(TP)->getDecl();
     break;
+  case Type::Using:
+    D = cast<UsingType>(TP)->getFoundDecl();
+    break;
   case Type::ObjCObject:
     D = cast<ObjCObjectType>(TP)->getInterface();
     break;
   case Type::ObjCInterface:
     D = cast<ObjCInterfaceType>(TP)->getDecl();
     break;
   case Type::Record:
   case Type::Enum:
switch (K) {
     TKIND(Complex);
     TKIND(Pointer);
     TKIND(BlockPointer);
     TKIND(LValueReference);
     TKIND(RValueReference);
     TKIND(Record);
     TKIND(Enum);
     TKIND(Typedef);
+    TKIND(Using);
     TKIND(ObjCInterface);
     TKIND(ObjCObject);
     TKIND(ObjCObjectPointer);
     TKIND(ObjCTypeParam);
     TKIND(FunctionNoProto);
     TKIND(FunctionProto);
     TKIND(ConstantArray);
     TKIND(IncompleteArray);