[Frontend] Share global completions cache

[yvvan]

Summary

Append ASTUnit cache with global completions cache. In case of multiple translation units for the same file reduces the memory consumption and save completions cache generation time.

include/clang/Frontend/ASTUnit.h

public:
     /// Cache pairs "filename - source location"
     ///
     /// Cache contains only source locations from preamble so it is
     /// guaranteed that they stay valid when the SourceManager is recreated.
     /// This cache is used when loading preamble to increase performance
     /// of that loading. It must be cleared when preamble is recreated.
     llvm::StringMap<SourceLocation> PreambleSrcLocCache;
 
+    /// The set of cached code-completion results.
+    std::vector<CachedCodeCompletionResult> CachedCompletionResults;
+
     /// Counter that determines when we want to try building a
     /// precompiled preamble.
     ///
     /// If zero, we will never build a precompiled preamble. Otherwise,
     /// it's treated as a counter that decrements each time we reparse
     /// without the benefit of a precompiled preamble. When it hits 1,
     /// we'll attempt to rebuild the precompiled header. This way, if
     /// building the precompiled preamble fails, we won't try again for
     /// some number of calls.
     unsigned PreambleRebuildCounter = 0;
 
     /// A string hash of the top-level declaration and macro definition
     /// names processed the last time that we reparsed the precompiled preamble.
     ///
     /// This hash value is used to determine when we need to refresh the
     /// global code-completion cache after a rebuild of the precompiled preamble.
     unsigned PreambleTopLevelHashValue = 0;
+
+    /// A string hash of the top-level declaration and macro definition
+    /// names processed the last time that we reparsed the file.
+    ///
+    /// This hash value is used to determine when we need to refresh the
+    /// global code-completion cache.
+    unsigned CompletionCacheTopLevelHashValue = 0;
   };
 
   void initCache();
   ASTUnitCache &getCache() { return ASTUnitCacheMap[getMainFileName()]; }
   static std::recursive_mutex &getCacheMutex() { return CacheMutex; }
 
   /// Retrieve the mapping from formatted type names to unique type
   /// identifiers.
   llvm::StringMap<unsigned> &getCachedCompletionTypes() {
-    return CachedCompletionTypes; 
+    return CachedCompletionTypes;
   }
-  
   /// Retrieve the allocator used to cache global code completions.
   std::shared_ptr<GlobalCodeCompletionAllocator>
   getCachedCompletionAllocator() {
     return CachedCompletionAllocator;
   }
 
   CodeCompletionTUInfo &getCodeCompletionTUInfo() {
     if (!CCTUInfo)
       CCTUInfo = llvm::make_unique<CodeCompletionTUInfo>(
           std::make_shared<GlobalCodeCompletionAllocator>());
     return *CCTUInfo;
   }
 
 private:
   static std::recursive_mutex CacheMutex;
   static llvm::StringMap<ASTUnitCache> ASTUnitCacheMap;
 
   /// Allocator used to store cached code completions.
   std::shared_ptr<GlobalCodeCompletionAllocator> CachedCompletionAllocator;
 
   std::unique_ptr<CodeCompletionTUInfo> CCTUInfo;
 
-  /// The set of cached code-completion results.
-  std::vector<CachedCodeCompletionResult> CachedCompletionResults;
-
   /// A mapping from the formatted type name to a unique number for that
   /// type, which is used for type equality comparisons.
   llvm::StringMap<unsigned> CachedCompletionTypes;
-  
-  /// A string hash of the top-level declaration and macro definition 
-  /// names processed the last time that we reparsed the file.
-  ///
-  /// This hash value is used to determine when we need to refresh the 
-  /// global code-completion cache.
-  unsigned CompletionCacheTopLevelHashValue = 0;
-
   /// The current hash value for the top-level declaration and macro
   /// definition names
   unsigned CurrentTopLevelHashValue = 0;
-  
   /// Bit used by CIndex to mark when a translation unit may be in an
   /// inconsistent state, and is not safe to free.
   unsigned UnsafeToFree : 1;
 
   /// \brief Enumerator specifying the scope for skipping function bodies.
   SkipFunctionBodiesScope SkipFunctionBodies = SkipFunctionBodiesScope::None;
 
   /// Cache any "global" code-completion results, so that we can avoid
stored_diag_iterator stored_diag_end() {
     return StoredDiagnostics.end(); 
   }
 
   unsigned stored_diag_size() const { return StoredDiagnostics.size(); }
 
   stored_diag_iterator stored_diag_afterDriver_begin() {
     if (NumStoredDiagnosticsFromDriver > StoredDiagnostics.size())
       NumStoredDiagnosticsFromDriver = 0;
-    return StoredDiagnostics.begin() + NumStoredDiagnosticsFromDriver; 
+    return StoredDiagnostics.begin() + NumStoredDiagnosticsFromDriver;
   }
 
   using cached_completion_iterator =
       std::vector<CachedCodeCompletionResult>::iterator;
-  
   cached_completion_iterator cached_completion_begin() {
-    return CachedCompletionResults.begin();
+    return ASTUnitCacheMap[getMainFileName()].CachedCompletionResults.begin();
   }
 
   cached_completion_iterator cached_completion_end() {
-    return CachedCompletionResults.end();
+    return ASTUnitCacheMap[getMainFileName()].CachedCompletionResults.end();
   }
 
-  unsigned cached_completion_size() const { 
-    return CachedCompletionResults.size();
+  unsigned cached_completion_size() const {
+    return ASTUnitCacheMap[getMainFileName()].CachedCompletionResults.size();
   }
 
   /// Returns an iterator range for the local preprocessing entities
   /// of the local Preprocessor, if this is a parsed source file, or the loaded
   /// preprocessing entities of the primary module if this is an AST file.
   llvm::iterator_range<PreprocessingRecord::iterator>
   getLocalPreprocessingEntities() const;
 

lib/Frontend/ASTUnit.cpp

void ASTUnit::CacheCodeCompletionResults() {
   CodeCompletionTUInfo CCTUInfo(CachedCompletionAllocator);
   TheSema->GatherGlobalCodeCompletions(*CachedCompletionAllocator,
                                        CCTUInfo, Results);
 
   // Translate global code completions into cached completions.
   llvm::DenseMap<CanQualType, unsigned> CompletionTypes;
   CodeCompletionContext CCContext(CodeCompletionContext::CCC_TopLevel);
 
+  std::vector<CachedCodeCompletionResult> CachedCompletionResults;
   for (auto &R : Results) {
     switch (R.Kind) {
     case Result::RK_Declaration: {
       bool IsNestedNameSpecifier = false;
       CachedCodeCompletionResult CachedResult;
       CachedResult.Completion = R.CreateCodeCompletionString(
           *TheSema, CCContext, *CachedCompletionAllocator, CCTUInfo,
           IncludeBriefCommentsInCodeCompletion);
case Result::RK_Macro: {
       CachedResult.Type = 0;
       CachedCompletionResults.push_back(CachedResult);
       break;
     }
     }
   }
 
   // Save the current top-level hash value.
-  CompletionCacheTopLevelHashValue = CurrentTopLevelHashValue;
+  StringRef MainFilePath = getMainFileName();
+  std::lock_guard<std::recursive_mutex> Lock(CacheMutex);
+  ASTUnitCacheMap[MainFilePath].CachedCompletionResults = std::move(CachedCompletionResults);
+  ASTUnitCacheMap[MainFilePath].CompletionCacheTopLevelHashValue = CurrentTopLevelHashValue;
 }
 
 void ASTUnit::ClearCachedCompletionResults() {
-  CachedCompletionResults.clear();
+  std::lock_guard<std::recursive_mutex> Lock(CacheMutex);
+  ASTUnitCacheMap[getMainFileName()].CachedCompletionResults.clear();
   CachedCompletionTypes.clear();
   CachedCompletionAllocator = nullptr;
 }
 
 namespace {
 
 /// Gathers information from ASTReader that will be used to initialize
 /// a Preprocessor.
ASTUnit::getMainBufferWithPrecompiledPreamble(
   ASTUnitCacheMap[MainFilePath].TopLevelDeclsInPreamble = Callbacks.takeTopLevelDeclIDs();
   ASTUnitCacheMap[MainFilePath].PreambleDiagnostics = std::move(NewPreambleDiagsStandalone);
 
   auto &PreambleTopLevelHashValue = ASTUnitCacheMap[MainFilePath].PreambleTopLevelHashValue;
   // If the hash of top-level entities differs from the hash of the top-level
   // entities the last time we rebuilt the preamble, clear out the completion
   // cache.
   if (NewPreambleTopLevelHashValue != PreambleTopLevelHashValue) {
-    CompletionCacheTopLevelHashValue = 0;
+    ASTUnitCacheMap[MainFilePath].CompletionCacheTopLevelHashValue = 0;
     PreambleTopLevelHashValue = NewPreambleTopLevelHashValue;
   }
 
   return MainFileBuffer;
 }
 
 void ASTUnit::RealizeTopLevelDeclsFromPreamble() {
   auto MainFilePath = getMainFileName();
bool ASTUnit::Reparse(std::shared_ptr<PCHContainerOperations> PCHContainerOps,
   ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts());
   if (OverrideMainBuffer)
     getDiagnostics().setNumWarnings(NumWarningsInPreamble);
 
   // Parse the sources
   bool Result =
       Parse(std::move(PCHContainerOps), std::move(OverrideMainBuffer), VFS);
 
+  {
+    std::lock_guard<std::recursive_mutex> Lock(CacheMutex);
     // If we're caching global code-completion results, and the top-level
     // declarations have changed, clear out the code-completion cache.
     if (!Result && ShouldCacheCodeCompletionResults &&
-      CurrentTopLevelHashValue != CompletionCacheTopLevelHashValue)
+        CurrentTopLevelHashValue !=
+            ASTUnitCacheMap[MainFilePath].CompletionCacheTopLevelHashValue) {
       CacheCodeCompletionResults();
+    }
+  }
 
   // We now need to clear out the completion info related to this translation
   // unit; it'll be recreated if necessary.
   CCTUInfo.reset();
 
   return Result;
 }
 
void AugmentedCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &S,
   bool AddedResult = false;
   uint64_t InContexts =
       Context.getKind() == CodeCompletionContext::CCC_Recovery
         ? NormalContexts : (1LL << Context.getKind());
   // Contains the set of names that are hidden by "local" completion results.
   llvm::StringSet<llvm::BumpPtrAllocator> HiddenNames;
   using Result = CodeCompletionResult;
   SmallVector<Result, 8> AllResults;
-  for (ASTUnit::cached_completion_iterator
-            C = AST.cached_completion_begin(),
+
+  {
+    std::lock_guard<std::recursive_mutex> Lock(ASTUnit::getCacheMutex());
+    for (ASTUnit::cached_completion_iterator C = AST.cached_completion_begin(),
                                              CEnd = AST.cached_completion_end();
          C != CEnd; ++C) {
       // If the context we are in matches any of the contexts we are
       // interested in, we'll add this result.
       if ((C->ShowInContexts & InContexts) == 0)
         continue;
 
       // If we haven't added any results previously, do so now.
       if (!AddedResult) {
         CalculateHiddenNames(Context, Results, NumResults, S.Context,
                              HiddenNames);
         AllResults.insert(AllResults.end(), Results, Results + NumResults);
         AddedResult = true;
       }
 
       // Determine whether this global completion result is hidden by a local
       // completion result. If so, skip it.
       if (C->Kind != CXCursor_MacroDefinition &&
           HiddenNames.count(C->Completion->getTypedText()))
         continue;
 
       // Adjust priority based on similar type classes.
       unsigned Priority = C->Priority;
       CodeCompletionString *Completion = C->Completion;
       if (!Context.getPreferredType().isNull()) {
         if (C->Kind == CXCursor_MacroDefinition) {
-        Priority = getMacroUsagePriority(C->Completion->getTypedText(),
-                                         S.getLangOpts(),
-                               Context.getPreferredType()->isAnyPointerType());
+          Priority = getMacroUsagePriority(
+              C->Completion->getTypedText(), S.getLangOpts(),
         } else if (C->Type) {
-        CanQualType Expected
-          = S.Context.getCanonicalType(
-                               Context.getPreferredType().getUnqualifiedType());
+          CanQualType Expected = S.Context.getCanonicalType(
           SimplifiedTypeClass ExpectedSTC = getSimplifiedTypeClass(Expected);
           if (ExpectedSTC == C->TypeClass) {
             // We know this type is similar; check for an exact match.
-          llvm::StringMap<unsigned> &CachedCompletionTypes
-            = AST.getCachedCompletionTypes();
-          llvm::StringMap<unsigned>::iterator Pos
-            = CachedCompletionTypes.find(QualType(Expected).getAsString());
+            llvm::StringMap<unsigned> &CachedCompletionTypes =
+                AST.getCachedCompletionTypes();
+            llvm::StringMap<unsigned>::iterator Pos =
+                CachedCompletionTypes.find(QualType(Expected).getAsString());
             if (Pos != CachedCompletionTypes.end() && Pos->second == C->Type)
               Priority /= CCF_ExactTypeMatch;
             else
               Priority /= CCF_SimilarTypeMatch;
           }
         }
       }
 
       // Adjust the completion string, if required.
       if (C->Kind == CXCursor_MacroDefinition &&
           Context.getKind() == CodeCompletionContext::CCC_MacroNameUse) {
         // Create a new code-completion string that just contains the
         // macro name, without its arguments.
         CodeCompletionBuilder Builder(getAllocator(), getCodeCompletionTUInfo(),
                                       CCP_CodePattern, C->Availability);
         Builder.AddTypedTextChunk(C->Completion->getTypedText());
         Priority = CCP_CodePattern;
         Completion = Builder.TakeString();
       }
 
-    AllResults.push_back(Result(Completion, Priority, C->Kind,
-                                C->Availability));
+      AllResults.push_back(
+          Result(Completion, Priority, C->Kind, C->Availability));
+    }
   }
 
   // If we did not add any cached completion results, just forward the
   // results we were given to the next consumer.
   if (!AddedResult) {
     Next.ProcessCodeCompleteResults(S, Context, Results, NumResults);
     return;
   }
void ASTUnit::CodeComplete(
 
   auto CCInvocation = std::make_shared<CompilerInvocation>(*Invocation);
 
   FrontendOptions &FrontendOpts = CCInvocation->getFrontendOpts();
   CodeCompleteOptions &CodeCompleteOpts = FrontendOpts.CodeCompleteOpts;
   PreprocessorOptions &PreprocessorOpts = CCInvocation->getPreprocessorOpts();
   StringRef MainFilePath = getMainFileName();
 
-  CodeCompleteOpts.IncludeMacros = IncludeMacros &&
-                                   CachedCompletionResults.empty();
-  CodeCompleteOpts.IncludeGlobals = CachedCompletionResults.empty();
+  {
+    std::lock_guard<std::recursive_mutex> Lock(CacheMutex);
+    CodeCompleteOpts.IncludeMacros =
+        IncludeMacros &&
+        ASTUnitCacheMap[MainFilePath].CachedCompletionResults.empty();
+    CodeCompleteOpts.IncludeGlobals =
+        ASTUnitCacheMap[MainFilePath].CachedCompletionResults.empty();
+  }
+
   CodeCompleteOpts.IncludeCodePatterns = IncludeCodePatterns;
   CodeCompleteOpts.IncludeBriefComments = IncludeBriefComments;
   CodeCompleteOpts.LoadExternal = Consumer.loadExternal();
   CodeCompleteOpts.IncludeFixIts = Consumer.includeFixIts();
 
   assert(IncludeBriefComments == this->IncludeBriefCommentsInCodeCompletion);
 
   FrontendOpts.CodeCompletionAt.FileName = File;