[clangd] Command line arg to specify compile_commands.json path

[Nebiroth]

Summary

Adds compileCommands command line argument to specify an absolute path directly to the requested compile_commands.json for flags.

[ilya-biryukov]

clangd/GlobalCompilationDatabase.cpp

29

Please place this flag in ClangdMain.cpp.

29

Following naming convention for flags, this should be compile-commands.
Given the semantics of the flag, maybe it's better to name it compile-commands-dir?

30

A description is somewhat vague. What is the intention of this flag?

• Always look for compile_commands.json only inside specified directory?
• First look inside specified directory, then proceed as normal (i.e. looking at the parent paths of each source file)?

It looks like the code also looks at the parent directories of compile-commands. Is that the original intention? Maybe consider making it look only inside the directory itself and not its parents?

49

Incidental whitespace change?

93

Please check command arguments for validity in main().
What is the purpose of find_first_of("/")? Checking for absolute paths? If yes, you could use llvm::sys::path::is_absolute.

101

Naming: local variables should be UpperCamelCase

103

Maybe rewrite to avoid extra nesting?

For example,

if (!badPath) {
    auto result = CDB.get();
    CompilationDatabases.insert(std::make_pair(File, std::move(CDB)));
    return result;
}
// Proceed as before...

103

Maybe extract a function from the for loop body instead of copying it here?
Could be named tryLoadDatabaseFromPath.

115

Please consider removing this code duplication by extracting a function from the loop body (also see my previous comment).

[ilya-biryukov]

BTW, if you're only looking for providing extra compilation flags for some files, you could use an extension to LSP that is already in clangd source tree. (See tests from https://reviews.llvm.org/D34947 for more details).
But your change is also useful, as it allows to override the whole compilation database. Would be interested in this change to land regardless of whether the extra flags thing suits you well.

[krasimir]

clangd/GlobalCompilationDatabase.cpp

93

Please make CompileCommands a member variable and pass it through the constructor of DirectoryBasedGlobalCompilationDatabase. This is more flexible and, among other things, allows for easier unit testing.

98

LLVM style uses no braces for single statement if's.

[Nebiroth]

Added function to avoid code reuse and extra nesting.

[ilya-biryukov]

See my comments.
Could you also clang-format the code please?

clangd/ClangdServer.cpp

150

Could you pass llvm::Optional<Path> instead (Path is just a descriptive typedef that we use in place of std::string) and check for empty string in main()?

clangd/GlobalCompilationDatabase.cpp

14

There are definitely unneeded includes here. Remove most of them and leave only the required ones?

30

How about chaning semantics of the flag to only look inside "--compile-commands-dir" and not its parent paths?
I think it makes the behavior much less surprising. The whole point of looking in parent paths is that typically compile_commands.json is put inside the project root.

The flag that you propose seems to have a different purpose of providing clangd with custom compilation flags.

93

Let's simply lookup only inside CompileCommandsDir if it was set.
Otherwise, fallback into looking at parent_paths of the file.

clangd/GlobalCompilationDatabase.h

38

GlobalCompilationDatabase is an interface class and is designed specifically to not contain any fields.
Could you please do the following?

• Move this field into DirectoryBasedGlobalCompilationDatabase.
• Make it private and initialize it in constructor.

clangd/tool/ClangdMain.cpp

29

Could you use descriptive Path typedef instead of std::string here and in other places?

30

Maybe rename this (and other occurences) to CompileCommandsDir?

43

• CompileCommands is empty by default, don't show the error message in that case.
• If value of CompileCommands is not absolute or the path does not exist, set CompileCommands to empty string after reporting an error.

44

Maybe rephrase the message a little bit, mentioning the name of the flag. Something like:
"Value of --compile-commands-dir must be an absolute path. The argument will be ignored."

[Nebiroth]

Modified CompileCommandsDir to only look in the specified path if the value is set.
Moved CompileCommandsDir field to DirectoryBasedGlobalCompilationDatabase class.
Minor refactoring.

[ilya-biryukov]

Could you also clang-format the code please?

clangd/GlobalCompilationDatabase.cpp

95

Why do we use parent_path of CompilerCommandsDir, not CompilerCommandsDir itself?
Why do we need to reassign the File parameter?

Maybe simply do
auto CDB = tryLoadDatabaseFromPath(CompileCommandsDir, Error)?

100

Code style: don't use else after return.
See https://llvm.org/docs/CodingStandards.html#don-t-use-else-after-a-return

clangd/tool/ClangdMain.cpp

41

Replace --CompileCommandsDir with --compile-commands-dir.

[ilya-biryukov]

clangd/ClangdServer.cpp

150

Remove CompileCommandsDir from ClangdServer parameters, it is hanlded by DirectoryBasedGlobalCompilationDatabase.

clangd/GlobalCompilationDatabase.cpp

70

Restore this assertion, move it to tryLoadDatabaseFromPath.

92–101

Maybe move this local variable into tryLoadDatabaseFromPath and remove Error parameter from tryLoadDatabaseFromPath?
Please make sure to move the TODO about logging into tryLoadDatabaseFromPath as well.

clangd/GlobalCompilationDatabase.h

49

Rename parameter to CompileCommandsDir, change type to llvm::Optional<Path>.

53

Make this function private.

clangd/tool/ClangdMain.cpp

46

Use Out.log() instead of Logs << for consistency with other logging code.

52

Maybe also rephrase to mention the name of the flag? Something like:
"Path specified by --compile-commands-dir does not exist. The argument will be ignored.\n"

52

Accept llvm::Optional in ClangdLSPServer, pass llvm::None if CompileCommandsDir == "" here.

[Nebiroth]

Ran clang-format on modified files.
More minor refactoring.

[klimek]

clangd/GlobalCompilationDatabase.cpp

128–130

Isn't that the same as "return CDB"?

[Nebiroth]

Simpilified a pointer return value.

[ilya-biryukov]

clangd/GlobalCompilationDatabase.cpp

104

Parentheses seem redundant.

107

Code style: local variable are UpperCamelCase

126

Even better: return tryLoadDatabaseFromPath(CompileCommandsDir);

clangd/GlobalCompilationDatabase.h

51

getValue() will fail if NewCompileCommandsDir does not have a value.
The original suggestion was to change type of the field 'CompileCommandsDir` to llvm::Optional<Path> and check if Optional has a value instead of checking for empty string.

57

Could you please move this to other fields?

Mixing functions and fields is a bit confusing.

clangd/tool/ClangdMain.cpp

50

Could you please move this out of the logic that validates CompileCommandsDir parameter?
It's very easy to miss while reading the code. Probably ok to put it right after JSONOutput Out(... line

52

Message does not mention that path does not exist. Probably incidental.

[Nebiroth]

Fixed a few comments.
Rebased on latest clangd version.

[ilya-biryukov]

All lit test for clangd are currently failing if I apply your change.
Generally, please run make check-clang-tools to make sure your changes do not introduce any regressions.

The tests are failing because when --compile-commands-dir is not specified clangd now shows the cmd arg validation errors ("path not absolute", "path does not exist").

clangd/tool/ClangdMain.cpp

57

The code doing command line argument validation shows errors using llvm::errs() and not Out.log(). Could you do the same for consistency?

Also, could you put your new code that does argument validation right after the previous checks (to line 65)? So that we have a clear structure in the code:

/// Validate command line arguments.
...

/// Initialize and run ClangdLSPServer.
...

[Nebiroth]

More consistent logging in clangdmain.
Restructured argument checking in ClangdMain
Fixed empty compile-commands-dir triggering error messages.
Fixed failing standard tests.

[ilya-biryukov]

Could you please run clang-format on every submission?

clangd/GlobalCompilationDatabase.cpp

127

Is this some kind of accidental change? Why do we need to assign "/" to CompileCommandsDir?

clangd/tool/ClangdMain.cpp

20

We certainly don't need that include.

57

This should be something like:

if (CompileCommandsDir.empty()) {
  //...
  CompileCommandsDirPath = llvm::None;
} else if (!is_absolute(...)) {
  //....
  CompileCommandsDirPath = llvm::None;
} else if (!exists(...)) {
  // ....
  CompileCommandsDirPath = llvm::None;
} else {
  CompileCommandsDirPath = CompileCommandsDir;
}

• It will have less nesting, therefore making code more readable.
• It will fix an error in the current implementation. (Currently, exists check will run on an empty string if -compile-commands-dir is not an absolute path).

[Nebiroth]

Fixed inverted compile_commands check logic that made tests fail.
More readable command arg checks.

[malaperle]

clangd/tool/ClangdMain.cpp

20

William, did you perhaps miss this comment? I don't think unistd.h makes sense here.

[Nebiroth]

clangd/tool/ClangdMain.cpp

20

I indeed missed it.

[ilya-biryukov]

clangd/GlobalCompilationDatabase.cpp

103–104

Why remove this FIXME?

clangd/tool/ClangdMain.cpp

65

NIT: maybe join this with previous line?

68

NIT: don't mix branches with and without {}. Simply use {} on all branches in that case.

[Nebiroth]

Fixed missed comments and suggstions.

[ilya-biryukov]

It seems some changes were be lost while merging with head.

clangd/GlobalCompilationDatabase.cpp

93

Maybe move Error closer to its usage (line 84: auto CDB = tooling::CompilationDatabase::loadFromDirectory ...)?

97–99

Please restore this logging statement.

112

Please remove this FIXME, it is already deleted in head.

[Nebiroth]

Fixed changes that were lost while merging with head.

[ilya-biryukov]

clangd/GlobalCompilationDatabase.cpp

105

We should also log if we can't find compilation database in this code path.

113

This logging statement is misplaced, in the current HEAD it's outside of the loop.
(i.e. it should be in the getCompilationDatabase, not in tryLoadDatabaseFromPath).

Otherwise the output of clangd gets really spammy.

[Nebiroth]

Changed placement of logging instruction to reduce logging output.

[ilya-biryukov]

Thanks. LGTM modulo minor NIT (see other inline comment).
Do you need help to land this?

clangd/GlobalCompilationDatabase.cpp

112

Message should probably mention that's clangd was looking for compile commands in an overridden directory.

[Nebiroth]

Improved logging message when unable to find compilation database in specified overriden directory.

[ilya-biryukov]

Thanks for fixing the last comment.
Do you want me to land this for you?

clangd/GlobalCompilationDatabase.cpp

113

NIT: missing a space at the start of "in overriden...". Otherwise filename will be concatenated with "in"

[Nebiroth]

In D37150#885749, @ilya-biryukov wrote:

Thanks for fixing the last comment.
Do you want me to land this for you?

Yes please!

[ilya-biryukov]

Did a minor rename and added a few std::moves before submitting. Was not worth another round of code review.

clangd/ClangdLSPServer.h

 namespace clangd {
 
 class JSONOutput;
 
 /// This class provides implementation of an LSP server, glueing the JSON
 /// dispatch and ClangdServer together.
 class ClangdLSPServer {
 public:
-  ClangdLSPServer(JSONOutput &Out, bool RunSynchronously);
+  ClangdLSPServer(JSONOutput &Out, bool RunSynchronously, std::string CompileCommands);
 
   /// Run LSP server loop, receiving input for it from \p In. \p In must be
   /// opened in binary mode. Output will be written using Out variable passed to
   /// class constructor. This method must not be executed more than once for
   /// each instance of ClangdLSPServer.
   void run(std::istream &In);
 
 private:

clangd/ClangdLSPServer.cpp

void ClangdLSPServer::LSPProtocolCallbacks::onGoToDefinition(
   }
   if (!Locations.empty())
     Locations.pop_back();
   Out.writeMessage(
       R"({"jsonrpc":"2.0","id":)" + ID.str() +
       R"(,"result":[)" + Locations + R"(]})");
 }
 
-ClangdLSPServer::ClangdLSPServer(JSONOutput &Out, bool RunSynchronously)
+ClangdLSPServer::ClangdLSPServer(JSONOutput &Out, bool RunSynchronously, std::string CompileCommands)
     : Out(Out), DiagConsumer(*this),
-      Server(CDB, DiagConsumer, FSProvider, RunSynchronously) {}
+      Server(CDB, DiagConsumer, FSProvider, RunSynchronously, CompileCommands) {}
 
 void ClangdLSPServer::run(std::istream &In) {
   assert(!IsDone && "Run was called before");
 
   // Set up JSONRPCDispatcher.
   LSPProtocolCallbacks Callbacks(*this);
   JSONRPCDispatcher Dispatcher(llvm::make_unique<Handler>(Out));
   regiterCallbackHandlers(Dispatcher, Out, Callbacks);

clangd/ClangdServer.h

public:
   /// completion/diagnostics also include a tag, that \p FSProvider returns
   /// along with the vfs::FileSystem.
   /// When \p ResourceDir is set, it will be used to search for internal headers
   /// (overriding defaults and -resource-dir compiler flag, if set). If \p
   /// ResourceDir is None, ClangdServer will attempt to set it to a standard
   /// location, obtained via CompilerInvocation::GetResourcePath.
   ClangdServer(GlobalCompilationDatabase &CDB,
                DiagnosticsConsumer &DiagConsumer,
-               FileSystemProvider &FSProvider, bool RunSynchronously,
+               FileSystemProvider &FSProvider, bool RunSynchronously, std::string CompileCommands, 
                llvm::Optional<StringRef> ResourceDir = llvm::None);
 
   /// 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
   /// constructor will receive onDiagnosticsReady callback.
   void addDocument(PathRef File, StringRef Contents);
   /// Remove \p File from list of tracked files, schedule a request to free

clangd/ClangdServer.cpp

void ClangdScheduler::addToEnd(std::function<void()> Request) {
   }
   RequestCV.notify_one();
 }
 
 ClangdServer::ClangdServer(GlobalCompilationDatabase &CDB,
                            DiagnosticsConsumer &DiagConsumer,
                            FileSystemProvider &FSProvider,
                            bool RunSynchronously,
+                           std::string CompileCommands,
                            llvm::Optional<StringRef> ResourceDir)
     : CDB(CDB), DiagConsumer(DiagConsumer), FSProvider(FSProvider),
       ResourceDir(ResourceDir ? ResourceDir->str() : getStandardResourceDir()),
       PCHs(std::make_shared<PCHContainerOperations>()),
-      WorkScheduler(RunSynchronously) {}
+      WorkScheduler(RunSynchronously) {
+
+        if (CompileCommands != "")
+          CDB.CompileCommands = CompileCommands;
+      }
 
 void ClangdServer::addDocument(PathRef File, StringRef Contents) {
   DocVersion Version = DraftMgr.updateDraft(File, Contents);
   Path FileStr = File;
   WorkScheduler.addToFront([this, FileStr, Version]() {
     auto FileContents = DraftMgr.getDraft(FileStr);
     if (FileContents.Version != Version)
       return; // This request is outdated, do nothing

clangd/GlobalCompilationDatabase.h

 /// Returns a default compile command to use for \p File.
 tooling::CompileCommand getDefaultCompileCommand(PathRef File);
 
 /// Provides compilation arguments used for building ClangdUnit.
 class GlobalCompilationDatabase {
 public:
   virtual ~GlobalCompilationDatabase() = default;
 
-  virtual std::vector<tooling::CompileCommand>
+  virtual std::vector<tooling::CompileCommand>  
   getCompileCommands(PathRef File) = 0;
+  std::string CompileCommands;  
 
   /// FIXME(ibiryukov): add facilities to track changes to compilation flags of
   /// existing targets.
 };
 
 /// Gets compile args from tooling::CompilationDatabases built for parent
 /// directories.
 class DirectoryBasedGlobalCompilationDatabase
     : public GlobalCompilationDatabase {
 public:
   std::vector<tooling::CompileCommand>
   getCompileCommands(PathRef File) override;
 
   void setExtraFlagsForFile(PathRef File, std::vector<std::string> ExtraFlags);
+  tooling::CompilationDatabase *tryLoadDatabaseFromPath(PathRef File, std::string &Error);
 
 private:
   tooling::CompilationDatabase *getCompilationDatabase(PathRef File);
 
   std::mutex Mutex;
   /// Caches compilation databases loaded from directories(keys are
   /// directories).
   llvm::StringMap<std::unique_ptr<clang::tooling::CompilationDatabase>>
       CompilationDatabases;
 
   /// Stores extra flags per file.
   llvm::StringMap<std::vector<std::string>> ExtraFlagsForFile;
 };
 } // namespace clangd
 } // namespace clang
 
 #endif

clangd/GlobalCompilationDatabase.cpp

 //===--- GlobalCompilationDatabase.cpp --------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===---------------------------------------------------------------------===//
 
 #include "GlobalCompilationDatabase.h"
 #include "clang/Tooling/CompilationDatabase.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
+#include "llvm/ADT/Statistic.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Compiler.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/Format.h"
+#include "llvm/Support/ManagedStatic.h"
+#include "llvm/Support/Mutex.h"
+#include "llvm/Support/Timer.h"
+#include "llvm/Support/YAMLTraits.h"
 
 namespace clang {
 namespace clangd {
 
 static void addExtraFlags(tooling::CompileCommand &Command,
                           const std::vector<std::string> &ExtraFlags) {
   if (ExtraFlags.empty())
     return;
   assert(Command.CommandLine.size() >= 2 &&
          "Expected a command line containing at least 2 arguments, the "
          "compiler binary and the output file");
   // The last argument of CommandLine is the name of the input file.
   // Add ExtraFlags before it.
   auto It = Command.CommandLine.end();
   --It;
   Command.CommandLine.insert(It, ExtraFlags.begin(), ExtraFlags.end());
 }
 
 tooling::CompileCommand getDefaultCompileCommand(PathRef File) {
   std::vector<std::string> CommandLine{"clang", "-fsyntax-only", File.str()};
   return tooling::CompileCommand(llvm::sys::path::parent_path(File),
                                  llvm::sys::path::filename(File), CommandLine,
                                  /*Output=*/"");
 }
 
 std::vector<tooling::CompileCommand>
 DirectoryBasedGlobalCompilationDatabase::getCompileCommands(PathRef File) {
   std::vector<tooling::CompileCommand> Commands;
 
   auto CDB = getCompilationDatabase(File);
   if (CDB)
     Commands = CDB->getCompileCommands(File);
   if (Commands.empty())
     Commands.push_back(getDefaultCompileCommand(File));
 
   auto It = ExtraFlagsForFile.find(File);
   if (It != ExtraFlagsForFile.end()) {
     // Append the user-specified flags to the compile commands.
     for (tooling::CompileCommand &Command : Commands)
       addExtraFlags(Command, It->second);
   }
 
   return Commands;
 }
 
 void DirectoryBasedGlobalCompilationDatabase::setExtraFlagsForFile(
     PathRef File, std::vector<std::string> ExtraFlags) {
   ExtraFlagsForFile[File] = std::move(ExtraFlags);
 }
 
+tooling::CompilationDatabase * DirectoryBasedGlobalCompilationDatabase::tryLoadDatabaseFromPath(PathRef File, std::string &Error)
+{
+  auto CachedIt = CompilationDatabases.find(File);
+  if (CachedIt != CompilationDatabases.end())
+    return (CachedIt->second.get());
+  auto CDB = tooling::CompilationDatabase::loadFromDirectory(File, Error);
+  if (CDB && Error.empty())
+  {
+    auto result = CDB.get();
+    CompilationDatabases.insert(std::make_pair(File, std::move(CDB)));
+    return result;
+  }
+  return nullptr;
+}
+
 tooling::CompilationDatabase *
 DirectoryBasedGlobalCompilationDatabase::getCompilationDatabase(PathRef File) {
   std::lock_guard<std::mutex> Lock(Mutex);
-
-  namespace path = llvm::sys::path;
+  namespace path = llvm::sys::path; 
+  if (llvm::sys::fs::exists(CompileCommands))
+    File = CompileCommands;
+
+  std::string Error;
+  File = path::parent_path(File);
+  auto CDB = tryLoadDatabaseFromPath(File, Error);
   
-  assert((path::is_absolute(File, path::Style::posix) ||
-          path::is_absolute(File, path::Style::windows)) &&
-         "path must be absolute");
+  if (CDB && Error.empty())
+    return CDB;
 
   for (auto Path = path::parent_path(File); !Path.empty();
-       Path = path::parent_path(Path)) {
-
-    auto CachedIt = CompilationDatabases.find(Path);
-    if (CachedIt != CompilationDatabases.end())
-      return CachedIt->second.get();
-    std::string Error;
-    auto CDB = tooling::CompilationDatabase::loadFromDirectory(Path, Error);
-    if (!CDB) {
-      if (!Error.empty()) {
-        // FIXME(ibiryukov): logging
-        // Output.log("Error when trying to load compilation database from " +
-        //            Twine(Path) + ": " + Twine(Error) + "\n");
-      }
+     Error = "";  
+     CDB = tryLoadDatabaseFromPath(Path, Error);
+     if (!CDB || !Error.empty())       
        continue;
-    }
        
-    // FIXME(ibiryukov): Invalidate cached compilation databases on changes
-    auto result = CDB.get();
-    CompilationDatabases.insert(std::make_pair(Path, std::move(CDB)));
-    return result;
+  return CDB;
   }
 
   // FIXME(ibiryukov): logging
   // Output.log("Failed to find compilation database for " + Twine(File) +
   // "\n");
   return nullptr;
 }
 
 } // namespace clangd
 } // namespace clang

clangd/tool/ClangdMain.cpp

 //===--- ClangdMain.cpp - clangd server loop ------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ClangdLSPServer.h"
 #include "JSONRPCDispatcher.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Program.h"
+#include "llvm/Support/Path.h"
 
 #include <iostream>
 #include <memory>
 #include <string>
 
 using namespace clang;
 using namespace clang::clangd;
 
 static llvm::cl::opt<bool>
     RunSynchronously("run-synchronously",
                      llvm::cl::desc("parse on main thread"),
                      llvm::cl::init(false), llvm::cl::Hidden);
 
+static llvm::cl::opt<std::string>
+    CompileCommands("compile-commands-dir",
+                     llvm::cl::desc("Specify a path to look for compile_commands.json. If path is invalid, clangd will look in the current directory and parent paths of each source file.")); 
+
+
 int main(int argc, char *argv[]) {
   llvm::cl::ParseCommandLineOptions(argc, argv, "clangd");
 
   llvm::raw_ostream &Outs = llvm::outs();
   llvm::raw_ostream &Logs = llvm::errs();
   JSONOutput Out(Outs, Logs);
 
+  // If --compileCommands arg was invoked, check value and override default path.
+  namespace path = llvm::sys::path;
+  if (!llvm::sys::path::is_absolute(CompileCommands) || CompileCommands.empty())
+    Logs << "Path specified for compilation database must be absolute. Verifying current folder instead.";
+
+  if (!llvm::sys::fs::exists(CompileCommands))
+    Logs << "File does not exist. Verifying current folder instead.";
+
   // Change stdin to binary to not lose \r\n on windows.
   llvm::sys::ChangeStdinToBinary();
 
-  ClangdLSPServer LSPServer(Out, RunSynchronously);
+  ClangdLSPServer LSPServer(Out, RunSynchronously, CompileCommands);
   LSPServer.run(std::cin);
 }

test/clangd/hover.test

+# RUN: clangd -run-synchronously < %s | FileCheck %s
+# It is absolutely vital that this file has CRLF line endings.
+#
+Content-Length: 125
+
+{"jsonrpc":"2.0","id":0,"method":"initialize","params":{"processId":123,"rootPath":"clangd","capabilities":{},"trace":"off"}}
+
+Content-Length: 172
+
+{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"file:///main.cpp","languageId":"cpp","version":1,"text":"int main() {\nint a;\na;\n}\n"}}}
+
+Content-Length: 143
+
+{"jsonrpc":"2.0","id":1,"method":"textDocument/hover","params":{"textDocument":{"uri":"file:///main.cpp"},"position":{"line":0,"character":5}}}
+# Go to local variable
+# CHECK: {"jsonrpc":"2.0","id":1,"result":{"contents": {"language": "C++", "value": "int main() {\nint a;\na;\n}"}, "range": {"start": {"line": 0, "character": 0}, "end": {"line": 3, "character": 1}}}}
+
+Content-Length: 143
+
+{"jsonrpc":"2.0","id":1,"method":"textDocument/hover","params":{"textDocument":{"uri":"file:///main.cpp"},"position":{"line":1,"character":5}}}
+# Go to local variable
+# CHECK: {"jsonrpc":"2.0","id":1,"result":{"contents": {"language": "C++", "value": "int a"}, "range": {"start": {"line": 1, "character": 0}, "end": {"line": 1, "character": 5}}}}
+
+Content-Length: 44
+
+{"jsonrpc":"2.0","id":3,"method":"shutdown"}