[clangd] Bail out early if we are sure that the symbol is used outside of the file.

[hokein]

Summary

This would reduce the false positive when the static index is in an
unavailable state, e.g. background index is not finished.

clang-tools-extra/trunk/clangd/refactor/Rename.cpp

if (const auto *FD = llvm::dyn_cast<FunctionDecl>(&RenameDecl)) {
     if (FD->isOverloadedOperator())
       return ReasonToReject::UnsupportedSymbol;
   }
   auto &ASTCtx = RenameDecl.getASTContext();
   const auto &SM = ASTCtx.getSourceManager();
   bool MainFileIsHeader = ASTCtx.getLangOpts().IsHeaderFile;
   bool DeclaredInMainFile = isInsideMainFile(RenameDecl.getBeginLoc(), SM);
 
+  if (!DeclaredInMainFile)
+    // We are sure the symbol is used externally, bail out early.
+    return UsedOutsideFile;
+
   // If the symbol is declared in the main file (which is not a header), we
   // rename it.
-  if (DeclaredInMainFile && !MainFileIsHeader)
+  if (!MainFileIsHeader)
     return None;
 
   // Below are cases where the symbol is declared in the header.
   // If the symbol is function-local, we rename it.
   if (RenameDecl.getParentFunctionOrMethod())
     return None;
 
   if (!Index)

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

TEST(RenameTest, SingleFile) {
   }
 }
 
 TEST(RenameTest, Renameable) {
   struct Case {
     const char *Code;
     const char* ErrorMessage; // null if no error
     bool IsHeaderFile;
+    const SymbolIndex *Index;
   };
+  TestTU OtherFile = TestTU::withCode("Outside s; auto ss = &foo;");
+  const char *CommonHeader = R"cpp(
+    class Outside {};
+    void foo();
+  )cpp";
+  OtherFile.HeaderCode = CommonHeader;
+  OtherFile.Filename = "other.cc";
+  // The index has a "Outside" reference and a "foo" reference.
+  auto OtherFileIndex = OtherFile.index();
+  const SymbolIndex *Index = OtherFileIndex.get();
+
   const bool HeaderFile = true;
   Case Cases[] = {
       {R"cpp(// allow -- function-local
         void f(int [[Lo^cal]]) {
           [[Local]] = 2;
         }
       )cpp",
-       nullptr, HeaderFile},
+       nullptr, HeaderFile, Index},
 
       {R"cpp(// allow -- symbol is indexable and has no refs in index.
         void [[On^lyInThisFile]]();
       )cpp",
-       nullptr, HeaderFile},
+       nullptr, HeaderFile, Index},
 
       {R"cpp(// disallow -- symbol is indexable and has other refs in index.
         void f() {
           Out^side s;
         }
       )cpp",
-       "used outside main file", HeaderFile},
+       "used outside main file", HeaderFile, Index},
 
       {R"cpp(// disallow -- symbol is not indexable.
         namespace {
         class Unin^dexable {};
         }
       )cpp",
-       "not eligible for indexing", HeaderFile},
+       "not eligible for indexing", HeaderFile, Index},
 
       {R"cpp(// disallow -- namespace symbol isn't supported
         namespace fo^o {}
       )cpp",
-       "not a supported kind", HeaderFile},
+       "not a supported kind", HeaderFile, Index},
 
       {
           R"cpp(
          #define MACRO 1
          int s = MAC^RO;
        )cpp",
-          "not a supported kind", HeaderFile},
+          "not a supported kind", HeaderFile, Index},
 
       {
 
           R"cpp(
         struct X { X operator++(int) {} };
         void f(X x) {x+^+;})cpp",
-          "not a supported kind", HeaderFile},
+          "not a supported kind", HeaderFile, Index},
 
       {R"cpp(// foo is declared outside the file.
         void fo^o() {}
-      )cpp", "used outside main file", !HeaderFile/*cc file*/},
+      )cpp", "used outside main file", !HeaderFile /*cc file*/, Index},
+
+      {R"cpp(
+         // We should detect the symbol is used outside the file from the AST.
+         void fo^o() {})cpp",
+       "used outside main file", !HeaderFile, nullptr /*no index*/},
   };
-  const char *CommonHeader = R"cpp(
-    class Outside {};
-    void foo();
-  )cpp";
-  TestTU OtherFile = TestTU::withCode("Outside s; auto ss = &foo;");
-  OtherFile.HeaderCode = CommonHeader;
-  OtherFile.Filename = "other.cc";
-  // The index has a "Outside" reference and a "foo" reference.
-  auto OtherFileIndex = OtherFile.index();
 
   for (const auto& Case : Cases) {
     Annotations T(Case.Code);
     TestTU TU = TestTU::withCode(T.code());
     TU.HeaderCode = CommonHeader;
     if (Case.IsHeaderFile) {
       // We open the .h file as the main file.
       TU.Filename = "test.h";
       // Parsing the .h file as C++ include.
       TU.ExtraArgs.push_back("-xobjective-c++-header");
     }
     auto AST = TU.build();
 
     auto Results = renameWithinFile(AST, testPath(TU.Filename), T.point(),
-                                    "dummyNewName", OtherFileIndex.get());
+                                    "dummyNewName", Case.Index);
     bool WantRename = true;
     if (T.ranges().empty())
       WantRename = false;
     if (!WantRename) {
       assert(Case.ErrorMessage && "Error message must be set!");
       EXPECT_FALSE(Results) << "expected renameWithinFile returned an error: "
                             << T.code();
       auto ActualMessage = llvm::toString(Results.takeError());