[clang][ExtractAPI] Add support for C++ global function templates

[evelez7]

Summary

Add records, serialization for global function templates and their specializations

Depends on D157350

[evelez7]

Update instances of Spec to Specialization

[dang]

LGTM

clang/include/clang/ExtractAPI/API.h

1077

Mega nit, can we keep the GlobalFunction stuff grouped together?

[evelez7]

Formatting changes, keep GlobalFunction has templates together and revert extraneous formatting

clang/include/clang/ExtractAPI/API.h

 // argument. This is so that they are compatible with `addTopLevelRecord`
 // defined in API.cpp
 /// The base representation of an API record. Holds common symbol information.
 struct APIRecord {
   /// Discriminator for LLVM-style RTTI (dyn_cast<> et al.)
   enum RecordKind {
     RK_Unknown,
     RK_GlobalFunction,
+    RK_GlobalFunctionTemplate,
+    RK_GlobalFunctionTemplateSpecialization,
     RK_GlobalVariable,
     RK_GlobalVariableTemplate,
     RK_GlobalVariableTemplateSpecialization,
     RK_GlobalVariableTemplatePartialSpecialization,
     RK_EnumConstant,
     RK_Enum,
     RK_StructField,
     RK_Struct,
GlobalFunctionRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
                        DeclarationFragments Declaration,
                        DeclarationFragments SubHeading,
                        FunctionSignature Signature, bool IsFromSystemHeader)
       : APIRecord(RK_GlobalFunction, USR, Name, Loc, std::move(Availabilities),
                   Linkage, Comment, Declaration, SubHeading,
                   IsFromSystemHeader),
         Signature(Signature) {}
 
+  GlobalFunctionRecord(RecordKind Kind, StringRef USR, StringRef Name,
+                       PresumedLoc Loc, AvailabilitySet Availabilities,
+                       LinkageInfo Linkage, const DocComment &Comment,
+                       DeclarationFragments Declaration,
+                       DeclarationFragments SubHeading,
+                       FunctionSignature Signature, bool IsFromSystemHeader)
+      : APIRecord(Kind, USR, Name, Loc, std::move(Availabilities), Linkage,
+                  Comment, Declaration, SubHeading, IsFromSystemHeader),
+        Signature(Signature) {}
+
   static bool classof(const APIRecord *Record) {
     return Record->getKind() == RK_GlobalFunction;
   }
 
 private:
   virtual void anchor();
 };
 
+struct GlobalFunctionTemplateRecord : GlobalFunctionRecord {
+  Template Templ;
+
+  GlobalFunctionTemplateRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
+                               AvailabilitySet Availabilities,
+                               LinkageInfo Linkage, const DocComment &Comment,
+                               DeclarationFragments Declaration,
+                               DeclarationFragments SubHeading,
+                               FunctionSignature Signature, Template Template,
+                               bool IsFromSystemHeader)
+      : GlobalFunctionRecord(RK_GlobalFunctionTemplate, USR, Name, Loc,
+                             std::move(Availabilities), Linkage, Comment,
+                             Declaration, SubHeading, Signature,
+                             IsFromSystemHeader),
+        Templ(Template) {}
+
+  static bool classof(const APIRecord *Record) {
+    return Record->getKind() == RK_GlobalFunctionTemplate;
+  }
+};
+
+struct GlobalFunctionTemplateSpecializationRecord : GlobalFunctionRecord {
+  GlobalFunctionTemplateSpecializationRecord(
+      StringRef USR, StringRef Name, PresumedLoc Loc,
+      AvailabilitySet Availabilities, LinkageInfo Linkage,
+      const DocComment &Comment, DeclarationFragments Declaration,
+      DeclarationFragments SubHeading, FunctionSignature Signature,
+      bool IsFromSystemHeader)
+      : GlobalFunctionRecord(RK_GlobalFunctionTemplateSpecialization, USR, Name,
+                             Loc, std::move(Availabilities), Linkage, Comment,
+                             Declaration, SubHeading, Signature,
+                             IsFromSystemHeader) {}
+
+  static bool classof(const APIRecord *Record) {
+    return Record->getKind() == RK_GlobalFunctionTemplateSpecialization;
+  }
+};
+
 /// This holds information associated with global functions.
 struct GlobalVariableRecord : APIRecord {
   GlobalVariableRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
                        AvailabilitySet Availabilities, LinkageInfo Linkage,
                        const DocComment &Comment,
                        DeclarationFragments Declaration,
                        DeclarationFragments SubHeading, bool IsFromSystemHeader)
       : APIRecord(RK_GlobalVariable, USR, Name, Loc, std::move(Availabilities),

 struct has_template<ClassTemplatePartialSpecializationRecord>
     : public std::true_type {};
 template <> struct has_template<ConceptRecord> : public std::true_type {};
 template <>
 struct has_template<GlobalVariableTemplateRecord> : public std::true_type {};
 template <>
 struct has_template<GlobalVariableTemplatePartialSpecializationRecord>
     : public std::true_type {};
 
+template <>
+struct has_template<GlobalFunctionTemplateRecord> : public std::true_type {};
+template <>
+struct has_function_signature<GlobalFunctionTemplateRecord>
+    : public std::true_type {};
+template <>
+struct has_function_signature<GlobalFunctionTemplateSpecializationRecord>
+    : public std::true_type {};
+
 /// APISet holds the set of API records collected from given inputs.
 class APISet {
 public:
   /// Create and add a global variable record into the API set.
   ///
   /// Note: the caller is responsible for keeping the StringRef \p Name and
   /// \p USR alive. APISet::copyString provides a way to copy strings into
   /// APISet itself, and APISet::recordUSR(const Decl *D) is a helper method
public:
   /// to generate the USR for \c D and keep it alive in APISet.
   GlobalFunctionRecord *
   addGlobalFunction(StringRef Name, StringRef USR, PresumedLoc Loc,
                     AvailabilitySet Availability, LinkageInfo Linkage,
                     const DocComment &Comment, DeclarationFragments Declaration,
                     DeclarationFragments SubHeading,
                     FunctionSignature Signature, bool IsFromSystemHeader);
 
+  GlobalFunctionTemplateRecord *addGlobalFunctionTemplate(
+      StringRef Name, StringRef USR, PresumedLoc Loc,
+      AvailabilitySet Availability, LinkageInfo Linkage,
+      const DocComment &Comment, DeclarationFragments Declaration,
+      DeclarationFragments SubHeading, FunctionSignature Signature,
+      Template Template, bool IsFromSystemHeader);
+
+  GlobalFunctionTemplateSpecializationRecord *
+  addGlobalFunctionTemplateSpecialization(
+      StringRef Name, StringRef USR, PresumedLoc Loc,
+      AvailabilitySet Availability, LinkageInfo Linkage,
+      const DocComment &Comment, DeclarationFragments Declaration,
+      DeclarationFragments SubHeading, FunctionSignature Signature,
+      bool IsFromSystemHeader);
+
   /// Create and add an enum constant record into the API set.
   ///
   /// Note: the caller is responsible for keeping the StringRef \p Name and
   /// \p USR alive. APISet::copyString provides a way to copy strings into
   /// APISet itself, and APISet::recordUSR(const Decl *D) is a helper method
   /// to generate the USR for \c D and keep it alive in APISet.
   EnumConstantRecord *
   addEnumConstant(EnumRecord *Enum, StringRef Name, StringRef USR,
public:
   const llvm::Triple &getTarget() const { return Target; }
 
   /// Get the language used by the APIs.
   Language getLanguage() const { return Lang; }
 
   const RecordMap<GlobalFunctionRecord> &getGlobalFunctions() const {
     return GlobalFunctions;
   }
+  const RecordMap<GlobalFunctionTemplateRecord> &
+  getGlobalFunctionTemplates() const {
+    return GlobalFunctionTemplates;
+  }
+  const RecordMap<GlobalFunctionTemplateSpecializationRecord> &
+  getGlobalFunctionTemplateSpecializations() const {
+    return GlobalFunctionTemplateSpecializations;
+  }
   const RecordMap<GlobalVariableRecord> &getGlobalVariables() const {
     return GlobalVariables;
   }
   const RecordMap<GlobalVariableTemplateRecord> &
   getGlobalVariableTemplates() const {
     return GlobalVariableTemplates;
   }
   const RecordMap<StaticFieldRecord> &getStaticFields() const {
private:
   /// Note: The main use for this is being able to deduplicate strings.
   llvm::BumpPtrAllocator StringAllocator;
 
   const llvm::Triple Target;
   const Language Lang;
 
   llvm::DenseMap<StringRef, APIRecord *> USRBasedLookupTable;
   RecordMap<GlobalFunctionRecord> GlobalFunctions;
+  RecordMap<GlobalFunctionTemplateRecord> GlobalFunctionTemplates;
+  RecordMap<GlobalFunctionTemplateSpecializationRecord>
+      GlobalFunctionTemplateSpecializations;
   RecordMap<GlobalVariableRecord> GlobalVariables;
   RecordMap<GlobalVariableTemplateRecord> GlobalVariableTemplates;
   RecordMap<GlobalVariableTemplateSpecializationRecord>
       GlobalVariableTemplateSpecializations;
   RecordMap<GlobalVariableTemplatePartialSpecializationRecord>
       GlobalVariableTemplatePartialSpecializations;
   RecordMap<ConceptRecord> Concepts;
   RecordMap<StaticFieldRecord> StaticFields;

clang/include/clang/ExtractAPI/DeclarationFragments.h

public:
   getFragmentsForConversionFunction(const CXXConversionDecl *);
 
   static DeclarationFragments
   getFragmentsForOverloadedOperator(const CXXMethodDecl *);
 
   static DeclarationFragments
       getFragmentsForTemplateParameters(ArrayRef<NamedDecl *>);
 
-  static std::string getNameForTemplateArgument(const ArrayRef<NamedDecl *>,
-                                                std::string);
+  static std::string
+  getNameForTemplateArgument(const ArrayRef<NamedDecl *>, std::string);
 
   static DeclarationFragments
   getFragmentsForTemplateArguments(const ArrayRef<TemplateArgument>,
                                    ASTContext &,
                                    const std::optional<ArrayRef<NamedDecl *>>);
 
   static DeclarationFragments getFragmentsForConcept(const ConceptDecl *);
 
   static DeclarationFragments
   getFragmentsForRedeclarableTemplate(const RedeclarableTemplateDecl *);
 
   static DeclarationFragments getFragmentsForClassTemplateSpecialization(
       const ClassTemplateSpecializationDecl *);
 
   static DeclarationFragments getFragmentsForClassTemplatePartialSpecialization(
       const ClassTemplatePartialSpecializationDecl *);
 
   static DeclarationFragments getFragmentsForVarTemplateSpecialization(
       const VarTemplateSpecializationDecl *);
 
   static DeclarationFragments getFragmentsForVarTemplatePartialSpecialization(
       const VarTemplatePartialSpecializationDecl *);
 
+  static DeclarationFragments
+  getFragmentsForFunctionTemplate(const FunctionTemplateDecl *Decl);
+
+  static DeclarationFragments
+  getFragmentsForFunctionTemplateSpecialization(const FunctionDecl *Decl);
+
   /// Build DeclarationFragments for an Objective-C category declaration
   /// ObjCCategoryDecl.
   static DeclarationFragments
   getFragmentsForObjCCategory(const ObjCCategoryDecl *);
 
   /// Build DeclarationFragments for an Objective-C interface declaration
   /// ObjCInterfaceDecl.
   static DeclarationFragments

 };
 
 template <typename FunctionT>
 FunctionSignature
 DeclarationFragmentsBuilder::getFunctionSignature(const FunctionT *Function) {
   FunctionSignature Signature;
 
   DeclarationFragments ReturnType, After;
-  ReturnType
-      .append(getFragmentsForType(Function->getReturnType(),
-                                  Function->getASTContext(), After))
-      .append(std::move(After));
+  ReturnType = getFragmentsForType(Function->getReturnType(),
+                                   Function->getASTContext(), After);
+  if (isa<FunctionDecl>(Function) &&
+      dyn_cast<FunctionDecl>(Function)->getDescribedFunctionTemplate() &&
+      ReturnType.begin()->Spelling.substr(0, 14).compare("type-parameter") ==
+          0) {
+    std::string ProperArgName =
+        getNameForTemplateArgument(dyn_cast<FunctionDecl>(Function)
+                                       ->getDescribedFunctionTemplate()
+                                       ->getTemplateParameters()
+                                       ->asArray(),
+                                   ReturnType.begin()->Spelling);
+    ReturnType.begin()->Spelling.swap(ProperArgName);
+  }
+  ReturnType.append(std::move(After));
   Signature.setReturnType(ReturnType);
 
   for (const auto *Param : Function->parameters())
     Signature.addParameter(Param->getName(), getFragmentsForParam(Param));
 
   return Signature;
 }
 
 } // namespace extractapi
 } // namespace clang
 
 #endif // LLVM_CLANG_EXTRACTAPI_DECLARATION_FRAGMENTS_H

clang/include/clang/ExtractAPI/ExtractAPIVisitor.h

public:
   bool WalkUpFromVarTemplateDecl(const VarTemplateDecl *Decl);
 
   bool WalkUpFromVarTemplateSpecializationDecl(
       const VarTemplateSpecializationDecl *Decl);
 
   bool WalkUpFromVarTemplatePartialSpecializationDecl(
       const VarTemplatePartialSpecializationDecl *Decl);
 
+  bool WalkUpFromFunctionTemplateDecl(const FunctionTemplateDecl *Decl);
+
   bool VisitRecordDecl(const RecordDecl *Decl);
 
   bool VisitCXXRecordDecl(const CXXRecordDecl *Decl);
 
   bool VisitConceptDecl(const ConceptDecl *Decl);
 
   bool VisitClassTemplateSpecializationDecl(
       const ClassTemplateSpecializationDecl *Decl);
 
   bool VisitClassTemplatePartialSpecializationDecl(
       const ClassTemplatePartialSpecializationDecl *Decl);
 
   bool VisitVarTemplateDecl(const VarTemplateDecl *Decl);
 
   bool
   VisitVarTemplateSpecializationDecl(const VarTemplateSpecializationDecl *Decl);
 
   bool VisitVarTemplatePartialSpecializationDecl(
       const VarTemplatePartialSpecializationDecl *Decl);
 
+  bool VisitFunctionTemplateDecl(const FunctionTemplateDecl *Decl);
+
   bool VisitObjCInterfaceDecl(const ObjCInterfaceDecl *Decl);
 
   bool VisitObjCProtocolDecl(const ObjCProtocolDecl *Decl);
 
   bool VisitTypedefNameDecl(const TypedefNameDecl *Decl);
 
   bool VisitObjCCategoryDecl(const ObjCCategoryDecl *Decl);
 
if (const auto *Method = dyn_cast<CXXMethodDecl>(Decl)) {
     if (isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method))
       return true;
   }
 
   // Skip templated functions.
   switch (Decl->getTemplatedKind()) {
   case FunctionDecl::TK_NonTemplate:
   case FunctionDecl::TK_DependentNonTemplate:
-    break;
   case FunctionDecl::TK_MemberSpecialization:
   case FunctionDecl::TK_FunctionTemplateSpecialization:
-    if (auto *TemplateInfo = Decl->getTemplateSpecializationInfo()) {
-      if (!TemplateInfo->isExplicitInstantiationOrSpecialization())
-        return true;
-    }
     break;
   case FunctionDecl::TK_FunctionTemplate:
   case FunctionDecl::TK_DependentFunctionTemplateSpecialization:
     return true;
   }
 
   if (!getDerivedExtractAPIVisitor().shouldDeclBeIncluded(Decl))
     return true;
 
   // Collect symbol information.
   StringRef Name = Decl->getName();
   StringRef USR = API.recordUSR(Decl);
   PresumedLoc Loc =
       Context.getSourceManager().getPresumedLoc(Decl->getLocation());
   LinkageInfo Linkage = Decl->getLinkageAndVisibility();
   DocComment Comment;
   if (auto *RawComment =
           getDerivedExtractAPIVisitor().fetchRawCommentForDecl(Decl))
     Comment = RawComment->getFormattedLines(Context.getSourceManager(),
                                             Context.getDiagnostics());
 
   // Build declaration fragments, sub-heading, and signature of the function.
-  DeclarationFragments Declaration =
-      DeclarationFragmentsBuilder::getFragmentsForFunction(Decl);
   DeclarationFragments SubHeading =
       DeclarationFragmentsBuilder::getSubHeading(Decl);
   FunctionSignature Signature =
       DeclarationFragmentsBuilder::getFunctionSignature(Decl);
 
+  if (Decl->getTemplateSpecializationInfo())
+    API.addGlobalFunctionTemplateSpecialization(
+        Name, USR, Loc, AvailabilitySet(Decl), Linkage, Comment,
+        DeclarationFragmentsBuilder::
+            getFragmentsForFunctionTemplateSpecialization(Decl),
+        SubHeading, Signature, isInSystemHeader(Decl));
+  else
     // Add the function record to the API set.
-  API.addGlobalFunction(Name, USR, Loc, AvailabilitySet(Decl), Linkage, Comment,
-                        Declaration, SubHeading, Signature,
-                        isInSystemHeader(Decl));
+    API.addGlobalFunction(
+        Name, USR, Loc, AvailabilitySet(Decl), Linkage, Comment,
+        DeclarationFragmentsBuilder::getFragmentsForFunction(Decl), SubHeading,
+        Signature, isInSystemHeader(Decl));
   return true;
 }
 
 template <typename Derived>
 bool ExtractAPIVisitorBase<Derived>::VisitEnumDecl(const EnumDecl *Decl) {
   if (!getDerivedExtractAPIVisitor().shouldDeclBeIncluded(Decl))
     return true;
 

 bool ExtractAPIVisitorBase<Derived>::
     WalkUpFromVarTemplatePartialSpecializationDecl(
         const VarTemplatePartialSpecializationDecl *Decl) {
   getDerivedExtractAPIVisitor().VisitVarTemplatePartialSpecializationDecl(Decl);
   return true;
 }
 
 template <typename Derived>
+bool ExtractAPIVisitorBase<Derived>::WalkUpFromFunctionTemplateDecl(
+    const FunctionTemplateDecl *Decl) {
+  getDerivedExtractAPIVisitor().VisitFunctionTemplateDecl(Decl);
+  return true;
+}
+
+template <typename Derived>
 bool ExtractAPIVisitorBase<Derived>::VisitRecordDecl(const RecordDecl *Decl) {
   if (!getDerivedExtractAPIVisitor().shouldDeclBeIncluded(Decl))
     return true;
   // Collect symbol information.
   StringRef Name = Decl->getName();
   if (Name.empty())
     Name = getTypedefName(Decl);
   if (Name.empty())
bool ExtractAPIVisitorBase<Derived>::VisitVarTemplatePartialSpecializationDecl(
 
   API.addGlobalVariableTemplatePartialSpecialization(
       Name, USR, Loc, AvailabilitySet(Decl), Linkage, Comment, Declaration,
       SubHeading, Template(Decl), isInSystemHeader(Decl));
   return true;
 }
 
 template <typename Derived>
+bool ExtractAPIVisitorBase<Derived>::VisitFunctionTemplateDecl(
+    const FunctionTemplateDecl *Decl) {
+  if (!getDerivedExtractAPIVisitor().shouldDeclBeIncluded(Decl))
+    return true;
+
+  // Collect symbol information.
+  StringRef Name = Decl->getName();
+  StringRef USR = API.recordUSR(Decl);
+  PresumedLoc Loc =
+      Context.getSourceManager().getPresumedLoc(Decl->getLocation());
+  LinkageInfo Linkage = Decl->getLinkageAndVisibility();
+  DocComment Comment;
+  if (auto *RawComment =
+          getDerivedExtractAPIVisitor().fetchRawCommentForDecl(Decl))
+    Comment = RawComment->getFormattedLines(Context.getSourceManager(),
+                                            Context.getDiagnostics());
+
+  DeclarationFragments SubHeading =
+      DeclarationFragmentsBuilder::getSubHeading(Decl);
+  FunctionSignature Signature =
+      DeclarationFragmentsBuilder::getFunctionSignature(
+          Decl->getTemplatedDecl());
+
+  API.addGlobalFunctionTemplate(
+      Name, USR, Loc, AvailabilitySet(Decl), Linkage, Comment,
+      DeclarationFragmentsBuilder::getFragmentsForFunctionTemplate(Decl),
+      SubHeading, Signature, Template(Decl), isInSystemHeader(Decl));
+
+  return true;
+}
+
+template <typename Derived>
 bool ExtractAPIVisitorBase<Derived>::VisitObjCInterfaceDecl(
     const ObjCInterfaceDecl *Decl) {
   if (!getDerivedExtractAPIVisitor().shouldDeclBeIncluded(Decl))
     return true;
 
   // Collect symbol information.
   StringRef Name = Decl->getName();
   StringRef USR = API.recordUSR(Decl);

clang/include/clang/ExtractAPI/Serialization/SerializerBase.h

void traverseAPISet() {
     getDerived()->traverseConcepts();
 
     getDerived()->traverseGlobalVariableTemplateRecords();
 
     getDerived()->traverseGlobalVariableTemplateSpecializationRecords();
 
     getDerived()->traverseGlobalVariableTemplatePartialSpecializationRecords();
 
+    getDerived()->traverseGlobalFunctionTemplateRecords();
+
+    getDerived()->traverseGlobalFunctionTemplateSpecializationRecords();
+
     getDerived()->traverseStructRecords();
 
     getDerived()->traverseObjCInterfaces();
 
     getDerived()->traverseObjCProtocols();
 
     getDerived()->traverseObjCCategories();
 
public:
 
   void traverseGlobalVariableTemplatePartialSpecializationRecords() {
     for (const auto &GlobalVariableTemplatePartialSpecialization :
          API.getGlobalVariableTemplatePartialSpecializations())
       getDerived()->visitGlobalVariableTemplatePartialSpecializationRecord(
           *GlobalVariableTemplatePartialSpecialization.second);
   }
 
+  void traverseGlobalFunctionTemplateRecords() {
+    for (const auto &GlobalFunctionTemplate : API.getGlobalFunctionTemplates())
+      getDerived()->visitGlobalFunctionTemplateRecord(
+          *GlobalFunctionTemplate.second);
+  }
+
+  void traverseGlobalFunctionTemplateSpecializationRecords() {
+    for (const auto &GlobalFunctionTemplateSpecialization :
+         API.getGlobalFunctionTemplateSpecializations())
+      getDerived()->visitGlobalFunctionTemplateSpecializationRecord(
+          *GlobalFunctionTemplateSpecialization.second);
+  }
+
   void traverseConcepts() {
     for (const auto &Concept : API.getConcepts())
       getDerived()->visitConceptRecord(*Concept.second);
   }
 
   void traverseObjCInterfaces() {
     for (const auto &Interface : API.getObjCInterfaces())
       getDerived()->visitObjCContainerRecord(*Interface.second);
void visitGlobalVariableTemplateRecord(
       const GlobalVariableTemplateRecord &Record) {}
 
   void visitGlobalVariableTemplateSpecializationRecord(
       const GlobalVariableTemplateSpecializationRecord &Record){};
 
   void visitGlobalVariableTemplatePartialSpecializationRecord(
       const GlobalVariableTemplatePartialSpecializationRecord &Record){};
 
+  void visitGlobalFunctionTemplateRecord(
+      const GlobalFunctionTemplateRecord &Record){};
+
+  void visitGlobalFunctionTemplateSpecializationRecord(
+      const GlobalFunctionTemplateSpecializationRecord &Record){};
+
   /// Visit an Objective-C container record.
   void visitObjCContainerRecord(const ObjCContainerRecord &Record){};
 
   /// Visit an Objective-C category record.
   void visitObjCCategoryRecord(const ObjCCategoryRecord &Record){};
 
   /// Visit a macro definition record.
   void visitMacroDefinitionRecord(const MacroDefinitionRecord &Record){};

clang/include/clang/ExtractAPI/Serialization/SymbolGraphSerializer.h

public:
   visitGlobalVariableTemplateRecord(const GlobalVariableTemplateRecord &Record);
 
   void visitGlobalVariableTemplateSpecializationRecord(
       const GlobalVariableTemplateSpecializationRecord &Record);
 
   void visitGlobalVariableTemplatePartialSpecializationRecord(
       const GlobalVariableTemplatePartialSpecializationRecord &Record);
 
+  void
+  visitGlobalFunctionTemplateRecord(const GlobalFunctionTemplateRecord &Record);
+
+  void visitGlobalFunctionTemplateSpecializationRecord(
+      const GlobalFunctionTemplateSpecializationRecord &Record);
+
   /// Visit an Objective-C container record.
   void visitObjCContainerRecord(const ObjCContainerRecord &Record);
 
   /// Visit an Objective-C category record.
   void visitObjCCategoryRecord(const ObjCCategoryRecord &Record);
 
   /// Visit a macro definition record.
   void visitMacroDefinitionRecord(const MacroDefinitionRecord &Record);

clang/lib/ExtractAPI/API.cpp

GlobalFunctionRecord *APISet::addGlobalFunction(
     DeclarationFragments SubHeading, FunctionSignature Signature,
     bool IsFromSystemHeader) {
   return addTopLevelRecord(USRBasedLookupTable, GlobalFunctions, USR, Name, Loc,
                            std::move(Availabilities), Linkage, Comment,
                            Fragments, SubHeading, Signature,
                            IsFromSystemHeader);
 }
 
+GlobalFunctionTemplateRecord *APISet::addGlobalFunctionTemplate(
+    StringRef Name, StringRef USR, PresumedLoc Loc,
+    AvailabilitySet Availability, LinkageInfo Linkage,
+    const DocComment &Comment, DeclarationFragments Declaration,
+    DeclarationFragments SubHeading, FunctionSignature Signature,
+    Template Template, bool IsFromSystemHeader) {
+  return addTopLevelRecord(USRBasedLookupTable, GlobalFunctionTemplates, USR,
+                           Name, Loc, std::move(Availability), Linkage, Comment,
+                           Declaration, SubHeading, Signature, Template,
+                           IsFromSystemHeader);
+}
+
+GlobalFunctionTemplateSpecializationRecord *
+APISet::addGlobalFunctionTemplateSpecialization(
+    StringRef Name, StringRef USR, PresumedLoc Loc,
+    AvailabilitySet Availability, LinkageInfo Linkage,
+    const DocComment &Comment, DeclarationFragments Declaration,
+    DeclarationFragments SubHeading, FunctionSignature Signature,
+    bool IsFromSystemHeader) {
+  return addTopLevelRecord(
+      USRBasedLookupTable, GlobalFunctionTemplateSpecializations, USR, Name,
+      Loc, std::move(Availability), Linkage, Comment, Declaration, SubHeading,
+      Signature, IsFromSystemHeader);
+}
+
 EnumConstantRecord *APISet::addEnumConstant(EnumRecord *Enum, StringRef Name,
                                             StringRef USR, PresumedLoc Loc,
                                             AvailabilitySet Availabilities,
                                             const DocComment &Comment,
                                             DeclarationFragments Declaration,
                                             DeclarationFragments SubHeading,
                                             bool IsFromSystemHeader) {
   auto Record = std::make_unique<EnumConstantRecord>(

clang/lib/ExtractAPI/DeclarationFragments.cpp

DeclarationFragmentsBuilder::getFragmentsForParam(const ParmVarDecl *Param) {
 
   QualType T = Param->getTypeSourceInfo()
                    ? Param->getTypeSourceInfo()->getType()
                    : Param->getASTContext().getUnqualifiedObjCPointerType(
                          Param->getType());
 
   DeclarationFragments TypeFragments =
       getFragmentsForType(T, Param->getASTContext(), After);
+  if (TypeFragments.begin()->Spelling.substr(0, 14).compare("type-parameter") ==
+      0) {
+    std::string ProperArgName = getNameForTemplateArgument(
+        dyn_cast<FunctionDecl>(Param->getDeclContext())
+            ->getDescribedFunctionTemplate()
+            ->getTemplateParameters()
+            ->asArray(),
+        TypeFragments.begin()->Spelling);
+    TypeFragments.begin()->Spelling.swap(ProperArgName);
+  }
 
   if (Param->isObjCMethodParameter())
     Fragments.append("(", DeclarationFragments::FragmentKind::Text)
         .append(std::move(TypeFragments))
         .append(") ", DeclarationFragments::FragmentKind::Text);
   else
     Fragments.append(std::move(TypeFragments)).appendSpace();
 
if (Func->isConsteval()) // if consteval, it is also constexpr
     Fragments.append("consteval", DeclarationFragments::FragmentKind::Keyword)
         .appendSpace();
   else if (Func->isConstexpr())
     Fragments.append("constexpr", DeclarationFragments::FragmentKind::Keyword)
         .appendSpace();
 
   // FIXME: Is `after` actually needed here?
   DeclarationFragments After;
-  Fragments
-      .append(getFragmentsForType(Func->getReturnType(), Func->getASTContext(),
-                                  After))
+  auto ReturnValueFragment =
+      getFragmentsForType(Func->getReturnType(), Func->getASTContext(), After);
+  if (ReturnValueFragment.begin()->Spelling.substr(0, 14).compare(
+          "type-parameter") == 0) {
+    std::string ProperArgName =
+        getNameForTemplateArgument(Func->getDescribedFunctionTemplate()
+                                       ->getTemplateParameters()
+                                       ->asArray(),
+                                   ReturnValueFragment.begin()->Spelling);
+    ReturnValueFragment.begin()->Spelling.swap(ProperArgName);
+  }
+
+  Fragments.append(std::move(ReturnValueFragment))
       .appendSpace()
-      .append(Func->getName(), DeclarationFragments::FragmentKind::Identifier)
-      .append(std::move(After));
+      .append(Func->getName(), DeclarationFragments::FragmentKind::Identifier);
+
+  if (Func->getTemplateSpecializationInfo()) {
+    Fragments.append("<", DeclarationFragments::FragmentKind::Text);
+
+    for (unsigned i = 0, end = Func->getNumParams(); i != end; ++i) {
+      if (i)
+        Fragments.append(", ", DeclarationFragments::FragmentKind::Text);
+      Fragments.append(
+          getFragmentsForType(Func->getParamDecl(i)->getType(),
+                              Func->getParamDecl(i)->getASTContext(), After));
+    }
+    Fragments.append(">", DeclarationFragments::FragmentKind::Text);
+  }
+  Fragments.append(std::move(After));
 
   Fragments.append("(", DeclarationFragments::FragmentKind::Text);
   for (unsigned i = 0, end = Func->getNumParams(); i != end; ++i) {
     if (i)
       Fragments.append(", ", DeclarationFragments::FragmentKind::Text);
     Fragments.append(getFragmentsForParam(Func->getParamDecl(i)));
   }
   Fragments.append(")", DeclarationFragments::FragmentKind::Text);
return Fragments
       .append(getFragmentsForTemplateArguments(
           Decl->getTemplateArgs().asArray(), Decl->getASTContext(),
           Decl->getTemplateParameters()->asArray()))
       .append(">", DeclarationFragments::FragmentKind::Text)
       .append(";", DeclarationFragments::FragmentKind::Text);
 }
 
 DeclarationFragments
+DeclarationFragmentsBuilder::getFragmentsForFunctionTemplate(
+    const FunctionTemplateDecl *Decl) {
+  DeclarationFragments Fragments;
+  return Fragments
+      .append("template", DeclarationFragments::FragmentKind::Keyword)
+      .append("<", DeclarationFragments::FragmentKind::Text)
+      // Partial specs may have new params.
+      .append(getFragmentsForTemplateParameters(
+          Decl->getTemplateParameters()->asArray()))
+      .append(">", DeclarationFragments::FragmentKind::Text)
+      .appendSpace()
+      .append(DeclarationFragmentsBuilder::getFragmentsForFunction(
+          Decl->getAsFunction()));
+}
+
+DeclarationFragments
+DeclarationFragmentsBuilder::getFragmentsForFunctionTemplateSpecialization(
+    const FunctionDecl *Decl) {
+  DeclarationFragments Fragments;
+  return Fragments
+      .append("template", DeclarationFragments::FragmentKind::Keyword)
+      .append("<>", DeclarationFragments::FragmentKind::Text)
+      .appendSpace()
+      .append(DeclarationFragmentsBuilder::getFragmentsForFunction(Decl));
+}
+
+DeclarationFragments
 DeclarationFragmentsBuilder::getFragmentsForMacro(StringRef Name,
                                                   const MacroDirective *MD) {
   DeclarationFragments Fragments;
   Fragments.append("#define", DeclarationFragments::FragmentKind::Keyword)
       .appendSpace();
   Fragments.append(Name, DeclarationFragments::FragmentKind::Identifier);
 
   auto *MI = MD->getMacroInfo();

clang/lib/ExtractAPI/Serialization/SymbolGraphSerializer.cpp

Object serializeSymbolKind(APIRecord::RecordKind RK, Language Lang) {
   switch (RK) {
   case APIRecord::RK_Unknown:
     llvm_unreachable("Records should have an explicit kind");
     break;
   case APIRecord::RK_GlobalFunction:
     Kind["identifier"] = AddLangPrefix("func");
     Kind["displayName"] = "Function";
     break;
+  case APIRecord::RK_GlobalFunctionTemplate:
+    Kind["identifier"] = AddLangPrefix("func");
+    Kind["displayName"] = "Function Template";
+    break;
+  case APIRecord::RK_GlobalFunctionTemplateSpecialization:
+    Kind["identifier"] = AddLangPrefix("func");
+    Kind["displayName"] = "Function Template Specialization";
+    break;
   case APIRecord::RK_GlobalVariableTemplate:
     Kind["identifier"] = AddLangPrefix("var");
     Kind["displayName"] = "Global Variable Template";
     break;
   case APIRecord::RK_GlobalVariableTemplateSpecialization:
     Kind["identifier"] = AddLangPrefix("var");
     Kind["displayName"] = "Global Variable Template Specialization";
     break;
void SymbolGraphSerializer::
     visitGlobalVariableTemplatePartialSpecializationRecord(
         const GlobalVariableTemplatePartialSpecializationRecord &Record) {
   auto GlobalVariableTemplatePartialSpecialization = serializeAPIRecord(Record);
   if (!GlobalVariableTemplatePartialSpecialization)
     return;
   Symbols.emplace_back(std::move(*GlobalVariableTemplatePartialSpecialization));
 }
 
+void SymbolGraphSerializer::visitGlobalFunctionTemplateRecord(
+    const GlobalFunctionTemplateRecord &Record) {
+  auto GlobalFunctionTemplate = serializeAPIRecord(Record);
+  if (!GlobalFunctionTemplate)
+    return;
+  Symbols.emplace_back(std::move(*GlobalFunctionTemplate));
+}
+
+void SymbolGraphSerializer::visitGlobalFunctionTemplateSpecializationRecord(
+    const GlobalFunctionTemplateSpecializationRecord &Record) {
+  auto GlobalFunctionTemplateSpecialization = serializeAPIRecord(Record);
+  if (!GlobalFunctionTemplateSpecialization)
+    return;
+  Symbols.emplace_back(std::move(*GlobalFunctionTemplateSpecialization));
+}
+
 void SymbolGraphSerializer::visitObjCContainerRecord(
     const ObjCContainerRecord &Record) {
   auto ObjCContainer = serializeAPIRecord(Record);
   if (!ObjCContainer)
     return;
 
   Symbols.emplace_back(std::move(*ObjCContainer));
 

clang/test/ExtractAPI/global_func_template.cpp

+// RUN: rm -rf %t
+// RUN: split-file %s %t
+// RUN: sed -e "s@INPUT_DIR@%{/t:regex_replacement}@g" \
+// RUN: %t/reference.output.json.in >> %t/reference.output.json
+// RUN: %clang_cc1 -extract-api -triple arm64-apple-macosx \
+// RUN:   -x c++-header %t/input.h -o %t/output.json -verify
+
+// Generator version is not consistent across test runs, normalize it.
+// RUN: sed -e "s@\"generator\": \".*\"@\"generator\": \"?\"@g" \
+// RUN: %t/output.json >> %t/output-normalized.json
+// RUN: diff %t/reference.output.json %t/output-normalized.json
+
+//--- input.h
+template<typename T> void Foo(T Bar);
+
+template<typename T> T Fizz(int Buzz);
+/// expected-no-diagnostics
+
+//--- reference.output.json.in
+{
+  "metadata": {
+    "formatVersion": {
+      "major": 0,
+      "minor": 5,
+      "patch": 3
+    },
+    "generator": "?"
+  },
+  "module": {
+    "name": "",
+    "platform": {
+      "architecture": "arm64",
+      "operatingSystem": {
+        "minimumVersion": {
+          "major": 11,
+          "minor": 0,
+          "patch": 0
+        },
+        "name": "macosx"
+      },
+      "vendor": "apple"
+    }
+  },
+  "relationships": [],
+  "symbols": [
+    {
+      "accessLevel": "public",
+      "declarationFragments": [
+        {
+          "kind": "keyword",
+          "spelling": "template"
+        },
+        {
+          "kind": "text",
+          "spelling": "<"
+        },
+        {
+          "kind": "keyword",
+          "spelling": "typename"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "genericParameter",
+          "spelling": "T"
+        },
+        {
+          "kind": "text",
+          "spelling": "> "
+        },
+        {
+          "kind": "typeIdentifier",
+          "preciseIdentifier": "c:v",
+          "spelling": "void"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "identifier",
+          "spelling": "Foo"
+        },
+        {
+          "kind": "text",
+          "spelling": "("
+        },
+        {
+          "kind": "typeIdentifier",
+          "preciseIdentifier": "c:t0.0",
+          "spelling": "T"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "internalParam",
+          "spelling": "Bar"
+        },
+        {
+          "kind": "text",
+          "spelling": ");"
+        }
+      ],
+      "functionSignature": {
+        "parameters": [
+          {
+            "declarationFragments": [
+              {
+                "kind": "typeIdentifier",
+                "preciseIdentifier": "c:t0.0",
+                "spelling": "T"
+              },
+              {
+                "kind": "text",
+                "spelling": " "
+              },
+              {
+                "kind": "internalParam",
+                "spelling": "Bar"
+              }
+            ],
+            "name": "Bar"
+          }
+        ],
+        "returns": [
+          {
+            "kind": "typeIdentifier",
+            "preciseIdentifier": "c:v",
+            "spelling": "void"
+          }
+        ]
+      },
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@FT@>1#TFoo#t0.0#v#"
+      },
+      "kind": {
+        "displayName": "Function Template",
+        "identifier": "c++.func"
+      },
+      "location": {
+        "position": {
+          "character": 27,
+          "line": 1
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "Foo"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "Foo"
+          }
+        ],
+        "title": "Foo"
+      },
+      "pathComponents": [
+        "Foo"
+      ],
+      "swiftGenerics": {
+        "parameters": [
+          {
+            "depth": 0,
+            "index": 0,
+            "name": "T"
+          }
+        ]
+      }
+    },
+    {
+      "accessLevel": "public",
+      "declarationFragments": [
+        {
+          "kind": "keyword",
+          "spelling": "template"
+        },
+        {
+          "kind": "text",
+          "spelling": "<"
+        },
+        {
+          "kind": "keyword",
+          "spelling": "typename"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "genericParameter",
+          "spelling": "T"
+        },
+        {
+          "kind": "text",
+          "spelling": "> "
+        },
+        {
+          "kind": "typeIdentifier",
+          "preciseIdentifier": "c:t0.0",
+          "spelling": "T"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "identifier",
+          "spelling": "Fizz"
+        },
+        {
+          "kind": "text",
+          "spelling": "("
+        },
+        {
+          "kind": "typeIdentifier",
+          "preciseIdentifier": "c:I",
+          "spelling": "int"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "internalParam",
+          "spelling": "Buzz"
+        },
+        {
+          "kind": "text",
+          "spelling": ");"
+        }
+      ],
+      "functionSignature": {
+        "parameters": [
+          {
+            "declarationFragments": [
+              {
+                "kind": "typeIdentifier",
+                "preciseIdentifier": "c:I",
+                "spelling": "int"
+              },
+              {
+                "kind": "text",
+                "spelling": " "
+              },
+              {
+                "kind": "internalParam",
+                "spelling": "Buzz"
+              }
+            ],
+            "name": "Buzz"
+          }
+        ],
+        "returns": [
+          {
+            "kind": "typeIdentifier",
+            "preciseIdentifier": "c:t0.0",
+            "spelling": "T"
+          }
+        ]
+      },
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@FT@>1#TFizz#I#t0.0#"
+      },
+      "kind": {
+        "displayName": "Function Template",
+        "identifier": "c++.func"
+      },
+      "location": {
+        "position": {
+          "character": 24,
+          "line": 3
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "Fizz"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "Fizz"
+          }
+        ],
+        "title": "Fizz"
+      },
+      "pathComponents": [
+        "Fizz"
+      ],
+      "swiftGenerics": {
+        "parameters": [
+          {
+            "depth": 0,
+            "index": 0,
+            "name": "T"
+          }
+        ]
+      }
+    }
+  ]
+}

clang/test/ExtractAPI/global_func_template_spec.cpp

+// RUN: rm -rf %t
+// RUN: split-file %s %t
+// RUN: sed -e "s@INPUT_DIR@%{/t:regex_replacement}@g" \
+// RUN: %t/reference.output.json.in >> %t/reference.output.json
+// RUN: %clang_cc1 -extract-api -triple arm64-apple-macosx \
+// RUN:   -x c++-header %t/input.h -o %t/output.json -verify
+
+// Generator version is not consistent across test runs, normalize it.
+// RUN: sed -e "s@\"generator\": \".*\"@\"generator\": \"?\"@g" \
+// RUN: %t/output.json >> %t/output-normalized.json
+// RUN: diff %t/reference.output.json %t/output-normalized.json
+
+//--- input.h
+template<typename T> void Foo(T Bar);
+
+template<> void Foo<int>(int Bar);
+/// expected-no-diagnostics
+
+//--- reference.output.json.in
+{
+  "metadata": {
+    "formatVersion": {
+      "major": 0,
+      "minor": 5,
+      "patch": 3
+    },
+    "generator": "?"
+  },
+  "module": {
+    "name": "",
+    "platform": {
+      "architecture": "arm64",
+      "operatingSystem": {
+        "minimumVersion": {
+          "major": 11,
+          "minor": 0,
+          "patch": 0
+        },
+        "name": "macosx"
+      },
+      "vendor": "apple"
+    }
+  },
+  "relationships": [],
+  "symbols": [
+    {
+      "accessLevel": "public",
+      "declarationFragments": [
+        {
+          "kind": "keyword",
+          "spelling": "template"
+        },
+        {
+          "kind": "text",
+          "spelling": "<"
+        },
+        {
+          "kind": "keyword",
+          "spelling": "typename"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "genericParameter",
+          "spelling": "T"
+        },
+        {
+          "kind": "text",
+          "spelling": "> "
+        },
+        {
+          "kind": "typeIdentifier",
+          "preciseIdentifier": "c:v",
+          "spelling": "void"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "identifier",
+          "spelling": "Foo"
+        },
+        {
+          "kind": "text",
+          "spelling": "("
+        },
+        {
+          "kind": "typeIdentifier",
+          "preciseIdentifier": "c:t0.0",
+          "spelling": "T"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "internalParam",
+          "spelling": "Bar"
+        },
+        {
+          "kind": "text",
+          "spelling": ");"
+        }
+      ],
+      "functionSignature": {
+        "parameters": [
+          {
+            "declarationFragments": [
+              {
+                "kind": "typeIdentifier",
+                "preciseIdentifier": "c:t0.0",
+                "spelling": "T"
+              },
+              {
+                "kind": "text",
+                "spelling": " "
+              },
+              {
+                "kind": "internalParam",
+                "spelling": "Bar"
+              }
+            ],
+            "name": "Bar"
+          }
+        ],
+        "returns": [
+          {
+            "kind": "typeIdentifier",
+            "preciseIdentifier": "c:v",
+            "spelling": "void"
+          }
+        ]
+      },
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@FT@>1#TFoo#t0.0#v#"
+      },
+      "kind": {
+        "displayName": "Function Template",
+        "identifier": "c++.func"
+      },
+      "location": {
+        "position": {
+          "character": 27,
+          "line": 1
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "Foo"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "Foo"
+          }
+        ],
+        "title": "Foo"
+      },
+      "pathComponents": [
+        "Foo"
+      ],
+      "swiftGenerics": {
+        "parameters": [
+          {
+            "depth": 0,
+            "index": 0,
+            "name": "T"
+          }
+        ]
+      }
+    },
+    {
+      "accessLevel": "public",
+      "declarationFragments": [
+        {
+          "kind": "keyword",
+          "spelling": "template"
+        },
+        {
+          "kind": "text",
+          "spelling": "<> "
+        },
+        {
+          "kind": "typeIdentifier",
+          "preciseIdentifier": "c:v",
+          "spelling": "void"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "identifier",
+          "spelling": "Foo"
+        },
+        {
+          "kind": "text",
+          "spelling": "<"
+        },
+        {
+          "kind": "typeIdentifier",
+          "preciseIdentifier": "c:I",
+          "spelling": "int"
+        },
+        {
+          "kind": "text",
+          "spelling": ">("
+        },
+        {
+          "kind": "typeIdentifier",
+          "preciseIdentifier": "c:I",
+          "spelling": "int"
+        },
+        {
+          "kind": "text",
+          "spelling": " "
+        },
+        {
+          "kind": "internalParam",
+          "spelling": "Bar"
+        },
+        {
+          "kind": "text",
+          "spelling": ");"
+        }
+      ],
+      "functionSignature": {
+        "parameters": [
+          {
+            "declarationFragments": [
+              {
+                "kind": "typeIdentifier",
+                "preciseIdentifier": "c:I",
+                "spelling": "int"
+              },
+              {
+                "kind": "text",
+                "spelling": " "
+              },
+              {
+                "kind": "internalParam",
+                "spelling": "Bar"
+              }
+            ],
+            "name": "Bar"
+          }
+        ],
+        "returns": [
+          {
+            "kind": "typeIdentifier",
+            "preciseIdentifier": "c:v",
+            "spelling": "void"
+          }
+        ]
+      },
+      "identifier": {
+        "interfaceLanguage": "c++",
+        "precise": "c:@F@Foo<#I>#I#"
+      },
+      "kind": {
+        "displayName": "Function Template Specialization",
+        "identifier": "c++.func"
+      },
+      "location": {
+        "position": {
+          "character": 17,
+          "line": 3
+        },
+        "uri": "file://INPUT_DIR/input.h"
+      },
+      "names": {
+        "navigator": [
+          {
+            "kind": "identifier",
+            "spelling": "Foo"
+          }
+        ],
+        "subHeading": [
+          {
+            "kind": "identifier",
+            "spelling": "Foo"
+          }
+        ],
+        "title": "Foo"
+      },
+      "pathComponents": [
+        "Foo"
+      ]
+    }
+  ]
+}