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/SmallString.h"
72#include "llvm/ADT/SmallVector.h"
73#include "llvm/ADT/StringMap.h"
74#include "llvm/ADT/StringRef.h"
75#include "llvm/ADT/StringSet.h"
76#include "llvm/ADT/Twine.h"
77#include "llvm/ADT/iterator_range.h"
78#include "llvm/Bitstream/BitstreamWriter.h"
79#include "llvm/Support/Allocator.h"
80#include "llvm/Support/Casting.h"
81#include "llvm/Support/CrashRecoveryContext.h"
82#include "llvm/Support/DJB.h"
83#include "llvm/Support/ErrorHandling.h"
84#include "llvm/Support/ErrorOr.h"
85#include "llvm/Support/FileSystem.h"
86#include "llvm/Support/FileUtilities.h"
87#include "llvm/Support/MemoryBuffer.h"
88#include "llvm/Support/SaveAndRestore.h"
89#include "llvm/Support/Timer.h"
90#include "llvm/Support/VirtualFileSystem.h"
91#include "llvm/Support/raw_ostream.h"
106using namespace clang;
108using llvm::TimeRecord;
118 explicit SimpleTimer(
bool WantTiming) : WantTiming(WantTiming) {
120 Start = TimeRecord::getCurrentTime();
125 TimeRecord Elapsed = TimeRecord::getCurrentTime();
127 llvm::errs() << Output <<
':';
128 Elapsed.print(Elapsed, llvm::errs());
129 llvm::errs() <<
'\n';
133 void setOutput(
const Twine &Output) {
135 this->Output = Output.str();
142static std::unique_ptr<T>
valueOrNull(llvm::ErrorOr<std::unique_ptr<T>> Val) {
145 return std::move(*Val);
152 Output = std::move(*Val);
158static std::unique_ptr<llvm::MemoryBuffer>
160 llvm::vfs::FileSystem *VFS,
161 StringRef FilePath,
bool isVolatile) {
167 llvm::MemoryBuffer *Buffer =
nullptr;
168 std::unique_ptr<llvm::MemoryBuffer> BufferOwner;
169 auto FileStatus = VFS->status(FilePath);
171 llvm::sys::fs::UniqueID MainFileID = FileStatus->getUniqueID();
174 for (
const auto &RF : PreprocessorOpts.RemappedFiles) {
175 std::string MPath(RF.first);
176 auto MPathStatus = VFS->status(MPath);
178 llvm::sys::fs::UniqueID MID = MPathStatus->getUniqueID();
179 if (MainFileID == MID) {
181 BufferOwner =
valueOrNull(VFS->getBufferForFile(RF.second, -1,
true, isVolatile));
190 for (
const auto &RB : PreprocessorOpts.RemappedFileBuffers) {
191 std::string MPath(RB.first);
192 auto MPathStatus = VFS->status(MPath);
194 llvm::sys::fs::UniqueID MID = MPathStatus->getUniqueID();
195 if (MainFileID == MID) {
198 Buffer =
const_cast<llvm::MemoryBuffer *
>(RB.second);
205 if (!Buffer && !BufferOwner) {
206 BufferOwner =
valueOrNull(VFS->getBufferForFile(FilePath, -1,
true, isVolatile));
215 return llvm::MemoryBuffer::getMemBufferCopy(Buffer->getBuffer(), FilePath);
227void ASTUnit::clearFileLevelDecls() {
242ASTUnit::ASTUnit(
bool _MainFileIsAST)
243 : MainFileIsAST(_MainFileIsAST), WantTiming(getenv(
"LIBCLANG_TIMING")),
244 ShouldCacheCodeCompletionResults(
false),
245 IncludeBriefCommentsInCodeCompletion(
false), UserFilesAreVolatile(
false),
246 UnsafeToFree(
false) {
247 if (getenv(
"LIBCLANG_OBJTRACKING"))
257 clearFileLevelDecls();
263 if (Invocation && OwnsRemappedFileBuffers) {
269 ClearCachedCompletionResults();
271 if (getenv(
"LIBCLANG_OBJTRACKING"))
276 this->PP = std::move(PP);
281 "Bad context for source file");
289 bool &IsNestedNameSpecifier) {
290 IsNestedNameSpecifier =
false;
292 if (isa<UsingShadowDecl>(ND))
297 uint64_t Contexts = 0;
298 if (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND) ||
299 isa<ClassTemplateDecl>(ND) || isa<TemplateTemplateParmDecl>(ND) ||
300 isa<TypeAliasTemplateDecl>(ND)) {
302 if (LangOpts.CPlusPlus || !isa<TagDecl>(ND))
311 if (LangOpts.CPlusPlus)
316 if (LangOpts.CPlusPlus || isa<ObjCInterfaceDecl>(ND))
320 if (
const auto *ID = dyn_cast<ObjCInterfaceDecl>(ND)) {
322 if (ID->getDefinition())
328 if (isa<EnumDecl>(ND)) {
332 if (LangOpts.CPlusPlus11)
333 IsNestedNameSpecifier =
true;
334 }
else if (
const auto *Record = dyn_cast<RecordDecl>(ND)) {
335 if (Record->isUnion())
340 if (LangOpts.CPlusPlus)
341 IsNestedNameSpecifier =
true;
342 }
else if (isa<ClassTemplateDecl>(ND))
343 IsNestedNameSpecifier =
true;
344 }
else if (isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND)) {
350 }
else if (isa<ObjCProtocolDecl>(ND)) {
352 }
else if (isa<ObjCCategoryDecl>(ND)) {
354 }
else if (isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND)) {
358 IsNestedNameSpecifier =
true;
364void ASTUnit::CacheCodeCompletionResults() {
368 SimpleTimer Timer(WantTiming);
369 Timer.setOutput(
"Cache global code completions for " +
getMainFileName());
372 ClearCachedCompletionResults();
377 CachedCompletionAllocator = std::make_shared<GlobalCodeCompletionAllocator>();
379 TheSema->GatherGlobalCodeCompletions(*CachedCompletionAllocator,
383 llvm::DenseMap<CanQualType, unsigned> CompletionTypes;
386 for (
auto &R : Results) {
388 case Result::RK_Declaration: {
389 bool IsNestedNameSpecifier =
false;
390 CachedCodeCompletionResult CachedResult;
391 CachedResult.Completion = R.CreateCodeCompletionString(
392 *TheSema, CCContext, *CachedCompletionAllocator, CCTUInfo,
393 IncludeBriefCommentsInCodeCompletion);
395 R.Declaration, Ctx->getLangOpts(), IsNestedNameSpecifier);
396 CachedResult.Priority = R.Priority;
397 CachedResult.Kind = R.CursorKind;
398 CachedResult.Availability = R.Availability;
405 CachedResult.Type = 0;
414 unsigned &TypeValue = CompletionTypes[CanUsageType];
415 if (TypeValue == 0) {
416 TypeValue = CompletionTypes.size();
421 CachedResult.Type = TypeValue;
424 CachedCompletionResults.push_back(CachedResult);
427 if (TheSema->Context.getLangOpts().CPlusPlus && IsNestedNameSpecifier &&
428 !R.StartsNestedNameSpecifier) {
444 if (isa<NamespaceDecl>(R.Declaration) ||
445 isa<NamespaceAliasDecl>(R.Declaration))
448 if (uint64_t RemainingContexts
449 = NNSContexts & ~CachedResult.ShowInContexts) {
453 R.StartsNestedNameSpecifier =
true;
454 CachedResult.Completion = R.CreateCodeCompletionString(
455 *TheSema, CCContext, *CachedCompletionAllocator, CCTUInfo,
456 IncludeBriefCommentsInCodeCompletion);
457 CachedResult.ShowInContexts = RemainingContexts;
460 CachedResult.Type = 0;
461 CachedCompletionResults.push_back(CachedResult);
467 case Result::RK_Keyword:
468 case Result::RK_Pattern:
473 case Result::RK_Macro: {
474 CachedCodeCompletionResult CachedResult;
475 CachedResult.Completion = R.CreateCodeCompletionString(
476 *TheSema, CCContext, *CachedCompletionAllocator, CCTUInfo,
477 IncludeBriefCommentsInCodeCompletion);
478 CachedResult.ShowInContexts
492 CachedResult.Priority = R.Priority;
493 CachedResult.Kind = R.CursorKind;
494 CachedResult.Availability = R.Availability;
496 CachedResult.Type = 0;
497 CachedCompletionResults.push_back(CachedResult);
504 CompletionCacheTopLevelHashValue = CurrentTopLevelHashValue;
507void ASTUnit::ClearCachedCompletionResults() {
508 CachedCompletionResults.clear();
509 CachedCompletionTypes.clear();
510 CachedCompletionAllocator =
nullptr;
523 std::shared_ptr<TargetOptions> &TargetOpts;
526 bool InitializedLanguage =
false;
527 bool InitializedHeaderSearchPaths =
false;
533 std::shared_ptr<TargetOptions> &TargetOpts,
535 : PP(PP), Context(Context), HSOpts(HSOpts), PPOpts(PPOpts),
536 LangOpt(LangOpt), TargetOpts(TargetOpts),
Target(
Target),
539 bool ReadLanguageOptions(
const LangOptions &LangOpts,
bool Complain,
540 bool AllowCompatibleDifferences)
override {
541 if (InitializedLanguage)
545 InitializedLanguage =
true;
552 StringRef SpecificModuleCachePath,
553 bool Complain)
override {
559 this->HSOpts = HSOpts;
565 bool Complain)
override {
566 if (InitializedHeaderSearchPaths)
580 InitializedHeaderSearchPaths =
true;
586 std::string &SuggestedPredefines)
override {
587 this->PPOpts = PPOpts;
591 bool ReadTargetOptions(
const TargetOptions &TargetOpts,
bool Complain,
592 bool AllowCompatibleDifferences)
override {
597 this->TargetOpts = std::make_shared<TargetOptions>(TargetOpts);
606 unsigned Value)
override {
612 if (!Target || !InitializedLanguage)
644 bool CaptureNonErrorsFromIncludes =
true;
649 FilterAndStoreDiagnosticConsumer(
652 bool CaptureNonErrorsFromIncludes)
653 : StoredDiags(StoredDiags), StandaloneDiags(StandaloneDiags),
654 CaptureNonErrorsFromIncludes(CaptureNonErrorsFromIncludes) {
655 assert((StoredDiags || StandaloneDiags) &&
656 "No output collections were passed to StoredDiagnosticConsumer.");
661 this->LangOpts = &LangOpts;
672class CaptureDroppedDiagnostics {
674 FilterAndStoreDiagnosticConsumer Client;
676 std::unique_ptr<DiagnosticConsumer> OwningPreviousClient;
679 CaptureDroppedDiagnostics(
684 Client(StoredDiags, StandaloneDiags,
685 CaptureDiagnostics !=
687 if (CaptureDiagnostics != CaptureDiagsKind::None ||
695 ~CaptureDroppedDiagnostics() {
697 Diags.
setClient(PreviousClient, !!OwningPreviousClient.release());
715void FilterAndStoreDiagnosticConsumer::HandleDiagnostic(
731 StoredDiags->emplace_back(Level, Info);
732 ResultDiag = &StoredDiags->back();
735 if (StandaloneDiags) {
736 std::optional<StoredDiagnostic> StoredDiag;
738 StoredDiag.emplace(Level, Info);
739 ResultDiag = &*StoredDiag;
741 StandaloneDiags->push_back(
753 return &WriterData->Writer;
759 return &WriterData->Writer;
763std::unique_ptr<llvm::MemoryBuffer>
766 auto Buffer = FileMgr->getBufferForFile(
Filename, UserFilesAreVolatile);
768 return std::move(*Buffer);
770 *ErrorStr = Buffer.getError().message();
778 assert(Diags.get() &&
"no DiagnosticsEngine was provided");
780 Diags->setClient(
new FilterAndStoreDiagnosticConsumer(
781 &AST.StoredDiagnostics,
nullptr,
790 bool AllowASTWithCompilerErrors,
bool UserFilesAreVolatile,
792 std::unique_ptr<ASTUnit> AST(
new ASTUnit(
true));
795 llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
796 ASTUnitCleanup(AST.get());
798 llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine>>
799 DiagCleanup(Diags.get());
801 ConfigureDiags(Diags, *AST, CaptureDiagnostics);
803 AST->LangOpts = std::make_shared<LangOptions>();
804 AST->OnlyLocalDecls = OnlyLocalDecls;
805 AST->CaptureDiagnostics = CaptureDiagnostics;
806 AST->Diagnostics = Diags;
807 AST->FileMgr =
new FileManager(FileSystemOpts, VFS);
808 AST->UserFilesAreVolatile = UserFilesAreVolatile;
810 AST->getFileManager(),
811 UserFilesAreVolatile);
813 AST->HSOpts = std::make_shared<HeaderSearchOptions>();
814 AST->HSOpts->ModuleFormat = std::string(PCHContainerRdr.
getFormat());
816 AST->getSourceManager(),
817 AST->getDiagnostics(),
820 AST->PPOpts = std::make_shared<PreprocessorOptions>();
827 AST->PP = std::make_shared<Preprocessor>(
828 AST->PPOpts, AST->getDiagnostics(), *AST->LangOpts,
829 AST->getSourceManager(), HeaderInfo, AST->ModuleLoader,
835 AST->Ctx =
new ASTContext(*AST->LangOpts, AST->getSourceManager(),
838 AST->getTranslationUnitKind());
842 if (::getenv(
"LIBCLANG_DISABLE_PCH_VALIDATION"))
845 PP, *AST->ModuleCache, AST->Ctx.get(), PCHContainerRdr, {},
847 disableValid, AllowASTWithCompilerErrors);
849 AST->Reader->setListener(std::make_unique<ASTInfoCollector>(
850 *AST->PP, AST->Ctx.get(), *AST->HSOpts, *AST->PPOpts, *AST->LangOpts,
851 AST->TargetOpts, AST->Target, Counter));
859 AST->Ctx->setExternalSource(AST->Reader);
872 AST->getDiagnostics().Report(diag::err_fe_unable_to_load_pch);
876 AST->OriginalSourceFile = std::string(AST->Reader->getOriginalSourceFile());
881 if (M && AST->getLangOpts().isCompilingModule() && M->
isModulePurview())
882 AST->Ctx->setNamedModuleForCodeGen(M);
890 AST->TheSema.reset(
new Sema(PP, *AST->Ctx, *AST->Consumer));
891 AST->TheSema->Initialize();
892 AST->Reader->InitializeSema(*AST->TheSema);
896 AST->getDiagnostics().getClient()->BeginSourceFile(PP.
getLangOpts(), &PP);
910class MacroDefinitionTrackerPPCallbacks :
public PPCallbacks {
914 explicit MacroDefinitionTrackerPPCallbacks(
unsigned &Hash) : Hash(Hash) {}
916 void MacroDefined(
const Token &MacroNameTok,
936 if (
const auto *ND = dyn_cast<NamedDecl>(D)) {
937 if (
const auto *EnumD = dyn_cast<EnumDecl>(D)) {
940 if (!EnumD->isScoped()) {
941 for (
const auto *EI : EnumD->enumerators()) {
942 if (EI->getIdentifier())
943 Hash = llvm::djbHash(EI->getIdentifier()->getName(), Hash);
948 if (ND->getIdentifier())
949 Hash = llvm::djbHash(ND->getIdentifier()->getName(), Hash);
951 std::string NameStr = Name.getAsString();
952 Hash = llvm::djbHash(NameStr, Hash);
957 if (
const auto *ImportD = dyn_cast<ImportDecl>(D)) {
958 if (
const Module *Mod = ImportD->getImportedModule()) {
959 std::string ModName = Mod->getFullModuleName();
960 Hash = llvm::djbHash(ModName, Hash);
968class TopLevelDeclTrackerConsumer :
public ASTConsumer {
973 TopLevelDeclTrackerConsumer(
ASTUnit &_Unit,
unsigned &Hash)
974 : Unit(_Unit), Hash(Hash) {
978 void handleTopLevelDecl(
Decl *D) {
986 if (isa<ObjCMethodDecl>(D))
992 handleFileLevelDecl(D);
995 void handleFileLevelDecl(
Decl *D) {
997 if (
auto *NSD = dyn_cast<NamespaceDecl>(D)) {
998 for (
auto *I : NSD->decls())
999 handleFileLevelDecl(I);
1004 for (
auto *TopLevelDecl : D)
1005 handleTopLevelDecl(TopLevelDecl);
1012 void HandleTopLevelDeclInObjCContainer(
DeclGroupRef D)
override {
1013 for (
auto *TopLevelDecl : D)
1014 handleTopLevelDecl(TopLevelDecl);
1031 StringRef InFile)
override {
1033 std::make_unique<MacroDefinitionTrackerPPCallbacks>(
1035 return std::make_unique<TopLevelDeclTrackerConsumer>(
1040 TopLevelDeclTrackerAction(
ASTUnit &_Unit) : Unit(_Unit) {}
1042 bool hasCodeCompletionSupport()
const override {
return false; }
1051 unsigned getHash()
const {
return Hash; }
1053 std::vector<Decl *> takeTopLevelDecls() {
return std::move(TopLevelDecls); }
1055 std::vector<serialization::DeclID> takeTopLevelDeclIDs() {
1056 return std::move(TopLevelDeclIDs);
1059 void AfterPCHEmitted(
ASTWriter &Writer)
override {
1060 TopLevelDeclIDs.reserve(TopLevelDecls.size());
1061 for (
const auto *D : TopLevelDecls) {
1063 if (D->isInvalidDecl())
1065 TopLevelDeclIDs.push_back(Writer.
getDeclID(D));
1070 for (
auto *D : DG) {
1075 if (isa<ObjCMethodDecl>(D))
1078 TopLevelDecls.push_back(D);
1082 std::unique_ptr<PPCallbacks> createPPCallbacks()
override {
1083 return std::make_unique<MacroDefinitionTrackerPPCallbacks>(Hash);
1088 std::vector<Decl *> TopLevelDecls;
1089 std::vector<serialization::DeclID> TopLevelDeclIDs;
1114 for (
auto &SD : StoredDiagnostics) {
1115 if (SD.getLocation().isValid()) {
1117 SD.setLocation(Loc);
1127bool ASTUnit::Parse(std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1128 std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer,
1134 assert(VFS == &FileMgr->getVirtualFileSystem() &&
1135 "VFS passed to Parse and VFS in FileMgr are different");
1137 auto CCInvocation = std::make_shared<CompilerInvocation>(*Invocation);
1138 if (OverrideMainBuffer) {
1140 "No preamble was built, but OverrideMainBuffer is not null");
1141 Preamble->AddImplicitPreamble(*CCInvocation, VFS, OverrideMainBuffer.get());
1146 std::unique_ptr<CompilerInstance> Clang(
1150 auto CleanOnError = llvm::make_scope_exit([&]() {
1152 SavedMainFileBuffer =
nullptr;
1156 transferASTDataFromCompilerInstance(*Clang);
1157 FailedParseDiagnostics.swap(StoredDiagnostics);
1158 StoredDiagnostics.clear();
1159 NumStoredDiagnosticsFromDriver = 0;
1165 if (VFS && FileMgr && &FileMgr->getVirtualFileSystem() == VFS)
1166 Clang->setFileManager(&*FileMgr);
1168 FileMgr = Clang->createFileManager(std::move(VFS));
1171 llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
1172 CICleanup(Clang.get());
1174 Clang->setInvocation(CCInvocation);
1175 OriginalSourceFile =
1176 std::string(Clang->getFrontendOpts().Inputs[0].getFile());
1183 if (!Clang->createTarget())
1186 assert(Clang->getFrontendOpts().Inputs.size() == 1 &&
1187 "Invocation must have exactly one source file!");
1188 assert(Clang->getFrontendOpts().Inputs[0].getKind().getFormat() ==
1190 "FIXME: AST inputs not yet supported here!");
1191 assert(Clang->getFrontendOpts().Inputs[0].getKind().getLanguage() !=
1193 "IR inputs not support here!");
1196 LangOpts = Clang->getInvocation().LangOpts;
1197 FileSystemOpts = Clang->getFileSystemOpts();
1202 UserFilesAreVolatile);
1203 if (!OverrideMainBuffer) {
1205 TopLevelDeclsInPreamble.clear();
1213 if (OverrideMainBuffer) {
1222 SavedMainFileBuffer = std::move(OverrideMainBuffer);
1225 std::unique_ptr<TopLevelDeclTrackerAction> Act(
1226 new TopLevelDeclTrackerAction(*
this));
1229 llvm::CrashRecoveryContextCleanupRegistrar<TopLevelDeclTrackerAction>
1230 ActCleanup(Act.get());
1232 if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0]))
1235 if (SavedMainFileBuffer)
1237 PreambleDiagnostics, StoredDiagnostics);
1239 PreambleSrcLocCache.clear();
1241 if (llvm::Error Err = Act->Execute()) {
1242 consumeError(std::move(Err));
1246 transferASTDataFromCompilerInstance(*Clang);
1248 Act->EndSourceFile();
1250 FailedParseDiagnostics.clear();
1252 CleanOnError.release();
1257static std::pair<unsigned, unsigned>
1262 unsigned EndOffset =
SM.getFileOffset(FileRange.
getEnd());
1263 return std::make_pair(
Offset, EndOffset);
1290 OutDiag.
Filename = std::string(
SM.getFilename(FileLoc));
1294 for (
const auto &Range : InDiag.
getRanges())
1296 for (
const auto &FixIt : InDiag.
getFixIts())
1322std::unique_ptr<llvm::MemoryBuffer>
1323ASTUnit::getMainBufferWithPrecompiledPreamble(
1324 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1327 unsigned MaxLines) {
1330 std::unique_ptr<llvm::MemoryBuffer> MainFileBuffer =
1332 MainFilePath, UserFilesAreVolatile);
1333 if (!MainFileBuffer)
1337 *PreambleInvocationIn.
getLangOpts(), *MainFileBuffer, MaxLines);
1342 if (Preamble->CanReuse(PreambleInvocationIn, *MainFileBuffer, Bounds,
1353 PreambleRebuildCountdown = 1;
1354 return MainFileBuffer;
1357 PreambleDiagnostics.clear();
1358 TopLevelDeclsInPreamble.clear();
1359 PreambleSrcLocCache.clear();
1360 PreambleRebuildCountdown = 1;
1367 if (PreambleRebuildCountdown > 1) {
1368 --PreambleRebuildCountdown;
1372 assert(!Preamble &&
"No Preamble should be stored at that point");
1382 ASTUnitPreambleCallbacks Callbacks;
1384 std::optional<CaptureDroppedDiagnostics>
Capture;
1386 Capture.emplace(CaptureDiagnostics, *Diagnostics, &NewPreambleDiags,
1387 &NewPreambleDiagsStandalone);
1390 SimpleTimer PreambleTimer(WantTiming);
1391 PreambleTimer.setOutput(
"Precompiling preamble");
1393 const bool PreviousSkipFunctionBodies =
1399 PreambleInvocationIn, MainFileBuffer.get(), Bounds, *Diagnostics, VFS,
1400 PCHContainerOps, StorePreamblesInMemory, PreambleStoragePath,
1404 PreviousSkipFunctionBodies;
1407 Preamble = std::move(*NewPreamble);
1408 PreambleRebuildCountdown = 1;
1413 PreambleRebuildCountdown = 1;
1423 llvm_unreachable(
"unexpected BuildPreambleError");
1427 assert(Preamble &&
"Preamble wasn't built");
1429 TopLevelDecls.clear();
1430 TopLevelDeclsInPreamble = Callbacks.takeTopLevelDeclIDs();
1431 PreambleTopLevelHashValue = Callbacks.getHash();
1436 StoredDiagnostics = std::move(NewPreambleDiags);
1437 PreambleDiagnostics = std::move(NewPreambleDiagsStandalone);
1442 if (CurrentTopLevelHashValue != PreambleTopLevelHashValue) {
1443 CompletionCacheTopLevelHashValue = 0;
1444 PreambleTopLevelHashValue = CurrentTopLevelHashValue;
1447 return MainFileBuffer;
1450void ASTUnit::RealizeTopLevelDeclsFromPreamble() {
1451 assert(Preamble &&
"Should only be called when preamble was built");
1453 std::vector<Decl *> Resolved;
1454 Resolved.reserve(TopLevelDeclsInPreamble.size());
1456 for (
const auto TopLevelDecl : TopLevelDeclsInPreamble) {
1460 Resolved.push_back(D);
1462 TopLevelDeclsInPreamble.clear();
1463 TopLevelDecls.insert(TopLevelDecls.begin(), Resolved.begin(), Resolved.end());
1486 if (Invocation && !Invocation->getFrontendOpts().Inputs.empty()) {
1491 return Input.
getBuffer().getBufferIdentifier();
1497 return FE->getName();
1508 Mod = Reader->getModuleManager().getPrimaryModule();
1512std::unique_ptr<ASTUnit>
1516 bool UserFilesAreVolatile) {
1517 std::unique_ptr<ASTUnit> AST(
new ASTUnit(
false));
1518 ConfigureDiags(Diags, *AST, CaptureDiagnostics);
1521 AST->Diagnostics = Diags;
1522 AST->FileSystemOpts = CI->getFileSystemOpts();
1523 AST->Invocation = std::move(CI);
1524 AST->FileMgr =
new FileManager(AST->FileSystemOpts, VFS);
1525 AST->UserFilesAreVolatile = UserFilesAreVolatile;
1526 AST->SourceMgr =
new SourceManager(AST->getDiagnostics(), *AST->FileMgr,
1527 UserFilesAreVolatile);
1534 std::shared_ptr<CompilerInvocation> CI,
1535 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1537 ASTUnit *Unit,
bool Persistent, StringRef ResourceFilesPath,
1539 unsigned PrecompilePreambleAfterNParses,
bool CacheCodeCompletionResults,
1540 bool UserFilesAreVolatile, std::unique_ptr<ASTUnit> *ErrAST) {
1541 assert(CI &&
"A CompilerInvocation is required");
1543 std::unique_ptr<ASTUnit> OwnAST;
1547 OwnAST =
create(CI, Diags, CaptureDiagnostics, UserFilesAreVolatile);
1553 if (!ResourceFilesPath.empty()) {
1557 AST->OnlyLocalDecls = OnlyLocalDecls;
1558 AST->CaptureDiagnostics = CaptureDiagnostics;
1559 if (PrecompilePreambleAfterNParses > 0)
1560 AST->PreambleRebuildCountdown = PrecompilePreambleAfterNParses;
1562 AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults;
1563 AST->IncludeBriefCommentsInCodeCompletion =
false;
1566 llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
1567 ASTUnitCleanup(OwnAST.get());
1569 llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine>>
1570 DiagCleanup(Diags.get());
1573 CI->getPreprocessorOpts().RetainRemappedFileBuffers =
true;
1574 CI->getFrontendOpts().DisableFree =
false;
1578 std::unique_ptr<CompilerInstance> Clang(
1582 llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
1583 CICleanup(Clang.get());
1585 Clang->setInvocation(std::move(CI));
1586 AST->OriginalSourceFile =
1587 std::string(Clang->getFrontendOpts().Inputs[0].getFile());
1594 if (!Clang->createTarget())
1597 assert(Clang->getFrontendOpts().Inputs.size() == 1 &&
1598 "Invocation must have exactly one source file!");
1599 assert(Clang->getFrontendOpts().Inputs[0].getKind().getFormat() ==
1601 "FIXME: AST inputs not yet supported here!");
1602 assert(Clang->getFrontendOpts().Inputs[0].getKind().getLanguage() !=
1604 "IR inputs not support here!");
1607 AST->TheSema.reset();
1610 AST->Reader =
nullptr;
1620 std::unique_ptr<TopLevelDeclTrackerAction> TrackerAct;
1622 TrackerAct.reset(
new TopLevelDeclTrackerAction(*AST));
1623 Act = TrackerAct.get();
1627 llvm::CrashRecoveryContextCleanupRegistrar<TopLevelDeclTrackerAction>
1628 ActCleanup(TrackerAct.get());
1630 if (!Act->
BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) {
1631 AST->transferASTDataFromCompilerInstance(*Clang);
1632 if (OwnAST && ErrAST)
1633 ErrAST->swap(OwnAST);
1638 if (Persistent && !TrackerAct) {
1639 Clang->getPreprocessor().addPPCallbacks(
1640 std::make_unique<MacroDefinitionTrackerPPCallbacks>(
1642 std::vector<std::unique_ptr<ASTConsumer>> Consumers;
1643 if (Clang->hasASTConsumer())
1644 Consumers.push_back(Clang->takeASTConsumer());
1645 Consumers.push_back(std::make_unique<TopLevelDeclTrackerConsumer>(
1647 Clang->setASTConsumer(
1648 std::make_unique<MultiplexConsumer>(std::move(Consumers)));
1650 if (llvm::Error Err = Act->
Execute()) {
1651 consumeError(std::move(Err));
1652 AST->transferASTDataFromCompilerInstance(*Clang);
1653 if (OwnAST && ErrAST)
1654 ErrAST->swap(OwnAST);
1660 AST->transferASTDataFromCompilerInstance(*Clang);
1665 return OwnAST.release();
1670bool ASTUnit::LoadFromCompilerInvocation(
1671 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1672 unsigned PrecompilePreambleAfterNParses,
1677 assert(VFS &&
"VFS is null");
1680 Invocation->getPreprocessorOpts().RetainRemappedFileBuffers =
true;
1681 Invocation->getFrontendOpts().DisableFree =
false;
1685 std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer;
1686 if (PrecompilePreambleAfterNParses > 0) {
1687 PreambleRebuildCountdown = PrecompilePreambleAfterNParses;
1688 OverrideMainBuffer =
1689 getMainBufferWithPrecompiledPreamble(PCHContainerOps, *Invocation, VFS);
1694 SimpleTimer ParsingTimer(WantTiming);
1698 llvm::CrashRecoveryContextCleanupRegistrar<llvm::MemoryBuffer>
1699 MemBufferCleanup(OverrideMainBuffer.get());
1701 return Parse(std::move(PCHContainerOps), std::move(OverrideMainBuffer), VFS);
1704std::unique_ptr<ASTUnit> ASTUnit::LoadFromCompilerInvocation(
1705 std::shared_ptr<CompilerInvocation> CI,
1706 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1710 bool CacheCodeCompletionResults,
bool IncludeBriefCommentsInCodeCompletion,
1711 bool UserFilesAreVolatile) {
1713 std::unique_ptr<ASTUnit> AST(
new ASTUnit(
false));
1714 ConfigureDiags(Diags, *AST, CaptureDiagnostics);
1715 AST->Diagnostics = Diags;
1716 AST->OnlyLocalDecls = OnlyLocalDecls;
1717 AST->CaptureDiagnostics = CaptureDiagnostics;
1718 AST->TUKind = TUKind;
1719 AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults;
1720 AST->IncludeBriefCommentsInCodeCompletion
1721 = IncludeBriefCommentsInCodeCompletion;
1722 AST->Invocation = std::move(CI);
1724 AST->FileMgr = FileMgr;
1725 AST->UserFilesAreVolatile = UserFilesAreVolatile;
1728 llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
1729 ASTUnitCleanup(AST.get());
1731 llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine>>
1732 DiagCleanup(Diags.get());
1734 if (AST->LoadFromCompilerInvocation(std::move(PCHContainerOps),
1735 PrecompilePreambleAfterNParses,
1736 &AST->FileMgr->getVirtualFileSystem()))
1742 const char **ArgBegin,
const char **ArgEnd,
1743 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1745 bool StorePreamblesInMemory, StringRef PreambleStoragePath,
1749 bool CacheCodeCompletionResults,
bool IncludeBriefCommentsInCodeCompletion,
1751 bool SingleFileParse,
bool UserFilesAreVolatile,
bool ForSerialization,
1752 bool RetainExcludedConditionalBlocks, std::optional<StringRef> ModuleFormat,
1753 std::unique_ptr<ASTUnit> *ErrAST,
1755 assert(Diags.get() &&
"no DiagnosticsEngine was provided");
1759 std::shared_ptr<CompilerInvocation> CI;
1762 CaptureDroppedDiagnostics
Capture(CaptureDiagnostics, *Diags,
1763 &StoredDiagnostics,
nullptr);
1767 CIOpts.
Diags = Diags;
1776 CI->getPreprocessorOpts().addRemappedFile(
RemappedFile.first,
1786 CI->getHeaderSearchOpts().ResourceDir = std::string(ResourceFilesPath);
1788 CI->getFrontendOpts().SkipFunctionBodies =
1792 CI->getHeaderSearchOpts().ModuleFormat = std::string(*ModuleFormat);
1795 std::unique_ptr<ASTUnit> AST;
1796 AST.reset(
new ASTUnit(
false));
1797 AST->NumStoredDiagnosticsFromDriver = StoredDiagnostics.size();
1798 AST->StoredDiagnostics.swap(StoredDiagnostics);
1799 ConfigureDiags(Diags, *AST, CaptureDiagnostics);
1800 AST->Diagnostics = Diags;
1801 AST->FileSystemOpts = CI->getFileSystemOpts();
1803 VFS = llvm::vfs::getRealFileSystem();
1805 AST->FileMgr =
new FileManager(AST->FileSystemOpts, VFS);
1806 AST->StorePreamblesInMemory = StorePreamblesInMemory;
1807 AST->PreambleStoragePath = PreambleStoragePath;
1809 AST->OnlyLocalDecls = OnlyLocalDecls;
1810 AST->CaptureDiagnostics = CaptureDiagnostics;
1811 AST->TUKind = TUKind;
1812 AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults;
1813 AST->IncludeBriefCommentsInCodeCompletion
1814 = IncludeBriefCommentsInCodeCompletion;
1815 AST->UserFilesAreVolatile = UserFilesAreVolatile;
1816 AST->Invocation = CI;
1817 AST->SkipFunctionBodies = SkipFunctionBodies;
1818 if (ForSerialization)
1819 AST->WriterData.reset(
new ASTWriterData(*AST->ModuleCache));
1825 llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
1826 ASTUnitCleanup(AST.get());
1828 if (AST->LoadFromCompilerInvocation(std::move(PCHContainerOps),
1829 PrecompilePreambleAfterNParses,
1834 AST->StoredDiagnostics.swap(AST->FailedParseDiagnostics);
1840 return AST.release();
1850 assert(FileMgr &&
"FileMgr is null on Reparse call");
1851 VFS = &FileMgr->getVirtualFileSystem();
1854 clearFileLevelDecls();
1856 SimpleTimer ParsingTimer(WantTiming);
1864 Invocation->getPreprocessorOpts().clearRemappedFiles();
1866 Invocation->getPreprocessorOpts().addRemappedFile(
RemappedFile.first,
1872 std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer;
1873 if (Preamble || PreambleRebuildCountdown > 0)
1874 OverrideMainBuffer =
1875 getMainBufferWithPrecompiledPreamble(PCHContainerOps, *Invocation, VFS);
1881 if (OverrideMainBuffer)
1886 Parse(std::move(PCHContainerOps), std::move(OverrideMainBuffer), VFS);
1890 if (!
Result && ShouldCacheCodeCompletionResults &&
1891 CurrentTopLevelHashValue != CompletionCacheTopLevelHashValue)
1892 CacheCodeCompletionResults();
1902 SavedMainFileBuffer.reset();
1910 TopLevelDecls.clear();
1911 clearFileLevelDecls();
1924 uint64_t NormalContexts;
1957 unsigned NumResults)
override;
1959 void ProcessOverloadCandidates(
Sema &S,
unsigned CurrentArg,
1961 unsigned NumCandidates,
1963 bool Braced)
override {
1964 Next.ProcessOverloadCandidates(S, CurrentArg, Candidates, NumCandidates,
1965 OpenParLoc, Braced);
1969 return Next.getAllocator();
1973 return Next.getCodeCompletionTUInfo();
1983 unsigned NumResults,
1985 llvm::StringSet<llvm::BumpPtrAllocator> &HiddenNames){
1986 bool OnlyTagNames =
false;
1987 switch (Context.getKind()) {
2011 OnlyTagNames =
true;
2036 for (
unsigned I = 0; I != NumResults; ++I) {
2037 if (Results[I].Kind != Result::RK_Declaration)
2041 = Results[I].Declaration->getUnderlyingDecl()->getIdentifierNamespace();
2043 bool Hiding =
false;
2052 Hiding = (IDNS & HiddenIDNS);
2062 HiddenNames.insert(Name.getAsString());
2066void AugmentedCodeCompleteConsumer::ProcessCodeCompleteResults(
Sema &S,
2069 unsigned NumResults) {
2071 bool AddedResult =
false;
2074 ? NormalContexts : (1LL << Context.getKind());
2076 llvm::StringSet<llvm::BumpPtrAllocator> HiddenNames;
2085 if ((
C->ShowInContexts & InContexts) == 0)
2092 AllResults.insert(AllResults.end(), Results, Results + NumResults);
2099 HiddenNames.count(
C->Completion->getTypedText()))
2105 if (!Context.getPreferredType().isNull()) {
2109 Context.getPreferredType()->isAnyPointerType());
2110 }
else if (
C->Type) {
2113 Context.getPreferredType().getUnqualifiedType());
2115 if (ExpectedSTC ==
C->TypeClass) {
2117 llvm::StringMap<unsigned> &CachedCompletionTypes
2119 llvm::StringMap<unsigned>::iterator Pos
2121 if (Pos != CachedCompletionTypes.end() && Pos->second ==
C->Type)
2136 Builder.AddTypedTextChunk(
C->Completion->getTypedText());
2138 Completion = Builder.TakeString();
2141 AllResults.push_back(
Result(Completion, Priority,
C->Kind,
2148 Next.ProcessCodeCompleteResults(S, Context, Results, NumResults);
2152 Next.ProcessCodeCompleteResults(S, Context, AllResults.data(),
2157 StringRef
File,
unsigned Line,
unsigned Column,
2159 bool IncludeCodePatterns,
bool IncludeBriefComments,
2161 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
2168 SimpleTimer CompletionTimer(WantTiming);
2169 CompletionTimer.setOutput(
"Code completion @ " +
File +
":" +
2170 Twine(Line) +
":" + Twine(Column));
2172 auto CCInvocation = std::make_shared<CompilerInvocation>(*Invocation);
2179 CachedCompletionResults.empty();
2181 CodeCompleteOpts.
IncludeGlobals = CachedCompletionResults.empty();
2186 assert(IncludeBriefComments == this->IncludeBriefCommentsInCodeCompletion);
2193 LangOpts = *CCInvocation->getLangOpts();
2196 LangOpts.SpellChecking =
false;
2197 CCInvocation->getDiagnosticOpts().IgnoreWarnings =
true;
2199 std::unique_ptr<CompilerInstance> Clang(
2203 llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
2204 CICleanup(Clang.get());
2206 auto &Inv = *CCInvocation;
2207 Clang->setInvocation(std::move(CCInvocation));
2208 OriginalSourceFile =
2209 std::string(Clang->getFrontendOpts().Inputs[0].getFile());
2212 Clang->setDiagnostics(&
Diag);
2214 Clang->getDiagnostics(),
2215 &StoredDiagnostics,
nullptr);
2219 if (!Clang->createTarget()) {
2220 Clang->setInvocation(
nullptr);
2224 assert(Clang->getFrontendOpts().Inputs.size() == 1 &&
2225 "Invocation must have exactly one source file!");
2226 assert(Clang->getFrontendOpts().Inputs[0].getKind().getFormat() ==
2228 "FIXME: AST inputs not yet supported here!");
2229 assert(Clang->getFrontendOpts().Inputs[0].getKind().getLanguage() !=
2231 "IR inputs not support here!");
2234 Clang->setFileManager(&FileMgr);
2235 Clang->setSourceManager(&SourceMgr);
2247 AugmentedCodeCompleteConsumer *AugmentedConsumer
2248 =
new AugmentedCodeCompleteConsumer(*
this, Consumer, CodeCompleteOpts);
2249 Clang->setCodeCompletionConsumer(AugmentedConsumer);
2252 [&FileMgr](StringRef
Filename) -> std::optional<llvm::sys::fs::UniqueID> {
2254 return Status->getUniqueID();
2255 return std::nullopt;
2258 auto hasSameUniqueID = [getUniqueID](StringRef LHS, StringRef RHS) {
2261 if (
auto LHSID = getUniqueID(LHS))
2262 if (
auto RHSID = getUniqueID(RHS))
2263 return *LHSID == *RHSID;
2271 std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer;
2272 if (Preamble && Line > 1 && hasSameUniqueID(
File, OriginalSourceFile)) {
2273 OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(
2279 if (OverrideMainBuffer) {
2281 "No preamble was built, but OverrideMainBuffer is not null");
2285 Preamble->AddImplicitPreamble(Clang->getInvocation(), VFS,
2286 OverrideMainBuffer.get());
2291 OwnedBuffers.push_back(OverrideMainBuffer.release());
2298 if (!Clang->getLangOpts().Modules)
2301 std::unique_ptr<SyntaxOnlyAction> Act;
2303 if (Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) {
2304 if (llvm::Error Err = Act->Execute()) {
2305 consumeError(std::move(Err));
2307 Act->EndSourceFile();
2312 if (HadModuleLoaderFatalFailure)
2319 TempPath +=
"-%%%%%%%%";
2323 if (llvm::Error Err = llvm::writeFileAtomically(
2324 TempPath,
File, [
this](llvm::raw_ostream &Out) {
2325 return serialize(Out) ? llvm::make_error<llvm::StringError>(
2326 "ASTUnit serialization failed",
2327 llvm::inconvertibleErrorCode())
2328 : llvm::Error::success();
2330 consumeError(std::move(Err));
2341 Writer.
WriteAST(S, std::string(),
nullptr,
"", hasErrors);
2344 if (!Buffer.empty())
2345 OS.write(Buffer.data(), Buffer.size());
2355 return serializeUnit(WriterData->Writer, WriterData->Buffer,
2359 llvm::BitstreamWriter Stream(Buffer);
2361 ASTWriter Writer(Stream, Buffer, ModuleCache, {});
2367void ASTUnit::TranslateStoredDiagnostics(
2377 Result.reserve(Diags.size());
2379 for (
const auto &SD : Diags) {
2381 if (SD.Filename.empty())
2383 auto FE = FileMgr.
getFile(SD.Filename);
2387 auto ItFileID = PreambleSrcLocCache.find(SD.Filename);
2388 if (ItFileID == PreambleSrcLocCache.end()) {
2391 PreambleSrcLocCache[SD.Filename] = FileLoc;
2393 FileLoc = ItFileID->getValue();
2402 Ranges.reserve(SD.Ranges.size());
2403 for (
const auto &Range : SD.Ranges) {
2410 FixIts.reserve(SD.FixIts.size());
2411 for (
const auto &FixIt : SD.FixIts) {
2421 SD.Message, Loc, Ranges, FixIts));
2435 if (Loc.
isInvalid() || !
SM.isLocalSourceLocation(Loc))
2443 assert(
SM.isLocalSourceLocation(FileLoc));
2446 std::tie(FID,
Offset) =
SM.getDecomposedLoc(FileLoc);
2450 std::unique_ptr<LocDeclsTy> &Decls = FileDecls[FID];
2452 Decls = std::make_unique<LocDeclsTy>();
2454 std::pair<unsigned, Decl *> LocDecl(
Offset, D);
2456 if (Decls->empty() || Decls->back().first <=
Offset) {
2457 Decls->push_back(LocDecl);
2461 LocDeclsTy::iterator I =
2462 llvm::upper_bound(*Decls, LocDecl, llvm::less_first());
2464 Decls->insert(I, LocDecl);
2469 if (
File.isInvalid())
2473 assert(Ctx->getExternalSource() &&
"No external source!");
2474 return Ctx->getExternalSource()->FindFileRegionDecls(
File,
Offset, Length,
2478 FileDeclsTy::iterator I = FileDecls.find(
File);
2479 if (I == FileDecls.end())
2483 if (LocDecls.empty())
2486 LocDeclsTy::iterator BeginIt =
2487 llvm::partition_point(LocDecls, [=](std::pair<unsigned, Decl *> LD) {
2488 return LD.first <
Offset;
2490 if (BeginIt != LocDecls.begin())
2496 while (BeginIt != LocDecls.begin() &&
2497 BeginIt->second->isTopLevelDeclInObjCContainer())
2500 LocDeclsTy::iterator EndIt = llvm::upper_bound(
2501 LocDecls, std::make_pair(
Offset + Length, (
Decl *)
nullptr),
2502 llvm::less_first());
2503 if (EndIt != LocDecls.end())
2506 for (LocDeclsTy::iterator DIt = BeginIt; DIt != EndIt; ++DIt)
2507 Decls.push_back(DIt->second);
2511 unsigned Line,
unsigned Col)
const {
2514 return SM.getMacroArgExpandedLocation(Loc);
2536 if (SourceMgr->
isInFileID(Loc, PreambleID, &Offs) && Offs < Preamble->getBounds().Size) {
2558 Offs < Preamble->getBounds().Size) {
2610llvm::iterator_range<PreprocessingRecord::iterator>
2614 Mod = Reader->getModuleManager().getPrimaryModule();
2615 return Reader->getModulePreprocessedEntities(Mod);
2619 return llvm::make_range(PPRec->local_begin(), PPRec->local_end());
2628 Mod = Reader->getModuleManager().getPrimaryModule();
2629 for (
const auto *D : Reader->getModuleFileLevelDecls(Mod)) {
2630 if (!Fn(context, D))
2639 TL != TLEnd; ++TL) {
2640 if (!Fn(context, *TL))
2654 case serialization::MK_ImplicitModule:
2655 case serialization::MK_ExplicitModule:
2656 case serialization::MK_PrebuiltModule:
2658 case serialization::MK_PCH:
2661 case serialization::MK_Preamble:
2663 case serialization::MK_MainFile:
2683 if (LangOpts.OpenCL)
2685 else if (LangOpts.CUDA)
2687 else if (LangOpts.RenderScript)
2689 else if (LangOpts.CPlusPlus)
2705ASTUnit::ConcurrencyState::ConcurrencyState() {
2706 Mutex =
new std::recursive_mutex;
2709ASTUnit::ConcurrencyState::~ConcurrencyState() {
2710 delete static_cast<std::recursive_mutex *
>(Mutex);
2713void ASTUnit::ConcurrencyState::start() {
2714 bool acquired =
static_cast<std::recursive_mutex *
>(Mutex)->try_lock();
2715 assert(acquired &&
"Concurrent access to ASTUnit!");
2718void ASTUnit::ConcurrencyState::finish() {
2719 static_cast<std::recursive_mutex *
>(Mutex)->unlock();
2724ASTUnit::ConcurrencyState::ConcurrencyState() { Mutex =
nullptr; }
2725ASTUnit::ConcurrencyState::~ConcurrencyState() {}
2726void ASTUnit::ConcurrencyState::start() {}
2727void 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 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 serializeUnit(ASTWriter &Writer, SmallVectorImpl< char > &Buffer, Sema &S, bool hasErrors, raw_ostream &OS)
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.
static CompilationDatabasePluginRegistry::Add< FixedCompilationDatabasePlugin > X("fixed-compilation-database", "Reads plain-text flags file")
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.
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
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any.
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
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...
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)
Perform code completion at the given file, line, and column within this translation unit.
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.
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
const FileEntry * getPCHFile()
Get the PCH file if one was included.
SourceLocation getEndOfPreambleFileID() const
static std::unique_ptr< ASTUnit > LoadFromASTFile(const std::string &Filename, const PCHContainerReader &PCHContainerRdr, WhatToLoad ToLoad, IntrusiveRefCntPtr< DiagnosticsEngine > Diags, const FileSystemOptions &FileSystemOpts, bool UseDebugInfo=false, 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.
@ 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
static 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 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.
ASTFileSignature WriteAST(Sema &SemaRef, StringRef OutputFile, Module *WritingModule, StringRef isysroot, bool hasErrors=false, bool ShouldCacheASTInMemory=false)
Write a precompiled header for the given semantic analysis.
serialization::DeclID getDeclID(const Decl *D)
Determine the 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_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.
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
PreprocessorOptions & getPreprocessorOpts()
DiagnosticOptions & getDiagnosticOpts() const
LangOptions * getLangOpts()
std::shared_ptr< LangOptions > LangOpts
Options controlling the language variant.
FrontendOptions & getFrontendOpts()
Helper class for holding the data necessary to invoke the compiler.
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()
bool hasUncompilableErrorOccurred() const
Errors that actually prevent compilation, not those that are upgraded from a warning by -Werror.
unsigned getNumWarnings() const
void Reset(bool soft=false)
Reset the state of the diagnostic object to its initial configuration.
Abstract interface for external sources of AST nodes.
virtual Decl * GetExternalDecl(uint32_t ID)
Resolve a declaration ID into a declaration, potentially building a new declaration.
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.
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.
@ CMK_ModuleMap
Compiling a module from a module map.
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 isModulePurview() const
Does this Module scope describe part of the purview of a standard named C++ 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::StringRef getFormat() 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.
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.
const FileEntry * getFileEntryForID(FileID FID) const
Returns the FileEntry record for the provided FileID.
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.
std::string FileName
The file name of the module file.
OptionalFileEntryRefDegradesToFileEntryPtr File
The file entry for 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.
IntrusiveRefCntPtr< llvm::vfs::FileSystem > createVFSFromOverlayFiles(ArrayRef< std::string > VFSOverlayFiles, DiagnosticsEngine &Diags, IntrusiveRefCntPtr< llvm::vfs::FileSystem > BaseFS)
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.
@ LLVM_IR
LLVM IR: we accept this so that we can run the optimizer on it, and compile it to assembly or object ...
@ 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.
@ 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....
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.
@ CCP_NestedNameSpecifier
Priority for a nested-name-specifier.
@ CCP_CodePattern
Priority for a code pattern.
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.