[clangd] Remove the cross-file-rename option.

[hokein]

Summary

and simplify the code.

[sammccall]

clang-tools-extra/clangd/ClangdServer.cpp

405

i'd trim this down a bit now: "we don't query the index, as we only need main-file references"

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

237

I don't understand why we're now allowing rename of non-indexable symbols.
Is this really intended? At the least it seems like an unrelated change.

[hokein]

address review comment.

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

237

oh, you're right. I didn't think it too much when removing the code.

clang-tools-extra/clangd/ClangdServer.cpp

void ClangdServer::formatOnType(PathRef File, llvm::StringRef Code,
   WorkScheduler.runQuick("FormatOnType", File, std::move(Action));
 }
 
 void ClangdServer::prepareRename(PathRef File, Position Pos,
                                  llvm::Optional<std::string> NewName,
                                  const RenameOptions &RenameOpts,
                                  Callback<RenameResult> CB) {
   auto Action = [Pos, File = File.str(), CB = std::move(CB),
-                 NewName = std::move(NewName), RenameOpts,
-                 this](llvm::Expected<InputsAndAST> InpAST) mutable {
+                 NewName = std::move(NewName),
+                 RenameOpts](llvm::Expected<InputsAndAST> InpAST) mutable {
     if (!InpAST)
       return CB(InpAST.takeError());
-    // prepareRename is latency-sensitive:
-    //  - for single-file rename, performing rename isn't substantially more
-    //    expensive than doing an AST-based check (the index is used to see if
-    //    the rename is complete);
-    //  - for cross-file rename, we deliberately pass a nullptr index to save
-    //    the cost, thus the result may be incomplete as it only contains
-    //    main-file occurrences;
+    // prepareRename is latency-sensitive: we don't query the index, as we
+    // only need main-file references
     auto Results = clangd::rename(
         {Pos, NewName.getValueOr("__clangd_rename_dummy"), InpAST->AST, File,
-         RenameOpts.AllowCrossFile ? nullptr : Index, RenameOpts});
+         /*Index=*/nullptr, RenameOpts});
     if (!Results) {
       // LSP says to return null on failure, but that will result in a generic
       // failure message. If we send an LSP error response, clients can surface
       // the message to users (VSCode does).
       return CB(Results.takeError());
     }
     return CB(*Results);
   };

clang-tools-extra/clangd/refactor/Rename.h

 class SymbolIndex;
 
 /// Gets dirty buffer for a given file \p AbsPath.
 /// Returns None if there is no dirty buffer for the given file.
 using DirtyBufferGetter =
     llvm::function_ref<llvm::Optional<std::string>(PathRef AbsPath)>;
 
 struct RenameOptions {
-  /// If true, enable cross-file rename; otherwise, only allows to rename a
-  /// symbol that's only used in the current file.
-  bool AllowCrossFile = true;
   /// The maximum number of affected files (0 means no limit), only meaningful
   /// when AllowCrossFile = true.
   /// If the actual number exceeds the limit, rename is forbidden.
   size_t LimitFiles = 50;
   /// If true, format the rename edits, only meaningful in ClangdServer layer.
   bool WantFormat = false;
 };
 

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

while (Loc.isMacroID()) {
     if (SM.isMacroBodyExpansion(Loc))
       return true;
     Loc = SM.getImmediateMacroCallerLoc(Loc);
   }
 
   return false;
 }
 
-// Query the index to find some other files where the Decl is referenced.
-llvm::Optional<std::string> getOtherRefFile(const Decl &D, StringRef MainFile,
-                                            const SymbolIndex &Index) {
-  RefsRequest Req;
-  // We limit the number of results, this is a correctness/performance
-  // tradeoff. We expect the number of symbol references in the current file
-  // is smaller than the limit.
-  Req.Limit = 100;
-  Req.IDs.insert(getSymbolID(&D));
-  llvm::Optional<std::string> OtherFile;
-  Index.refs(Req, [&](const Ref &R) {
-    if (OtherFile)
-      return;
-    if (auto RefFilePath = filePath(R.Location, /*HintFilePath=*/MainFile)) {
-      if (!pathEqual(*RefFilePath, MainFile))
-        OtherFile = *RefFilePath;
-    }
-  });
-  return OtherFile;
-}
-
 // Canonical declarations help simplify the process of renaming. Examples:
 // - Template's canonical decl is the templated declaration (i.e.
 //   ClassTemplateDecl is canonicalized to its child CXXRecordDecl,
 //   FunctionTemplateDecl - to child FunctionDecl)
 // - Given a constructor/destructor, canonical declaration is the parent
 //   CXXRecordDecl because we want to rename both type name and its ctor/dtor.
 // - All specializations are canonicalized to the primary template. For example:
 //
#undef SYMBOL
   });
   return StdSymbols->count(printQualifiedName(RenameDecl));
 }
 
 enum class ReasonToReject {
   NoSymbolFound,
   NoIndexProvided,
   NonIndexable,
-  UsedOutsideFile, // for within-file rename only.
   UnsupportedSymbol,
   AmbiguousSymbol,
 
   // name validation.
   RenameToKeywords,
   SameName,
 };
 
 llvm::Optional<ReasonToReject> renameable(const NamedDecl &RenameDecl,
                                           StringRef MainFilePath,
-                                          const SymbolIndex *Index,
-                                          bool CrossFile) {
+                                          const SymbolIndex *Index) {
   trace::Span Tracer("Renameable");
   // Filter out symbols that are unsupported in both rename modes.
   if (llvm::isa<NamespaceDecl>(&RenameDecl))
     return ReasonToReject::UnsupportedSymbol;
   if (const auto *FD = llvm::dyn_cast<FunctionDecl>(&RenameDecl)) {
     if (FD->isOverloadedOperator())
       return ReasonToReject::UnsupportedSymbol;
   }
llvm::Optional<ReasonToReject> renameable(const NamedDecl &RenameDecl,
   bool DeclaredInMainFile =
       isInsideMainFile(RenameDecl.getBeginLoc(), ASTCtx.getSourceManager());
   bool IsMainFileOnly = true;
   if (MainFileIsHeader)
     // main file is a header, the symbol can't be main file only.
     IsMainFileOnly = false;
   else if (!DeclaredInMainFile)
     IsMainFileOnly = false;
   // If the symbol is not indexable, we disallow rename.
   if (!SymbolCollector::shouldCollectSymbol(
           RenameDecl, RenameDecl.getASTContext(), SymbolCollector::Options(),
           IsMainFileOnly))
     return ReasonToReject::NonIndexable;
 
-  if (!CrossFile) {
-    if (!DeclaredInMainFile)
-      // We are sure the symbol is used externally, bail out early.
-      return ReasonToReject::UsedOutsideFile;
-
-    // If the symbol is declared in the main file (which is not a header), we
-    // rename it.
-    if (!MainFileIsHeader)
-      return None;
-
-    if (!Index)
-      return ReasonToReject::NoIndexProvided;
-
-    auto OtherFile = getOtherRefFile(RenameDecl, MainFilePath, *Index);
-    // If the symbol is indexable and has no refs from other files in the index,
-    // we rename it.
-    if (!OtherFile)
-      return None;
-    // If the symbol is indexable and has refs from other files in the index,
-    // we disallow rename.
-    return ReasonToReject::UsedOutsideFile;
-  }
-
-  assert(CrossFile);
 
   // FIXME: Renaming virtual methods requires to rename all overridens in
   // subclasses, our index doesn't have this information.
-  // Note: Within-file rename does support this through the AST.
   if (const auto *S = llvm::dyn_cast<CXXMethodDecl>(&RenameDecl)) {
     if (S->isVirtual())
       return ReasonToReject::UnsupportedSymbol;
   }
   return None;
 }
 
 llvm::Error makeError(ReasonToReject Reason) {
   auto Message = [](ReasonToReject Reason) {
     switch (Reason) {
     case ReasonToReject::NoSymbolFound:
       return "there is no symbol at the given location";
     case ReasonToReject::NoIndexProvided:
       return "no index provided";
-    case ReasonToReject::UsedOutsideFile:
-      return "the symbol is used outside main file";
     case ReasonToReject::NonIndexable:
       return "symbol may be used in other files (not eligible for indexing)";
     case ReasonToReject::UnsupportedSymbol:
       return "symbol is not a supported kind (e.g. namespace, macro)";
     case ReasonToReject::AmbiguousSymbol:
       return "there are multiple symbols at the given location";
     case ReasonToReject::RenameToKeywords:
       return "the chosen name is a keyword";
llvm::Expected<RenameResult> rename(const RenameInputs &RInputs) {
   if (!ID)
     return makeError(ReasonToReject::UnsupportedSymbol);
   if (ID->getName() == RInputs.NewName)
     return makeError(ReasonToReject::SameName);
   auto Invalid = checkName(RenameDecl, RInputs.NewName);
   if (Invalid)
     return makeError(*Invalid);
 
-  auto Reject = renameable(RenameDecl, RInputs.MainFilePath, RInputs.Index,
-                           Opts.AllowCrossFile);
+  auto Reject = renameable(RenameDecl, RInputs.MainFilePath, RInputs.Index);
   if (Reject)
     return makeError(*Reject);
 
   // We have two implementations of the rename:
   //   - AST-based rename: used for renaming local symbols, e.g. variables
   //     defined in a function body;
   //   - index-based rename: used for renaming non-local symbols, and not
   //     feasible for local symbols (as by design our index don't index these
   //     symbols by design;
   // To make cross-file rename work for local symbol, we use a hybrid solution:
   //   - run AST-based rename on the main file;
   //   - run index-based rename on other affected files;
   auto MainFileRenameEdit = renameWithinFile(AST, RenameDecl, RInputs.NewName);
   if (!MainFileRenameEdit)
     return MainFileRenameEdit.takeError();
   RenameResult Result;
   Result.Target = CurrentIdentifier;
   Edit MainFileEdits = Edit(MainFileCode, std::move(*MainFileRenameEdit));
   llvm::for_each(MainFileEdits.asTextEdits(), [&Result](const TextEdit &TE) {
     Result.LocalChanges.push_back(TE.range);
   });
 
   // return the main file edit if this is a within-file rename or the symbol
   // being renamed is function local.
-  if (!Opts.AllowCrossFile || RenameDecl.getParentFunctionOrMethod()) {
+  if (RenameDecl.getParentFunctionOrMethod()) {
     Result.GlobalChanges = FileEdits(
         {std::make_pair(RInputs.MainFilePath, std::move(MainFileEdits))});
     return Result;
   }
 
   // If the index is nullptr, we don't know the completeness of the result, so
   // we don't populate the field GlobalChanges.
   if (!RInputs.Index) {
-    assert(Result.GlobalChanges.empty() && Opts.AllowCrossFile);
+    assert(Result.GlobalChanges.empty());
     return Result;
   }
 
   auto OtherFilesEdits = renameOutsideFile(
       RenameDecl, RInputs.MainFilePath, RInputs.NewName, *RInputs.Index,
       Opts.LimitFiles == 0 ? std::numeric_limits<size_t>::max()
                            : Opts.LimitFiles,
       GetFileContent);

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

llvm::StringRef Tests[] = {
       // Member function.
       R"cpp(
         struct X {
           void [[F^oo]]() {}
           void Baz() { [[F^oo]](); }
         };
       )cpp",
 
-      // Class methods overrides.
-      R"cpp(
-        struct A {
-         virtual void [[f^oo]]() {}
-        };
-        struct B : A {
-          void [[f^oo]]() override {}
-        };
-        struct C : B {
-          void [[f^oo]]() override {}
-        };
-
-        void func() {
-          A().[[f^oo]]();
-          B().[[f^oo]]();
-          C().[[f^oo]]();
-        }
-      )cpp",
-
       // Templated method instantiation.
       R"cpp(
         template<typename T>
         class Foo {
         public:
           static T [[f^oo]]() {}
         };
 
TEST(RenameTest, WithinFileRename) {
   };
   llvm::StringRef NewName = "NewName";
   for (llvm::StringRef T : Tests) {
     SCOPED_TRACE(T);
     Annotations Code(T);
     auto TU = TestTU::withCode(Code.code());
     TU.ExtraArgs.push_back("-xobjective-c++");
     auto AST = TU.build();
+    auto Index = TU.index();
     for (const auto &RenamePos : Code.points()) {
-      auto RenameResult = rename({RenamePos,
-                                  NewName,
-                                  AST,
-                                  testPath(TU.Filename),
-                                  /*Index*/ nullptr,
-                                  {/*CrossFile*/ false}});
+      auto RenameResult =
+          rename({RenamePos, NewName, AST, testPath(TU.Filename), Index.get()});
       ASSERT_TRUE(bool(RenameResult)) << RenameResult.takeError();
       ASSERT_EQ(1u, RenameResult->GlobalChanges.size());
       EXPECT_EQ(
           applyEdits(std::move(RenameResult->GlobalChanges)).front().second,
           expectedResult(Code, NewName));
     }
   }
 }
 
 TEST(RenameTest, Renameable) {
   struct Case {
     const char *Code;
     const char* ErrorMessage; // null if no error
     bool IsHeaderFile;
-    const SymbolIndex *Index;
     llvm::StringRef NewName = "DummyName";
   };
-  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, Index},
-
-      {R"cpp(// allow -- symbol is indexable and has no refs in index.
-        void [[On^lyInThisFile]]();
-      )cpp",
-       nullptr, HeaderFile, Index},
-
-      {R"cpp(
-        void ^f();
-      )cpp",
-       "keyword", HeaderFile, Index, "return"},
-
-      {R"cpp(// disallow -- symbol is indexable and has other refs in index.
-        void f() {
-          Out^side s;
-        }
-      )cpp",
-       "used outside main file", HeaderFile, Index},
+       nullptr, HeaderFile},
 
       {R"cpp(// disallow -- symbol in anonymous namespace in header is not indexable.
         namespace {
         class Unin^dexable {};
         }
       )cpp",
-       "not eligible for indexing", HeaderFile, Index},
-
-      {R"cpp(// allow -- symbol in anonymous namespace in non-header file is indexable.
-        namespace {
-        class [[F^oo]] {};
-        }
-      )cpp",
-       nullptr, !HeaderFile, Index},
+       "not eligible for indexing", HeaderFile},
 
       {R"cpp(// disallow -- namespace symbol isn't supported
         namespace n^s {}
       )cpp",
-       "not a supported kind", HeaderFile, Index},
+       "not a supported kind", HeaderFile},
 
       {
           R"cpp(
          #define MACRO 1
          int s = MAC^RO;
        )cpp",
-          "not a supported kind", HeaderFile, Index},
+          "not a supported kind", HeaderFile},
 
       {
           R"cpp(
         struct X { X operator++(int); };
         void f(X x) {x+^+;})cpp",
-          "no symbol", HeaderFile, Index},
-
-      {R"cpp(// foo is declared outside the file.
-        void fo^o() {}
-      )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*/},
+          "no symbol", HeaderFile},
 
       {R"cpp(// disallow rename on excluded symbols (e.g. std symbols)
          namespace std {
          class str^ing {};
          }
        )cpp",
-       "not a supported kind", !HeaderFile, Index},
+       "not a supported kind", !HeaderFile},
       {R"cpp(// disallow rename on excluded symbols (e.g. std symbols)
          namespace std {
          inline namespace __u {
          class str^ing {};
          }
          }
        )cpp",
-       "not a supported kind", !HeaderFile, Index},
+       "not a supported kind", !HeaderFile},
 
       {R"cpp(// disallow rename on non-normal identifiers.
          @interface Foo {}
          -(int) fo^o:(int)x; // Token is an identifier, but declaration name isn't a simple identifier.
          @end
        )cpp",
-       "not a supported kind", HeaderFile, Index},
-
+       "not a supported kind", HeaderFile},
+      {R"cpp(// FIXME: rename virtual/override methods is not supported yet.
+         struct A {
+          virtual void f^oo() {}
+         };
+      )cpp",
+       "not a supported kind", !HeaderFile},
       {R"cpp(
          void foo(int);
          void foo(char);
          template <typename T> void f(T t) {
            fo^o(t);
          })cpp",
-       "multiple symbols", !HeaderFile, nullptr /*no index*/},
+       "multiple symbols", !HeaderFile},
 
       {R"cpp(// disallow rename on unrelated token.
          cl^ass Foo {};
        )cpp",
-       "no symbol", !HeaderFile, nullptr},
+       "no symbol", !HeaderFile},
 
       {R"cpp(// disallow rename on unrelated token.
          temp^late<typename T>
          class Foo {};
        )cpp",
-       "no symbol", !HeaderFile, nullptr},
+       "no symbol", !HeaderFile},
 
       {R"cpp(
         namespace {
         int Conflict;
         int Va^r;
         }
       )cpp",
-       "conflict", !HeaderFile, nullptr, "Conflict"},
+       "conflict", !HeaderFile, "Conflict"},
 
       {R"cpp(
         int Conflict;
         int Va^r;
       )cpp",
-       "conflict", !HeaderFile, nullptr, "Conflict"},
+       "conflict", !HeaderFile, "Conflict"},
 
       {R"cpp(
         class Foo {
           int Conflict;
           int Va^r;
         };
       )cpp",
-       "conflict", !HeaderFile, nullptr, "Conflict"},
+       "conflict", !HeaderFile, "Conflict"},
 
       {R"cpp(
         enum E {
           Conflict,
           Fo^o,
         };
       )cpp",
-       "conflict", !HeaderFile, nullptr, "Conflict"},
+       "conflict", !HeaderFile, "Conflict"},
 
       {R"cpp(
         int Conflict;
         enum E { // transparent context.
           F^oo,
         };
       )cpp",
-       "conflict", !HeaderFile, nullptr, "Conflict"},
+       "conflict", !HeaderFile, "Conflict"},
 
       {R"cpp(
         void func() {
           bool Whatever;
           int V^ar;
           char Conflict;
         }
       )cpp",
-       "conflict", !HeaderFile, nullptr, "Conflict"},
+       "conflict", !HeaderFile, "Conflict"},
 
       {R"cpp(
         void func() {
           if (int Conflict = 42) {
             int V^ar;
           }
         }
       )cpp",
-       "conflict", !HeaderFile, nullptr, "Conflict"},
+       "conflict", !HeaderFile, "Conflict"},
 
       {R"cpp(
         void func() {
           if (int Conflict = 42) {
           } else {
             bool V^ar;
           }
         }
       )cpp",
-       "conflict", !HeaderFile, nullptr, "Conflict"},
+       "conflict", !HeaderFile, "Conflict"},
 
       {R"cpp(
         void func() {
           if (int V^ar = 42) {
           } else {
             bool Conflict;
           }
         }
       )cpp",
-       "conflict", !HeaderFile, nullptr, "Conflict"},
+       "conflict", !HeaderFile, "Conflict"},
 
       {R"cpp(
         void func() {
           while (int V^ar = 10) {
             bool Conflict = true;
           }
         }
       )cpp",
-       "conflict", !HeaderFile, nullptr, "Conflict"},
+       "conflict", !HeaderFile, "Conflict"},
 
       {R"cpp(
         void func() {
           for (int Something = 9000, Anything = 14, Conflict = 42; Anything > 9;
                ++Something) {
             int V^ar;
           }
         }
       )cpp",
-       "conflict", !HeaderFile, nullptr, "Conflict"},
+       "conflict", !HeaderFile, "Conflict"},
 
       {R"cpp(
         void func() {
           for (int V^ar = 14, Conflict = 42;;) {
           }
         }
       )cpp",
-       "conflict", !HeaderFile, nullptr, "Conflict"},
+       "conflict", !HeaderFile, "Conflict"},
 
       {R"cpp(
         void func(int Conflict) {
           bool V^ar;
         }
       )cpp",
-       "conflict", !HeaderFile, nullptr, "Conflict"},
+       "conflict", !HeaderFile, "Conflict"},
 
       {R"cpp(
         void func(int Var);
 
         void func(int V^ar) {
           bool Conflict;
         }
       )cpp",
-       "conflict", !HeaderFile, nullptr, "Conflict"},
+       "conflict", !HeaderFile, "Conflict"},
 
       {R"cpp(// No conflict: only forward declaration's argument is renamed.
         void func(int [[V^ar]]);
 
         void func(int Var) {
           bool Conflict;
         }
       )cpp",
-       nullptr, !HeaderFile, nullptr, "Conflict"},
+       nullptr, !HeaderFile, "Conflict"},
 
       {R"cpp(
         void func(int V^ar, int Conflict) {
         }
       )cpp",
-       "conflict", !HeaderFile, nullptr, "Conflict"},
+       "conflict", !HeaderFile, "Conflict"},
 
       {R"cpp(// Trying to rename into the same name, SameName == SameName.
         void func() {
           int S^ameName;
         }
       )cpp",
-       "new name is the same", !HeaderFile, nullptr, "SameName"},
+       "new name is the same", !HeaderFile, "SameName"},
       {R"cpp(// Ensure it doesn't associate base specifier with base name.
         struct A {};
         struct B : priv^ate A {};
       )cpp",
-       "Cannot rename symbol: there is no symbol at the given location", false,
-       nullptr},
+       "Cannot rename symbol: there is no symbol at the given location", false},
   };
 
   for (const auto& Case : Cases) {
     SCOPED_TRACE(Case.Code);
     Annotations T(Case.Code);
     TestTU TU = TestTU::withCode(T.code());
-    TU.HeaderCode = CommonHeader;
     TU.ExtraArgs.push_back("-fno-delayed-template-parsing");
     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();
     llvm::StringRef NewName = Case.NewName;
-    auto Results = rename({T.point(),
-                           NewName,
-                           AST,
-                           testPath(TU.Filename),
-                           Case.Index,
-                           {/*CrossFile=*/false}});
+    auto Results = rename({T.point(), NewName, AST, testPath(TU.Filename)});
     bool WantRename = true;
     if (T.ranges().empty())
       WantRename = false;
     if (!WantRename) {
       assert(Case.ErrorMessage && "Error message must be set!");
       EXPECT_FALSE(Results)
           << "expected rename returned an error: " << T.code();
       auto ActualMessage = llvm::toString(Results.takeError());
TEST(RenameTest, IndexMergeMainFile) {
   auto AST = TU.build();
 
   auto Main = testPath("main.cc");
 
   auto Rename = [&](const SymbolIndex *Idx) {
     auto GetDirtyBuffer = [&](PathRef Path) -> llvm::Optional<std::string> {
       return Code.code().str(); // Every file has the same content.
     };
-    RenameOptions Opts;
-    Opts.AllowCrossFile = true;
-    RenameInputs Inputs{Code.point(), "xPrime", AST,           Main,
-                        Idx,          Opts,     GetDirtyBuffer};
+    RenameInputs Inputs{Code.point(), "xPrime",        AST,           Main,
+                        Idx,          RenameOptions(), GetDirtyBuffer};
     auto Results = rename(Inputs);
     EXPECT_TRUE(bool(Results)) << llvm::toString(Results.takeError());
     return std::move(*Results);
   };
 
   // We do not expect to see duplicated edits from AST vs index.
   auto Results = Rename(TU.index().get());
   EXPECT_THAT(Results.GlobalChanges.keys(), ElementsAre(Main));
TEST(RenameTest, PrepareRename) {
 
   trace::TestTracer Tracer;
   MockCompilationDatabase CDB;
   ClangdServer Server(CDB, FS, ServerOpts);
   runAddDocument(Server, FooHPath, FooH.code());
   runAddDocument(Server, FooCCPath, FooCC.code());
 
   auto Results = runPrepareRename(Server, FooCCPath, FooCC.point(),
-                                  /*NewName=*/llvm::None, {/*CrossFile=*/true});
+                                  /*NewName=*/llvm::None, {});
   // Verify that for multi-file rename, we only return main-file occurrences.
   ASSERT_TRUE(bool(Results)) << Results.takeError();
   // We don't know the result is complete in prepareRename (passing a nullptr
   // index internally), so GlobalChanges should be empty.
   EXPECT_TRUE(Results->GlobalChanges.empty());
   EXPECT_THAT(FooCC.ranges(),
               testing::UnorderedElementsAreArray(Results->LocalChanges));
 
   // Name validation.
-  Results =
-      runPrepareRename(Server, FooCCPath, FooCC.point(),
-                       /*NewName=*/std::string("int"), {/*CrossFile=*/true});
+  Results = runPrepareRename(Server, FooCCPath, FooCC.point(),
+                             /*NewName=*/std::string("int"), {});
   EXPECT_FALSE(Results);
   EXPECT_THAT(llvm::toString(Results.takeError()),
               testing::HasSubstr("keyword"));
   EXPECT_THAT(Tracer.takeMetric("rename_name_invalid", "Keywords"),
               ElementsAre(1));
-
-  // Single-file rename on global symbols, we should report an error.
-  Results = runPrepareRename(Server, FooCCPath, FooCC.point(),
-                             /*NewName=*/llvm::None, {/*CrossFile=*/false});
-  EXPECT_FALSE(Results);
-  EXPECT_THAT(llvm::toString(Results.takeError()),
-              testing::HasSubstr("is used outside"));
 }
 
 TEST(CrossFileRenameTests, DirtyBuffer) {
   Annotations FooCode("class [[Foo]] {};");
   std::string FooPath = testPath("foo.cc");
   Annotations FooDirtyBuffer("class [[Foo]] {};\n// this is dirty buffer");
   Annotations BarCode("void [[Bar]]() {}");
   std::string BarPath = testPath("bar.cc");
TEST(CrossFileRenameTests, DirtyBuffer) {
   TestTU TU = TestTU::withCode(MainCode.code());
   auto AST = TU.build();
   llvm::StringRef NewName = "newName";
   auto Results = rename({MainCode.point(),
                          NewName,
                          AST,
                          MainFilePath,
                          Index.get(),
-                         {/*CrossFile=*/true},
+                         {},
                          GetDirtyBuffer});
   ASSERT_TRUE(bool(Results)) << Results.takeError();
   EXPECT_THAT(
       applyEdits(std::move(Results->GlobalChanges)),
       UnorderedElementsAre(
           Pair(Eq(FooPath), Eq(expectedResult(FooDirtyBuffer, NewName))),
           Pair(Eq(MainFilePath), Eq(expectedResult(MainCode, NewName)))));
 
   // Run rename on Bar, there is no dirty buffer for the affected file bar.cc,
   // so we should read file content from VFS.
   MainCode = Annotations("void [[Bar]]() { [[B^ar]](); }");
   TU = TestTU::withCode(MainCode.code());
   // Set a file "bar.cc" on disk.
   TU.AdditionalFiles["bar.cc"] = std::string(BarCode.code());
   AST = TU.build();
   Results = rename({MainCode.point(),
                     NewName,
                     AST,
                     MainFilePath,
                     Index.get(),
-                    {/*CrossFile=*/true},
+                    {},
                     GetDirtyBuffer});
   ASSERT_TRUE(bool(Results)) << Results.takeError();
   EXPECT_THAT(
       applyEdits(std::move(Results->GlobalChanges)),
       UnorderedElementsAre(
           Pair(Eq(BarPath), Eq(expectedResult(BarCode, NewName))),
           Pair(Eq(MainFilePath), Eq(expectedResult(MainCode, NewName)))));
 
class PaginationIndex : public SymbolIndex {
 
     size_t estimateMemoryUsage() const override { return 0; }
   } PIndex;
   Results = rename({MainCode.point(),
                     NewName,
                     AST,
                     MainFilePath,
                     &PIndex,
-                    {/*CrossFile=*/true},
+                    {},
                     GetDirtyBuffer});
   EXPECT_FALSE(Results);
   EXPECT_THAT(llvm::toString(Results.takeError()),
               testing::HasSubstr("too many occurrences"));
 }
 
 TEST(CrossFileRenameTests, DeduplicateRefsFromIndex) {
   auto MainCode = Annotations("int [[^x]] = 2;");
public:
     indexedFiles() const override {
       return [](llvm::StringRef) { return IndexContents::None; };
     }
 
     size_t estimateMemoryUsage() const override { return 0; }
     Ref ReturnedRef;
   } DIndex(XRefInBarCC);
   llvm::StringRef NewName = "newName";
-  auto Results = rename({MainCode.point(),
-                         NewName,
-                         AST,
-                         MainFilePath,
-                         &DIndex,
-                         {/*CrossFile=*/true}});
+  auto Results =
+      rename({MainCode.point(), NewName, AST, MainFilePath, &DIndex});
   ASSERT_TRUE(bool(Results)) << Results.takeError();
   EXPECT_THAT(
       applyEdits(std::move(Results->GlobalChanges)),
       UnorderedElementsAre(
           Pair(Eq(BarPath), Eq(expectedResult(BarCode, NewName))),
           Pair(Eq(MainFilePath), Eq(expectedResult(MainCode, NewName)))));
 }
 
for (const auto &T : Cases) {
     // Add all files to clangd server to make sure the dynamic index has been
     // built.
     runAddDocument(Server, FooHPath, FooH.code());
     runAddDocument(Server, FooCCPath, FooCC.code());
 
     llvm::StringRef NewName = "NewName";
     for (const auto &RenamePos : FooH.points()) {
       EXPECT_THAT(Tracer.takeMetric("rename_files"), SizeIs(0));
-      auto FileEditsList = llvm::cantFail(runRename(
-          Server, FooHPath, RenamePos, NewName, {/*CrossFile=*/true}));
+      auto FileEditsList =
+          llvm::cantFail(runRename(Server, FooHPath, RenamePos, NewName, {}));
       EXPECT_THAT(Tracer.takeMetric("rename_files"), ElementsAre(2));
       EXPECT_THAT(
           applyEdits(std::move(FileEditsList.GlobalChanges)),
           UnorderedElementsAre(
               Pair(Eq(FooHPath), Eq(expectedResult(T.FooH, NewName))),
               Pair(Eq(FooCCPath), Eq(expectedResult(T.FooCC, NewName)))));
     }
   }