[clangd] Allow to pass code completion opts to ClangdServer.

[krasimir]

Great! I like the unit testing approach a lot!

[ilya-biryukov]

In D38731#898539, @krasimir wrote:

Great! I like the unit testing approach a lot!

Thanks!

clangd/ClangdLSPServer.cpp

 }
 
 ClangdLSPServer::ClangdLSPServer(JSONOutput &Out, unsigned AsyncThreadsCount,
                                  bool SnippetCompletions,
                                  llvm::Optional<StringRef> ResourceDir,
                                  llvm::Optional<Path> CompileCommandsDir)
     : Out(Out), CDB(/*Logger=*/Out, std::move(CompileCommandsDir)),
       Server(CDB, /*DiagConsumer=*/*this, FSProvider, AsyncThreadsCount,
-             SnippetCompletions, /*Logger=*/Out, ResourceDir) {}
+             clangd::CodeCompleteOptions(
+                 /*EnableSnippetsAndCodePatterns=*/SnippetCompletions),
+             /*Logger=*/Out, ResourceDir) {}
 
 void ClangdLSPServer::run(std::istream &In) {
   assert(!IsDone && "Run was called before");
 
   // Set up JSONRPCDispatcher.
   JSONRPCDispatcher Dispatcher(llvm::make_unique<Handler>(Out));
   registerCallbackHandlers(Dispatcher, Out, /*Callbacks=*/*this);
 

clangd/ClangdServer.h

public:
   /// \p DiagConsumer. Note that a callback to \p DiagConsumer happens on a
   /// worker thread. Therefore, instances of \p DiagConsumer must properly
   /// synchronize access to shared state.
   ///
   /// Various messages are logged using \p Logger.
   ClangdServer(GlobalCompilationDatabase &CDB,
                DiagnosticsConsumer &DiagConsumer,
                FileSystemProvider &FSProvider, unsigned AsyncThreadsCount,
-               bool SnippetCompletions, clangd::Logger &Logger,
+               clangd::CodeCompleteOptions CodeCompleteOpts,
+               clangd::Logger &Logger,
                llvm::Optional<StringRef> ResourceDir = llvm::None);
 
   /// Set the root path of the workspace.
   void setRootPath(PathRef RootPath);
 
   /// Add a \p File to the list of tracked C++ files or update the contents if
   /// \p File is already tracked. Also schedules parsing of the AST for it on a
   /// separate thread. When the parsing is complete, DiagConsumer passed in
public:
   /// This method should only be called for currently tracked files. However, it
   /// is safe to call removeDocument for \p File after this method returns, even
   /// while returned future is not yet ready.
   std::future<Tagged<std::vector<CompletionItem>>>
   codeComplete(PathRef File, Position Pos,
                llvm::Optional<StringRef> OverridenContents = llvm::None,
                IntrusiveRefCntPtr<vfs::FileSystem> *UsedFS = nullptr);
 
+  /// A version of `codeComplete` that runs \p Callback on the processing thread
+  /// when codeComplete results become available.
+  void codeComplete(
+      UniqueFunction<void(Tagged<std::vector<CompletionItem>>)> Callback,
+      PathRef File, Position Pos,
+      llvm::Optional<StringRef> OverridenContents = llvm::None,
+      IntrusiveRefCntPtr<vfs::FileSystem> *UsedFS = nullptr);
   /// Provide signature help for \p File at \p Pos. If \p OverridenContents is
   /// not None, they will used only for signature help, i.e. no diagnostics
   /// update will be scheduled and a draft for \p File will not be updated. If
   /// \p OverridenContents is None, contents of the current draft for \p File
   /// will be used. If \p UsedFS is non-null, it will be overwritten by
   /// vfs::FileSystem used for signature help. This method should only be called
   /// for currently tracked files.
   Tagged<SignatureHelp>
private:
   DiagnosticsConsumer &DiagConsumer;
   FileSystemProvider &FSProvider;
   DraftStore DraftMgr;
   CppFileCollection Units;
   std::string ResourceDir;
   // If set, this represents the workspace path.
   llvm::Optional<std::string> RootPath;
   std::shared_ptr<PCHContainerOperations> PCHs;
-  bool SnippetCompletions;
+  clangd::CodeCompleteOptions CodeCompleteOpts;
   /// Used to serialize diagnostic callbacks.
   /// FIXME(ibiryukov): get rid of an extra map and put all version counters
   /// into CppFile.
   std::mutex DiagnosticsMutex;
   /// Maps from a filename to the latest version of reported diagnostics.
   llvm::StringMap<DocVersion> ReportedDiagnosticVersions;
   // WorkScheduler has to be the last member, because its destructor has to be
   // called before all other members to stop the worker thread that references
   // ClangdServer
   ClangdScheduler WorkScheduler;
 };
 
 } // namespace clangd
 } // namespace clang
 
 #endif

clangd/ClangdServer.cpp

ClangdScheduler::~ClangdScheduler() {
 
   for (auto &Worker : Workers)
     Worker.join();
 }
 
 ClangdServer::ClangdServer(GlobalCompilationDatabase &CDB,
                            DiagnosticsConsumer &DiagConsumer,
                            FileSystemProvider &FSProvider,
-                           unsigned AsyncThreadsCount, bool SnippetCompletions,
+                           unsigned AsyncThreadsCount,
+                           clangd::CodeCompleteOptions CodeCompleteOpts,
                            clangd::Logger &Logger,
                            llvm::Optional<StringRef> ResourceDir)
     : Logger(Logger), CDB(CDB), DiagConsumer(DiagConsumer),
       FSProvider(FSProvider),
       ResourceDir(ResourceDir ? ResourceDir->str() : getStandardResourceDir()),
       PCHs(std::make_shared<PCHContainerOperations>()),
-      SnippetCompletions(SnippetCompletions), WorkScheduler(AsyncThreadsCount) {
-}
+      CodeCompleteOpts(CodeCompleteOpts), WorkScheduler(AsyncThreadsCount) {}
 
 void ClangdServer::setRootPath(PathRef RootPath) {
   std::string NewRootPath = llvm::sys::path::convert_to_slash(
       RootPath, llvm::sys::path::Style::posix);
   if (llvm::sys::fs::is_directory(NewRootPath))
     this->RootPath = NewRootPath;
 }
 
if (!Preamble) {
       Preamble = Resources->getPossiblyStalePreamble();
     }
     // FIXME(ibiryukov): even if Preamble is non-null, we may want to check
     // both the old and the new version in case only one of them matches.
 
     std::vector<CompletionItem> Result = clangd::codeComplete(
         File, Resources->getCompileCommand(),
         Preamble ? &Preamble->Preamble : nullptr, Contents, Pos, TaggedFS.Value,
-        PCHs, SnippetCompletions, Logger);
+        PCHs, CodeCompleteOpts, Logger);
     return make_tagged(std::move(Result), std::move(TaggedFS.Tag));
   });
 
   auto Future = Task.get_future();
   // FIXME(ibiryukov): to reduce overhead for wrapping the same callable
   // multiple times, ClangdScheduler should return future<> itself.
   WorkScheduler.addToFront([](PackagedTask Task) { Task(); }, std::move(Task));
   return Future;

clangd/ClangdUnit.h

private:
   /// waiting for rebuild to finish.
   std::shared_ptr<const PreambleData> LatestAvailablePreamble;
   /// Utility class, required by clang.
   std::shared_ptr<PCHContainerOperations> PCHs;
   /// Used for logging various messages.
   clangd::Logger &Logger;
 };
 
+struct CodeCompleteOptions {
+  CodeCompleteOptions() = default;
+
+  /// Uses default values for all flags, but sets EnableSnippets and
+  /// IncludeCodePatterns to the value of EnableSnippetsAndCodePatterns.
+  explicit CodeCompleteOptions(bool EnableSnippetsAndCodePatterns);
+
+  CodeCompleteOptions(bool EnableSnippets, bool IncludeCodePatterns,
+                      bool IncludeMacros, bool IncludeGlobals,
+                      bool IncludeBriefComments);
+
+  /// Returns options that can be passed to clang's completion engine.
+  clang::CodeCompleteOptions getClangCompleteOpts();
+
+  /// When true, completion items will contain expandable code snippets in
+  /// completion (e.g.  `return ${1:expression}` or `foo(${1:int a}, ${2:int
+  /// b})).
+  bool EnableSnippets = false;
+
+  /// Add code patterns to completion results.
+  /// If EnableSnippets is false, this options is ignored and code patterns will
+  /// always be omitted.
+  bool IncludeCodePatterns = false;
+
+  /// Add macros to code completion results.
+  bool IncludeMacros = true;
+
+  /// Add globals to code completion results.
+  bool IncludeGlobals = true;
+
+  /// Add brief comments to completion items, if available.
+  /// Note that it
+  /// when many items have comments.
+  /// FIXME(ibiryukov): it looks like this option significantly slows down
+  /// completion, investigate if it can be made faster.
+  bool IncludeBriefComments = true;
+};
+
 /// Get code completions at a specified \p Pos in \p FileName.
 std::vector<CompletionItem>
 codeComplete(PathRef FileName, tooling::CompileCommand Command,
              PrecompiledPreamble const *Preamble, StringRef Contents,
              Position Pos, IntrusiveRefCntPtr<vfs::FileSystem> VFS,
              std::shared_ptr<PCHContainerOperations> PCHs,
-             bool SnippetCompletions, clangd::Logger &Logger);
+             clangd::CodeCompleteOptions Opts, clangd::Logger &Logger);
 
 /// Get signature help at a specified \p Pos in \p FileName.
 SignatureHelp signatureHelp(PathRef FileName, tooling::CompileCommand Command,
                             PrecompiledPreamble const *Preamble,
                             StringRef Contents, Position Pos,
                             IntrusiveRefCntPtr<vfs::FileSystem> VFS,
                             std::shared_ptr<PCHContainerOperations> PCHs,
                             clangd::Logger &Logger);
 
 /// Get definition of symbol at a specified \p Pos.
 std::vector<Location> findDefinitions(ParsedAST &AST, Position Pos,
                                       clangd::Logger &Logger);
 
 /// For testing/debugging purposes. Note that this method deserializes all
+
 /// unserialized Decls, so use with care.
 void dumpAST(ParsedAST &AST, llvm::raw_ostream &OS);
 
 } // namespace clangd
 } // namespace clang
 #endif

clangd/ClangdUnit.cpp

if (CCS.getBriefComment() != nullptr) {
     }
     Result += CCS.getBriefComment();
   }
   return Result;
 }
 
 class CompletionItemsCollector : public CodeCompleteConsumer {
 public:
-  CompletionItemsCollector(const CodeCompleteOptions &CodeCompleteOpts,
+  CompletionItemsCollector(const clang::CodeCompleteOptions &CodeCompleteOpts,
                            std::vector<CompletionItem> &Items)
       : CodeCompleteConsumer(CodeCompleteOpts, /*OutputIsBinary=*/false),
         Items(Items),
         Allocator(std::make_shared<clang::GlobalCodeCompletionAllocator>()),
         CCTUInfo(Allocator) {}
 
   void ProcessCodeCompleteResults(Sema &S, CodeCompletionContext Context,
                                   CodeCompletionResult *Results,
bool isInformativeQualifierChunk(CodeCompletionString::Chunk const &Chunk) {
   return Chunk.Kind == CodeCompletionString::CK_Informative &&
          StringRef(Chunk.Text).endswith("::");
 }
 
 class PlainTextCompletionItemsCollector final
     : public CompletionItemsCollector {
 
 public:
-  PlainTextCompletionItemsCollector(const CodeCompleteOptions &CodeCompleteOpts,
-                                    std::vector<CompletionItem> &Items)
+  PlainTextCompletionItemsCollector(
+      const clang::CodeCompleteOptions &CodeCompleteOpts,
       : CompletionItemsCollector(CodeCompleteOpts, Items) {}
 
 private:
   void ProcessChunks(const CodeCompletionString &CCS,
                      CompletionItem &Item) const override {
     for (const auto &Chunk : CCS) {
       // Informative qualifier chunks only clutter completion results, skip
       // them.
for (const auto &Chunk : CCS) {
       }
     }
   }
 }; // PlainTextCompletionItemsCollector
 
 class SnippetCompletionItemsCollector final : public CompletionItemsCollector {
 
 public:
-  SnippetCompletionItemsCollector(const CodeCompleteOptions &CodeCompleteOpts,
-                                  std::vector<CompletionItem> &Items)
+  SnippetCompletionItemsCollector(
+      const clang::CodeCompleteOptions &CodeCompleteOpts,
       : CompletionItemsCollector(CodeCompleteOpts, Items) {}
 
 private:
   void ProcessChunks(const CodeCompletionString &CCS,
                      CompletionItem &Item) const override {
     unsigned ArgCount = 0;
     for (const auto &Chunk : CCS) {
       // Informative qualifier chunks only clutter completion results, skip
for (const auto &Chunk : CCS) {
       }
     }
   }
 }; // SnippetCompletionItemsCollector
 
 class SignatureHelpCollector final : public CodeCompleteConsumer {
 
 public:
-  SignatureHelpCollector(const CodeCompleteOptions &CodeCompleteOpts,
+  SignatureHelpCollector(const clang::CodeCompleteOptions &CodeCompleteOpts,
                          SignatureHelp &SigHelp)
       : CodeCompleteConsumer(CodeCompleteOpts, /*OutputIsBinary=*/false),
         SigHelp(SigHelp),
         Allocator(std::make_shared<clang::GlobalCodeCompletionAllocator>()),
         CCTUInfo(Allocator) {}
 
   void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg,
                                  OverloadCandidate *Candidates,
private:
 
   SignatureHelp &SigHelp;
   std::shared_ptr<clang::GlobalCodeCompletionAllocator> Allocator;
   CodeCompletionTUInfo CCTUInfo;
 
 }; // SignatureHelpCollector
 
 bool invokeCodeComplete(std::unique_ptr<CodeCompleteConsumer> Consumer,
-                        const CodeCompleteOptions &Options, PathRef FileName,
+                        const clang::CodeCompleteOptions &Options,
+                        PathRef FileName,
                         const tooling::CompileCommand &Command,
                         PrecompiledPreamble const *Preamble, StringRef Contents,
                         Position Pos, IntrusiveRefCntPtr<vfs::FileSystem> VFS,
                         std::shared_ptr<PCHContainerOperations> PCHs,
                         clangd::Logger &Logger) {
   std::vector<const char *> ArgStrs;
   for (const auto &S : Command.CommandLine)
     ArgStrs.push_back(S.c_str());
bool invokeCodeComplete(std::unique_ptr<CodeCompleteConsumer> Consumer,
 
   Action.EndSourceFile();
 
   return true;
 }
 
 } // namespace
 
+clangd::CodeCompleteOptions::CodeCompleteOptions(
+    bool EnableSnippetsAndCodePatterns)
+    : CodeCompleteOptions() {
+  EnableSnippets = EnableSnippetsAndCodePatterns;
+  IncludeCodePatterns = EnableSnippetsAndCodePatterns;
+}
+
+clangd::CodeCompleteOptions::CodeCompleteOptions(bool EnableSnippets,
+                                                 bool IncludeCodePatterns,
+                                                 bool IncludeMacros,
+                                                 bool IncludeGlobals,
+                                                 bool IncludeBriefComments)
+    : EnableSnippets(EnableSnippets), IncludeCodePatterns(IncludeCodePatterns),
+      IncludeMacros(IncludeMacros), IncludeGlobals(IncludeGlobals),
+      IncludeBriefComments(IncludeBriefComments) {}
+
+clang::CodeCompleteOptions clangd::CodeCompleteOptions::getClangCompleteOpts() {
+  clang::CodeCompleteOptions Result;
+  Result.IncludeCodePatterns = EnableSnippets && IncludeCodePatterns;
+  Result.IncludeMacros = IncludeMacros;
+  Result.IncludeGlobals = IncludeGlobals;
+  Result.IncludeBriefComments = IncludeBriefComments;
+
+  return Result;
+}
+
 std::vector<CompletionItem>
 clangd::codeComplete(PathRef FileName, tooling::CompileCommand Command,
                      PrecompiledPreamble const *Preamble, StringRef Contents,
                      Position Pos, IntrusiveRefCntPtr<vfs::FileSystem> VFS,
                      std::shared_ptr<PCHContainerOperations> PCHs,
-                     bool SnippetCompletions, clangd::Logger &Logger) {
+                     clangd::CodeCompleteOptions Opts, clangd::Logger &Logger) {
   std::vector<CompletionItem> Results;
-  CodeCompleteOptions Options;
   std::unique_ptr<CodeCompleteConsumer> Consumer;
-  Options.IncludeGlobals = true;
-  Options.IncludeMacros = true;
-  Options.IncludeBriefComments = true;
-  if (SnippetCompletions) {
-    Options.IncludeCodePatterns = true;
-    Consumer =
-        llvm::make_unique<SnippetCompletionItemsCollector>(Options, Results);
+  clang::CodeCompleteOptions ClangCompleteOpts = Opts.getClangCompleteOpts();
+  if (Opts.EnableSnippets) {
+    Consumer = llvm::make_unique<SnippetCompletionItemsCollector>(
+        ClangCompleteOpts, Results);
   } else {
-    Options.IncludeCodePatterns = false;
-    Consumer =
-        llvm::make_unique<PlainTextCompletionItemsCollector>(Options, Results);
+    Consumer = llvm::make_unique<PlainTextCompletionItemsCollector>(
+        ClangCompleteOpts, Results);
   }
-  invokeCodeComplete(std::move(Consumer), Options, FileName, Command, Preamble,
-                     Contents, Pos, std::move(VFS), std::move(PCHs), Logger);
+  invokeCodeComplete(std::move(Consumer), ClangCompleteOpts, FileName, Command,
+                     Preamble, Contents, Pos, std::move(VFS), std::move(PCHs),
+                     Logger);
   return Results;
 }
 
 SignatureHelp
 clangd::signatureHelp(PathRef FileName, tooling::CompileCommand Command,
                       PrecompiledPreamble const *Preamble, StringRef Contents,
                       Position Pos, IntrusiveRefCntPtr<vfs::FileSystem> VFS,
                       std::shared_ptr<PCHContainerOperations> PCHs,
                       clangd::Logger &Logger) {
   SignatureHelp Result;
-  CodeCompleteOptions Options;
+  clang::CodeCompleteOptions Options;
   Options.IncludeGlobals = false;
   Options.IncludeMacros = false;
   Options.IncludeCodePatterns = false;
   Options.IncludeBriefComments = true;
   invokeCodeComplete(llvm::make_unique<SignatureHelpCollector>(Options, Result),
                      Options, FileName, Command, Preamble, Contents, Pos,
                      std::move(VFS), std::move(PCHs), Logger);
   return Result;

unittests/clangd/ClangdTests.cpp

IntrusiveRefCntPtr<vfs::FileSystem> getTempOnlyFS() {
   return new vfs::FilteredFileSystem(std::move(TmpDirs),
                                      vfs::getRealFileSystem());
 }
 } // namespace vfs
 
 namespace clangd {
 namespace {
 
+struct StringWithPos {
+  std::string Text;
+  clangd::Position MarkerPos;
+};
+
+/// Returns location of "{mark}" substring in \p Text and removes it from \p
+/// Text. Note that \p Text must contain exactly one occurence of "{mark}".
+///
+/// Marker name can be configured using \p MarkerName parameter.
+StringWithPos parseTextMarker(StringRef Text, StringRef MarkerName = "mark") {
+  SmallString<16> Marker;
+  Twine("{" + MarkerName + "}").toVector(/*ref*/ Marker);
+
+  std::size_t MarkerOffset = Text.find(Marker);
+  assert(MarkerOffset != StringRef::npos && "{mark} wasn't found in Text.");
+
+  std::string WithoutMarker;
+  WithoutMarker += Text.take_front(MarkerOffset);
+  WithoutMarker += Text.drop_front(MarkerOffset + Marker.size());
+  assert(StringRef(WithoutMarker).find(Marker) == StringRef::npos &&
+         "There were multiple occurences of {mark} inside Text");
+
+  clangd::Position MarkerPos =
+      clangd::offsetToPosition(WithoutMarker, MarkerOffset);
+  return {std::move(WithoutMarker), MarkerPos};
+}
+
 // Don't wait for async ops in clangd test more than that to avoid blocking
 // indefinitely in case of bugs.
 static const std::chrono::seconds DefaultFutureTimeout =
     std::chrono::seconds(10);
 
 static bool diagsContainErrors(ArrayRef<DiagWithFixIts> Diagnostics) {
   for (const auto &DiagAndFixIts : Diagnostics) {
     // FIXME: severities returned by clangd should have a descriptive
#endif
   std::string parseSourceAndDumpAST(
       PathRef SourceFileRelPath, StringRef SourceContents,
       std::vector<std::pair<PathRef, StringRef>> ExtraFiles = {},
       bool ExpectErrors = false) {
     MockFSProvider FS;
     ErrorCheckingDiagConsumer DiagConsumer;
     MockCompilationDatabase CDB(/*AddFreestandingFlag=*/true);
     ClangdServer Server(CDB, DiagConsumer, FS, getDefaultAsyncThreadsCount(),
-                        /*SnippetCompletions=*/false,
+                        clangd::CodeCompleteOptions(),
                         EmptyLogger::getInstance());
     for (const auto &FileWithContents : ExtraFiles)
       FS.Files[getVirtualTestFilePath(FileWithContents.first)] =
           FileWithContents.second;
 
     auto SourceFilename = getVirtualTestFilePath(SourceFileRelPath);
 
     FS.ExpectedFile = SourceFilename;
parseSourceAndDumpAST("foo.cpp", SourceContents, {{"foo.h", "int a;"}},
                         /*ExpectErrors=*/false);
 }
 
 TEST_F(ClangdVFSTest, Reparse) {
   MockFSProvider FS;
   ErrorCheckingDiagConsumer DiagConsumer;
   MockCompilationDatabase CDB(/*AddFreestandingFlag=*/true);
   ClangdServer Server(CDB, DiagConsumer, FS, getDefaultAsyncThreadsCount(),
-                      /*SnippetCompletions=*/false, EmptyLogger::getInstance());
+                      clangd::CodeCompleteOptions(),
+                      EmptyLogger::getInstance());
 
   const auto SourceContents = R"cpp(
 #include "foo.h"
 int b = a;
 )cpp";
 
   auto FooCpp = getVirtualTestFilePath("foo.cpp");
   auto FooH = getVirtualTestFilePath("foo.h");

 }
 
 TEST_F(ClangdVFSTest, ReparseOnHeaderChange) {
   MockFSProvider FS;
   ErrorCheckingDiagConsumer DiagConsumer;
   MockCompilationDatabase CDB(/*AddFreestandingFlag=*/true);
 
   ClangdServer Server(CDB, DiagConsumer, FS, getDefaultAsyncThreadsCount(),
-                      /*SnippetCompletions=*/false, EmptyLogger::getInstance());
+                      clangd::CodeCompleteOptions(),
+                      EmptyLogger::getInstance());
 
   const auto SourceContents = R"cpp(
 #include "foo.h"
 int b = a;
 )cpp";
 
   auto FooCpp = getVirtualTestFilePath("foo.cpp");
   auto FooH = getVirtualTestFilePath("foo.h");

 }
 
 TEST_F(ClangdVFSTest, CheckVersions) {
   MockFSProvider FS;
   ErrorCheckingDiagConsumer DiagConsumer;
   MockCompilationDatabase CDB(/*AddFreestandingFlag=*/true);
   // Run ClangdServer synchronously.
   ClangdServer Server(CDB, DiagConsumer, FS,
-                      /*AsyncThreadsCount=*/0, /*SnippetCompletions=*/false,
+                      /*AsyncThreadsCount=*/0, clangd::CodeCompleteOptions(),
                       EmptyLogger::getInstance());
 
   auto FooCpp = getVirtualTestFilePath("foo.cpp");
   const auto SourceContents = "int a;";
   FS.Files[FooCpp] = SourceContents;
   FS.ExpectedFile = FooCpp;
 
   // No need to sync reparses, because requests are processed on the calling
TEST_F(ClangdVFSTest, SearchLibDir) {
   ErrorCheckingDiagConsumer DiagConsumer;
   MockCompilationDatabase CDB(/*AddFreestandingFlag=*/true);
   CDB.ExtraClangFlags.insert(CDB.ExtraClangFlags.end(),
                              {"-xc++", "-target", "x86_64-linux-unknown",
                               "-m64", "--gcc-toolchain=/randomusr",
                               "-stdlib=libstdc++"});
   // Run ClangdServer synchronously.
   ClangdServer Server(CDB, DiagConsumer, FS,
-                      /*AsyncThreadsCount=*/0, /*SnippetCompletions=*/false,
+                      /*AsyncThreadsCount=*/0, clangd::CodeCompleteOptions(),
                       EmptyLogger::getInstance());
 
   // Just a random gcc version string
   SmallString<8> Version("4.9.3");
 
   // A lib dir for gcc installation
   SmallString<64> LibDir("/randomusr/lib/gcc/x86_64-linux-gnu");
   llvm::sys::path::append(LibDir, Version);

 }
 #endif // LLVM_ON_UNIX
 
 TEST_F(ClangdVFSTest, ForceReparseCompileCommand) {
   MockFSProvider FS;
   ErrorCheckingDiagConsumer DiagConsumer;
   MockCompilationDatabase CDB(/*AddFreestandingFlag=*/true);
   ClangdServer Server(CDB, DiagConsumer, FS,
-                      /*AsyncThreadsCount=*/0, /*SnippetCompletions=*/false,
+                      /*AsyncThreadsCount=*/0, clangd::CodeCompleteOptions(),
                       EmptyLogger::getInstance());
   // No need to sync reparses, because reparses are performed on the calling
   // thread to true.
 
   auto FooCpp = getVirtualTestFilePath("foo.cpp");
   const auto SourceContents1 = R"cpp(
 template <class T>
 struct foo { T x; };
)cpp";
   Server.addDocument(FooCpp, SourceContents1);
   EXPECT_FALSE(DiagConsumer.hadErrorInLastDiags());
   Server.addDocument(FooCpp, SourceContents2);
   EXPECT_FALSE(DiagConsumer.hadErrorInLastDiags());
 }
 
 class ClangdCompletionTest : public ClangdVFSTest {
 protected:
-  bool ContainsItem(std::vector<CompletionItem> const &Items, StringRef Name) {
+  template <class Predicate>
+  bool ContainsItemPred(std::vector<CompletionItem> const &Items,
+                        Predicate Pred) {
     for (const auto &Item : Items) {
-      if (Item.insertText == Name)
+      if (Pred(Item))
         return true;
     }
     return false;
   }
+
+  bool ContainsItem(std::vector<CompletionItem> const &Items, StringRef Name) {
+    return ContainsItemPred(Items, [Name](clangd::CompletionItem Item) {
+      return Item.insertText == Name;
+    });
+    return false;
+  }
 };
 
 TEST_F(ClangdCompletionTest, CheckContentsOverride) {
   MockFSProvider FS;
   ErrorCheckingDiagConsumer DiagConsumer;
   MockCompilationDatabase CDB(/*AddFreestandingFlag=*/true);
 
   ClangdServer Server(CDB, DiagConsumer, FS, getDefaultAsyncThreadsCount(),
-                      /*SnippetCompletions=*/false, EmptyLogger::getInstance());
+                      clangd::CodeCompleteOptions(),
+                      EmptyLogger::getInstance());
 
   auto FooCpp = getVirtualTestFilePath("foo.cpp");
   const auto SourceContents = R"cpp(
 int aba;
 int b =   ;
 )cpp";
 
   const auto OverridenSourceContents = R"cpp(
)cpp";
   {
     auto CodeCompletionResults2 =
         Server.codeComplete(FooCpp, CompletePos, None).get().Value;
     EXPECT_TRUE(ContainsItem(CodeCompletionResults2, "aba"));
     EXPECT_FALSE(ContainsItem(CodeCompletionResults2, "cbc"));
   }
 }
 
+TEST_F(ClangdCompletionTest, CompletionOptions) {
+  MockFSProvider FS;
+  ErrorCheckingDiagConsumer DiagConsumer;
+  MockCompilationDatabase CDB(/*AddFreestandingFlag=*/true);
+  CDB.ExtraClangFlags.push_back("-xc++");
+
+  auto FooCpp = getVirtualTestFilePath("foo.cpp");
+  FS.Files[FooCpp] = "";
+  FS.ExpectedFile = FooCpp;
+
+  const auto GlobalCompletionSourceTemplate = R"cpp(
+#define MACRO X
+
+int global_var;
+int global_func();
+
+struct GlobalClass {};
+
+struct ClassWithMembers {
+  /// Doc for method.
+  int method();
+};
+
+int test() {
+  struct LocalClass {};
+
+  /// Doc for local_var.
+  int local_var;
+
+  {complete}
+}
+)cpp";
+  const auto MemberCompletionSourceTemplate = R"cpp(
+#define MACRO X
+
+int global_var;
+
+int global_func();
+
+struct GlobalClass {};
+
+struct ClassWithMembers {
+  /// Doc for method.
+  int method();
+
+  int field;
+};
+
+int test() {
+  struct LocalClass {};
+
+  /// Doc for local_var.
+  int local_var;
+
+  ClassWithMembers().{complete}
+}
+)cpp";
+
+  StringWithPos GlobalCompletion =
+      parseTextMarker(GlobalCompletionSourceTemplate, "complete");
+  StringWithPos MemberCompletion =
+      parseTextMarker(MemberCompletionSourceTemplate, "complete");
+
+  auto TestWithOpts = [&](clangd::CodeCompleteOptions Opts) {
+    ClangdServer Server(CDB, DiagConsumer, FS, getDefaultAsyncThreadsCount(),
+                        Opts, EmptyLogger::getInstance());
+    // No need to sync reparses here as there are no asserts on diagnostics (or
+    // other async operations).
+    Server.addDocument(FooCpp, GlobalCompletion.Text);
+
+    StringRef MethodItemText = Opts.EnableSnippets ? "method()" : "method";
+    StringRef GlobalFuncItemText =
+        Opts.EnableSnippets ? "global_func()" : "global_func";
+
+    /// For after-dot completion we must always get consistent results.
+    {
+      auto Results = Server
+                         .codeComplete(FooCpp, MemberCompletion.MarkerPos,
+                                       StringRef(MemberCompletion.Text))
+                         .get()
+                         .Value;
+
+      // Class members. The only items that must be present in after-dor
+      // completion.
+      EXPECT_TRUE(ContainsItem(Results, MethodItemText));
+      EXPECT_TRUE(ContainsItem(Results, "field"));
+      // Global items.
+      EXPECT_FALSE(ContainsItem(Results, "global_var"));
+      EXPECT_FALSE(ContainsItem(Results, GlobalFuncItemText));
+      EXPECT_FALSE(ContainsItem(Results, "GlobalClass"));
+      // A macro.
+      EXPECT_FALSE(ContainsItem(Results, "MACRO"));
+      // Local items.
+      EXPECT_FALSE(ContainsItem(Results, "LocalClass"));
+      // There should be no code patterns (aka snippets) in after-dot
+      // completion. At least there aren't any we're aware of.
+      EXPECT_FALSE(
+          ContainsItemPred(Results, [](clangd::CompletionItem const &Item) {
+            return Item.kind == clangd::CompletionItemKind::Snippet;
+          }));
+      // Check documentation.
+      EXPECT_EQ(
+          Opts.IncludeBriefComments,
+          ContainsItemPred(Results, [](clangd::CompletionItem const &Item) {
+            return !Item.documentation.empty();
+          }));
+    }
+    // Global completion differs based on the Opts that were passed.
+    {
+      auto Results = Server
+                         .codeComplete(FooCpp, GlobalCompletion.MarkerPos,
+                                       StringRef(GlobalCompletion.Text))
+                         .get()
+                         .Value;
+
+      // Class members. Should never be present in global completions.
+      EXPECT_FALSE(ContainsItem(Results, MethodItemText));
+      EXPECT_FALSE(ContainsItem(Results, "field"));
+      // Global items.
+      EXPECT_EQ(ContainsItem(Results, "global_var"), Opts.IncludeGlobals);
+      EXPECT_EQ(ContainsItem(Results, GlobalFuncItemText), Opts.IncludeGlobals);
+      EXPECT_EQ(ContainsItem(Results, "GlobalClass"), Opts.IncludeGlobals);
+      // A macro.
+      EXPECT_EQ(ContainsItem(Results, "MACRO"), Opts.IncludeMacros);
+      // Local items. Must be present always.
+      EXPECT_TRUE(ContainsItem(Results, "local_var"));
+      EXPECT_TRUE(ContainsItem(Results, "LocalClass"));
+      // FIXME(ibiryukov): snippets have wrong Item.kind now. Reenable this
+      // check after https://reviews.llvm.org/D38720 makes it in.
+      //
+      // Code patterns (aka snippets).
+      // EXPECT_EQ(
+      //     Opts.IncludeCodePatterns && Opts.EnableSnippets,
+      //     ContainsItemPred(Results, [](clangd::CompletionItem const &Item) {
+      //       return Item.kind == clangd::CompletionItemKind::Snippet;
+      //     }));
+
+      // Check documentation.
+      EXPECT_EQ(
+          Opts.IncludeBriefComments,
+          ContainsItemPred(Results, [](clangd::CompletionItem const &Item) {
+            return !Item.documentation.empty();
+          }));
+    }
+    // FIXME(ibiryukov): test Opts.IncludeBriefComments and
+    // Opts.IncludeCodePatterns.
+  };
+
+  for (bool IncludeMacros : {true, false})
+    for (bool IncludeGlobals : {true, false})
+      for (bool IncludeBriefComments : {true, false})
+        for (bool EnableSnippets : {true, false})
+          for (bool IncludeCodePatterns : {true, false}) {
+            TestWithOpts(clangd::CodeCompleteOptions(
+                /*EnableSnippets=*/EnableSnippets,
+                /*IncludeCodePatterns=*/IncludeCodePatterns,
+                /*IncludeMacros=*/IncludeMacros,
+                /*IncludeGlobals=*/IncludeGlobals,
+                /*IncludeBriefComments=*/IncludeBriefComments));
+          }
+}
+
 class ClangdThreadingTest : public ClangdVFSTest {};
 
 TEST_F(ClangdThreadingTest, StressTest) {
   // Without 'static' clang gives an error for a usage inside TestDiagConsumer.
   static const unsigned FilesCount = 5;
   const unsigned RequestsCount = 500;
   // Blocking requests wait for the parsing to complete, they slow down the test
   // dramatically, so they are issued rarely. Each
)cpp";
   ReqStats.reserve(FilesCount);
   for (unsigned FileIndex = 0; FileIndex < FilesCount; ++FileIndex)
     ReqStats.emplace_back();
 
   TestDiagConsumer DiagConsumer;
   {
     MockCompilationDatabase CDB(/*AddFreestandingFlag=*/true);
     ClangdServer Server(CDB, DiagConsumer, FS, getDefaultAsyncThreadsCount(),
-                        /*SnippetCompletions=*/false,
+                        clangd::CodeCompleteOptions(),
                         EmptyLogger::getInstance());
 
     // Prepare some random distributions for the test.
     std::random_device RandGen;
 
     std::uniform_int_distribution<unsigned> FileIndexDist(0, FilesCount - 1);
     // Pass a text that contains compiler errors to addDocument in about 20% of
     // all requests.

 }
 
 TEST_F(ClangdVFSTest, CheckSourceHeaderSwitch) {
   MockFSProvider FS;
   ErrorCheckingDiagConsumer DiagConsumer;
   MockCompilationDatabase CDB(/*AddFreestandingFlag=*/true);
 
   ClangdServer Server(CDB, DiagConsumer, FS, getDefaultAsyncThreadsCount(),
-                      /*SnippetCompletions=*/false, EmptyLogger::getInstance());
+                      clangd::CodeCompleteOptions(),
+                      EmptyLogger::getInstance());
 
   auto SourceContents = R"cpp(
   #include "foo.h"
   int b = a;
   )cpp";
 
   auto FooCpp = getVirtualTestFilePath("foo.cpp");
   auto FooH = getVirtualTestFilePath("foo.h");
)cpp";
 
   std::promise<void> StartSecondReparsePromise;
   std::future<void> StartSecondReparse = StartSecondReparsePromise.get_future();
 
   NoConcurrentAccessDiagConsumer DiagConsumer(
       std::move(StartSecondReparsePromise));
 
   MockCompilationDatabase CDB(/*AddFreestandingFlag=*/true);
-  ClangdServer Server(CDB, DiagConsumer, FS, 4, /*SnippetCompletions=*/false,
+  ClangdServer Server(CDB, DiagConsumer, FS, 4, clangd::CodeCompleteOptions(),
                       EmptyLogger::getInstance());
   Server.addDocument(FooCpp, SourceContentsWithErrors);
   StartSecondReparse.wait();
 
   auto Future = Server.addDocument(FooCpp, SourceContentsWithoutErrors);
   Future.wait();
 }
 
 } // namespace clangd
 } // namespace clang