CXCursor.cpp | Explore in Territory

//===- CXCursor.cpp - Routines for manipulating CXCursors -----------------===//
//
// 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 routines for manipulating CXCursors. It should be the
// only file that has internal knowledge of the encoding of the data in
// CXCursor.
//
//===----------------------------------------------------------------------===//

#include "CXCursor.h"
#include "CXString.h"
#include "CXTranslationUnit.h"
#include "CXType.h"
#include "clang-c/Index.h"
#include "clang/AST/Attr.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclObjC.h"
#include "clang/AST/DeclTemplate.h"
#include "clang/AST/Expr.h"
#include "clang/AST/ExprCXX.h"
#include "clang/AST/ExprObjC.h"
#include "clang/Frontend/ASTUnit.h"
#include "llvm/Support/ErrorHandling.h"

usingnamespaceclang;
usingnamespacecxcursor;

CXCursor cxcursor::MakeCXCursorInvalid(CXCursorKind K, CXTranslationUnit TU) { … }

static CXCursorKind GetCursorKind(const Attr *A) { … }

CXCursor cxcursor::MakeCXCursor(const Attr *A, const Decl *Parent,
                                CXTranslationUnit TU) { … }

CXCursor cxcursor::MakeCXCursor(const Decl *D, CXTranslationUnit TU,
                                SourceRange RegionOfInterest,
                                bool FirstInDeclGroup) { … }

CXCursor cxcursor::MakeCXCursor(const Stmt *S, const Decl *Parent,
                                CXTranslationUnit TU,
                                SourceRange RegionOfInterest) { … }

CXCursor cxcursor::MakeCursorObjCSuperClassRef(ObjCInterfaceDecl *Super,
                                               SourceLocation Loc,
                                               CXTranslationUnit TU) { … }

std::pair<const ObjCInterfaceDecl *, SourceLocation>
cxcursor::getCursorObjCSuperClassRef(CXCursor C) { … }

CXCursor cxcursor::MakeCursorObjCProtocolRef(const ObjCProtocolDecl *Proto,
                                             SourceLocation Loc,
                                             CXTranslationUnit TU) { … }

std::pair<const ObjCProtocolDecl *, SourceLocation>
cxcursor::getCursorObjCProtocolRef(CXCursor C) { … }

CXCursor cxcursor::MakeCursorObjCClassRef(const ObjCInterfaceDecl *Class,
                                          SourceLocation Loc,
                                          CXTranslationUnit TU) { … }

std::pair<const ObjCInterfaceDecl *, SourceLocation>
cxcursor::getCursorObjCClassRef(CXCursor C) { … }

CXCursor cxcursor::MakeCursorTypeRef(const TypeDecl *Type, SourceLocation Loc,
                                     CXTranslationUnit TU) { … }

std::pair<const TypeDecl *, SourceLocation>
cxcursor::getCursorTypeRef(CXCursor C) { … }

CXCursor cxcursor::MakeCursorTemplateRef(const TemplateDecl *Template,
                                         SourceLocation Loc,
                                         CXTranslationUnit TU) { … }

std::pair<const TemplateDecl *, SourceLocation>
cxcursor::getCursorTemplateRef(CXCursor C) { … }

CXCursor cxcursor::MakeCursorNamespaceRef(const NamedDecl *NS,
                                          SourceLocation Loc,
                                          CXTranslationUnit TU) { … }

std::pair<const NamedDecl *, SourceLocation>
cxcursor::getCursorNamespaceRef(CXCursor C) { … }

CXCursor cxcursor::MakeCursorVariableRef(const VarDecl *Var, SourceLocation Loc,
                                         CXTranslationUnit TU) { … }

std::pair<const VarDecl *, SourceLocation>
cxcursor::getCursorVariableRef(CXCursor C) { … }

CXCursor cxcursor::MakeCursorMemberRef(const FieldDecl *Field,
                                       SourceLocation Loc,
                                       CXTranslationUnit TU) { … }

std::pair<const FieldDecl *, SourceLocation>
cxcursor::getCursorMemberRef(CXCursor C) { … }

CXCursor cxcursor::MakeCursorCXXBaseSpecifier(const CXXBaseSpecifier *B,
                                              CXTranslationUnit TU) { … }

const CXXBaseSpecifier *cxcursor::getCursorCXXBaseSpecifier(CXCursor C) { … }

CXCursor cxcursor::MakePreprocessingDirectiveCursor(SourceRange Range,
                                                    CXTranslationUnit TU) { … }

SourceRange cxcursor::getCursorPreprocessingDirective(CXCursor C) { … }

CXCursor cxcursor::MakeMacroDefinitionCursor(const MacroDefinitionRecord *MI,
                                             CXTranslationUnit TU) { … }

const MacroDefinitionRecord *cxcursor::getCursorMacroDefinition(CXCursor C) { … }

CXCursor cxcursor::MakeMacroExpansionCursor(MacroExpansion *MI,
                                            CXTranslationUnit TU) { … }

CXCursor cxcursor::MakeMacroExpansionCursor(MacroDefinitionRecord *MI,
                                            SourceLocation Loc,
                                            CXTranslationUnit TU) { … }

const IdentifierInfo *cxcursor::MacroExpansionCursor::getName() const { … }
const MacroDefinitionRecord *
cxcursor::MacroExpansionCursor::getDefinition() const { … }
SourceRange cxcursor::MacroExpansionCursor::getSourceRange() const { … }

CXCursor cxcursor::MakeInclusionDirectiveCursor(InclusionDirective *ID,
                                                CXTranslationUnit TU) { … }

const InclusionDirective *cxcursor::getCursorInclusionDirective(CXCursor C) { … }

CXCursor cxcursor::MakeCursorLabelRef(LabelStmt *Label, SourceLocation Loc,
                                      CXTranslationUnit TU) { … }

std::pair<const LabelStmt *, SourceLocation>
cxcursor::getCursorLabelRef(CXCursor C) { … }

CXCursor cxcursor::MakeCursorOverloadedDeclRef(const OverloadExpr *E,
                                               CXTranslationUnit TU) { … }

CXCursor cxcursor::MakeCursorOverloadedDeclRef(const Decl *D,
                                               SourceLocation Loc,
                                               CXTranslationUnit TU) { … }

CXCursor cxcursor::MakeCursorOverloadedDeclRef(TemplateName Name,
                                               SourceLocation Loc,
                                               CXTranslationUnit TU) { … }

std::pair<cxcursor::OverloadedDeclRefStorage, SourceLocation>
cxcursor::getCursorOverloadedDeclRef(CXCursor C) { … }

const Decl *cxcursor::getCursorDecl(CXCursor Cursor) { … }

const Expr *cxcursor::getCursorExpr(CXCursor Cursor) { … }

const Stmt *cxcursor::getCursorStmt(CXCursor Cursor) { … }

const Attr *cxcursor::getCursorAttr(CXCursor Cursor) { … }

ASTContext &cxcursor::getCursorContext(CXCursor Cursor) { … }

ASTUnit *cxcursor::getCursorASTUnit(CXCursor Cursor) { … }

CXTranslationUnit cxcursor::getCursorTU(CXCursor Cursor) { … }

void cxcursor::getOverriddenCursors(CXCursor cursor,
                                    SmallVectorImpl<CXCursor> &overridden) { … }

std::pair<int, SourceLocation>
cxcursor::getSelectorIdentifierIndexAndLoc(CXCursor cursor) { … }

CXCursor cxcursor::getSelectorIdentifierCursor(int SelIdx, CXCursor cursor) { … }

CXCursor cxcursor::getTypeRefCursor(CXCursor cursor) { … }

bool cxcursor::operator==(CXCursor X, CXCursor Y) { … }

// FIXME: Remove once we can model DeclGroups and their appropriate ranges
// properly in the ASTs.
bool cxcursor::isFirstInDeclGroup(CXCursor C) { … }

//===----------------------------------------------------------------------===//
// libclang CXCursor APIs
//===----------------------------------------------------------------------===//

int clang_Cursor_isNull(CXCursor cursor) { … }

CXTranslationUnit clang_Cursor_getTranslationUnit(CXCursor cursor) { … }

int clang_Cursor_getNumArguments(CXCursor C) { … }

CXCursor clang_Cursor_getArgument(CXCursor C, unsigned i) { … }

int clang_Cursor_getNumTemplateArguments(CXCursor C) { … }

enum CXGetTemplateArgumentStatus { … };

static int clang_Cursor_getTemplateArgument(CXCursor C, unsigned I,
                                            TemplateArgument *TA) { … }

enum CXTemplateArgumentKind clang_Cursor_getTemplateArgumentKind(CXCursor C,
                                                                 unsigned I) { … }

CXType clang_Cursor_getTemplateArgumentType(CXCursor C, unsigned I) { … }

long long clang_Cursor_getTemplateArgumentValue(CXCursor C, unsigned I) { … }

unsigned long long clang_Cursor_getTemplateArgumentUnsignedValue(CXCursor C,
                                                                 unsigned I) { … }

//===----------------------------------------------------------------------===//
// CXCursorSet.
//===----------------------------------------------------------------------===//

CXCursorSet_Impl;

static inline CXCursorSet packCXCursorSet(CXCursorSet_Impl *setImpl) { … }
static inline CXCursorSet_Impl *unpackCXCursorSet(CXCursorSet set) { … }
namespace llvm {
template <> struct DenseMapInfo<CXCursor> { … };
} // namespace llvm

CXCursorSet clang_createCXCursorSet() { … }

void clang_disposeCXCursorSet(CXCursorSet set) { … }

unsigned clang_CXCursorSet_contains(CXCursorSet set, CXCursor cursor) { … }

unsigned clang_CXCursorSet_insert(CXCursorSet set, CXCursor cursor) { … }

CXCompletionString clang_getCursorCompletionString(CXCursor cursor) { … }

namespace {
struct OverridenCursorsPool { … };
} // namespace

void *cxcursor::createOverridenCXCursorsPool() { … }

void cxcursor::disposeOverridenCXCursorsPool(void *pool) { … }

void clang_getOverriddenCursors(CXCursor cursor, CXCursor **overridden,
                                unsigned *num_overridden) { … }

void clang_disposeOverriddenCursors(CXCursor *overridden) { … }

int clang_Cursor_isDynamicCall(CXCursor C) { … }

CXType clang_Cursor_getReceiverType(CXCursor C) { … }
llvm/clang/tools/libclang/CXCursor.cpp
