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 ↗

(On Diff #477085)

1787 ↗

(On Diff #477085)

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

1787 ↗

(On Diff #477085)

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

1787 ↗

(On Diff #477085)

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

1787 ↗

(On Diff #477085)

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/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();
+
+  CXTranslationUnit TU = GetTU(CT);
+  SmallString<64> Str;
+  llvm::raw_svector_ostream OS(Str);
+  PrintingPolicy PP(cxtu::getASTUnit(TU)->getASTContext().getLangOpts());
+
+  std::string qname = clang::TypeName::getFullyQualifiedName(
+      T, cxtu::getASTUnit(TU)->getASTContext(), PP);
+
+  return cxstring::createDup(qname);
+}
+
 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)) {

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;
 # };