Allow getting template args for ClassTemplateSpecializations

[anderslanglands]

Summary

Modifies clang_Cursor_getNumTemplateArguments() and friends to work on Struct, Class and ClassTemplatePartialSpecialization decls as well as functions

[anderslanglands]

Hello again, this generalizes the template argument functionality to operate on cursor kinds other than functions.

I could use some help creating a test for this. On my previous patch I was able to just copy/paste and modify an existing test, but from a quick scan of the current tests I can't see how I'd modify one of them to test this functionality.

[anderslanglands]

Updating doc comments to reflect new functionality

[aaron.ballman]

Mostly nits from me (FWIW, we use auto when the type is explicitly spelled out in the initialization and we don't usually use else after an unconditional return as a matter of coding style.) In terms of the test coverage, I would probably make a new test modeled after https://github.com/llvm/llvm-project/blob/main/clang/test/Index/cxx14-lambdas.cpp.

clang/include/clang-c/Index.h

3594–3595

Since we're in the area already...

clang/tools/libclang/CXCursor.cpp

1357

CXCursor_StructDecl is interesting -- does that only get used in C or will it also show up in C++? If it's C-only, we can drop that bit.

1363

1370–1379

1403

Same question here about struct decl as above.

1409

1423–1439

[anderslanglands]

Add testing, address style notes

[anderslanglands]

I ended up modifying c-index-test to print out the template arguments in the same way it does for FunctionDecl, which ends up working all cases in the existing test suite. The only other thing I added was a specific case in index-templates.cpp to check whether it catches StructDecl too (it does).

clang/tools/libclang/CXCursor.cpp

1357

It does. I added a case to index-templates.cpp that tests for this.

[aaron.ballman]

LGTM! I can fix up the minor nit with the release note formatting when I land on your behalf.

clang/docs/ReleaseNotes.rst

407–408

clang/docs/ReleaseNotes.rst

 libclang
 --------
 - Introduced the new function ``clang_getUnqualifiedType``, which mimics
   the behavior of ``QualType::getUnqualifiedType`` for ``CXType``.
 - Introduced the new function ``clang_getNonReferenceType``, which mimics
   the behavior of ``QualType::getNonReferenceType`` for ``CXType``.
 - Introduced the new function ``clang_CXXMethod_isDeleted``, which queries
   whether the method is declared ``= delete``.
+- ``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.
 
 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

enum CXTemplateArgumentKind {
   CXTemplateArgumentKind_TemplateExpansion,
   CXTemplateArgumentKind_Expression,
   CXTemplateArgumentKind_Pack,
   /* Indicates an error case, preventing the kind from being deduced. */
   CXTemplateArgumentKind_Invalid
 };
 
 /**
- *Returns the number of template args of a function decl representing a
- * template specialization.
+ *Returns the number of template args of a function, struct, or class decl
+ *representing a template specialization.
  *
  * If the argument cursor cannot be converted into a template function
  * declaration, -1 is returned.
  *
  * For example, for the following declaration and specialization:
  *   template <typename T, int kInt, bool kBool>
  *   void foo() { ... }
  *
  *   template <>
  *   void foo<float, -7, true>();
  *
  * The value 3 would be returned from this call.
  */
 CINDEX_LINKAGE int clang_Cursor_getNumTemplateArguments(CXCursor C);
 
 /**
  * Retrieve the kind of the I'th template argument of the CXCursor C.
  *
- * If the argument CXCursor does not represent a FunctionDecl, an invalid
- * template argument kind is returned.
+ * If the argument CXCursor does not represent a FunctionDecl, StructDecl, or
+ * ClassTemplatePartialSpecialization, an invalid template argument kind is
+ * returned.
  *
  * For example, for the following declaration and specialization:
  *   template <typename T, int kInt, bool kBool>
  *   void foo() { ... }
  *
  *   template <>
  *   void foo<float, -7, true>();
  *
  * For I = 0, 1, and 2, Type, Integral, and Integral will be returned,
  * respectively.
  */
 CINDEX_LINKAGE enum CXTemplateArgumentKind
 clang_Cursor_getTemplateArgumentKind(CXCursor C, unsigned I);
 
 /**
  * Retrieve a CXType representing the type of a TemplateArgument of a
  *  function decl representing a template specialization.
  *
- * If the argument CXCursor does not represent a FunctionDecl whose I'th
- * template argument has a kind of CXTemplateArgKind_Integral, an invalid type
- * is returned.
+ * If the argument CXCursor does not represent a FunctionDecl, StructDecl,
+ * ClassDecl or ClassTemplatePartialSpecialization whose I'th template argument
+ * has a kind of CXTemplateArgKind_Integral, an invalid type is returned.
  *
  * For example, for the following declaration and specialization:
  *   template <typename T, int kInt, bool kBool>
  *   void foo() { ... }
  *
  *   template <>
  *   void foo<float, -7, true>();
  *
  * If called with I = 0, "float", will be returned.
  * Invalid types will be returned for I == 1 or 2.
  */
 CINDEX_LINKAGE CXType clang_Cursor_getTemplateArgumentType(CXCursor C,
                                                            unsigned I);
 
 /**
  * Retrieve the value of an Integral TemplateArgument (of a function
  *  decl representing a template specialization) as a signed long long.
  *
  * It is undefined to call this function on a CXCursor that does not represent a
- * FunctionDecl or whose I'th template argument is not an integral value.
+ * FunctionDecl, StructDecl, ClassDecl or ClassTemplatePartialSpecialization
+ * whose I'th template argument is not an integral value.
  *
  * For example, for the following declaration and specialization:
  *   template <typename T, int kInt, bool kBool>
  *   void foo() { ... }
  *
  *   template <>
  *   void foo<float, -7, true>();
  *
  * If called with I = 1 or 2, -7 or true will be returned, respectively.
  * For I == 0, this function's behavior is undefined.
  */
 CINDEX_LINKAGE long long clang_Cursor_getTemplateArgumentValue(CXCursor C,
                                                                unsigned I);
 
 /**
  * Retrieve the value of an Integral TemplateArgument (of a function
  *  decl representing a template specialization) as an unsigned long long.
  *
  * It is undefined to call this function on a CXCursor that does not represent a
- * FunctionDecl or whose I'th template argument is not an integral value.
+ * FunctionDecl, StructDecl, ClassDecl or ClassTemplatePartialSpecialization or
+ * whose I'th template argument is not an integral value.
  *
  * For example, for the following declaration and specialization:
  *   template <typename T, int kInt, bool kBool>
  *   void foo() { ... }
  *
  *   template <>
  *   void foo<float, 2147483649, true>();
  *

clang/tools/libclang/CXCursor.cpp

if (const CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(E)) {
       }
     }
   }
 
   return clang_getNullCursor();
 }
 
 int clang_Cursor_getNumTemplateArguments(CXCursor C) {
-  if (clang_getCursorKind(C) != CXCursor_FunctionDecl) {
-    return -1;
-  }
-
-  const FunctionDecl *FD =
-      llvm::dyn_cast_or_null<clang::FunctionDecl>(getCursorDecl(C));
-  if (!FD) {
+  CXCursorKind kind = clang_getCursorKind(C);
+  if (kind != CXCursor_FunctionDecl && kind != CXCursor_StructDecl &&
+      kind != CXCursor_ClassDecl &&
+      kind != CXCursor_ClassTemplatePartialSpecialization) {
     return -1;
   }
 
+  if (const FunctionDecl *FD =
+          llvm::dyn_cast_if_present<clang::FunctionDecl>(getCursorDecl(C))) {
     const FunctionTemplateSpecializationInfo *SpecInfo =
         FD->getTemplateSpecializationInfo();
     if (!SpecInfo) {
       return -1;
     }
-
     return SpecInfo->TemplateArguments->size();
+  } else if (const ClassTemplateSpecializationDecl *SD =
+                 llvm::dyn_cast_if_present<
+                     clang::ClassTemplateSpecializationDecl>(
+                     getCursorDecl(C))) {
+    return SD->getTemplateArgs().size();
+  } else {
+    return -1;
+  }
 }
 
 enum CXGetTemplateArgumentStatus {
   /** The operation completed successfully */
   CXGetTemplateArgumentStatus_Success = 0,
 
-  /** The specified cursor did not represent a FunctionDecl. */
-  CXGetTemplateArgumentStatus_CursorNotFunctionDecl = -1,
-
-  /** The specified cursor was not castable to a FunctionDecl. */
-  CXGetTemplateArgumentStatus_BadFunctionDeclCast = -2,
+  /** The specified cursor did not represent a FunctionDecl or
+      ClassTemplateSpecializationDecl.                         */
+  CXGetTemplateArgumentStatus_CursorNotCompatibleDecl = -1,
+
+  /** The specified cursor was not castable to a FunctionDecl or
+      ClassTemplateSpecializationDecl.                         */
+  CXGetTemplateArgumentStatus_BadDeclCast = -2,
 
   /** A NULL FunctionTemplateSpecializationInfo was retrieved. */
   CXGetTemplateArgumentStatus_NullTemplSpecInfo = -3,
 
   /** An invalid (OOB) argument index was specified */
   CXGetTemplateArgumentStatus_InvalidIndex = -4
 };
 
 static int clang_Cursor_getTemplateArgument(CXCursor C, unsigned I,
                                             TemplateArgument *TA) {
-  if (clang_getCursorKind(C) != CXCursor_FunctionDecl) {
-    return CXGetTemplateArgumentStatus_CursorNotFunctionDecl;
+  CXCursorKind kind = clang_getCursorKind(C);
+  if (kind != CXCursor_FunctionDecl && kind != CXCursor_StructDecl &&
+      kind != CXCursor_ClassDecl &&
+      kind != CXCursor_ClassTemplatePartialSpecialization) {
+    return -1;
   }
 
-  const FunctionDecl *FD =
-      llvm::dyn_cast_or_null<clang::FunctionDecl>(getCursorDecl(C));
-  if (!FD) {
-    return CXGetTemplateArgumentStatus_BadFunctionDeclCast;
-  }
+  if (const FunctionDecl *FD =
+          llvm::dyn_cast_if_present<clang::FunctionDecl>(getCursorDecl(C))) {
 
     const FunctionTemplateSpecializationInfo *SpecInfo =
         FD->getTemplateSpecializationInfo();
     if (!SpecInfo) {
       return CXGetTemplateArgumentStatus_NullTemplSpecInfo;
     }
 
     if (I >= SpecInfo->TemplateArguments->size()) {
       return CXGetTemplateArgumentStatus_InvalidIndex;
     }
 
     *TA = SpecInfo->TemplateArguments->get(I);
     return 0;
+  } else if (const ClassTemplateSpecializationDecl *SD =
+                 llvm::dyn_cast_if_present<
+                     clang::ClassTemplateSpecializationDecl>(
+                     getCursorDecl(C))) {
+    if (I >= SD->getTemplateArgs().size()) {
+      printf("INVALID INDEX\n");
+      return CXGetTemplateArgumentStatus_InvalidIndex;
+    }
+
+    *TA = SD->getTemplateArgs()[I];
+    return 0;
+  } else {
+    printf("CAST FAILED\n");
+    return CXGetTemplateArgumentStatus_BadDeclCast;
+  }
 }
 
 enum CXTemplateArgumentKind clang_Cursor_getTemplateArgumentKind(CXCursor C,
                                                                  unsigned I) {
   TemplateArgument TA;
   if (clang_Cursor_getTemplateArgument(C, I, &TA)) {
     return CXTemplateArgumentKind_Invalid;
   }