[clangd] Catch an unchecked "Expected<T>" in HeaderSourceSwitch.

[hokein]

Summary

Also fixes a potential user-after-scope issue of "Path".

[kadircet]

LGTM

[merge_guards_bot]

Bulid results are available at http://results.llvm-merge-guard.org/Phabricator-13

See http://jenkins.llvm-merge-guard.org/job/Phabricator/13/ for more details.

clang-tools-extra/trunk/clangd/ClangdLSPServer.cpp

void ClangdLSPServer::onSwitchSourceHeader(
     Callback<llvm::Optional<URIForFile>> Reply) {
   Server->switchSourceHeader(
       Params.uri.file(),
       [Reply = std::move(Reply),
        Params](llvm::Expected<llvm::Optional<clangd::Path>> Path) mutable {
         if (!Path)
           return Reply(Path.takeError());
         if (*Path)
-          Reply(URIForFile::canonicalize(**Path, Params.uri.file()));
+          return Reply(URIForFile::canonicalize(**Path, Params.uri.file()));
         return Reply(llvm::None);
       });
 }
 
 void ClangdLSPServer::onDocumentHighlight(
     const TextDocumentPositionParams &Params,
     Callback<std::vector<DocumentHighlight>> Reply) {
   Server->findDocumentHighlights(Params.textDocument.uri.file(),

clang-tools-extra/trunk/clangd/ClangdServer.cpp

void ClangdServer::switchSourceHeader(
   //  1) use the file-only heuristic, it requires some IO but it is much
   //     faster than building AST, but it only works when .h/.cc files are in
   //     the same directory.
   //  2) if 1) fails, we use the AST&Index approach, it is slower but supports
   //     different code layout.
   if (auto CorrespondingFile =
           getCorrespondingHeaderOrSource(Path, FSProvider.getFileSystem()))
     return CB(std::move(CorrespondingFile));
-  auto Action = [Path, CB = std::move(CB),
+  auto Action = [Path = Path.str(), CB = std::move(CB),
                  this](llvm::Expected<InputsAndAST> InpAST) mutable {
     if (!InpAST)
       return CB(InpAST.takeError());
     CB(getCorrespondingHeaderOrSource(Path, InpAST->AST, Index));
   };
   WorkScheduler.runWithAST("SwitchHeaderSource", Path, std::move(Action));
 }
 

clang-tools-extra/trunk/clangd/HeaderSourceSwitch.cpp

for (const auto *D : getIndexableLocalDecls(AST)) {
     if (auto ID = getSymbolID(D))
       Request.IDs.insert(*ID);
   }
   llvm::StringMap<int> Candidates; // Target path => score.
   auto AwardTarget = [&](const char *TargetURI) {
     if (auto TargetPath = URI::resolve(TargetURI, OriginalFile)) {
       if (*TargetPath != OriginalFile) // exclude the original file.
         ++Candidates[*TargetPath];
-    };
+    } else {
+      elog("Failed to resolve URI {0}: {1}", TargetURI, TargetPath.takeError());
+    }
   };
   // If we switch from a header, we are looking for the implementation
   // file, so we use the definition loc; otherwise we look for the header file,
   // we use the decl loc;
   //
   // For each symbol in the original file, we get its target location (decl or
   // def) from the index, then award that target file.
   bool IsHeader = AST.getASTContext().getLangOpts().IsHeaderFile;

clang-tools-extra/trunk/clangd/unittests/HeaderSourceSwitchTests.cpp

TEST(HeaderSourceSwitchTest, FromHeaderToSource) {
   Testing.Filename = "a.cpp";
   Testing.Code = "void A_Sym1() {};";
   for (auto &Sym : Testing.headerSymbols())
     AllSymbols.insert(Sym);
 
   Testing.HeaderCode = R"cpp(
   void B_Sym1();
   void B_Sym2();
+  void B_Sym3_NoDef();
   )cpp";
   Testing.Filename = "b.cpp";
   Testing.Code = R"cpp(
   void B_Sym1() {}
   void B_Sym2() {}
   )cpp";
   for (auto &Sym : Testing.headerSymbols())
     AllSymbols.insert(Sym);
llvm::Optional<std::string> ExpectedSource;
        )cpp",
        testPath("b.cpp")},
       {R"cpp(
          // a.cpp and b.cpp have same scope, but a.cpp because "a.cpp" < "b.cpp".
          void A_Sym1();
          void B_Sym1();
        )cpp",
        testPath("a.cpp")},
+
+       {R"cpp(
+          // We don't have definition in the index, so stay in the header.
+          void B_Sym3_NoDef();
+       )cpp",
+       None},
   };
   for (const auto &Case : TestCases) {
     TestTU TU = TestTU::withCode(Case.HeaderCode);
     TU.Filename = "TestTU.h";
     TU.ExtraArgs.push_back("-xc++-header"); // inform clang this is a header.
     auto HeaderAST = TU.build();
     EXPECT_EQ(Case.ExpectedSource,
               getCorrespondingHeaderOrSource(testPath(TU.Filename), HeaderAST,