[clangd] Replace usages of dummy with more descriptive words

[kadircet]

Summary

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.

[hokein]

clang-tools-extra/clangd/SemanticHighlighting.cpp

399

I'd name it InvalidHightlightingToken.

[kadircet]

• address comments

clang-tools-extra/clangd/ClangdServer.cpp

void ClangdServer::prepareRename(PathRef File, Position Pos,
   auto Action = [Pos, File = File.str(), CB = std::move(CB),
                  NewName = std::move(NewName),
                  RenameOpts](llvm::Expected<InputsAndAST> InpAST) mutable {
     if (!InpAST)
       return CB(InpAST.takeError());
     // 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) {
       // 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());
     }

clang-tools-extra/clangd/CompileCommands.cpp

#ifdef __APPLE__
   if (auto MacClang = queryXcrun({"xcrun", "--find", "clang"}))
     return resolve(std::move(*MacClang));
 #endif
   // On other platforms, just look for compilers on the PATH.
   for (const char *Name : {"clang", "gcc", "cc"})
     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");
   return std::string(ClangPath.str());
 }
 
 // On mac, /usr/bin/clang sets SDKROOT and then invokes the real clang.
 // The effect of this is to set -isysroot correctly. We do the same.
 const llvm::Optional<std::string> detectSysroot() {
 #ifndef __APPLE__
   return llvm::None;
 #endif
 
   // SDKROOT overridden in environment, respect it. Driver will set isysroot.
   if (::getenv("SDKROOT"))
     return llvm::None;
   return queryXcrun({"xcrun", "--show-sdk-path"});
   return llvm::None;
 }
 
 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:
 //  - its parent directory is Driver::Dir, used for library discovery
 //  - its basename affects CLI parsing (clang-cl) and other settings
 // Where possible it should be an absolute path with sensible directory, but
 // with the original basename.
 static std::string resolveDriver(llvm::StringRef Driver, bool FollowSymlink,

clang-tools-extra/clangd/FindSymbols.cpp

public:
     }
   };
 
 public:
   DocumentOutline(ParsedAST &AST) : AST(AST) {}
 
   /// 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:
   enum class VisitKind { No, OnlyDecl, OnlyChildren, DeclAndChildren };
 
   void traverseDecl(Decl *D, SymBuilder &Parent) {
     // Skip symbols which do not originate from the main file.
     if (!isInsideMainFile(D->getLocation(), AST.getSourceManager()))

clang-tools-extra/clangd/Format.cpp

 namespace clangd {
 namespace {
 
 /// Append closing brackets )]} to \p Code to make it well-formed.
 /// Clang-format conservatively refuses to format files with unmatched brackets
 /// 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,
             format::getFormattingLangOpts(Style));
   Token Tok;
   std::vector<char> Brackets;
   while (!Lex.LexFromRawLexer(Tok)) {
     switch(Tok.getKind()) {

clang-tools-extra/clangd/SemanticHighlighting.cpp

 public:
   HighlightingsBuilder(const ParsedAST &AST)
       : TB(AST.getTokens()), SourceMgr(AST.getSourceManager()),
         LangOpts(AST.getLangOpts()) {}
 
   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(
         halfOpenToRange(SourceMgr,
                         Tok->range(SourceMgr).toCharRange(SourceMgr)),
         Kind);
   }
 
std::vector<HighlightingToken> collect(ParsedAST &AST) && {
     return WithInactiveLines;
   }
 
 private:
   const syntax::TokenBuffer &TB;
   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) {
   const DeclContext *DC = D->getDeclContext();
   // Injected "Foo" within the class "Foo" has file scope, not class scope.
   if (auto *R = dyn_cast_or_null<RecordDecl>(D))
     if (R->isInjectedClassName())
       DC = DC->getParent();

clang-tools-extra/clangd/SourceCode.cpp

 }
 
 static void
 lex(llvm::StringRef Code, const LangOptions &LangOpts,
     llvm::function_ref<void(const syntax::Token &, const SourceManager &SM)>
         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);
 }
 
 llvm::StringMap<unsigned> collectIdentifiers(llvm::StringRef Content,
                                              const format::FormatStyle &Style) {
   llvm::StringMap<unsigned> Identifiers;

clang-tools-extra/clangd/XRefs.cpp

SymbolLocation toIndexLocation(const Location &Loc, std::string &URIStorage) {
   SymLoc.End.setColumn(Loc.range.end.character);
   return SymLoc;
 }
 
 // Returns the preferred location between an AST location and an index location.
 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);
   return Merged.CanonicalDeclaration;
 }
 
 std::vector<std::pair<const NamedDecl *, DeclRelationSet>>
 getDeclAtPositionWithRelations(ParsedAST &AST, SourceLocation Pos,

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

 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..
   ${CMAKE_CURRENT_BINARY_DIR}/..)
 
 set(LLVM_LINK_COMPONENTS
   FuzzMutate
   Support
   )
 
 # 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
   PRIVATE
   clangBasic
   clangFormat
   clangFrontend
   clangSema
   clangTooling
   clangToolingCore
   )
 target_link_libraries(clangd-fuzzer
   PRIVATE
   clangDaemon
   clangdSupport
   )

clang-tools-extra/clangd/fuzzer/FuzzerClangdMain.cpp

-//===---- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Implementation of main so we can build and test without linking libFuzzer.

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

add_clang_library(clangdRemoteIndex
     DEPENDS
     RemoteIndexProto
     RemoteIndexServiceProto
     )
 
   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

if (const Type *ExprType = E->getType().getTypePtrOrNull())
     if (ExprType->isVoidType())
       return false;
 
   // A plain reference to a name (e.g. variable) isn't  worth extracting.
   // FIXME: really? What if it's e.g. `std::is_same<void, void>::value`?
   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))
     return false;
 
   const SelectionTree::Node &OuterImplicit = N->outerImplicit();
   const auto *Parent = OuterImplicit.Parent;
   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>(),
                       OuterImplicit.ASTNode.get<Expr>()))
     return false;
 
   // Disable extraction of full RHS on assignment operations, e.g:
   // auto x = [[RHS_EXPR]];
const SelectionTree::Node *computeExtractedExpr(const SelectionTree::Node *N) {
   const clang::Expr *SelectedExpr = N->ASTNode.get<clang::Expr>();
   if (!SelectedExpr)
     return nullptr;
   // For function and member function DeclRefs, extract the whole call.
   if (llvm::isa<DeclRefExpr>(SelectedExpr) ||
       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)
       return nullptr;
   }
   if (!TargetNode || !eligibleForExtraction(TargetNode))
     return nullptr;
   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;
   bool prepare(const Selection &Inputs) override;
   Expected<Effect> apply(const Selection &Inputs) override;
   std::string title() const override {
     return "Extract subexpression to variable";
   }
if (const SelectionTree::Node *N =
           computeExtractedExpr(Inputs.ASTSelection.commonAncestor()))
     Target = std::make_unique<ExtractionContext>(N, SM, Ctx);
   return Target && Target->isExtractable();
 }
 
 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)))
     return std::move(Err);
   // replace expression with variable name
   if (auto Err = Result.add(Target->replaceWithVar(Range, VarName)))
     return std::move(Err);
   return Effect::mainFileEdit(Inputs.AST->getSourceManager(),
                               std::move(Result));
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang

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

JSONSpan(JSONTracer *Tracer, llvm::StringRef Name)
         if (!OriginTime)
           OriginTime = (*Parent)->StartTime;
 
         auto FlowID = nextID();
         Tracer->jsonEvent(
             "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);
       }
     }
 
     ~JSONSpan() {
       // Finally, record the event (ending at EndTime, not timestamp())!
       Tracer->jsonEvent("X",
                         llvm::json::Object{{"name", std::move(Name)},

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

TEST(ClangdServerTest, SearchLibDir) {
   SmallString<8> Version("4.9.3");
 
   // A lib dir for gcc installation
   SmallString<64> LibDir("/randomusr/lib/gcc/x86_64-linux-gnu");
   llvm::sys::path::append(LibDir, Version);
 
   // 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);
 
   SmallString<64> StringPath;
   llvm::sys::path::append(StringPath, IncludeDir, "string");
   FS.Files[StringPath] = "class mock_string {};";
 

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

MATCHER_P2(hasFlag, Flag, Path, "") {
   }
   if (!llvm::is_contained(Cmds.front().CommandLine, Flag)) {
     *result_listener << "flags are: " << printArgv(Cmds.front().CommandLine);
     return false;
   }
   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;
   auto Stale = std::chrono::steady_clock::now() - std::chrono::minutes(1);
   auto Fresh = std::chrono::steady_clock::now() + std::chrono::hours(24);
 
   DirectoryBasedGlobalCompilationDatabase GDB(FS);
   FS.Files["compile_flags.txt"] = "-DROOT";
TEST_F(DirectoryBasedGlobalCompilationDatabaseCacheTest, Cacheable) {
   EXPECT_EQ(Bar, lookupCDB(GDB, testPath("foo/test.cc"), Stale))
       << "cache still valid";
   auto FooBar = lookupCDB(GDB, testPath("foo/test.cc"), Fresh);
   EXPECT_THAT(FooBar, hasFlag("-DFOOBAR")) << "cdb reloaded";
 
   // 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.
   // However this *does* cause a CDB reload (we cache only one CDB per dir).
   FS.Files.erase("foo/compile_commands.json");
   auto FoobarAgain = lookupCDB(GDB, testPath("foo/test.cc"), Fresh);
   EXPECT_THAT(FoobarAgain, hasFlag("-DFOOBAR")) << "reloaded compile_flags";
   EXPECT_NE(FoobarAgain, FooBar) << "CDB discarded (shadowed within directory)";

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

TEST(RenameTest, WithinFileRename) {
   }
 }
 
 TEST(RenameTest, Renameable) {
   struct Case {
     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[] = {
       {R"cpp(// allow -- function-local
         void f(int [[Lo^cal]]) {
           [[Local]] = 2;
         }
       )cpp",

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

MATCHER_P2(TUState, PreambleActivity, ASTActivity, "") {
   }
   if (arg.ASTActivity.K != ASTActivity) {
     *result_listener << "aststate is " << arg.ASTActivity.K;
     return false;
   }
   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());
 }
 llvm::StringRef boundPath() {
   const std::string *V = Context::current().get(BoundPath);
   return V ? *V : llvm::StringRef("");
 }

clang-tools-extra/clangd/unittests/tweaks/ExtractVariableTests.cpp

TEST_F(ExtractVariableTest, Test) {
 
   // vector of pairs of input and output strings
   const std::vector<std::pair<std::string, std::string>> InputOutputs = {
       // extraction from variable declaration/assignment
       {R"cpp(void varDecl() {
                    int a = 5 * (4 + (3 [[- 1)]]);
                  })cpp",
        R"cpp(void varDecl() {
-                   auto dummy = (3 - 1); int a = 5 * (4 + dummy);
+                   auto placeholder = (3 - 1); int a = 5 * (4 + placeholder);
                  })cpp"},
       // FIXME: extraction from switch case
       /*{R"cpp(void f(int a) {
                if(1)
                  while(a < 1)
                    switch (1) {
                        case 1:
                          a = [[1 + 2]];
                          break;
                        default:
                          break;
                    }
              })cpp",
        R"cpp(void f(int a) {
-               auto dummy = 1 + 2; if(1)
+               auto placeholder = 1 + 2; if(1)
                  while(a < 1)
                    switch (1) {
                        case 1:
-                         a = dummy;
+                         a = placeholder;
                          break;
                        default:
                          break;
                    }
              })cpp"},*/
       // Macros
       {R"cpp(#define PLUS(x) x++
                  void f(int a) {
                    int y = PLUS([[1+a]]);
                  })cpp",
        /*FIXME: It should be extracted like this.
         R"cpp(#define PLUS(x) x++
               void f(int a) {
-                auto dummy = 1+a; int y = PLUS(dummy);
+                auto placeholder = 1+a; int y = PLUS(placeholder);
               })cpp"},*/
        R"cpp(#define PLUS(x) x++
                  void f(int a) {
-                   auto dummy = PLUS(1+a); int y = dummy;
+                   auto placeholder = PLUS(1+a); int y = placeholder;
                  })cpp"},
       // ensure InsertionPoint isn't inside a macro
       {R"cpp(#define LOOP(x) while (1) {a = x;}
                  void f(int a) {
                    if(1)
                     LOOP(5 + [[3]])
                  })cpp",
        R"cpp(#define LOOP(x) while (1) {a = x;}
                  void f(int a) {
-                   auto dummy = 3; if(1)
-                    LOOP(5 + dummy)
+                   auto placeholder = 3; if(1)
+                    LOOP(5 + placeholder)
                  })cpp"},
       {R"cpp(#define LOOP(x) do {x;} while(1);
                  void f(int a) {
                    if(1)
                     LOOP(5 + [[3]])
                  })cpp",
        R"cpp(#define LOOP(x) do {x;} while(1);
                  void f(int a) {
-                   auto dummy = 3; if(1)
-                    LOOP(5 + dummy)
+                   auto placeholder = 3; if(1)
+                    LOOP(5 + placeholder)
                  })cpp"},
       // attribute testing
       {R"cpp(void f(int a) {
                     [ [gsl::suppress("type")] ] for (;;) a = [[1]] + 1;
                  })cpp",
        R"cpp(void f(int a) {
-                    auto dummy = 1; [ [gsl::suppress("type")] ] for (;;) a = dummy + 1;
+                    auto placeholder = 1; [ [gsl::suppress("type")] ] for (;;) a = placeholder + 1;
                  })cpp"},
       // MemberExpr
       {R"cpp(class T {
                    T f() {
                      return [[T().f()]].f();
                    }
                  };)cpp",
        R"cpp(class T {
                    T f() {
-                     auto dummy = T().f(); return dummy.f();
+                     auto placeholder = T().f(); return placeholder.f();
                    }
                  };)cpp"},
       // Function DeclRefExpr
       {R"cpp(int f() {
                    return [[f]]();
                  })cpp",
        R"cpp(int f() {
-                   auto dummy = f(); return dummy;
+                   auto placeholder = f(); return placeholder;
                  })cpp"},
       // FIXME: Wrong result for \[\[clang::uninitialized\]\] int b = [[1]];
       // since the attr is inside the DeclStmt and the bounds of
       // DeclStmt don't cover the attribute.
 
       // Binary subexpressions
       {R"cpp(void f() {
                    int x = 1 + [[2 + 3 + 4]] + 5;
                  })cpp",
        R"cpp(void f() {
-                   auto dummy = 2 + 3 + 4; int x = 1 + dummy + 5;
+                   auto placeholder = 2 + 3 + 4; int x = 1 + placeholder + 5;
                  })cpp"},
       {R"cpp(void f() {
                    int x = [[1 + 2 + 3]] + 4 + 5;
                  })cpp",
        R"cpp(void f() {
-                   auto dummy = 1 + 2 + 3; int x = dummy + 4 + 5;
+                   auto placeholder = 1 + 2 + 3; int x = placeholder + 4 + 5;
                  })cpp"},
       {R"cpp(void f() {
                    int x = 1 + 2 + [[3 + 4 + 5]];
                  })cpp",
        R"cpp(void f() {
-                   auto dummy = 3 + 4 + 5; int x = 1 + 2 + dummy;
+                   auto placeholder = 3 + 4 + 5; int x = 1 + 2 + placeholder;
                  })cpp"},
       // Non-associative operations have no special support
       {R"cpp(void f() {
                    int x = 1 - [[2 - 3 - 4]] - 5;
                  })cpp",
        R"cpp(void f() {
-                   auto dummy = 1 - 2 - 3 - 4; int x = dummy - 5;
+                   auto placeholder = 1 - 2 - 3 - 4; int x = placeholder - 5;
                  })cpp"},
       // A mix of associative operators isn't associative.
       {R"cpp(void f() {
                    int x = 0 + 1 * [[2 + 3]] * 4 + 5;
                  })cpp",
        R"cpp(void f() {
-                   auto dummy = 1 * 2 + 3 * 4; int x = 0 + dummy + 5;
+                   auto placeholder = 1 * 2 + 3 * 4; int x = 0 + placeholder + 5;
                  })cpp"},
       // Overloaded operators are supported, we assume associativity
       // as if they were built-in.
       {R"cpp(struct S {
                    S(int);
                  };
                  S operator+(S, S);
 
                  void f() {
                    S x = S(1) + [[S(2) + S(3) + S(4)]] + S(5);
                  })cpp",
        R"cpp(struct S {
                    S(int);
                  };
                  S operator+(S, S);
 
                  void f() {
-                   auto dummy = S(2) + S(3) + S(4); S x = S(1) + dummy + S(5);
+                   auto placeholder = S(2) + S(3) + S(4); S x = S(1) + placeholder + S(5);
                  })cpp"},
       // Don't try to analyze across macro boundaries
       // FIXME: it'd be nice to do this someday (in a safe way)
       {R"cpp(#define ECHO(X) X
                  void f() {
                    int x = 1 + [[ECHO(2 + 3) + 4]] + 5;
                  })cpp",
        R"cpp(#define ECHO(X) X
                  void f() {
-                   auto dummy = 1 + ECHO(2 + 3) + 4; int x = dummy + 5;
+                   auto placeholder = 1 + ECHO(2 + 3) + 4; int x = placeholder + 5;
                  })cpp"},
       {R"cpp(#define ECHO(X) X
                  void f() {
                    int x = 1 + [[ECHO(2) + ECHO(3) + 4]] + 5;
                  })cpp",
        R"cpp(#define ECHO(X) X
                  void f() {
-                   auto dummy = 1 + ECHO(2) + ECHO(3) + 4; int x = dummy + 5;
+                   auto placeholder = 1 + ECHO(2) + ECHO(3) + 4; int x = placeholder + 5;
                  })cpp"},
   };
   for (const auto &IO : InputOutputs) {
     EXPECT_EQ(IO.second, apply(IO.first)) << IO.first;
   }
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang