[clangd] Replace usages of dummy with more descriptive words

Dummy is a word with inappropriate associations. This patch updates the
references to it in clangd code base with more precise ones.

The only user-visible change is the default variable name used when extracting a
variable. It will be named as `placeholder` from now on.

Differential Revision: https://reviews.llvm.org/D99065

Author: kadircet

clang-tools-extra/clangd/ClangdServer.cpp

@@ -497,7 +497,7 @@ void ClangdServer::prepareRename(PathRef File, Position Pos,
     // 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"),
+        clangd::rename({Pos, NewName.getValueOr("__clangd_rename_placeholder"),
                         InpAST->AST, File, /*FS=*/nullptr,
                         /*Index=*/nullptr, RenameOpts});
     if (!Results) {

clang-tools-extra/clangd/CompileCommands.cpp

@@ -96,9 +96,9 @@ std::string detectClangPath() {
     if (auto PathCC = llvm::sys::findProgramByName(Name))
       return resolve(std::move(*PathCC));
   // Fallback: a nonexistent 'clang' binary next to clangd.
-  static int Dummy;
+  static int StaticForMainAddr;
   std::string ClangdExecutable =
-      llvm::sys::fs::getMainExecutable("clangd", (void *)&Dummy);
+      llvm::sys::fs::getMainExecutable("clangd", (void *)&StaticForMainAddr);
   SmallString<128> ClangPath;
   ClangPath = llvm::sys::path::parent_path(ClangdExecutable);
   llvm::sys::path::append(ClangPath, "clang");
@@ -120,8 +120,9 @@ const llvm::Optional<std::string> detectSysroot() {
 }
 
 std::string detectStandardResourceDir() {
-  static int Dummy; // Just an address in this process.
-  return CompilerInvocation::GetResourcesPath("clangd", (void *)&Dummy);
+  static int StaticForMainAddr; // Just an address in this process.
+  return CompilerInvocation::GetResourcesPath("clangd",
+                                              (void *)&StaticForMainAddr);
 }
 
 // The path passed to argv[0] is important:

clang-tools-extra/clangd/FindSymbols.cpp

@@ -376,10 +376,10 @@ class DocumentOutline {
 
   /// Builds the document outline for the generated AST.
   std::vector<DocumentSymbol> build() {
-    SymBuilder DummyRoot;
+    SymBuilder Root;
     for (auto &TopLevel : AST.getLocalTopLevelDecls())
-      traverseDecl(TopLevel, DummyRoot);
-    return std::move(std::move(DummyRoot).build().children);
+      traverseDecl(TopLevel, Root);
+    return std::move(std::move(Root).build().children);
   }
 
 private:

clang-tools-extra/clangd/Format.cpp

@@ -23,7 +23,7 @@ namespace {
 /// as it isn't sure where the errors are and so can't correct.
 /// When editing, it's reasonable to assume code before the cursor is complete.
 void closeBrackets(std::string &Code, const format::FormatStyle &Style) {
-  SourceManagerForFile FileSM("dummy.cpp", Code);
+  SourceManagerForFile FileSM("mock_file.cpp", Code);
   auto &SM = FileSM.get();
   FileID FID = SM.getMainFileID();
   Lexer Lex(FID, SM.getBufferOrFake(FID), SM,

clang-tools-extra/clangd/SemanticHighlighting.cpp

@@ -294,7 +294,7 @@ class HighlightingsBuilder {
   HighlightingToken &addToken(SourceLocation Loc, HighlightingKind Kind) {
     Loc = getHighlightableSpellingToken(Loc, SourceMgr);
     if (Loc.isInvalid())
-      return Dummy;
+      return InvalidHighlightingToken;
     const auto *Tok = TB.spelledTokenAt(Loc);
     assert(Tok);
     return addToken(
@@ -395,7 +395,8 @@ class HighlightingsBuilder {
   const SourceManager &SourceMgr;
   const LangOptions &LangOpts;
   std::vector<HighlightingToken> Tokens;
-  HighlightingToken Dummy; // returned from addToken(InvalidLoc)
+  // returned from addToken(InvalidLoc)
+  HighlightingToken InvalidHighlightingToken;
 };
 
 llvm::Optional<HighlightingModifier> scopeModifier(const NamedDecl *D) {

clang-tools-extra/clangd/SourceCode.cpp

@@ -599,7 +599,7 @@ lex(llvm::StringRef Code, const LangOptions &LangOpts,
         Action) {
   // FIXME: InMemoryFileAdapter crashes unless the buffer is null terminated!
   std::string NullTerminatedCode = Code.str();
-  SourceManagerForFile FileSM("dummy.cpp", NullTerminatedCode);
+  SourceManagerForFile FileSM("mock_file_name.cpp", NullTerminatedCode);
   auto &SM = FileSM.get();
   for (const auto &Tok : syntax::tokenize(SM.getMainFileID(), SM, LangOpts))
     Action(Tok, SM);

clang-tools-extra/clangd/XRefs.cpp

@@ -162,10 +162,10 @@ SymbolLocation toIndexLocation(const Location &Loc, std::string &URIStorage) {
 SymbolLocation getPreferredLocation(const Location &ASTLoc,
                                     const SymbolLocation &IdxLoc,
                                     std::string &Scratch) {
-  // Also use a dummy symbol for the index location so that other fields (e.g.
+  // Also use a mock symbol for the index location so that other fields (e.g.
   // definition) are not factored into the preference.
   Symbol ASTSym, IdxSym;
-  ASTSym.ID = IdxSym.ID = SymbolID("dummy_id");
+  ASTSym.ID = IdxSym.ID = SymbolID("mock_symbol_id");
   ASTSym.CanonicalDeclaration = toIndexLocation(ASTLoc, Scratch);
   IdxSym.CanonicalDeclaration = IdxLoc;
   auto Merged = mergeSymbol(ASTSym, IdxSym);

clang-tools-extra/clangd/fuzzer/CMakeLists.txt

@@ -9,7 +9,7 @@ set(LLVM_LINK_COMPONENTS
 # This fuzzer runs on oss-fuzz, so keep it around even if it looks unreferenced.
 add_llvm_fuzzer(clangd-fuzzer
   clangd-fuzzer.cpp
-  DUMMY_MAIN DummyClangdMain.cpp
+  DUMMY_MAIN FuzzerClangdMain.cpp
   )
 
 clang_target_link_libraries(clangd-fuzzer

clang-tools-extra/clangd/fuzzer/DummyClangdMain.cpp renamed to clang-tools-extra/clangd/fuzzer/FuzzerClangdMain.cpp

@@ -1,4 +1,4 @@
-//===---- DummyClangdMain.cpp - Entry point to sanity check the fuzzer ----===//
+//===--- FuzzerClangdMain.cpp - Entry point to sanity check the fuzzer ----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.

clang-tools-extra/clangd/index/remote/CMakeLists.txt

@@ -39,6 +39,6 @@ if (CLANGD_ENABLE_REMOTE)
   add_subdirectory(marshalling)
   add_subdirectory(server)
 else()
-  # Provides a dummy implementation of clangdRemoteIndex.
+  # Provides a no-op implementation of clangdRemoteIndex.
   add_subdirectory(unimplemented)
 endif()

clang-tools-extra/clangd/refactor/tweaks/ExtractVariable.cpp

@@ -376,7 +376,7 @@ bool eligibleForExtraction(const SelectionTree::Node *N) {
   if (llvm::isa<DeclRefExpr>(E) || llvm::isa<MemberExpr>(E))
     return false;
 
-  // Extracting Exprs like a = 1 gives dummy = a = 1 which isn't useful.
+  // Extracting Exprs like a = 1 gives placeholder = a = 1 which isn't useful.
   // FIXME: we could still hoist the assignment, and leave the variable there?
   ParsedBinaryOperator BinOp;
   if (BinOp.parse(*N) && BinaryOperator::isAssignmentOp(BinOp.Kind))
@@ -387,7 +387,7 @@ bool eligibleForExtraction(const SelectionTree::Node *N) {
   if (!Parent)
     return false;
   // We don't want to extract expressions used as statements, that would leave
-  // a `dummy;` around that has no effect.
+  // a `placeholder;` around that has no effect.
   // Unfortunately because the AST doesn't have ExprStmt, we have to check in
   // this roundabout way.
   if (childExprIsStmt(Parent->ASTNode.get<Stmt>(),
@@ -422,7 +422,7 @@ const SelectionTree::Node *computeExtractedExpr(const SelectionTree::Node *N) {
       llvm::isa<MemberExpr>(SelectedExpr))
     if (const SelectionTree::Node *Call = getCallExpr(N))
       TargetNode = Call;
-  // Extracting Exprs like a = 1 gives dummy = a = 1 which isn't useful.
+  // Extracting Exprs like a = 1 gives placeholder = a = 1 which isn't useful.
   if (const BinaryOperator *BinOpExpr =
           dyn_cast_or_null<BinaryOperator>(SelectedExpr)) {
     if (BinOpExpr->getOpcode() == BinaryOperatorKind::BO_Assign)
@@ -433,13 +433,13 @@ const SelectionTree::Node *computeExtractedExpr(const SelectionTree::Node *N) {
   return TargetNode;
 }
 
-/// Extracts an expression to the variable dummy
+/// Extracts an expression to the variable placeholder
 /// Before:
 /// int x = 5 + 4 * 3;
 ///         ^^^^^
 /// After:
-/// auto dummy = 5 + 4;
-/// int x = dummy * 3;
+/// auto placeholder = 5 + 4;
+/// int x = placeholder * 3;
 class ExtractVariable : public Tweak {
 public:
   const char *id() const override final;
@@ -476,7 +476,7 @@ bool ExtractVariable::prepare(const Selection &Inputs) {
 Expected<Tweak::Effect> ExtractVariable::apply(const Selection &Inputs) {
   tooling::Replacements Result;
   // FIXME: get variable name from user or suggest based on type
-  std::string VarName = "dummy";
+  std::string VarName = "placeholder";
   SourceRange Range = Target->getExtractionChars();
   // insert new variable declaration
   if (auto Err = Result.add(Target->insertDeclaration(VarName, Range)))

clang-tools-extra/clangd/support/Trace.cpp

@@ -112,14 +112,14 @@ class JSONTracer : public EventTracer {
             "s",
             llvm::json::Object{{"id", FlowID},
                                {"name", "Context crosses threads"},
-                               {"cat", "dummy"}},
+                               {"cat", "mock_cat"}},
             (*Parent)->TID, (*Parent)->StartTime);
         Tracer->jsonEvent(
             "f",
             llvm::json::Object{{"id", FlowID},
                                {"bp", "e"},
                                {"name", "Context crosses threads"},
-                               {"cat", "dummy"}},
+                               {"cat", "mock_cat"}},
             TID);
       }
     }

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

@@ -407,9 +407,9 @@ TEST(ClangdServerTest, SearchLibDir) {
 
   // Put crtbegin.o into LibDir/64 to trick clang into thinking there's a gcc
   // installation there.
-  SmallString<64> DummyLibFile;
-  llvm::sys::path::append(DummyLibFile, LibDir, "64", "crtbegin.o");
-  FS.Files[DummyLibFile] = "";
+  SmallString<64> MockLibFile;
+  llvm::sys::path::append(MockLibFile, LibDir, "64", "crtbegin.o");
+  FS.Files[MockLibFile] = "";
 
   SmallString<64> IncludeDir("/randomusr/include/c++");
   llvm::sys::path::append(IncludeDir, Version);

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

@@ -463,7 +463,9 @@ MATCHER_P2(hasFlag, Flag, Path, "") {
   return true;
 }
 
-auto hasFlag(llvm::StringRef Flag) { return hasFlag(Flag, "dummy.cc"); }
+auto hasFlag(llvm::StringRef Flag) {
+  return hasFlag(Flag, "mock_file_name.cc");
+}
 
 TEST_F(DirectoryBasedGlobalCompilationDatabaseCacheTest, Cacheable) {
   MockFS FS;
@@ -507,15 +509,15 @@ TEST_F(DirectoryBasedGlobalCompilationDatabaseCacheTest, Cacheable) {
   // compile_commands.json takes precedence over compile_flags.txt.
   FS.Files["foo/compile_commands.json"] =
       llvm::formatv(R"json([{
-    "file": "{0}/foo/dummy.cc",
-    "command": "clang -DBAZ dummy.cc",
+    "file": "{0}/foo/mock_file.cc",
+    "command": "clang -DBAZ mock_file.cc",
     "directory": "{0}/foo",
   }])json",
                     llvm::sys::path::convert_to_slash(testRoot()));
   EXPECT_EQ(FooBar, lookupCDB(GDB, testPath("foo/test.cc"), Stale))
       << "cache still valid";
   auto Baz = lookupCDB(GDB, testPath("foo/test.cc"), Fresh);
-  EXPECT_THAT(Baz, hasFlag("-DBAZ", testPath("foo/dummy.cc")))
+  EXPECT_THAT(Baz, hasFlag("-DBAZ", testPath("foo/mock_file.cc")))
       << "compile_commands overrides compile_flags";
 
   // Removing compile_commands.json reveals compile_flags.txt again.

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

@@ -844,7 +844,7 @@ TEST(RenameTest, Renameable) {
     const char *Code;
     const char* ErrorMessage; // null if no error
     bool IsHeaderFile;
-    llvm::StringRef NewName = "DummyName";
+    llvm::StringRef NewName = "MockName";
   };
   const bool HeaderFile = true;
   Case Cases[] = {

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

@@ -71,7 +71,7 @@ MATCHER_P2(TUState, PreambleActivity, ASTActivity, "") {
   return true;
 }
 
-// Dummy ContextProvider to verify the provider is invoked & contexts are used.
+// Simple ContextProvider to verify the provider is invoked & contexts are used.
 static Key<std::string> BoundPath;
 Context bindPath(PathRef F) {
   return Context::current().derive(BoundPath, F.str());