66#include "llvm/ADT/ArrayRef.h"
67#include "llvm/ADT/DenseMap.h"
68#include "llvm/ADT/IntrusiveRefCntPtr.h"
69#include "llvm/ADT/STLExtras.h"
70#include "llvm/ADT/ScopeExit.h"
71#include "llvm/ADT/SmallVector.h"
72#include "llvm/ADT/StringMap.h"
73#include "llvm/ADT/StringRef.h"
74#include "llvm/ADT/StringSet.h"
75#include "llvm/ADT/Twine.h"
76#include "llvm/ADT/iterator_range.h"
77#include "llvm/Bitstream/BitstreamWriter.h"
78#include "llvm/Support/Allocator.h"
79#include "llvm/Support/Casting.h"
80#include "llvm/Support/CrashRecoveryContext.h"
81#include "llvm/Support/DJB.h"
82#include "llvm/Support/ErrorHandling.h"
83#include "llvm/Support/ErrorOr.h"
84#include "llvm/Support/FileSystem.h"
85#include "llvm/Support/MemoryBuffer.h"
86#include "llvm/Support/SaveAndRestore.h"
87#include "llvm/Support/Timer.h"
88#include "llvm/Support/VirtualFileSystem.h"
89#include "llvm/Support/raw_ostream.h"
104using namespace clang;
106using llvm::TimeRecord;
116 explicit SimpleTimer(
bool WantTiming) : WantTiming(WantTiming) {
118 Start = TimeRecord::getCurrentTime();
123 TimeRecord Elapsed = TimeRecord::getCurrentTime();
125 llvm::errs() << Output <<
':';
126 Elapsed.print(Elapsed, llvm::errs());
127 llvm::errs() <<
'\n';
131 void setOutput(
const Twine &Output) {
133 this->Output = Output.str();
140static std::unique_ptr<T>
valueOrNull(llvm::ErrorOr<std::unique_ptr<T>> Val) {
143 return std::move(*Val);
150 Output = std::move(*Val);
156static std::unique_ptr<llvm::MemoryBuffer>
158 llvm::vfs::FileSystem *VFS,
159 StringRef FilePath,
bool isVolatile) {
165 llvm::MemoryBuffer *Buffer =
nullptr;
166 std::unique_ptr<llvm::MemoryBuffer> BufferOwner;
167 auto FileStatus = VFS->status(FilePath);
169 llvm::sys::fs::UniqueID MainFileID = FileStatus->getUniqueID();
172 for (
const auto &RF : PreprocessorOpts.RemappedFiles) {
173 std::string MPath(RF.first);
174 auto MPathStatus = VFS->status(MPath);
176 llvm::sys::fs::UniqueID MID = MPathStatus->getUniqueID();
177 if (MainFileID == MID) {
179 BufferOwner =
valueOrNull(VFS->getBufferForFile(RF.second, -1,
true, isVolatile));
188 for (
const auto &RB : PreprocessorOpts.RemappedFileBuffers) {
189 std::string MPath(RB.first);
190 auto MPathStatus = VFS->status(MPath);
192 llvm::sys::fs::UniqueID MID = MPathStatus->getUniqueID();
193 if (MainFileID == MID) {
196 Buffer =
const_cast<llvm::MemoryBuffer *
>(RB.second);
203 if (!Buffer && !BufferOwner) {
204 BufferOwner =
valueOrNull(VFS->getBufferForFile(FilePath, -1,
true, isVolatile));
213 return llvm::MemoryBuffer::getMemBufferCopy(Buffer->getBuffer(), FilePath);
225void ASTUnit::clearFileLevelDecls() {
240ASTUnit::ASTUnit(
bool _MainFileIsAST)
241 : MainFileIsAST(_MainFileIsAST), WantTiming(getenv(
"LIBCLANG_TIMING")),
242 ShouldCacheCodeCompletionResults(
false),
243 IncludeBriefCommentsInCodeCompletion(
false), UserFilesAreVolatile(
false),
244 UnsafeToFree(
false) {
245 if (getenv(
"LIBCLANG_OBJTRACKING"))
255 clearFileLevelDecls();
261 if (Invocation && OwnsRemappedFileBuffers) {
267 ClearCachedCompletionResults();
269 if (getenv(
"LIBCLANG_OBJTRACKING"))
274 this->PP = std::move(PP);
279 "Bad context for source file");
287 bool &IsNestedNameSpecifier) {
288 IsNestedNameSpecifier =
false;
290 if (isa<UsingShadowDecl>(ND))
295 uint64_t Contexts = 0;
296 if (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND) ||
297 isa<ClassTemplateDecl>(ND) || isa<TemplateTemplateParmDecl>(ND) ||
298 isa<TypeAliasTemplateDecl>(ND)) {
300 if (LangOpts.CPlusPlus || !isa<TagDecl>(ND))
309 if (LangOpts.CPlusPlus)
314 if (LangOpts.CPlusPlus || isa<ObjCInterfaceDecl>(ND))
318 if (
const auto *ID = dyn_cast<ObjCInterfaceDecl>(ND)) {
320 if (ID->getDefinition())
327 if (isa<EnumDecl>(ND)) {
331 if (LangOpts.CPlusPlus11)
332 IsNestedNameSpecifier =
true;
333 }
else if (
const auto *
Record = dyn_cast<RecordDecl>(ND)) {
339 if (LangOpts.CPlusPlus)
340 IsNestedNameSpecifier =
true;
341 }
else if (isa<ClassTemplateDecl>(ND))
342 IsNestedNameSpecifier =
true;
343 }
else if (isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND)) {
349 }
else if (isa<ObjCProtocolDecl>(ND)) {
351 }
else if (isa<ObjCCategoryDecl>(ND)) {
353 }
else if (isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND)) {
357 IsNestedNameSpecifier =
true;
363void ASTUnit::CacheCodeCompletionResults() {
367 SimpleTimer Timer(WantTiming);
368 Timer.setOutput(
"Cache global code completions for " +
getMainFileName());
371 ClearCachedCompletionResults();
376 CachedCompletionAllocator = std::make_shared<GlobalCodeCompletionAllocator>();
378 TheSema->GatherGlobalCodeCompletions(*CachedCompletionAllocator,
382 llvm::DenseMap<CanQualType, unsigned> CompletionTypes;
385 for (
auto &R : Results) {
387 case Result::RK_Declaration: {
388 bool IsNestedNameSpecifier =
false;
389 CachedCodeCompletionResult CachedResult;
390 CachedResult.Completion = R.CreateCodeCompletionString(
391 *TheSema, CCContext, *CachedCompletionAllocator, CCTUInfo,
392 IncludeBriefCommentsInCodeCompletion);
394 R.Declaration, Ctx->getLangOpts(), IsNestedNameSpecifier);
395 CachedResult.Priority = R.Priority;
396 CachedResult.Kind = R.CursorKind;
397 CachedResult.Availability = R.Availability;
404 CachedResult.Type = 0;
413 unsigned &TypeValue = CompletionTypes[CanUsageType];
414 if (TypeValue == 0) {
415 TypeValue = CompletionTypes.size();
420 CachedResult.Type = TypeValue;
423 CachedCompletionResults.push_back(CachedResult);
426 if (TheSema->Context.getLangOpts().CPlusPlus && IsNestedNameSpecifier &&
427 !R.StartsNestedNameSpecifier) {
443 if (isa<NamespaceDecl>(R.Declaration) ||
444 isa<NamespaceAliasDecl>(R.Declaration))
447 if (uint64_t RemainingContexts
448 = NNSContexts & ~CachedResult.ShowInContexts) {
452 R.StartsNestedNameSpecifier =
true;
453 CachedResult.Completion = R.CreateCodeCompletionString(
454 *TheSema, CCContext, *CachedCompletionAllocator, CCTUInfo,
455 IncludeBriefCommentsInCodeCompletion);
456 CachedResult.ShowInContexts = RemainingContexts;
459 CachedResult.Type = 0;
460 CachedCompletionResults.push_back(CachedResult);
466 case Result::RK_Keyword:
467 case Result::RK_Pattern:
472 case Result::RK_Macro: {
473 CachedCodeCompletionResult CachedResult;
474 CachedResult.Completion = R.CreateCodeCompletionString(
475 *TheSema, CCContext, *CachedCompletionAllocator, CCTUInfo,
476 IncludeBriefCommentsInCodeCompletion);
477 CachedResult.ShowInContexts
491 CachedResult.Priority = R.Priority;
492 CachedResult.Kind = R.CursorKind;
493 CachedResult.Availability = R.Availability;
495 CachedResult.Type = 0;
496 CachedCompletionResults.push_back(CachedResult);
503 CompletionCacheTopLevelHashValue = CurrentTopLevelHashValue;
506void ASTUnit::ClearCachedCompletionResults() {
507 CachedCompletionResults.clear();
508 CachedCompletionTypes.clear();
509 CachedCompletionAllocator =
nullptr;
522 std::shared_ptr<TargetOptions> &TargetOpts;
525 bool InitializedLanguage =
false;
526 bool InitializedHeaderSearchPaths =
false;
532 std::shared_ptr<TargetOptions> &TargetOpts,
534 : PP(PP), Context(Context), HSOpts(HSOpts), PPOpts(PPOpts),
535 LangOpt(LangOpt), TargetOpts(TargetOpts),
Target(
Target),
538 bool ReadLanguageOptions(
const LangOptions &LangOpts,
bool Complain,
539 bool AllowCompatibleDifferences)
override {
540 if (InitializedLanguage)
546 auto PICLevel = LangOpt.PICLevel;
547 auto PIE = LangOpt.PIE;
551 LangOpt.PICLevel = PICLevel;
554 InitializedLanguage =
true;
561 StringRef SpecificModuleCachePath,
562 bool Complain)
override {
564 auto ForceCheckCXX20ModulesInputFiles =
570 this->HSOpts = HSOpts;
572 ForceCheckCXX20ModulesInputFiles;
578 bool Complain)
override {
579 if (InitializedHeaderSearchPaths)
593 InitializedHeaderSearchPaths =
true;
599 bool ReadMacros,
bool Complain,
600 std::string &SuggestedPredefines)
override {
601 this->PPOpts = PPOpts;
605 bool ReadTargetOptions(
const TargetOptions &TargetOpts,
bool Complain,
606 bool AllowCompatibleDifferences)
override {
611 this->TargetOpts = std::make_shared<TargetOptions>(TargetOpts);
620 unsigned Value)
override {
626 if (!
Target || !InitializedLanguage)
658 bool CaptureNonErrorsFromIncludes =
true;
663 FilterAndStoreDiagnosticConsumer(
666 bool CaptureNonErrorsFromIncludes)
667 : StoredDiags(StoredDiags), StandaloneDiags(StandaloneDiags),
668 CaptureNonErrorsFromIncludes(CaptureNonErrorsFromIncludes) {
669 assert((StoredDiags || StandaloneDiags) &&
670 "No output collections were passed to StoredDiagnosticConsumer.");
675 this->LangOpts = &LangOpts;
686class CaptureDroppedDiagnostics {
688 FilterAndStoreDiagnosticConsumer Client;
690 std::unique_ptr<DiagnosticConsumer> OwningPreviousClient;
693 CaptureDroppedDiagnostics(
698 Client(StoredDiags, StandaloneDiags,
699 CaptureDiagnostics !=
701 if (CaptureDiagnostics != CaptureDiagsKind::None ||
709 ~CaptureDroppedDiagnostics() {
711 Diags.
setClient(PreviousClient, !!OwningPreviousClient.release());
729void FilterAndStoreDiagnosticConsumer::HandleDiagnostic(
745 StoredDiags->emplace_back(Level, Info);
746 ResultDiag = &StoredDiags->back();
749 if (StandaloneDiags) {
750 std::optional<StoredDiagnostic> StoredDiag;
752 StoredDiag.emplace(Level, Info);
753 ResultDiag = &*StoredDiag;
755 StandaloneDiags->push_back(
767 return &WriterData->Writer;
773 return &WriterData->Writer;
777std::unique_ptr<llvm::MemoryBuffer>
780 auto Buffer = FileMgr->getBufferForFile(
Filename, UserFilesAreVolatile);
782 return std::move(*Buffer);
784 *ErrorStr = Buffer.getError().message();
792 assert(Diags.get() &&
"no DiagnosticsEngine was provided");
794 Diags->setClient(
new FilterAndStoreDiagnosticConsumer(
795 &AST.StoredDiagnostics,
nullptr,
803 std::shared_ptr<HeaderSearchOptions> HSOpts,
804 std::shared_ptr<LangOptions> LangOpts,
bool OnlyLocalDecls,
807 std::unique_ptr<ASTUnit> AST(
new ASTUnit(
true));
810 llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
811 ASTUnitCleanup(AST.get());
813 llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine>>
814 DiagCleanup(Diags.get());
816 ConfigureDiags(Diags, *AST, CaptureDiagnostics);
818 AST->LangOpts = LangOpts ? LangOpts : std::make_shared<LangOptions>();
819 AST->OnlyLocalDecls = OnlyLocalDecls;
820 AST->CaptureDiagnostics = CaptureDiagnostics;
821 AST->Diagnostics = Diags;
822 AST->FileMgr =
new FileManager(FileSystemOpts, VFS);
823 AST->UserFilesAreVolatile = UserFilesAreVolatile;
825 AST->getFileManager(),
826 UserFilesAreVolatile);
828 AST->HSOpts = HSOpts ? HSOpts : std::make_shared<HeaderSearchOptions>();
829 AST->HSOpts->ModuleFormat = std::string(PCHContainerRdr.
getFormats().front());
831 AST->getSourceManager(),
832 AST->getDiagnostics(),
835 AST->PPOpts = std::make_shared<PreprocessorOptions>();
841 AST->PP = std::make_shared<Preprocessor>(
842 AST->PPOpts, AST->getDiagnostics(), *AST->LangOpts,
843 AST->getSourceManager(), HeaderInfo, AST->ModuleLoader,
849 AST->Ctx =
new ASTContext(*AST->LangOpts, AST->getSourceManager(),
852 AST->getTranslationUnitKind());
856 if (::getenv(
"LIBCLANG_DISABLE_PCH_VALIDATION"))
859 PP, *AST->ModuleCache, AST->Ctx.get(), PCHContainerRdr, {},
861 disableValid, AllowASTWithCompilerErrors);
863 unsigned Counter = 0;
864 AST->Reader->setListener(std::make_unique<ASTInfoCollector>(
865 *AST->PP, AST->Ctx.get(), *AST->HSOpts, *AST->PPOpts, *AST->LangOpts,
866 AST->TargetOpts, AST->Target, Counter));
874 AST->Ctx->setExternalSource(AST->Reader);
887 AST->getDiagnostics().Report(diag::err_fe_unable_to_load_pch);
891 AST->OriginalSourceFile = std::string(AST->Reader->getOriginalSourceFile());
896 if (M && AST->getLangOpts().isCompilingModule() && M->
isNamedModule())
897 AST->Ctx->setCurrentNamedModule(M);
905 AST->TheSema.reset(
new Sema(PP, *AST->Ctx, *AST->Consumer));
906 AST->TheSema->Initialize();
907 AST->Reader->InitializeSema(*AST->TheSema);
911 AST->getDiagnostics().getClient()->BeginSourceFile(PP.
getLangOpts(), &PP);
925class MacroDefinitionTrackerPPCallbacks :
public PPCallbacks {
929 explicit MacroDefinitionTrackerPPCallbacks(
unsigned &Hash) : Hash(Hash) {}
931 void MacroDefined(
const Token &MacroNameTok,
951 if (
const auto *ND = dyn_cast<NamedDecl>(D)) {
952 if (
const auto *EnumD = dyn_cast<EnumDecl>(D)) {
955 if (!EnumD->isScoped()) {
956 for (
const auto *EI : EnumD->enumerators()) {
957 if (EI->getIdentifier())
958 Hash = llvm::djbHash(EI->getIdentifier()->getName(), Hash);
963 if (ND->getIdentifier())
964 Hash = llvm::djbHash(ND->getIdentifier()->getName(), Hash);
966 std::string NameStr = Name.getAsString();
967 Hash = llvm::djbHash(NameStr, Hash);
972 if (
const auto *ImportD = dyn_cast<ImportDecl>(D)) {
973 if (
const Module *Mod = ImportD->getImportedModule()) {
974 std::string ModName = Mod->getFullModuleName();
975 Hash = llvm::djbHash(ModName, Hash);
983class TopLevelDeclTrackerConsumer :
public ASTConsumer {
988 TopLevelDeclTrackerConsumer(
ASTUnit &_Unit,
unsigned &Hash)
989 : Unit(_Unit), Hash(Hash) {
993 void handleTopLevelDecl(
Decl *D) {
1001 if (isa<ObjCMethodDecl>(D))
1007 handleFileLevelDecl(D);
1010 void handleFileLevelDecl(
Decl *D) {
1012 if (
auto *NSD = dyn_cast<NamespaceDecl>(D)) {
1013 for (
auto *I : NSD->decls())
1014 handleFileLevelDecl(I);
1019 for (
auto *TopLevelDecl : D)
1020 handleTopLevelDecl(TopLevelDecl);
1027 void HandleTopLevelDeclInObjCContainer(
DeclGroupRef D)
override {
1028 for (
auto *TopLevelDecl : D)
1029 handleTopLevelDecl(TopLevelDecl);
1046 StringRef InFile)
override {
1048 std::make_unique<MacroDefinitionTrackerPPCallbacks>(
1050 return std::make_unique<TopLevelDeclTrackerConsumer>(
1055 TopLevelDeclTrackerAction(
ASTUnit &_Unit) : Unit(_Unit) {}
1057 bool hasCodeCompletionSupport()
const override {
return false; }
1066 unsigned getHash()
const {
return Hash; }
1068 std::vector<Decl *> takeTopLevelDecls() {
return std::move(TopLevelDecls); }
1070 std::vector<LocalDeclID> takeTopLevelDeclIDs() {
1071 return std::move(TopLevelDeclIDs);
1074 void AfterPCHEmitted(
ASTWriter &Writer)
override {
1075 TopLevelDeclIDs.reserve(TopLevelDecls.size());
1076 for (
const auto *D : TopLevelDecls) {
1078 if (D->isInvalidDecl())
1080 TopLevelDeclIDs.push_back(Writer.
getDeclID(D));
1085 for (
auto *D : DG) {
1090 if (isa<ObjCMethodDecl>(D))
1093 TopLevelDecls.push_back(D);
1097 std::unique_ptr<PPCallbacks> createPPCallbacks()
override {
1098 return std::make_unique<MacroDefinitionTrackerPPCallbacks>(Hash);
1103 std::vector<Decl *> TopLevelDecls;
1104 std::vector<LocalDeclID> TopLevelDeclIDs;
1129 for (
auto &SD : StoredDiagnostics) {
1130 if (SD.getLocation().isValid()) {
1132 SD.setLocation(Loc);
1142bool ASTUnit::Parse(std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1143 std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer,
1149 assert(VFS == &FileMgr->getVirtualFileSystem() &&
1150 "VFS passed to Parse and VFS in FileMgr are different");
1152 auto CCInvocation = std::make_shared<CompilerInvocation>(*Invocation);
1153 if (OverrideMainBuffer) {
1155 "No preamble was built, but OverrideMainBuffer is not null");
1156 Preamble->AddImplicitPreamble(*CCInvocation, VFS, OverrideMainBuffer.get());
1161 std::unique_ptr<CompilerInstance> Clang(
1163 Clang->setInvocation(CCInvocation);
1166 auto CleanOnError = llvm::make_scope_exit([&]() {
1168 SavedMainFileBuffer =
nullptr;
1172 transferASTDataFromCompilerInstance(*Clang);
1173 FailedParseDiagnostics.swap(StoredDiagnostics);
1174 StoredDiagnostics.clear();
1175 NumStoredDiagnosticsFromDriver = 0;
1181 if (VFS && FileMgr && &FileMgr->getVirtualFileSystem() ==
VFS)
1182 Clang->setFileManager(&*FileMgr);
1184 FileMgr = Clang->createFileManager(std::move(VFS));
1187 llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
1188 CICleanup(Clang.get());
1190 OriginalSourceFile =
1191 std::string(Clang->getFrontendOpts().Inputs[0].getFile());
1198 if (!Clang->createTarget())
1201 assert(Clang->getFrontendOpts().Inputs.size() == 1 &&
1202 "Invocation must have exactly one source file!");
1203 assert(Clang->getFrontendOpts().Inputs[0].getKind().getFormat() ==
1205 "FIXME: AST inputs not yet supported here!");
1206 assert(Clang->getFrontendOpts().Inputs[0].getKind().getLanguage() !=
1208 "IR inputs not support here!");
1211 LangOpts = Clang->getInvocation().LangOpts;
1212 FileSystemOpts = Clang->getFileSystemOpts();
1217 UserFilesAreVolatile);
1218 if (!OverrideMainBuffer) {
1220 TopLevelDeclsInPreamble.clear();
1228 if (OverrideMainBuffer) {
1237 SavedMainFileBuffer = std::move(OverrideMainBuffer);
1240 std::unique_ptr<TopLevelDeclTrackerAction> Act(
1241 new TopLevelDeclTrackerAction(*
this));
1244 llvm::CrashRecoveryContextCleanupRegistrar<TopLevelDeclTrackerAction>
1245 ActCleanup(Act.get());
1247 if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0]))
1250 if (SavedMainFileBuffer)
1252 PreambleDiagnostics, StoredDiagnostics);
1254 PreambleSrcLocCache.clear();
1256 if (llvm::Error Err = Act->Execute()) {
1257 consumeError(std::move(Err));
1261 transferASTDataFromCompilerInstance(*Clang);
1263 Act->EndSourceFile();
1265 FailedParseDiagnostics.clear();
1267 CleanOnError.release();
1272static std::pair<unsigned, unsigned>
1276 unsigned Offset =
SM.getFileOffset(FileRange.
getBegin());
1277 unsigned EndOffset =
SM.getFileOffset(FileRange.
getEnd());
1278 return std::make_pair(Offset, EndOffset);
1305 OutDiag.
Filename = std::string(
SM.getFilename(FileLoc));
1309 for (
const auto &Range : InDiag.
getRanges())
1311 for (
const auto &FixIt : InDiag.
getFixIts())
1337std::unique_ptr<llvm::MemoryBuffer>
1338ASTUnit::getMainBufferWithPrecompiledPreamble(
1339 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1342 unsigned MaxLines) {
1345 std::unique_ptr<llvm::MemoryBuffer> MainFileBuffer =
1347 MainFilePath, UserFilesAreVolatile);
1348 if (!MainFileBuffer)
1352 PreambleInvocationIn.
getLangOpts(), *MainFileBuffer, MaxLines);
1357 if (Preamble->CanReuse(PreambleInvocationIn, *MainFileBuffer, Bounds,
1368 PreambleRebuildCountdown = 1;
1369 return MainFileBuffer;
1372 PreambleDiagnostics.clear();
1373 TopLevelDeclsInPreamble.clear();
1374 PreambleSrcLocCache.clear();
1375 PreambleRebuildCountdown = 1;
1382 if (PreambleRebuildCountdown > 1) {
1383 --PreambleRebuildCountdown;
1387 assert(!Preamble &&
"No Preamble should be stored at that point");
1397 ASTUnitPreambleCallbacks Callbacks;
1399 std::optional<CaptureDroppedDiagnostics>
Capture;
1401 Capture.emplace(CaptureDiagnostics, *Diagnostics, &NewPreambleDiags,
1402 &NewPreambleDiagsStandalone);
1405 SimpleTimer PreambleTimer(WantTiming);
1406 PreambleTimer.setOutput(
"Precompiling preamble");
1408 const bool PreviousSkipFunctionBodies =
1414 PreambleInvocationIn, MainFileBuffer.get(), Bounds, *Diagnostics, VFS,
1415 PCHContainerOps, StorePreamblesInMemory, PreambleStoragePath,
1419 PreviousSkipFunctionBodies;
1422 Preamble = std::move(*NewPreamble);
1423 PreambleRebuildCountdown = 1;
1428 PreambleRebuildCountdown = 1;
1438 llvm_unreachable(
"unexpected BuildPreambleError");
1442 assert(Preamble &&
"Preamble wasn't built");
1444 TopLevelDecls.clear();
1445 TopLevelDeclsInPreamble = Callbacks.takeTopLevelDeclIDs();
1446 PreambleTopLevelHashValue = Callbacks.getHash();
1451 StoredDiagnostics = std::move(NewPreambleDiags);
1452 PreambleDiagnostics = std::move(NewPreambleDiagsStandalone);
1457 if (CurrentTopLevelHashValue != PreambleTopLevelHashValue) {
1458 CompletionCacheTopLevelHashValue = 0;
1459 PreambleTopLevelHashValue = CurrentTopLevelHashValue;
1462 return MainFileBuffer;
1465void ASTUnit::RealizeTopLevelDeclsFromPreamble() {
1466 assert(Preamble &&
"Should only be called when preamble was built");
1468 std::vector<Decl *> Resolved;
1469 Resolved.reserve(TopLevelDeclsInPreamble.size());
1472 for (
const auto TopLevelDecl : TopLevelDeclsInPreamble) {
1475 if (
Decl *D = Reader->GetDecl(Reader->getGlobalDeclID(MF, TopLevelDecl)))
1476 Resolved.push_back(D);
1478 TopLevelDeclsInPreamble.clear();
1479 TopLevelDecls.insert(TopLevelDecls.begin(), Resolved.begin(), Resolved.end());
1502 if (Invocation && !Invocation->getFrontendOpts().Inputs.empty()) {
1507 return Input.
getBuffer().getBufferIdentifier();
1513 return FE->getName();
1524 Mod = Reader->getModuleManager().getPrimaryModule();
1528std::unique_ptr<ASTUnit>
1532 bool UserFilesAreVolatile) {
1533 std::unique_ptr<ASTUnit> AST(
new ASTUnit(
false));
1534 ConfigureDiags(Diags, *AST, CaptureDiagnostics);
1537 AST->Diagnostics = Diags;
1538 AST->FileSystemOpts = CI->getFileSystemOpts();
1539 AST->Invocation = std::move(CI);
1540 AST->FileMgr =
new FileManager(AST->FileSystemOpts, VFS);
1541 AST->UserFilesAreVolatile = UserFilesAreVolatile;
1542 AST->SourceMgr =
new SourceManager(AST->getDiagnostics(), *AST->FileMgr,
1543 UserFilesAreVolatile);
1550 std::shared_ptr<CompilerInvocation> CI,
1551 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1553 ASTUnit *Unit,
bool Persistent, StringRef ResourceFilesPath,
1555 unsigned PrecompilePreambleAfterNParses,
bool CacheCodeCompletionResults,
1556 bool UserFilesAreVolatile, std::unique_ptr<ASTUnit> *ErrAST) {
1557 assert(CI &&
"A CompilerInvocation is required");
1559 std::unique_ptr<ASTUnit> OwnAST;
1563 OwnAST =
create(CI, Diags, CaptureDiagnostics, UserFilesAreVolatile);
1569 if (!ResourceFilesPath.empty()) {
1573 AST->OnlyLocalDecls = OnlyLocalDecls;
1574 AST->CaptureDiagnostics = CaptureDiagnostics;
1575 if (PrecompilePreambleAfterNParses > 0)
1576 AST->PreambleRebuildCountdown = PrecompilePreambleAfterNParses;
1578 AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults;
1579 AST->IncludeBriefCommentsInCodeCompletion =
false;
1582 llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
1583 ASTUnitCleanup(OwnAST.get());
1585 llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine>>
1586 DiagCleanup(Diags.get());
1589 CI->getPreprocessorOpts().RetainRemappedFileBuffers =
true;
1590 CI->getFrontendOpts().DisableFree =
false;
1594 std::unique_ptr<CompilerInstance> Clang(
1598 llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
1599 CICleanup(Clang.get());
1601 Clang->setInvocation(std::move(CI));
1602 AST->OriginalSourceFile =
1603 std::string(Clang->getFrontendOpts().Inputs[0].getFile());
1610 if (!Clang->createTarget())
1613 assert(Clang->getFrontendOpts().Inputs.size() == 1 &&
1614 "Invocation must have exactly one source file!");
1615 assert(Clang->getFrontendOpts().Inputs[0].getKind().getFormat() ==
1617 "FIXME: AST inputs not yet supported here!");
1618 assert(Clang->getFrontendOpts().Inputs[0].getKind().getLanguage() !=
1620 "IR inputs not support here!");
1623 AST->TheSema.reset();
1626 AST->Reader =
nullptr;
1636 std::unique_ptr<TopLevelDeclTrackerAction> TrackerAct;
1638 TrackerAct.reset(
new TopLevelDeclTrackerAction(*AST));
1639 Act = TrackerAct.get();
1643 llvm::CrashRecoveryContextCleanupRegistrar<TopLevelDeclTrackerAction>
1644 ActCleanup(TrackerAct.get());
1646 if (!Act->
BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) {
1647 AST->transferASTDataFromCompilerInstance(*Clang);
1648 if (OwnAST && ErrAST)
1649 ErrAST->swap(OwnAST);
1654 if (Persistent && !TrackerAct) {
1655 Clang->getPreprocessor().addPPCallbacks(
1656 std::make_unique<MacroDefinitionTrackerPPCallbacks>(
1658 std::vector<std::unique_ptr<ASTConsumer>> Consumers;
1659 if (Clang->hasASTConsumer())
1660 Consumers.push_back(Clang->takeASTConsumer());
1661 Consumers.push_back(std::make_unique<TopLevelDeclTrackerConsumer>(
1663 Clang->setASTConsumer(
1664 std::make_unique<MultiplexConsumer>(std::move(Consumers)));
1666 if (llvm::Error Err = Act->
Execute()) {
1667 consumeError(std::move(Err));
1668 AST->transferASTDataFromCompilerInstance(*Clang);
1669 if (OwnAST && ErrAST)
1670 ErrAST->swap(OwnAST);
1676 AST->transferASTDataFromCompilerInstance(*Clang);
1681 return OwnAST.release();
1686bool ASTUnit::LoadFromCompilerInvocation(
1687 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1688 unsigned PrecompilePreambleAfterNParses,
1693 assert(VFS &&
"VFS is null");
1696 Invocation->getPreprocessorOpts().RetainRemappedFileBuffers =
true;
1697 Invocation->getFrontendOpts().DisableFree =
false;
1701 std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer;
1702 if (PrecompilePreambleAfterNParses > 0) {
1703 PreambleRebuildCountdown = PrecompilePreambleAfterNParses;
1704 OverrideMainBuffer =
1705 getMainBufferWithPrecompiledPreamble(PCHContainerOps, *Invocation, VFS);
1710 SimpleTimer ParsingTimer(WantTiming);
1714 llvm::CrashRecoveryContextCleanupRegistrar<llvm::MemoryBuffer>
1715 MemBufferCleanup(OverrideMainBuffer.get());
1717 return Parse(std::move(PCHContainerOps), std::move(OverrideMainBuffer), VFS);
1720std::unique_ptr<ASTUnit> ASTUnit::LoadFromCompilerInvocation(
1721 std::shared_ptr<CompilerInvocation> CI,
1722 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1726 bool CacheCodeCompletionResults,
bool IncludeBriefCommentsInCodeCompletion,
1727 bool UserFilesAreVolatile) {
1729 std::unique_ptr<ASTUnit> AST(
new ASTUnit(
false));
1730 ConfigureDiags(Diags, *AST, CaptureDiagnostics);
1731 AST->Diagnostics = Diags;
1732 AST->OnlyLocalDecls = OnlyLocalDecls;
1733 AST->CaptureDiagnostics = CaptureDiagnostics;
1734 AST->TUKind = TUKind;
1735 AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults;
1736 AST->IncludeBriefCommentsInCodeCompletion
1737 = IncludeBriefCommentsInCodeCompletion;
1738 AST->Invocation = std::move(CI);
1740 AST->FileMgr = FileMgr;
1741 AST->UserFilesAreVolatile = UserFilesAreVolatile;
1744 llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
1745 ASTUnitCleanup(AST.get());
1747 llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine>>
1748 DiagCleanup(Diags.get());
1750 if (AST->LoadFromCompilerInvocation(std::move(PCHContainerOps),
1751 PrecompilePreambleAfterNParses,
1752 &AST->FileMgr->getVirtualFileSystem()))
1758 const char **ArgBegin,
const char **ArgEnd,
1759 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1761 bool StorePreamblesInMemory, StringRef PreambleStoragePath,
1765 bool CacheCodeCompletionResults,
bool IncludeBriefCommentsInCodeCompletion,
1767 bool SingleFileParse,
bool UserFilesAreVolatile,
bool ForSerialization,
1768 bool RetainExcludedConditionalBlocks, std::optional<StringRef> ModuleFormat,
1769 std::unique_ptr<ASTUnit> *ErrAST,
1771 assert(Diags.get() &&
"no DiagnosticsEngine was provided");
1777 VFS = llvm::vfs::createPhysicalFileSystem();
1781 std::shared_ptr<CompilerInvocation> CI;
1784 CaptureDroppedDiagnostics
Capture(CaptureDiagnostics, *Diags,
1785 &StoredDiagnostics,
nullptr);
1789 CIOpts.
Diags = Diags;
1798 CI->getPreprocessorOpts().addRemappedFile(
RemappedFile.first,
1808 CI->getHeaderSearchOpts().ResourceDir = std::string(ResourceFilesPath);
1810 CI->getFrontendOpts().SkipFunctionBodies =
1814 CI->getHeaderSearchOpts().ModuleFormat = std::string(*ModuleFormat);
1817 std::unique_ptr<ASTUnit> AST;
1818 AST.reset(
new ASTUnit(
false));
1819 AST->NumStoredDiagnosticsFromDriver = StoredDiagnostics.size();
1820 AST->StoredDiagnostics.swap(StoredDiagnostics);
1821 ConfigureDiags(Diags, *AST, CaptureDiagnostics);
1822 AST->Diagnostics = Diags;
1823 AST->FileSystemOpts = CI->getFileSystemOpts();
1825 AST->FileMgr =
new FileManager(AST->FileSystemOpts, VFS);
1826 AST->StorePreamblesInMemory = StorePreamblesInMemory;
1827 AST->PreambleStoragePath = PreambleStoragePath;
1829 AST->OnlyLocalDecls = OnlyLocalDecls;
1830 AST->CaptureDiagnostics = CaptureDiagnostics;
1831 AST->TUKind = TUKind;
1832 AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults;
1833 AST->IncludeBriefCommentsInCodeCompletion
1834 = IncludeBriefCommentsInCodeCompletion;
1835 AST->UserFilesAreVolatile = UserFilesAreVolatile;
1836 AST->Invocation = CI;
1837 AST->SkipFunctionBodies = SkipFunctionBodies;
1838 if (ForSerialization)
1839 AST->WriterData.reset(
new ASTWriterData(*AST->ModuleCache));
1845 llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
1846 ASTUnitCleanup(AST.get());
1848 if (AST->LoadFromCompilerInvocation(std::move(PCHContainerOps),
1849 PrecompilePreambleAfterNParses,
1854 AST->StoredDiagnostics.swap(AST->FailedParseDiagnostics);
1870 assert(FileMgr &&
"FileMgr is null on Reparse call");
1871 VFS = &FileMgr->getVirtualFileSystem();
1874 clearFileLevelDecls();
1876 SimpleTimer ParsingTimer(WantTiming);
1884 Invocation->getPreprocessorOpts().clearRemappedFiles();
1886 Invocation->getPreprocessorOpts().addRemappedFile(
RemappedFile.first,
1892 std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer;
1893 if (Preamble || PreambleRebuildCountdown > 0)
1894 OverrideMainBuffer =
1895 getMainBufferWithPrecompiledPreamble(PCHContainerOps, *Invocation, VFS);
1901 if (OverrideMainBuffer)
1906 Parse(std::move(PCHContainerOps), std::move(OverrideMainBuffer), VFS);
1910 if (!
Result && ShouldCacheCodeCompletionResults &&
1911 CurrentTopLevelHashValue != CompletionCacheTopLevelHashValue)
1912 CacheCodeCompletionResults();
1922 SavedMainFileBuffer.reset();
1930 TopLevelDecls.clear();
1931 clearFileLevelDecls();
1944 uint64_t NormalContexts;
1977 unsigned NumResults)
override;
1979 void ProcessOverloadCandidates(
Sema &S,
unsigned CurrentArg,
1981 unsigned NumCandidates,
1983 bool Braced)
override {
1984 Next.ProcessOverloadCandidates(S, CurrentArg, Candidates, NumCandidates,
1985 OpenParLoc, Braced);
1989 return Next.getAllocator();
1993 return Next.getCodeCompletionTUInfo();
2003 unsigned NumResults,
2005 llvm::StringSet<llvm::BumpPtrAllocator> &HiddenNames){
2006 bool OnlyTagNames =
false;
2007 switch (Context.getKind()) {
2032 OnlyTagNames =
true;
2058 for (
unsigned I = 0; I != NumResults; ++I) {
2059 if (Results[I].Kind != Result::RK_Declaration)
2063 = Results[I].Declaration->getUnderlyingDecl()->getIdentifierNamespace();
2065 bool Hiding =
false;
2074 Hiding = (IDNS & HiddenIDNS);
2084 HiddenNames.insert(Name.getAsString());
2088void AugmentedCodeCompleteConsumer::ProcessCodeCompleteResults(
Sema &S,
2091 unsigned NumResults) {
2093 bool AddedResult =
false;
2096 ? NormalContexts : (1LL << Context.getKind());
2098 llvm::StringSet<llvm::BumpPtrAllocator> HiddenNames;
2107 if ((
C->ShowInContexts & InContexts) == 0)
2114 AllResults.insert(AllResults.end(), Results, Results + NumResults);
2121 HiddenNames.count(
C->Completion->getTypedText()))
2127 if (!Context.getPreferredType().isNull()) {
2131 Context.getPreferredType()->isAnyPointerType());
2132 }
else if (
C->Type) {
2135 Context.getPreferredType().getUnqualifiedType());
2137 if (ExpectedSTC ==
C->TypeClass) {
2139 llvm::StringMap<unsigned> &CachedCompletionTypes
2141 llvm::StringMap<unsigned>::iterator Pos
2143 if (Pos != CachedCompletionTypes.end() && Pos->second ==
C->Type)
2158 Builder.AddTypedTextChunk(
C->Completion->getTypedText());
2160 Completion = Builder.TakeString();
2163 AllResults.push_back(
Result(Completion, Priority,
C->Kind,
2170 Next.ProcessCodeCompleteResults(S, Context, Results, NumResults);
2174 Next.ProcessCodeCompleteResults(S, Context, AllResults.data(),
2181 bool IncludeCodePatterns,
bool IncludeBriefComments,
2183 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
2187 std::unique_ptr<SyntaxOnlyAction> Act) {
2191 SimpleTimer CompletionTimer(WantTiming);
2192 CompletionTimer.setOutput(
"Code completion @ " +
File +
":" +
2195 auto CCInvocation = std::make_shared<CompilerInvocation>(*Invocation);
2202 CachedCompletionResults.empty();
2204 CodeCompleteOpts.
IncludeGlobals = CachedCompletionResults.empty();
2209 assert(IncludeBriefComments == this->IncludeBriefCommentsInCodeCompletion);
2216 LangOpts = CCInvocation->getLangOpts();
2219 LangOpts.SpellChecking =
false;
2220 CCInvocation->getDiagnosticOpts().IgnoreWarnings =
true;
2222 std::unique_ptr<CompilerInstance> Clang(
2226 llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
2227 CICleanup(Clang.get());
2229 auto &Inv = *CCInvocation;
2230 Clang->setInvocation(std::move(CCInvocation));
2231 OriginalSourceFile =
2232 std::string(Clang->getFrontendOpts().Inputs[0].getFile());
2235 Clang->setDiagnostics(&
Diag);
2237 Clang->getDiagnostics(),
2238 &StoredDiagnostics,
nullptr);
2242 if (!Clang->createTarget()) {
2243 Clang->setInvocation(
nullptr);
2247 assert(Clang->getFrontendOpts().Inputs.size() == 1 &&
2248 "Invocation must have exactly one source file!");
2249 assert(Clang->getFrontendOpts().Inputs[0].getKind().getFormat() ==
2251 "FIXME: AST inputs not yet supported here!");
2252 assert(Clang->getFrontendOpts().Inputs[0].getKind().getLanguage() !=
2254 "IR inputs not support here!");
2257 Clang->setFileManager(&FileMgr);
2258 Clang->setSourceManager(&SourceMgr);
2270 AugmentedCodeCompleteConsumer *AugmentedConsumer
2271 =
new AugmentedCodeCompleteConsumer(*
this, Consumer, CodeCompleteOpts);
2272 Clang->setCodeCompletionConsumer(AugmentedConsumer);
2275 [&FileMgr](StringRef
Filename) -> std::optional<llvm::sys::fs::UniqueID> {
2277 return Status->getUniqueID();
2278 return std::nullopt;
2281 auto hasSameUniqueID = [getUniqueID](StringRef LHS, StringRef RHS) {
2284 if (
auto LHSID = getUniqueID(LHS))
2285 if (
auto RHSID = getUniqueID(RHS))
2286 return *LHSID == *RHSID;
2294 std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer;
2295 if (Preamble &&
Line > 1 && hasSameUniqueID(
File, OriginalSourceFile)) {
2296 OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(
2302 if (OverrideMainBuffer) {
2304 "No preamble was built, but OverrideMainBuffer is not null");
2308 Preamble->AddImplicitPreamble(Clang->getInvocation(), VFS,
2309 OverrideMainBuffer.get());
2314 OwnedBuffers.push_back(OverrideMainBuffer.release());
2321 if (!Clang->getLangOpts().Modules)
2327 if (Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) {
2328 if (llvm::Error Err = Act->Execute()) {
2329 consumeError(std::move(Err));
2331 Act->EndSourceFile();
2336 if (HadModuleLoaderFatalFailure)
2342 if (llvm::Error Err = llvm::writeToOutput(
2343 File, [
this](llvm::raw_ostream &Out) {
2344 return serialize(Out) ? llvm::make_error<llvm::StringError>(
2345 "ASTUnit serialization failed",
2346 llvm::inconvertibleErrorCode())
2347 : llvm::Error::success();
2349 consumeError(std::move(Err));
2356 Sema &S, raw_ostream &OS) {
2357 Writer.
WriteAST(S, std::string(),
nullptr,
"");
2360 if (!Buffer.empty())
2361 OS.write(Buffer.data(), Buffer.size());
2371 llvm::BitstreamWriter Stream(Buffer);
2373 ASTWriter Writer(Stream, Buffer, ModuleCache, {});
2379void ASTUnit::TranslateStoredDiagnostics(
2389 Result.reserve(Diags.size());
2391 for (
const auto &SD : Diags) {
2393 if (SD.Filename.empty())
2395 auto FE = FileMgr.
getFile(SD.Filename);
2399 auto ItFileID = PreambleSrcLocCache.find(SD.Filename);
2400 if (ItFileID == PreambleSrcLocCache.end()) {
2403 PreambleSrcLocCache[SD.Filename] = FileLoc;
2405 FileLoc = ItFileID->getValue();
2414 Ranges.reserve(SD.Ranges.size());
2415 for (
const auto &Range : SD.Ranges) {
2422 FixIts.reserve(SD.FixIts.size());
2423 for (
const auto &FixIt : SD.FixIts) {
2433 SD.Message, Loc, Ranges, FixIts));
2447 if (Loc.
isInvalid() || !
SM.isLocalSourceLocation(Loc))
2455 assert(
SM.isLocalSourceLocation(FileLoc));
2458 std::tie(FID, Offset) =
SM.getDecomposedLoc(FileLoc);
2462 std::unique_ptr<LocDeclsTy> &Decls = FileDecls[FID];
2464 Decls = std::make_unique<LocDeclsTy>();
2466 std::pair<unsigned, Decl *> LocDecl(Offset, D);
2468 if (Decls->empty() || Decls->back().first <= Offset) {
2469 Decls->push_back(LocDecl);
2473 LocDeclsTy::iterator I =
2474 llvm::upper_bound(*Decls, LocDecl, llvm::less_first());
2476 Decls->insert(I, LocDecl);
2481 if (
File.isInvalid())
2485 assert(Ctx->getExternalSource() &&
"No external source!");
2486 return Ctx->getExternalSource()->FindFileRegionDecls(
File, Offset, Length,
2490 FileDeclsTy::iterator I = FileDecls.find(
File);
2491 if (I == FileDecls.end())
2495 if (LocDecls.empty())
2498 LocDeclsTy::iterator BeginIt =
2499 llvm::partition_point(LocDecls, [=](std::pair<unsigned, Decl *> LD) {
2500 return LD.first < Offset;
2502 if (BeginIt != LocDecls.begin())
2508 while (BeginIt != LocDecls.begin() &&
2509 BeginIt->second->isTopLevelDeclInObjCContainer())
2512 LocDeclsTy::iterator EndIt = llvm::upper_bound(
2513 LocDecls, std::make_pair(Offset + Length, (
Decl *)
nullptr),
2514 llvm::less_first());
2515 if (EndIt != LocDecls.end())
2518 for (LocDeclsTy::iterator DIt = BeginIt; DIt != EndIt; ++DIt)
2519 Decls.push_back(DIt->second);
2523 unsigned Line,
unsigned Col)
const {
2526 return SM.getMacroArgExpandedLocation(Loc);
2530 unsigned Offset)
const {
2548 if (SourceMgr->
isInFileID(Loc, PreambleID, &Offs) && Offs < Preamble->getBounds().Size) {
2570 Offs < Preamble->getBounds().Size) {
2622llvm::iterator_range<PreprocessingRecord::iterator>
2626 Mod = Reader->getModuleManager().getPrimaryModule();
2627 return Reader->getModulePreprocessedEntities(Mod);
2631 return llvm::make_range(PPRec->local_begin(), PPRec->local_end());
2640 Mod = Reader->getModuleManager().getPrimaryModule();
2641 for (
const auto *D : Reader->getModuleFileLevelDecls(Mod)) {
2642 if (!Fn(context, D))
2651 TL != TLEnd; ++TL) {
2652 if (!Fn(context, *TL))
2661 return std::nullopt;
2666 case serialization::MK_ImplicitModule:
2667 case serialization::MK_ExplicitModule:
2668 case serialization::MK_PrebuiltModule:
2670 case serialization::MK_PCH:
2673 case serialization::MK_Preamble:
2675 case serialization::MK_MainFile:
2684 return std::nullopt;
2695 if (LangOpts.OpenCL)
2697 else if (LangOpts.CUDA)
2699 else if (LangOpts.RenderScript)
2701 else if (LangOpts.CPlusPlus)
2717ASTUnit::ConcurrencyState::ConcurrencyState() {
2718 Mutex =
new std::recursive_mutex;
2721ASTUnit::ConcurrencyState::~ConcurrencyState() {
2722 delete static_cast<std::recursive_mutex *
>(Mutex);
2725void ASTUnit::ConcurrencyState::start() {
2726 bool acquired =
static_cast<std::recursive_mutex *
>(Mutex)->try_lock();
2727 assert(acquired &&
"Concurrent access to ASTUnit!");
2730void ASTUnit::ConcurrencyState::finish() {
2731 static_cast<std::recursive_mutex *
>(Mutex)->unlock();
2736ASTUnit::ConcurrencyState::ConcurrencyState() { Mutex =
nullptr; }
2737ASTUnit::ConcurrencyState::~ConcurrencyState() {}
2738void ASTUnit::ConcurrencyState::start() {}
2739void 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.
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
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=std::nullopt, 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...
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=std::nullopt, 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
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()
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.
static std::unique_ptr< ASTUnit > LoadFromASTFile(const std::string &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.
Writes an AST file containing the contents of a translation unit.
ASTFileSignature WriteAST(Sema &SemaRef, StringRef OutputFile, Module *WritingModule, StringRef isysroot, bool ShouldCacheASTInMemory=false)
Write a precompiled header for the given semantic analysis.
LocalDeclID getDeclID(const Decl *D)
Determine the local declaration ID of an already-emitted declaration.
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()
A map from continuous integer ranges to some value, with a very specialized interface.
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...
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) ...
const SourceLocation & getLocation() const
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
FileSystemOptions & getFileSystemOpts()
Returns the current file system options.
llvm::IntrusiveRefCntPtr< llvm::vfs::FileSystem > getVirtualFileSystemPtr() const
llvm::ErrorOr< const FileEntry * > getFile(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)
Lookup, cache, and verify the specified file (real or virtual).
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.
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.
@ 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.
bool isWrittenInMainFile(SourceLocation Loc) const
Returns true if the spelling location for the given location is in the main file buffer.
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.
@ 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)
@ 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....
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.
void ProcessWarningOptions(DiagnosticsEngine &Diags, const DiagnosticOptions &Opts, bool ReportDiags=true)
ProcessWarningOptions - Initialize the diagnostic client and process the warning options specified on...
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)
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.
@ CCP_NestedNameSpecifier
Priority for a nested-name-specifier.
@ CCP_CodePattern
Priority for a code pattern.
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.