| 1 |
//===- CXIndexDataConsumer.h - Index data consumer for libclang--*- C++ -*-===// |
| 2 |
// |
| 3 |
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 |
// See https://llvm.org/LICENSE.txt for license information. |
| 5 |
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 |
// |
| 7 |
//===----------------------------------------------------------------------===// |
| 8 |
|
| 9 |
#ifndef LLVM_CLANG_TOOLS_LIBCLANG_CXINDEXDATACONSUMER_H |
| 10 |
#define LLVM_CLANG_TOOLS_LIBCLANG_CXINDEXDATACONSUMER_H |
| 11 |
|
| 12 |
#include "CXCursor.h" |
| 13 |
#include "Index_Internal.h" |
| 14 |
#include "clang/Index/IndexDataConsumer.h" |
| 15 |
#include "clang/AST/DeclGroup.h" |
| 16 |
#include "clang/AST/DeclObjC.h" |
| 17 |
#include "llvm/ADT/DenseSet.h" |
| 18 |
|
| 19 |
namespace clang { |
| 20 |
class FileEntry; |
| 21 |
class MSPropertyDecl; |
| 22 |
class ObjCPropertyDecl; |
| 23 |
class ClassTemplateDecl; |
| 24 |
class FunctionTemplateDecl; |
| 25 |
class TypeAliasTemplateDecl; |
| 26 |
class ClassTemplateSpecializationDecl; |
| 27 |
|
| 28 |
namespace cxindex { |
| 29 |
class CXIndexDataConsumer; |
| 30 |
class AttrListInfo; |
| 31 |
|
| 32 |
class ScratchAlloc { |
| 33 |
CXIndexDataConsumer &IdxCtx; |
| 34 |
|
| 35 |
public: |
| 36 |
explicit ScratchAlloc(CXIndexDataConsumer &indexCtx); |
| 37 |
ScratchAlloc(const ScratchAlloc &SA); |
| 38 |
|
| 39 |
~ScratchAlloc(); |
| 40 |
|
| 41 |
const char *toCStr(StringRef Str); |
| 42 |
const char *copyCStr(StringRef Str); |
| 43 |
|
| 44 |
template <typename T> |
| 45 |
T *allocate(); |
| 46 |
}; |
| 47 |
|
| 48 |
struct EntityInfo : public CXIdxEntityInfo { |
| 49 |
const NamedDecl *Dcl; |
| 50 |
CXIndexDataConsumer *IndexCtx; |
| 51 |
IntrusiveRefCntPtr<AttrListInfo> AttrList; |
| 52 |
|
| 53 |
EntityInfo() { |
| 54 |
name = USR = nullptr; |
| 55 |
attributes = nullptr; |
| 56 |
numAttributes = 0; |
| 57 |
} |
| 58 |
}; |
| 59 |
|
| 60 |
struct ContainerInfo : public CXIdxContainerInfo { |
| 61 |
const DeclContext *DC; |
| 62 |
CXIndexDataConsumer *IndexCtx; |
| 63 |
}; |
| 64 |
|
| 65 |
struct DeclInfo : public CXIdxDeclInfo { |
| 66 |
enum DInfoKind { |
| 67 |
Info_Decl, |
| 68 |
|
| 69 |
Info_ObjCContainer, |
| 70 |
Info_ObjCInterface, |
| 71 |
Info_ObjCProtocol, |
| 72 |
Info_ObjCCategory, |
| 73 |
|
| 74 |
Info_ObjCProperty, |
| 75 |
|
| 76 |
Info_CXXClass |
| 77 |
}; |
| 78 |
|
| 79 |
DInfoKind Kind; |
| 80 |
|
| 81 |
EntityInfo EntInfo; |
| 82 |
ContainerInfo SemanticContainer; |
| 83 |
ContainerInfo LexicalContainer; |
| 84 |
ContainerInfo DeclAsContainer; |
| 85 |
|
| 86 |
DeclInfo(bool isRedeclaration, bool isDefinition, bool isContainer) |
| 87 |
: Kind(Info_Decl) { |
| 88 |
this->isRedeclaration = isRedeclaration; |
| 89 |
this->isDefinition = isDefinition; |
| 90 |
this->isContainer = isContainer; |
| 91 |
attributes = nullptr; |
| 92 |
numAttributes = 0; |
| 93 |
declAsContainer = semanticContainer = lexicalContainer = nullptr; |
| 94 |
flags = 0; |
| 95 |
} |
| 96 |
DeclInfo(DInfoKind K, |
| 97 |
bool isRedeclaration, bool isDefinition, bool isContainer) |
| 98 |
: Kind(K) { |
| 99 |
this->isRedeclaration = isRedeclaration; |
| 100 |
this->isDefinition = isDefinition; |
| 101 |
this->isContainer = isContainer; |
| 102 |
attributes = nullptr; |
| 103 |
numAttributes = 0; |
| 104 |
declAsContainer = semanticContainer = lexicalContainer = nullptr; |
| 105 |
flags = 0; |
| 106 |
} |
| 107 |
}; |
| 108 |
|
| 109 |
struct ObjCContainerDeclInfo : public DeclInfo { |
| 110 |
CXIdxObjCContainerDeclInfo ObjCContDeclInfo; |
| 111 |
|
| 112 |
ObjCContainerDeclInfo(bool isForwardRef, |
| 113 |
bool isRedeclaration, |
| 114 |
bool isImplementation) |
| 115 |
: DeclInfo(Info_ObjCContainer, isRedeclaration, |
| 116 |
/*isDefinition=*/!isForwardRef, /*isContainer=*/!isForwardRef) { |
| 117 |
init(isForwardRef, isImplementation); |
| 118 |
} |
| 119 |
ObjCContainerDeclInfo(DInfoKind K, |
| 120 |
bool isForwardRef, |
| 121 |
bool isRedeclaration, |
| 122 |
bool isImplementation) |
| 123 |
: DeclInfo(K, isRedeclaration, /*isDefinition=*/!isForwardRef, |
| 124 |
/*isContainer=*/!isForwardRef) { |
| 125 |
init(isForwardRef, isImplementation); |
| 126 |
} |
| 127 |
|
| 128 |
static bool classof(const DeclInfo *D) { |
| 129 |
return Info_ObjCContainer <= D->Kind && D->Kind <= Info_ObjCCategory; |
| 130 |
} |
| 131 |
|
| 132 |
private: |
| 133 |
void init(bool isForwardRef, bool isImplementation) { |
| 134 |
if (isForwardRef) |
| 135 |
ObjCContDeclInfo.kind = CXIdxObjCContainer_ForwardRef; |
| 136 |
else if (isImplementation) |
| 137 |
ObjCContDeclInfo.kind = CXIdxObjCContainer_Implementation; |
| 138 |
else |
| 139 |
ObjCContDeclInfo.kind = CXIdxObjCContainer_Interface; |
| 140 |
} |
| 141 |
}; |
| 142 |
|
| 143 |
struct ObjCInterfaceDeclInfo : public ObjCContainerDeclInfo { |
| 144 |
CXIdxObjCInterfaceDeclInfo ObjCInterDeclInfo; |
| 145 |
CXIdxObjCProtocolRefListInfo ObjCProtoListInfo; |
| 146 |
|
| 147 |
ObjCInterfaceDeclInfo(const ObjCInterfaceDecl *D) |
| 148 |
: ObjCContainerDeclInfo(Info_ObjCInterface, |
| 149 |
/*isForwardRef=*/false, |
| 150 |
/*isRedeclaration=*/D->getPreviousDecl() != nullptr, |
| 151 |
/*isImplementation=*/false) { } |
| 152 |
|
| 153 |
static bool classof(const DeclInfo *D) { |
| 154 |
return D->Kind == Info_ObjCInterface; |
| 155 |
} |
| 156 |
}; |
| 157 |
|
| 158 |
struct ObjCProtocolDeclInfo : public ObjCContainerDeclInfo { |
| 159 |
CXIdxObjCProtocolRefListInfo ObjCProtoRefListInfo; |
| 160 |
|
| 161 |
ObjCProtocolDeclInfo(const ObjCProtocolDecl *D) |
| 162 |
: ObjCContainerDeclInfo(Info_ObjCProtocol, |
| 163 |
/*isForwardRef=*/false, |
| 164 |
/*isRedeclaration=*/D->getPreviousDecl(), |
| 165 |
/*isImplementation=*/false) { } |
| 166 |
|
| 167 |
static bool classof(const DeclInfo *D) { |
| 168 |
return D->Kind == Info_ObjCProtocol; |
| 169 |
} |
| 170 |
}; |
| 171 |
|
| 172 |
struct ObjCCategoryDeclInfo : public ObjCContainerDeclInfo { |
| 173 |
CXIdxObjCCategoryDeclInfo ObjCCatDeclInfo; |
| 174 |
CXIdxObjCProtocolRefListInfo ObjCProtoListInfo; |
| 175 |
|
| 176 |
explicit ObjCCategoryDeclInfo(bool isImplementation) |
| 177 |
: ObjCContainerDeclInfo(Info_ObjCCategory, |
| 178 |
/*isForwardRef=*/false, |
| 179 |
/*isRedeclaration=*/isImplementation, |
| 180 |
/*isImplementation=*/isImplementation) { } |
| 181 |
|
| 182 |
static bool classof(const DeclInfo *D) { |
| 183 |
return D->Kind == Info_ObjCCategory; |
| 184 |
} |
| 185 |
}; |
| 186 |
|
| 187 |
struct ObjCPropertyDeclInfo : public DeclInfo { |
| 188 |
CXIdxObjCPropertyDeclInfo ObjCPropDeclInfo; |
| 189 |
|
| 190 |
ObjCPropertyDeclInfo() |
| 191 |
: DeclInfo(Info_ObjCProperty, |
| 192 |
/*isRedeclaration=*/false, /*isDefinition=*/false, |
| 193 |
/*isContainer=*/false) { } |
| 194 |
|
| 195 |
static bool classof(const DeclInfo *D) { |
| 196 |
return D->Kind == Info_ObjCProperty; |
| 197 |
} |
| 198 |
}; |
| 199 |
|
| 200 |
struct CXXClassDeclInfo : public DeclInfo { |
| 201 |
CXIdxCXXClassDeclInfo CXXClassInfo; |
| 202 |
|
| 203 |
CXXClassDeclInfo(bool isRedeclaration, bool isDefinition) |
| 204 |
: DeclInfo(Info_CXXClass, isRedeclaration, isDefinition, isDefinition) { } |
| 205 |
|
| 206 |
static bool classof(const DeclInfo *D) { |
| 207 |
return D->Kind == Info_CXXClass; |
| 208 |
} |
| 209 |
}; |
| 210 |
|
| 211 |
struct AttrInfo : public CXIdxAttrInfo { |
| 212 |
const Attr *A; |
| 213 |
|
| 214 |
AttrInfo(CXIdxAttrKind Kind, CXCursor C, CXIdxLoc Loc, const Attr *A) { |
| 215 |
kind = Kind; |
| 216 |
cursor = C; |
| 217 |
loc = Loc; |
| 218 |
this->A = A; |
| 219 |
} |
| 220 |
}; |
| 221 |
|
| 222 |
struct IBOutletCollectionInfo : public AttrInfo { |
| 223 |
EntityInfo ClassInfo; |
| 224 |
CXIdxIBOutletCollectionAttrInfo IBCollInfo; |
| 225 |
|
| 226 |
IBOutletCollectionInfo(CXCursor C, CXIdxLoc Loc, const Attr *A) : |
| 227 |
AttrInfo(CXIdxAttr_IBOutletCollection, C, Loc, A) { |
| 228 |
assert(C.kind == CXCursor_IBOutletCollectionAttr); |
| 229 |
IBCollInfo.objcClass = nullptr; |
| 230 |
} |
| 231 |
|
| 232 |
IBOutletCollectionInfo(const IBOutletCollectionInfo &other); |
| 233 |
|
| 234 |
static bool classof(const AttrInfo *A) { |
| 235 |
return A->kind == CXIdxAttr_IBOutletCollection; |
| 236 |
} |
| 237 |
}; |
| 238 |
|
| 239 |
class AttrListInfo { |
| 240 |
ScratchAlloc SA; |
| 241 |
|
| 242 |
SmallVector<AttrInfo, 2> Attrs; |
| 243 |
SmallVector<IBOutletCollectionInfo, 2> IBCollAttrs; |
| 244 |
SmallVector<CXIdxAttrInfo *, 2> CXAttrs; |
| 245 |
unsigned ref_cnt; |
| 246 |
|
| 247 |
AttrListInfo(const AttrListInfo &) = delete; |
| 248 |
void operator=(const AttrListInfo &) = delete; |
| 249 |
public: |
| 250 |
AttrListInfo(const Decl *D, CXIndexDataConsumer &IdxCtx); |
| 251 |
|
| 252 |
static IntrusiveRefCntPtr<AttrListInfo> create(const Decl *D, |
| 253 |
CXIndexDataConsumer &IdxCtx); |
| 254 |
|
| 255 |
const CXIdxAttrInfo *const *getAttrs() const { |
| 256 |
if (CXAttrs.empty()) |
| 257 |
return nullptr; |
| 258 |
return CXAttrs.data(); |
| 259 |
} |
| 260 |
unsigned getNumAttrs() const { return (unsigned)CXAttrs.size(); } |
| 261 |
|
| 262 |
/// Retain/Release only useful when we allocate a AttrListInfo from the |
| 263 |
/// BumpPtrAllocator, and not from the stack; so that we keep a pointer |
| 264 |
// in the EntityInfo |
| 265 |
void Retain() { ++ref_cnt; } |
| 266 |
void Release() { |
| 267 |
assert (ref_cnt > 0 && "Reference count is already zero."); |
| 268 |
if (--ref_cnt == 0) { |
| 269 |
// Memory is allocated from a BumpPtrAllocator, no need to delete it. |
| 270 |
this->~AttrListInfo(); |
| 271 |
} |
| 272 |
} |
| 273 |
}; |
| 274 |
|
| 275 |
class CXIndexDataConsumer : public index::IndexDataConsumer { |
| 276 |
ASTContext *Ctx; |
| 277 |
CXClientData ClientData; |
| 278 |
IndexerCallbacks &CB; |
| 279 |
unsigned IndexOptions; |
| 280 |
CXTranslationUnit CXTU; |
| 281 |
|
| 282 |
typedef llvm::DenseMap<const FileEntry *, CXIdxClientFile> FileMapTy; |
| 283 |
typedef llvm::DenseMap<const DeclContext *, CXIdxClientContainer> |
| 284 |
ContainerMapTy; |
| 285 |
typedef llvm::DenseMap<const Decl *, CXIdxClientEntity> EntityMapTy; |
| 286 |
|
| 287 |
FileMapTy FileMap; |
| 288 |
ContainerMapTy ContainerMap; |
| 289 |
EntityMapTy EntityMap; |
| 290 |
|
| 291 |
typedef std::pair<const FileEntry *, const Decl *> RefFileOccurrence; |
| 292 |
llvm::DenseSet<RefFileOccurrence> RefFileOccurrences; |
| 293 |
|
| 294 |
llvm::BumpPtrAllocator StrScratch; |
| 295 |
unsigned StrAdapterCount; |
| 296 |
friend class ScratchAlloc; |
| 297 |
|
| 298 |
struct ObjCProtocolListInfo { |
| 299 |
SmallVector<CXIdxObjCProtocolRefInfo, 4> ProtInfos; |
| 300 |
SmallVector<EntityInfo, 4> ProtEntities; |
| 301 |
SmallVector<CXIdxObjCProtocolRefInfo *, 4> Prots; |
| 302 |
|
| 303 |
CXIdxObjCProtocolRefListInfo getListInfo() const { |
| 304 |
CXIdxObjCProtocolRefListInfo Info = { Prots.data(), |
| 305 |
(unsigned)Prots.size() }; |
| 306 |
return Info; |
| 307 |
} |
| 308 |
|
| 309 |
ObjCProtocolListInfo(const ObjCProtocolList &ProtList, |
| 310 |
CXIndexDataConsumer &IdxCtx, |
| 311 |
ScratchAlloc &SA); |
| 312 |
}; |
| 313 |
|
| 314 |
struct CXXBasesListInfo { |
| 315 |
SmallVector<CXIdxBaseClassInfo, 4> BaseInfos; |
| 316 |
SmallVector<EntityInfo, 4> BaseEntities; |
| 317 |
SmallVector<CXIdxBaseClassInfo *, 4> CXBases; |
| 318 |
|
| 319 |
const CXIdxBaseClassInfo *const *getBases() const { |
| 320 |
return CXBases.data(); |
| 321 |
} |
| 322 |
unsigned getNumBases() const { return (unsigned)CXBases.size(); } |
| 323 |
|
| 324 |
CXXBasesListInfo(const CXXRecordDecl *D, |
| 325 |
CXIndexDataConsumer &IdxCtx, ScratchAlloc &SA); |
| 326 |
|
| 327 |
private: |
| 328 |
SourceLocation getBaseLoc(const CXXBaseSpecifier &Base) const; |
| 329 |
}; |
| 330 |
|
| 331 |
friend class AttrListInfo; |
| 332 |
|
| 333 |
public: |
| 334 |
CXIndexDataConsumer(CXClientData clientData, IndexerCallbacks &indexCallbacks, |
| 335 |
unsigned indexOptions, CXTranslationUnit cxTU) |
| 336 |
: Ctx(nullptr), ClientData(clientData), CB(indexCallbacks), |
| 337 |
IndexOptions(indexOptions), CXTU(cxTU), StrAdapterCount(0) {} |
| 338 |
|
| 339 |
ASTContext &getASTContext() const { return *Ctx; } |
| 340 |
CXTranslationUnit getCXTU() const { return CXTU; } |
| 341 |
|
| 342 |
void setASTContext(ASTContext &ctx); |
| 343 |
void setPreprocessor(std::shared_ptr<Preprocessor> PP) override; |
| 344 |
|
| 345 |
bool shouldSuppressRefs() const { |
| 346 |
return IndexOptions & CXIndexOpt_SuppressRedundantRefs; |
| 347 |
} |
| 348 |
|
| 349 |
bool shouldIndexFunctionLocalSymbols() const { |
| 350 |
return IndexOptions & CXIndexOpt_IndexFunctionLocalSymbols; |
| 351 |
} |
| 352 |
|
| 353 |
bool shouldIndexImplicitTemplateInsts() const { |
| 354 |
return IndexOptions & CXIndexOpt_IndexImplicitTemplateInstantiations; |
| 355 |
} |
| 356 |
|
| 357 |
static bool isFunctionLocalDecl(const Decl *D); |
| 358 |
|
| 359 |
bool shouldAbort(); |
| 360 |
|
| 361 |
bool hasDiagnosticCallback() const { return CB.diagnostic; } |
| 362 |
|
| 363 |
void enteredMainFile(const FileEntry *File); |
| 364 |
|
| 365 |
void ppIncludedFile(SourceLocation hashLoc, StringRef filename, |
| 366 |
OptionalFileEntryRef File, bool isImport, bool isAngled, |
| 367 |
bool isModuleImport); |
| 368 |
|
| 369 |
void importedModule(const ImportDecl *ImportD); |
| 370 |
void importedPCH(const FileEntry *File); |
| 371 |
|
| 372 |
void startedTranslationUnit(); |
| 373 |
|
| 374 |
void indexDiagnostics(); |
| 375 |
|
| 376 |
void handleDiagnosticSet(CXDiagnosticSet CXDiagSet); |
| 377 |
|
| 378 |
bool handleFunction(const FunctionDecl *FD); |
| 379 |
|
| 380 |
bool handleVar(const VarDecl *D); |
| 381 |
|
| 382 |
bool handleField(const FieldDecl *D); |
| 383 |
|
| 384 |
bool handleEnumerator(const EnumConstantDecl *D); |
| 385 |
|
| 386 |
bool handleTagDecl(const TagDecl *D); |
| 387 |
|
| 388 |
bool handleTypedefName(const TypedefNameDecl *D); |
| 389 |
|
| 390 |
bool handleObjCInterface(const ObjCInterfaceDecl *D); |
| 391 |
bool handleObjCImplementation(const ObjCImplementationDecl *D); |
| 392 |
|
| 393 |
bool handleObjCProtocol(const ObjCProtocolDecl *D); |
| 394 |
|
| 395 |
bool handleObjCCategory(const ObjCCategoryDecl *D); |
| 396 |
bool handleObjCCategoryImpl(const ObjCCategoryImplDecl *D); |
| 397 |
|
| 398 |
bool handleObjCMethod(const ObjCMethodDecl *D, SourceLocation Loc); |
| 399 |
|
| 400 |
bool handleSynthesizedObjCProperty(const ObjCPropertyImplDecl *D); |
| 401 |
bool handleSynthesizedObjCMethod(const ObjCMethodDecl *D, SourceLocation Loc, |
| 402 |
const DeclContext *LexicalDC); |
| 403 |
|
| 404 |
bool handleObjCProperty(const ObjCPropertyDecl *D); |
| 405 |
|
| 406 |
bool handleNamespace(const NamespaceDecl *D); |
| 407 |
|
| 408 |
bool handleClassTemplate(const ClassTemplateDecl *D); |
| 409 |
bool handleFunctionTemplate(const FunctionTemplateDecl *D); |
| 410 |
bool handleTypeAliasTemplate(const TypeAliasTemplateDecl *D); |
| 411 |
|
| 412 |
bool handleConcept(const ConceptDecl *D); |
| 413 |
|
| 414 |
bool handleReference(const NamedDecl *D, SourceLocation Loc, CXCursor Cursor, |
| 415 |
const NamedDecl *Parent, |
| 416 |
const DeclContext *DC, |
| 417 |
const Expr *E = nullptr, |
| 418 |
CXIdxEntityRefKind Kind = CXIdxEntityRef_Direct, |
| 419 |
CXSymbolRole Role = CXSymbolRole_None); |
| 420 |
|
| 421 |
bool isNotFromSourceFile(SourceLocation Loc) const; |
| 422 |
|
| 423 |
void translateLoc(SourceLocation Loc, CXIdxClientFile *indexFile, CXFile *file, |
| 424 |
unsigned *line, unsigned *column, unsigned *offset); |
| 425 |
|
| 426 |
CXIdxClientContainer getClientContainerForDC(const DeclContext *DC) const; |
| 427 |
void addContainerInMap(const DeclContext *DC, CXIdxClientContainer container); |
| 428 |
|
| 429 |
CXIdxClientEntity getClientEntity(const Decl *D) const; |
| 430 |
void setClientEntity(const Decl *D, CXIdxClientEntity client); |
| 431 |
|
| 432 |
static bool isTemplateImplicitInstantiation(const Decl *D); |
| 433 |
|
| 434 |
private: |
| 435 |
bool handleDeclOccurrence(const Decl *D, index::SymbolRoleSet Roles, |
| 436 |
ArrayRef<index::SymbolRelation> Relations, |
| 437 |
SourceLocation Loc, ASTNodeInfo ASTNode) override; |
| 438 |
|
| 439 |
bool handleModuleOccurrence(const ImportDecl *ImportD, const Module *Mod, |
| 440 |
index::SymbolRoleSet Roles, |
| 441 |
SourceLocation Loc) override; |
| 442 |
|
| 443 |
void finish() override; |
| 444 |
|
| 445 |
bool handleDecl(const NamedDecl *D, |
| 446 |
SourceLocation Loc, CXCursor Cursor, |
| 447 |
DeclInfo &DInfo, |
| 448 |
const DeclContext *LexicalDC = nullptr, |
| 449 |
const DeclContext *SemaDC = nullptr); |
| 450 |
|
| 451 |
bool handleObjCContainer(const ObjCContainerDecl *D, |
| 452 |
SourceLocation Loc, CXCursor Cursor, |
| 453 |
ObjCContainerDeclInfo &ContDInfo); |
| 454 |
|
| 455 |
bool handleCXXRecordDecl(const CXXRecordDecl *RD, const NamedDecl *OrigD); |
| 456 |
|
| 457 |
bool markEntityOccurrenceInFile(const NamedDecl *D, SourceLocation Loc); |
| 458 |
|
| 459 |
const NamedDecl *getEntityDecl(const NamedDecl *D) const; |
| 460 |
|
| 461 |
const DeclContext *getEntityContainer(const Decl *D) const; |
| 462 |
|
| 463 |
CXIdxClientFile getIndexFile(const FileEntry *File); |
| 464 |
|
| 465 |
CXIdxLoc getIndexLoc(SourceLocation Loc) const; |
| 466 |
|
| 467 |
void getEntityInfo(const NamedDecl *D, |
| 468 |
EntityInfo &EntityInfo, |
| 469 |
ScratchAlloc &SA); |
| 470 |
|
| 471 |
void getContainerInfo(const DeclContext *DC, ContainerInfo &ContInfo); |
| 472 |
|
| 473 |
CXCursor getCursor(const Decl *D) { |
| 474 |
return cxcursor::MakeCXCursor(D, CXTU); |
| 475 |
} |
| 476 |
|
| 477 |
CXCursor getRefCursor(const NamedDecl *D, SourceLocation Loc); |
| 478 |
|
| 479 |
static bool shouldIgnoreIfImplicit(const Decl *D); |
| 480 |
}; |
| 481 |
|
| 482 |
inline ScratchAlloc::ScratchAlloc(CXIndexDataConsumer &idxCtx) : IdxCtx(idxCtx) { |
| 483 |
++IdxCtx.StrAdapterCount; |
| 484 |
} |
| 485 |
inline ScratchAlloc::ScratchAlloc(const ScratchAlloc &SA) : IdxCtx(SA.IdxCtx) { |
| 486 |
++IdxCtx.StrAdapterCount; |
| 487 |
} |
| 488 |
|
| 489 |
inline ScratchAlloc::~ScratchAlloc() { |
| 490 |
--IdxCtx.StrAdapterCount; |
| 491 |
if (IdxCtx.StrAdapterCount == 0) |
| 492 |
IdxCtx.StrScratch.Reset(); |
| 493 |
} |
| 494 |
|
| 495 |
template <typename T> |
| 496 |
inline T *ScratchAlloc::allocate() { |
| 497 |
return IdxCtx.StrScratch.Allocate<T>(); |
| 498 |
} |
| 499 |
|
| 500 |
}} // end clang::cxindex |
| 501 |
|
| 502 |
#endif |