Add support for querying SubstTemplateTypeParm types

[anderslanglands]

Summary

Adds CXType_SubstTemplateTypeParm and clang_Type_getReplacementType()

[aaron.ballman]

Thanks for this! You should also add a release note about the new functionality.

clang/include/clang-c/Index.h

2793–2794

clang/tools/libclang/CXType.cpp

129–130

1363–1367

1367

Can you add the newline back?

clang/tools/libclang/libclang.map

170

You should keep this in alphabetical order.

[anderslanglands]

Added release note, incorporated other review notes

[aaron.ballman]

LGTM, thank you!

[anderslanglands]

Great, thanks! I've got a couple more things to land once this is merged and I've cleaned them up. Do you wanna show me how to do the merge myself?

[anderslanglands]

Arg just noticed an issue: clang_Type_getReplacementType should be in the LLVM_16 block in libclang.map not in the LLVM_13 block. I've blown away my local branch so don't know how to fix the patch. Shall I just make a new patch once this is merged?

[aaron.ballman]

In D137818#3939213, @anderslanglands wrote:

Arg just noticed an issue: clang_Type_getReplacementType should be in the LLVM_16 block in libclang.map not in the LLVM_13 block. I've blown away my local branch so don't know how to fix the patch. Shall I just make a new patch once this is merged?

In Phabricator, you can click the "Download Raw Diff" link (right-hand side of the page, near-ish the top) to get the patch back; you should be able to use that to get your local branch back to the same state.

[anderslanglands]

Move getReplacementType to LLVM_16 block

clang/docs/ReleaseNotes.rst

- Introduced the new function ``clang_CXXMethod_isCopyAssignmentOperator``,
   operator.
 - Introduced the new function ``clang_CXXMethod_isMoveAssignmentOperator``,
   which identifies whether a method cursor is a move-assignment
   operator.
 - ``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``.
 
 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                    *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
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,
+  /* Represents a type that has been substituted for a template type parameter. */
+  CXType_SubstTemplateTypeParm = 179
 };
 
 /**
  * Describes the calling convention of a function type
  */
 enum CXCallingConv {
   CXCallingConv_Default = 0,
   CXCallingConv_C = 1,

 /**
  * Gets the type contained by this atomic type.
  *
  * If a non-atomic type is passed in, an invalid type is returned.
  */
 CINDEX_LINKAGE CXType clang_Type_getValueType(CXType CT);
 
 /**
+ * Gets the replacement type for a SubstTemplateTypeParm type.
+ *
+ * If any other type kind is passed in, an invalid type is returned.
+ */
+CINDEX_LINKAGE CXType clang_Type_getReplacementType(CXType CT);
+
+/**
  * Return the offset of the field represented by the Cursor.
  *
  * If the cursor is not a field declaration, -1 is returned.
  * If the cursor semantic parent is not a record field declaration,
  *   CXTypeLayoutError_Invalid is returned.
  * If the field's type declaration is an incomplete type,
  *   CXTypeLayoutError_Incomplete is returned.
  * If the field's type declaration is a dependent type,

clang/test/Index/print-type.cpp

 // CHECK: VarDecl=member_pointer:50:12 (Definition) [type=int Blob::*] [typekind=MemberPointer] [isPOD=1]
 // CHECK: FunctionDecl=elaboratedNamespaceType:52:42 [type=NS::Type (const NS::Type)] [typekind=FunctionProto] [canonicaltype=NS::Type (NS::Type)] [canonicaltypekind=FunctionProto] [resulttype=NS::Type] [resulttypekind=Elaborated] [args= [const NS::Type] [Elaborated]] [isPOD=0]
 // CHECK: NamespaceRef=NS:52:11 [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: TypeRef=struct NS::Type:52:23 [type=NS::Type] [typekind=Record] [isPOD=1]
 // CHECK: ParmDecl=t:52:81 (Definition) [type=const NS::Type] [typekind=Elaborated] const [canonicaltype=const NS::Type] [canonicaltypekind=Record] [isPOD=1]
 // CHECK: VarDecl=autoI:54:6 (Definition) [type=int] [typekind=Auto] [canonicaltype=int] [canonicaltypekind=Int] [isPOD=1]
 // CHECK: IntegerLiteral= [type=int] [typekind=Int] [isPOD=1]
 // CHECK: VarDecl=autoTbar:55:6 (Definition) [type=int] [typekind=Auto] [canonicaltype=int] [canonicaltypekind=Int] [isPOD=1]
-// CHECK: CallExpr=tbar:36:3 [type=int] [typekind=Unexposed] [canonicaltype=int] [canonicaltypekind=Int] [args= [int] [Int]] [isPOD=1]
+// CHECK: CallExpr=tbar:36:3 [type=int] [typekind=SubstTemplateTypeParm] [canonicaltype=int] [canonicaltypekind=Int] [args= [int] [Int]] [isPOD=1]
 // CHECK: UnexposedExpr=tbar:36:3 [type=int (*)(int)] [typekind=Pointer] [canonicaltype=int (*)(int)] [canonicaltypekind=Pointer] [isPOD=1] [pointeetype=int (int)] [pointeekind=FunctionProto]
 // CHECK: DeclRefExpr=tbar:36:3 RefName=[55:17 - 55:21] RefName=[55:21 - 55:26] [type=int (int)] [typekind=FunctionProto] [canonicaltype=int (int)] [canonicaltypekind=FunctionProto] [isPOD=0]
 // CHECK: IntegerLiteral= [type=int] [typekind=Int] [isPOD=1]
 // CHECK: VarDecl=autoBlob:56:6 (Definition) [type=Blob *] [typekind=Auto] [canonicaltype=Blob *] [canonicaltypekind=Pointer] [isPOD=1]
 // CHECK: CXXNewExpr= [type=Blob *] [typekind=Pointer] [canonicaltype=Blob *] [canonicaltypekind=Pointer] [isPOD=1] [pointeetype=Blob] [pointeekind=Elaborated]
 // CHECK: TypeRef=struct Blob:46:8 [type=Blob] [typekind=Record] [isPOD=1] [nbFields=2]
 // CHECK: CallExpr=Blob:46:8 [type=Blob] [typekind=Elaborated] [canonicaltype=Blob] [canonicaltypekind=Record] [isPOD=1] [nbFields=2]
 // CHECK: FunctionDecl=autoFunction:57:6 (Definition) [type=int ()] [typekind=FunctionProto] [canonicaltype=int ()] [canonicaltypekind=FunctionProto] [resulttype=int] [resulttypekind=Auto] [isPOD=0]

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
 //
 //===--------------------------------------------------------------------===//
 //
switch (TP->getTypeClass()) {
     TKCASE(ExtVector);
     TKCASE(MemberPointer);
     TKCASE(Auto);
     TKCASE(Elaborated);
     TKCASE(Pipe);
     TKCASE(Attributed);
     TKCASE(BTFTagAttributed);
     TKCASE(Atomic);
+    TKCASE(SubstTemplateTypeParm);
     default:
       return CXType_Unexposed;
   }
 #undef TKCASE
 }
 
-
 CXType cxtype::MakeCXType(QualType T, CXTranslationUnit TU) {
   CXTypeKind TK = CXType_Invalid;
 
   if (TU && !T.isNull()) {
     // Handle attributed types as the original type
     if (auto *ATT = T->getAs<AttributedType>()) {
       if (!(TU->ParsingOptions & CXTranslationUnit_IncludeAttributedTypes)) {
         // Return the equivalent type which represents the canonically
         // equivalent type.
         return MakeCXType(ATT->getEquivalentType(), TU);
       }

 #undef IMAGE_TYPE
 #define EXT_OPAQUE_TYPE(ExtTYpe, Id, Ext) TKIND(Id);
 #include "clang/Basic/OpenCLExtensionTypes.def"
     TKIND(OCLSampler);
     TKIND(OCLEvent);
     TKIND(OCLQueue);
     TKIND(OCLReserveID);
     TKIND(Atomic);
+    TKIND(SubstTemplateTypeParm);
   }
 #undef TKIND
   return cxstring::createRef(s);
 }
 
 unsigned clang_equalTypes(CXType A, CXType B) {
   return A.data[0] == B.data[0] && A.data[1] == B.data[1];
 }
CXType clang_Type_getValueType(CXType CT) {
   QualType T = GetQualType(CT);
 
   if (T.isNull() || !T->isAtomicType())
       return MakeCXType(QualType(), GetTU(CT));
 
   const auto *AT = T->castAs<AtomicType>();
   return MakeCXType(AT->getValueType(), GetTU(CT));
 }
+
+CXType clang_Type_getReplacementType(CXType CT) {
+  QualType T = GetQualType(CT);
+
+  const auto *ST =
+      !T.isNull() ? T->getAs<SubstTemplateTypeParmType>() : nullptr;
+  return MakeCXType(ST ? ST->getReplacementType() : QualType(), GetTU(CT));
+}

clang/tools/libclang/libclang.map

global:
     clang_Type_getObjCEncoding;
     clang_Type_getObjCObjectBaseType;
     clang_Type_getObjCProtocolDecl;
     clang_Type_getObjCTypeArg;
     clang_Type_getOffsetOf;
     clang_Type_getSizeOf;
     clang_Type_getTemplateArgumentAsType;
     clang_Type_getValueType;
     clang_Type_isTransparentTagTypedef;
     clang_Type_visitFields;
     clang_VerbatimBlockLineComment_getText;
     clang_VerbatimLineComment_getText;
     clang_VirtualFileOverlay_addFileMapping;
     clang_VirtualFileOverlay_create;
     clang_VirtualFileOverlay_dispose;
     clang_VirtualFileOverlay_setCaseSensitivity;
     clang_VirtualFileOverlay_writeToBuffer;

 
 LLVM_16 {
   global:
     clang_getUnqualifiedType;
     clang_getNonReferenceType;
     clang_CXXMethod_isDeleted;
     clang_CXXMethod_isCopyAssignmentOperator;
     clang_CXXMethod_isMoveAssignmentOperator;
+    clang_Type_getReplacementType;
 };
 
 # 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;
 # };