ASTUnit.cpp revision 4125c37c71c6c8475019497de837204f0ee4370f 
1//===--- ASTUnit.cpp - ASTUnit utility ------------------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// ASTUnit Implementation.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/Frontend/ASTUnit.h"
15#include "clang/AST/ASTContext.h"
16#include "clang/AST/ASTConsumer.h"
17#include "clang/AST/DeclVisitor.h"
18#include "clang/AST/TypeOrdering.h"
19#include "clang/AST/StmtVisitor.h"
20#include "clang/Driver/Compilation.h"
21#include "clang/Driver/Driver.h"
22#include "clang/Driver/Job.h"
23#include "clang/Driver/Tool.h"
24#include "clang/Frontend/CompilerInstance.h"
25#include "clang/Frontend/FrontendActions.h"
26#include "clang/Frontend/FrontendDiagnostic.h"
27#include "clang/Frontend/FrontendOptions.h"
28#include "clang/Serialization/ASTReader.h"
29#include "clang/Serialization/ASTWriter.h"
30#include "clang/Lex/HeaderSearch.h"
31#include "clang/Lex/Preprocessor.h"
32#include "clang/Basic/TargetOptions.h"
33#include "clang/Basic/TargetInfo.h"
34#include "clang/Basic/Diagnostic.h"
35#include "llvm/ADT/StringSet.h"
36#include "llvm/Support/MemoryBuffer.h"
37#include "llvm/System/Host.h"
38#include "llvm/System/Path.h"
39#include "llvm/Support/raw_ostream.h"
40#include "llvm/Support/Timer.h"
41#include <cstdlib>
42#include <cstdio>
43#include <sys/stat.h>
44using namespace clang;
45
46/// \brief After failing to build a precompiled preamble (due to
47/// errors in the source that occurs in the preamble), the number of
48/// reparses during which we'll skip even trying to precompile the
49/// preamble.
50const unsigned DefaultPreambleRebuildInterval = 5;
51
52ASTUnit::ASTUnit(bool _MainFileIsAST)
53  : CaptureDiagnostics(false), MainFileIsAST(_MainFileIsAST),
54    CompleteTranslationUnit(true), ConcurrencyCheckValue(CheckUnlocked),
55    PreambleRebuildCounter(0), SavedMainFileBuffer(0), PreambleBuffer(0),
56    ShouldCacheCodeCompletionResults(false),
57    NumTopLevelDeclsAtLastCompletionCache(0),
58    CacheCodeCompletionCoolDown(0),
59    UnsafeToFree(false) {
60}
61
62ASTUnit::~ASTUnit() {
63  ConcurrencyCheckValue = CheckLocked;
64  CleanTemporaryFiles();
65  if (!PreambleFile.empty())
66    llvm::sys::Path(PreambleFile).eraseFromDisk();
67
68  // Free the buffers associated with remapped files. We are required to
69  // perform this operation here because we explicitly request that the
70  // compiler instance *not* free these buffers for each invocation of the
71  // parser.
72  if (Invocation.get()) {
73    PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
74    for (PreprocessorOptions::remapped_file_buffer_iterator
75           FB = PPOpts.remapped_file_buffer_begin(),
76           FBEnd = PPOpts.remapped_file_buffer_end();
77         FB != FBEnd;
78         ++FB)
79      delete FB->second;
80  }
81
82  delete SavedMainFileBuffer;
83  delete PreambleBuffer;
84
85  ClearCachedCompletionResults();
86
87  for (unsigned I = 0, N = Timers.size(); I != N; ++I)
88    delete Timers[I];
89}
90
91void ASTUnit::CleanTemporaryFiles() {
92  for (unsigned I = 0, N = TemporaryFiles.size(); I != N; ++I)
93    TemporaryFiles[I].eraseFromDisk();
94  TemporaryFiles.clear();
95}
96
97/// \brief Determine the set of code-completion contexts in which this
98/// declaration should be shown.
99static unsigned getDeclShowContexts(NamedDecl *ND,
100                                    const LangOptions &LangOpts,
101                                    bool &IsNestedNameSpecifier) {
102  IsNestedNameSpecifier = false;
103
104  if (isa<UsingShadowDecl>(ND))
105    ND = dyn_cast<NamedDecl>(ND->getUnderlyingDecl());
106  if (!ND)
107    return 0;
108
109  unsigned Contexts = 0;
110  if (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND) ||
111      isa<ClassTemplateDecl>(ND) || isa<TemplateTemplateParmDecl>(ND)) {
112    // Types can appear in these contexts.
113    if (LangOpts.CPlusPlus || !isa<TagDecl>(ND))
114      Contexts |= (1 << (CodeCompletionContext::CCC_TopLevel - 1))
115                | (1 << (CodeCompletionContext::CCC_ObjCIvarList - 1))
116                | (1 << (CodeCompletionContext::CCC_ClassStructUnion - 1))
117                | (1 << (CodeCompletionContext::CCC_Statement - 1))
118                | (1 << (CodeCompletionContext::CCC_Type - 1));
119
120    // In C++, types can appear in expressions contexts (for functional casts).
121    if (LangOpts.CPlusPlus)
122      Contexts |= (1 << (CodeCompletionContext::CCC_Expression - 1));
123
124    // In Objective-C, message sends can send interfaces. In Objective-C++,
125    // all types are available due to functional casts.
126    if (LangOpts.CPlusPlus || isa<ObjCInterfaceDecl>(ND))
127      Contexts |= (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1));
128
129    // Deal with tag names.
130    if (isa<EnumDecl>(ND)) {
131      Contexts |= (1 << (CodeCompletionContext::CCC_EnumTag - 1));
132
133      // Part of the nested-name-specifier in C++0x.
134      if (LangOpts.CPlusPlus0x)
135        IsNestedNameSpecifier = true;
136    } else if (RecordDecl *Record = dyn_cast<RecordDecl>(ND)) {
137      if (Record->isUnion())
138        Contexts |= (1 << (CodeCompletionContext::CCC_UnionTag - 1));
139      else
140        Contexts |= (1 << (CodeCompletionContext::CCC_ClassOrStructTag - 1));
141
142      if (LangOpts.CPlusPlus)
143        IsNestedNameSpecifier = true;
144    } else if (isa<ClassTemplateDecl>(ND) || isa<TemplateTemplateParmDecl>(ND))
145      IsNestedNameSpecifier = true;
146  } else if (isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND)) {
147    // Values can appear in these contexts.
148    Contexts = (1 << (CodeCompletionContext::CCC_Statement - 1))
149             | (1 << (CodeCompletionContext::CCC_Expression - 1))
150             | (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1));
151  } else if (isa<ObjCProtocolDecl>(ND)) {
152    Contexts = (1 << (CodeCompletionContext::CCC_ObjCProtocolName - 1));
153  } else if (isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND)) {
154    Contexts = (1 << (CodeCompletionContext::CCC_Namespace - 1));
155
156    // Part of the nested-name-specifier.
157    IsNestedNameSpecifier = true;
158  }
159
160  return Contexts;
161}
162
163void ASTUnit::CacheCodeCompletionResults() {
164  if (!TheSema)
165    return;
166
167  llvm::Timer *CachingTimer = 0;
168  if (TimerGroup.get()) {
169    CachingTimer = new llvm::Timer("Cache global code completions",
170                                   *TimerGroup);
171    CachingTimer->startTimer();
172    Timers.push_back(CachingTimer);
173  }
174
175  // Clear out the previous results.
176  ClearCachedCompletionResults();
177
178  // Gather the set of global code completions.
179  typedef CodeCompletionResult Result;
180  llvm::SmallVector<Result, 8> Results;
181  TheSema->GatherGlobalCodeCompletions(Results);
182
183  // Translate global code completions into cached completions.
184  llvm::DenseMap<CanQualType, unsigned> CompletionTypes;
185
186  for (unsigned I = 0, N = Results.size(); I != N; ++I) {
187    switch (Results[I].Kind) {
188    case Result::RK_Declaration: {
189      bool IsNestedNameSpecifier = false;
190      CachedCodeCompletionResult CachedResult;
191      CachedResult.Completion = Results[I].CreateCodeCompletionString(*TheSema);
192      CachedResult.ShowInContexts = getDeclShowContexts(Results[I].Declaration,
193                                                        Ctx->getLangOptions(),
194                                                        IsNestedNameSpecifier);
195      CachedResult.Priority = Results[I].Priority;
196      CachedResult.Kind = Results[I].CursorKind;
197      CachedResult.Availability = Results[I].Availability;
198
199      // Keep track of the type of this completion in an ASTContext-agnostic
200      // way.
201      QualType UsageType = getDeclUsageType(*Ctx, Results[I].Declaration);
202      if (UsageType.isNull()) {
203        CachedResult.TypeClass = STC_Void;
204        CachedResult.Type = 0;
205      } else {
206        CanQualType CanUsageType
207          = Ctx->getCanonicalType(UsageType.getUnqualifiedType());
208        CachedResult.TypeClass = getSimplifiedTypeClass(CanUsageType);
209
210        // Determine whether we have already seen this type. If so, we save
211        // ourselves the work of formatting the type string by using the
212        // temporary, CanQualType-based hash table to find the associated value.
213        unsigned &TypeValue = CompletionTypes[CanUsageType];
214        if (TypeValue == 0) {
215          TypeValue = CompletionTypes.size();
216          CachedCompletionTypes[QualType(CanUsageType).getAsString()]
217            = TypeValue;
218        }
219
220        CachedResult.Type = TypeValue;
221      }
222
223      CachedCompletionResults.push_back(CachedResult);
224
225      /// Handle nested-name-specifiers in C++.
226      if (TheSema->Context.getLangOptions().CPlusPlus &&
227          IsNestedNameSpecifier && !Results[I].StartsNestedNameSpecifier) {
228        // The contexts in which a nested-name-specifier can appear in C++.
229        unsigned NNSContexts
230          = (1 << (CodeCompletionContext::CCC_TopLevel - 1))
231          | (1 << (CodeCompletionContext::CCC_ObjCIvarList - 1))
232          | (1 << (CodeCompletionContext::CCC_ClassStructUnion - 1))
233          | (1 << (CodeCompletionContext::CCC_Statement - 1))
234          | (1 << (CodeCompletionContext::CCC_Expression - 1))
235          | (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1))
236          | (1 << (CodeCompletionContext::CCC_EnumTag - 1))
237          | (1 << (CodeCompletionContext::CCC_UnionTag - 1))
238          | (1 << (CodeCompletionContext::CCC_ClassOrStructTag - 1))
239          | (1 << (CodeCompletionContext::CCC_Type - 1))
240          | (1 << (CodeCompletionContext::CCC_PotentiallyQualifiedName - 1));
241
242        if (isa<NamespaceDecl>(Results[I].Declaration) ||
243            isa<NamespaceAliasDecl>(Results[I].Declaration))
244          NNSContexts |= (1 << (CodeCompletionContext::CCC_Namespace - 1));
245
246        if (unsigned RemainingContexts
247                                = NNSContexts & ~CachedResult.ShowInContexts) {
248          // If there any contexts where this completion can be a
249          // nested-name-specifier but isn't already an option, create a
250          // nested-name-specifier completion.
251          Results[I].StartsNestedNameSpecifier = true;
252          CachedResult.Completion = Results[I].CreateCodeCompletionString(*TheSema);
253          CachedResult.ShowInContexts = RemainingContexts;
254          CachedResult.Priority = CCP_NestedNameSpecifier;
255          CachedResult.TypeClass = STC_Void;
256          CachedResult.Type = 0;
257          CachedCompletionResults.push_back(CachedResult);
258        }
259      }
260      break;
261    }
262
263    case Result::RK_Keyword:
264    case Result::RK_Pattern:
265      // Ignore keywords and patterns; we don't care, since they are so
266      // easily regenerated.
267      break;
268
269    case Result::RK_Macro: {
270      CachedCodeCompletionResult CachedResult;
271      CachedResult.Completion = Results[I].CreateCodeCompletionString(*TheSema);
272      CachedResult.ShowInContexts
273        = (1 << (CodeCompletionContext::CCC_TopLevel - 1))
274        | (1 << (CodeCompletionContext::CCC_ObjCInterface - 1))
275        | (1 << (CodeCompletionContext::CCC_ObjCImplementation - 1))
276        | (1 << (CodeCompletionContext::CCC_ObjCIvarList - 1))
277        | (1 << (CodeCompletionContext::CCC_ClassStructUnion - 1))
278        | (1 << (CodeCompletionContext::CCC_Statement - 1))
279        | (1 << (CodeCompletionContext::CCC_Expression - 1))
280        | (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1))
281        | (1 << (CodeCompletionContext::CCC_MacroNameUse - 1))
282        | (1 << (CodeCompletionContext::CCC_PreprocessorExpression - 1));
283
284      CachedResult.Priority = Results[I].Priority;
285      CachedResult.Kind = Results[I].CursorKind;
286      CachedResult.Availability = Results[I].Availability;
287      CachedResult.TypeClass = STC_Void;
288      CachedResult.Type = 0;
289      CachedCompletionResults.push_back(CachedResult);
290      break;
291    }
292    }
293    Results[I].Destroy();
294  }
295
296  if (CachingTimer)
297    CachingTimer->stopTimer();
298
299  // Make a note of the state when we performed this caching.
300  NumTopLevelDeclsAtLastCompletionCache = top_level_size();
301  CacheCodeCompletionCoolDown = 15;
302}
303
304void ASTUnit::ClearCachedCompletionResults() {
305  for (unsigned I = 0, N = CachedCompletionResults.size(); I != N; ++I)
306    delete CachedCompletionResults[I].Completion;
307  CachedCompletionResults.clear();
308  CachedCompletionTypes.clear();
309}
310
311namespace {
312
313/// \brief Gathers information from ASTReader that will be used to initialize
314/// a Preprocessor.
315class ASTInfoCollector : public ASTReaderListener {
316  LangOptions &LangOpt;
317  HeaderSearch &HSI;
318  std::string &TargetTriple;
319  std::string &Predefines;
320  unsigned &Counter;
321
322  unsigned NumHeaderInfos;
323
324public:
325  ASTInfoCollector(LangOptions &LangOpt, HeaderSearch &HSI,
326                   std::string &TargetTriple, std::string &Predefines,
327                   unsigned &Counter)
328    : LangOpt(LangOpt), HSI(HSI), TargetTriple(TargetTriple),
329      Predefines(Predefines), Counter(Counter), NumHeaderInfos(0) {}
330
331  virtual bool ReadLanguageOptions(const LangOptions &LangOpts) {
332    LangOpt = LangOpts;
333    return false;
334  }
335
336  virtual bool ReadTargetTriple(llvm::StringRef Triple) {
337    TargetTriple = Triple;
338    return false;
339  }
340
341  virtual bool ReadPredefinesBuffer(const PCHPredefinesBlocks &Buffers,
342                                    llvm::StringRef OriginalFileName,
343                                    std::string &SuggestedPredefines) {
344    Predefines = Buffers[0].Data;
345    for (unsigned I = 1, N = Buffers.size(); I != N; ++I) {
346      Predefines += Buffers[I].Data;
347    }
348    return false;
349  }
350
351  virtual void ReadHeaderFileInfo(const HeaderFileInfo &HFI, unsigned ID) {
352    HSI.setHeaderFileInfoForUID(HFI, NumHeaderInfos++);
353  }
354
355  virtual void ReadCounter(unsigned Value) {
356    Counter = Value;
357  }
358};
359
360class StoredDiagnosticClient : public DiagnosticClient {
361  llvm::SmallVectorImpl<StoredDiagnostic> &StoredDiags;
362
363public:
364  explicit StoredDiagnosticClient(
365                          llvm::SmallVectorImpl<StoredDiagnostic> &StoredDiags)
366    : StoredDiags(StoredDiags) { }
367
368  virtual void HandleDiagnostic(Diagnostic::Level Level,
369                                const DiagnosticInfo &Info);
370};
371
372/// \brief RAII object that optionally captures diagnostics, if
373/// there is no diagnostic client to capture them already.
374class CaptureDroppedDiagnostics {
375  Diagnostic &Diags;
376  StoredDiagnosticClient Client;
377  DiagnosticClient *PreviousClient;
378
379public:
380  CaptureDroppedDiagnostics(bool RequestCapture, Diagnostic &Diags,
381                           llvm::SmallVectorImpl<StoredDiagnostic> &StoredDiags)
382    : Diags(Diags), Client(StoredDiags), PreviousClient(0)
383  {
384    if (RequestCapture || Diags.getClient() == 0) {
385      PreviousClient = Diags.takeClient();
386      Diags.setClient(&Client);
387    }
388  }
389
390  ~CaptureDroppedDiagnostics() {
391    if (Diags.getClient() == &Client) {
392      Diags.takeClient();
393      Diags.setClient(PreviousClient);
394    }
395  }
396};
397
398} // anonymous namespace
399
400void StoredDiagnosticClient::HandleDiagnostic(Diagnostic::Level Level,
401                                              const DiagnosticInfo &Info) {
402  StoredDiags.push_back(StoredDiagnostic(Level, Info));
403}
404
405const std::string &ASTUnit::getOriginalSourceFileName() {
406  return OriginalSourceFile;
407}
408
409const std::string &ASTUnit::getASTFileName() {
410  assert(isMainFileAST() && "Not an ASTUnit from an AST file!");
411  return static_cast<ASTReader *>(Ctx->getExternalSource())->getFileName();
412}
413
414ASTUnit *ASTUnit::LoadFromASTFile(const std::string &Filename,
415                                  llvm::IntrusiveRefCntPtr<Diagnostic> Diags,
416                                  bool OnlyLocalDecls,
417                                  RemappedFile *RemappedFiles,
418                                  unsigned NumRemappedFiles,
419                                  bool CaptureDiagnostics) {
420  llvm::OwningPtr<ASTUnit> AST(new ASTUnit(true));
421
422  if (!Diags.getPtr()) {
423    // No diagnostics engine was provided, so create our own diagnostics object
424    // with the default options.
425    DiagnosticOptions DiagOpts;
426    Diags = CompilerInstance::createDiagnostics(DiagOpts, 0, 0);
427  }
428
429  AST->CaptureDiagnostics = CaptureDiagnostics;
430  AST->OnlyLocalDecls = OnlyLocalDecls;
431  AST->Diagnostics = Diags;
432  AST->FileMgr.reset(new FileManager);
433  AST->SourceMgr.reset(new SourceManager(AST->getDiagnostics()));
434  AST->HeaderInfo.reset(new HeaderSearch(AST->getFileManager()));
435
436  // If requested, capture diagnostics in the ASTUnit.
437  CaptureDroppedDiagnostics Capture(CaptureDiagnostics, AST->getDiagnostics(),
438                                    AST->StoredDiagnostics);
439
440  for (unsigned I = 0; I != NumRemappedFiles; ++I) {
441    // Create the file entry for the file that we're mapping from.
442    const FileEntry *FromFile
443      = AST->getFileManager().getVirtualFile(RemappedFiles[I].first,
444                                    RemappedFiles[I].second->getBufferSize(),
445                                             0);
446    if (!FromFile) {
447      AST->getDiagnostics().Report(diag::err_fe_remap_missing_from_file)
448        << RemappedFiles[I].first;
449      delete RemappedFiles[I].second;
450      continue;
451    }
452
453    // Override the contents of the "from" file with the contents of
454    // the "to" file.
455    AST->getSourceManager().overrideFileContents(FromFile,
456                                                 RemappedFiles[I].second);
457  }
458
459  // Gather Info for preprocessor construction later on.
460
461  LangOptions LangInfo;
462  HeaderSearch &HeaderInfo = *AST->HeaderInfo.get();
463  std::string TargetTriple;
464  std::string Predefines;
465  unsigned Counter;
466
467  llvm::OwningPtr<ASTReader> Reader;
468
469  Reader.reset(new ASTReader(AST->getSourceManager(), AST->getFileManager(),
470                             AST->getDiagnostics()));
471  Reader->setListener(new ASTInfoCollector(LangInfo, HeaderInfo, TargetTriple,
472                                           Predefines, Counter));
473
474  switch (Reader->ReadAST(Filename)) {
475  case ASTReader::Success:
476    break;
477
478  case ASTReader::Failure:
479  case ASTReader::IgnorePCH:
480    AST->getDiagnostics().Report(diag::err_fe_unable_to_load_pch);
481    return NULL;
482  }
483
484  AST->OriginalSourceFile = Reader->getOriginalSourceFile();
485
486  // AST file loaded successfully. Now create the preprocessor.
487
488  // Get information about the target being compiled for.
489  //
490  // FIXME: This is broken, we should store the TargetOptions in the AST file.
491  TargetOptions TargetOpts;
492  TargetOpts.ABI = "";
493  TargetOpts.CXXABI = "";
494  TargetOpts.CPU = "";
495  TargetOpts.Features.clear();
496  TargetOpts.Triple = TargetTriple;
497  AST->Target.reset(TargetInfo::CreateTargetInfo(AST->getDiagnostics(),
498                                                 TargetOpts));
499  AST->PP.reset(new Preprocessor(AST->getDiagnostics(), LangInfo,
500                                 *AST->Target.get(),
501                                 AST->getSourceManager(), HeaderInfo));
502  Preprocessor &PP = *AST->PP.get();
503
504  PP.setPredefines(Reader->getSuggestedPredefines());
505  PP.setCounterValue(Counter);
506  Reader->setPreprocessor(PP);
507
508  // Create and initialize the ASTContext.
509
510  AST->Ctx.reset(new ASTContext(LangInfo,
511                                AST->getSourceManager(),
512                                *AST->Target.get(),
513                                PP.getIdentifierTable(),
514                                PP.getSelectorTable(),
515                                PP.getBuiltinInfo(),
516                                /* size_reserve = */0));
517  ASTContext &Context = *AST->Ctx.get();
518
519  Reader->InitializeContext(Context);
520
521  // Attach the AST reader to the AST context as an external AST
522  // source, so that declarations will be deserialized from the
523  // AST file as needed.
524  ASTReader *ReaderPtr = Reader.get();
525  llvm::OwningPtr<ExternalASTSource> Source(Reader.take());
526  Context.setExternalSource(Source);
527
528  // Create an AST consumer, even though it isn't used.
529  AST->Consumer.reset(new ASTConsumer);
530
531  // Create a semantic analysis object and tell the AST reader about it.
532  AST->TheSema.reset(new Sema(PP, Context, *AST->Consumer));
533  AST->TheSema->Initialize();
534  ReaderPtr->InitializeSema(*AST->TheSema);
535
536  return AST.take();
537}
538
539namespace {
540
541class TopLevelDeclTrackerConsumer : public ASTConsumer {
542  ASTUnit &Unit;
543
544public:
545  TopLevelDeclTrackerConsumer(ASTUnit &_Unit) : Unit(_Unit) {}
546
547  void HandleTopLevelDecl(DeclGroupRef D) {
548    for (DeclGroupRef::iterator it = D.begin(), ie = D.end(); it != ie; ++it) {
549      Decl *D = *it;
550      // FIXME: Currently ObjC method declarations are incorrectly being
551      // reported as top-level declarations, even though their DeclContext
552      // is the containing ObjC @interface/@implementation.  This is a
553      // fundamental problem in the parser right now.
554      if (isa<ObjCMethodDecl>(D))
555        continue;
556      Unit.addTopLevelDecl(D);
557    }
558  }
559
560  // We're not interested in "interesting" decls.
561  void HandleInterestingDecl(DeclGroupRef) {}
562};
563
564class TopLevelDeclTrackerAction : public ASTFrontendAction {
565public:
566  ASTUnit &Unit;
567
568  virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
569                                         llvm::StringRef InFile) {
570    return new TopLevelDeclTrackerConsumer(Unit);
571  }
572
573public:
574  TopLevelDeclTrackerAction(ASTUnit &_Unit) : Unit(_Unit) {}
575
576  virtual bool hasCodeCompletionSupport() const { return false; }
577  virtual bool usesCompleteTranslationUnit()  {
578    return Unit.isCompleteTranslationUnit();
579  }
580};
581
582class PrecompilePreambleConsumer : public PCHGenerator {
583  ASTUnit &Unit;
584  std::vector<Decl *> TopLevelDecls;
585
586public:
587  PrecompilePreambleConsumer(ASTUnit &Unit,
588                             const Preprocessor &PP, bool Chaining,
589                             const char *isysroot, llvm::raw_ostream *Out)
590    : PCHGenerator(PP, Chaining, isysroot, Out), Unit(Unit) { }
591
592  virtual void HandleTopLevelDecl(DeclGroupRef D) {
593    for (DeclGroupRef::iterator it = D.begin(), ie = D.end(); it != ie; ++it) {
594      Decl *D = *it;
595      // FIXME: Currently ObjC method declarations are incorrectly being
596      // reported as top-level declarations, even though their DeclContext
597      // is the containing ObjC @interface/@implementation.  This is a
598      // fundamental problem in the parser right now.
599      if (isa<ObjCMethodDecl>(D))
600        continue;
601      TopLevelDecls.push_back(D);
602    }
603  }
604
605  virtual void HandleTranslationUnit(ASTContext &Ctx) {
606    PCHGenerator::HandleTranslationUnit(Ctx);
607    if (!Unit.getDiagnostics().hasErrorOccurred()) {
608      // Translate the top-level declarations we captured during
609      // parsing into declaration IDs in the precompiled
610      // preamble. This will allow us to deserialize those top-level
611      // declarations when requested.
612      for (unsigned I = 0, N = TopLevelDecls.size(); I != N; ++I)
613        Unit.addTopLevelDeclFromPreamble(
614                                      getWriter().getDeclID(TopLevelDecls[I]));
615    }
616  }
617};
618
619class PrecompilePreambleAction : public ASTFrontendAction {
620  ASTUnit &Unit;
621
622public:
623  explicit PrecompilePreambleAction(ASTUnit &Unit) : Unit(Unit) {}
624
625  virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
626                                         llvm::StringRef InFile) {
627    std::string Sysroot;
628    llvm::raw_ostream *OS = 0;
629    bool Chaining;
630    if (GeneratePCHAction::ComputeASTConsumerArguments(CI, InFile, Sysroot,
631                                                       OS, Chaining))
632      return 0;
633
634    const char *isysroot = CI.getFrontendOpts().RelocatablePCH ?
635                             Sysroot.c_str() : 0;
636    return new PrecompilePreambleConsumer(Unit, CI.getPreprocessor(), Chaining,
637                                          isysroot, OS);
638  }
639
640  virtual bool hasCodeCompletionSupport() const { return false; }
641  virtual bool hasASTFileSupport() const { return false; }
642  virtual bool usesCompleteTranslationUnit() { return false; }
643};
644
645}
646
647/// Parse the source file into a translation unit using the given compiler
648/// invocation, replacing the current translation unit.
649///
650/// \returns True if a failure occurred that causes the ASTUnit not to
651/// contain any translation-unit information, false otherwise.
652bool ASTUnit::Parse(llvm::MemoryBuffer *OverrideMainBuffer) {
653  delete SavedMainFileBuffer;
654  SavedMainFileBuffer = 0;
655
656  if (!Invocation.get()) {
657    delete OverrideMainBuffer;
658    return true;
659  }
660
661  // Create the compiler instance to use for building the AST.
662  CompilerInstance Clang;
663  Clang.setInvocation(Invocation.take());
664  OriginalSourceFile = Clang.getFrontendOpts().Inputs[0].second;
665
666  // Set up diagnostics, capturing any diagnostics that would
667  // otherwise be dropped.
668  Clang.setDiagnostics(&getDiagnostics());
669  CaptureDroppedDiagnostics Capture(CaptureDiagnostics,
670                                    getDiagnostics(),
671                                    StoredDiagnostics);
672
673  // Create the target instance.
674  Clang.setTarget(TargetInfo::CreateTargetInfo(Clang.getDiagnostics(),
675                                               Clang.getTargetOpts()));
676  if (!Clang.hasTarget()) {
677    delete OverrideMainBuffer;
678    return true;
679  }
680
681  // Inform the target of the language options.
682  //
683  // FIXME: We shouldn't need to do this, the target should be immutable once
684  // created. This complexity should be lifted elsewhere.
685  Clang.getTarget().setForcedLangOptions(Clang.getLangOpts());
686
687  assert(Clang.getFrontendOpts().Inputs.size() == 1 &&
688         "Invocation must have exactly one source file!");
689  assert(Clang.getFrontendOpts().Inputs[0].first != IK_AST &&
690         "FIXME: AST inputs not yet supported here!");
691  assert(Clang.getFrontendOpts().Inputs[0].first != IK_LLVM_IR &&
692         "IR inputs not support here!");
693
694  // Configure the various subsystems.
695  // FIXME: Should we retain the previous file manager?
696  FileMgr.reset(new FileManager);
697  SourceMgr.reset(new SourceManager(getDiagnostics()));
698  TheSema.reset();
699  Ctx.reset();
700  PP.reset();
701
702  // Clear out old caches and data.
703  TopLevelDecls.clear();
704  CleanTemporaryFiles();
705  PreprocessedEntitiesByFile.clear();
706
707  if (!OverrideMainBuffer) {
708    StoredDiagnostics.clear();
709    TopLevelDeclsInPreamble.clear();
710  }
711
712  // Create a file manager object to provide access to and cache the filesystem.
713  Clang.setFileManager(&getFileManager());
714
715  // Create the source manager.
716  Clang.setSourceManager(&getSourceManager());
717
718  // If the main file has been overridden due to the use of a preamble,
719  // make that override happen and introduce the preamble.
720  PreprocessorOptions &PreprocessorOpts = Clang.getPreprocessorOpts();
721  std::string PriorImplicitPCHInclude;
722  if (OverrideMainBuffer) {
723    PreprocessorOpts.addRemappedFile(OriginalSourceFile, OverrideMainBuffer);
724    PreprocessorOpts.PrecompiledPreambleBytes.first = Preamble.size();
725    PreprocessorOpts.PrecompiledPreambleBytes.second
726                                                    = PreambleEndsAtStartOfLine;
727    PriorImplicitPCHInclude = PreprocessorOpts.ImplicitPCHInclude;
728    PreprocessorOpts.ImplicitPCHInclude = PreambleFile;
729    PreprocessorOpts.DisablePCHValidation = true;
730
731    // Keep track of the override buffer;
732    SavedMainFileBuffer = OverrideMainBuffer;
733
734    // The stored diagnostic has the old source manager in it; update
735    // the locations to refer into the new source manager. Since we've
736    // been careful to make sure that the source manager's state
737    // before and after are identical, so that we can reuse the source
738    // location itself.
739    for (unsigned I = 0, N = StoredDiagnostics.size(); I != N; ++I) {
740      FullSourceLoc Loc(StoredDiagnostics[I].getLocation(),
741                        getSourceManager());
742      StoredDiagnostics[I].setLocation(Loc);
743    }
744  } else {
745    PreprocessorOpts.PrecompiledPreambleBytes.first = 0;
746    PreprocessorOpts.PrecompiledPreambleBytes.second = false;
747  }
748
749  llvm::OwningPtr<TopLevelDeclTrackerAction> Act;
750  Act.reset(new TopLevelDeclTrackerAction(*this));
751  if (!Act->BeginSourceFile(Clang, Clang.getFrontendOpts().Inputs[0].second,
752                            Clang.getFrontendOpts().Inputs[0].first))
753    goto error;
754
755  Act->Execute();
756
757  // Steal the created target, context, and preprocessor, and take back the
758  // source and file managers.
759  TheSema.reset(Clang.takeSema());
760  Consumer.reset(Clang.takeASTConsumer());
761  Ctx.reset(Clang.takeASTContext());
762  PP.reset(Clang.takePreprocessor());
763  Clang.takeSourceManager();
764  Clang.takeFileManager();
765  Target.reset(Clang.takeTarget());
766
767  Act->EndSourceFile();
768
769  // Remove the overridden buffer we used for the preamble.
770  if (OverrideMainBuffer) {
771    PreprocessorOpts.eraseRemappedFile(
772                               PreprocessorOpts.remapped_file_buffer_end() - 1);
773    PreprocessorOpts.ImplicitPCHInclude = PriorImplicitPCHInclude;
774  }
775
776  Invocation.reset(Clang.takeInvocation());
777
778  // If we were asked to cache code-completion results and don't have any
779  // results yet, do so now.
780  if (ShouldCacheCodeCompletionResults && CachedCompletionResults.empty())
781    CacheCodeCompletionResults();
782
783  return false;
784
785error:
786  // Remove the overridden buffer we used for the preamble.
787  if (OverrideMainBuffer) {
788    PreprocessorOpts.eraseRemappedFile(
789                               PreprocessorOpts.remapped_file_buffer_end() - 1);
790    PreprocessorOpts.DisablePCHValidation = true;
791    PreprocessorOpts.ImplicitPCHInclude = PriorImplicitPCHInclude;
792    delete OverrideMainBuffer;
793  }
794
795  Clang.takeSourceManager();
796  Clang.takeFileManager();
797  Invocation.reset(Clang.takeInvocation());
798  return true;
799}
800
801/// \brief Simple function to retrieve a path for a preamble precompiled header.
802static std::string GetPreamblePCHPath() {
803  // FIXME: This is lame; sys::Path should provide this function (in particular,
804  // it should know how to find the temporary files dir).
805  // FIXME: This is really lame. I copied this code from the Driver!
806  std::string Error;
807  const char *TmpDir = ::getenv("TMPDIR");
808  if (!TmpDir)
809    TmpDir = ::getenv("TEMP");
810  if (!TmpDir)
811    TmpDir = ::getenv("TMP");
812  if (!TmpDir)
813    TmpDir = "/tmp";
814  llvm::sys::Path P(TmpDir);
815  P.appendComponent("preamble");
816  P.appendSuffix("pch");
817  if (P.createTemporaryFileOnDisk())
818    return std::string();
819
820  return P.str();
821}
822
823/// \brief Compute the preamble for the main file, providing the source buffer
824/// that corresponds to the main file along with a pair (bytes, start-of-line)
825/// that describes the preamble.
826std::pair<llvm::MemoryBuffer *, std::pair<unsigned, bool> >
827ASTUnit::ComputePreamble(CompilerInvocation &Invocation,
828                         unsigned MaxLines, bool &CreatedBuffer) {
829  FrontendOptions &FrontendOpts = Invocation.getFrontendOpts();
830  PreprocessorOptions &PreprocessorOpts
831    = Invocation.getPreprocessorOpts();
832  CreatedBuffer = false;
833
834  // Try to determine if the main file has been remapped, either from the
835  // command line (to another file) or directly through the compiler invocation
836  // (to a memory buffer).
837  llvm::MemoryBuffer *Buffer = 0;
838  llvm::sys::PathWithStatus MainFilePath(FrontendOpts.Inputs[0].second);
839  if (const llvm::sys::FileStatus *MainFileStatus = MainFilePath.getFileStatus()) {
840    // Check whether there is a file-file remapping of the main file
841    for (PreprocessorOptions::remapped_file_iterator
842          M = PreprocessorOpts.remapped_file_begin(),
843          E = PreprocessorOpts.remapped_file_end();
844         M != E;
845         ++M) {
846      llvm::sys::PathWithStatus MPath(M->first);
847      if (const llvm::sys::FileStatus *MStatus = MPath.getFileStatus()) {
848        if (MainFileStatus->uniqueID == MStatus->uniqueID) {
849          // We found a remapping. Try to load the resulting, remapped source.
850          if (CreatedBuffer) {
851            delete Buffer;
852            CreatedBuffer = false;
853          }
854
855          Buffer = llvm::MemoryBuffer::getFile(M->second);
856          if (!Buffer)
857            return std::make_pair((llvm::MemoryBuffer*)0,
858                                  std::make_pair(0, true));
859          CreatedBuffer = true;
860
861          // Remove this remapping. We've captured the buffer already.
862          M = PreprocessorOpts.eraseRemappedFile(M);
863          E = PreprocessorOpts.remapped_file_end();
864          if (M == E)
865            break;
866        }
867      }
868    }
869
870    // Check whether there is a file-buffer remapping. It supercedes the
871    // file-file remapping.
872    for (PreprocessorOptions::remapped_file_buffer_iterator
873           M = PreprocessorOpts.remapped_file_buffer_begin(),
874           E = PreprocessorOpts.remapped_file_buffer_end();
875         M != E;
876         ++M) {
877      llvm::sys::PathWithStatus MPath(M->first);
878      if (const llvm::sys::FileStatus *MStatus = MPath.getFileStatus()) {
879        if (MainFileStatus->uniqueID == MStatus->uniqueID) {
880          // We found a remapping.
881          if (CreatedBuffer) {
882            delete Buffer;
883            CreatedBuffer = false;
884          }
885
886          Buffer = const_cast<llvm::MemoryBuffer *>(M->second);
887
888          // Remove this remapping. We've captured the buffer already.
889          M = PreprocessorOpts.eraseRemappedFile(M);
890          E = PreprocessorOpts.remapped_file_buffer_end();
891          if (M == E)
892            break;
893        }
894      }
895    }
896  }
897
898  // If the main source file was not remapped, load it now.
899  if (!Buffer) {
900    Buffer = llvm::MemoryBuffer::getFile(FrontendOpts.Inputs[0].second);
901    if (!Buffer)
902      return std::make_pair((llvm::MemoryBuffer*)0, std::make_pair(0, true));
903
904    CreatedBuffer = true;
905  }
906
907  return std::make_pair(Buffer, Lexer::ComputePreamble(Buffer, MaxLines));
908}
909
910static llvm::MemoryBuffer *CreatePaddedMainFileBuffer(llvm::MemoryBuffer *Old,
911                                                      bool DeleteOld,
912                                                      unsigned NewSize,
913                                                      llvm::StringRef NewName) {
914  llvm::MemoryBuffer *Result
915    = llvm::MemoryBuffer::getNewUninitMemBuffer(NewSize, NewName);
916  memcpy(const_cast<char*>(Result->getBufferStart()),
917         Old->getBufferStart(), Old->getBufferSize());
918  memset(const_cast<char*>(Result->getBufferStart()) + Old->getBufferSize(),
919         ' ', NewSize - Old->getBufferSize() - 1);
920  const_cast<char*>(Result->getBufferEnd())[-1] = '\n';
921
922  if (DeleteOld)
923    delete Old;
924
925  return Result;
926}
927
928/// \brief Attempt to build or re-use a precompiled preamble when (re-)parsing
929/// the source file.
930///
931/// This routine will compute the preamble of the main source file. If a
932/// non-trivial preamble is found, it will precompile that preamble into a
933/// precompiled header so that the precompiled preamble can be used to reduce
934/// reparsing time. If a precompiled preamble has already been constructed,
935/// this routine will determine if it is still valid and, if so, avoid
936/// rebuilding the precompiled preamble.
937///
938/// \param AllowRebuild When true (the default), this routine is
939/// allowed to rebuild the precompiled preamble if it is found to be
940/// out-of-date.
941///
942/// \param MaxLines When non-zero, the maximum number of lines that
943/// can occur within the preamble.
944///
945/// \returns If the precompiled preamble can be used, returns a newly-allocated
946/// buffer that should be used in place of the main file when doing so.
947/// Otherwise, returns a NULL pointer.
948llvm::MemoryBuffer *ASTUnit::getMainBufferWithPrecompiledPreamble(
949                                          CompilerInvocation PreambleInvocation,
950                                                           bool AllowRebuild,
951                                                           unsigned MaxLines) {
952  FrontendOptions &FrontendOpts = PreambleInvocation.getFrontendOpts();
953  PreprocessorOptions &PreprocessorOpts
954    = PreambleInvocation.getPreprocessorOpts();
955
956  bool CreatedPreambleBuffer = false;
957  std::pair<llvm::MemoryBuffer *, std::pair<unsigned, bool> > NewPreamble
958    = ComputePreamble(PreambleInvocation, MaxLines, CreatedPreambleBuffer);
959
960  if (!NewPreamble.second.first) {
961    // We couldn't find a preamble in the main source. Clear out the current
962    // preamble, if we have one. It's obviously no good any more.
963    Preamble.clear();
964    if (!PreambleFile.empty()) {
965      llvm::sys::Path(PreambleFile).eraseFromDisk();
966      PreambleFile.clear();
967    }
968    if (CreatedPreambleBuffer)
969      delete NewPreamble.first;
970
971    // The next time we actually see a preamble, precompile it.
972    PreambleRebuildCounter = 1;
973    return 0;
974  }
975
976  if (!Preamble.empty()) {
977    // We've previously computed a preamble. Check whether we have the same
978    // preamble now that we did before, and that there's enough space in
979    // the main-file buffer within the precompiled preamble to fit the
980    // new main file.
981    if (Preamble.size() == NewPreamble.second.first &&
982        PreambleEndsAtStartOfLine == NewPreamble.second.second &&
983        NewPreamble.first->getBufferSize() < PreambleReservedSize-2 &&
984        memcmp(&Preamble[0], NewPreamble.first->getBufferStart(),
985               NewPreamble.second.first) == 0) {
986      // The preamble has not changed. We may be able to re-use the precompiled
987      // preamble.
988
989      // Check that none of the files used by the preamble have changed.
990      bool AnyFileChanged = false;
991
992      // First, make a record of those files that have been overridden via
993      // remapping or unsaved_files.
994      llvm::StringMap<std::pair<off_t, time_t> > OverriddenFiles;
995      for (PreprocessorOptions::remapped_file_iterator
996                R = PreprocessorOpts.remapped_file_begin(),
997             REnd = PreprocessorOpts.remapped_file_end();
998           !AnyFileChanged && R != REnd;
999           ++R) {
1000        struct stat StatBuf;
1001        if (stat(R->second.c_str(), &StatBuf)) {
1002          // If we can't stat the file we're remapping to, assume that something
1003          // horrible happened.
1004          AnyFileChanged = true;
1005          break;
1006        }
1007
1008        OverriddenFiles[R->first] = std::make_pair(StatBuf.st_size,
1009                                                   StatBuf.st_mtime);
1010      }
1011      for (PreprocessorOptions::remapped_file_buffer_iterator
1012                R = PreprocessorOpts.remapped_file_buffer_begin(),
1013             REnd = PreprocessorOpts.remapped_file_buffer_end();
1014           !AnyFileChanged && R != REnd;
1015           ++R) {
1016        // FIXME: Should we actually compare the contents of file->buffer
1017        // remappings?
1018        OverriddenFiles[R->first] = std::make_pair(R->second->getBufferSize(),
1019                                                   0);
1020      }
1021
1022      // Check whether anything has changed.
1023      for (llvm::StringMap<std::pair<off_t, time_t> >::iterator
1024             F = FilesInPreamble.begin(), FEnd = FilesInPreamble.end();
1025           !AnyFileChanged && F != FEnd;
1026           ++F) {
1027        llvm::StringMap<std::pair<off_t, time_t> >::iterator Overridden
1028          = OverriddenFiles.find(F->first());
1029        if (Overridden != OverriddenFiles.end()) {
1030          // This file was remapped; check whether the newly-mapped file
1031          // matches up with the previous mapping.
1032          if (Overridden->second != F->second)
1033            AnyFileChanged = true;
1034          continue;
1035        }
1036
1037        // The file was not remapped; check whether it has changed on disk.
1038        struct stat StatBuf;
1039        if (stat(F->first(), &StatBuf)) {
1040          // If we can't stat the file, assume that something horrible happened.
1041          AnyFileChanged = true;
1042        } else if (StatBuf.st_size != F->second.first ||
1043                   StatBuf.st_mtime != F->second.second)
1044          AnyFileChanged = true;
1045      }
1046
1047      if (!AnyFileChanged) {
1048        // Okay! We can re-use the precompiled preamble.
1049
1050        // Set the state of the diagnostic object to mimic its state
1051        // after parsing the preamble.
1052        getDiagnostics().Reset();
1053        getDiagnostics().setNumWarnings(NumWarningsInPreamble);
1054        if (StoredDiagnostics.size() > NumStoredDiagnosticsInPreamble)
1055          StoredDiagnostics.erase(
1056            StoredDiagnostics.begin() + NumStoredDiagnosticsInPreamble,
1057                                  StoredDiagnostics.end());
1058
1059        // Create a version of the main file buffer that is padded to
1060        // buffer size we reserved when creating the preamble.
1061        return CreatePaddedMainFileBuffer(NewPreamble.first,
1062                                          CreatedPreambleBuffer,
1063                                          PreambleReservedSize,
1064                                          FrontendOpts.Inputs[0].second);
1065      }
1066    }
1067
1068    // If we aren't allowed to rebuild the precompiled preamble, just
1069    // return now.
1070    if (!AllowRebuild)
1071      return 0;
1072
1073    // We can't reuse the previously-computed preamble. Build a new one.
1074    Preamble.clear();
1075    llvm::sys::Path(PreambleFile).eraseFromDisk();
1076    PreambleRebuildCounter = 1;
1077  } else if (!AllowRebuild) {
1078    // We aren't allowed to rebuild the precompiled preamble; just
1079    // return now.
1080    return 0;
1081  }
1082
1083  // If the preamble rebuild counter > 1, it's because we previously
1084  // failed to build a preamble and we're not yet ready to try
1085  // again. Decrement the counter and return a failure.
1086  if (PreambleRebuildCounter > 1) {
1087    --PreambleRebuildCounter;
1088    return 0;
1089  }
1090
1091  // We did not previously compute a preamble, or it can't be reused anyway.
1092  llvm::Timer *PreambleTimer = 0;
1093  if (TimerGroup.get()) {
1094    PreambleTimer = new llvm::Timer("Precompiling preamble", *TimerGroup);
1095    PreambleTimer->startTimer();
1096    Timers.push_back(PreambleTimer);
1097  }
1098
1099  // Create a new buffer that stores the preamble. The buffer also contains
1100  // extra space for the original contents of the file (which will be present
1101  // when we actually parse the file) along with more room in case the file
1102  // grows.
1103  PreambleReservedSize = NewPreamble.first->getBufferSize();
1104  if (PreambleReservedSize < 4096)
1105    PreambleReservedSize = 8191;
1106  else
1107    PreambleReservedSize *= 2;
1108
1109  // Save the preamble text for later; we'll need to compare against it for
1110  // subsequent reparses.
1111  Preamble.assign(NewPreamble.first->getBufferStart(),
1112                  NewPreamble.first->getBufferStart()
1113                                                  + NewPreamble.second.first);
1114  PreambleEndsAtStartOfLine = NewPreamble.second.second;
1115
1116  delete PreambleBuffer;
1117  PreambleBuffer
1118    = llvm::MemoryBuffer::getNewUninitMemBuffer(PreambleReservedSize,
1119                                                FrontendOpts.Inputs[0].second);
1120  memcpy(const_cast<char*>(PreambleBuffer->getBufferStart()),
1121         NewPreamble.first->getBufferStart(), Preamble.size());
1122  memset(const_cast<char*>(PreambleBuffer->getBufferStart()) + Preamble.size(),
1123         ' ', PreambleReservedSize - Preamble.size() - 1);
1124  const_cast<char*>(PreambleBuffer->getBufferEnd())[-1] = '\n';
1125
1126  // Remap the main source file to the preamble buffer.
1127  llvm::sys::PathWithStatus MainFilePath(FrontendOpts.Inputs[0].second);
1128  PreprocessorOpts.addRemappedFile(MainFilePath.str(), PreambleBuffer);
1129
1130  // Tell the compiler invocation to generate a temporary precompiled header.
1131  FrontendOpts.ProgramAction = frontend::GeneratePCH;
1132  // FIXME: Set ChainedPCH unconditionally, once it is ready.
1133  if (::getenv("LIBCLANG_CHAINING"))
1134    FrontendOpts.ChainedPCH = true;
1135  // FIXME: Generate the precompiled header into memory?
1136  FrontendOpts.OutputFile = GetPreamblePCHPath();
1137
1138  // Create the compiler instance to use for building the precompiled preamble.
1139  CompilerInstance Clang;
1140  Clang.setInvocation(&PreambleInvocation);
1141  OriginalSourceFile = Clang.getFrontendOpts().Inputs[0].second;
1142
1143  // Set up diagnostics, capturing all of the diagnostics produced.
1144  Clang.setDiagnostics(&getDiagnostics());
1145  CaptureDroppedDiagnostics Capture(CaptureDiagnostics,
1146                                    getDiagnostics(),
1147                                    StoredDiagnostics);
1148
1149  // Create the target instance.
1150  Clang.setTarget(TargetInfo::CreateTargetInfo(Clang.getDiagnostics(),
1151                                               Clang.getTargetOpts()));
1152  if (!Clang.hasTarget()) {
1153    llvm::sys::Path(FrontendOpts.OutputFile).eraseFromDisk();
1154    Preamble.clear();
1155    if (CreatedPreambleBuffer)
1156      delete NewPreamble.first;
1157    if (PreambleTimer)
1158      PreambleTimer->stopTimer();
1159    PreambleRebuildCounter = DefaultPreambleRebuildInterval;
1160    PreprocessorOpts.eraseRemappedFile(
1161                               PreprocessorOpts.remapped_file_buffer_end() - 1);
1162    return 0;
1163  }
1164
1165  // Inform the target of the language options.
1166  //
1167  // FIXME: We shouldn't need to do this, the target should be immutable once
1168  // created. This complexity should be lifted elsewhere.
1169  Clang.getTarget().setForcedLangOptions(Clang.getLangOpts());
1170
1171  assert(Clang.getFrontendOpts().Inputs.size() == 1 &&
1172         "Invocation must have exactly one source file!");
1173  assert(Clang.getFrontendOpts().Inputs[0].first != IK_AST &&
1174         "FIXME: AST inputs not yet supported here!");
1175  assert(Clang.getFrontendOpts().Inputs[0].first != IK_LLVM_IR &&
1176         "IR inputs not support here!");
1177
1178  // Clear out old caches and data.
1179  StoredDiagnostics.clear();
1180  TopLevelDecls.clear();
1181  TopLevelDeclsInPreamble.clear();
1182
1183  // Create a file manager object to provide access to and cache the filesystem.
1184  Clang.setFileManager(new FileManager);
1185
1186  // Create the source manager.
1187  Clang.setSourceManager(new SourceManager(getDiagnostics()));
1188
1189  llvm::OwningPtr<PrecompilePreambleAction> Act;
1190  Act.reset(new PrecompilePreambleAction(*this));
1191  if (!Act->BeginSourceFile(Clang, Clang.getFrontendOpts().Inputs[0].second,
1192                            Clang.getFrontendOpts().Inputs[0].first)) {
1193    Clang.takeInvocation();
1194    llvm::sys::Path(FrontendOpts.OutputFile).eraseFromDisk();
1195    Preamble.clear();
1196    if (CreatedPreambleBuffer)
1197      delete NewPreamble.first;
1198    if (PreambleTimer)
1199      PreambleTimer->stopTimer();
1200    PreambleRebuildCounter = DefaultPreambleRebuildInterval;
1201    PreprocessorOpts.eraseRemappedFile(
1202                               PreprocessorOpts.remapped_file_buffer_end() - 1);
1203    return 0;
1204  }
1205
1206  Act->Execute();
1207  Act->EndSourceFile();
1208  Clang.takeInvocation();
1209
1210  if (Diagnostics->hasErrorOccurred()) {
1211    // There were errors parsing the preamble, so no precompiled header was
1212    // generated. Forget that we even tried.
1213    // FIXME: Should we leave a note for ourselves to try again?
1214    llvm::sys::Path(FrontendOpts.OutputFile).eraseFromDisk();
1215    Preamble.clear();
1216    if (CreatedPreambleBuffer)
1217      delete NewPreamble.first;
1218    if (PreambleTimer)
1219      PreambleTimer->stopTimer();
1220    TopLevelDeclsInPreamble.clear();
1221    PreambleRebuildCounter = DefaultPreambleRebuildInterval;
1222    PreprocessorOpts.eraseRemappedFile(
1223                               PreprocessorOpts.remapped_file_buffer_end() - 1);
1224    return 0;
1225  }
1226
1227  // Keep track of the preamble we precompiled.
1228  PreambleFile = FrontendOpts.OutputFile;
1229  NumStoredDiagnosticsInPreamble = StoredDiagnostics.size();
1230  NumWarningsInPreamble = getDiagnostics().getNumWarnings();
1231
1232  // Keep track of all of the files that the source manager knows about,
1233  // so we can verify whether they have changed or not.
1234  FilesInPreamble.clear();
1235  SourceManager &SourceMgr = Clang.getSourceManager();
1236  const llvm::MemoryBuffer *MainFileBuffer
1237    = SourceMgr.getBuffer(SourceMgr.getMainFileID());
1238  for (SourceManager::fileinfo_iterator F = SourceMgr.fileinfo_begin(),
1239                                     FEnd = SourceMgr.fileinfo_end();
1240       F != FEnd;
1241       ++F) {
1242    const FileEntry *File = F->second->Entry;
1243    if (!File || F->second->getRawBuffer() == MainFileBuffer)
1244      continue;
1245
1246    FilesInPreamble[File->getName()]
1247      = std::make_pair(F->second->getSize(), File->getModificationTime());
1248  }
1249
1250  if (PreambleTimer)
1251    PreambleTimer->stopTimer();
1252
1253  PreambleRebuildCounter = 1;
1254  PreprocessorOpts.eraseRemappedFile(
1255                               PreprocessorOpts.remapped_file_buffer_end() - 1);
1256  return CreatePaddedMainFileBuffer(NewPreamble.first,
1257                                    CreatedPreambleBuffer,
1258                                    PreambleReservedSize,
1259                                    FrontendOpts.Inputs[0].second);
1260}
1261
1262void ASTUnit::RealizeTopLevelDeclsFromPreamble() {
1263  std::vector<Decl *> Resolved;
1264  Resolved.reserve(TopLevelDeclsInPreamble.size());
1265  ExternalASTSource &Source = *getASTContext().getExternalSource();
1266  for (unsigned I = 0, N = TopLevelDeclsInPreamble.size(); I != N; ++I) {
1267    // Resolve the declaration ID to an actual declaration, possibly
1268    // deserializing the declaration in the process.
1269    Decl *D = Source.GetExternalDecl(TopLevelDeclsInPreamble[I]);
1270    if (D)
1271      Resolved.push_back(D);
1272  }
1273  TopLevelDeclsInPreamble.clear();
1274  TopLevelDecls.insert(TopLevelDecls.begin(), Resolved.begin(), Resolved.end());
1275}
1276
1277unsigned ASTUnit::getMaxPCHLevel() const {
1278  if (!getOnlyLocalDecls())
1279    return Decl::MaxPCHLevel;
1280
1281  unsigned Result = 0;
1282  if (isMainFileAST() || SavedMainFileBuffer)
1283    ++Result;
1284  return Result;
1285}
1286
1287ASTUnit *ASTUnit::LoadFromCompilerInvocation(CompilerInvocation *CI,
1288                                   llvm::IntrusiveRefCntPtr<Diagnostic> Diags,
1289                                             bool OnlyLocalDecls,
1290                                             bool CaptureDiagnostics,
1291                                             bool PrecompilePreamble,
1292                                             bool CompleteTranslationUnit,
1293                                             bool CacheCodeCompletionResults) {
1294  if (!Diags.getPtr()) {
1295    // No diagnostics engine was provided, so create our own diagnostics object
1296    // with the default options.
1297    DiagnosticOptions DiagOpts;
1298    Diags = CompilerInstance::createDiagnostics(DiagOpts, 0, 0);
1299  }
1300
1301  // Create the AST unit.
1302  llvm::OwningPtr<ASTUnit> AST;
1303  AST.reset(new ASTUnit(false));
1304  AST->Diagnostics = Diags;
1305  AST->CaptureDiagnostics = CaptureDiagnostics;
1306  AST->OnlyLocalDecls = OnlyLocalDecls;
1307  AST->CompleteTranslationUnit = CompleteTranslationUnit;
1308  AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults;
1309  AST->Invocation.reset(CI);
1310  CI->getPreprocessorOpts().RetainRemappedFileBuffers = true;
1311
1312  if (getenv("LIBCLANG_TIMING"))
1313    AST->TimerGroup.reset(
1314                  new llvm::TimerGroup(CI->getFrontendOpts().Inputs[0].second));
1315
1316
1317  llvm::MemoryBuffer *OverrideMainBuffer = 0;
1318  // FIXME: When C++ PCH is ready, allow use of it for a precompiled preamble.
1319  if (PrecompilePreamble && !CI->getLangOpts().CPlusPlus) {
1320    AST->PreambleRebuildCounter = 1;
1321    OverrideMainBuffer
1322      = AST->getMainBufferWithPrecompiledPreamble(*AST->Invocation);
1323  }
1324
1325  llvm::Timer *ParsingTimer = 0;
1326  if (AST->TimerGroup.get()) {
1327    ParsingTimer = new llvm::Timer("Initial parse", *AST->TimerGroup);
1328    ParsingTimer->startTimer();
1329    AST->Timers.push_back(ParsingTimer);
1330  }
1331
1332  bool Failed = AST->Parse(OverrideMainBuffer);
1333  if (ParsingTimer)
1334    ParsingTimer->stopTimer();
1335
1336  return Failed? 0 : AST.take();
1337}
1338
1339ASTUnit *ASTUnit::LoadFromCommandLine(const char **ArgBegin,
1340                                      const char **ArgEnd,
1341                                    llvm::IntrusiveRefCntPtr<Diagnostic> Diags,
1342                                      llvm::StringRef ResourceFilesPath,
1343                                      bool OnlyLocalDecls,
1344                                      RemappedFile *RemappedFiles,
1345                                      unsigned NumRemappedFiles,
1346                                      bool CaptureDiagnostics,
1347                                      bool PrecompilePreamble,
1348                                      bool CompleteTranslationUnit,
1349                                      bool CacheCodeCompletionResults) {
1350  bool CreatedDiagnosticsObject = false;
1351
1352  if (!Diags.getPtr()) {
1353    // No diagnostics engine was provided, so create our own diagnostics object
1354    // with the default options.
1355    DiagnosticOptions DiagOpts;
1356    Diags = CompilerInstance::createDiagnostics(DiagOpts, 0, 0);
1357    CreatedDiagnosticsObject = true;
1358  }
1359
1360  llvm::SmallVector<const char *, 16> Args;
1361  Args.push_back("<clang>"); // FIXME: Remove dummy argument.
1362  Args.insert(Args.end(), ArgBegin, ArgEnd);
1363
1364  // FIXME: Find a cleaner way to force the driver into restricted modes. We
1365  // also want to force it to use clang.
1366  Args.push_back("-fsyntax-only");
1367
1368  // FIXME: We shouldn't have to pass in the path info.
1369  driver::Driver TheDriver("clang", llvm::sys::getHostTriple(),
1370                           "a.out", false, false, *Diags);
1371
1372  // Don't check that inputs exist, they have been remapped.
1373  TheDriver.setCheckInputsExist(false);
1374
1375  llvm::OwningPtr<driver::Compilation> C(
1376    TheDriver.BuildCompilation(Args.size(), Args.data()));
1377
1378  // We expect to get back exactly one command job, if we didn't something
1379  // failed.
1380  const driver::JobList &Jobs = C->getJobs();
1381  if (Jobs.size() != 1 || !isa<driver::Command>(Jobs.begin())) {
1382    llvm::SmallString<256> Msg;
1383    llvm::raw_svector_ostream OS(Msg);
1384    C->PrintJob(OS, C->getJobs(), "; ", true);
1385    Diags->Report(diag::err_fe_expected_compiler_job) << OS.str();
1386    return 0;
1387  }
1388
1389  const driver::Command *Cmd = cast<driver::Command>(*Jobs.begin());
1390  if (llvm::StringRef(Cmd->getCreator().getName()) != "clang") {
1391    Diags->Report(diag::err_fe_expected_clang_command);
1392    return 0;
1393  }
1394
1395  const driver::ArgStringList &CCArgs = Cmd->getArguments();
1396  llvm::OwningPtr<CompilerInvocation> CI(new CompilerInvocation);
1397  CompilerInvocation::CreateFromArgs(*CI,
1398                                     const_cast<const char **>(CCArgs.data()),
1399                                     const_cast<const char **>(CCArgs.data()) +
1400                                     CCArgs.size(),
1401                                     *Diags);
1402
1403  // Override any files that need remapping
1404  for (unsigned I = 0; I != NumRemappedFiles; ++I)
1405    CI->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first,
1406                                              RemappedFiles[I].second);
1407
1408  // Override the resources path.
1409  CI->getHeaderSearchOpts().ResourceDir = ResourceFilesPath;
1410
1411  CI->getFrontendOpts().DisableFree = false;
1412  return LoadFromCompilerInvocation(CI.take(), Diags, OnlyLocalDecls,
1413                                    CaptureDiagnostics, PrecompilePreamble,
1414                                    CompleteTranslationUnit,
1415                                    CacheCodeCompletionResults);
1416}
1417
1418bool ASTUnit::Reparse(RemappedFile *RemappedFiles, unsigned NumRemappedFiles) {
1419  if (!Invocation.get())
1420    return true;
1421
1422  llvm::Timer *ReparsingTimer = 0;
1423  if (TimerGroup.get()) {
1424    ReparsingTimer = new llvm::Timer("Reparse", *TimerGroup);
1425    ReparsingTimer->startTimer();
1426    Timers.push_back(ReparsingTimer);
1427  }
1428
1429  // Remap files.
1430  PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
1431  for (PreprocessorOptions::remapped_file_buffer_iterator
1432         R = PPOpts.remapped_file_buffer_begin(),
1433         REnd = PPOpts.remapped_file_buffer_end();
1434       R != REnd;
1435       ++R) {
1436    delete R->second;
1437  }
1438  Invocation->getPreprocessorOpts().clearRemappedFiles();
1439  for (unsigned I = 0; I != NumRemappedFiles; ++I)
1440    Invocation->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first,
1441                                                      RemappedFiles[I].second);
1442
1443  // If we have a preamble file lying around, or if we might try to
1444  // build a precompiled preamble, do so now.
1445  llvm::MemoryBuffer *OverrideMainBuffer = 0;
1446  if (!PreambleFile.empty() || PreambleRebuildCounter > 0)
1447    OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(*Invocation);
1448
1449  // Clear out the diagnostics state.
1450  if (!OverrideMainBuffer)
1451    getDiagnostics().Reset();
1452
1453  // Parse the sources
1454  bool Result = Parse(OverrideMainBuffer);
1455  if (ReparsingTimer)
1456    ReparsingTimer->stopTimer();
1457
1458  if (ShouldCacheCodeCompletionResults) {
1459    if (CacheCodeCompletionCoolDown > 0)
1460      --CacheCodeCompletionCoolDown;
1461    else if (top_level_size() != NumTopLevelDeclsAtLastCompletionCache)
1462      CacheCodeCompletionResults();
1463  }
1464
1465  return Result;
1466}
1467
1468//----------------------------------------------------------------------------//
1469// Code completion
1470//----------------------------------------------------------------------------//
1471
1472namespace {
1473  /// \brief Code completion consumer that combines the cached code-completion
1474  /// results from an ASTUnit with the code-completion results provided to it,
1475  /// then passes the result on to
1476  class AugmentedCodeCompleteConsumer : public CodeCompleteConsumer {
1477    unsigned NormalContexts;
1478    ASTUnit &AST;
1479    CodeCompleteConsumer &Next;
1480
1481  public:
1482    AugmentedCodeCompleteConsumer(ASTUnit &AST, CodeCompleteConsumer &Next,
1483                                  bool IncludeMacros, bool IncludeCodePatterns,
1484                                  bool IncludeGlobals)
1485      : CodeCompleteConsumer(IncludeMacros, IncludeCodePatterns, IncludeGlobals,
1486                             Next.isOutputBinary()), AST(AST), Next(Next)
1487    {
1488      // Compute the set of contexts in which we will look when we don't have
1489      // any information about the specific context.
1490      NormalContexts
1491        = (1 << (CodeCompletionContext::CCC_TopLevel - 1))
1492        | (1 << (CodeCompletionContext::CCC_ObjCInterface - 1))
1493        | (1 << (CodeCompletionContext::CCC_ObjCImplementation - 1))
1494        | (1 << (CodeCompletionContext::CCC_ObjCIvarList - 1))
1495        | (1 << (CodeCompletionContext::CCC_Statement - 1))
1496        | (1 << (CodeCompletionContext::CCC_Expression - 1))
1497        | (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1))
1498        | (1 << (CodeCompletionContext::CCC_MemberAccess - 1))
1499        | (1 << (CodeCompletionContext::CCC_ObjCProtocolName - 1));
1500
1501      if (AST.getASTContext().getLangOptions().CPlusPlus)
1502        NormalContexts |= (1 << (CodeCompletionContext::CCC_EnumTag - 1))
1503                    | (1 << (CodeCompletionContext::CCC_UnionTag - 1))
1504                    | (1 << (CodeCompletionContext::CCC_ClassOrStructTag - 1));
1505    }
1506
1507    virtual void ProcessCodeCompleteResults(Sema &S,
1508                                            CodeCompletionContext Context,
1509                                            CodeCompletionResult *Results,
1510                                            unsigned NumResults);
1511
1512    virtual void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg,
1513                                           OverloadCandidate *Candidates,
1514                                           unsigned NumCandidates) {
1515      Next.ProcessOverloadCandidates(S, CurrentArg, Candidates, NumCandidates);
1516    }
1517  };
1518}
1519
1520/// \brief Helper function that computes which global names are hidden by the
1521/// local code-completion results.
1522void CalculateHiddenNames(const CodeCompletionContext &Context,
1523                          CodeCompletionResult *Results,
1524                          unsigned NumResults,
1525                          ASTContext &Ctx,
1526                          llvm::StringSet<> &HiddenNames) {
1527  bool OnlyTagNames = false;
1528  switch (Context.getKind()) {
1529  case CodeCompletionContext::CCC_Other:
1530  case CodeCompletionContext::CCC_TopLevel:
1531  case CodeCompletionContext::CCC_ObjCInterface:
1532  case CodeCompletionContext::CCC_ObjCImplementation:
1533  case CodeCompletionContext::CCC_ObjCIvarList:
1534  case CodeCompletionContext::CCC_ClassStructUnion:
1535  case CodeCompletionContext::CCC_Statement:
1536  case CodeCompletionContext::CCC_Expression:
1537  case CodeCompletionContext::CCC_ObjCMessageReceiver:
1538  case CodeCompletionContext::CCC_MemberAccess:
1539  case CodeCompletionContext::CCC_Namespace:
1540  case CodeCompletionContext::CCC_Type:
1541  case CodeCompletionContext::CCC_Name:
1542  case CodeCompletionContext::CCC_PotentiallyQualifiedName:
1543    break;
1544
1545  case CodeCompletionContext::CCC_EnumTag:
1546  case CodeCompletionContext::CCC_UnionTag:
1547  case CodeCompletionContext::CCC_ClassOrStructTag:
1548    OnlyTagNames = true;
1549    break;
1550
1551  case CodeCompletionContext::CCC_ObjCProtocolName:
1552  case CodeCompletionContext::CCC_MacroName:
1553  case CodeCompletionContext::CCC_MacroNameUse:
1554  case CodeCompletionContext::CCC_PreprocessorExpression:
1555    // If we're just looking for protocol or macro names, nothing can hide them.
1556    return;
1557  }
1558
1559  typedef CodeCompletionResult Result;
1560  for (unsigned I = 0; I != NumResults; ++I) {
1561    if (Results[I].Kind != Result::RK_Declaration)
1562      continue;
1563
1564    unsigned IDNS
1565      = Results[I].Declaration->getUnderlyingDecl()->getIdentifierNamespace();
1566
1567    bool Hiding = false;
1568    if (OnlyTagNames)
1569      Hiding = (IDNS & Decl::IDNS_Tag);
1570    else {
1571      unsigned HiddenIDNS = (Decl::IDNS_Type | Decl::IDNS_Member |
1572                             Decl::IDNS_Namespace | Decl::IDNS_Ordinary |
1573                             Decl::IDNS_NonMemberOperator);
1574      if (Ctx.getLangOptions().CPlusPlus)
1575        HiddenIDNS |= Decl::IDNS_Tag;
1576      Hiding = (IDNS & HiddenIDNS);
1577    }
1578
1579    if (!Hiding)
1580      continue;
1581
1582    DeclarationName Name = Results[I].Declaration->getDeclName();
1583    if (IdentifierInfo *Identifier = Name.getAsIdentifierInfo())
1584      HiddenNames.insert(Identifier->getName());
1585    else
1586      HiddenNames.insert(Name.getAsString());
1587  }
1588}
1589
1590
1591void AugmentedCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &S,
1592                                            CodeCompletionContext Context,
1593                                            CodeCompletionResult *Results,
1594                                            unsigned NumResults) {
1595  // Merge the results we were given with the results we cached.
1596  bool AddedResult = false;
1597  unsigned InContexts
1598    = (Context.getKind() == CodeCompletionContext::CCC_Other? NormalContexts
1599                                            : (1 << (Context.getKind() - 1)));
1600
1601  // Contains the set of names that are hidden by "local" completion results.
1602  llvm::StringSet<> HiddenNames;
1603  llvm::SmallVector<CodeCompletionString *, 4> StringsToDestroy;
1604  typedef CodeCompletionResult Result;
1605  llvm::SmallVector<Result, 8> AllResults;
1606  for (ASTUnit::cached_completion_iterator
1607            C = AST.cached_completion_begin(),
1608         CEnd = AST.cached_completion_end();
1609       C != CEnd; ++C) {
1610    // If the context we are in matches any of the contexts we are
1611    // interested in, we'll add this result.
1612    if ((C->ShowInContexts & InContexts) == 0)
1613      continue;
1614
1615    // If we haven't added any results previously, do so now.
1616    if (!AddedResult) {
1617      CalculateHiddenNames(Context, Results, NumResults, S.Context,
1618                           HiddenNames);
1619      AllResults.insert(AllResults.end(), Results, Results + NumResults);
1620      AddedResult = true;
1621    }
1622
1623    // Determine whether this global completion result is hidden by a local
1624    // completion result. If so, skip it.
1625    if (C->Kind != CXCursor_MacroDefinition &&
1626        HiddenNames.count(C->Completion->getTypedText()))
1627      continue;
1628
1629    // Adjust priority based on similar type classes.
1630    unsigned Priority = C->Priority;
1631    CXCursorKind CursorKind = C->Kind;
1632    CodeCompletionString *Completion = C->Completion;
1633    if (!Context.getPreferredType().isNull()) {
1634      if (C->Kind == CXCursor_MacroDefinition) {
1635        Priority = getMacroUsagePriority(C->Completion->getTypedText(),
1636                               Context.getPreferredType()->isAnyPointerType());
1637      } else if (C->Type) {
1638        CanQualType Expected
1639          = S.Context.getCanonicalType(
1640                               Context.getPreferredType().getUnqualifiedType());
1641        SimplifiedTypeClass ExpectedSTC = getSimplifiedTypeClass(Expected);
1642        if (ExpectedSTC == C->TypeClass) {
1643          // We know this type is similar; check for an exact match.
1644          llvm::StringMap<unsigned> &CachedCompletionTypes
1645            = AST.getCachedCompletionTypes();
1646          llvm::StringMap<unsigned>::iterator Pos
1647            = CachedCompletionTypes.find(QualType(Expected).getAsString());
1648          if (Pos != CachedCompletionTypes.end() && Pos->second == C->Type)
1649            Priority /= CCF_ExactTypeMatch;
1650          else
1651            Priority /= CCF_SimilarTypeMatch;
1652        }
1653      }
1654    }
1655
1656    // Adjust the completion string, if required.
1657    if (C->Kind == CXCursor_MacroDefinition &&
1658        Context.getKind() == CodeCompletionContext::CCC_MacroNameUse) {
1659      // Create a new code-completion string that just contains the
1660      // macro name, without its arguments.
1661      Completion = new CodeCompletionString;
1662      Completion->AddTypedTextChunk(C->Completion->getTypedText());
1663      StringsToDestroy.push_back(Completion);
1664      CursorKind = CXCursor_NotImplemented;
1665      Priority = CCP_CodePattern;
1666    }
1667
1668    AllResults.push_back(Result(Completion, Priority, CursorKind,
1669                                C->Availability));
1670  }
1671
1672  // If we did not add any cached completion results, just forward the
1673  // results we were given to the next consumer.
1674  if (!AddedResult) {
1675    Next.ProcessCodeCompleteResults(S, Context, Results, NumResults);
1676    return;
1677  }
1678
1679  Next.ProcessCodeCompleteResults(S, Context, AllResults.data(),
1680                                  AllResults.size());
1681
1682  for (unsigned I = 0, N = StringsToDestroy.size(); I != N; ++I)
1683    delete StringsToDestroy[I];
1684}
1685
1686
1687
1688void ASTUnit::CodeComplete(llvm::StringRef File, unsigned Line, unsigned Column,
1689                           RemappedFile *RemappedFiles,
1690                           unsigned NumRemappedFiles,
1691                           bool IncludeMacros,
1692                           bool IncludeCodePatterns,
1693                           CodeCompleteConsumer &Consumer,
1694                           Diagnostic &Diag, LangOptions &LangOpts,
1695                           SourceManager &SourceMgr, FileManager &FileMgr,
1696                   llvm::SmallVectorImpl<StoredDiagnostic> &StoredDiagnostics,
1697             llvm::SmallVectorImpl<const llvm::MemoryBuffer *> &OwnedBuffers) {
1698  if (!Invocation.get())
1699    return;
1700
1701  llvm::Timer *CompletionTimer = 0;
1702  if (TimerGroup.get()) {
1703    llvm::SmallString<128> TimerName;
1704    llvm::raw_svector_ostream TimerNameOut(TimerName);
1705    TimerNameOut << "Code completion @ " << File << ":" << Line << ":"
1706                 << Column;
1707    CompletionTimer = new llvm::Timer(TimerNameOut.str(), *TimerGroup);
1708    CompletionTimer->startTimer();
1709    Timers.push_back(CompletionTimer);
1710  }
1711
1712  CompilerInvocation CCInvocation(*Invocation);
1713  FrontendOptions &FrontendOpts = CCInvocation.getFrontendOpts();
1714  PreprocessorOptions &PreprocessorOpts = CCInvocation.getPreprocessorOpts();
1715
1716  FrontendOpts.ShowMacrosInCodeCompletion
1717    = IncludeMacros && CachedCompletionResults.empty();
1718  FrontendOpts.ShowCodePatternsInCodeCompletion = IncludeCodePatterns;
1719  FrontendOpts.ShowGlobalSymbolsInCodeCompletion
1720    = CachedCompletionResults.empty();
1721  FrontendOpts.CodeCompletionAt.FileName = File;
1722  FrontendOpts.CodeCompletionAt.Line = Line;
1723  FrontendOpts.CodeCompletionAt.Column = Column;
1724
1725  // Turn on spell-checking when performing code completion. It leads
1726  // to better results.
1727  unsigned SpellChecking = CCInvocation.getLangOpts().SpellChecking;
1728  CCInvocation.getLangOpts().SpellChecking = 1;
1729
1730  // Set the language options appropriately.
1731  LangOpts = CCInvocation.getLangOpts();
1732
1733  CompilerInstance Clang;
1734  Clang.setInvocation(&CCInvocation);
1735  OriginalSourceFile = Clang.getFrontendOpts().Inputs[0].second;
1736
1737  // Set up diagnostics, capturing any diagnostics produced.
1738  Clang.setDiagnostics(&Diag);
1739  CaptureDroppedDiagnostics Capture(true,
1740                                    Clang.getDiagnostics(),
1741                                    StoredDiagnostics);
1742
1743  // Create the target instance.
1744  Clang.setTarget(TargetInfo::CreateTargetInfo(Clang.getDiagnostics(),
1745                                               Clang.getTargetOpts()));
1746  if (!Clang.hasTarget()) {
1747    Clang.takeInvocation();
1748    CCInvocation.getLangOpts().SpellChecking = SpellChecking;
1749    return;
1750  }
1751
1752  // Inform the target of the language options.
1753  //
1754  // FIXME: We shouldn't need to do this, the target should be immutable once
1755  // created. This complexity should be lifted elsewhere.
1756  Clang.getTarget().setForcedLangOptions(Clang.getLangOpts());
1757
1758  assert(Clang.getFrontendOpts().Inputs.size() == 1 &&
1759         "Invocation must have exactly one source file!");
1760  assert(Clang.getFrontendOpts().Inputs[0].first != IK_AST &&
1761         "FIXME: AST inputs not yet supported here!");
1762  assert(Clang.getFrontendOpts().Inputs[0].first != IK_LLVM_IR &&
1763         "IR inputs not support here!");
1764
1765
1766  // Use the source and file managers that we were given.
1767  Clang.setFileManager(&FileMgr);
1768  Clang.setSourceManager(&SourceMgr);
1769
1770  // Remap files.
1771  PreprocessorOpts.clearRemappedFiles();
1772  PreprocessorOpts.RetainRemappedFileBuffers = true;
1773  for (unsigned I = 0; I != NumRemappedFiles; ++I) {
1774    PreprocessorOpts.addRemappedFile(RemappedFiles[I].first,
1775                                     RemappedFiles[I].second);
1776    OwnedBuffers.push_back(RemappedFiles[I].second);
1777  }
1778
1779  // Use the code completion consumer we were given, but adding any cached
1780  // code-completion results.
1781  AugmentedCodeCompleteConsumer
1782  AugmentedConsumer(*this, Consumer, FrontendOpts.ShowMacrosInCodeCompletion,
1783                    FrontendOpts.ShowCodePatternsInCodeCompletion,
1784                    FrontendOpts.ShowGlobalSymbolsInCodeCompletion);
1785  Clang.setCodeCompletionConsumer(&AugmentedConsumer);
1786
1787  // If we have a precompiled preamble, try to use it. We only allow
1788  // the use of the precompiled preamble if we're if the completion
1789  // point is within the main file, after the end of the precompiled
1790  // preamble.
1791  llvm::MemoryBuffer *OverrideMainBuffer = 0;
1792  if (!PreambleFile.empty()) {
1793    using llvm::sys::FileStatus;
1794    llvm::sys::PathWithStatus CompleteFilePath(File);
1795    llvm::sys::PathWithStatus MainPath(OriginalSourceFile);
1796    if (const FileStatus *CompleteFileStatus = CompleteFilePath.getFileStatus())
1797      if (const FileStatus *MainStatus = MainPath.getFileStatus())
1798        if (CompleteFileStatus->getUniqueID() == MainStatus->getUniqueID())
1799          OverrideMainBuffer
1800            = getMainBufferWithPrecompiledPreamble(CCInvocation, false, Line);
1801  }
1802
1803  // If the main file has been overridden due to the use of a preamble,
1804  // make that override happen and introduce the preamble.
1805  if (OverrideMainBuffer) {
1806    PreprocessorOpts.addRemappedFile(OriginalSourceFile, OverrideMainBuffer);
1807    PreprocessorOpts.PrecompiledPreambleBytes.first = Preamble.size();
1808    PreprocessorOpts.PrecompiledPreambleBytes.second
1809                                                    = PreambleEndsAtStartOfLine;
1810    PreprocessorOpts.ImplicitPCHInclude = PreambleFile;
1811    PreprocessorOpts.DisablePCHValidation = true;
1812
1813    // The stored diagnostics have the old source manager. Copy them
1814    // to our output set of stored diagnostics, updating the source
1815    // manager to the one we were given.
1816    for (unsigned I = 0, N = this->StoredDiagnostics.size(); I != N; ++I) {
1817      StoredDiagnostics.push_back(this->StoredDiagnostics[I]);
1818      FullSourceLoc Loc(StoredDiagnostics[I].getLocation(), SourceMgr);
1819      StoredDiagnostics[I].setLocation(Loc);
1820    }
1821
1822    OwnedBuffers.push_back(OverrideMainBuffer);
1823  } else {
1824    PreprocessorOpts.PrecompiledPreambleBytes.first = 0;
1825    PreprocessorOpts.PrecompiledPreambleBytes.second = false;
1826  }
1827
1828  llvm::OwningPtr<SyntaxOnlyAction> Act;
1829  Act.reset(new SyntaxOnlyAction);
1830  if (Act->BeginSourceFile(Clang, Clang.getFrontendOpts().Inputs[0].second,
1831                           Clang.getFrontendOpts().Inputs[0].first)) {
1832    Act->Execute();
1833    Act->EndSourceFile();
1834  }
1835
1836  if (CompletionTimer)
1837    CompletionTimer->stopTimer();
1838
1839  // Steal back our resources.
1840  Clang.takeFileManager();
1841  Clang.takeSourceManager();
1842  Clang.takeInvocation();
1843  Clang.takeCodeCompletionConsumer();
1844  CCInvocation.getLangOpts().SpellChecking = SpellChecking;
1845}
1846
1847bool ASTUnit::Save(llvm::StringRef File) {
1848  if (getDiagnostics().hasErrorOccurred())
1849    return true;
1850
1851  // FIXME: Can we somehow regenerate the stat cache here, or do we need to
1852  // unconditionally create a stat cache when we parse the file?
1853  std::string ErrorInfo;
1854  llvm::raw_fd_ostream Out(File.str().c_str(), ErrorInfo,
1855                           llvm::raw_fd_ostream::F_Binary);
1856  if (!ErrorInfo.empty() || Out.has_error())
1857    return true;
1858
1859  std::vector<unsigned char> Buffer;
1860  llvm::BitstreamWriter Stream(Buffer);
1861  ASTWriter Writer(Stream);
1862  Writer.WriteAST(getSema(), 0, 0);
1863
1864  // Write the generated bitstream to "Out".
1865  if (!Buffer.empty())
1866    Out.write((char *)&Buffer.front(), Buffer.size());
1867  Out.close();
1868  return Out.has_error();
1869}
1870