Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/ASTUnit_8cpp_source.html below:

clang: lib/Frontend/ASTUnit.cpp Source File

;

llvm::TimeRecord;

SimpleTimer(

WantTiming) : WantTiming(WantTiming) {

Start = TimeRecord::getCurrentTime();

TimeRecord Elapsed = TimeRecord::getCurrentTime();

llvm::errs() << Output <<

;

Elapsed.print(Elapsed, llvm::errs());

llvm::errs() <<

;

setOutput(

Twine &Output) {

this->Output = Output.str();

std::unique_ptr<T>

(llvm::ErrorOr<std::unique_ptr<T>> Val) {

std::move(*Val);

Output = std::move(*Val);

std::unique_ptr<llvm::MemoryBuffer>

llvm::vfs::FileSystem *VFS,

StringRef FilePath,

isVolatile) {

llvm::MemoryBuffer *Buffer =

;

std::unique_ptr<llvm::MemoryBuffer> BufferOwner;

FileStatus = VFS->status(FilePath);

llvm::sys::fs::UniqueID MainFileID = FileStatus->getUniqueID();

(

&RF : PreprocessorOpts.RemappedFiles) {

std::string MPath(RF.first);

MPathStatus = VFS->status(MPath);

llvm::sys::fs::UniqueID MID = MPathStatus->getUniqueID();

(MainFileID == MID) {

BufferOwner =

(VFS->getBufferForFile(RF.second, -1,

, isVolatile));

(

&RB : PreprocessorOpts.RemappedFileBuffers) {

std::string MPath(RB.first);

MPathStatus = VFS->status(MPath);

llvm::sys::fs::UniqueID MID = MPathStatus->getUniqueID();

(MainFileID == MID) {

Buffer =

llvm::MemoryBuffer *

(RB.second);

(!Buffer && !BufferOwner) {

BufferOwner =

(VFS->getBufferForFile(FilePath, -1,

, isVolatile));

llvm::MemoryBuffer::getMemBufferCopy(Buffer->getBuffer(), FilePath);

ASTUnit::clearFileLevelDecls() {

ASTUnit::ASTUnit(

_MainFileIsAST)

: MainFileIsAST(_MainFileIsAST), WantTiming(getenv(

)),

ShouldCacheCodeCompletionResults(

),

IncludeBriefCommentsInCodeCompletion(

), UserFilesAreVolatile(

),

UnsafeToFree(

) {

(getenv(

))

clearFileLevelDecls();

(Invocation && OwnsRemappedFileBuffers) {

ClearCachedCompletionResults();

(getenv(

))

this->PP = std::move(PP);

);

&IsNestedNameSpecifier) {

IsNestedNameSpecifier =

;

(isa<UsingShadowDecl>(ND))

uint64_t Contexts = 0;

(isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND) ||

isa<ClassTemplateDecl>(ND) || isa<TemplateTemplateParmDecl>(ND) ||

isa<TypeAliasTemplateDecl>(ND)) {

(LangOpts.CPlusPlus || !isa<TagDecl>(ND))

(LangOpts.CPlusPlus)

(LangOpts.CPlusPlus || isa<ObjCInterfaceDecl>(ND))

(

*ID = dyn_cast<ObjCInterfaceDecl>(ND)) {

(ID->getDefinition())

(isa<EnumDecl>(ND)) {

(LangOpts.CPlusPlus11)

IsNestedNameSpecifier =

;

}

(

*

= dyn_cast<RecordDecl>(ND)) {

(LangOpts.CPlusPlus)

IsNestedNameSpecifier =

;

}

(isa<ClassTemplateDecl>(ND))

IsNestedNameSpecifier =

;

}

(isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND)) {

}

(isa<ObjCProtocolDecl>(ND)) {

}

(isa<ObjCCategoryDecl>(ND)) {

}

(isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND)) {

IsNestedNameSpecifier =

;

ASTUnit::CacheCodeCompletionResults() {

SimpleTimer Timer(WantTiming);

Timer.setOutput(

+

());

ClearCachedCompletionResults();

CachedCompletionAllocator = std::make_shared<GlobalCodeCompletionAllocator>();

TheSema->CodeCompletion().GatherGlobalCodeCompletions(

*CachedCompletionAllocator, CCTUInfo, Results);

llvm::DenseMap<CanQualType, unsigned> CompletionTypes;

(

&R : Results) {

Result::RK_Declaration: {

IsNestedNameSpecifier =

;

CachedCodeCompletionResult CachedResult;

CachedResult.Completion = R.CreateCodeCompletionString(

*TheSema, CCContext, *CachedCompletionAllocator, CCTUInfo,

IncludeBriefCommentsInCodeCompletion);

R.Declaration, Ctx->getLangOpts(), IsNestedNameSpecifier);

CachedResult.Priority = R.Priority;

CachedResult.Kind = R.CursorKind;

CachedResult.Availability = R.Availability;

(UsageType.

()) {

CachedResult.Type = 0;

&TypeValue = CompletionTypes[CanUsageType];

(TypeValue == 0) {

TypeValue = CompletionTypes.size();

CachedResult.Type = TypeValue;

CachedCompletionResults.push_back(CachedResult);

(TheSema->Context.getLangOpts().CPlusPlus && IsNestedNameSpecifier &&

!R.StartsNestedNameSpecifier) {

(isa<NamespaceDecl>(R.Declaration) ||

isa<NamespaceAliasDecl>(R.Declaration))

(uint64_t RemainingContexts

= NNSContexts & ~CachedResult.ShowInContexts) {

R.StartsNestedNameSpecifier =

;

CachedResult.Completion = R.CreateCodeCompletionString(

*TheSema, CCContext, *CachedCompletionAllocator, CCTUInfo,

IncludeBriefCommentsInCodeCompletion);

CachedResult.ShowInContexts = RemainingContexts;

CachedResult.Type = 0;

CachedCompletionResults.push_back(CachedResult);

Result::RK_Keyword:

Result::RK_Pattern:

Result::RK_Macro: {

CachedCodeCompletionResult CachedResult;

CachedResult.Completion = R.CreateCodeCompletionString(

*TheSema, CCContext, *CachedCompletionAllocator, CCTUInfo,

IncludeBriefCommentsInCodeCompletion);

CachedResult.ShowInContexts

CachedResult.Priority = R.Priority;

CachedResult.Kind = R.CursorKind;

CachedResult.Availability = R.Availability;

CachedResult.Type = 0;

CachedCompletionResults.push_back(CachedResult);

CompletionCacheTopLevelHashValue = CurrentTopLevelHashValue;

ASTUnit::ClearCachedCompletionResults() {

CachedCompletionResults.clear();

CachedCompletionTypes.clear();

CachedCompletionAllocator =

;

std::shared_ptr<TargetOptions> &TargetOpts;

InitializedLanguage =

;

InitializedHeaderSearchPaths =

;

std::shared_ptr<TargetOptions> &TargetOpts,

: PP(PP), Context(Context), HSOpts(HSOpts), PPOpts(PPOpts),

LangOpt(LangOpt), TargetOpts(TargetOpts),

(

),

ReadLanguageOptions(

&LangOpts,

StringRef ModuleFilename,

Complain,

AllowCompatibleDifferences)

{

(InitializedLanguage)

PICLevel = LangOpt.PICLevel;

PIE = LangOpt.PIE;

LangOpt.PICLevel = PICLevel;

InitializedLanguage =

;

StringRef ModuleFilename,

StringRef SpecificModuleCachePath,

Complain)

{

ForceCheckCXX20ModulesInputFiles =

this->HSOpts = HSOpts;

ForceCheckCXX20ModulesInputFiles;

Complain)

{

(InitializedHeaderSearchPaths)

InitializedHeaderSearchPaths =

;

StringRef ModuleFilename,

ReadMacros,

std::string &SuggestedPredefines)

{

this->PPOpts = PPOpts;

StringRef ModuleFilename,

Complain,

AllowCompatibleDifferences)

{

this->TargetOpts = std::make_shared<TargetOptions>(TargetOpts);

)

{

(!

|| !InitializedLanguage)

CaptureNonErrorsFromIncludes =

;

FilterAndStoreDiagnosticConsumer(

CaptureNonErrorsFromIncludes)

: StoredDiags(StoredDiags), StandaloneDiags(StandaloneDiags),

CaptureNonErrorsFromIncludes(CaptureNonErrorsFromIncludes) {

assert((StoredDiags || StandaloneDiags) &&

);

this->LangOpts = &LangOpts;

CaptureDroppedDiagnostics {

FilterAndStoreDiagnosticConsumer Client;

std::unique_ptr<DiagnosticConsumer> OwningPreviousClient;

CaptureDroppedDiagnostics(

Client(StoredDiags, StandaloneDiags,

CaptureDiagnostics !=

(CaptureDiagnostics != CaptureDiagsKind::None ||

~CaptureDroppedDiagnostics() {

Diags.

(PreviousClient, !!OwningPreviousClient.release());

&M =

.getSourceManager();

M.isWrittenInMainFile(M.getExpansionLoc(

.

()));

FilterAndStoreDiagnosticConsumer::HandleDiagnostic(

StoredDiags->emplace_back(Level, Info);

ResultDiag = &StoredDiags->back();

(StandaloneDiags) {

std::optional<StoredDiagnostic> StoredDiag;

StoredDiag.emplace(Level, Info);

ResultDiag = &*StoredDiag;

StandaloneDiags->push_back(

&WriterData->Writer;

&WriterData->Writer;

std::unique_ptr<llvm::MemoryBuffer>

Buffer = FileMgr->getBufferForFile(

, UserFilesAreVolatile);

std::move(*Buffer);

*ErrorStr = Buffer.getError().message();

assert(Diags.get() &&

);

Diags->setClient(

FilterAndStoreDiagnosticConsumer(

&AST.StoredDiagnostics,

,

std::shared_ptr<HeaderSearchOptions> HSOpts,

std::shared_ptr<LangOptions> LangOpts,

OnlyLocalDecls,

std::unique_ptr<ASTUnit> AST(

(

));

llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>

ASTUnitCleanup(AST.get());

llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine>>

DiagCleanup(Diags.get());

ConfigureDiags(Diags, *AST, CaptureDiagnostics);

AST->LangOpts = LangOpts ? LangOpts : std::make_shared<LangOptions>();

AST->OnlyLocalDecls = OnlyLocalDecls;

AST->CaptureDiagnostics = CaptureDiagnostics;

AST->Diagnostics = Diags;

AST->FileMgr =

(FileSystemOpts, VFS);

AST->UserFilesAreVolatile = UserFilesAreVolatile;

AST->getFileManager(),

UserFilesAreVolatile);

AST->HSOpts = HSOpts ? HSOpts : std::make_shared<HeaderSearchOptions>();

AST->HSOpts->ModuleFormat = std::string(PCHContainerRdr.

().front());

AST->getSourceManager(),

AST->getDiagnostics(),

AST->PPOpts = std::make_shared<PreprocessorOptions>();

AST->PP = std::make_shared<Preprocessor>(

AST->PPOpts, AST->getDiagnostics(), *AST->LangOpts,

AST->getSourceManager(), HeaderInfo, AST->ModuleLoader,

AST->Ctx =

(*AST->LangOpts, AST->getSourceManager(),

AST->getTranslationUnitKind());

(::getenv(

))

PP, *AST->ModuleCache, AST->Ctx.get(), PCHContainerRdr, {},

disableValid, AllowASTWithCompilerErrors);

Counter = 0;

AST->Reader->setListener(std::make_unique<ASTInfoCollector>(

*AST->PP, AST->Ctx.get(), *AST->HSOpts, *AST->PPOpts, *AST->LangOpts,

AST->TargetOpts, AST->Target, Counter));

AST->Ctx->setExternalSource(AST->Reader);

AST->getDiagnostics().Report(diag::err_fe_unable_to_load_pch);

AST->OriginalSourceFile = std::string(AST->Reader->getOriginalSourceFile());

(M && AST->getLangOpts().isCompilingModule() && M->

())

AST->Ctx->setCurrentNamedModule(M);

AST->TheSema.reset(

(PP, *AST->Ctx, *AST->Consumer));

AST->TheSema->Initialize();

AST->Reader->InitializeSema(*AST->TheSema);

AST->getDiagnostics().getClient()->BeginSourceFile(PP.

(), &PP);

MacroDefinitionTrackerPPCallbacks :

{

MacroDefinitionTrackerPPCallbacks(

&Hash) : Hash(Hash) {}

MacroDefined(

&MacroNameTok,

(

*ND = dyn_cast<NamedDecl>(

)) {

(

*EnumD = dyn_cast<EnumDecl>(

)) {

(!EnumD->isScoped()) {

(

*EI : EnumD->enumerators()) {

(EI->getIdentifier())

Hash = llvm::djbHash(EI->getIdentifier()->getName(), Hash);

(ND->getIdentifier())

Hash = llvm::djbHash(ND->getIdentifier()->getName(), Hash);

std::string NameStr = Name.getAsString();

Hash = llvm::djbHash(NameStr, Hash);

(

*ImportD = dyn_cast<ImportDecl>(

)) {

(

*Mod = ImportD->getImportedModule()) {

std::string ModName = Mod->getFullModuleName();

Hash = llvm::djbHash(ModName, Hash);

TopLevelDeclTrackerConsumer :

{

TopLevelDeclTrackerConsumer(

&_Unit,

&Hash)

: Unit(_Unit), Hash(Hash) {

handleTopLevelDecl(

*

) {

(isa<ObjCMethodDecl>(

))

handleFileLevelDecl(

);

handleFileLevelDecl(

*

) {

(

*NSD = dyn_cast<NamespaceDecl>(

)) {

(

*I : NSD->decls())

handleFileLevelDecl(I);

(

*TopLevelDecl :

)

handleTopLevelDecl(TopLevelDecl);

HandleTopLevelDeclInObjCContainer(

)

{

(

*TopLevelDecl :

)

handleTopLevelDecl(TopLevelDecl);

StringRef InFile)

{

std::make_unique<MacroDefinitionTrackerPPCallbacks>(

std::make_unique<TopLevelDeclTrackerConsumer>(

TopLevelDeclTrackerAction(

&_Unit) : Unit(_Unit) {}

hasCodeCompletionSupport()

{

; }

getHash()

{

Hash; }

std::vector<Decl *> takeTopLevelDecls() {

std::move(TopLevelDecls); }

std::vector<LocalDeclID> takeTopLevelDeclIDs() {

std::move(TopLevelDeclIDs);

AfterPCHEmitted(

&Writer)

{

TopLevelDeclIDs.reserve(TopLevelDecls.size());

(

*

: TopLevelDecls) {

TopLevelDeclIDs.push_back(Writer.

(

));

(

*

: DG) {

(isa<ObjCMethodDecl>(

))

TopLevelDecls.push_back(

);

std::unique_ptr<PPCallbacks> createPPCallbacks()

{

std::make_unique<MacroDefinitionTrackerPPCallbacks>(Hash);

std::vector<Decl *> TopLevelDecls;

std::vector<LocalDeclID> TopLevelDeclIDs;

(

&SD : StoredDiagnostics) {

(SD.getLocation().isValid()) {

SD.setLocation(

);

ASTUnit::Parse(std::shared_ptr<PCHContainerOperations> PCHContainerOps,

std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer,

assert(VFS == &FileMgr->getVirtualFileSystem() &&

);

CCInvocation = std::make_shared<CompilerInvocation>(*Invocation);

(OverrideMainBuffer) {

);

Preamble->AddImplicitPreamble(*CCInvocation, VFS, OverrideMainBuffer.get());

std::unique_ptr<CompilerInstance> Clang(

Clang->setInvocation(CCInvocation);

CleanOnError = llvm::make_scope_exit([&]() {

SavedMainFileBuffer =

;

transferASTDataFromCompilerInstance(*Clang);

FailedParseDiagnostics.swap(StoredDiagnostics);

StoredDiagnostics.clear();

NumStoredDiagnosticsFromDriver = 0;

(VFS && FileMgr && &FileMgr->getVirtualFileSystem() ==

)

Clang->setFileManager(&*FileMgr);

FileMgr = Clang->createFileManager(std::move(VFS));

llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>

CICleanup(Clang.get());

OriginalSourceFile =

std::string(Clang->getFrontendOpts().Inputs[0].getFile());

(!Clang->createTarget())

assert(Clang->getFrontendOpts().Inputs.size() == 1 &&

);

assert(Clang->getFrontendOpts().Inputs[0].getKind().getFormat() ==

);

assert(Clang->getFrontendOpts().Inputs[0].getKind().getLanguage() !=

);

LangOpts = Clang->getInvocation().LangOpts;

FileSystemOpts = Clang->getFileSystemOpts();

UserFilesAreVolatile);

(!OverrideMainBuffer) {

TopLevelDeclsInPreamble.clear();

(OverrideMainBuffer) {

SavedMainFileBuffer = std::move(OverrideMainBuffer);

std::unique_ptr<TopLevelDeclTrackerAction> Act(

TopLevelDeclTrackerAction(*

));

llvm::CrashRecoveryContextCleanupRegistrar<TopLevelDeclTrackerAction>

ActCleanup(Act.get());

(!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0]))

(SavedMainFileBuffer)

PreambleDiagnostics, StoredDiagnostics);

PreambleSrcLocCache.clear();

(llvm::Error Err = Act->Execute()) {

consumeError(std::move(Err));

transferASTDataFromCompilerInstance(*Clang);

Act->EndSourceFile();

FailedParseDiagnostics.clear();

CleanOnError.release();

std::pair<unsigned, unsigned>

Offset =

.getFileOffset(FileRange.

());

EndOffset =

.getFileOffset(FileRange.

());

std::make_pair(Offset, EndOffset);

OutDiag.

= InDiag.

();

OutDiag.

= std::string(

.getFilename(FileLoc));

(

&FixIt : InDiag.

())

std::unique_ptr<llvm::MemoryBuffer>

ASTUnit::getMainBufferWithPrecompiledPreamble(

std::shared_ptr<PCHContainerOperations> PCHContainerOps,

MaxLines) {

std::unique_ptr<llvm::MemoryBuffer> MainFileBuffer =

MainFilePath, UserFilesAreVolatile);

(!MainFileBuffer)

PreambleInvocationIn.

(), *MainFileBuffer, MaxLines);

(Preamble->CanReuse(PreambleInvocationIn, *MainFileBuffer, Bounds,

PreambleRebuildCountdown = 1;

MainFileBuffer;

PreambleDiagnostics.clear();

TopLevelDeclsInPreamble.clear();

PreambleSrcLocCache.clear();

PreambleRebuildCountdown = 1;

(PreambleRebuildCountdown > 1) {

--PreambleRebuildCountdown;

assert(!Preamble &&

);

ASTUnitPreambleCallbacks Callbacks;

std::optional<CaptureDroppedDiagnostics>

;

.emplace(CaptureDiagnostics, *Diagnostics, &NewPreambleDiags,

&NewPreambleDiagsStandalone);

SimpleTimer PreambleTimer(WantTiming);

PreambleTimer.setOutput(

);

PreviousSkipFunctionBodies =

PreambleInvocationIn, MainFileBuffer.get(), Bounds, *Diagnostics, VFS,

PCHContainerOps, StorePreamblesInMemory, PreambleStoragePath,

PreviousSkipFunctionBodies;

Preamble = std::move(*NewPreamble);

PreambleRebuildCountdown = 1;

PreambleRebuildCountdown = 1;

llvm_unreachable(

);

assert(Preamble &&

);

TopLevelDecls.clear();

TopLevelDeclsInPreamble = Callbacks.takeTopLevelDeclIDs();

PreambleTopLevelHashValue = Callbacks.getHash();

StoredDiagnostics = std::move(NewPreambleDiags);

PreambleDiagnostics = std::move(NewPreambleDiagsStandalone);

(CurrentTopLevelHashValue != PreambleTopLevelHashValue) {

CompletionCacheTopLevelHashValue = 0;

PreambleTopLevelHashValue = CurrentTopLevelHashValue;

MainFileBuffer;

ASTUnit::RealizeTopLevelDeclsFromPreamble() {

assert(Preamble &&

);

std::vector<Decl *> Resolved;

Resolved.reserve(TopLevelDeclsInPreamble.size());

(

TopLevelDecl : TopLevelDeclsInPreamble) {

(

*

= Reader->GetLocalDecl(MF, TopLevelDecl))

Resolved.push_back(

);

TopLevelDeclsInPreamble.clear();

TopLevelDecls.insert(TopLevelDecls.begin(), Resolved.begin(), Resolved.end());

(Invocation && !Invocation->getFrontendOpts().Inputs.empty()) {

Input.

().getBufferIdentifier();

FE->getName();

Mod = Reader->getModuleManager().getPrimaryModule();

std::unique_ptr<ASTUnit>

UserFilesAreVolatile) {

std::unique_ptr<ASTUnit> AST(

(

));

ConfigureDiags(Diags, *AST, CaptureDiagnostics);

AST->Diagnostics = Diags;

AST->FileSystemOpts = CI->getFileSystemOpts();

AST->Invocation = std::move(CI);

AST->FileMgr =

(AST->FileSystemOpts, VFS);

AST->UserFilesAreVolatile = UserFilesAreVolatile;

AST->SourceMgr =

(AST->getDiagnostics(), *AST->FileMgr,

UserFilesAreVolatile);

std::shared_ptr<CompilerInvocation> CI,

std::shared_ptr<PCHContainerOperations> PCHContainerOps,

*Unit,

Persistent, StringRef ResourceFilesPath,

PrecompilePreambleAfterNParses,

CacheCodeCompletionResults,

UserFilesAreVolatile, std::unique_ptr<ASTUnit> *ErrAST) {

assert(CI &&

);

std::unique_ptr<ASTUnit> OwnAST;

OwnAST =

(CI, Diags, CaptureDiagnostics, UserFilesAreVolatile);

(!ResourceFilesPath.empty()) {

AST->OnlyLocalDecls = OnlyLocalDecls;

AST->CaptureDiagnostics = CaptureDiagnostics;

(PrecompilePreambleAfterNParses > 0)

AST->PreambleRebuildCountdown = PrecompilePreambleAfterNParses;

AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults;

AST->IncludeBriefCommentsInCodeCompletion =

;

llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>

ASTUnitCleanup(OwnAST.get());

llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine>>

DiagCleanup(Diags.get());

CI->getPreprocessorOpts().RetainRemappedFileBuffers =

;

CI->getFrontendOpts().DisableFree =

;

std::unique_ptr<CompilerInstance> Clang(

llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>

CICleanup(Clang.get());

Clang->setInvocation(std::move(CI));

AST->OriginalSourceFile =

std::string(Clang->getFrontendOpts().Inputs[0].getFile());

(!Clang->createTarget())

assert(Clang->getFrontendOpts().Inputs.size() == 1 &&

);

assert(Clang->getFrontendOpts().Inputs[0].getKind().getFormat() ==

);

assert(Clang->getFrontendOpts().Inputs[0].getKind().getLanguage() !=

);

AST->TheSema.reset();

AST->Ctx =

;

AST->Reader =

;

std::unique_ptr<TopLevelDeclTrackerAction> TrackerAct;

TrackerAct.reset(

TopLevelDeclTrackerAction(*AST));

Act = TrackerAct.get();

llvm::CrashRecoveryContextCleanupRegistrar<TopLevelDeclTrackerAction>

ActCleanup(TrackerAct.get());

(!Act->

(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) {

AST->transferASTDataFromCompilerInstance(*Clang);

(OwnAST && ErrAST)

ErrAST->swap(OwnAST);

(Persistent && !TrackerAct) {

Clang->getPreprocessor().addPPCallbacks(

std::make_unique<MacroDefinitionTrackerPPCallbacks>(

std::vector<std::unique_ptr<ASTConsumer>> Consumers;

(Clang->hasASTConsumer())

Consumers.push_back(Clang->takeASTConsumer());

Consumers.push_back(std::make_unique<TopLevelDeclTrackerConsumer>(

Clang->setASTConsumer(

std::make_unique<MultiplexConsumer>(std::move(Consumers)));

(llvm::Error Err = Act->

()) {

consumeError(std::move(Err));

AST->transferASTDataFromCompilerInstance(*Clang);

(OwnAST && ErrAST)

ErrAST->swap(OwnAST);

AST->transferASTDataFromCompilerInstance(*Clang);

OwnAST.release();

ASTUnit::LoadFromCompilerInvocation(

std::shared_ptr<PCHContainerOperations> PCHContainerOps,

PrecompilePreambleAfterNParses,

assert(VFS &&

);

Invocation->getPreprocessorOpts().RetainRemappedFileBuffers =

;

Invocation->getFrontendOpts().DisableFree =

;

std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer;

(PrecompilePreambleAfterNParses > 0) {

PreambleRebuildCountdown = PrecompilePreambleAfterNParses;

OverrideMainBuffer =

getMainBufferWithPrecompiledPreamble(PCHContainerOps, *Invocation, VFS);

SimpleTimer ParsingTimer(WantTiming);

llvm::CrashRecoveryContextCleanupRegistrar<llvm::MemoryBuffer>

MemBufferCleanup(OverrideMainBuffer.get());

Parse(std::move(PCHContainerOps), std::move(OverrideMainBuffer), VFS);

std::unique_ptr<ASTUnit> ASTUnit::LoadFromCompilerInvocation(

std::shared_ptr<CompilerInvocation> CI,

std::shared_ptr<PCHContainerOperations> PCHContainerOps,

CacheCodeCompletionResults,

IncludeBriefCommentsInCodeCompletion,

UserFilesAreVolatile) {

std::unique_ptr<ASTUnit> AST(

(

));

ConfigureDiags(Diags, *AST, CaptureDiagnostics);

AST->Diagnostics = Diags;

AST->OnlyLocalDecls = OnlyLocalDecls;

AST->CaptureDiagnostics = CaptureDiagnostics;

AST->TUKind = TUKind;

AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults;

AST->IncludeBriefCommentsInCodeCompletion

= IncludeBriefCommentsInCodeCompletion;

AST->Invocation = std::move(CI);

AST->FileMgr = FileMgr;

AST->UserFilesAreVolatile = UserFilesAreVolatile;

llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>

ASTUnitCleanup(AST.get());

llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine>>

DiagCleanup(Diags.get());

(AST->LoadFromCompilerInvocation(std::move(PCHContainerOps),

PrecompilePreambleAfterNParses,

&AST->FileMgr->getVirtualFileSystem()))

**ArgBegin,

**ArgEnd,

std::shared_ptr<PCHContainerOperations> PCHContainerOps,

StorePreamblesInMemory, StringRef PreambleStoragePath,

CacheCodeCompletionResults,

IncludeBriefCommentsInCodeCompletion,

SingleFileParse,

UserFilesAreVolatile,

ForSerialization,

RetainExcludedConditionalBlocks, std::optional<StringRef> ModuleFormat,

std::unique_ptr<ASTUnit> *ErrAST,

assert(Diags.get() &&

);

VFS = llvm::vfs::createPhysicalFileSystem();

std::shared_ptr<CompilerInvocation> CI;

CaptureDroppedDiagnostics

(CaptureDiagnostics, *Diags,

&StoredDiagnostics,

);

CIOpts.

= Diags;

CI->getPreprocessorOpts().addRemappedFile(

.first,

CI->getHeaderSearchOpts().ResourceDir = std::string(ResourceFilesPath);

CI->getFrontendOpts().SkipFunctionBodies =

CI->getHeaderSearchOpts().ModuleFormat = std::string(*ModuleFormat);

std::unique_ptr<ASTUnit> AST;

AST.reset(

(

));

AST->NumStoredDiagnosticsFromDriver = StoredDiagnostics.size();

AST->StoredDiagnostics.swap(StoredDiagnostics);

ConfigureDiags(Diags, *AST, CaptureDiagnostics);

AST->Diagnostics = Diags;

AST->FileSystemOpts = CI->getFileSystemOpts();

AST->FileMgr =

(AST->FileSystemOpts, VFS);

AST->StorePreamblesInMemory = StorePreamblesInMemory;

AST->PreambleStoragePath = PreambleStoragePath;

AST->OnlyLocalDecls = OnlyLocalDecls;

AST->CaptureDiagnostics = CaptureDiagnostics;

AST->TUKind = TUKind;

AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults;

AST->IncludeBriefCommentsInCodeCompletion

= IncludeBriefCommentsInCodeCompletion;

AST->UserFilesAreVolatile = UserFilesAreVolatile;

AST->Invocation = CI;

AST->SkipFunctionBodies = SkipFunctionBodies;

(ForSerialization)

AST->WriterData.reset(

(*AST->ModuleCache));

llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>

ASTUnitCleanup(AST.get());

(AST->LoadFromCompilerInvocation(std::move(PCHContainerOps),

PrecompilePreambleAfterNParses,

AST->StoredDiagnostics.swap(AST->FailedParseDiagnostics);

assert(FileMgr &&

);

VFS = &FileMgr->getVirtualFileSystem();

clearFileLevelDecls();

SimpleTimer ParsingTimer(WantTiming);

Invocation->getPreprocessorOpts().clearRemappedFiles();

Invocation->getPreprocessorOpts().addRemappedFile(

.first,

std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer;

(Preamble || PreambleRebuildCountdown > 0)

OverrideMainBuffer =

getMainBufferWithPrecompiledPreamble(PCHContainerOps, *Invocation, VFS);

(OverrideMainBuffer)

Parse(std::move(PCHContainerOps), std::move(OverrideMainBuffer), VFS);

(!

&& ShouldCacheCodeCompletionResults &&

CurrentTopLevelHashValue != CompletionCacheTopLevelHashValue)

CacheCodeCompletionResults();

SavedMainFileBuffer.reset();

TopLevelDecls.clear();

clearFileLevelDecls();

uint64_t NormalContexts;

NumResults)

;

ProcessOverloadCandidates(

&S,

CurrentArg,

NumCandidates,

Braced)

{

Next.ProcessOverloadCandidates(S, CurrentArg, Candidates, NumCandidates,

OpenParLoc, Braced);

Next.getAllocator();

Next.getCodeCompletionTUInfo();

NumResults,

llvm::StringSet<llvm::BumpPtrAllocator> &HiddenNames){

OnlyTagNames =

;

(Context.getKind()) {

OnlyTagNames =

;

(

I = 0; I != NumResults; ++I) {

(Results[I].Kind != Result::RK_Declaration)

= Results[I].Declaration->getUnderlyingDecl()->getIdentifierNamespace();

Hiding =

;

Hiding = (IDNS & HiddenIDNS);

HiddenNames.insert(Name.getAsString());

AugmentedCodeCompleteConsumer::ProcessCodeCompleteResults(

&S,

NumResults) {

AddedResult =

;

? NormalContexts : (1LL << Context.getKind());

llvm::StringSet<llvm::BumpPtrAllocator> HiddenNames;

((

->ShowInContexts & InContexts) == 0)

AllResults.insert(AllResults.end(), Results, Results + NumResults);

AddedResult =

;

HiddenNames.count(

->Completion->getTypedText()))

(!Context.getPreferredType().isNull()) {

Context.getPreferredType()->isAnyPointerType());

}

(

->Type) {

Context.getPreferredType().getUnqualifiedType());

(ExpectedSTC ==

->TypeClass) {

llvm::StringMap<unsigned> &CachedCompletionTypes

llvm::StringMap<unsigned>::iterator Pos

(Pos != CachedCompletionTypes.end() && Pos->second ==

->Type)

Builder.AddTypedTextChunk(

->Completion->getTypedText());

Completion = Builder.TakeString();

AllResults.push_back(

(Completion, Priority,

->Kind,

Next.ProcessCodeCompleteResults(S, Context, Results, NumResults);

Next.ProcessCodeCompleteResults(S, Context, AllResults.data(),

IncludeCodePatterns,

IncludeBriefComments,

std::shared_ptr<PCHContainerOperations> PCHContainerOps,

std::unique_ptr<SyntaxOnlyAction> Act) {

SimpleTimer CompletionTimer(WantTiming);

CompletionTimer.setOutput(

+

+

+

CCInvocation = std::make_shared<CompilerInvocation>(*Invocation);

CachedCompletionResults.empty();

CodeCompleteOpts.

= CachedCompletionResults.empty();

assert(IncludeBriefComments == this->IncludeBriefCommentsInCodeCompletion);

LangOpts = CCInvocation->getLangOpts();

LangOpts.SpellChecking =

;

CCInvocation->getDiagnosticOpts().IgnoreWarnings =

;

std::unique_ptr<CompilerInstance> Clang(

llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>

CICleanup(Clang.get());

&Inv = *CCInvocation;

Clang->setInvocation(std::move(CCInvocation));

OriginalSourceFile =

std::string(Clang->getFrontendOpts().Inputs[0].getFile());

Clang->setDiagnostics(&

);

Clang->getDiagnostics(),

&StoredDiagnostics,

);

(!Clang->createTarget()) {

Clang->setInvocation(

);

assert(Clang->getFrontendOpts().Inputs.size() == 1 &&

);

assert(Clang->getFrontendOpts().Inputs[0].getKind().getFormat() ==

);

assert(Clang->getFrontendOpts().Inputs[0].getKind().getLanguage() !=

);

Clang->setFileManager(&FileMgr);

Clang->setSourceManager(&SourceMgr);

AugmentedCodeCompleteConsumer *AugmentedConsumer

=

AugmentedCodeCompleteConsumer(*

, Consumer, CodeCompleteOpts);

Clang->setCodeCompletionConsumer(AugmentedConsumer);

[&FileMgr](StringRef

) -> std::optional<llvm::sys::fs::UniqueID> {

Status->getUniqueID();

std::nullopt;

hasSameUniqueID = [getUniqueID](StringRef LHS, StringRef RHS) {

(

LHSID = getUniqueID(LHS))

(

RHSID = getUniqueID(RHS))

*LHSID == *RHSID;

std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer;

(Preamble &&

> 1 && hasSameUniqueID(

, OriginalSourceFile)) {

OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(

(OverrideMainBuffer) {

);

Preamble->AddImplicitPreamble(Clang->getInvocation(), VFS,

OverrideMainBuffer.get());

OwnedBuffers.push_back(OverrideMainBuffer.release());

(!Clang->getLangOpts().Modules)

(Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) {

(llvm::Error Err = Act->Execute()) {

consumeError(std::move(Err));

Act->EndSourceFile();

(HadModuleLoaderFatalFailure)

(llvm::Error Err = llvm::writeToOutput(

, [

](llvm::raw_ostream &Out) {

(Out) ? llvm::make_error<llvm::StringError>(

,

llvm::inconvertibleErrorCode())

: llvm::Error::success();

consumeError(std::move(Err));

&S, raw_ostream &OS) {

Writer.

(&S, std::string(),

,

);

(!Buffer.empty())

OS.write(Buffer.data(), Buffer.size());

llvm::BitstreamWriter Stream(Buffer);

Writer(Stream, Buffer, ModuleCache, {});

ASTUnit::TranslateStoredDiagnostics(

.reserve(Diags.size());

(

&SD : Diags) {

(SD.Filename.empty())

ItFileID = PreambleSrcLocCache.find(SD.Filename);

(ItFileID == PreambleSrcLocCache.end()) {

PreambleSrcLocCache[SD.Filename] = FileLoc;

FileLoc = ItFileID->getValue();

Ranges.reserve(SD.Ranges.size());

(

&

: SD.Ranges) {

FixIts.reserve(SD.FixIts.size());

(

&FixIt : SD.FixIts) {

SD.Message,

, Ranges, FixIts));

assert(

.isLocalSourceLocation(FileLoc));

std::tie(FID, Offset) =

.getDecomposedLoc(FileLoc);

std::unique_ptr<LocDeclsTy> &Decls = FileDecls[FID];

Decls = std::make_unique<LocDeclsTy>();

std::pair<unsigned, Decl *> LocDecl(Offset,

);

(Decls->empty() || Decls->back().first <= Offset) {

Decls->push_back(LocDecl);

LocDeclsTy::iterator I =

llvm::upper_bound(*Decls, LocDecl, llvm::less_first());

Decls->insert(I, LocDecl);

(

.isInvalid())

assert(Ctx->getExternalSource() &&

);

Ctx->getExternalSource()->FindFileRegionDecls(

, Offset, Length,

FileDeclsTy::iterator I = FileDecls.find(

);

(I == FileDecls.end())

(LocDecls.empty())

LocDeclsTy::iterator BeginIt =

llvm::partition_point(LocDecls, [=](std::pair<unsigned, Decl *> LD) {

LD.first < Offset;

(BeginIt != LocDecls.begin())

(BeginIt != LocDecls.begin() &&

BeginIt->second->isTopLevelDeclInObjCContainer())

LocDeclsTy::iterator EndIt = llvm::upper_bound(

LocDecls, std::make_pair(Offset + Length, (

*)

),

llvm::less_first());

(EndIt != LocDecls.end())

(LocDeclsTy::iterator DIt = BeginIt; DIt != EndIt; ++DIt)

Decls.push_back(DIt->second);

,

Col)

{

.getMacroArgExpandedLocation(

);

Offset)

{

(SourceMgr->

(

, PreambleID, &Offs) && Offs < Preamble->getBounds().Size) {

Offs < Preamble->getBounds().Size) {

llvm::iterator_range<PreprocessingRecord::iterator>

Mod = Reader->getModuleManager().getPrimaryModule();

Reader->getModulePreprocessedEntities(Mod);

llvm::make_range(PPRec->local_begin(), PPRec->local_end());

Mod = Reader->getModuleManager().getPrimaryModule();

(

*

: Reader->getModuleFileLevelDecls(Mod)) {

(!Fn(context,

))

TL != TLEnd; ++TL) {

(!Fn(context, *TL))

std::nullopt;

case serialization::MK_ImplicitModule:

case serialization::MK_ExplicitModule:

case serialization::MK_PrebuiltModule:

case serialization::MK_PCH:

case serialization::MK_Preamble:

case serialization::MK_MainFile:

std::nullopt;

(LangOpts.OpenCL)

(LangOpts.CUDA)

(LangOpts.CPlusPlus)

ASTUnit::ConcurrencyState::ConcurrencyState() {

Mutex =

std::recursive_mutex;

ASTUnit::ConcurrencyState::~ConcurrencyState() {

std::recursive_mutex *

(Mutex);

ASTUnit::ConcurrencyState::start() {

acquired =

std::recursive_mutex *

(Mutex)->try_lock();

assert(acquired &&

);

ASTUnit::ConcurrencyState::finish() {

std::recursive_mutex *

(Mutex)->unlock();

ASTUnit::ConcurrencyState::ConcurrencyState() { Mutex =

; }

ASTUnit::ConcurrencyState::~ConcurrencyState() {}

ASTUnit::ConcurrencyState::start() {}

ASTUnit::ConcurrencyState::finish() {}

Defines the clang::ASTContext interface.

static void checkAndSanitizeDiags(SmallVectorImpl< StoredDiagnostic > &StoredDiagnostics, SourceManager &SM)

static void CalculateHiddenNames(const CodeCompletionContext &Context, CodeCompletionResult *Results, unsigned NumResults, ASTContext &Ctx, llvm::StringSet< llvm::BumpPtrAllocator > &HiddenNames)

Helper function that computes which global names are hidden by the local code-completion results.

static uint64_t getDeclShowContexts(const NamedDecl *ND, const LangOptions &LangOpts, bool &IsNestedNameSpecifier)

Determine the set of code-completion contexts in which this declaration should be shown.

static void AddTopLevelDeclarationToHash(Decl *D, unsigned &Hash)

Add the given declaration to the hash of all top-level entities.

static bool moveOnNoError(llvm::ErrorOr< T > Val, T &Output)

static std::unique_ptr< T > valueOrNull(llvm::ErrorOr< std::unique_ptr< T > > Val)

static std::pair< unsigned, unsigned > makeStandaloneRange(CharSourceRange Range, const SourceManager &SM, const LangOptions &LangOpts)

static bool serializeUnit(ASTWriter &Writer, SmallVectorImpl< char > &Buffer, Sema &S, raw_ostream &OS)

static std::unique_ptr< llvm::MemoryBuffer > getBufferForFileHandlingRemapping(const CompilerInvocation &Invocation, llvm::vfs::FileSystem *VFS, StringRef FilePath, bool isVolatile)

Get a source buffer for MainFilePath, handling all file-to-file and file-to-buffer remappings inside ...

const unsigned DefaultPreambleRebuildInterval

After failing to build a precompiled preamble (due to errors in the source that occurs in the preambl...

static void checkAndRemoveNonDriverDiags(SmallVectorImpl< StoredDiagnostic > &StoredDiags)

static bool isInMainFile(const clang::Diagnostic &D)

static ASTUnit::StandaloneDiagnostic makeStandaloneDiagnostic(const LangOptions &LangOpts, const StoredDiagnostic &InDiag)

static bool isNonDriverDiag(const StoredDiagnostic &StoredDiag)

static std::atomic< unsigned > ActiveASTUnitObjects

Tracks the number of ASTUnit objects that are currently active.

static ASTUnit::StandaloneFixIt makeStandaloneFixIt(const SourceManager &SM, const LangOptions &LangOpts, const FixItHint &InFix)

static void AddDefinedMacroToHash(const Token &MacroNameTok, unsigned &Hash)

Add the given macro to the hash of all top-level entities.

Defines the Diagnostic-related interfaces.

Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....

Defines the C++ template declaration subclasses.

Defines the clang::FileManager interface and associated types.

Defines the clang::FrontendAction interface and various convenience abstract classes (clang::ASTFront...

Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.

Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.

Defines the clang::LangOptions interface.

static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)

Produce a diagnostic highlighting some portion of a literal.

llvm::MachO::Target Target

llvm::MachO::Record Record

Defines the clang::Module class, which describes a module in the source code.

Defines the PPCallbacks interface.

Defines the clang::Preprocessor interface.

This file declares facilities that support code completion.

Defines the clang::SourceLocation class and associated facilities.

Defines the SourceManager interface.

Defines the clang::TargetOptions class.

Allows QualTypes to be sorted and hence used in maps and sets.

C Language Family Type Representation.

ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs.

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

void InitBuiltinTypes(const TargetInfo &Target, const TargetInfo *AuxTarget=nullptr)

Initialize built-in types.

CanQualType getCanonicalType(QualType T) const

Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...

comments::CommandTraits & getCommentCommandTraits() const

const LangOptions & getLangOpts() const

void setPrintingPolicy(const clang::PrintingPolicy &Policy)

Abstract base class to use for AST consumer-based frontend actions.

An abstract interface that should be implemented by listeners that want to be notified when an AST en...

Abstract interface for callback invocations by the ASTReader.

Reads an AST files chain containing the contents of a translation unit.

@ ARR_None

The client can't handle any AST loading failures.

@ Success

The control block was read successfully.

@ ConfigurationMismatch

The AST file was written with a different language/target configuration.

@ OutOfDate

The AST file is out-of-date relative to its input files, and needs to be regenerated.

@ Failure

The AST file itself appears corrupted.

@ VersionMismatch

The AST file was written by a different version of Clang.

@ HadErrors

The AST file has errors.

@ Missing

The AST file was missing.

Utility class for loading a ASTContext from an AST file.

unsigned & getCurrentTopLevelHashValue()

Retrieve a reference to the current top-level name hash value.

void enableSourceFileDiagnostics()

Enable source-range based diagnostic messages.

void addFileLevelDecl(Decl *D)

Add a new local file-level declaration.

const FileManager & getFileManager() const

void CodeComplete(StringRef File, unsigned Line, unsigned Column, ArrayRef< RemappedFile > RemappedFiles, bool IncludeMacros, bool IncludeCodePatterns, bool IncludeBriefComments, CodeCompleteConsumer &Consumer, std::shared_ptr< PCHContainerOperations > PCHContainerOps, DiagnosticsEngine &Diag, LangOptions &LangOpts, SourceManager &SourceMgr, FileManager &FileMgr, SmallVectorImpl< StoredDiagnostic > &StoredDiagnostics, SmallVectorImpl< const llvm::MemoryBuffer * > &OwnedBuffers, std::unique_ptr< SyntaxOnlyAction > Act)

Perform code completion at the given file, line, and column within this translation unit.

cached_completion_iterator cached_completion_end()

bool serialize(raw_ostream &OS)

Serialize this translation unit with the given output stream.

ASTDeserializationListener * getDeserializationListener()

bool Reparse(std::shared_ptr< PCHContainerOperations > PCHContainerOps, ArrayRef< RemappedFile > RemappedFiles={}, IntrusiveRefCntPtr< llvm::vfs::FileSystem > VFS=nullptr)

Reparse the source files using the same command-line options that were originally used to produce thi...

std::unique_ptr< llvm::MemoryBuffer > getBufferForFile(StringRef Filename, std::string *ErrorStr=nullptr)

llvm::StringMap< unsigned > & getCachedCompletionTypes()

Retrieve the mapping from formatted type names to unique type identifiers.

const DiagnosticsEngine & getDiagnostics() const

SourceLocation getLocation(const FileEntry *File, unsigned Line, unsigned Col) const

Get the source location for the given file:line:col triplet.

void ResetForParse()

Free data that will be re-generated on the next parse.

InputKind getInputKind() const

Determine the input kind this AST unit represents.

OptionalFileEntryRef getPCHFile()

Get the PCH file if one was included.

StringRef getMainFileName() const

SourceLocation mapLocationToPreamble(SourceLocation Loc) const

If Loc is a local location of the main file but inside the preamble chunk, returns the corresponding ...

cached_completion_iterator cached_completion_begin()

const LangOptions & getLangOpts() const

static std::unique_ptr< ASTUnit > LoadFromCommandLine(const char **ArgBegin, const char **ArgEnd, std::shared_ptr< PCHContainerOperations > PCHContainerOps, IntrusiveRefCntPtr< DiagnosticsEngine > Diags, StringRef ResourceFilesPath, bool StorePreamblesInMemory=false, StringRef PreambleStoragePath=StringRef(), bool OnlyLocalDecls=false, CaptureDiagsKind CaptureDiagnostics=CaptureDiagsKind::None, ArrayRef< RemappedFile > RemappedFiles={}, bool RemappedFilesKeepOriginalName=true, unsigned PrecompilePreambleAfterNParses=0, TranslationUnitKind TUKind=TU_Complete, bool CacheCodeCompletionResults=false, bool IncludeBriefCommentsInCodeCompletion=false, bool AllowPCHWithCompilerErrors=false, SkipFunctionBodiesScope SkipFunctionBodies=SkipFunctionBodiesScope::None, bool SingleFileParse=false, bool UserFilesAreVolatile=false, bool ForSerialization=false, bool RetainExcludedConditionalBlocks=false, std::optional< StringRef > ModuleFormat=std::nullopt, std::unique_ptr< ASTUnit > *ErrAST=nullptr, IntrusiveRefCntPtr< llvm::vfs::FileSystem > VFS=nullptr)

LoadFromCommandLine - Create an ASTUnit from a vector of command line arguments, which must specify e...

bool isMainFileAST() const

std::vector< Decl * >::iterator top_level_iterator

const SourceManager & getSourceManager() const

SourceLocation getEndOfPreambleFileID() const

@ LoadASTOnly

Load the AST, but do not restore Sema state.

@ LoadEverything

Load everything, including Sema.

top_level_iterator top_level_end()

SourceLocation getStartOfMainFileID() const

IntrusiveRefCntPtr< ASTReader > getASTReader() const

bool(*)(void *context, const Decl *D) DeclVisitorFn

Type for a function iterating over a number of declarations.

bool visitLocalTopLevelDecls(void *context, DeclVisitorFn Fn)

Iterate over local declarations (locally parsed if this is a parsed source file or the loaded declara...

llvm::iterator_range< PreprocessingRecord::iterator > getLocalPreprocessingEntities() const

Returns an iterator range for the local preprocessing entities of the local Preprocessor,...

top_level_iterator top_level_begin()

std::vector< CachedCodeCompletionResult >::iterator cached_completion_iterator

ASTMutationListener * getASTMutationListener()

static std::unique_ptr< ASTUnit > LoadFromASTFile(StringRef Filename, const PCHContainerReader &PCHContainerRdr, WhatToLoad ToLoad, IntrusiveRefCntPtr< DiagnosticsEngine > Diags, const FileSystemOptions &FileSystemOpts, std::shared_ptr< HeaderSearchOptions > HSOpts, std::shared_ptr< LangOptions > LangOpts=nullptr, bool OnlyLocalDecls=false, CaptureDiagsKind CaptureDiagnostics=CaptureDiagsKind::None, bool AllowASTWithCompilerErrors=false, bool UserFilesAreVolatile=false, IntrusiveRefCntPtr< llvm::vfs::FileSystem > VFS=llvm::vfs::getRealFileSystem())

Create a ASTUnit from an AST file.

TranslationUnitKind getTranslationUnitKind() const

Determine what kind of translation unit this AST represents.

void setPreprocessor(std::shared_ptr< Preprocessor > pp)

StringRef getASTFileName() const

If this ASTUnit came from an AST file, returns the filename for it.

bool Save(StringRef File)

Save this translation unit to a file with the given name.

static std::unique_ptr< ASTUnit > create(std::shared_ptr< CompilerInvocation > CI, IntrusiveRefCntPtr< DiagnosticsEngine > Diags, CaptureDiagsKind CaptureDiagnostics, bool UserFilesAreVolatile)

Create a ASTUnit. Gets ownership of the passed CompilerInvocation.

const HeaderSearchOptions & getHeaderSearchOpts() const

void addTopLevelDecl(Decl *D)

Add a new top-level declaration.

static ASTUnit * LoadFromCompilerInvocationAction(std::shared_ptr< CompilerInvocation > CI, std::shared_ptr< PCHContainerOperations > PCHContainerOps, IntrusiveRefCntPtr< DiagnosticsEngine > Diags, FrontendAction *Action=nullptr, ASTUnit *Unit=nullptr, bool Persistent=true, StringRef ResourceFilesPath=StringRef(), bool OnlyLocalDecls=false, CaptureDiagsKind CaptureDiagnostics=CaptureDiagsKind::None, unsigned PrecompilePreambleAfterNParses=0, bool CacheCodeCompletionResults=false, bool UserFilesAreVolatile=false, std::unique_ptr< ASTUnit > *ErrAST=nullptr)

Create an ASTUnit from a source file, via a CompilerInvocation object, by invoking the optionally pro...

bool isInMainFileID(SourceLocation Loc) const

bool isModuleFile() const

Returns true if the ASTUnit was constructed from a serialized module file.

void findFileRegionDecls(FileID File, unsigned Offset, unsigned Length, SmallVectorImpl< Decl * > &Decls)

Get the decls that are contained in a file in the Offset/Length range.

const ASTContext & getASTContext() const

bool isInPreambleFileID(SourceLocation Loc) const

SourceLocation mapLocationFromPreamble(SourceLocation Loc) const

If Loc is a loaded location from the preamble, returns the corresponding local location of the main f...

std::pair< std::string, llvm::MemoryBuffer * > RemappedFile

A mapping from a file name to the memory buffer that stores the remapped contents of that file.

Writes an AST file containing the contents of a translation unit.

LocalDeclID getDeclID(const Decl *D)

Determine the local declaration ID of an already-emitted declaration.

ASTFileSignature WriteAST(llvm::PointerUnion< Sema *, Preprocessor * > Subject, StringRef OutputFile, Module *WritingModule, StringRef isysroot, bool ShouldCacheASTInMemory=false)

Write a precompiled header or a module with the AST produced by the Sema object, or a dependency scan...

Represents a character-granular source range.

static CharSourceRange getCharRange(SourceRange R)

SourceLocation getEnd() const

SourceLocation getBegin() const

Abstract interface for a consumer of code-completion information.

bool includeFixIts() const

Whether to include completion items with small fix-its, e.g.

bool loadExternal() const

Hint whether to load data from the external AST in order to provide full results.

Options controlling the behavior of code completion.

unsigned IncludeCodePatterns

Show code patterns in code completion results.

unsigned IncludeFixIts

Include results after corrections (small fix-its), e.g.

unsigned LoadExternal

Hint whether to load data from the external AST to provide full results.

unsigned IncludeMacros

Show macros in code completion results.

unsigned IncludeBriefComments

Show brief documentation comments in code completion results.

unsigned IncludeGlobals

Show top-level decls in code completion results.

An allocator used specifically for the purpose of code completion.

A builder class used to construct new code-completion strings.

The context in which code completion occurred, so that the code-completion consumer can process the r...

@ CCC_TypeQualifiers

Code completion within a type-qualifier list.

@ CCC_ObjCMessageReceiver

Code completion occurred where an Objective-C message receiver is expected.

@ CCC_PreprocessorExpression

Code completion occurred within a preprocessor expression.

@ CCC_ObjCCategoryName

Code completion where an Objective-C category name is expected.

@ CCC_ObjCIvarList

Code completion occurred within the instance variable list of an Objective-C interface,...

@ CCC_Statement

Code completion occurred where a statement (or declaration) is expected in a function,...

@ CCC_Type

Code completion occurred where a type name is expected.

@ CCC_ArrowMemberAccess

Code completion occurred on the right-hand side of a member access expression using the arrow operato...

@ CCC_ClassStructUnion

Code completion occurred within a class, struct, or union.

@ CCC_ObjCInterface

Code completion occurred within an Objective-C interface, protocol, or category interface.

@ CCC_ObjCPropertyAccess

Code completion occurred on the right-hand side of an Objective-C property access expression.

@ CCC_Expression

Code completion occurred where an expression is expected.

@ CCC_SelectorName

Code completion for a selector, as in an @selector expression.

@ CCC_TopLevelOrExpression

Code completion at a top level, i.e.

@ CCC_EnumTag

Code completion occurred after the "enum" keyword, to indicate an enumeration name.

@ CCC_UnionTag

Code completion occurred after the "union" keyword, to indicate a union name.

@ CCC_ParenthesizedExpression

Code completion in a parenthesized expression, which means that we may also have types here in C and ...

@ CCC_TopLevel

Code completion occurred within a "top-level" completion context, e.g., at namespace or global scope.

@ CCC_ClassOrStructTag

Code completion occurred after the "struct" or "class" keyword, to indicate a struct or class name.

@ CCC_ObjCClassMessage

Code completion where an Objective-C class message is expected.

@ CCC_ObjCImplementation

Code completion occurred within an Objective-C implementation or category implementation.

@ CCC_IncludedFile

Code completion inside the filename part of a #include directive.

@ CCC_ObjCInstanceMessage

Code completion where an Objective-C instance message is expected.

@ CCC_SymbolOrNewName

Code completion occurred where both a new name and an existing symbol is permissible.

@ CCC_Recovery

An unknown context, in which we are recovering from a parsing error and don't know which completions ...

@ CCC_ObjCProtocolName

Code completion occurred where a protocol name is expected.

@ CCC_OtherWithMacros

An unspecified code-completion context where we should also add macro completions.

@ CCC_NewName

Code completion occurred where a new name is expected.

@ CCC_MacroNameUse

Code completion occurred where a macro name is expected (without any arguments, in the case of a func...

@ CCC_Symbol

Code completion occurred where an existing name(such as type, function or variable) is expected.

@ CCC_Attribute

Code completion of an attribute name.

@ CCC_Other

An unspecified code-completion context.

@ CCC_DotMemberAccess

Code completion occurred on the right-hand side of a member access expression using the dot operator.

@ CCC_MacroName

Code completion occurred where an macro is being defined.

@ CCC_Namespace

Code completion occurred where a namespace or namespace alias is expected.

@ CCC_PreprocessorDirective

Code completion occurred where a preprocessor directive is expected.

@ CCC_NaturalLanguage

Code completion occurred in a context where natural language is expected, e.g., a comment or string l...

@ CCC_ObjCInterfaceName

Code completion where the name of an Objective-C class is expected.

@ CCC_ObjCClassForwardDecl

Captures a result of code completion.

A "string" used to describe how code completion can be performed for an entity.

CompilerInstance - Helper class for managing a single instance of the Clang compiler.

void setFileManager(FileManager *Value)

Replace the current file manager and virtual file system.

void setSourceManager(SourceManager *Value)

setSourceManager - Replace the current source manager.

std::shared_ptr< Preprocessor > getPreprocessorPtr()

std::unique_ptr< Sema > takeSema()

IntrusiveRefCntPtr< ASTReader > getASTReader() const

bool hasASTContext() const

Preprocessor & getPreprocessor() const

Return the current preprocessor.

ASTContext & getASTContext() const

bool hasInvocation() const

bool hadModuleLoaderFatalFailure() const

CompilerInvocation & getInvocation()

std::unique_ptr< ASTConsumer > takeASTConsumer()

takeASTConsumer - Remove the current AST consumer and give ownership to the caller.

TargetInfo & getTarget() const

bool hasPreprocessor() const

Helper class for holding the data necessary to invoke the compiler.

PreprocessorOptions & getPreprocessorOpts()

LangOptions & getLangOpts()

Mutable getters.

FrontendOptions & getFrontendOpts()

std::shared_ptr< LangOptions > LangOpts

Base class internals.

DiagnosticOptions & getDiagnosticOpts()

DeclContext - This is used only as base class of specific decl types that can act as declaration cont...

bool isFileContext() const

bool isTranslationUnit() const

DeclContext * getLookupParent()

Find the parent context of this context that will be used for unqualified name lookup.

Decl - This represents one declaration (or definition), e.g.

bool isFromASTFile() const

Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...

bool isInvalidDecl() const

SourceLocation getLocation() const

@ IDNS_NonMemberOperator

This declaration is a C++ operator declared in a non-class context.

@ IDNS_Ordinary

Ordinary names.

@ IDNS_Type

Types, declared with 'struct foo', typedefs, etc.

@ IDNS_Member

Members, declared with object declarations within tag definitions.

@ IDNS_Namespace

Namespaces, declared with 'namespace foo {}'.

@ IDNS_Tag

Tags, declared with 'struct foo;' and referenced with 'struct foo'.

DeclContext * getDeclContext()

DeclContext * getLexicalDeclContext()

getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).

The name of a declaration.

Abstract interface, implemented by clients of the front-end, which formats and prints fully processed...

virtual void EndSourceFile()

Callback to inform the diagnostic client that processing of a source file has ended.

virtual void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info)

Handle this diagnostic, reporting it to the user or capturing it to a log as needed.

virtual void BeginSourceFile(const LangOptions &LangOpts, const Preprocessor *PP=nullptr)

Callback to inform the diagnostic client that processing of a source file is beginning.

A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine a...

SourceManager & getSourceManager() const

bool hasSourceManager() const

Concrete class used by the front-end to report problems and issues.

void setNumWarnings(unsigned NumWarnings)

void setClient(DiagnosticConsumer *client, bool ShouldOwnClient=true)

Set the diagnostic client associated with this diagnostic object.

std::unique_ptr< DiagnosticConsumer > takeClient()

Return the current diagnostic client along with ownership of that client.

Level

The level of the diagnostic, after it has been through mapping.

DiagnosticConsumer * getClient()

unsigned getNumWarnings() const

void Reset(bool soft=false)

Reset the state of the diagnostic object to its initial configuration.

Cached information about one file (either on disk or in the virtual file system).

An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...

Implements support for file system lookup, file system caching, and directory search management.

llvm::vfs::FileSystem & getVirtualFileSystem() const

OptionalFileEntryRef getOptionalFileRef(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)

Get a FileEntryRef if it exists, without doing anything on error.

FileSystemOptions & getFileSystemOpts()

Returns the current file system options.

llvm::IntrusiveRefCntPtr< llvm::vfs::FileSystem > getVirtualFileSystemPtr() const

void setVirtualFileSystem(IntrusiveRefCntPtr< llvm::vfs::FileSystem > FS)

Keeps track of options that affect how file operations are performed.

Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...

bool BeforePreviousInsertions

CharSourceRange RemoveRange

Code that should be replaced to correct the error.

CharSourceRange InsertFromRange

Code in the specific range that should be inserted in the insertion location.

std::string CodeToInsert

The actual code to insert at the insertion location, as a string.

Abstract base class for actions which can be performed by the frontend.

virtual void EndSourceFile()

Perform any per-file post processing, deallocate per-file objects, and run statistics and output file...

llvm::Error Execute()

Set the source manager's main input file, and run the action.

virtual TranslationUnitKind getTranslationUnitKind()

For AST-based actions, the kind of translation unit we're handling.

bool BeginSourceFile(CompilerInstance &CI, const FrontendInputFile &Input)

Prepare the action for processing the input file Input.

An input file for the front end.

llvm::MemoryBufferRef getBuffer() const

StringRef getFile() const

FrontendOptions - Options for controlling the behavior of the frontend.

unsigned SkipFunctionBodies

Skip over function bodies to speed up parsing in cases you do not need them (e.g.

CodeCompleteOptions CodeCompleteOpts

ParsedSourceLocation CodeCompletionAt

If given, enable code completion at the provided location.

SmallVector< FrontendInputFile, 0 > Inputs

The input files and their types.

A SourceLocation and its associated SourceManager.

const SourceManager & getManager() const

One of these records is kept for each identifier that is lexed.

StringRef getName() const

Return the actual identifier string.

In-memory cache for modules.

The kind of a file that we've been handed as an input.

Format

The input file format.

@ CMK_ModuleMap

Compiling a module from a module map.

Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...

CommentOptions CommentOpts

Options for parsing comments.

bool isCompilingModule() const

Are we compiling a module?

static CharSourceRange makeFileCharRange(CharSourceRange Range, const SourceManager &SM, const LangOptions &LangOpts)

Accepts a range and returns a character range with file locations.

Encapsulates changes to the "macros namespace" (the location where the macro name became active,...

Describes a module or submodule.

bool isNamedModule() const

Does this Module is a named module of a standard named module?

This represents a decl that may have a name.

NamedDecl * getUnderlyingDecl()

Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.

This abstract interface provides operations for unwrapping containers for serialized ASTs (precompile...

virtual llvm::ArrayRef< llvm::StringRef > getFormats() const =0

Equivalent to the format passed to -fmodule-format=.

This interface provides a way to observe the actions of the preprocessor as it does its thing.

A set of callbacks to gather useful information while building a preamble.

static llvm::ErrorOr< PrecompiledPreamble > Build(const CompilerInvocation &Invocation, const llvm::MemoryBuffer *MainFileBuffer, PreambleBounds Bounds, DiagnosticsEngine &Diagnostics, IntrusiveRefCntPtr< llvm::vfs::FileSystem > VFS, std::shared_ptr< PCHContainerOperations > PCHContainerOps, bool StoreInMemory, StringRef StoragePath, PreambleCallbacks &Callbacks)

Try to build PrecompiledPreamble for Invocation.

Iteration over the preprocessed entities.

A record of the steps taken while preprocessing a source file, including the various preprocessing di...

PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...

std::pair< unsigned, bool > PrecompiledPreambleBytes

If non-zero, the implicit PCH include is actually a precompiled preamble that covers this number of b...

bool RemappedFilesKeepOriginalName

True if the SourceManager should report the original file name for contents of files that were remapp...

bool RetainRemappedFileBuffers

Whether the compiler instance should retain (i.e., not free) the buffers associated with remapped fil...

bool SingleFileParseMode

When enabled, preprocessor is in a mode for parsing a single file only.

bool DetailedRecord

Whether we should maintain a detailed record of all macro definitions and expansions.

bool RetainExcludedConditionalBlocks

When enabled, excluded conditional blocks retain in the main file.

void clearRemappedFiles()

void addRemappedFile(StringRef From, StringRef To)

bool AllowPCHWithCompilerErrors

When true, a PCH with compiler errors will not be rejected.

std::vector< std::pair< std::string, llvm::MemoryBuffer * > > RemappedFileBuffers

The set of file-to-buffer remappings, which take existing files on the system (the first part of each...

Engages in a tight little dance with the lexer to efficiently preprocess tokens.

void addPPCallbacks(std::unique_ptr< PPCallbacks > C)

SourceManager & getSourceManager() const

FileManager & getFileManager() const

void Initialize(const TargetInfo &Target, const TargetInfo *AuxTarget=nullptr)

Initialize the preprocessor using information about the target.

IdentifierTable & getIdentifierTable()

Builtin::Context & getBuiltinInfo()

const LangOptions & getLangOpts() const

void setCounterValue(unsigned V)

PreprocessingRecord * getPreprocessingRecord() const

Retrieve the preprocessing record, or NULL if there is no preprocessing record.

DiagnosticsEngine & getDiagnostics() const

SelectorTable & getSelectorTable()

A (possibly-)qualified type.

bool isNull() const

Return true if this QualType doesn't point to a type yet.

QualType getUnqualifiedType() const

Retrieve the unqualified variant of the given type, removing as little sugar as possible.

static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)

Sema - This implements semantic analysis and AST building for C.

const LangOptions & getLangOpts() const

Encodes a location in the source.

bool isValid() const

Return true if this is a valid SourceLocation object.

SourceLocation getLocWithOffset(IntTy Offset) const

Return a source location with the specified offset from this SourceLocation.

This class handles loading and caching of source files into memory.

OptionalFileEntryRef getFileEntryRefForID(FileID FID) const

Returns the FileEntryRef for the provided FileID.

FileID translateFile(const FileEntry *SourceFile) const

Get the FileID for the given file.

SourceLocation getLocForEndOfFile(FileID FID) const

Return the source location corresponding to the last byte of the specified file.

FileID getMainFileID() const

Returns the FileID of the main source file.

bool isInFileID(SourceLocation Loc, FileID FID, unsigned *RelativeOffset=nullptr) const

Given a specific FileID, returns true if Loc is inside that FileID chunk and sets relative offset (of...

FileID getPreambleFileID() const

Get the file ID for the precompiled preamble if there is one.

bool isLoadedFileID(FileID FID) const

Returns true if FID came from a PCH/Module.

SourceLocation getLocForStartOfFile(FileID FID) const

Return the source location corresponding to the first byte of the specified file.

Represents a diagnostic in a form that can be retained until its corresponding source manager is dest...

ArrayRef< FixItHint > getFixIts() const

ArrayRef< CharSourceRange > getRanges() const

DiagnosticsEngine::Level getLevel() const

const FullSourceLoc & getLocation() const

StringRef getMessage() const

static TargetInfo * CreateTargetInfo(DiagnosticsEngine &Diags, const std::shared_ptr< TargetOptions > &Opts)

Construct a target for the given options.

Options for controlling the target.

Token - This structure provides full information about a lexed token.

IdentifierInfo * getIdentifierInfo() const

Information about a module that has been loaded by the ASTReader.

FileEntryRef File

The file entry for the module file.

std::string FileName

The file name of the module file.

ModuleKind Kind

The type of this module.

@ CXCursor_MacroDefinition

Defines the clang::TargetInfo interface.

@ FixIt

Parse and apply any fixits to the source.

@ MK_MainFile

File is a PCH file treated as the actual main file.

The JSON file list parser is used to communicate input to InstallAPI.

IntrusiveRefCntPtr< llvm::vfs::FileSystem > createVFSFromOverlayFiles(ArrayRef< std::string > VFSOverlayFiles, DiagnosticsEngine &Diags, IntrusiveRefCntPtr< llvm::vfs::FileSystem > BaseFS)

@ CCP_NestedNameSpecifier

Priority for a nested-name-specifier.

@ CCP_CodePattern

Priority for a code pattern.

QualType getDeclUsageType(ASTContext &C, const NamedDecl *ND)

Determine the type that this declaration will have if it is used as a type or in an expression.

SkipFunctionBodiesScope

Enumerates the available scopes for skipping function bodies.

std::unique_ptr< CompilerInvocation > createInvocation(ArrayRef< const char * > Args, CreateInvocationOptions Opts={})

Interpret clang arguments in preparation to parse a file.

Language

The language for the input, used to select and validate the language standard and possible actions.

@ C

Languages that the frontend can parse and compile.

@ Result

The result type of a method or function.

SimplifiedTypeClass

A simplified classification of types used when determining "similar" types for code completion.

CaptureDiagsKind

Enumerates the available kinds for capturing diagnostics.

@ AllWithoutNonErrorsFromIncludes

IntrusiveRefCntPtr< llvm::vfs::FileSystem > createVFSFromCompilerInvocation(const CompilerInvocation &CI, DiagnosticsEngine &Diags)

void ProcessWarningOptions(DiagnosticsEngine &Diags, const DiagnosticOptions &Opts, llvm::vfs::FileSystem &VFS, bool ReportDiags=true)

ProcessWarningOptions - Initialize the diagnostic client and process the warning options specified on...

TranslationUnitKind

Describes the kind of translation unit being processed.

@ TU_Complete

The translation unit is a complete translation unit.

SimplifiedTypeClass getSimplifiedTypeClass(CanQualType T)

Determine the simplified type class of the given canonical type.

@ CCF_ExactTypeMatch

Divide by this factor when a code-completion result's type exactly matches the type we expect.

@ CCF_SimilarTypeMatch

Divide by this factor when a code-completion result's type is similar to the type we expect (e....

const FunctionProtoType * T

unsigned getMacroUsagePriority(StringRef MacroName, const LangOptions &LangOpts, bool PreferredTypeIsPointer=false)

Determine the priority to be given to a macro code completion result with the given name.

DisableValidationForModuleKind

Whether to disable the normal validation performed on precompiled headers and module files when they ...

@ None

Perform validation, don't disable it.

@ All

Disable validation for all kinds.

PreambleBounds ComputePreambleBounds(const LangOptions &LangOpts, const llvm::MemoryBufferRef &Buffer, unsigned MaxLines)

Runs lexer to compute suggested preamble bounds.

@ CouldntCreateTargetInfo

llvm::StringRef getAsString(SyncScope S)

llvm::BitstreamWriter Stream

SmallString< 128 > Buffer

ASTWriterData(InMemoryModuleCache &ModuleCache)

DiagnosticsEngine::Level Level

std::vector< std::pair< unsigned, unsigned > > Ranges

std::vector< StandaloneFixIt > FixIts

std::pair< unsigned, unsigned > InsertFromRange

std::pair< unsigned, unsigned > RemoveRange

bool BeforePreviousInsertions

Optional inputs to createInvocation.

IntrusiveRefCntPtr< DiagnosticsEngine > Diags

Receives diagnostics encountered while parsing command-line flags.

bool ProbePrecompiled

Allow the driver to probe the filesystem for PCH files.

IntrusiveRefCntPtr< llvm::vfs::FileSystem > VFS

Used e.g.

OverloadCandidate - A single candidate in an overload set (C++ 13.3).

Describes the bounds (start, size) of the preamble and a flag required by PreprocessorOptions::Precom...

unsigned Size

Size of the preamble in bytes.

Describes how types, statements, expressions, and declarations should be printed.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4