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)) {
334 if (Record->isUnion())
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)
544 InitializedLanguage =
true;
551 StringRef SpecificModuleCachePath,
552 bool Complain)
override {
554 auto ForceCheckCXX20ModulesInputFiles =
560 this->HSOpts = HSOpts;
562 ForceCheckCXX20ModulesInputFiles;
568 bool Complain)
override {
569 if (InitializedHeaderSearchPaths)
583 InitializedHeaderSearchPaths =
true;
589 bool ReadMacros,
bool Complain,
590 std::string &SuggestedPredefines)
override {
591 this->PPOpts = PPOpts;
595 bool ReadTargetOptions(
const TargetOptions &TargetOpts,
bool Complain,
596 bool AllowCompatibleDifferences)
override {
601 this->TargetOpts = std::make_shared<TargetOptions>(TargetOpts);
610 unsigned Value)
override {
616 if (!Target || !InitializedLanguage)
648 bool CaptureNonErrorsFromIncludes =
true;
653 FilterAndStoreDiagnosticConsumer(
656 bool CaptureNonErrorsFromIncludes)
657 : StoredDiags(StoredDiags), StandaloneDiags(StandaloneDiags),
658 CaptureNonErrorsFromIncludes(CaptureNonErrorsFromIncludes) {
659 assert((StoredDiags || StandaloneDiags) &&
660 "No output collections were passed to StoredDiagnosticConsumer.");
665 this->LangOpts = &LangOpts;
676class CaptureDroppedDiagnostics {
678 FilterAndStoreDiagnosticConsumer Client;
680 std::unique_ptr<DiagnosticConsumer> OwningPreviousClient;
683 CaptureDroppedDiagnostics(
688 Client(StoredDiags, StandaloneDiags,
689 CaptureDiagnostics !=
691 if (CaptureDiagnostics != CaptureDiagsKind::None ||
699 ~CaptureDroppedDiagnostics() {
701 Diags.
setClient(PreviousClient, !!OwningPreviousClient.release());
719void FilterAndStoreDiagnosticConsumer::HandleDiagnostic(
735 StoredDiags->emplace_back(Level, Info);
736 ResultDiag = &StoredDiags->back();
739 if (StandaloneDiags) {
740 std::optional<StoredDiagnostic> StoredDiag;
742 StoredDiag.emplace(Level, Info);
743 ResultDiag = &*StoredDiag;
745 StandaloneDiags->push_back(
757 return &WriterData->Writer;
763 return &WriterData->Writer;
767std::unique_ptr<llvm::MemoryBuffer>
770 auto Buffer = FileMgr->getBufferForFile(
Filename, UserFilesAreVolatile);
772 return std::move(*Buffer);
774 *ErrorStr = Buffer.getError().message();
782 assert(Diags.get() &&
"no DiagnosticsEngine was provided");
784 Diags->setClient(
new FilterAndStoreDiagnosticConsumer(
785 &AST.StoredDiagnostics,
nullptr,
793 std::shared_ptr<HeaderSearchOptions> HSOpts,
bool UseDebugInfo,
795 bool AllowASTWithCompilerErrors,
bool UserFilesAreVolatile,
797 std::unique_ptr<ASTUnit> AST(
new ASTUnit(
true));
800 llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
801 ASTUnitCleanup(AST.get());
803 llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine>>
804 DiagCleanup(Diags.get());
806 ConfigureDiags(Diags, *AST, CaptureDiagnostics);
808 AST->LangOpts = std::make_shared<LangOptions>();
809 AST->OnlyLocalDecls = OnlyLocalDecls;
810 AST->CaptureDiagnostics = CaptureDiagnostics;
811 AST->Diagnostics = Diags;
812 AST->FileMgr =
new FileManager(FileSystemOpts, VFS);
813 AST->UserFilesAreVolatile = UserFilesAreVolatile;
815 AST->getFileManager(),
816 UserFilesAreVolatile);
818 AST->HSOpts = HSOpts ? HSOpts : std::make_shared<HeaderSearchOptions>();
819 AST->HSOpts->ModuleFormat = std::string(PCHContainerRdr.
getFormats().front());
821 AST->getSourceManager(),
822 AST->getDiagnostics(),
825 AST->PPOpts = std::make_shared<PreprocessorOptions>();
831 AST->PP = std::make_shared<Preprocessor>(
832 AST->PPOpts, AST->getDiagnostics(), *AST->LangOpts,
833 AST->getSourceManager(), HeaderInfo, AST->ModuleLoader,
839 AST->Ctx =
new ASTContext(*AST->LangOpts, AST->getSourceManager(),
842 AST->getTranslationUnitKind());
846 if (::getenv(
"LIBCLANG_DISABLE_PCH_VALIDATION"))
849 PP, *AST->ModuleCache, AST->Ctx.get(), PCHContainerRdr, {},
851 disableValid, AllowASTWithCompilerErrors);
853 unsigned Counter = 0;
854 AST->Reader->setListener(std::make_unique<ASTInfoCollector>(
855 *AST->PP, AST->Ctx.get(), *AST->HSOpts, *AST->PPOpts, *AST->LangOpts,
856 AST->TargetOpts, AST->Target, Counter));
864 AST->Ctx->setExternalSource(AST->Reader);
877 AST->getDiagnostics().Report(diag::err_fe_unable_to_load_pch);
881 AST->OriginalSourceFile = std::string(AST->Reader->getOriginalSourceFile());
886 if (M && AST->getLangOpts().isCompilingModule() && M->
isModulePurview())
887 AST->Ctx->setCurrentNamedModule(M);
895 AST->TheSema.reset(
new Sema(PP, *AST->Ctx, *AST->Consumer));
896 AST->TheSema->Initialize();
897 AST->Reader->InitializeSema(*AST->TheSema);
901 AST->getDiagnostics().getClient()->BeginSourceFile(PP.
getLangOpts(), &PP);
915class MacroDefinitionTrackerPPCallbacks :
public PPCallbacks {
919 explicit MacroDefinitionTrackerPPCallbacks(
unsigned &Hash) : Hash(Hash) {}
921 void MacroDefined(
const Token &MacroNameTok,
941 if (
const auto *ND = dyn_cast<NamedDecl>(D)) {
942 if (
const auto *EnumD = dyn_cast<EnumDecl>(D)) {
945 if (!EnumD->isScoped()) {
946 for (
const auto *EI : EnumD->enumerators()) {
947 if (EI->getIdentifier())
948 Hash = llvm::djbHash(EI->getIdentifier()->getName(), Hash);
953 if (ND->getIdentifier())
954 Hash = llvm::djbHash(ND->getIdentifier()->getName(), Hash);
956 std::string NameStr = Name.getAsString();
957 Hash = llvm::djbHash(NameStr, Hash);
962 if (
const auto *ImportD = dyn_cast<ImportDecl>(D)) {
963 if (
const Module *Mod = ImportD->getImportedModule()) {
964 std::string ModName = Mod->getFullModuleName();
965 Hash = llvm::djbHash(ModName, Hash);
973class TopLevelDeclTrackerConsumer :
public ASTConsumer {
978 TopLevelDeclTrackerConsumer(
ASTUnit &_Unit,
unsigned &Hash)
979 : Unit(_Unit), Hash(Hash) {
983 void handleTopLevelDecl(
Decl *D) {
991 if (isa<ObjCMethodDecl>(D))
997 handleFileLevelDecl(D);
1000 void handleFileLevelDecl(
Decl *D) {
1002 if (
auto *NSD = dyn_cast<NamespaceDecl>(D)) {
1003 for (
auto *I : NSD->decls())
1004 handleFileLevelDecl(I);
1009 for (
auto *TopLevelDecl : D)
1010 handleTopLevelDecl(TopLevelDecl);
1017 void HandleTopLevelDeclInObjCContainer(
DeclGroupRef D)
override {
1018 for (
auto *TopLevelDecl : D)
1019 handleTopLevelDecl(TopLevelDecl);
1036 StringRef InFile)
override {
1038 std::make_unique<MacroDefinitionTrackerPPCallbacks>(
1040 return std::make_unique<TopLevelDeclTrackerConsumer>(
1045 TopLevelDeclTrackerAction(
ASTUnit &_Unit) : Unit(_Unit) {}
1047 bool hasCodeCompletionSupport()
const override {
return false; }
1056 unsigned getHash()
const {
return Hash; }
1058 std::vector<Decl *> takeTopLevelDecls() {
return std::move(TopLevelDecls); }
1060 std::vector<serialization::DeclID> takeTopLevelDeclIDs() {
1061 return std::move(TopLevelDeclIDs);
1064 void AfterPCHEmitted(
ASTWriter &Writer)
override {
1065 TopLevelDeclIDs.reserve(TopLevelDecls.size());
1066 for (
const auto *D : TopLevelDecls) {
1068 if (D->isInvalidDecl())
1070 TopLevelDeclIDs.push_back(Writer.
getDeclID(D));
1075 for (
auto *D : DG) {
1080 if (isa<ObjCMethodDecl>(D))
1083 TopLevelDecls.push_back(D);
1087 std::unique_ptr<PPCallbacks> createPPCallbacks()
override {
1088 return std::make_unique<MacroDefinitionTrackerPPCallbacks>(Hash);
1093 std::vector<Decl *> TopLevelDecls;
1094 std::vector<serialization::DeclID> TopLevelDeclIDs;
1119 for (
auto &SD : StoredDiagnostics) {
1120 if (SD.getLocation().isValid()) {
1122 SD.setLocation(Loc);
1132bool ASTUnit::Parse(std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1133 std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer,
1139 assert(VFS == &FileMgr->getVirtualFileSystem() &&
1140 "VFS passed to Parse and VFS in FileMgr are different");
1142 auto CCInvocation = std::make_shared<CompilerInvocation>(*Invocation);
1143 if (OverrideMainBuffer) {
1145 "No preamble was built, but OverrideMainBuffer is not null");
1146 Preamble->AddImplicitPreamble(*CCInvocation, VFS, OverrideMainBuffer.get());
1151 std::unique_ptr<CompilerInstance> Clang(
1153 Clang->setInvocation(CCInvocation);
1156 auto CleanOnError = llvm::make_scope_exit([&]() {
1158 SavedMainFileBuffer =
nullptr;
1162 transferASTDataFromCompilerInstance(*Clang);
1163 FailedParseDiagnostics.swap(StoredDiagnostics);
1164 StoredDiagnostics.clear();
1165 NumStoredDiagnosticsFromDriver = 0;
1171 if (VFS && FileMgr && &FileMgr->getVirtualFileSystem() == VFS)
1172 Clang->setFileManager(&*FileMgr);
1174 FileMgr = Clang->createFileManager(std::move(VFS));
1177 llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
1178 CICleanup(Clang.get());
1180 OriginalSourceFile =
1181 std::string(Clang->getFrontendOpts().Inputs[0].getFile());
1188 if (!Clang->createTarget())
1191 assert(Clang->getFrontendOpts().Inputs.size() == 1 &&
1192 "Invocation must have exactly one source file!");
1193 assert(Clang->getFrontendOpts().Inputs[0].getKind().getFormat() ==
1195 "FIXME: AST inputs not yet supported here!");
1196 assert(Clang->getFrontendOpts().Inputs[0].getKind().getLanguage() !=
1198 "IR inputs not support here!");
1201 LangOpts = Clang->getInvocation().LangOpts;
1202 FileSystemOpts = Clang->getFileSystemOpts();
1207 UserFilesAreVolatile);
1208 if (!OverrideMainBuffer) {
1210 TopLevelDeclsInPreamble.clear();
1218 if (OverrideMainBuffer) {
1227 SavedMainFileBuffer = std::move(OverrideMainBuffer);
1230 std::unique_ptr<TopLevelDeclTrackerAction> Act(
1231 new TopLevelDeclTrackerAction(*
this));
1234 llvm::CrashRecoveryContextCleanupRegistrar<TopLevelDeclTrackerAction>
1235 ActCleanup(Act.get());
1237 if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0]))
1240 if (SavedMainFileBuffer)
1242 PreambleDiagnostics, StoredDiagnostics);
1244 PreambleSrcLocCache.clear();
1246 if (llvm::Error Err = Act->Execute()) {
1247 consumeError(std::move(Err));
1251 transferASTDataFromCompilerInstance(*Clang);
1253 Act->EndSourceFile();
1255 FailedParseDiagnostics.clear();
1257 CleanOnError.release();
1262static std::pair<unsigned, unsigned>
1267 unsigned EndOffset =
SM.getFileOffset(FileRange.
getEnd());
1268 return std::make_pair(
Offset, EndOffset);
1295 OutDiag.
Filename = std::string(
SM.getFilename(FileLoc));
1299 for (
const auto &Range : InDiag.
getRanges())
1301 for (
const auto &FixIt : InDiag.
getFixIts())
1327std::unique_ptr<llvm::MemoryBuffer>
1328ASTUnit::getMainBufferWithPrecompiledPreamble(
1329 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1332 unsigned MaxLines) {
1335 std::unique_ptr<llvm::MemoryBuffer> MainFileBuffer =
1337 MainFilePath, UserFilesAreVolatile);
1338 if (!MainFileBuffer)
1342 PreambleInvocationIn.
getLangOpts(), *MainFileBuffer, MaxLines);
1347 if (Preamble->CanReuse(PreambleInvocationIn, *MainFileBuffer, Bounds,
1358 PreambleRebuildCountdown = 1;
1359 return MainFileBuffer;
1362 PreambleDiagnostics.clear();
1363 TopLevelDeclsInPreamble.clear();
1364 PreambleSrcLocCache.clear();
1365 PreambleRebuildCountdown = 1;
1372 if (PreambleRebuildCountdown > 1) {
1373 --PreambleRebuildCountdown;
1377 assert(!Preamble &&
"No Preamble should be stored at that point");
1387 ASTUnitPreambleCallbacks Callbacks;
1389 std::optional<CaptureDroppedDiagnostics>
Capture;
1391 Capture.emplace(CaptureDiagnostics, *Diagnostics, &NewPreambleDiags,
1392 &NewPreambleDiagsStandalone);
1395 SimpleTimer PreambleTimer(WantTiming);
1396 PreambleTimer.setOutput(
"Precompiling preamble");
1398 const bool PreviousSkipFunctionBodies =
1404 PreambleInvocationIn, MainFileBuffer.get(), Bounds, *Diagnostics, VFS,
1405 PCHContainerOps, StorePreamblesInMemory, PreambleStoragePath,
1409 PreviousSkipFunctionBodies;
1412 Preamble = std::move(*NewPreamble);
1413 PreambleRebuildCountdown = 1;
1418 PreambleRebuildCountdown = 1;
1428 llvm_unreachable(
"unexpected BuildPreambleError");
1432 assert(Preamble &&
"Preamble wasn't built");
1434 TopLevelDecls.clear();
1435 TopLevelDeclsInPreamble = Callbacks.takeTopLevelDeclIDs();
1436 PreambleTopLevelHashValue = Callbacks.getHash();
1441 StoredDiagnostics = std::move(NewPreambleDiags);
1442 PreambleDiagnostics = std::move(NewPreambleDiagsStandalone);
1447 if (CurrentTopLevelHashValue != PreambleTopLevelHashValue) {
1448 CompletionCacheTopLevelHashValue = 0;
1449 PreambleTopLevelHashValue = CurrentTopLevelHashValue;
1452 return MainFileBuffer;
1455void ASTUnit::RealizeTopLevelDeclsFromPreamble() {
1456 assert(Preamble &&
"Should only be called when preamble was built");
1458 std::vector<Decl *> Resolved;
1459 Resolved.reserve(TopLevelDeclsInPreamble.size());
1461 for (
const auto TopLevelDecl : TopLevelDeclsInPreamble) {
1465 Resolved.push_back(D);
1467 TopLevelDeclsInPreamble.clear();
1468 TopLevelDecls.insert(TopLevelDecls.begin(), Resolved.begin(), Resolved.end());
1491 if (Invocation && !Invocation->getFrontendOpts().Inputs.empty()) {
1496 return Input.
getBuffer().getBufferIdentifier();
1502 return FE->getName();
1513 Mod = Reader->getModuleManager().getPrimaryModule();
1517std::unique_ptr<ASTUnit>
1521 bool UserFilesAreVolatile) {
1522 std::unique_ptr<ASTUnit> AST(
new ASTUnit(
false));
1523 ConfigureDiags(Diags, *AST, CaptureDiagnostics);
1526 AST->Diagnostics = Diags;
1527 AST->FileSystemOpts = CI->getFileSystemOpts();
1528 AST->Invocation = std::move(CI);
1529 AST->FileMgr =
new FileManager(AST->FileSystemOpts, VFS);
1530 AST->UserFilesAreVolatile = UserFilesAreVolatile;
1531 AST->SourceMgr =
new SourceManager(AST->getDiagnostics(), *AST->FileMgr,
1532 UserFilesAreVolatile);
1539 std::shared_ptr<CompilerInvocation> CI,
1540 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1542 ASTUnit *Unit,
bool Persistent, StringRef ResourceFilesPath,
1544 unsigned PrecompilePreambleAfterNParses,
bool CacheCodeCompletionResults,
1545 bool UserFilesAreVolatile, std::unique_ptr<ASTUnit> *ErrAST) {
1546 assert(CI &&
"A CompilerInvocation is required");
1548 std::unique_ptr<ASTUnit> OwnAST;
1552 OwnAST =
create(CI, Diags, CaptureDiagnostics, UserFilesAreVolatile);
1558 if (!ResourceFilesPath.empty()) {
1562 AST->OnlyLocalDecls = OnlyLocalDecls;
1563 AST->CaptureDiagnostics = CaptureDiagnostics;
1564 if (PrecompilePreambleAfterNParses > 0)
1565 AST->PreambleRebuildCountdown = PrecompilePreambleAfterNParses;
1567 AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults;
1568 AST->IncludeBriefCommentsInCodeCompletion =
false;
1571 llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
1572 ASTUnitCleanup(OwnAST.get());
1574 llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine>>
1575 DiagCleanup(Diags.get());
1578 CI->getPreprocessorOpts().RetainRemappedFileBuffers =
true;
1579 CI->getFrontendOpts().DisableFree =
false;
1583 std::unique_ptr<CompilerInstance> Clang(
1587 llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
1588 CICleanup(Clang.get());
1590 Clang->setInvocation(std::move(CI));
1591 AST->OriginalSourceFile =
1592 std::string(Clang->getFrontendOpts().Inputs[0].getFile());
1599 if (!Clang->createTarget())
1602 assert(Clang->getFrontendOpts().Inputs.size() == 1 &&
1603 "Invocation must have exactly one source file!");
1604 assert(Clang->getFrontendOpts().Inputs[0].getKind().getFormat() ==
1606 "FIXME: AST inputs not yet supported here!");
1607 assert(Clang->getFrontendOpts().Inputs[0].getKind().getLanguage() !=
1609 "IR inputs not support here!");
1612 AST->TheSema.reset();
1615 AST->Reader =
nullptr;
1625 std::unique_ptr<TopLevelDeclTrackerAction> TrackerAct;
1627 TrackerAct.reset(
new TopLevelDeclTrackerAction(*AST));
1628 Act = TrackerAct.get();
1632 llvm::CrashRecoveryContextCleanupRegistrar<TopLevelDeclTrackerAction>
1633 ActCleanup(TrackerAct.get());
1635 if (!Act->
BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) {
1636 AST->transferASTDataFromCompilerInstance(*Clang);
1637 if (OwnAST && ErrAST)
1638 ErrAST->swap(OwnAST);
1643 if (Persistent && !TrackerAct) {
1644 Clang->getPreprocessor().addPPCallbacks(
1645 std::make_unique<MacroDefinitionTrackerPPCallbacks>(
1647 std::vector<std::unique_ptr<ASTConsumer>> Consumers;
1648 if (Clang->hasASTConsumer())
1649 Consumers.push_back(Clang->takeASTConsumer());
1650 Consumers.push_back(std::make_unique<TopLevelDeclTrackerConsumer>(
1652 Clang->setASTConsumer(
1653 std::make_unique<MultiplexConsumer>(std::move(Consumers)));
1655 if (llvm::Error Err = Act->
Execute()) {
1656 consumeError(std::move(Err));
1657 AST->transferASTDataFromCompilerInstance(*Clang);
1658 if (OwnAST && ErrAST)
1659 ErrAST->swap(OwnAST);
1665 AST->transferASTDataFromCompilerInstance(*Clang);
1670 return OwnAST.release();
1675bool ASTUnit::LoadFromCompilerInvocation(
1676 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1677 unsigned PrecompilePreambleAfterNParses,
1682 assert(VFS &&
"VFS is null");
1685 Invocation->getPreprocessorOpts().RetainRemappedFileBuffers =
true;
1686 Invocation->getFrontendOpts().DisableFree =
false;
1690 std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer;
1691 if (PrecompilePreambleAfterNParses > 0) {
1692 PreambleRebuildCountdown = PrecompilePreambleAfterNParses;
1693 OverrideMainBuffer =
1694 getMainBufferWithPrecompiledPreamble(PCHContainerOps, *Invocation, VFS);
1699 SimpleTimer ParsingTimer(WantTiming);
1703 llvm::CrashRecoveryContextCleanupRegistrar<llvm::MemoryBuffer>
1704 MemBufferCleanup(OverrideMainBuffer.get());
1706 return Parse(std::move(PCHContainerOps), std::move(OverrideMainBuffer), VFS);
1709std::unique_ptr<ASTUnit> ASTUnit::LoadFromCompilerInvocation(
1710 std::shared_ptr<CompilerInvocation> CI,
1711 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1715 bool CacheCodeCompletionResults,
bool IncludeBriefCommentsInCodeCompletion,
1716 bool UserFilesAreVolatile) {
1718 std::unique_ptr<ASTUnit> AST(
new ASTUnit(
false));
1719 ConfigureDiags(Diags, *AST, CaptureDiagnostics);
1720 AST->Diagnostics = Diags;
1721 AST->OnlyLocalDecls = OnlyLocalDecls;
1722 AST->CaptureDiagnostics = CaptureDiagnostics;
1723 AST->TUKind = TUKind;
1724 AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults;
1725 AST->IncludeBriefCommentsInCodeCompletion
1726 = IncludeBriefCommentsInCodeCompletion;
1727 AST->Invocation = std::move(CI);
1729 AST->FileMgr = FileMgr;
1730 AST->UserFilesAreVolatile = UserFilesAreVolatile;
1733 llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
1734 ASTUnitCleanup(AST.get());
1736 llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine>>
1737 DiagCleanup(Diags.get());
1739 if (AST->LoadFromCompilerInvocation(std::move(PCHContainerOps),
1740 PrecompilePreambleAfterNParses,
1741 &AST->FileMgr->getVirtualFileSystem()))
1747 const char **ArgBegin,
const char **ArgEnd,
1748 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1750 bool StorePreamblesInMemory, StringRef PreambleStoragePath,
1754 bool CacheCodeCompletionResults,
bool IncludeBriefCommentsInCodeCompletion,
1756 bool SingleFileParse,
bool UserFilesAreVolatile,
bool ForSerialization,
1757 bool RetainExcludedConditionalBlocks, std::optional<StringRef> ModuleFormat,
1758 std::unique_ptr<ASTUnit> *ErrAST,
1760 assert(Diags.get() &&
"no DiagnosticsEngine was provided");
1766 VFS = llvm::vfs::createPhysicalFileSystem();
1770 std::shared_ptr<CompilerInvocation> CI;
1773 CaptureDroppedDiagnostics
Capture(CaptureDiagnostics, *Diags,
1774 &StoredDiagnostics,
nullptr);
1778 CIOpts.
Diags = Diags;
1787 CI->getPreprocessorOpts().addRemappedFile(
RemappedFile.first,
1797 CI->getHeaderSearchOpts().ResourceDir = std::string(ResourceFilesPath);
1799 CI->getFrontendOpts().SkipFunctionBodies =
1803 CI->getHeaderSearchOpts().ModuleFormat = std::string(*ModuleFormat);
1806 std::unique_ptr<ASTUnit> AST;
1807 AST.reset(
new ASTUnit(
false));
1808 AST->NumStoredDiagnosticsFromDriver = StoredDiagnostics.size();
1809 AST->StoredDiagnostics.swap(StoredDiagnostics);
1810 ConfigureDiags(Diags, *AST, CaptureDiagnostics);
1811 AST->Diagnostics = Diags;
1812 AST->FileSystemOpts = CI->getFileSystemOpts();
1814 AST->FileMgr =
new FileManager(AST->FileSystemOpts, VFS);
1815 AST->StorePreamblesInMemory = StorePreamblesInMemory;
1816 AST->PreambleStoragePath = PreambleStoragePath;
1818 AST->OnlyLocalDecls = OnlyLocalDecls;
1819 AST->CaptureDiagnostics = CaptureDiagnostics;
1820 AST->TUKind = TUKind;
1821 AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults;
1822 AST->IncludeBriefCommentsInCodeCompletion
1823 = IncludeBriefCommentsInCodeCompletion;
1824 AST->UserFilesAreVolatile = UserFilesAreVolatile;
1825 AST->Invocation = CI;
1826 AST->SkipFunctionBodies = SkipFunctionBodies;
1827 if (ForSerialization)
1828 AST->WriterData.reset(
new ASTWriterData(*AST->ModuleCache));
1834 llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
1835 ASTUnitCleanup(AST.get());
1837 if (AST->LoadFromCompilerInvocation(std::move(PCHContainerOps),
1838 PrecompilePreambleAfterNParses,
1843 AST->StoredDiagnostics.swap(AST->FailedParseDiagnostics);
1859 assert(FileMgr &&
"FileMgr is null on Reparse call");
1860 VFS = &FileMgr->getVirtualFileSystem();
1863 clearFileLevelDecls();
1865 SimpleTimer ParsingTimer(WantTiming);
1873 Invocation->getPreprocessorOpts().clearRemappedFiles();
1875 Invocation->getPreprocessorOpts().addRemappedFile(
RemappedFile.first,
1881 std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer;
1882 if (Preamble || PreambleRebuildCountdown > 0)
1883 OverrideMainBuffer =
1884 getMainBufferWithPrecompiledPreamble(PCHContainerOps, *Invocation, VFS);
1890 if (OverrideMainBuffer)
1895 Parse(std::move(PCHContainerOps), std::move(OverrideMainBuffer), VFS);
1899 if (!
Result && ShouldCacheCodeCompletionResults &&
1900 CurrentTopLevelHashValue != CompletionCacheTopLevelHashValue)
1901 CacheCodeCompletionResults();
1911 SavedMainFileBuffer.reset();
1919 TopLevelDecls.clear();
1920 clearFileLevelDecls();
1933 uint64_t NormalContexts;
1966 unsigned NumResults)
override;
1968 void ProcessOverloadCandidates(
Sema &S,
unsigned CurrentArg,
1970 unsigned NumCandidates,
1972 bool Braced)
override {
1973 Next.ProcessOverloadCandidates(S, CurrentArg, Candidates, NumCandidates,
1974 OpenParLoc, Braced);
1978 return Next.getAllocator();
1982 return Next.getCodeCompletionTUInfo();
1992 unsigned NumResults,
1994 llvm::StringSet<llvm::BumpPtrAllocator> &HiddenNames){
1995 bool OnlyTagNames =
false;
1996 switch (Context.getKind()) {
2021 OnlyTagNames =
true;
2047 for (
unsigned I = 0; I != NumResults; ++I) {
2048 if (Results[I].Kind != Result::RK_Declaration)
2052 = Results[I].Declaration->getUnderlyingDecl()->getIdentifierNamespace();
2054 bool Hiding =
false;
2063 Hiding = (IDNS & HiddenIDNS);
2073 HiddenNames.insert(Name.getAsString());
2077void AugmentedCodeCompleteConsumer::ProcessCodeCompleteResults(
Sema &S,
2080 unsigned NumResults) {
2082 bool AddedResult =
false;
2085 ? NormalContexts : (1LL << Context.getKind());
2087 llvm::StringSet<llvm::BumpPtrAllocator> HiddenNames;
2096 if ((
C->ShowInContexts & InContexts) == 0)
2103 AllResults.insert(AllResults.end(), Results, Results + NumResults);
2110 HiddenNames.count(
C->Completion->getTypedText()))
2116 if (!Context.getPreferredType().isNull()) {
2120 Context.getPreferredType()->isAnyPointerType());
2121 }
else if (
C->Type) {
2124 Context.getPreferredType().getUnqualifiedType());
2126 if (ExpectedSTC ==
C->TypeClass) {
2128 llvm::StringMap<unsigned> &CachedCompletionTypes
2130 llvm::StringMap<unsigned>::iterator Pos
2132 if (Pos != CachedCompletionTypes.end() && Pos->second ==
C->Type)
2147 Builder.AddTypedTextChunk(
C->Completion->getTypedText());
2149 Completion = Builder.TakeString();
2152 AllResults.push_back(
Result(Completion, Priority,
C->Kind,
2159 Next.ProcessCodeCompleteResults(S, Context, Results, NumResults);
2163 Next.ProcessCodeCompleteResults(S, Context, AllResults.data(),
2168 StringRef
File,
unsigned Line,
unsigned Column,
2170 bool IncludeCodePatterns,
bool IncludeBriefComments,
2172 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
2176 std::unique_ptr<SyntaxOnlyAction> Act) {
2180 SimpleTimer CompletionTimer(WantTiming);
2181 CompletionTimer.setOutput(
"Code completion @ " +
File +
":" +
2182 Twine(Line) +
":" + Twine(Column));
2184 auto CCInvocation = std::make_shared<CompilerInvocation>(*Invocation);
2191 CachedCompletionResults.empty();
2193 CodeCompleteOpts.
IncludeGlobals = CachedCompletionResults.empty();
2198 assert(IncludeBriefComments == this->IncludeBriefCommentsInCodeCompletion);
2205 LangOpts = CCInvocation->getLangOpts();
2208 LangOpts.SpellChecking =
false;
2209 CCInvocation->getDiagnosticOpts().IgnoreWarnings =
true;
2211 std::unique_ptr<CompilerInstance> Clang(
2215 llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
2216 CICleanup(Clang.get());
2218 auto &Inv = *CCInvocation;
2219 Clang->setInvocation(std::move(CCInvocation));
2220 OriginalSourceFile =
2221 std::string(Clang->getFrontendOpts().Inputs[0].getFile());
2224 Clang->setDiagnostics(&
Diag);
2226 Clang->getDiagnostics(),
2227 &StoredDiagnostics,
nullptr);
2231 if (!Clang->createTarget()) {
2232 Clang->setInvocation(
nullptr);
2236 assert(Clang->getFrontendOpts().Inputs.size() == 1 &&
2237 "Invocation must have exactly one source file!");
2238 assert(Clang->getFrontendOpts().Inputs[0].getKind().getFormat() ==
2240 "FIXME: AST inputs not yet supported here!");
2241 assert(Clang->getFrontendOpts().Inputs[0].getKind().getLanguage() !=
2243 "IR inputs not support here!");
2246 Clang->setFileManager(&FileMgr);
2247 Clang->setSourceManager(&SourceMgr);
2259 AugmentedCodeCompleteConsumer *AugmentedConsumer
2260 =
new AugmentedCodeCompleteConsumer(*
this, Consumer, CodeCompleteOpts);
2261 Clang->setCodeCompletionConsumer(AugmentedConsumer);
2264 [&FileMgr](StringRef
Filename) -> std::optional<llvm::sys::fs::UniqueID> {
2266 return Status->getUniqueID();
2267 return std::nullopt;
2270 auto hasSameUniqueID = [getUniqueID](StringRef LHS, StringRef RHS) {
2273 if (
auto LHSID = getUniqueID(LHS))
2274 if (
auto RHSID = getUniqueID(RHS))
2275 return *LHSID == *RHSID;
2283 std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer;
2284 if (Preamble && Line > 1 && hasSameUniqueID(
File, OriginalSourceFile)) {
2285 OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(
2291 if (OverrideMainBuffer) {
2293 "No preamble was built, but OverrideMainBuffer is not null");
2297 Preamble->AddImplicitPreamble(Clang->getInvocation(), VFS,
2298 OverrideMainBuffer.get());
2303 OwnedBuffers.push_back(OverrideMainBuffer.release());
2310 if (!Clang->getLangOpts().Modules)
2316 if (Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) {
2317 if (llvm::Error Err = Act->Execute()) {
2318 consumeError(std::move(Err));
2320 Act->EndSourceFile();
2325 if (HadModuleLoaderFatalFailure)
2331 if (llvm::Error Err = llvm::writeToOutput(
2332 File, [
this](llvm::raw_ostream &Out) {
2333 return serialize(Out) ? llvm::make_error<llvm::StringError>(
2334 "ASTUnit serialization failed",
2335 llvm::inconvertibleErrorCode())
2336 : llvm::Error::success();
2338 consumeError(std::move(Err));
2349 Writer.
WriteAST(S, std::string(),
nullptr,
"", hasErrors);
2352 if (!Buffer.empty())
2353 OS.write(Buffer.data(), Buffer.size());
2363 return serializeUnit(WriterData->Writer, WriterData->Buffer,
2367 llvm::BitstreamWriter Stream(Buffer);
2369 ASTWriter Writer(Stream, Buffer, ModuleCache, {});
2375void ASTUnit::TranslateStoredDiagnostics(
2385 Result.reserve(Diags.size());
2387 for (
const auto &SD : Diags) {
2389 if (SD.Filename.empty())
2391 auto FE = FileMgr.
getFile(SD.Filename);
2395 auto ItFileID = PreambleSrcLocCache.find(SD.Filename);
2396 if (ItFileID == PreambleSrcLocCache.end()) {
2399 PreambleSrcLocCache[SD.Filename] = FileLoc;
2401 FileLoc = ItFileID->getValue();
2410 Ranges.reserve(SD.Ranges.size());
2411 for (
const auto &Range : SD.Ranges) {
2418 FixIts.reserve(SD.FixIts.size());
2419 for (
const auto &FixIt : SD.FixIts) {
2429 SD.Message, Loc, Ranges, FixIts));
2443 if (Loc.
isInvalid() || !
SM.isLocalSourceLocation(Loc))
2451 assert(
SM.isLocalSourceLocation(FileLoc));
2454 std::tie(FID,
Offset) =
SM.getDecomposedLoc(FileLoc);
2458 std::unique_ptr<LocDeclsTy> &Decls = FileDecls[FID];
2460 Decls = std::make_unique<LocDeclsTy>();
2462 std::pair<unsigned, Decl *> LocDecl(
Offset, D);
2464 if (Decls->empty() || Decls->back().first <=
Offset) {
2465 Decls->push_back(LocDecl);
2469 LocDeclsTy::iterator I =
2470 llvm::upper_bound(*Decls, LocDecl, llvm::less_first());
2472 Decls->insert(I, LocDecl);
2477 if (
File.isInvalid())
2481 assert(Ctx->getExternalSource() &&
"No external source!");
2482 return Ctx->getExternalSource()->FindFileRegionDecls(
File,
Offset, Length,
2486 FileDeclsTy::iterator I = FileDecls.find(
File);
2487 if (I == FileDecls.end())
2491 if (LocDecls.empty())
2494 LocDeclsTy::iterator BeginIt =
2495 llvm::partition_point(LocDecls, [=](std::pair<unsigned, Decl *> LD) {
2496 return LD.first <
Offset;
2498 if (BeginIt != LocDecls.begin())
2504 while (BeginIt != LocDecls.begin() &&
2505 BeginIt->second->isTopLevelDeclInObjCContainer())
2508 LocDeclsTy::iterator EndIt = llvm::upper_bound(
2509 LocDecls, std::make_pair(
Offset + Length, (
Decl *)
nullptr),
2510 llvm::less_first());
2511 if (EndIt != LocDecls.end())
2514 for (LocDeclsTy::iterator DIt = BeginIt; DIt != EndIt; ++DIt)
2515 Decls.push_back(DIt->second);
2519 unsigned Line,
unsigned Col)
const {
2522 return SM.getMacroArgExpandedLocation(Loc);
2544 if (SourceMgr->
isInFileID(Loc, PreambleID, &Offs) && Offs < Preamble->getBounds().Size) {
2566 Offs < Preamble->getBounds().Size) {
2618llvm::iterator_range<PreprocessingRecord::iterator>
2622 Mod = Reader->getModuleManager().getPrimaryModule();
2623 return Reader->getModulePreprocessedEntities(Mod);
2627 return llvm::make_range(PPRec->local_begin(), PPRec->local_end());
2636 Mod = Reader->getModuleManager().getPrimaryModule();
2637 for (
const auto *D : Reader->getModuleFileLevelDecls(Mod)) {
2638 if (!Fn(context, D))
2647 TL != TLEnd; ++TL) {
2648 if (!Fn(context, *TL))
2657 return std::nullopt;
2662 case serialization::MK_ImplicitModule:
2663 case serialization::MK_ExplicitModule:
2664 case serialization::MK_PrebuiltModule:
2666 case serialization::MK_PCH:
2669 case serialization::MK_Preamble:
2671 case serialization::MK_MainFile:
2680 return std::nullopt;
2691 if (LangOpts.OpenCL)
2693 else if (LangOpts.CUDA)
2695 else if (LangOpts.RenderScript)
2697 else if (LangOpts.CPlusPlus)
2713ASTUnit::ConcurrencyState::ConcurrencyState() {
2714 Mutex =
new std::recursive_mutex;
2717ASTUnit::ConcurrencyState::~ConcurrencyState() {
2718 delete static_cast<std::recursive_mutex *
>(Mutex);
2721void ASTUnit::ConcurrencyState::start() {
2722 bool acquired =
static_cast<std::recursive_mutex *
>(Mutex)->try_lock();
2723 assert(acquired &&
"Concurrent access to ASTUnit!");
2726void ASTUnit::ConcurrencyState::finish() {
2727 static_cast<std::recursive_mutex *
>(Mutex)->unlock();
2732ASTUnit::ConcurrencyState::ConcurrencyState() { Mutex =
nullptr; }
2733ASTUnit::ConcurrencyState::~ConcurrencyState() {}
2734void ASTUnit::ConcurrencyState::start() {}
2735void 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.
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
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...
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)
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, 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.
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.
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=nullptr)
Perform code completion at the given file, line, and column within this translation unit.
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.
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_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()
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::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.
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.
@ 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....
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.
@ CCP_NestedNameSpecifier
Priority for a nested-name-specifier.
@ CCP_CodePattern
Priority for a code pattern.
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.