[NFC] Slightly improve wording in the comments

[hokein]

thanks.

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

88

I slightly prefer the lower case, but up to you.

[kbobyrev]

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

88

Yes, right, I'm slightly confused about it :( There are numerous lower-case FIXME-s and a lot of upper-case ones, too. IIUC, the prevalent style in the llvm/ itself is upper-case, but there's no entry in the codestyle on that.

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

llvm::DenseSet<const Decl *> locateDeclAt(ParsedAST &AST,
   const SelectionTree::Node *SelectedNode = Selection.commonAncestor();
   if (!SelectedNode)
     return {};
 
   // If the location points to a Decl, we check it is actually on the name
   // range of the Decl. This would avoid allowing rename on unrelated tokens.
   //   ^class Foo {} // SelectionTree returns CXXRecordDecl,
   //                 // we don't attempt to trigger rename on this position.
-  // FIXME: make this work on destructors, e.g. "~F^oo()".
+  // FIXME: Make this work on destructors, e.g. "~F^oo()".
   if (const auto *D = SelectedNode->ASTNode.get<Decl>()) {
     if (D->getLocation() != TokenStartLoc)
       return {};
   }
 
   llvm::DenseSet<const Decl *> Result;
   for (const auto *D :
        targetDecl(SelectedNode->ASTNode,
llvm::Optional<ReasonToReject> renameable(const Decl &RenameDecl,
   }
 
   assert(CrossFile);
   if (!Index)
     return ReasonToReject::NoIndexProvided;
 
   // Blacklist symbols that are not supported yet in cross-file mode due to the
   // limitations of our index.
-  // FIXME: renaming templates requries to rename all related specializations,
-  //        our index doesn't have this information.
+  // FIXME: Renaming templates requires to rename all related specializations,
+  // our index doesn't have this information.
   if (RenameDecl.getDescribedTemplate())
     return ReasonToReject::UnsupportedSymbol;
 
-  // 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.
+  // 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) {
std::vector<SourceLocation> findOccurrencesWithinFile(ParsedAST &AST,
   // In theory, locateDeclAt should return the primary template. However, if the
   // cursor is under the underlying CXXRecordDecl of the ClassTemplateDecl, ND
   // will be the CXXRecordDecl, for this case, we need to get the primary
   // template maunally.
   const auto &RenameDecl =
       ND.getDescribedTemplate() ? *ND.getDescribedTemplate() : ND;
   // getUSRsForDeclaration will find other related symbols, e.g. virtual and its
   // overriddens, primary template and all explicit specializations.
-  // FIXME: get rid of the remaining tooling APIs.
+  // FIXME: Get rid of the remaining tooling APIs.
   std::vector<std::string> RenameUSRs = tooling::getUSRsForDeclaration(
       tooling::getCanonicalSymbolDeclaration(&RenameDecl), AST.getASTContext());
   llvm::DenseSet<SymbolID> TargetIDs;
   for (auto &USR : RenameUSRs)
     TargetIDs.insert(SymbolID(USR));
 
   std::vector<SourceLocation> Results;
   for (Decl *TopLevelDecl : AST.getLocalTopLevelDecls()) {
Range toRange(const SymbolLocation &L) {
   Range R;
   R.start.line = L.Start.line();
   R.start.character = L.Start.column();
   R.end.line = L.End.line();
   R.end.character = L.End.column();
   return R;
 }
 
-// Return all rename occurrences (per the index) outside of the main file,
+// Return all rename occurrences (using the index) outside of the main file,
 // grouped by the absolute file path.
 llvm::Expected<llvm::StringMap<std::vector<Range>>>
 findOccurrencesOutsideFile(const NamedDecl &RenameDecl,
                            llvm::StringRef MainFile, const SymbolIndex &Index) {
   RefsRequest RQuest;
   RQuest.IDs.insert(*getSymbolID(&RenameDecl));
 
   // Absolute file path => rename occurrences in that file.
   llvm::StringMap<std::vector<Range>> AffectedFiles;
-  // FIXME: make the limit customizable.
+  // FIXME: Make the limit customizable.
   static constexpr size_t MaxLimitFiles = 50;
   bool HasMore = Index.refs(RQuest, [&](const Ref &R) {
     if (AffectedFiles.size() > MaxLimitFiles)
       return;
     if (auto RefFilePath = filePath(R.Location, /*HintFilePath=*/MainFile)) {
       if (*RefFilePath != MainFile)
         AffectedFiles[*RefFilePath].push_back(toRange(R.Location));
     }

 //
 // Clangd builds a dynamic index for all opened files on top of the static
 // index of the whole codebase. Dynamic index is up-to-date (respects dirty
 // buffers) as long as clangd finishes processing opened files, while static
 // index (background index) is relatively stale. We choose the dirty buffers
 // as the file content we rename on, and fallback to file content on disk if
 // there is no dirty buffer.
 //
-// FIXME: add range patching heuristics to detect staleness of the index, and
-//        report to users.
-// FIXME: our index may return implicit references, which are non-eligitble
-//        for rename, we should filter out these references.
+// FIXME: Add range patching heuristics to detect staleness of the index, and
+// report to users.
+// FIXME: Our index may return implicit references, which are not eligible for
+// rename, we should filter out these references.
 llvm::Expected<FileEdits> renameOutsideFile(
     const NamedDecl &RenameDecl, llvm::StringRef MainFilePath,
     llvm::StringRef NewName, const SymbolIndex &Index,
     llvm::function_ref<llvm::Expected<std::string>(PathRef)> GetFileContent) {
   auto AffectedFiles =
       findOccurrencesOutsideFile(RenameDecl, MainFilePath, Index);
   if (!AffectedFiles)
     return AffectedFiles.takeError();
if (!*Content)
           llvm::inconvertibleErrorCode(),
           llvm::formatv("Got no buffer for file {0}", AbsPath));
 
     return (*Content)->getBuffer().str();
   };
   SourceLocation SourceLocationBeg =
       SM.getMacroArgExpandedLocation(getBeginningOfIdentifier(
           RInputs.Pos, SM, AST.getASTContext().getLangOpts()));
-  // FIXME: renaming macros is not supported yet, the macro-handling code should
+  // FIXME: Renaming macros is not supported yet, the macro-handling code should
   // be moved to rename tooling library.
   if (locateMacroAt(SourceLocationBeg, AST.getPreprocessor()))
     return makeError(ReasonToReject::UnsupportedSymbol);
 
   auto DeclsUnderCursor = locateDeclAt(AST, SourceLocationBeg);
   if (DeclsUnderCursor.empty())
     return makeError(ReasonToReject::NoSymbolFound);
   if (DeclsUnderCursor.size() > 1)
     return makeError(ReasonToReject::AmbiguousSymbol);
 
   const auto *RenameDecl = llvm::dyn_cast<NamedDecl>(*DeclsUnderCursor.begin());
   if (!RenameDecl)
     return makeError(ReasonToReject::UnsupportedSymbol);
 
   auto Reject =
       renameable(*RenameDecl->getCanonicalDecl(), RInputs.MainFilePath,
                  RInputs.Index, RInputs.AllowCrossFile);
   if (Reject)
     return makeError(*Reject);
 
-  // We have two implemenations of the rename:
+  // 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();
 
   if (!RInputs.AllowCrossFile) {
-    // within-file rename, just return the main file results.
+    // Within-file rename: just return the main file results.
     return FileEdits(
         {std::make_pair(RInputs.MainFilePath,
                         Edit{MainFileCode, std::move(*MainFileRenameEdit)})});
   }
 
   FileEdits Results;
-  // renameable safely guards us that at this point we are renaming a local
-  // symbol if we don't have index,
+  // Renameable safely guards us that at this point we are renaming a local
+  // symbol if we don't have index.
   if (RInputs.Index) {
     auto OtherFilesEdits =
         renameOutsideFile(*RenameDecl, RInputs.MainFilePath, RInputs.NewName,
                           *RInputs.Index, GetFileContent);
     if (!OtherFilesEdits)
       return OtherFilesEdits.takeError();
     Results = std::move(*OtherFilesEdits);
   }