Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- ExtractAPI/API.h -----------------------------------------*- 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

//

//===----------------------------------------------------------------------===//

///

/// \file

/// This file defines the APIRecord-based structs and the APISet class.

///

/// Clang ExtractAPI is a tool to collect API information from a given set of

/// header files. The structures in this file describe data representations of

/// the API information collected for various kinds of symbols.

///

//===----------------------------------------------------------------------===//

#ifndef LLVM_CLANG_EXTRACTAPI_API_H

#define LLVM_CLANG_EXTRACTAPI_API_H

#include "clang/AST/Decl.h"

#include "clang/AST/DeclObjC.h"

#include "clang/AST/RawCommentList.h"

#include "clang/Basic/SourceLocation.h"

#include "clang/ExtractAPI/AvailabilityInfo.h"

#include "clang/ExtractAPI/DeclarationFragments.h"

#include "llvm/ADT/MapVector.h"

#include "llvm/ADT/StringRef.h"

#include "llvm/ADT/Triple.h"

#include "llvm/Support/Allocator.h"

#include "llvm/Support/Casting.h"

#include <memory>

#include <type_traits>

namespace clang {

namespace extractapi {

/// DocComment is a vector of RawComment::CommentLine.

///

/// Each line represents one line of striped documentation comment,

/// with source range information. This simplifies calculating the source

/// location of a character in the doc comment for pointing back to the source

/// file.

/// e.g.

/// \code

///   /// This is a documentation comment

///       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'  First line.

///   ///     with multiple lines.

///       ^~~~~~~~~~~~~~~~~~~~~~~'         Second line.

/// \endcode

using DocComment = std::vector<RawComment::CommentLine>;

// Classes deriving from APIRecord need to have USR be the first constructor

// 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_GlobalVariable,

    RK_EnumConstant,

    RK_Enum,

    RK_StructField,

    RK_Struct,

    RK_ObjCInstanceProperty,

    RK_ObjCClassProperty,

    RK_ObjCIvar,

    RK_ObjCClassMethod,

    RK_ObjCInstanceMethod,

    RK_ObjCInterface,

    RK_ObjCCategory,

    RK_ObjCProtocol,

    RK_MacroDefinition,

    RK_Typedef,

  };

  /// Stores information about the context of the declaration of this API.

  /// This is roughly analogous to the DeclContext hierarchy for an AST Node.

  struct HierarchyInformation {

    /// The USR of the parent API.

    StringRef ParentUSR;

    /// The name of the parent API.

    StringRef ParentName;

    /// The record kind of the parent API.

    RecordKind ParentKind = RK_Unknown;

    /// A pointer to the parent APIRecord if known.

    APIRecord *ParentRecord = nullptr;

    HierarchyInformation() = default;

    HierarchyInformation(StringRef ParentUSR, StringRef ParentName,

                         RecordKind Kind, APIRecord *ParentRecord = nullptr)

        : ParentUSR(ParentUSR), ParentName(ParentName), ParentKind(Kind),

          ParentRecord(ParentRecord) {}

    bool empty() const {

      return ParentUSR.empty() && ParentName.empty() &&

             ParentKind == RK_Unknown && ParentRecord == nullptr;

    }

  };

  StringRef USR;

  StringRef Name;

  PresumedLoc Location;

  AvailabilitySet Availabilities;

  LinkageInfo Linkage;

  /// Documentation comment lines attached to this symbol declaration.

  DocComment Comment;

  /// Declaration fragments of this symbol declaration.

  DeclarationFragments Declaration;

  /// SubHeading provides a more detailed representation than the plain

  /// declaration name.

  ///

  /// SubHeading is an array of declaration fragments of tagged declaration

  /// name, with potentially more tokens (for example the \c +/- symbol for

  /// Objective-C class/instance methods).

  DeclarationFragments SubHeading;

  /// Information about the parent record of this record.

  HierarchyInformation ParentInformation;

  /// Whether the symbol was defined in a system header.

  bool IsFromSystemHeader;

private:

  const RecordKind Kind;

public:

  RecordKind getKind() const { return Kind; }

  APIRecord() = delete;

  APIRecord(RecordKind Kind, StringRef USR, StringRef Name,

            PresumedLoc Location, AvailabilitySet Availabilities,

            LinkageInfo Linkage, const DocComment &Comment,

            DeclarationFragments Declaration, DeclarationFragments SubHeading,

            bool IsFromSystemHeader)

      : USR(USR), Name(Name), Location(Location),

        Availabilities(std::move(Availabilities)), Linkage(Linkage),

        Comment(Comment), Declaration(Declaration), SubHeading(SubHeading),

        IsFromSystemHeader(IsFromSystemHeader), Kind(Kind) {}

  // Pure virtual destructor to make APIRecord abstract

  virtual ~APIRecord() = 0;

};

/// This holds information associated with global functions.

struct GlobalFunctionRecord : APIRecord {

  FunctionSignature Signature;

  GlobalFunctionRecord(StringRef USR, StringRef Name, PresumedLoc Loc,

                       AvailabilitySet Availabilities, LinkageInfo Linkage,

                       const DocComment &Comment,

                       DeclarationFragments Declaration,

                       DeclarationFragments SubHeading,

                       FunctionSignature Signature, bool IsFromSystemHeader)

      : APIRecord(RK_GlobalFunction, 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();

};

/// 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),

                  Linkage, Comment, Declaration, SubHeading,

                  IsFromSystemHeader) {}

  static bool classof(const APIRecord *Record) {

    return Record->getKind() == RK_GlobalVariable;

  }

private:

  virtual void anchor();

};

/// This holds information associated with enum constants.

struct EnumConstantRecord : APIRecord {

  EnumConstantRecord(StringRef USR, StringRef Name, PresumedLoc Loc,

                     AvailabilitySet Availabilities, const DocComment &Comment,

                     DeclarationFragments Declaration,

                     DeclarationFragments SubHeading, bool IsFromSystemHeader)

      : APIRecord(RK_EnumConstant, USR, Name, Loc, std::move(Availabilities),

                  LinkageInfo::none(), Comment, Declaration, SubHeading,

                  IsFromSystemHeader) {}

  static bool classof(const APIRecord *Record) {

    return Record->getKind() == RK_EnumConstant;

  }

private:

  virtual void anchor();

};

/// This holds information associated with enums.

struct EnumRecord : APIRecord {

  SmallVector<std::unique_ptr<EnumConstantRecord>> Constants;

  EnumRecord(StringRef USR, StringRef Name, PresumedLoc Loc,

             AvailabilitySet Availabilities, const DocComment &Comment,

             DeclarationFragments Declaration, DeclarationFragments SubHeading,

             bool IsFromSystemHeader)

      : APIRecord(RK_Enum, USR, Name, Loc, std::move(Availabilities),

                  LinkageInfo::none(), Comment, Declaration, SubHeading,

                  IsFromSystemHeader) {}

  static bool classof(const APIRecord *Record) {

    return Record->getKind() == RK_Enum;

  }

private:

  virtual void anchor();

};

/// This holds information associated with struct fields.

struct StructFieldRecord : APIRecord {

  StructFieldRecord(StringRef USR, StringRef Name, PresumedLoc Loc,

                    AvailabilitySet Availabilities, const DocComment &Comment,

                    DeclarationFragments Declaration,

                    DeclarationFragments SubHeading, bool IsFromSystemHeader)

      : APIRecord(RK_StructField, USR, Name, Loc, std::move(Availabilities),

                  LinkageInfo::none(), Comment, Declaration, SubHeading,

                  IsFromSystemHeader) {}

  static bool classof(const APIRecord *Record) {

    return Record->getKind() == RK_StructField;

  }

private:

  virtual void anchor();

};

/// This holds information associated with structs.

struct StructRecord : APIRecord {

  SmallVector<std::unique_ptr<StructFieldRecord>> Fields;

  StructRecord(StringRef USR, StringRef Name, PresumedLoc Loc,

               AvailabilitySet Availabilities, const DocComment &Comment,

               DeclarationFragments Declaration,

               DeclarationFragments SubHeading, bool IsFromSystemHeader)

      : APIRecord(RK_Struct, USR, Name, Loc, std::move(Availabilities),

                  LinkageInfo::none(), Comment, Declaration, SubHeading,

                  IsFromSystemHeader) {}

  static bool classof(const APIRecord *Record) {

    return Record->getKind() == RK_Struct;

  }

private:

  virtual void anchor();

};

/// This holds information associated with Objective-C properties.

struct ObjCPropertyRecord : APIRecord {

  /// The attributes associated with an Objective-C property.

  enum AttributeKind : unsigned {

    NoAttr = 0,

    ReadOnly = 1,

    Dynamic = 1 << 2,

  };

  AttributeKind Attributes;

  StringRef GetterName;

  StringRef SetterName;

  bool IsOptional;

  ObjCPropertyRecord(RecordKind Kind, StringRef USR, StringRef Name,

                     PresumedLoc Loc, AvailabilitySet Availabilities,

                     const DocComment &Comment,

                     DeclarationFragments Declaration,

                     DeclarationFragments SubHeading, AttributeKind Attributes,

                     StringRef GetterName, StringRef SetterName,

                     bool IsOptional, bool IsFromSystemHeader)

      : APIRecord(Kind, USR, Name, Loc, std::move(Availabilities),

                  LinkageInfo::none(), Comment, Declaration, SubHeading,

                  IsFromSystemHeader),

        Attributes(Attributes), GetterName(GetterName), SetterName(SetterName),

        IsOptional(IsOptional) {}

  bool isReadOnly() const { return Attributes & ReadOnly; }

  bool isDynamic() const { return Attributes & Dynamic; }

  virtual ~ObjCPropertyRecord() = 0;

};

struct ObjCInstancePropertyRecord : ObjCPropertyRecord {

  ObjCInstancePropertyRecord(StringRef USR, StringRef Name, PresumedLoc Loc,

                             AvailabilitySet Availabilities,

                             const DocComment &Comment,

                             DeclarationFragments Declaration,

                             DeclarationFragments SubHeading,

                             AttributeKind Attributes, StringRef GetterName,

                             StringRef SetterName, bool IsOptional,

                             bool IsFromSystemHeader)

      : ObjCPropertyRecord(RK_ObjCInstanceProperty, USR, Name, Loc,

                           std::move(Availabilities), Comment, Declaration,

                           SubHeading, Attributes, GetterName, SetterName,

                           IsOptional, IsFromSystemHeader) {}

  static bool classof(const APIRecord *Record) {

    return Record->getKind() == RK_ObjCInstanceProperty;

  }

private:

  virtual void anchor();

};

struct ObjCClassPropertyRecord : ObjCPropertyRecord {

  ObjCClassPropertyRecord(StringRef USR, StringRef Name, PresumedLoc Loc,

                          AvailabilitySet Availabilities,

                          const DocComment &Comment,

                          DeclarationFragments Declaration,

                          DeclarationFragments SubHeading,

                          AttributeKind Attributes, StringRef GetterName,

                          StringRef SetterName, bool IsOptional,

                          bool IsFromSystemHeader)

      : ObjCPropertyRecord(RK_ObjCClassProperty, USR, Name, Loc,

                           std::move(Availabilities), Comment, Declaration,

                           SubHeading, Attributes, GetterName, SetterName,

                           IsOptional, IsFromSystemHeader) {}

  static bool classof(const APIRecord *Record) {

    return Record->getKind() == RK_ObjCClassProperty;

  }

private:

  virtual void anchor();

};

/// This holds information associated with Objective-C instance variables.

struct ObjCInstanceVariableRecord : APIRecord {

  using AccessControl = ObjCIvarDecl::AccessControl;

  AccessControl Access;

  ObjCInstanceVariableRecord(StringRef USR, StringRef Name, PresumedLoc Loc,

                             AvailabilitySet Availabilities,

                             const DocComment &Comment,

                             DeclarationFragments Declaration,

                             DeclarationFragments SubHeading,

                             AccessControl Access, bool IsFromSystemHeader)

      : APIRecord(RK_ObjCIvar, USR, Name, Loc, std::move(Availabilities),

                  LinkageInfo::none(), Comment, Declaration, SubHeading,

                  IsFromSystemHeader),

        Access(Access) {}

  static bool classof(const APIRecord *Record) {

    return Record->getKind() == RK_ObjCIvar;

  }

private:

  virtual void anchor();

};

/// This holds information associated with Objective-C methods.

struct ObjCMethodRecord : APIRecord {

  FunctionSignature Signature;

  ObjCMethodRecord() = delete;

  ObjCMethodRecord(RecordKind Kind, StringRef USR, StringRef Name,

                   PresumedLoc Loc, AvailabilitySet Availabilities,

                   const DocComment &Comment, DeclarationFragments Declaration,

                   DeclarationFragments SubHeading, FunctionSignature Signature,

                   bool IsFromSystemHeader)

      : APIRecord(Kind, USR, Name, Loc, std::move(Availabilities),

                  LinkageInfo::none(), Comment, Declaration, SubHeading,

                  IsFromSystemHeader),

        Signature(Signature) {}

  virtual ~ObjCMethodRecord() = 0;

};

struct ObjCInstanceMethodRecord : ObjCMethodRecord {

  ObjCInstanceMethodRecord(StringRef USR, StringRef Name, PresumedLoc Loc,

                           AvailabilitySet Availabilities,

                           const DocComment &Comment,

                           DeclarationFragments Declaration,

                           DeclarationFragments SubHeading,

                           FunctionSignature Signature, bool IsFromSystemHeader)

      : ObjCMethodRecord(RK_ObjCInstanceMethod, USR, Name, Loc,

                         std::move(Availabilities), Comment, Declaration,

                         SubHeading, Signature, IsFromSystemHeader) {}

  static bool classof(const APIRecord *Record) {

    return Record->getKind() == RK_ObjCInstanceMethod;

  }

private:

  virtual void anchor();

};

struct ObjCClassMethodRecord : ObjCMethodRecord {

  ObjCClassMethodRecord(StringRef USR, StringRef Name, PresumedLoc Loc,

                        AvailabilitySet Availabilities,

                        const DocComment &Comment,

                        DeclarationFragments Declaration,

                        DeclarationFragments SubHeading,

                        FunctionSignature Signature, bool IsFromSystemHeader)

      : ObjCMethodRecord(RK_ObjCClassMethod, USR, Name, Loc,

                         std::move(Availabilities), Comment, Declaration,

                         SubHeading, Signature, IsFromSystemHeader) {}

  static bool classof(const APIRecord *Record) {

    return Record->getKind() == RK_ObjCClassMethod;

  }

private:

  virtual void anchor();

};

/// This represents a reference to another symbol that might come from external

/// sources.

struct SymbolReference {

  StringRef Name;

  StringRef USR;

  /// The source project/module/product of the referred symbol.

  StringRef Source;

  SymbolReference() = default;

  SymbolReference(StringRef Name, StringRef USR = "", StringRef Source = "")

      : Name(Name), USR(USR), Source(Source) {}

  SymbolReference(const APIRecord &Record)

      : Name(Record.Name), USR(Record.USR) {}

  /// Determine if this SymbolReference is empty.

  ///

  /// \returns true if and only if all \c Name, \c USR, and \c Source is empty.

  bool empty() const { return Name.empty() && USR.empty() && Source.empty(); }

};

/// The base representation of an Objective-C container record. Holds common

/// information associated with Objective-C containers.

struct ObjCContainerRecord : APIRecord {

  SmallVector<std::unique_ptr<ObjCMethodRecord>> Methods;

  SmallVector<std::unique_ptr<ObjCPropertyRecord>> Properties;

  SmallVector<std::unique_ptr<ObjCInstanceVariableRecord>> Ivars;

  SmallVector<SymbolReference> Protocols;

  ObjCContainerRecord() = delete;

  ObjCContainerRecord(RecordKind Kind, StringRef USR, StringRef Name,

                      PresumedLoc Loc, AvailabilitySet Availabilities,

                      LinkageInfo Linkage, const DocComment &Comment,

                      DeclarationFragments Declaration,

                      DeclarationFragments SubHeading, bool IsFromSystemHeader)

      : APIRecord(Kind, USR, Name, Loc, std::move(Availabilities), Linkage,

                  Comment, Declaration, SubHeading, IsFromSystemHeader) {}

  virtual ~ObjCContainerRecord() = 0;

};

/// This holds information associated with Objective-C categories.

struct ObjCCategoryRecord : ObjCContainerRecord {

  SymbolReference Interface;

  ObjCCategoryRecord(StringRef USR, StringRef Name, PresumedLoc Loc,

                     AvailabilitySet Availabilities, const DocComment &Comment,

                     DeclarationFragments Declaration,

                     DeclarationFragments SubHeading, SymbolReference Interface,

                     bool IsFromSystemHeader)

      : ObjCContainerRecord(RK_ObjCCategory, USR, Name, Loc,

                            std::move(Availabilities), LinkageInfo::none(),

                            Comment, Declaration, SubHeading,

                            IsFromSystemHeader),

        Interface(Interface) {}

  static bool classof(const APIRecord *Record) {

    return Record->getKind() == RK_ObjCCategory;

  }

private:

  virtual void anchor();

};

/// This holds information associated with Objective-C interfaces/classes.

struct ObjCInterfaceRecord : ObjCContainerRecord {

  SymbolReference SuperClass;

  // ObjCCategoryRecord%s are stored in and owned by APISet.

  SmallVector<ObjCCategoryRecord *> Categories;

  ObjCInterfaceRecord(StringRef USR, StringRef Name, PresumedLoc Loc,

                      AvailabilitySet Availabilities, LinkageInfo Linkage,

                      const DocComment &Comment,

                      DeclarationFragments Declaration,

                      DeclarationFragments SubHeading,

                      SymbolReference SuperClass, bool IsFromSystemHeader)

      : ObjCContainerRecord(RK_ObjCInterface, USR, Name, Loc,

                            std::move(Availabilities), Linkage, Comment,

                            Declaration, SubHeading, IsFromSystemHeader),

        SuperClass(SuperClass) {}

  static bool classof(const APIRecord *Record) {

    return Record->getKind() == RK_ObjCInterface;

  }

private:

  virtual void anchor();

};

/// This holds information associated with Objective-C protocols.

struct ObjCProtocolRecord : ObjCContainerRecord {

  ObjCProtocolRecord(StringRef USR, StringRef Name, PresumedLoc Loc,

                     AvailabilitySet Availabilities, const DocComment &Comment,

                     DeclarationFragments Declaration,

                     DeclarationFragments SubHeading, bool IsFromSystemHeader)

      : ObjCContainerRecord(RK_ObjCProtocol, USR, Name, Loc,

                            std::move(Availabilities), LinkageInfo::none(),

                            Comment, Declaration, SubHeading,

                            IsFromSystemHeader) {}

  static bool classof(const APIRecord *Record) {

    return Record->getKind() == RK_ObjCProtocol;

  }

private:

  virtual void anchor();

};

/// This holds information associated with macro definitions.

struct MacroDefinitionRecord : APIRecord {

  MacroDefinitionRecord(StringRef USR, StringRef Name, PresumedLoc Loc,

                        DeclarationFragments Declaration,

                        DeclarationFragments SubHeading,

                        bool IsFromSystemHeader)

      : APIRecord(RK_MacroDefinition, USR, Name, Loc, AvailabilitySet(),

                  LinkageInfo(), {}, Declaration, SubHeading,

                  IsFromSystemHeader) {}

  static bool classof(const APIRecord *Record) {

    return Record->getKind() == RK_MacroDefinition;

  }

private:

  virtual void anchor();

};

/// This holds information associated with typedefs.

///

/// Note: Typedefs for anonymous enums and structs typically don't get emitted

/// by the serializers but still get a TypedefRecord. Instead we use the

/// typedef name as a name for the underlying anonymous struct or enum.

struct TypedefRecord : APIRecord {

  SymbolReference UnderlyingType;

  TypedefRecord(StringRef USR, StringRef Name, PresumedLoc Loc,

                AvailabilitySet Availabilities, const DocComment &Comment,

                DeclarationFragments Declaration,

                DeclarationFragments SubHeading, SymbolReference UnderlyingType,

                bool IsFromSystemHeader)

      : APIRecord(RK_Typedef, USR, Name, Loc, std::move(Availabilities),

                  LinkageInfo(), Comment, Declaration, SubHeading,

                  IsFromSystemHeader),

        UnderlyingType(UnderlyingType) {}

  static bool classof(const APIRecord *Record) {

    return Record->getKind() == RK_Typedef;

  }

private:

  virtual void anchor();

};

/// Check if a record type has a function signature mixin.

///

/// This is denoted by the record type having a ``Signature`` field of type

/// FunctionSignature.

template <typename RecordTy>

struct has_function_signature : public std::false_type {};

template <>

struct has_function_signature<GlobalFunctionRecord> : public std::true_type {};

template <>

struct has_function_signature<ObjCMethodRecord> : public std::true_type {};

template <>

struct has_function_signature<ObjCInstanceMethodRecord>

    : public std::true_type {};

template <>

struct has_function_signature<ObjCClassMethodRecord> : 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

  /// to generate the USR for \c D and keep it alive in APISet.

  GlobalVariableRecord *

  addGlobalVar(StringRef Name, StringRef USR, PresumedLoc Loc,

               AvailabilitySet Availability, LinkageInfo Linkage,

               const DocComment &Comment, DeclarationFragments Declaration,

               DeclarationFragments SubHeadin, bool IsFromSystemHeaderg);

  /// Create and add a function 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.

  GlobalFunctionRecord *

  addGlobalFunction(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,

                  PresumedLoc Loc, AvailabilitySet Availability,

                  const DocComment &Comment, DeclarationFragments Declaration,

                  DeclarationFragments SubHeading, bool IsFromSystemHeader);

  /// Create and add an enum 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.

  EnumRecord *addEnum(StringRef Name, StringRef USR, PresumedLoc Loc,

                      AvailabilitySet Availability, const DocComment &Comment,

                      DeclarationFragments Declaration,

                      DeclarationFragments SubHeading, bool IsFromSystemHeader);

  /// Create and add a struct field 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.

  StructFieldRecord *

  addStructField(StructRecord *Struct, StringRef Name, StringRef USR,

                 PresumedLoc Loc, AvailabilitySet Availability,

                 const DocComment &Comment, DeclarationFragments Declaration,

                 DeclarationFragments SubHeading, bool IsFromSystemHeader);

  /// Create and add a struct 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.

  StructRecord *addStruct(StringRef Name, StringRef USR, PresumedLoc Loc,

                          AvailabilitySet Availability,

                          const DocComment &Comment,

                          DeclarationFragments Declaration,

                          DeclarationFragments SubHeading,

                          bool IsFromSystemHeader);

  /// Create and add an Objective-C category 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.

  ObjCCategoryRecord *

  addObjCCategory(StringRef Name, StringRef USR, PresumedLoc Loc,

                  AvailabilitySet Availability, const DocComment &Comment,

                  DeclarationFragments Declaration,

                  DeclarationFragments SubHeading, SymbolReference Interface,

                  bool IsFromSystemHeader);

  /// Create and add an Objective-C interface 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.

  ObjCInterfaceRecord *

  addObjCInterface(StringRef Name, StringRef USR, PresumedLoc Loc,

                   AvailabilitySet Availability, LinkageInfo Linkage,

                   const DocComment &Comment, DeclarationFragments Declaration,

                   DeclarationFragments SubHeading, SymbolReference SuperClass,

                   bool IsFromSystemHeader);

  /// Create and add an Objective-C method 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.

  ObjCMethodRecord *

  addObjCMethod(ObjCContainerRecord *Container, StringRef Name, StringRef USR,

                PresumedLoc Loc, AvailabilitySet Availability,

                const DocComment &Comment, DeclarationFragments Declaration,

                DeclarationFragments SubHeading, FunctionSignature Signature,

                bool IsInstanceMethod, bool IsFromSystemHeader);

  /// Create and add an Objective-C property 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.

  ObjCPropertyRecord *

  addObjCProperty(ObjCContainerRecord *Container, StringRef Name, StringRef USR,

                  PresumedLoc Loc, AvailabilitySet Availability,

                  const DocComment &Comment, DeclarationFragments Declaration,

                  DeclarationFragments SubHeading,

                  ObjCPropertyRecord::AttributeKind Attributes,

                  StringRef GetterName, StringRef SetterName, bool IsOptional,

                  bool IsInstanceProperty, bool IsFromSystemHeader);

  /// Create and add an Objective-C instance 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

  /// to generate the USR for \c D and keep it alive in APISet.

  ObjCInstanceVariableRecord *addObjCInstanceVariable(

      ObjCContainerRecord *Container, StringRef Name, StringRef USR,

      PresumedLoc Loc, AvailabilitySet Availability, const DocComment &Comment,

      DeclarationFragments Declaration, DeclarationFragments SubHeading,

      ObjCInstanceVariableRecord::AccessControl Access,

      bool IsFromSystemHeader);

  /// Create and add an Objective-C protocol 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.

  ObjCProtocolRecord *

  addObjCProtocol(StringRef Name, StringRef USR, PresumedLoc Loc,

                  AvailabilitySet Availability, const DocComment &Comment,

                  DeclarationFragments Declaration,

                  DeclarationFragments SubHeading, bool IsFromSystemHeader);

  /// Create a macro definition 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::recordUSRForMacro(StringRef Name,

  /// SourceLocation SL, const SourceManager &SM) is a helper method to generate

  /// the USR for the macro and keep it alive in APISet.

  MacroDefinitionRecord *addMacroDefinition(StringRef Name, StringRef USR,

                                            PresumedLoc Loc,

                                            DeclarationFragments Declaration,

                                            DeclarationFragments SubHeading,

                                            bool IsFromSystemHeader);

  /// Create a typedef 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.

  TypedefRecord *

  addTypedef(StringRef Name, StringRef USR, PresumedLoc Loc,

             AvailabilitySet Availability, const DocComment &Comment,

             DeclarationFragments Declaration, DeclarationFragments SubHeading,

             SymbolReference UnderlyingType, bool IsFromSystemHeader);

  /// A mapping type to store a set of APIRecord%s with the USR as the key.

  template <typename RecordTy,

            typename =

                std::enable_if_t<std::is_base_of<APIRecord, RecordTy>::value>>

  using RecordMap = llvm::MapVector<StringRef, std::unique_ptr<RecordTy>>;

  /// Get the target triple for the ExtractAPI invocation.

  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<GlobalVariableRecord> &getGlobalVariables() const {

    return GlobalVariables;

  }

  const RecordMap<EnumRecord> &getEnums() const { return Enums; }

  const RecordMap<StructRecord> &getStructs() const { return Structs; }

  const RecordMap<ObjCCategoryRecord> &getObjCCategories() const {

    return ObjCCategories;

  }

  const RecordMap<ObjCInterfaceRecord> &getObjCInterfaces() const {

    return ObjCInterfaces;

  }

  const RecordMap<ObjCProtocolRecord> &getObjCProtocols() const {

    return ObjCProtocols;

  }

  const RecordMap<MacroDefinitionRecord> &getMacros() const { return Macros; }

  const RecordMap<TypedefRecord> &getTypedefs() const { return Typedefs; }

  /// Finds the APIRecord for a given USR.

  ///

  /// \returns a pointer to the APIRecord associated with that USR or nullptr.

  APIRecord *findRecordForUSR(StringRef USR) const;

  /// Generate and store the USR of declaration \p D.

  ///

  /// Note: The USR string is stored in and owned by Allocator.

  ///

  /// \returns a StringRef of the generated USR string.

  StringRef recordUSR(const Decl *D);

  /// Generate and store the USR for a macro \p Name.

  ///

  /// Note: The USR string is stored in and owned by Allocator.

  ///

  /// \returns a StringRef to the generate USR string.

  StringRef recordUSRForMacro(StringRef Name, SourceLocation SL,

                              const SourceManager &SM);

  /// Copy \p String into the Allocator in this APISet.

  ///

  /// \returns a StringRef of the copied string in APISet::Allocator.

  StringRef copyString(StringRef String);

  APISet(const llvm::Triple &Target, Language Lang,

         const std::string &ProductName)

      : Target(Target), Lang(Lang), ProductName(ProductName) {}

private:

  /// BumpPtrAllocator to store generated/copied strings.

  ///

  /// 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<GlobalVariableRecord> GlobalVariables;

  RecordMap<EnumRecord> Enums;

  RecordMap<StructRecord> Structs;

  RecordMap<ObjCCategoryRecord> ObjCCategories;

  RecordMap<ObjCInterfaceRecord> ObjCInterfaces;

  RecordMap<ObjCProtocolRecord> ObjCProtocols;

  RecordMap<MacroDefinitionRecord> Macros;

  RecordMap<TypedefRecord> Typedefs;

public:

  const std::string ProductName;

};

} // namespace extractapi

} // namespace clang

#endif // LLVM_CLANG_EXTRACTAPI_API_H