//===- CXExtractAPI.cpp - libclang APIs for manipulating CXAPISet ---------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

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

//

// This file defines all libclang APIs related to manipulation CXAPISet

//

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

#include "CXCursor.h"

#include "CXString.h"

#include "CXTranslationUnit.h"

#include "clang-c/CXErrorCode.h"

#include "clang-c/Documentation.h"

#include "clang-c/Index.h"

#include "clang-c/Platform.h"

#include "clang/AST/Decl.h"

#include "clang/AST/DeclObjC.h"

#include "clang/Basic/TargetInfo.h"

#include "clang/ExtractAPI/API.h"

#include "clang/ExtractAPI/ExtractAPIVisitor.h"

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

#include "clang/Frontend/ASTUnit.h"

#include "clang/Frontend/FrontendOptions.h"

#include "clang/Index/USRGeneration.h"

#include "llvm/ADT/SmallString.h"

#include "llvm/Support/CBindingWrapping.h"

#include "llvm/Support/Casting.h"

#include "llvm/Support/JSON.h"

#include "llvm/Support/raw_ostream.h"

using namespace clang;

using namespace clang::extractapi;

namespace {

struct LibClangExtractAPIVisitor

    : ExtractAPIVisitor<LibClangExtractAPIVisitor> {

  using Base = ExtractAPIVisitor<LibClangExtractAPIVisitor>;

  LibClangExtractAPIVisitor(ASTContext &Context, APISet &API)

      : ExtractAPIVisitor<LibClangExtractAPIVisitor>(Context, API) {}

  const RawComment *fetchRawCommentForDecl(const Decl *D) const {

    return Context.getRawCommentForAnyRedecl(D);

  }

  // We need to visit implementations as well to ensure that when a user clicks

  // on a method defined only within the implementation that we can still

  // provide a symbol graph for it.

  bool VisitObjCImplementationDecl(const ObjCImplementationDecl *Decl) {

    if (!shouldDeclBeIncluded(Decl))

      return true;

    const ObjCInterfaceDecl *Interface = Decl->getClassInterface();

    StringRef Name = Interface->getName();

    StringRef USR = API.recordUSR(Decl);

    PresumedLoc Loc =

        Context.getSourceManager().getPresumedLoc(Decl->getLocation());

    LinkageInfo Linkage = Decl->getLinkageAndVisibility();

    DocComment Comment;

    if (auto *RawComment = fetchRawCommentForDecl(Interface))

      Comment = RawComment->getFormattedLines(Context.getSourceManager(),

                                              Context.getDiagnostics());

    // Build declaration fragments and sub-heading by generating them for the

    // interface.

    DeclarationFragments Declaration =

        DeclarationFragmentsBuilder::getFragmentsForObjCInterface(Interface);

    DeclarationFragments SubHeading =

        DeclarationFragmentsBuilder::getSubHeading(Decl);

    // Collect super class information.

    SymbolReference SuperClass;

    if (const auto *SuperClassDecl = Decl->getSuperClass()) {

      SuperClass.Name = SuperClassDecl->getObjCRuntimeNameAsString();

      SuperClass.USR = API.recordUSR(SuperClassDecl);

    }

    ObjCInterfaceRecord *ObjCInterfaceRecord = API.addObjCInterface(

        Name, USR, Loc, AvailabilitySet(Decl), Linkage, Comment, Declaration,

        SubHeading, SuperClass, isInSystemHeader(Decl));

    // Record all methods (selectors). This doesn't include automatically

    // synthesized property methods.

    recordObjCMethods(ObjCInterfaceRecord, Decl->methods());

    recordObjCProperties(ObjCInterfaceRecord, Decl->properties());

    recordObjCInstanceVariables(ObjCInterfaceRecord, Decl->ivars());

    return true;

  }

};

} // namespace

DEFINE_SIMPLE_CONVERSION_FUNCTIONS(APISet, CXAPISet)

static void WalkupFromMostDerivedType(LibClangExtractAPIVisitor &Visitor,

                                      Decl *D);

template <typename DeclTy>

static bool WalkupParentContext(DeclContext *Parent,

                                LibClangExtractAPIVisitor &Visitor) {

  if (auto *D = dyn_cast<DeclTy>(Parent)) {

    WalkupFromMostDerivedType(Visitor, D);

    return true;

  }

  return false;

}

CXExtractAPI.cpp:bool WalkupParentContext<clang::ObjCContainerDecl>(clang::DeclContext*, (anonymous namespace)::LibClangExtractAPIVisitor&)

Line

Count

Source

104

19

                                LibClangExtractAPIVisitor &Visitor) {

105

19

  if (auto *D = dyn_cast<DeclTy>(Parent)) {

106

5

    WalkupFromMostDerivedType(Visitor, D);

107

5

    return true;

108

5

  }

109

14

  return false;

110

19

}

CXExtractAPI.cpp:bool WalkupParentContext<clang::TagDecl>(clang::DeclContext*, (anonymous namespace)::LibClangExtractAPIVisitor&)

Line

Count

Source

104

14

                                LibClangExtractAPIVisitor &Visitor) {

105

14

  if (auto *D = dyn_cast<DeclTy>(Parent)) {

106

1

    WalkupFromMostDerivedType(Visitor, D);

107

1

    return true;

108

1

  }

109

13

  return false;

110

14

}

static void WalkupFromMostDerivedType(LibClangExtractAPIVisitor &Visitor,

                                      Decl *D) {

  switch (D->getKind()) {

#define ABSTRACT_DECL(DECL)

#define DECL(CLASS, BASE)                                                      \

  case Decl::CLASS:                                                            \

    Visitor.WalkUpFrom##CLASS##Decl(static_cast<CLASS##Decl *>(D));            \

    break;

#include 
"clang/AST/DeclNodes.inc"0

  }

  
for (auto *Parent = D->getDeclContext(); 19
Parent != nullptr;

       
Parent = Parent->getParent()13
) {

    if (WalkupParentContext<ObjCContainerDecl>(Parent, Visitor))

      return;

    if (WalkupParentContext<TagDecl>(Parent, Visitor))

      return;

  }

}

static CXString GenerateCXStringFromSymbolGraphData(llvm::json::Object Obj) {

  llvm::SmallString<0> BackingString;

  llvm::raw_svector_ostream OS(BackingString);

  OS << Value(std::move(Obj));

  return cxstring::createDup(BackingString.str());

}

enum CXErrorCode clang_createAPISet(CXTranslationUnit tu, CXAPISet *out_api) {

  if (cxtu::isNotUsableTU(tu) || !out_api)

    return CXError_InvalidArguments;

  ASTUnit *Unit = cxtu::getASTUnit(tu);

  auto &Ctx = Unit->getASTContext();

  auto Lang = Unit->getInputKind().getLanguage();

  APISet *API = new APISet(Ctx.getTargetInfo().getTriple(), Lang,

                           Unit->getMainFileName().str());

  LibClangExtractAPIVisitor Visitor(Ctx, *API);

  for (auto It = Unit->top_level_begin(); It != Unit->top_level_end(); 
++It36
) {

    Visitor.TraverseDecl(*It);

  }

  *out_api = wrap(API);

  return CXError_Success;

}

void clang_disposeAPISet(CXAPISet api) { delete unwrap(api); }

CXString clang_getSymbolGraphForUSR(const char *usr, CXAPISet api) {

  auto *API = unwrap(api);

  if (auto SGF = SymbolGraphSerializer::serializeSingleSymbolSGF(usr, *API))

    return GenerateCXStringFromSymbolGraphData(std::move(*SGF));

  return cxstring::createNull();

}

CXString clang_getSymbolGraphForCursor(CXCursor cursor) {

  cursor = clang_getCursorReferenced(cursor);

  CXCursorKind Kind = clang_getCursorKind(cursor);

  if (!clang_isDeclaration(Kind))

    return cxstring::createNull();

  const Decl *D = cxcursor::getCursorDecl(cursor);

  if (!D)

    return cxstring::createNull();

  CXTranslationUnit TU = cxcursor::getCursorTU(cursor);

  if (!TU)

    return cxstring::createNull();

  ASTUnit *Unit = cxtu::getASTUnit(TU);

  auto &Ctx = Unit->getASTContext();

  auto Lang = Unit->getInputKind().getLanguage();

  APISet API(Ctx.getTargetInfo().getTriple(), Lang,

             Unit->getMainFileName().str());

  LibClangExtractAPIVisitor Visitor(Ctx, API);

  const Decl *CanonicalDecl = D->getCanonicalDecl();

  CanonicalDecl = CanonicalDecl ? CanonicalDecl : 
D0
;

  SmallString<128> USR;

  if (index::generateUSRForDecl(CanonicalDecl, USR))

    return cxstring::createNull();

  WalkupFromMostDerivedType(Visitor, const_cast<Decl *>(CanonicalDecl));

  auto *Record = API.findRecordForUSR(USR);

  if (!Record)

    return cxstring::createNull();

  
for (const auto &Fragment : Record->Declaration.getFragments())10
 {

    if (Fragment.Declaration)

      WalkupFromMostDerivedType(Visitor,

                                const_cast<Decl *>(Fragment.Declaration));

  }

  if (auto SGF = SymbolGraphSerializer::serializeSingleSymbolSGF(USR, API))

    return GenerateCXStringFromSymbolGraphData(std::move(*SGF));

  return cxstring::createNull();

}