add clang_Type_getFullyQualifiedName

[anderslanglands]

Summary

Not sure how to test this - adding it to c-index-test's PrintType will change *everything*, which doesn't seem like a great idea.

[aaron.ballman]

In terms of testing, I'd recommend adding -test-print-qualified-type and see if you can thread a qualified vs unqualified parameter through PrintType() and friends to try to share as much code as possible. You'll probably need new wrapper functions that calls PrintType with the correct argument value depending on which test is being run. WDYT?

clang/tools/libclang/CXType.cpp

318–325

Simplifying a bit and fixing up a naming convention nit.

[anderslanglands]

Now tested by adding a -print-qualified-type-names flag to c-index-test and creating a (small) dedicated test in print-qualified-type.cpp

[aaron.ballman]

This looks like the right direction to me, but there's quite a few whitespace and formatting NFC changes in the patch. If you don't mind splitting those changes out into their own commit, that would be appreciated (feel free to land those changes without review given that they're only changing whitespace and other formatting).

clang/tools/c-index-test/c-index-test.c

378

1789

I'm not super familiar with c-index-test -- how certain are you that the client data will 1) be non-null, and 2) actually be a VisitorData pointer?

[anderslanglands]

Re the whitespace - yeah that's me running clang-format on the whole function rather than just the lines I changed. I'll see if I can split those out.

clang/tools/c-index-test/c-index-test.c

1789

This was just copy-pasted from another function. I'm as certain as I can be given that all the tests pass :\

[anderslanglands]

clang/tools/c-index-test/c-index-test.c

1789

From a quick scan, VisitorData is the only CXClientData struct used in the visitor callbacks, so I think we're safe.

[anderslanglands]

Remove whitespace changes on unaffected lines

[anderslanglands]

couple of little spaces I missed...

[aaron.ballman]

LGTM!

clang/tools/c-index-test/c-index-test.c

1789

Thanks! That matches what I was seeing as well, great.

clang/docs/ReleaseNotes.rst

 - ``clang_Cursor_getNumTemplateArguments``, ``clang_Cursor_getTemplateArgumentKind``, 
   ``clang_Cursor_getTemplateArgumentType``, ``clang_Cursor_getTemplateArgumentValue`` and 
   ``clang_Cursor_getTemplateArgumentUnsignedValue`` now work on struct, class,
   and partial template specialization cursors in addition to function cursors.
 - Added ``CXType_SubstTemplateTypeParm`` to ``CXTypeKind``, which identifies a type that 
   is a replacement for a template type parameter (previously reported a ``CXType_Unexposed``).
 - Introduced the new function ``clang_Type_getReplacementType`` which gets the type replacing
   the template type parameter when type kind is ``CXType_SubstTemplateTypeParm``.
+- Introduced the new function ``clang_Type_getFullyQualifiedName``, which gets the fully
+  qualified name of the given type, including qualification of all template parameters.
 
 Static Analyzer
 ---------------
 - Removed the deprecated ``-analyzer-store`` and
   ``-analyzer-opt-analyze-nested-blocks`` analyzer flags.
   ``scanbuild`` was also updated accordingly.
   Passing these flags will result in a hard error.
 

clang/include/clang-c/Index.h

 /*===-- clang-c/Index.h - Indexing Public C Interface -------------*- C -*-===*\
 |*                                                                            *|
 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
 |* Exceptions.                                                                *|
 |* See https://llvm.org/LICENSE.txt for license information.                  *|
 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|

  * Pretty-print the underlying type using the rules of the
  * language of the translation unit from which it came.
  *
  * If the type is invalid, an empty string is returned.
  */
 CINDEX_LINKAGE CXString clang_getTypeSpelling(CXType CT);
 
 /**
+ * Get the fully qualified name for a type.
+ *
+ * This includes full qualification of all template parameters.
+*/
+CINDEX_LINKAGE CXString clang_Type_getFullyQualifiedName(CXType CT);
+
+/**
  * Retrieve the underlying type of a typedef declaration.
  *
  * If the cursor does not reference a typedef declaration, an invalid type is
  * returned.
  */
 CINDEX_LINKAGE CXType clang_getTypedefDeclUnderlyingType(CXCursor C);
 
 /**

clang/test/Index/print-qualified-type.cpp

+namespace A {
+  namespace B {
+    struct Foo {};
+    template <class T>
+    struct Bar {
+    };
+
+    typedef Bar<Foo> FooBar;
+    void foobar(const FooBar&);
+  } 
+
+}
+
+
+
+// RUN: c-index-test -test-print-type -print-qualified-type-names %s -std=c++14 | FileCheck %s
+// CHECK: FunctionDecl=foobar:9:10 [type=void (const FooBar &)] [typekind=FunctionProto] [canonicaltype=void (const A::B::Bar<A::B::Foo> &)] [canonicaltypekind=FunctionProto] [resulttype=void] [resulttypekind=Void] [args= [const A::B::FooBar &] [LValueReference]] [isPOD=0] [isAnonRecDecl=0]

clang/tools/c-index-test/c-index-test.c

if (argc == 0)
     return CommentSchemaFile;
 
   if (!strncmp(argv[0], CommentsSchemaArg, strlen(CommentsSchemaArg)))
     CommentSchemaFile = argv[0] + strlen(CommentsSchemaArg);
 
   return CommentSchemaFile;
 }
 
+static int parse_print_qualified_type_names(int argc, const char **argv) {
+  const char *PrintQualifiedTypeNamesArg = "-print-qualified-type-names";
+  int PrintQualifiedTypeNames = 0;
+
+  if (argc == 0)
+    return PrintQualifiedTypeNames;
+
+  if (!strncmp(argv[0], PrintQualifiedTypeNamesArg, strlen(PrintQualifiedTypeNamesArg)))
+    PrintQualifiedTypeNames = 1;
+
+  return PrintQualifiedTypeNames;
+}
+
 /******************************************************************************/
 /* Pretty-printing.                                                           */
 /******************************************************************************/
 
 static const char *FileCheckPrefix = "CHECK";
 
 static void PrintCString(const char *CStr) {
   if (CStr != NULL && CStr[0] != '\0') {
static void PrintCursorExtent(CXCursor C) {
   PrintRange(extent, "Extent");
 }
 
 /* Data used by the visitors. */
 typedef struct {
   CXTranslationUnit TU;
   enum CXCursorKind *Filter;
   const char *CommentSchemaFile;
+  int PrintQualifiedTypeNames;
 } VisitorData;
 
 
 enum CXChildVisitResult FilteredPrintingVisitor(CXCursor Cursor,
                                                 CXCursor Parent,
                                                 CXClientData ClientData) {
   VisitorData *Data = (VisitorData *)ClientData;
   if (!Data->Filter || (Cursor.kind == *(enum CXCursorKind *)Data->Filter)) {
static enum CXChildVisitResult PrintVisibility(CXCursor cursor, CXCursor p,
 
   return CXChildVisit_Recurse;
 }
 
 /******************************************************************************/
 /* Typekind testing.                                                          */
 /******************************************************************************/
 
-static void PrintTypeAndTypeKind(CXType T, const char *Format) {
+static void PrintTypeAndTypeKind(CXType T, const char *Format,
+                                 int PrintQualifiedName) {
   CXString TypeSpelling, TypeKindSpelling;
 
+  if (PrintQualifiedName != 0) {
+    TypeSpelling = clang_Type_getFullyQualifiedName(T);
+  } else {
     TypeSpelling = clang_getTypeSpelling(T);
+  }
   TypeKindSpelling = clang_getTypeKindSpelling(T.kind);
   printf(Format,
          clang_getCString(TypeSpelling),
          clang_getCString(TypeKindSpelling));
   clang_disposeString(TypeSpelling);
   clang_disposeString(TypeKindSpelling);
 }
 
 static enum CXVisitorResult FieldVisitor(CXCursor C,
                                          CXClientData client_data) {
     (*(int *) client_data)+=1;
     return CXVisit_Continue;
 }
 
-static void PrintTypeTemplateArgs(CXType T, const char *Format) {
+static void PrintTypeTemplateArgs(CXType T, const char *Format,
+                                  int PrintQualifiedName) {
   int NumTArgs = clang_Type_getNumTemplateArguments(T);
   if (NumTArgs != -1 && NumTArgs != 0) {
     int i;
     CXType TArg;
     printf(Format, NumTArgs);
     for (i = 0; i < NumTArgs; ++i) {
       TArg = clang_Type_getTemplateArgumentAsType(T, i);
       if (TArg.kind != CXType_Invalid) {
-        PrintTypeAndTypeKind(TArg, " [type=%s] [typekind=%s]");
+        PrintTypeAndTypeKind(TArg, " [type=%s] [typekind=%s]",
+                             PrintQualifiedName);
       }
     }
     /* Ensure that the returned type is invalid when indexing off-by-one. */
     TArg = clang_Type_getTemplateArgumentAsType(T, i);
     assert(TArg.kind == CXType_Invalid);
     printf("]");
   }
 }

 
 static enum CXChildVisitResult PrintType(CXCursor cursor, CXCursor p,
                                          CXClientData d) {
   if (!clang_isInvalid(clang_getCursorKind(cursor))) {
     CXType T = clang_getCursorType(cursor);
     CXType PT = clang_getPointeeType(T);
     enum CXRefQualifierKind RQ = clang_Type_getCXXRefQualifier(T);
     PrintCursor(cursor, NULL);
-    PrintTypeAndTypeKind(T, " [type=%s] [typekind=%s]");
+    VisitorData *Data = (VisitorData *)d;
+    PrintTypeAndTypeKind(T, " [type=%s] [typekind=%s]",
+                         Data->PrintQualifiedTypeNames);
     PrintNullabilityKind(T, " [nullability=%s]");
     if (clang_isConstQualifiedType(T))
       printf(" const");
     if (clang_isVolatileQualifiedType(T))
       printf(" volatile");
     if (clang_isRestrictQualifiedType(T))
       printf(" restrict");
     if (RQ == CXRefQualifier_LValue)
       printf(" lvalue-ref-qualifier");
     if (RQ == CXRefQualifier_RValue)
       printf(" rvalue-ref-qualifier");
     /* Print the template argument types if they exist. */
-    PrintTypeTemplateArgs(T, " [templateargs/%d=");
+    PrintTypeTemplateArgs(T,
+                          " [templateargs/%d=", Data->PrintQualifiedTypeNames);
     /* Print the canonical type if it is different. */
     {
       CXType CT = clang_getCanonicalType(T);
       if (!clang_equalTypes(T, CT)) {
-        PrintTypeAndTypeKind(CT, " [canonicaltype=%s] [canonicaltypekind=%s]");
-        PrintTypeTemplateArgs(CT, " [canonicaltemplateargs/%d=");
+        PrintTypeAndTypeKind(CT, " [canonicaltype=%s] [canonicaltypekind=%s]",
+                             Data->PrintQualifiedTypeNames);
+        PrintTypeTemplateArgs(
+            CT, " [canonicaltemplateargs/%d=", Data->PrintQualifiedTypeNames);
       }
     }
     /* Print the value type if it exists. */
     {
       CXType VT = clang_Type_getValueType(T);
       if (VT.kind != CXType_Invalid)
-        PrintTypeAndTypeKind(VT, " [valuetype=%s] [valuetypekind=%s]");
+        PrintTypeAndTypeKind(VT, " [valuetype=%s] [valuetypekind=%s]",
+                             Data->PrintQualifiedTypeNames);
     }
     /* Print the modified type if it exists. */
     {
       CXType MT = clang_Type_getModifiedType(T);
       if (MT.kind != CXType_Invalid) {
-        PrintTypeAndTypeKind(MT, " [modifiedtype=%s] [modifiedtypekind=%s]");
+        PrintTypeAndTypeKind(MT, " [modifiedtype=%s] [modifiedtypekind=%s]",
+                             Data->PrintQualifiedTypeNames);
       }
     }
     /* Print the return type if it exists. */
     {
       CXType RT = clang_getCursorResultType(cursor);
       if (RT.kind != CXType_Invalid) {
-        PrintTypeAndTypeKind(RT, " [resulttype=%s] [resulttypekind=%s]");
+        PrintTypeAndTypeKind(RT, " [resulttype=%s] [resulttypekind=%s]",
+                             Data->PrintQualifiedTypeNames);
       }
       PrintNullabilityKind(RT, " [resultnullability=%s]");
     }
     /* Print the argument types if they exist. */
     {
       int NumArgs = clang_Cursor_getNumArguments(cursor);
       if (NumArgs != -1 && NumArgs != 0) {
         int i;
         printf(" [args=");
         for (i = 0; i < NumArgs; ++i) {
           CXType T = clang_getCursorType(clang_Cursor_getArgument(cursor, i));
           if (T.kind != CXType_Invalid) {
-            PrintTypeAndTypeKind(T, " [%s] [%s]");
+            PrintTypeAndTypeKind(T, " [%s] [%s]",
+                                 Data->PrintQualifiedTypeNames);
             PrintNullabilityKind(T, " [%s]");
           }
         }
         printf("]");
       }
     }
     /* Print ObjC base types, type arguments, and protocol list if available. */
     {
       CXType BT = clang_Type_getObjCObjectBaseType(PT);
       if (BT.kind != CXType_Invalid) {
-        PrintTypeAndTypeKind(BT, " [basetype=%s] [basekind=%s]");
+        PrintTypeAndTypeKind(BT, " [basetype=%s] [basekind=%s]",
+                             Data->PrintQualifiedTypeNames);
       }
     }
     {
       unsigned NumTypeArgs = clang_Type_getNumObjCTypeArgs(PT);
       if (NumTypeArgs > 0) {
         unsigned i;
         printf(" [typeargs=");
         for (i = 0; i < NumTypeArgs; ++i) {
           CXType TA = clang_Type_getObjCTypeArg(PT, i);
           if (TA.kind != CXType_Invalid) {
-            PrintTypeAndTypeKind(TA, " [%s] [%s]");
+            PrintTypeAndTypeKind(TA, " [%s] [%s]",
+                                 Data->PrintQualifiedTypeNames);
           }
         }
         printf("]");
       }
     }
     {
       unsigned NumProtocols = clang_Type_getNumObjCProtocolRefs(PT);
       if (NumProtocols > 0) {
         unsigned i;
         printf(" [protocols=");
         for (i = 0; i < NumProtocols; ++i) {
           CXCursor P = clang_Type_getObjCProtocolDecl(PT, i);
           if (!clang_isInvalid(clang_getCursorKind(P))) {
             PrintCursor(P, NULL);
           }
         }
         printf("]");
       }
     }
     /* Print if this is a non-POD type. */
     printf(" [isPOD=%d]", clang_isPODType(T));
     /* Print the pointee type. */
     {
       if (PT.kind != CXType_Invalid) {
-        PrintTypeAndTypeKind(PT, " [pointeetype=%s] [pointeekind=%s]");
+        PrintTypeAndTypeKind(PT, " [pointeetype=%s] [pointeekind=%s]",
+                             Data->PrintQualifiedTypeNames);
       }
     }
     /* Print the number of fields if they exist. */
     {
       int numFields = 0;
       if (clang_Type_visitFields(T, FieldVisitor, &numFields)){
         if (numFields != 0) {
           printf(" [nbFields=%d]", numFields);
if (!clang_isInvalid(clang_getCursorKind(cursor))) {
 
     printf("\n");
   }
   return CXChildVisit_Recurse;
 }
 
 static void PrintSingleTypeSize(CXType T, const char *TypeKindFormat,
                                 const char *SizeFormat,
-                                const char *AlignFormat) {
-  PrintTypeAndTypeKind(T, TypeKindFormat);
+                                const char *AlignFormat,
+                                int PrintQualifiedName) {
+  PrintTypeAndTypeKind(T, TypeKindFormat, PrintQualifiedName);
   /* Print the type sizeof if applicable. */
   {
     long long Size = clang_Type_getSizeOf(T);
     if (Size >= 0 || Size < -1 ) {
       printf(SizeFormat, Size);
     }
   }
   /* Print the type alignof if applicable. */
   {
     long long Align = clang_Type_getAlignOf(T);
     if (Align >= 0 || Align < -1) {
       printf(AlignFormat, Align);
     }
   }
 
   /* Print the return type if it exists. */
   {
     CXType RT = clang_getResultType(T);
     if (RT.kind != CXType_Invalid)
       PrintSingleTypeSize(RT, " [resulttype=%s] [resulttypekind=%s]",
-                              " [resultsizeof=%lld]", " [resultalignof=%lld]");
+                          " [resultsizeof=%lld]", " [resultalignof=%lld]",
+                          PrintQualifiedName);
   }
 }
 
 static enum CXChildVisitResult PrintTypeSize(CXCursor cursor, CXCursor p,
                                              CXClientData d) {
   CXType T;
   enum CXCursorKind K = clang_getCursorKind(cursor);
   if (clang_isInvalid(K))
     return CXChildVisit_Recurse;
   T = clang_getCursorType(cursor);
   PrintCursor(cursor, NULL);
+  VisitorData *Data = (VisitorData *)d;
   PrintSingleTypeSize(T, " [type=%s] [typekind=%s]", " [sizeof=%lld]",
-                      " [alignof=%lld]");
+                      " [alignof=%lld]", Data->PrintQualifiedTypeNames);
   /* Print the record field offset if applicable. */
   {
     CXString FieldSpelling = clang_getCursorSpelling(cursor);
     const char *FieldName = clang_getCString(FieldSpelling);
     /* recurse to get the first parent record that is not anonymous. */
     unsigned RecordIsAnonymous = 0;
     if (clang_getCursorKind(cursor) == CXCursor_FieldDecl) {
       CXCursor Record;

 /******************************************************************************/
 
 static enum CXChildVisitResult PrintTypeDeclaration(CXCursor cursor, CXCursor p,
                                              CXClientData d) {
   CXCursor typeDeclaration = clang_getTypeDeclaration(clang_getCursorType(cursor));
 
   if (clang_isDeclaration(typeDeclaration.kind)) {
     PrintCursor(cursor, NULL);
-    PrintTypeAndTypeKind(clang_getCursorType(typeDeclaration), " [typedeclaration=%s] [typekind=%s]\n");
+    VisitorData *Data = (VisitorData *)d;
+    PrintTypeAndTypeKind(clang_getCursorType(typeDeclaration),
+                         " [typedeclaration=%s] [typekind=%s]\n",
+                         Data->PrintQualifiedTypeNames);
   }
 
   return CXChildVisit_Recurse;
 }
 
 /******************************************************************************/
 /* Declaration attributes testing                                             */
 /******************************************************************************/

 /******************************************************************************/
 /* Loading ASTs/source.                                                       */
 /******************************************************************************/
 
 static int perform_test_load(CXIndex Idx, CXTranslationUnit TU,
                              const char *filter, const char *prefix,
                              CXCursorVisitor Visitor,
                              PostVisitTU PV,
-                             const char *CommentSchemaFile) {
+                             const char *CommentSchemaFile,
+                             int PrintQualifiedTypeNames) {
 
   if (prefix)
     FileCheckPrefix = prefix;
 
   if (Visitor) {
     enum CXCursorKind K = CXCursor_NotImplemented;
     enum CXCursorKind *ck = &K;
     VisitorData Data;
if (Visitor) {
     else {
       fprintf(stderr, "Unknown filter for -test-load-tu: %s\n", filter);
       return 1;
     }
 
     Data.TU = TU;
     Data.Filter = ck;
     Data.CommentSchemaFile = CommentSchemaFile;
+    Data.PrintQualifiedTypeNames = PrintQualifiedTypeNames;
     clang_visitChildren(clang_getTranslationUnitCursor(TU), Visitor, &Data);
   }
 
   if (PV)
     PV(TU);
 
   PrintDiagnostics(TU);
   if (checkForErrors(TU) != 0) {
     clang_disposeTranslationUnit(TU);
     return -1;
   }
 
   clang_disposeTranslationUnit(TU);
   return 0;
 }
 
 int perform_test_load_tu(const char *file, const char *filter,
                          const char *prefix, CXCursorVisitor Visitor,
-                         PostVisitTU PV) {
+                         PostVisitTU PV, int PrintQualifiedTypeNames) {
   CXIndex Idx;
   CXTranslationUnit TU;
   int result;
   Idx = clang_createIndex(/* excludeDeclsFromPCH */
                           !strcmp(filter, "local") ? 1 : 0,
                           /* displayDiagnostics=*/1);
 
   if (!CreateTranslationUnit(Idx, file, &TU)) {
     clang_disposeIndex(Idx);
     return 1;
   }
 
-  result = perform_test_load(Idx, TU, filter, prefix, Visitor, PV, NULL);
+  result = perform_test_load(Idx, TU, filter, prefix, Visitor, PV, NULL,
+                             PrintQualifiedTypeNames);
   clang_disposeIndex(Idx);
   return result;
 }
 
 int perform_test_load_source(int argc, const char **argv,
                              const char *filter, CXCursorVisitor Visitor,
                              PostVisitTU PV) {
   CXIndex Idx;
   CXTranslationUnit TU;
   const char *CommentSchemaFile;
+  int PrintQualifiedTypeNames = 0;
   struct CXUnsavedFile *unsaved_files = 0;
   int num_unsaved_files = 0;
   enum CXErrorCode Err;
   int result;
   unsigned Repeats = 0;
   unsigned I;
   const char *InvocationPath;
 
   Idx = clang_createIndex(/* excludeDeclsFromPCH */
                           (!strcmp(filter, "local") ||
                            !strcmp(filter, "local-display") ||
                            !strcmp(filter, "local-pretty"))
                               ? 1
                               : 0,
                           /* displayDiagnostics=*/1);
   InvocationPath = getenv("CINDEXTEST_INVOCATION_EMISSION_PATH");
   if (InvocationPath)
     clang_CXIndex_setInvocationEmissionPathOption(Idx, InvocationPath);
 
   if ((CommentSchemaFile = parse_comments_schema(argc, argv))) {
     argc--;
     argv++;
   }
 
+  if ((PrintQualifiedTypeNames = parse_print_qualified_type_names(argc, argv))) {
+    argc--;
+    argv++;
+  }
+
   if (parse_remapped_files(argc, argv, 0, &unsaved_files, &num_unsaved_files)) {
     clang_disposeIndex(Idx);
     return -1;
   }
 
   if (getenv("CINDEXTEST_EDITING"))
     Repeats = 5;
 
if (Repeats > 1) {
         free_remapped_files(unsaved_files, num_unsaved_files);
         clang_disposeIndex(Idx);
         return 1;
       }
     }
   }
 
   result = perform_test_load(Idx, TU, filter, NULL, Visitor, PV,
-                             CommentSchemaFile);
+                             CommentSchemaFile, PrintQualifiedTypeNames);
   free_remapped_files(unsaved_files, num_unsaved_files);
   clang_disposeIndex(Idx);
   return result;
 }
 
 int perform_test_reparse_source(int argc, const char **argv, int trials,
                                 const char *filter, CXCursorVisitor Visitor,
                                 PostVisitTU PV) {
   CXIndex Idx;
   CXTranslationUnit TU;
   struct CXUnsavedFile *unsaved_files = 0;
   int num_unsaved_files = 0;
   int compiler_arg_idx = 0;
   enum CXErrorCode Err;
   int result, i;
   int trial;
   int execute_after_trial = 0;
   const char *execute_command = NULL;
   int remap_after_trial = 0;
   char *endptr = 0;
+  int PrintQualifiedTypeNames = 0;
   
   Idx = clang_createIndex(/* excludeDeclsFromPCH */
                           !strcmp(filter, "local") ? 1 : 0,
                           /* displayDiagnostics=*/1);
   
   if (parse_remapped_files(argc, argv, 0, &unsaved_files, &num_unsaved_files)) {
     clang_disposeIndex(Idx);
     return -1;
if (Err != CXError_Success) {
       free_remapped_files(unsaved_files, num_unsaved_files);
       clang_disposeIndex(Idx);
       return -1;      
     }
 
     if (checkForErrors(TU) != 0)
       return -1;
   }
-  
-  result = perform_test_load(Idx, TU, filter, NULL, Visitor, PV, NULL);
+  result = perform_test_load(Idx, TU, filter, NULL, Visitor, PV, NULL,
+                             PrintQualifiedTypeNames);
 
   free_remapped_files(unsaved_files, num_unsaved_files);
   clang_disposeIndex(Idx);
   return result;
 }
 
 static int perform_single_file_parse(const char *filename) {
   CXIndex Idx;
static int perform_single_file_parse(const char *filename) {
   if (Err != CXError_Success) {
     fprintf(stderr, "Unable to load translation unit!\n");
     describeLibclangFailure(Err);
     clang_disposeIndex(Idx);
     return 1;
   }
 
   result = perform_test_load(Idx, TU, /*filter=*/"all", /*prefix=*/NULL, FilteredPrintingVisitor, /*PostVisit=*/NULL,
-                             /*CommentSchemaFile=*/NULL);
+                             /*CommentSchemaFile=*/NULL,
+                             /*PrintQualifiedTypeNames*/ 0);
   clang_disposeIndex(Idx);
   return result;
 }
 
 static int perform_file_retain_excluded_cb(const char *filename) {
   CXIndex Idx;
   CXTranslationUnit TU;
   enum CXErrorCode Err;
static int perform_file_retain_excluded_cb(const char *filename) {
   if (Err != CXError_Success) {
     fprintf(stderr, "Unable to load translation unit!\n");
     describeLibclangFailure(Err);
     clang_disposeIndex(Idx);
     return 1;
   }
 
   result = perform_test_load(Idx, TU, /*filter=*/"all", /*prefix=*/NULL, FilteredPrintingVisitor, /*PostVisit=*/NULL,
-                             /*CommentSchemaFile=*/NULL);
+                             /*CommentSchemaFile=*/NULL,
+                             /*PrintQualifiedTypeNames*/ 0);
   clang_disposeIndex(Idx);
   return result;
 }
 
 /******************************************************************************/
 /* Logic for testing clang_getCursor().                                       */
 /******************************************************************************/
 
int cindextest_main(int argc, const char **argv) {
   if (argc > 2 && strcmp(argv[1], "-index-tu") == 0)
     return index_tu(argc - 2, argv + 2);
   if (argc > 2 && strcmp(argv[1], "-index-compile-db") == 0)
     return index_compile_db(argc - 2, argv + 2);
   else if (argc >= 4 && strncmp(argv[1], "-test-load-tu", 13) == 0) {
     CXCursorVisitor I = GetVisitor(argv[1] + 13);
     if (I)
       return perform_test_load_tu(argv[2], argv[3], argc >= 5 ? argv[4] : 0, I,
-                                  NULL);
+                                  NULL, 0);
   }
   else if (argc >= 5 && strncmp(argv[1], "-test-load-source-reparse", 25) == 0){
     CXCursorVisitor I = GetVisitor(argv[1] + 25);
     if (I) {
       int trials = atoi(argv[2]);
       return perform_test_reparse_source(argc - 4, argv + 4, trials, argv[3], I, 
                                          NULL);
     }
return perform_file_scan(argv[2], argv[3],
                              argc >= 5 ? argv[4] : 0);
   else if (argc > 2 && strstr(argv[1], "-test-annotate-tokens=") == argv[1])
     return perform_token_annotation(argc, argv);
   else if (argc > 2 && strcmp(argv[1], "-test-inclusion-stack-source") == 0)
     return perform_test_load_source(argc - 2, argv + 2, "all", NULL,
                                     PrintInclusionStack);
   else if (argc > 2 && strcmp(argv[1], "-test-inclusion-stack-tu") == 0)
     return perform_test_load_tu(argv[2], "all", NULL, NULL,
-                                PrintInclusionStack);
+                                PrintInclusionStack, 0);
   else if (argc > 2 && strcmp(argv[1], "-test-print-linkage-source") == 0)
     return perform_test_load_source(argc - 2, argv + 2, "all", PrintLinkage,
                                     NULL);
   else if (argc > 2 && strcmp(argv[1], "-test-print-visibility") == 0)
     return perform_test_load_source(argc - 2, argv + 2, "all", PrintVisibility,
                                     NULL);
   else if (argc > 2 && strcmp(argv[1], "-test-print-type") == 0)
     return perform_test_load_source(argc - 2, argv + 2, "all",
                                     PrintType, 0);
   else if (argc > 2 && strcmp(argv[1], "-test-print-type-size") == 0)
     return perform_test_load_source(argc - 2, argv + 2, "all",
                                     PrintTypeSize, 0);
   else if (argc > 2 && strcmp(argv[1], "-test-print-type-declaration") == 0)
     return perform_test_load_source(argc - 2, argv + 2, "all",
                                     PrintTypeDeclaration, 0);
   else if (argc > 2 && strcmp(argv[1], "-test-print-decl-attributes") == 0)
     return perform_test_load_source(argc - 2, argv + 2, "all",
                                     PrintDeclAttributes, 0);
   else if (argc > 2 && strcmp(argv[1], "-test-print-bitwidth") == 0)
     return perform_test_load_source(argc - 2, argv + 2, "all",
                                     PrintBitWidth, 0);
   else if (argc > 2 && strcmp(argv[1], "-test-print-mangle") == 0)
-    return perform_test_load_tu(argv[2], "all", NULL, PrintMangledName, NULL);
+    return perform_test_load_tu(argv[2], "all", NULL, PrintMangledName, NULL, 0);
   else if (argc > 2 && strcmp(argv[1], "-test-print-manglings") == 0)
-    return perform_test_load_tu(argv[2], "all", NULL, PrintManglings, NULL);
+    return perform_test_load_tu(argv[2], "all", NULL, PrintManglings, NULL, 0);
   else if (argc > 2 && strcmp(argv[1], "-test-print-target-info") == 0)
     return print_target_info(argc - 2, argv + 2);
   else if (argc > 1 && strcmp(argv[1], "-print-usr") == 0) {
     if (argc > 2)
       return print_usrs(argv + 2, argv + argc);
     else {
       display_usrs();
       return 1;

clang/tools/libclang/CXType.cpp

 //===- CXType.cpp - Implements 'CXTypes' aspect of libclang ---------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===--------------------------------------------------------------------===//
 //
 // This file implements the 'CXTypes' API hooks in the Clang-C library.
 //
 //===--------------------------------------------------------------------===//
 
 #include "CIndexer.h"
 #include "CXCursor.h"
 #include "CXString.h"
 #include "CXTranslationUnit.h"
 #include "CXType.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/Type.h"
+#include "clang/AST/QualTypeNames.h"
 #include "clang/Basic/AddressSpaces.h"
 #include "clang/Frontend/ASTUnit.h"
 
 using namespace clang;
 
 static CXTypeKind GetBuiltinTypeKind(const BuiltinType *BT) {
 #define BTCASE(K) case BuiltinType::K: return CXType_##K
   switch (BT->getKind()) {
CXString clang_getTypeSpelling(CXType CT) {
   llvm::raw_svector_ostream OS(Str);
   PrintingPolicy PP(cxtu::getASTUnit(TU)->getASTContext().getLangOpts());
 
   T.print(OS, PP);
 
   return cxstring::createDup(OS.str());
 }
 
+CXString clang_Type_getFullyQualifiedName(CXType CT) {
+  QualType T = GetQualType(CT);
+  if (T.isNull())
+    return cxstring::createEmpty();
+
+  const ASTContext &Ctx = cxtu::getASTUnit(GetTU(CT))->getASTContext();
+  std::string QualName = clang::TypeName::getFullyQualifiedName(
+      T, Ctx, Ctx.getLangOpts());
+
+  return cxstring::createDup(QualName);
+}
+
 CXType clang_getTypedefDeclUnderlyingType(CXCursor C) {
   using namespace cxcursor;
   CXTranslationUnit TU = cxcursor::getCursorTU(C);
 
   if (clang_isDeclaration(C.kind)) {
     const Decl *D = cxcursor::getCursorDecl(C);
 
     if (const TypedefNameDecl *TD = dyn_cast_or_null<TypedefNameDecl>(D)) {
       QualType T = TD->getUnderlyingType();

clang/tools/libclang/libclang.map

 
 LLVM_16 {
   global:
     clang_getUnqualifiedType;
     clang_getNonReferenceType;
     clang_CXXMethod_isDeleted;
     clang_CXXMethod_isCopyAssignmentOperator;
     clang_CXXMethod_isMoveAssignmentOperator;
+    clang_Type_getFullyQualifiedName;
 };
 
 # Example of how to add a new symbol version entry.  If you do add a new symbol
 # version, please update the example to depend on the version you added.
 # LLVM_X {
 # global:
 #   clang_newsymbol;
 # };