[CodeCompletion] Use the arguments to check the equality of the invocation

Checking "selected" properties of CompilerInvocation is hard to keep it
up to date. If the arguments are the same, the invocations are the same.

Author: rintaro

include/swift/IDE/CompletionInstance.h

@@ -14,6 +14,7 @@
 #define SWIFT_IDE_COMPLETIONINSTANCE_H
 
 #include "swift/Frontend/Frontend.h"
+#include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
@@ -37,6 +38,7 @@ makeCodeCompletionMemoryBuffer(const llvm::MemoryBuffer *origBuf,
 /// Manages \c CompilerInstance for completion like operations.
 class CompletionInstance {
   std::unique_ptr<CompilerInstance> CachedCI = nullptr;
+  llvm::hash_code CachedArgsHash;
   bool EnableASTCaching = false;
   unsigned MaxASTReuseCount = 100;
   unsigned CurrentASTReuseCount = 0;
@@ -48,27 +50,31 @@ class CompletionInstance {
   /// bodies, or the interface hash of the file has changed.
   swift::CompilerInstance *
   getCachedCompilerInstance(const swift::CompilerInvocation &Invocation,
+                            llvm::hash_code ArgsHash,
                             llvm::MemoryBuffer *completionBuffer,
                             unsigned int Offset, DiagnosticConsumer *DiagC);
 
   /// Returns new \c CompilerInstance for the completion request. Users still
   /// have to call \c performParseAndResolveImportsOnly() , and perform the
   /// second pass on it.
   swift::CompilerInstance *renewCompilerInstance(
-      swift::CompilerInvocation &Invocation,
+      swift::CompilerInvocation &Invocation, llvm::hash_code ArgsHash,
       llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> FileSystem,
       llvm::MemoryBuffer *completionBuffer, unsigned int Offset,
       std::string &Error, DiagnosticConsumer *DiagC);
 
 public:
-  void setEnableASTCaching(bool Flag) {
-    EnableASTCaching = Flag;
-  }
+  void setEnableASTCaching(bool Flag) { EnableASTCaching = Flag; }
 
   /// Returns \C CompilerInstance for the completion request. Users can check if
   /// it's cached or not by 'hasPersistentParserState()'.
+  ///
+  /// NOTE: \p Args is only used for checking the equaity of the invocation.
+  /// Since this function assumes that it is already normalized, exact the same
+  /// arguments including their order is considered as the same invocation.
   swift::CompilerInstance *getCompilerInstance(
       swift::CompilerInvocation &Invocation,
+      llvm::ArrayRef<const char *> Args,
       llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> FileSystem,
       llvm::MemoryBuffer *completionBuffer, unsigned int Offset,
       std::string &Error, DiagnosticConsumer *DiagC);

lib/IDE/CompletionInstance.cpp

@@ -23,8 +23,8 @@
 #include "swift/Frontend/Frontend.h"
 #include "swift/Parse/PersistentParserState.h"
 #include "swift/Subsystems.h"
-#include "llvm/Support/MemoryBuffer.h"
 #include "llvm/ADT/Hashing.h"
+#include "llvm/Support/MemoryBuffer.h"
 
 using namespace swift;
 using namespace ide;
@@ -127,76 +127,10 @@ static DeclContext *getEquivalentDeclContextFromSourceFile(DeclContext *DC,
   return newDC;
 }
 
-/// Calculate the hash value of the \c CompilerInvocation.
-/// This should take all options affecting completion results into account.
-/// If the hashes between multiple completion invocation are different, we
-/// cannot reuse the CompilerInstance.
-static llvm::hash_code calculateInvocationHash(const CompilerInvocation &Inv) {
-  llvm::hash_code hash(0);
-
-  auto &frontendOpts = Inv.getFrontendOptions();
-  for (const InputFile &Input : frontendOpts.InputsAndOutputs.getAllInputs())
-    hash = llvm::hash_combine(hash, Input.file());
-  hash = llvm::hash_combine(
-      hash,
-      frontendOpts.InputKind,
-      llvm::makeArrayRef(frontendOpts.ImplicitImportModuleNames),
-      frontendOpts.ImplicitObjCHeaderPath,
-      frontendOpts.ModuleName,
-      frontendOpts.PrebuiltModuleCachePath,
-      llvm::makeArrayRef(frontendOpts.PreferInterfaceForModules),
-      frontendOpts.ParseStdlib,
-      frontendOpts.EnableSourceImport,
-      frontendOpts.ImportUnderlyingModule);
-
-  auto &langOpts = Inv.getLangOptions();
-  hash = llvm::hash_combine(
-      hash,
-      langOpts.Target.str(),
-      llvm::VersionTuple(langOpts.EffectiveLanguageVersion).getAsString(),
-      llvm::VersionTuple(langOpts.PackageDescriptionVersion).getAsString(),
-      langOpts.DisableAvailabilityChecking,
-      langOpts.EnableAccessControl,
-      langOpts.EnableAppExtensionRestrictions,
-      langOpts.RequireExplicitAvailability,
-      langOpts.RequireExplicitAvailabilityTarget,
-      langOpts.EnableObjCInterop,
-      langOpts.EnableCXXInterop,
-      langOpts.InferImportAsMember,
-      langOpts.EnableSwift3ObjCInference);
-
-  auto &searchPathOpts = Inv.getSearchPathOptions();
-  hash = llvm::hash_combine(
-      hash,
-      searchPathOpts.SDKPath,
-      llvm::makeArrayRef(searchPathOpts.ImportSearchPaths),
-      llvm::makeArrayRef(searchPathOpts.VFSOverlayFiles),
-      searchPathOpts.RuntimeResourcePath,
-      llvm::makeArrayRef(searchPathOpts.RuntimeLibraryImportPaths),
-      llvm::makeArrayRef(searchPathOpts.SkipRuntimeLibraryImportPaths));
-  for (auto &P : searchPathOpts.FrameworkSearchPaths)
-    hash = llvm::hash_combine(hash, P.IsSystem, P.Path);
-
-  auto &clangOpts = Inv.getClangImporterOptions();
-  hash = llvm::hash_combine(
-      hash,
-      clangOpts.ModuleCachePath,
-      llvm::makeArrayRef(clangOpts.ExtraArgs),
-      clangOpts.OverrideResourceDir,
-      clangOpts.TargetCPU,
-      static_cast<uint8_t>(clangOpts.Mode),
-      clangOpts.ImportForwardDeclarations,
-      clangOpts.InferImportAsMember,
-      clangOpts.DisableSwiftBridgeAttr,
-      clangOpts.DisableOverlayModules);
-
-  return hash;
-}
-
 } // namespace
 
 CompilerInstance *CompletionInstance::getCachedCompilerInstance(
-    const swift::CompilerInvocation &Invocation,
+    const swift::CompilerInvocation &Invocation, llvm::hash_code ArgsHash,
     llvm::MemoryBuffer *completionBuffer, unsigned int Offset,
     DiagnosticConsumer *DiagC) {
   if (!EnableASTCaching)
@@ -210,8 +144,7 @@ CompilerInstance *CompletionInstance::getCachedCompilerInstance(
   if (!CachedCI)
     return nullptr;
 
-  if (calculateInvocationHash(Invocation) !=
-      calculateInvocationHash(CachedCI->getInvocation()))
+  if (ArgsHash != CachedArgsHash)
     return nullptr;
 
   auto &oldState = CachedCI->getPersistentParserState();
@@ -307,12 +240,13 @@ CompilerInstance *CompletionInstance::getCachedCompilerInstance(
 }
 
 CompilerInstance *CompletionInstance::renewCompilerInstance(
-    swift::CompilerInvocation &Invocation,
+    swift::CompilerInvocation &Invocation, llvm::hash_code ArgsHash,
     llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> FileSystem,
     llvm::MemoryBuffer *completionBuffer, unsigned int Offset,
     std::string &Error, DiagnosticConsumer *DiagC) {
   CachedCI.reset();
   CachedCI = std::make_unique<CompilerInstance>();
+  CachedArgsHash = ArgsHash;
   auto *CI = CachedCI.get();
   if (DiagC)
     CachedCI->addDiagnosticConsumer(DiagC);
@@ -332,7 +266,7 @@ CompilerInstance *CompletionInstance::renewCompilerInstance(
 }
 
 CompilerInstance *swift::ide::CompletionInstance::getCompilerInstance(
-    swift::CompilerInvocation &Invocation,
+    swift::CompilerInvocation &Invocation, llvm::ArrayRef<const char *> Args,
     llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> FileSystem,
     llvm::MemoryBuffer *completionBuffer, unsigned int Offset,
     std::string &Error, DiagnosticConsumer *DiagC) {
@@ -348,12 +282,18 @@ CompilerInstance *swift::ide::CompletionInstance::getCompilerInstance(
   // FIXME: ASTScopeLookup doesn't support code completion yet.
   Invocation.disableASTScopeLookup();
 
-  if (auto *cached = getCachedCompilerInstance(Invocation, completionBuffer,
-                                              Offset, DiagC))
+  // Compute the signature of the invocation.
+  llvm::hash_code ArgsHash(0);
+  for (auto arg : Args)
+    ArgsHash = llvm::hash_combine(ArgsHash, StringRef(arg));
+
+  if (auto *cached = getCachedCompilerInstance(Invocation, ArgsHash,
+                                               completionBuffer, Offset, DiagC))
     return cached;
 
-  if (auto *renewed = renewCompilerInstance(
-          Invocation, FileSystem, completionBuffer, Offset, Error, DiagC))
+  if (auto *renewed =
+          renewCompilerInstance(Invocation, ArgsHash, FileSystem,
+                                completionBuffer, Offset, Error, DiagC))
     return renewed;
 
   assert(!Error.empty());

tools/SourceKit/lib/SwiftLang/SwiftCompletion.cpp

@@ -176,7 +176,7 @@ static bool swiftCodeCompleteImpl(
   // Pin completion instance.
   auto CompletionInst =  Lang.getCompletionInstance();
   CompilerInstance *CI = CompletionInst->getCompilerInstance(
-      Invocation, FileSystem, newBuffer.get(), Offset, Error, &CIDiags);
+      Invocation, Args, FileSystem, newBuffer.get(), Offset, Error, &CIDiags);
   if (!CI)
     return false;
   SWIFT_DEFER { CI->removeDiagnosticConsumer(&CIDiags); };

tools/SourceKit/lib/SwiftLang/SwiftConformingMethodList.cpp

@@ -80,7 +80,7 @@ static bool swiftConformingMethodListImpl(
   // Pin completion instance.
   auto CompletionInst =  Lang.getCompletionInstance();
   CompilerInstance *CI = CompletionInst->getCompilerInstance(
-      Invocation, FileSystem, newBuffer.get(), Offset, Error, &CIDiags);
+      Invocation, Args, FileSystem, newBuffer.get(), Offset, Error, &CIDiags);
   if (!CI)
     return false;
   SWIFT_DEFER { CI->removeDiagnosticConsumer(&CIDiags); };

tools/SourceKit/lib/SwiftLang/SwiftTypeContextInfo.cpp

@@ -78,7 +78,7 @@ static bool swiftTypeContextInfoImpl(
   // Pin completion instance.
   auto CompletionInst =  Lang.getCompletionInstance();
   CompilerInstance *CI = CompletionInst->getCompilerInstance(
-      Invocation, FileSystem, newBuffer.get(), Offset, Error, &CIDiags);
+      Invocation, Args, FileSystem, newBuffer.get(), Offset, Error, &CIDiags);
   if (!CI)
     return false;
   SWIFT_DEFER { CI->removeDiagnosticConsumer(&CIDiags); };

tools/swift-ide-test/swift-ide-test.cpp

@@ -758,8 +758,8 @@ static bool doCodeCompletionImpl(
   PrintingDiagnosticConsumer PrintDiags;
   CompletionInstance CompletionInst;
   auto *CI = CompletionInst.getCompilerInstance(
-      Invocation, llvm::vfs::getRealFileSystem(), CleanFile.get(), Offset,
-      Error, CodeCompletionDiagnostics ? &PrintDiags : nullptr);
+      Invocation, /*Args=*/{}, llvm::vfs::getRealFileSystem(), CleanFile.get(),
+      Offset, Error, CodeCompletionDiagnostics ? &PrintDiags : nullptr);
   if (!CI)
     return 1;