xref: /llvm-project/clang/lib/Frontend/FrontendActions.cpp (revision f7d93373969b2b757f5d5ef5e157dabe3bb9b0ae) 
1 //===--- FrontendActions.cpp ----------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "clang/Frontend/FrontendActions.h"
10 #include "clang/AST/ASTConsumer.h"
11 #include "clang/AST/Decl.h"
12 #include "clang/Basic/FileManager.h"
13 #include "clang/Basic/LangStandard.h"
14 #include "clang/Basic/Module.h"
15 #include "clang/Basic/TargetInfo.h"
16 #include "clang/Frontend/ASTConsumers.h"
17 #include "clang/Frontend/CompilerInstance.h"
18 #include "clang/Frontend/FrontendDiagnostic.h"
19 #include "clang/Frontend/MultiplexConsumer.h"
20 #include "clang/Frontend/Utils.h"
21 #include "clang/Lex/DependencyDirectivesScanner.h"
22 #include "clang/Lex/HeaderSearch.h"
23 #include "clang/Lex/Preprocessor.h"
24 #include "clang/Lex/PreprocessorOptions.h"
25 #include "clang/Sema/TemplateInstCallback.h"
26 #include "clang/Serialization/ASTReader.h"
27 #include "clang/Serialization/ASTWriter.h"
28 #include "clang/Serialization/ModuleFile.h"
29 #include "llvm/Support/ErrorHandling.h"
30 #include "llvm/Support/FileSystem.h"
31 #include "llvm/Support/MemoryBuffer.h"
32 #include "llvm/Support/Path.h"
33 #include "llvm/Support/YAMLTraits.h"
34 #include "llvm/Support/raw_ostream.h"
35 #include <memory>
36 #include <optional>
37 #include <system_error>
38 
39 using namespace clang;
40 
41 namespace {
42 CodeCompleteConsumer *GetCodeCompletionConsumer(CompilerInstance &CI) {
43   return CI.hasCodeCompletionConsumer() ? &CI.getCodeCompletionConsumer()
44                                         : nullptr;
45 }
46 
47 void EnsureSemaIsCreated(CompilerInstance &CI, FrontendAction &Action) {
48   if (Action.hasCodeCompletionSupport() &&
49       !CI.getFrontendOpts().CodeCompletionAt.FileName.empty())
50     CI.createCodeCompletionConsumer();
51 
52   if (!CI.hasSema())
53     CI.createSema(Action.getTranslationUnitKind(),
54                   GetCodeCompletionConsumer(CI));
55 }
56 } // namespace
57 
58 //===----------------------------------------------------------------------===//
59 // Custom Actions
60 //===----------------------------------------------------------------------===//
61 
62 std::unique_ptr<ASTConsumer>
63 InitOnlyAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
64   return std::make_unique<ASTConsumer>();
65 }
66 
67 void InitOnlyAction::ExecuteAction() {
68 }
69 
70 // Basically PreprocessOnlyAction::ExecuteAction.
71 void ReadPCHAndPreprocessAction::ExecuteAction() {
72   CompilerInstance &CI = getCompilerInstance();
73   AdjustCI(CI);
74 
75   Preprocessor &PP = CI.getPreprocessor();
76 
77   // Ignore unknown pragmas.
78   PP.IgnorePragmas();
79 
80   Token Tok;
81   // Start parsing the specified input file.
82   PP.EnterMainSourceFile();
83   do {
84     PP.Lex(Tok);
85   } while (Tok.isNot(tok::eof));
86 }
87 
88 std::unique_ptr<ASTConsumer>
89 ReadPCHAndPreprocessAction::CreateASTConsumer(CompilerInstance &CI,
90                                               StringRef InFile) {
91   return std::make_unique<ASTConsumer>();
92 }
93 
94 //===----------------------------------------------------------------------===//
95 // AST Consumer Actions
96 //===----------------------------------------------------------------------===//
97 
98 std::unique_ptr<ASTConsumer>
99 ASTPrintAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
100   if (std::unique_ptr<raw_ostream> OS =
101           CI.createDefaultOutputFile(false, InFile))
102     return CreateASTPrinter(std::move(OS), CI.getFrontendOpts().ASTDumpFilter);
103   return nullptr;
104 }
105 
106 std::unique_ptr<ASTConsumer>
107 ASTDumpAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
108   const FrontendOptions &Opts = CI.getFrontendOpts();
109   return CreateASTDumper(nullptr /*Dump to stdout.*/, Opts.ASTDumpFilter,
110                          Opts.ASTDumpDecls, Opts.ASTDumpAll,
111                          Opts.ASTDumpLookups, Opts.ASTDumpDeclTypes,
112                          Opts.ASTDumpFormat);
113 }
114 
115 std::unique_ptr<ASTConsumer>
116 ASTDeclListAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
117   return CreateASTDeclNodeLister();
118 }
119 
120 std::unique_ptr<ASTConsumer>
121 ASTViewAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
122   return CreateASTViewer();
123 }
124 
125 std::unique_ptr<ASTConsumer>
126 GeneratePCHAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
127   std::string Sysroot;
128   if (!ComputeASTConsumerArguments(CI, /*ref*/ Sysroot))
129     return nullptr;
130 
131   std::string OutputFile;
132   std::unique_ptr<raw_pwrite_stream> OS =
133       CreateOutputFile(CI, InFile, /*ref*/ OutputFile);
134   if (!OS)
135     return nullptr;
136 
137   if (!CI.getFrontendOpts().RelocatablePCH)
138     Sysroot.clear();
139 
140   const auto &FrontendOpts = CI.getFrontendOpts();
141   auto Buffer = std::make_shared<PCHBuffer>();
142   std::vector<std::unique_ptr<ASTConsumer>> Consumers;
143   Consumers.push_back(std::make_unique<PCHGenerator>(
144       CI.getPreprocessor(), CI.getModuleCache(), OutputFile, Sysroot, Buffer,
145       FrontendOpts.ModuleFileExtensions,
146       CI.getPreprocessorOpts().AllowPCHWithCompilerErrors,
147       FrontendOpts.IncludeTimestamps, FrontendOpts.BuildingImplicitModule,
148       +CI.getLangOpts().CacheGeneratedPCH));
149   Consumers.push_back(CI.getPCHContainerWriter().CreatePCHContainerGenerator(
150       CI, std::string(InFile), OutputFile, std::move(OS), Buffer));
151 
152   return std::make_unique<MultiplexConsumer>(std::move(Consumers));
153 }
154 
155 bool GeneratePCHAction::ComputeASTConsumerArguments(CompilerInstance &CI,
156                                                     std::string &Sysroot) {
157   Sysroot = CI.getHeaderSearchOpts().Sysroot;
158   if (CI.getFrontendOpts().RelocatablePCH && Sysroot.empty()) {
159     CI.getDiagnostics().Report(diag::err_relocatable_without_isysroot);
160     return false;
161   }
162 
163   return true;
164 }
165 
166 std::unique_ptr<llvm::raw_pwrite_stream>
167 GeneratePCHAction::CreateOutputFile(CompilerInstance &CI, StringRef InFile,
168                                     std::string &OutputFile) {
169   // Because this is exposed via libclang we must disable RemoveFileOnSignal.
170   std::unique_ptr<raw_pwrite_stream> OS = CI.createDefaultOutputFile(
171       /*Binary=*/true, InFile, /*Extension=*/"", /*RemoveFileOnSignal=*/false);
172   if (!OS)
173     return nullptr;
174 
175   OutputFile = CI.getFrontendOpts().OutputFile;
176   return OS;
177 }
178 
179 bool GeneratePCHAction::shouldEraseOutputFiles() {
180   if (getCompilerInstance().getPreprocessorOpts().AllowPCHWithCompilerErrors)
181     return false;
182   return ASTFrontendAction::shouldEraseOutputFiles();
183 }
184 
185 bool GeneratePCHAction::BeginSourceFileAction(CompilerInstance &CI) {
186   CI.getLangOpts().CompilingPCH = true;
187   return true;
188 }
189 
190 std::vector<std::unique_ptr<ASTConsumer>>
191 GenerateModuleAction::CreateMultiplexConsumer(CompilerInstance &CI,
192                                               StringRef InFile) {
193   std::unique_ptr<raw_pwrite_stream> OS = CreateOutputFile(CI, InFile);
194   if (!OS)
195     return {};
196 
197   std::string OutputFile = CI.getFrontendOpts().OutputFile;
198   std::string Sysroot;
199 
200   auto Buffer = std::make_shared<PCHBuffer>();
201   std::vector<std::unique_ptr<ASTConsumer>> Consumers;
202 
203   Consumers.push_back(std::make_unique<PCHGenerator>(
204       CI.getPreprocessor(), CI.getModuleCache(), OutputFile, Sysroot, Buffer,
205       CI.getFrontendOpts().ModuleFileExtensions,
206       /*AllowASTWithErrors=*/
207       +CI.getFrontendOpts().AllowPCMWithCompilerErrors,
208       /*IncludeTimestamps=*/
209       +CI.getFrontendOpts().BuildingImplicitModule &&
210           +CI.getFrontendOpts().IncludeTimestamps,
211       /*BuildingImplicitModule=*/+CI.getFrontendOpts().BuildingImplicitModule,
212       /*ShouldCacheASTInMemory=*/
213       +CI.getFrontendOpts().BuildingImplicitModule));
214   Consumers.push_back(CI.getPCHContainerWriter().CreatePCHContainerGenerator(
215       CI, std::string(InFile), OutputFile, std::move(OS), Buffer));
216   return Consumers;
217 }
218 
219 std::unique_ptr<ASTConsumer>
220 GenerateModuleAction::CreateASTConsumer(CompilerInstance &CI,
221                                         StringRef InFile) {
222   std::vector<std::unique_ptr<ASTConsumer>> Consumers =
223       CreateMultiplexConsumer(CI, InFile);
224   if (Consumers.empty())
225     return nullptr;
226 
227   return std::make_unique<MultiplexConsumer>(std::move(Consumers));
228 }
229 
230 bool GenerateModuleAction::shouldEraseOutputFiles() {
231   return !getCompilerInstance().getFrontendOpts().AllowPCMWithCompilerErrors &&
232          ASTFrontendAction::shouldEraseOutputFiles();
233 }
234 
235 bool GenerateModuleFromModuleMapAction::BeginSourceFileAction(
236     CompilerInstance &CI) {
237   if (!CI.getLangOpts().Modules) {
238     CI.getDiagnostics().Report(diag::err_module_build_requires_fmodules);
239     return false;
240   }
241 
242   return GenerateModuleAction::BeginSourceFileAction(CI);
243 }
244 
245 std::unique_ptr<raw_pwrite_stream>
246 GenerateModuleFromModuleMapAction::CreateOutputFile(CompilerInstance &CI,
247                                                     StringRef InFile) {
248   // If no output file was provided, figure out where this module would go
249   // in the module cache.
250   if (CI.getFrontendOpts().OutputFile.empty()) {
251     StringRef ModuleMapFile = CI.getFrontendOpts().OriginalModuleMap;
252     if (ModuleMapFile.empty())
253       ModuleMapFile = InFile;
254 
255     HeaderSearch &HS = CI.getPreprocessor().getHeaderSearchInfo();
256     CI.getFrontendOpts().OutputFile =
257         HS.getCachedModuleFileName(CI.getLangOpts().CurrentModule,
258                                    ModuleMapFile);
259   }
260 
261   // Because this is exposed via libclang we must disable RemoveFileOnSignal.
262   return CI.createDefaultOutputFile(/*Binary=*/true, InFile, /*Extension=*/"",
263                                     /*RemoveFileOnSignal=*/false,
264                                     /*CreateMissingDirectories=*/true,
265                                     /*ForceUseTemporary=*/true);
266 }
267 
268 bool GenerateModuleInterfaceAction::BeginSourceFileAction(
269     CompilerInstance &CI) {
270   CI.getLangOpts().setCompilingModule(LangOptions::CMK_ModuleInterface);
271 
272   return GenerateModuleAction::BeginSourceFileAction(CI);
273 }
274 
275 std::unique_ptr<ASTConsumer>
276 GenerateModuleInterfaceAction::CreateASTConsumer(CompilerInstance &CI,
277                                                  StringRef InFile) {
278   CI.getHeaderSearchOpts().ModulesSkipDiagnosticOptions = true;
279   CI.getHeaderSearchOpts().ModulesSkipHeaderSearchPaths = true;
280   CI.getHeaderSearchOpts().ModulesSkipPragmaDiagnosticMappings = true;
281 
282   std::vector<std::unique_ptr<ASTConsumer>> Consumers =
283       CreateMultiplexConsumer(CI, InFile);
284   if (Consumers.empty())
285     return nullptr;
286 
287   return std::make_unique<MultiplexConsumer>(std::move(Consumers));
288 }
289 
290 std::unique_ptr<raw_pwrite_stream>
291 GenerateModuleInterfaceAction::CreateOutputFile(CompilerInstance &CI,
292                                                 StringRef InFile) {
293   return CI.createDefaultOutputFile(/*Binary=*/true, InFile, "pcm");
294 }
295 
296 std::unique_ptr<ASTConsumer>
297 GenerateReducedModuleInterfaceAction::CreateASTConsumer(CompilerInstance &CI,
298                                                         StringRef InFile) {
299   return std::make_unique<ReducedBMIGenerator>(CI.getPreprocessor(),
300                                                CI.getModuleCache(),
301                                                CI.getFrontendOpts().OutputFile);
302 }
303 
304 bool GenerateHeaderUnitAction::BeginSourceFileAction(CompilerInstance &CI) {
305   if (!CI.getLangOpts().CPlusPlusModules) {
306     CI.getDiagnostics().Report(diag::err_module_interface_requires_cpp_modules);
307     return false;
308   }
309   CI.getLangOpts().setCompilingModule(LangOptions::CMK_HeaderUnit);
310   return GenerateModuleAction::BeginSourceFileAction(CI);
311 }
312 
313 std::unique_ptr<raw_pwrite_stream>
314 GenerateHeaderUnitAction::CreateOutputFile(CompilerInstance &CI,
315                                            StringRef InFile) {
316   return CI.createDefaultOutputFile(/*Binary=*/true, InFile, "pcm");
317 }
318 
319 SyntaxOnlyAction::~SyntaxOnlyAction() {
320 }
321 
322 std::unique_ptr<ASTConsumer>
323 SyntaxOnlyAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
324   return std::make_unique<ASTConsumer>();
325 }
326 
327 std::unique_ptr<ASTConsumer>
328 DumpModuleInfoAction::CreateASTConsumer(CompilerInstance &CI,
329                                         StringRef InFile) {
330   return std::make_unique<ASTConsumer>();
331 }
332 
333 std::unique_ptr<ASTConsumer>
334 VerifyPCHAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
335   return std::make_unique<ASTConsumer>();
336 }
337 
338 void VerifyPCHAction::ExecuteAction() {
339   CompilerInstance &CI = getCompilerInstance();
340   bool Preamble = CI.getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
341   const std::string &Sysroot = CI.getHeaderSearchOpts().Sysroot;
342   std::unique_ptr<ASTReader> Reader(new ASTReader(
343       CI.getPreprocessor(), CI.getModuleCache(), &CI.getASTContext(),
344       CI.getPCHContainerReader(), CI.getFrontendOpts().ModuleFileExtensions,
345       Sysroot.empty() ? "" : Sysroot.c_str(),
346       DisableValidationForModuleKind::None,
347       /*AllowASTWithCompilerErrors*/ false,
348       /*AllowConfigurationMismatch*/ true,
349       /*ValidateSystemInputs*/ true));
350 
351   Reader->ReadAST(getCurrentFile(),
352                   Preamble ? serialization::MK_Preamble
353                            : serialization::MK_PCH,
354                   SourceLocation(),
355                   ASTReader::ARR_ConfigurationMismatch);
356 }
357 
358 namespace {
359 struct TemplightEntry {
360   std::string Name;
361   std::string Kind;
362   std::string Event;
363   std::string DefinitionLocation;
364   std::string PointOfInstantiation;
365 };
366 } // namespace
367 
368 namespace llvm {
369 namespace yaml {
370 template <> struct MappingTraits<TemplightEntry> {
371   static void mapping(IO &io, TemplightEntry &fields) {
372     io.mapRequired("name", fields.Name);
373     io.mapRequired("kind", fields.Kind);
374     io.mapRequired("event", fields.Event);
375     io.mapRequired("orig", fields.DefinitionLocation);
376     io.mapRequired("poi", fields.PointOfInstantiation);
377   }
378 };
379 } // namespace yaml
380 } // namespace llvm
381 
382 namespace {
383 class DefaultTemplateInstCallback : public TemplateInstantiationCallback {
384   using CodeSynthesisContext = Sema::CodeSynthesisContext;
385 
386 public:
387   void initialize(const Sema &) override {}
388 
389   void finalize(const Sema &) override {}
390 
391   void atTemplateBegin(const Sema &TheSema,
392                        const CodeSynthesisContext &Inst) override {
393     displayTemplightEntry<true>(llvm::outs(), TheSema, Inst);
394   }
395 
396   void atTemplateEnd(const Sema &TheSema,
397                      const CodeSynthesisContext &Inst) override {
398     displayTemplightEntry<false>(llvm::outs(), TheSema, Inst);
399   }
400 
401 private:
402   static std::string toString(CodeSynthesisContext::SynthesisKind Kind) {
403     switch (Kind) {
404     case CodeSynthesisContext::TemplateInstantiation:
405       return "TemplateInstantiation";
406     case CodeSynthesisContext::DefaultTemplateArgumentInstantiation:
407       return "DefaultTemplateArgumentInstantiation";
408     case CodeSynthesisContext::DefaultFunctionArgumentInstantiation:
409       return "DefaultFunctionArgumentInstantiation";
410     case CodeSynthesisContext::ExplicitTemplateArgumentSubstitution:
411       return "ExplicitTemplateArgumentSubstitution";
412     case CodeSynthesisContext::DeducedTemplateArgumentSubstitution:
413       return "DeducedTemplateArgumentSubstitution";
414     case CodeSynthesisContext::LambdaExpressionSubstitution:
415       return "LambdaExpressionSubstitution";
416     case CodeSynthesisContext::PriorTemplateArgumentSubstitution:
417       return "PriorTemplateArgumentSubstitution";
418     case CodeSynthesisContext::DefaultTemplateArgumentChecking:
419       return "DefaultTemplateArgumentChecking";
420     case CodeSynthesisContext::ExceptionSpecEvaluation:
421       return "ExceptionSpecEvaluation";
422     case CodeSynthesisContext::ExceptionSpecInstantiation:
423       return "ExceptionSpecInstantiation";
424     case CodeSynthesisContext::DeclaringSpecialMember:
425       return "DeclaringSpecialMember";
426     case CodeSynthesisContext::DeclaringImplicitEqualityComparison:
427       return "DeclaringImplicitEqualityComparison";
428     case CodeSynthesisContext::DefiningSynthesizedFunction:
429       return "DefiningSynthesizedFunction";
430     case CodeSynthesisContext::RewritingOperatorAsSpaceship:
431       return "RewritingOperatorAsSpaceship";
432     case CodeSynthesisContext::Memoization:
433       return "Memoization";
434     case CodeSynthesisContext::ConstraintsCheck:
435       return "ConstraintsCheck";
436     case CodeSynthesisContext::ConstraintSubstitution:
437       return "ConstraintSubstitution";
438     case CodeSynthesisContext::ConstraintNormalization:
439       return "ConstraintNormalization";
440     case CodeSynthesisContext::RequirementParameterInstantiation:
441       return "RequirementParameterInstantiation";
442     case CodeSynthesisContext::ParameterMappingSubstitution:
443       return "ParameterMappingSubstitution";
444     case CodeSynthesisContext::RequirementInstantiation:
445       return "RequirementInstantiation";
446     case CodeSynthesisContext::NestedRequirementConstraintsCheck:
447       return "NestedRequirementConstraintsCheck";
448     case CodeSynthesisContext::InitializingStructuredBinding:
449       return "InitializingStructuredBinding";
450     case CodeSynthesisContext::MarkingClassDllexported:
451       return "MarkingClassDllexported";
452     case CodeSynthesisContext::BuildingBuiltinDumpStructCall:
453       return "BuildingBuiltinDumpStructCall";
454     case CodeSynthesisContext::BuildingDeductionGuides:
455       return "BuildingDeductionGuides";
456     case CodeSynthesisContext::TypeAliasTemplateInstantiation:
457       return "TypeAliasTemplateInstantiation";
458     }
459     return "";
460   }
461 
462   template <bool BeginInstantiation>
463   static void displayTemplightEntry(llvm::raw_ostream &Out, const Sema &TheSema,
464                                     const CodeSynthesisContext &Inst) {
465     std::string YAML;
466     {
467       llvm::raw_string_ostream OS(YAML);
468       llvm::yaml::Output YO(OS);
469       TemplightEntry Entry =
470           getTemplightEntry<BeginInstantiation>(TheSema, Inst);
471       llvm::yaml::EmptyContext Context;
472       llvm::yaml::yamlize(YO, Entry, true, Context);
473     }
474     Out << "---" << YAML << "\n";
475   }
476 
477   static void printEntryName(const Sema &TheSema, const Decl *Entity,
478                              llvm::raw_string_ostream &OS) {
479     auto *NamedTemplate = cast<NamedDecl>(Entity);
480 
481     PrintingPolicy Policy = TheSema.Context.getPrintingPolicy();
482     // FIXME: Also ask for FullyQualifiedNames?
483     Policy.SuppressDefaultTemplateArgs = false;
484     NamedTemplate->getNameForDiagnostic(OS, Policy, true);
485 
486     if (!OS.str().empty())
487       return;
488 
489     Decl *Ctx = Decl::castFromDeclContext(NamedTemplate->getDeclContext());
490     NamedDecl *NamedCtx = dyn_cast_or_null<NamedDecl>(Ctx);
491 
492     if (const auto *Decl = dyn_cast<TagDecl>(NamedTemplate)) {
493       if (const auto *R = dyn_cast<RecordDecl>(Decl)) {
494         if (R->isLambda()) {
495           OS << "lambda at ";
496           Decl->getLocation().print(OS, TheSema.getSourceManager());
497           return;
498         }
499       }
500       OS << "unnamed " << Decl->getKindName();
501       return;
502     }
503 
504     assert(NamedCtx && "NamedCtx cannot be null");
505 
506     if (const auto *Decl = dyn_cast<ParmVarDecl>(NamedTemplate)) {
507       OS << "unnamed function parameter " << Decl->getFunctionScopeIndex()
508          << " ";
509       if (Decl->getFunctionScopeDepth() > 0)
510         OS << "(at depth " << Decl->getFunctionScopeDepth() << ") ";
511       OS << "of ";
512       NamedCtx->getNameForDiagnostic(OS, TheSema.getLangOpts(), true);
513       return;
514     }
515 
516     if (const auto *Decl = dyn_cast<TemplateTypeParmDecl>(NamedTemplate)) {
517       if (const Type *Ty = Decl->getTypeForDecl()) {
518         if (const auto *TTPT = dyn_cast_or_null<TemplateTypeParmType>(Ty)) {
519           OS << "unnamed template type parameter " << TTPT->getIndex() << " ";
520           if (TTPT->getDepth() > 0)
521             OS << "(at depth " << TTPT->getDepth() << ") ";
522           OS << "of ";
523           NamedCtx->getNameForDiagnostic(OS, TheSema.getLangOpts(), true);
524           return;
525         }
526       }
527     }
528 
529     if (const auto *Decl = dyn_cast<NonTypeTemplateParmDecl>(NamedTemplate)) {
530       OS << "unnamed template non-type parameter " << Decl->getIndex() << " ";
531       if (Decl->getDepth() > 0)
532         OS << "(at depth " << Decl->getDepth() << ") ";
533       OS << "of ";
534       NamedCtx->getNameForDiagnostic(OS, TheSema.getLangOpts(), true);
535       return;
536     }
537 
538     if (const auto *Decl = dyn_cast<TemplateTemplateParmDecl>(NamedTemplate)) {
539       OS << "unnamed template template parameter " << Decl->getIndex() << " ";
540       if (Decl->getDepth() > 0)
541         OS << "(at depth " << Decl->getDepth() << ") ";
542       OS << "of ";
543       NamedCtx->getNameForDiagnostic(OS, TheSema.getLangOpts(), true);
544       return;
545     }
546 
547     llvm_unreachable("Failed to retrieve a name for this entry!");
548     OS << "unnamed identifier";
549   }
550 
551   template <bool BeginInstantiation>
552   static TemplightEntry getTemplightEntry(const Sema &TheSema,
553                                           const CodeSynthesisContext &Inst) {
554     TemplightEntry Entry;
555     Entry.Kind = toString(Inst.Kind);
556     Entry.Event = BeginInstantiation ? "Begin" : "End";
557     llvm::raw_string_ostream OS(Entry.Name);
558     printEntryName(TheSema, Inst.Entity, OS);
559     const PresumedLoc DefLoc =
560         TheSema.getSourceManager().getPresumedLoc(Inst.Entity->getLocation());
561     if (!DefLoc.isInvalid())
562       Entry.DefinitionLocation = std::string(DefLoc.getFilename()) + ":" +
563                                  std::to_string(DefLoc.getLine()) + ":" +
564                                  std::to_string(DefLoc.getColumn());
565     const PresumedLoc PoiLoc =
566         TheSema.getSourceManager().getPresumedLoc(Inst.PointOfInstantiation);
567     if (!PoiLoc.isInvalid()) {
568       Entry.PointOfInstantiation = std::string(PoiLoc.getFilename()) + ":" +
569                                    std::to_string(PoiLoc.getLine()) + ":" +
570                                    std::to_string(PoiLoc.getColumn());
571     }
572     return Entry;
573   }
574 };
575 } // namespace
576 
577 std::unique_ptr<ASTConsumer>
578 TemplightDumpAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
579   return std::make_unique<ASTConsumer>();
580 }
581 
582 void TemplightDumpAction::ExecuteAction() {
583   CompilerInstance &CI = getCompilerInstance();
584 
585   // This part is normally done by ASTFrontEndAction, but needs to happen
586   // before Templight observers can be created
587   // FIXME: Move the truncation aspect of this into Sema, we delayed this till
588   // here so the source manager would be initialized.
589   EnsureSemaIsCreated(CI, *this);
590 
591   CI.getSema().TemplateInstCallbacks.push_back(
592       std::make_unique<DefaultTemplateInstCallback>());
593   ASTFrontendAction::ExecuteAction();
594 }
595 
596 namespace {
597   /// AST reader listener that dumps module information for a module
598   /// file.
599   class DumpModuleInfoListener : public ASTReaderListener {
600     llvm::raw_ostream &Out;
601 
602   public:
603     DumpModuleInfoListener(llvm::raw_ostream &Out) : Out(Out) { }
604 
605 #define DUMP_BOOLEAN(Value, Text)                       \
606     Out.indent(4) << Text << ": " << (Value? "Yes" : "No") << "\n"
607 
608     bool ReadFullVersionInformation(StringRef FullVersion) override {
609       Out.indent(2)
610         << "Generated by "
611         << (FullVersion == getClangFullRepositoryVersion()? "this"
612                                                           : "a different")
613         << " Clang: " << FullVersion << "\n";
614       return ASTReaderListener::ReadFullVersionInformation(FullVersion);
615     }
616 
617     void ReadModuleName(StringRef ModuleName) override {
618       Out.indent(2) << "Module name: " << ModuleName << "\n";
619     }
620     void ReadModuleMapFile(StringRef ModuleMapPath) override {
621       Out.indent(2) << "Module map file: " << ModuleMapPath << "\n";
622     }
623 
624     bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
625                              bool AllowCompatibleDifferences) override {
626       Out.indent(2) << "Language options:\n";
627 #define LANGOPT(Name, Bits, Default, Description) \
628       DUMP_BOOLEAN(LangOpts.Name, Description);
629 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
630       Out.indent(4) << Description << ": "                   \
631                     << static_cast<unsigned>(LangOpts.get##Name()) << "\n";
632 #define VALUE_LANGOPT(Name, Bits, Default, Description) \
633       Out.indent(4) << Description << ": " << LangOpts.Name << "\n";
634 #define BENIGN_LANGOPT(Name, Bits, Default, Description)
635 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
636 #include "clang/Basic/LangOptions.def"
637 
638       if (!LangOpts.ModuleFeatures.empty()) {
639         Out.indent(4) << "Module features:\n";
640         for (StringRef Feature : LangOpts.ModuleFeatures)
641           Out.indent(6) << Feature << "\n";
642       }
643 
644       return false;
645     }
646 
647     bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
648                            bool AllowCompatibleDifferences) override {
649       Out.indent(2) << "Target options:\n";
650       Out.indent(4) << "  Triple: " << TargetOpts.Triple << "\n";
651       Out.indent(4) << "  CPU: " << TargetOpts.CPU << "\n";
652       Out.indent(4) << "  TuneCPU: " << TargetOpts.TuneCPU << "\n";
653       Out.indent(4) << "  ABI: " << TargetOpts.ABI << "\n";
654 
655       if (!TargetOpts.FeaturesAsWritten.empty()) {
656         Out.indent(4) << "Target features:\n";
657         for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size();
658              I != N; ++I) {
659           Out.indent(6) << TargetOpts.FeaturesAsWritten[I] << "\n";
660         }
661       }
662 
663       return false;
664     }
665 
666     bool ReadDiagnosticOptions(IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts,
667                                bool Complain) override {
668       Out.indent(2) << "Diagnostic options:\n";
669 #define DIAGOPT(Name, Bits, Default) DUMP_BOOLEAN(DiagOpts->Name, #Name);
670 #define ENUM_DIAGOPT(Name, Type, Bits, Default) \
671       Out.indent(4) << #Name << ": " << DiagOpts->get##Name() << "\n";
672 #define VALUE_DIAGOPT(Name, Bits, Default) \
673       Out.indent(4) << #Name << ": " << DiagOpts->Name << "\n";
674 #include "clang/Basic/DiagnosticOptions.def"
675 
676       Out.indent(4) << "Diagnostic flags:\n";
677       for (const std::string &Warning : DiagOpts->Warnings)
678         Out.indent(6) << "-W" << Warning << "\n";
679       for (const std::string &Remark : DiagOpts->Remarks)
680         Out.indent(6) << "-R" << Remark << "\n";
681 
682       return false;
683     }
684 
685     bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
686                                  StringRef SpecificModuleCachePath,
687                                  bool Complain) override {
688       Out.indent(2) << "Header search options:\n";
689       Out.indent(4) << "System root [-isysroot=]: '" << HSOpts.Sysroot << "'\n";
690       Out.indent(4) << "Resource dir [ -resource-dir=]: '" << HSOpts.ResourceDir << "'\n";
691       Out.indent(4) << "Module Cache: '" << SpecificModuleCachePath << "'\n";
692       DUMP_BOOLEAN(HSOpts.UseBuiltinIncludes,
693                    "Use builtin include directories [-nobuiltininc]");
694       DUMP_BOOLEAN(HSOpts.UseStandardSystemIncludes,
695                    "Use standard system include directories [-nostdinc]");
696       DUMP_BOOLEAN(HSOpts.UseStandardCXXIncludes,
697                    "Use standard C++ include directories [-nostdinc++]");
698       DUMP_BOOLEAN(HSOpts.UseLibcxx,
699                    "Use libc++ (rather than libstdc++) [-stdlib=]");
700       return false;
701     }
702 
703     bool ReadHeaderSearchPaths(const HeaderSearchOptions &HSOpts,
704                                bool Complain) override {
705       Out.indent(2) << "Header search paths:\n";
706       Out.indent(4) << "User entries:\n";
707       for (const auto &Entry : HSOpts.UserEntries)
708         Out.indent(6) << Entry.Path << "\n";
709       Out.indent(4) << "System header prefixes:\n";
710       for (const auto &Prefix : HSOpts.SystemHeaderPrefixes)
711         Out.indent(6) << Prefix.Prefix << "\n";
712       Out.indent(4) << "VFS overlay files:\n";
713       for (const auto &Overlay : HSOpts.VFSOverlayFiles)
714         Out.indent(6) << Overlay << "\n";
715       return false;
716     }
717 
718     bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
719                                  bool ReadMacros, bool Complain,
720                                  std::string &SuggestedPredefines) override {
721       Out.indent(2) << "Preprocessor options:\n";
722       DUMP_BOOLEAN(PPOpts.UsePredefines,
723                    "Uses compiler/target-specific predefines [-undef]");
724       DUMP_BOOLEAN(PPOpts.DetailedRecord,
725                    "Uses detailed preprocessing record (for indexing)");
726 
727       if (ReadMacros) {
728         Out.indent(4) << "Predefined macros:\n";
729       }
730 
731       for (std::vector<std::pair<std::string, bool/*isUndef*/> >::const_iterator
732              I = PPOpts.Macros.begin(), IEnd = PPOpts.Macros.end();
733            I != IEnd; ++I) {
734         Out.indent(6);
735         if (I->second)
736           Out << "-U";
737         else
738           Out << "-D";
739         Out << I->first << "\n";
740       }
741       return false;
742     }
743 
744     /// Indicates that a particular module file extension has been read.
745     void readModuleFileExtension(
746            const ModuleFileExtensionMetadata &Metadata) override {
747       Out.indent(2) << "Module file extension '"
748                     << Metadata.BlockName << "' " << Metadata.MajorVersion
749                     << "." << Metadata.MinorVersion;
750       if (!Metadata.UserInfo.empty()) {
751         Out << ": ";
752         Out.write_escaped(Metadata.UserInfo);
753       }
754 
755       Out << "\n";
756     }
757 
758     /// Tells the \c ASTReaderListener that we want to receive the
759     /// input files of the AST file via \c visitInputFile.
760     bool needsInputFileVisitation() override { return true; }
761 
762     /// Tells the \c ASTReaderListener that we want to receive the
763     /// input files of the AST file via \c visitInputFile.
764     bool needsSystemInputFileVisitation() override { return true; }
765 
766     /// Indicates that the AST file contains particular input file.
767     ///
768     /// \returns true to continue receiving the next input file, false to stop.
769     bool visitInputFile(StringRef Filename, bool isSystem,
770                         bool isOverridden, bool isExplicitModule) override {
771 
772       Out.indent(2) << "Input file: " << Filename;
773 
774       if (isSystem || isOverridden || isExplicitModule) {
775         Out << " [";
776         if (isSystem) {
777           Out << "System";
778           if (isOverridden || isExplicitModule)
779             Out << ", ";
780         }
781         if (isOverridden) {
782           Out << "Overridden";
783           if (isExplicitModule)
784             Out << ", ";
785         }
786         if (isExplicitModule)
787           Out << "ExplicitModule";
788 
789         Out << "]";
790       }
791 
792       Out << "\n";
793 
794       return true;
795     }
796 
797     /// Returns true if this \c ASTReaderListener wants to receive the
798     /// imports of the AST file via \c visitImport, false otherwise.
799     bool needsImportVisitation() const override { return true; }
800 
801     /// If needsImportVisitation returns \c true, this is called for each
802     /// AST file imported by this AST file.
803     void visitImport(StringRef ModuleName, StringRef Filename) override {
804       Out.indent(2) << "Imports module '" << ModuleName
805                     << "': " << Filename.str() << "\n";
806     }
807 #undef DUMP_BOOLEAN
808   };
809 }
810 
811 bool DumpModuleInfoAction::BeginInvocation(CompilerInstance &CI) {
812   // The Object file reader also supports raw ast files and there is no point in
813   // being strict about the module file format in -module-file-info mode.
814   CI.getHeaderSearchOpts().ModuleFormat = "obj";
815   return true;
816 }
817 
818 static StringRef ModuleKindName(Module::ModuleKind MK) {
819   switch (MK) {
820   case Module::ModuleMapModule:
821     return "Module Map Module";
822   case Module::ModuleInterfaceUnit:
823     return "Interface Unit";
824   case Module::ModuleImplementationUnit:
825     return "Implementation Unit";
826   case Module::ModulePartitionInterface:
827     return "Partition Interface";
828   case Module::ModulePartitionImplementation:
829     return "Partition Implementation";
830   case Module::ModuleHeaderUnit:
831     return "Header Unit";
832   case Module::ExplicitGlobalModuleFragment:
833     return "Global Module Fragment";
834   case Module::ImplicitGlobalModuleFragment:
835     return "Implicit Module Fragment";
836   case Module::PrivateModuleFragment:
837     return "Private Module Fragment";
838   }
839   llvm_unreachable("unknown module kind!");
840 }
841 
842 void DumpModuleInfoAction::ExecuteAction() {
843   assert(isCurrentFileAST() && "dumping non-AST?");
844   // Set up the output file.
845   CompilerInstance &CI = getCompilerInstance();
846   StringRef OutputFileName = CI.getFrontendOpts().OutputFile;
847   if (!OutputFileName.empty() && OutputFileName != "-") {
848     std::error_code EC;
849     OutputStream.reset(new llvm::raw_fd_ostream(
850         OutputFileName.str(), EC, llvm::sys::fs::OF_TextWithCRLF));
851   }
852   llvm::raw_ostream &Out = OutputStream ? *OutputStream : llvm::outs();
853 
854   Out << "Information for module file '" << getCurrentFile() << "':\n";
855   auto &FileMgr = CI.getFileManager();
856   auto Buffer = FileMgr.getBufferForFile(getCurrentFile());
857   StringRef Magic = (*Buffer)->getMemBufferRef().getBuffer();
858   bool IsRaw = Magic.starts_with("CPCH");
859   Out << "  Module format: " << (IsRaw ? "raw" : "obj") << "\n";
860 
861   Preprocessor &PP = CI.getPreprocessor();
862   DumpModuleInfoListener Listener(Out);
863   HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts();
864 
865   // The FrontendAction::BeginSourceFile () method loads the AST so that much
866   // of the information is already available and modules should have been
867   // loaded.
868 
869   const LangOptions &LO = getCurrentASTUnit().getLangOpts();
870   if (LO.CPlusPlusModules && !LO.CurrentModule.empty()) {
871     ASTReader *R = getCurrentASTUnit().getASTReader().get();
872     unsigned SubModuleCount = R->getTotalNumSubmodules();
873     serialization::ModuleFile &MF = R->getModuleManager().getPrimaryModule();
874     Out << "  ====== C++20 Module structure ======\n";
875 
876     if (MF.ModuleName != LO.CurrentModule)
877       Out << "  Mismatched module names : " << MF.ModuleName << " and "
878           << LO.CurrentModule << "\n";
879 
880     struct SubModInfo {
881       unsigned Idx;
882       Module *Mod;
883       Module::ModuleKind Kind;
884       std::string &Name;
885       bool Seen;
886     };
887     std::map<std::string, SubModInfo> SubModMap;
888     auto PrintSubMapEntry = [&](std::string Name, Module::ModuleKind Kind) {
889       Out << "    " << ModuleKindName(Kind) << " '" << Name << "'";
890       auto I = SubModMap.find(Name);
891       if (I == SubModMap.end())
892         Out << " was not found in the sub modules!\n";
893       else {
894         I->second.Seen = true;
895         Out << " is at index #" << I->second.Idx << "\n";
896       }
897     };
898     Module *Primary = nullptr;
899     for (unsigned Idx = 0; Idx <= SubModuleCount; ++Idx) {
900       Module *M = R->getModule(Idx);
901       if (!M)
902         continue;
903       if (M->Name == LO.CurrentModule) {
904         Primary = M;
905         Out << "  " << ModuleKindName(M->Kind) << " '" << LO.CurrentModule
906             << "' is the Primary Module at index #" << Idx << "\n";
907         SubModMap.insert({M->Name, {Idx, M, M->Kind, M->Name, true}});
908       } else
909         SubModMap.insert({M->Name, {Idx, M, M->Kind, M->Name, false}});
910     }
911     if (Primary) {
912       if (!Primary->submodules().empty())
913         Out << "   Sub Modules:\n";
914       for (auto *MI : Primary->submodules()) {
915         PrintSubMapEntry(MI->Name, MI->Kind);
916       }
917       if (!Primary->Imports.empty())
918         Out << "   Imports:\n";
919       for (auto *IMP : Primary->Imports) {
920         PrintSubMapEntry(IMP->Name, IMP->Kind);
921       }
922       if (!Primary->Exports.empty())
923         Out << "   Exports:\n";
924       for (unsigned MN = 0, N = Primary->Exports.size(); MN != N; ++MN) {
925         if (Module *M = Primary->Exports[MN].getPointer()) {
926           PrintSubMapEntry(M->Name, M->Kind);
927         }
928       }
929     }
930 
931     // Emit the macro definitions in the module file so that we can know how
932     // much definitions in the module file quickly.
933     // TODO: Emit the macro definition bodies completely.
934     if (auto FilteredMacros = llvm::make_filter_range(
935             R->getPreprocessor().macros(),
936             [](const auto &Macro) { return Macro.first->isFromAST(); });
937         !FilteredMacros.empty()) {
938       Out << "   Macro Definitions:\n";
939       for (/*<IdentifierInfo *, MacroState> pair*/ const auto &Macro :
940            FilteredMacros)
941         Out << "     " << Macro.first->getName() << "\n";
942     }
943 
944     // Now let's print out any modules we did not see as part of the Primary.
945     for (const auto &SM : SubModMap) {
946       if (!SM.second.Seen && SM.second.Mod) {
947         Out << "  " << ModuleKindName(SM.second.Kind) << " '" << SM.first
948             << "' at index #" << SM.second.Idx
949             << " has no direct reference in the Primary\n";
950       }
951     }
952     Out << "  ====== ======\n";
953   }
954 
955   // The reminder of the output is produced from the listener as the AST
956   // FileCcontrolBlock is (re-)parsed.
957   ASTReader::readASTFileControlBlock(
958       getCurrentFile(), FileMgr, CI.getModuleCache(),
959       CI.getPCHContainerReader(),
960       /*FindModuleFileExtensions=*/true, Listener,
961       HSOpts.ModulesValidateDiagnosticOptions);
962 }
963 
964 //===----------------------------------------------------------------------===//
965 // Preprocessor Actions
966 //===----------------------------------------------------------------------===//
967 
968 void DumpRawTokensAction::ExecuteAction() {
969   Preprocessor &PP = getCompilerInstance().getPreprocessor();
970   SourceManager &SM = PP.getSourceManager();
971 
972   // Start lexing the specified input file.
973   llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(SM.getMainFileID());
974   Lexer RawLex(SM.getMainFileID(), FromFile, SM, PP.getLangOpts());
975   RawLex.SetKeepWhitespaceMode(true);
976 
977   Token RawTok;
978   RawLex.LexFromRawLexer(RawTok);
979   while (RawTok.isNot(tok::eof)) {
980     PP.DumpToken(RawTok, true);
981     llvm::errs() << "\n";
982     RawLex.LexFromRawLexer(RawTok);
983   }
984 }
985 
986 void DumpTokensAction::ExecuteAction() {
987   Preprocessor &PP = getCompilerInstance().getPreprocessor();
988   // Start preprocessing the specified input file.
989   Token Tok;
990   PP.EnterMainSourceFile();
991   do {
992     PP.Lex(Tok);
993     PP.DumpToken(Tok, true);
994     llvm::errs() << "\n";
995   } while (Tok.isNot(tok::eof));
996 }
997 
998 void PreprocessOnlyAction::ExecuteAction() {
999   Preprocessor &PP = getCompilerInstance().getPreprocessor();
1000 
1001   // Ignore unknown pragmas.
1002   PP.IgnorePragmas();
1003 
1004   Token Tok;
1005   // Start parsing the specified input file.
1006   PP.EnterMainSourceFile();
1007   do {
1008     PP.Lex(Tok);
1009   } while (Tok.isNot(tok::eof));
1010 }
1011 
1012 void PrintPreprocessedAction::ExecuteAction() {
1013   CompilerInstance &CI = getCompilerInstance();
1014   // Output file may need to be set to 'Binary', to avoid converting Unix style
1015   // line feeds (<LF>) to Microsoft style line feeds (<CR><LF>) on Windows.
1016   //
1017   // Look to see what type of line endings the file uses. If there's a
1018   // CRLF, then we won't open the file up in binary mode. If there is
1019   // just an LF or CR, then we will open the file up in binary mode.
1020   // In this fashion, the output format should match the input format, unless
1021   // the input format has inconsistent line endings.
1022   //
1023   // This should be a relatively fast operation since most files won't have
1024   // all of their source code on a single line. However, that is still a
1025   // concern, so if we scan for too long, we'll just assume the file should
1026   // be opened in binary mode.
1027 
1028   bool BinaryMode = false;
1029   if (llvm::Triple(LLVM_HOST_TRIPLE).isOSWindows()) {
1030     BinaryMode = true;
1031     const SourceManager &SM = CI.getSourceManager();
1032     if (std::optional<llvm::MemoryBufferRef> Buffer =
1033             SM.getBufferOrNone(SM.getMainFileID())) {
1034       const char *cur = Buffer->getBufferStart();
1035       const char *end = Buffer->getBufferEnd();
1036       const char *next = (cur != end) ? cur + 1 : end;
1037 
1038       // Limit ourselves to only scanning 256 characters into the source
1039       // file.  This is mostly a check in case the file has no
1040       // newlines whatsoever.
1041       if (end - cur > 256)
1042         end = cur + 256;
1043 
1044       while (next < end) {
1045         if (*cur == 0x0D) {  // CR
1046           if (*next == 0x0A) // CRLF
1047             BinaryMode = false;
1048 
1049           break;
1050         } else if (*cur == 0x0A) // LF
1051           break;
1052 
1053         ++cur;
1054         ++next;
1055       }
1056     }
1057   }
1058 
1059   std::unique_ptr<raw_ostream> OS =
1060       CI.createDefaultOutputFile(BinaryMode, getCurrentFileOrBufferName());
1061   if (!OS) return;
1062 
1063   // If we're preprocessing a module map, start by dumping the contents of the
1064   // module itself before switching to the input buffer.
1065   auto &Input = getCurrentInput();
1066   if (Input.getKind().getFormat() == InputKind::ModuleMap) {
1067     if (Input.isFile()) {
1068       (*OS) << "# 1 \"";
1069       OS->write_escaped(Input.getFile());
1070       (*OS) << "\"\n";
1071     }
1072     getCurrentModule()->print(*OS);
1073     (*OS) << "#pragma clang module contents\n";
1074   }
1075 
1076   DoPrintPreprocessedInput(CI.getPreprocessor(), OS.get(),
1077                            CI.getPreprocessorOutputOpts());
1078 }
1079 
1080 void PrintPreambleAction::ExecuteAction() {
1081   switch (getCurrentFileKind().getLanguage()) {
1082   case Language::C:
1083   case Language::CXX:
1084   case Language::ObjC:
1085   case Language::ObjCXX:
1086   case Language::OpenCL:
1087   case Language::OpenCLCXX:
1088   case Language::CUDA:
1089   case Language::HIP:
1090   case Language::HLSL:
1091   case Language::CIR:
1092     break;
1093 
1094   case Language::Unknown:
1095   case Language::Asm:
1096   case Language::LLVM_IR:
1097   case Language::RenderScript:
1098     // We can't do anything with these.
1099     return;
1100   }
1101 
1102   // We don't expect to find any #include directives in a preprocessed input.
1103   if (getCurrentFileKind().isPreprocessed())
1104     return;
1105 
1106   CompilerInstance &CI = getCompilerInstance();
1107   auto Buffer = CI.getFileManager().getBufferForFile(getCurrentFile());
1108   if (Buffer) {
1109     unsigned Preamble =
1110         Lexer::ComputePreamble((*Buffer)->getBuffer(), CI.getLangOpts()).Size;
1111     llvm::outs().write((*Buffer)->getBufferStart(), Preamble);
1112   }
1113 }
1114 
1115 void DumpCompilerOptionsAction::ExecuteAction() {
1116   CompilerInstance &CI = getCompilerInstance();
1117   std::unique_ptr<raw_ostream> OSP =
1118       CI.createDefaultOutputFile(false, getCurrentFile());
1119   if (!OSP)
1120     return;
1121 
1122   raw_ostream &OS = *OSP;
1123   const Preprocessor &PP = CI.getPreprocessor();
1124   const LangOptions &LangOpts = PP.getLangOpts();
1125 
1126   // FIXME: Rather than manually format the JSON (which is awkward due to
1127   // needing to remove trailing commas), this should make use of a JSON library.
1128   // FIXME: Instead of printing enums as an integral value and specifying the
1129   // type as a separate field, use introspection to print the enumerator.
1130 
1131   OS << "{\n";
1132   OS << "\n\"features\" : [\n";
1133   {
1134     llvm::SmallString<128> Str;
1135 #define FEATURE(Name, Predicate)                                               \
1136   ("\t{\"" #Name "\" : " + llvm::Twine(Predicate ? "true" : "false") + "},\n") \
1137       .toVector(Str);
1138 #include "clang/Basic/Features.def"
1139 #undef FEATURE
1140     // Remove the newline and comma from the last entry to ensure this remains
1141     // valid JSON.
1142     OS << Str.substr(0, Str.size() - 2);
1143   }
1144   OS << "\n],\n";
1145 
1146   OS << "\n\"extensions\" : [\n";
1147   {
1148     llvm::SmallString<128> Str;
1149 #define EXTENSION(Name, Predicate)                                             \
1150   ("\t{\"" #Name "\" : " + llvm::Twine(Predicate ? "true" : "false") + "},\n") \
1151       .toVector(Str);
1152 #include "clang/Basic/Features.def"
1153 #undef EXTENSION
1154     // Remove the newline and comma from the last entry to ensure this remains
1155     // valid JSON.
1156     OS << Str.substr(0, Str.size() - 2);
1157   }
1158   OS << "\n]\n";
1159 
1160   OS << "}";
1161 }
1162 
1163 void PrintDependencyDirectivesSourceMinimizerAction::ExecuteAction() {
1164   CompilerInstance &CI = getCompilerInstance();
1165   SourceManager &SM = CI.getPreprocessor().getSourceManager();
1166   llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(SM.getMainFileID());
1167 
1168   llvm::SmallVector<dependency_directives_scan::Token, 16> Tokens;
1169   llvm::SmallVector<dependency_directives_scan::Directive, 32> Directives;
1170   if (scanSourceForDependencyDirectives(
1171           FromFile.getBuffer(), Tokens, Directives, &CI.getDiagnostics(),
1172           SM.getLocForStartOfFile(SM.getMainFileID()))) {
1173     assert(CI.getDiagnostics().hasErrorOccurred() &&
1174            "no errors reported for failure");
1175 
1176     // Preprocess the source when verifying the diagnostics to capture the
1177     // 'expected' comments.
1178     if (CI.getDiagnosticOpts().VerifyDiagnostics) {
1179       // Make sure we don't emit new diagnostics!
1180       CI.getDiagnostics().setSuppressAllDiagnostics(true);
1181       Preprocessor &PP = getCompilerInstance().getPreprocessor();
1182       PP.EnterMainSourceFile();
1183       Token Tok;
1184       do {
1185         PP.Lex(Tok);
1186       } while (Tok.isNot(tok::eof));
1187     }
1188     return;
1189   }
1190   printDependencyDirectivesAsSource(FromFile.getBuffer(), Directives,
1191                                     llvm::outs());
1192 }
1193 
1194 void GetDependenciesByModuleNameAction::ExecuteAction() {
1195   CompilerInstance &CI = getCompilerInstance();
1196   AdjustCI(CI);
1197 
1198   Preprocessor &PP = CI.getPreprocessor();
1199   SourceManager &SM = PP.getSourceManager();
1200   FileID MainFileID = SM.getMainFileID();
1201   SourceLocation FileStart = SM.getLocForStartOfFile(MainFileID);
1202   SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path;
1203   IdentifierInfo *ModuleID = PP.getIdentifierInfo(ModuleName);
1204   Path.push_back(std::make_pair(ModuleID, FileStart));
1205   auto ModResult = CI.loadModule(FileStart, Path, Module::Hidden, false);
1206   PPCallbacks *CB = PP.getPPCallbacks();
1207   CB->moduleImport(SourceLocation(), Path, ModResult);
1208 }
1209