[CodeCompletionn] Block completions in other threads

if fast-completion is enabled. So they have higher chance to use the cached
completion instance.
If it's disabled, don't block, use an ephemeral instance so we can peform
multiple completions simultaneously.

(cherry picked from commit 2aec5d4)

Author: rintaro

include/swift/IDE/CompletionInstance.h

@@ -40,12 +40,11 @@ class CompletionInstance {
   unsigned MaxASTReuseCount = 100;
   bool EnableASTCaching = false;
 
-  struct CachedInstance {
-    CompilerInstance CI;
-    llvm::hash_code ArgHash;
-    unsigned ReuseCound = 0;
-  };
-  std::shared_ptr<CachedInstance> CachedInst;
+  std::mutex mtx;
+
+  std::unique_ptr<CompilerInstance> CachedCI;
+  llvm::hash_code CachedArgHash;
+  unsigned CachedReuseCound = 0;
 
   /// Calls \p Callback with cached \c CompilerInstance if it's usable for the
   /// specified completion request.

lib/IDE/CompletionInstance.cpp

@@ -138,20 +138,17 @@ bool CompletionInstance::performCachedOperaitonIfPossible(
   if (!EnableASTCaching)
     return false;
 
-  // Temporary move the CI so other threads don't use the same instance.
-  std::shared_ptr<CachedInstance> CachedI(nullptr);
-  CachedInst.swap(CachedI);
-
-  if (!CachedI)
+  if (!CachedCI)
     return false;
-  if (CachedI->ReuseCound >= MaxASTReuseCount)
+
+  if (CachedReuseCound >= MaxASTReuseCount)
     return false;
-  if (CachedI->ArgHash != ArgsHash)
+  if (CachedArgHash != ArgsHash)
     return false;
 
-  auto &CI = CachedI->CI;
+  auto &CI = *CachedCI;
 
-  auto &oldState = CachedI->CI.getPersistentParserState();
+  auto &oldState = CI.getPersistentParserState();
   if (!oldState.hasCodeCompletionDelayedDeclState())
     return false;
 
@@ -242,8 +239,7 @@ bool CompletionInstance::performCachedOperaitonIfPossible(
   if (DiagC)
     CI.removeDiagnosticConsumer(DiagC);
 
-  CachedI->ReuseCound += 1;
-  CachedInst.swap(CachedI);
+  CachedReuseCound += 1;
 
   return true;
 }
@@ -254,9 +250,9 @@ bool CompletionInstance::performNewOperation(
     llvm::MemoryBuffer *completionBuffer, unsigned int Offset,
     std::string &Error, DiagnosticConsumer *DiagC,
     llvm::function_ref<void(CompilerInstance &)> Callback) {
-  CachedInst.reset();
-  auto TheInstance = std::make_shared<CachedInstance>();
-  auto &CI = TheInstance->CI;
+
+  auto TheInstance = std::make_unique<CompilerInstance>();
+  auto &CI = *TheInstance;
   if (DiagC)
     CI.addDiagnosticConsumer(DiagC);
 
@@ -278,8 +274,9 @@ bool CompletionInstance::performNewOperation(
     CI.removeDiagnosticConsumer(DiagC);
 
   if (EnableASTCaching) {
-    TheInstance->ArgHash = ArgsHash;
-    CachedInst.swap(TheInstance);
+    CachedCI = std::move(TheInstance);
+    CachedArgHash = ArgsHash;
+    CachedReuseCound = 0;
   }
 
   return true;
@@ -308,6 +305,12 @@ bool swift::ide::CompletionInstance::performOperation(
   for (auto arg : Args)
     ArgsHash = llvm::hash_combine(ArgsHash, StringRef(arg));
 
+  // If AST caching is enabled, block completions in other threads. So they
+  // have higher chance to use the cached completion instance.
+  Optional<std::lock_guard<std::mutex>> lock;
+  if (EnableASTCaching)
+    lock.emplace(mtx);
+
   if (performCachedOperaitonIfPossible(Invocation, ArgsHash, completionBuffer,
                                        Offset, DiagC, Callback))
     return true;

test/SourceKit/CodeComplete/complete_sequence_race.swift

@@ -23,10 +23,12 @@ func bar(arg: Bar) {
 // RUN:   -req=complete -pos=15:11 %s -async -- %s == \
 // RUN:   -req=complete -pos=12:11 %s -async -- %s == \
 // RUN:   -req=complete -pos=15:11 %s -async -- %s == \
+// RUN:   -req=complete -pos=17:1 %s -async -- %s == \
 // RUN:   -req=complete -pos=12:11 %s -async -- %s == \
 // RUN:   -req=complete -pos=15:11 %s -async -- %s == \
 // RUN:   -req=complete -pos=12:11 %s -async -- %s == \
 // RUN:   -req=complete -pos=15:11 %s -async -- %s == \
+// RUN:   -req=complete -pos=17:1 %s -async -- %s == \
 // RUN:   -req=complete -pos=12:11 %s -async -- %s == \
 // RUN:   -req=complete -pos=15:11 %s -async -- %s
 
@@ -36,9 +38,11 @@ func bar(arg: Bar) {
 // RUN:   -req=complete -req-opts=reuseastcontext=1 -pos=15:11 %s -async -- %s == \
 // RUN:   -req=complete -req-opts=reuseastcontext=1 -pos=12:11 %s -async -- %s == \
 // RUN:   -req=complete -req-opts=reuseastcontext=1 -pos=15:11 %s -async -- %s == \
+// RUN:   -req=complete -req-opts=reuseastcontext=1 -pos=17:1 %s -async -- %s == \
 // RUN:   -req=complete -req-opts=reuseastcontext=1 -pos=12:11 %s -async -- %s == \
 // RUN:   -req=complete -req-opts=reuseastcontext=1 -pos=15:11 %s -async -- %s == \
 // RUN:   -req=complete -req-opts=reuseastcontext=1 -pos=12:11 %s -async -- %s == \
 // RUN:   -req=complete -req-opts=reuseastcontext=1 -pos=15:11 %s -async -- %s == \
+// RUN:   -req=complete -req-opts=reuseastcontext=1 -pos=17:1 %s -async -- %s == \
 // RUN:   -req=complete -req-opts=reuseastcontext=1 -pos=12:11 %s -async -- %s == \
 // RUN:   -req=complete -req-opts=reuseastcontext=1 -pos=15:11 %s -async -- %s