[NFC][clangd] cleaning up llvm-qualified-auto

[kuhnel]

Summary

This is a cleanup of all llvm-qualified-auto findings.
This patch was created by automatically applying the fixes from
clang-tidy.

[sammccall]

There is a reasonable style rule here, but:

• the suggested fixes spell out const in ways we generally prefer not to. (And the rule doesn't require).
• Strings are a special case. auto* for string literals makes no sense to me, the check should be modified to either accept auto or replace with const char*

clang-tools-extra/clangd/AST.cpp

441

We usually use auto* rather than const auto* for locals like this.

For the same reason we don't const locals: it adds more noise than it helps.
(And if it's critical we spell out these things, we probably shouldn't be using auto at all)

When this check was introduced, there was a discussion about this and they agreed to have the check stop flagging auto*, but if it sees auto it will still suggest the const. So the automatic fixes generally aren't what we want, we need to drop const.

clang-tools-extra/clangd/index/IndexAction.cpp

64

This is a particularly confusing type.
The original code is atypical for clangd, I'd suggest changing to auto* File

clang-tools-extra/clangd/index/dex/Iterator.cpp

209

const char* or auto or StringRef for strings. "Some kind of pointer" is technically correct but unhelpful.

[kuhnel]

Based on Sam's comments and our offline discussion, I would propose:

1. abandon this patch
2. start a discussion on the mailing list to disable this check for all of the llvm monorepo.

Other thoughts?

[sammccall]

This check was written specifically for the LLVM monorepo, I doubt there'll be consensus to disable it.
https://reviews.llvm.org/D72217 has some previous discussion - some people want the consts spelled out, but we don't do this in clangd.
And I don't particularly think that would be the right thing to do: it's throwing out the baby with the bathwater.

I think we should rather:

• fix the check to exempt strings (I don't think this would be terribly controversial, but I might be wrong)
• land a version of this patch that doesn't add const in the places we don't normally use it

[kuhnel]

When trying to revert some of the changes, I just noticed there are a couple of if (const auto* ... in CodeComplete.cpp and AST.cpp (and maybe other files as well). So some folks seem to be using this right now. If we want to be consistent, we would have to remove these const as well.

I'm not sure what the right way forward would be.

@sammccall WDYT?

[sammccall]

In D113898#3140320, @kuhnel wrote:

When trying to revert some of the changes, I just noticed there are a couple of if (const auto* ... in CodeComplete.cpp and AST.cpp (and maybe other files as well). So some folks seem to be using this right now. If we want to be consistent, we would have to remove these const as well.

I'm not sure what the right way forward would be.

@sammccall WDYT?

Yeah, we don't really have a consistent pattern for this after all.
In current code, where Foo is local and can be const:

• we favor Foo over const Foo
• we favor const Foo* over Foo* (the language often forces this)
• auto *Foo vs const auto *Foo is a mix

Most of the time, I think the const is noise in contexts where auto is appropriate. But not all the time!
"This variable is intended for mutation" would be a useful signal, but marking every *other* variable as const is an ineffective and expensive way to do it. And we have no good way to keep that consistent.

So I'd suggest:

• if applying bulk fixes like this and you don't want to look through case-by-case, prefer auto*
• if a human has written const auto*, then there may or may not be a good reason. To "clean these up" would require two people to think about whether const communicates something important in each location, and I don't personally think that's a great use of time.

[• Quuxplusone]

In D113898#3140320, @kuhnel wrote:

When trying to revert some of the changes, I just noticed there are a couple of if (const auto* ... in CodeComplete.cpp and AST.cpp (and maybe other files as well). So some folks seem to be using this right now. If we want to be consistent, we would have to remove these const as well.

Just in case it's news to anyone: (1) Theoretically, the compiler has enough information to tell you when it's deducing a cv-qualified type for a non-forwarding-reference auto; and personally I'd like such a warning and would go fix my code every time it fired. I like that const auto *p has the same "shape" as const Widget *p. That sometimes a non-const auto can secretly mean constWidget is weird and I don't like it.
(2) In template contexts, const auto * can be significant, because maybe in some instantiations the const doesn't matter and in others it does. https://quuxplusone.github.io/blog/2020/03/04/field-report-on-lifetime-extension/#true-positive-3-conditionally-redundant-lifetime-extension-in-template-code is related.

[kuhnel]

Looking at the documentation, this looks like a bug in the clang-tidy check:
https://releases.llvm.org/13.0.0/tools/clang/tools/extra/docs/clang-tidy/checks/readability-qualified-auto.html

The rule llvm-qualified-auto should not add a const qualifier.

[kbobyrev]

In D113898#3167050, @kuhnel wrote:

Looking at the documentation, this looks like a bug in the clang-tidy check:
https://releases.llvm.org/13.0.0/tools/clang/tools/extra/docs/clang-tidy/checks/readability-qualified-auto.html

The rule llvm-qualified-auto should not add a const qualifier.

I don't see how that is a bug: the docs specially cover the const auto * conversion in the first example by drawing the line between observe() (non-mutating function) and change() (possibly mutating function).

[kuhnel]

In D113898#3167215, @kbobyrev wrote:

In D113898#3167050, @kuhnel wrote:

Looking at the documentation, this looks like a bug in the clang-tidy check:
https://releases.llvm.org/13.0.0/tools/clang/tools/extra/docs/clang-tidy/checks/readability-qualified-auto.html

The rule llvm-qualified-auto should not add a const qualifier.

I don't see how that is a bug: the docs specially cover the const auto * conversion in the first example by drawing the line between observe() (non-mutating function) and change() (possibly mutating function).

Sorry I should have been more precise here: AddConstToQualified allows to configure if we want to have const added or not. The default for that rule is true. However the last sentence on that page says:

Note in the LLVM alias, the default value is false.

So my understanding of this is: With the LLVM-rules we're using, const should not be added.

[kuhnel]

reverted the const as advised in Sam's comment

[kuhnel]

fixed more const ClangdTests.cpp

[kuhnel]

more reverts of consts

[kuhnel]

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

2550

while clang-tidy added a const here, I would keep it for consistency with the next line...

[kuhnel]

TODO: check for remaining const then submit.

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

252

remove const here

clang-tools-extra/clangd/AST.cpp

bool VisitFunctionDecl(FunctionDecl *D) {
     if (CurLoc.isInvalid())
       CurLoc = D->getSourceRange().getBegin();
     if (CurLoc != SearchedLocation)
       return true;
 
     const AutoType *AT = D->getReturnType()->getContainedAutoType();
     if (AT && !AT->getDeducedType().isNull()) {
       DeducedType = AT->getDeducedType();
-    } else if (auto DT = dyn_cast<DecltypeType>(D->getReturnType())) {
+    } else if (const auto *DT = dyn_cast<DecltypeType>(D->getReturnType())) {
       // auto in a trailing return type just points to a DecltypeType and
       // getContainedAutoType does not unwrap it.
       if (!DT->getUnderlyingType().isNull())
         DeducedType = DT->getUnderlyingType();
     } else if (!D->getReturnType().isNull()) {
       DeducedType = D->getReturnType();
     }
     return true;

clang-tools-extra/clangd/CodeComplete.cpp

struct BundledEntry {
     std::string Signature;
     std::string ReturnType;
   };
 
   // If all BundledEntries have the same value for a property, return it.
   template <std::string BundledEntry::*Member>
   const std::string *onlyValue() const {
     auto B = Bundled.begin(), E = Bundled.end();
-    for (auto I = B + 1; I != E; ++I)
+    for (const auto *I = B + 1; I != E; ++I)
       if (I->*Member != B->*Member)
         return nullptr;
     return &(B->*Member);
   }
 
   template <bool BundledEntry::*Member> const bool *onlyValue() const {
     auto B = Bundled.begin(), E = Bundled.end();
-    for (auto I = B + 1; I != E; ++I)
+    for (const auto *I = B + 1; I != E; ++I)
       if (I->*Member != B->*Member)
         return nullptr;
     return &(B->*Member);
   }
 
   std::string summarizeReturnType() const {
     if (auto *RT = onlyValue<&BundledEntry::ReturnType>())
       return *RT;

clang-tools-extra/clangd/ExpectedTypes.cpp

typeOfCompletion(const CodeCompletionResult &R) {
   if (auto *Template = dyn_cast_or_null<TemplateDecl>(D))
     D = Template->getTemplatedDecl();
   auto *VD = dyn_cast_or_null<ValueDecl>(D);
   if (!VD)
     return llvm::None; // We handle only variables and functions below.
   auto T = VD->getType();
   if (T.isNull())
     return llvm::None;
-  if (auto FuncT = T->getAs<FunctionType>()) {
+  if (const auto *FuncT = T->getAs<FunctionType>()) {
     // Functions are a special case. They are completed as 'foo()' and we want
     // to match their return type rather than the function type itself.
     // FIXME(ibiryukov): in some cases, we might want to avoid completing `()`
     // after the function name, e.g. `std::cout << std::endl`.
     return FuncT->getReturnType();
   }
   return T;
 }

clang-tools-extra/clangd/FindSymbols.cpp

if (D->isImplicit())
       return VisitKind::No;
 
     if (llvm::isa<LinkageSpecDecl>(D) || llvm::isa<ExportDecl>(D))
       return VisitKind::OnlyChildren;
 
     if (!llvm::isa<NamedDecl>(D))
       return VisitKind::No;
 
-    if (auto Func = llvm::dyn_cast<FunctionDecl>(D)) {
+    if (auto *Func = llvm::dyn_cast<FunctionDecl>(D)) {
       // Some functions are implicit template instantiations, those should be
       // ignored.
       if (auto *Info = Func->getTemplateSpecializationInfo()) {
         if (!Info->isExplicitInstantiationOrSpecialization())
           return VisitKind::No;
       }
       // Only visit the function itself, do not visit the children (i.e.
       // function parameters, etc.)

clang-tools-extra/clangd/HeaderSourceSwitch.cpp

llvm::Optional<Path> getCorrespondingHeaderOrSource(
     PathRef OriginalFile, llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS) {
   llvm::StringRef SourceExtensions[] = {".cpp", ".c", ".cc", ".cxx",
                                         ".c++", ".m", ".mm"};
   llvm::StringRef HeaderExtensions[] = {".h", ".hh", ".hpp", ".hxx", ".inc"};
 
   llvm::StringRef PathExt = llvm::sys::path::extension(OriginalFile);
 
   // Lookup in a list of known extensions.
-  auto SourceIter =
+  auto *SourceIter =
       llvm::find_if(SourceExtensions, [&PathExt](PathRef SourceExt) {
         return SourceExt.equals_insensitive(PathExt);
       });
   bool IsSource = SourceIter != std::end(SourceExtensions);
 
-  auto HeaderIter =
+  auto *HeaderIter =
       llvm::find_if(HeaderExtensions, [&PathExt](PathRef HeaderExt) {
         return HeaderExt.equals_insensitive(PathExt);
       });
   bool IsHeader = HeaderIter != std::end(HeaderExtensions);
 
   // We can only switch between the known extensions.
   if (!IsSource && !IsHeader)
     return None;

clang-tools-extra/clangd/Hover.cpp

else if (const ObjCContainerDecl *CD = dyn_cast<ObjCContainerDecl>(DC))
     return printObjCContainer(*CD);
 
   auto GetName = [](const TypeDecl *D) {
     if (!D->getDeclName().isEmpty()) {
       PrintingPolicy Policy = D->getASTContext().getPrintingPolicy();
       Policy.SuppressScope = true;
       return declaredType(D).getAsString(Policy);
     }
-    if (auto RD = dyn_cast<RecordDecl>(D))
+    if (const auto *RD = dyn_cast<RecordDecl>(D))
       return ("(anonymous " + RD->getKindName() + ")").str();
     return std::string("");
   };
   while (DC) {
     if (const TypeDecl *TD = dyn_cast<TypeDecl>(DC))
       Scopes.push_back(GetName(TD));
     else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(DC))
       Scopes.push_back(FD->getNameAsString());

clang-tools-extra/clangd/TUScheduler.cpp

DebouncePolicy::compute(llvm::ArrayRef<clock::duration> History) const {
   assert(Min <= Max && "Invalid policy");
   if (History.empty())
     return Max; // Arbitrary.
 
   // Base the result on the median rebuild.
   // nth_element needs a mutable array, take the chance to bound the data size.
   History = History.take_back(15);
   llvm::SmallVector<clock::duration, 15> Recent(History.begin(), History.end());
-  auto Median = Recent.begin() + Recent.size() / 2;
+  auto *Median = Recent.begin() + Recent.size() / 2;
   std::nth_element(Recent.begin(), Median, Recent.end());
 
   clock::duration Target =
       std::chrono::duration_cast<clock::duration>(RebuildRatio * *Median);
   if (Target > Max)
     return Max;
   if (Target < Min)
     return Min;

clang-tools-extra/clangd/index/IndexAction.cpp

void FileChanged(SourceLocation Loc, FileChangeReason Reason,
                    SrcMgr::CharacteristicKind FileType,
                    FileID PrevFID) override {
     // We only need to process each file once. So we don't care about anything
     // but entries.
     if (Reason != FileChangeReason::EnterFile)
       return;
 
     const auto FileID = SM.getFileID(Loc);
-    const auto File = SM.getFileEntryForID(FileID);
+    const auto *const File = SM.getFileEntryForID(FileID);
     auto URI = toURI(File);
     if (!URI)
       return;
     auto I = IG.try_emplace(*URI).first;
 
     auto &Node = I->getValue();
     // Node has already been populated.
     if (Node.URI.data() == I->getKeyData()) {

clang-tools-extra/clangd/index/SymbolCollector.cpp

 
 namespace clang {
 namespace clangd {
 namespace {
 
 /// If \p ND is a template specialization, returns the described template.
 /// Otherwise, returns \p ND.
 const NamedDecl &getTemplateOrThis(const NamedDecl &ND) {
-  if (auto T = ND.getDescribedTemplate())
+  if (auto *T = ND.getDescribedTemplate())
     return *T;
   return ND;
 }
 
 // Checks whether the decl is a private symbol in a header generated by
 // protobuf compiler.
 // FIXME: make filtering extensible when there are more use cases for symbol
 // filters.

clang-tools-extra/clangd/index/dex/Iterator.cpp

public:
 
   size_t estimateSize() const override {
     return Children.front()->estimateSize();
   }
 
 private:
   llvm::raw_ostream &dump(llvm::raw_ostream &OS) const override {
     OS << "(& ";
-    auto Separator = "";
+    const auto *Separator = "";
     for (const auto &Child : Children) {
       OS << Separator << *Child;
       Separator = " ";
     }
     OS << ')';
     return OS;
   }
 
size_t estimateSize() const override {
     for (const auto &Child : Children)
       Size = std::max(Size, Child->estimateSize());
     return Size;
   }
 
 private:
   llvm::raw_ostream &dump(llvm::raw_ostream &OS) const override {
     OS << "(| ";
-    auto Separator = "";
+    const auto *Separator = "";
     for (const auto &Child : Children) {
       OS << Separator << *Child;
       Separator = " ";
     }
     OS << ')';
     return OS;
   }
 

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

llvm::StringLiteral kind() const override {
     return CodeAction::REFACTOR_KIND;
   }
   bool hidden() const override { return true; }
 };
 REGISTER_TWEAK(AnnotateHighlightings)
 
 Expected<Tweak::Effect> AnnotateHighlightings::apply(const Selection &Inputs) {
   const Decl *CommonDecl = nullptr;
-  for (auto N = Inputs.ASTSelection.commonAncestor(); N && !CommonDecl;
+  for (const auto *N = Inputs.ASTSelection.commonAncestor(); N && !CommonDecl;
        N = N->Parent)
     CommonDecl = N->ASTNode.get<Decl>();
 
   std::vector<HighlightingToken> HighlightingTokens;
   if (!CommonDecl) {
     // Now we hit the TUDecl case where commonAncestor() returns null
     // intendedly. We only annotate tokens in the main file, so use the default
     // traversal scope (which is the top level decls of the main file).

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

 
 // Returns the canonical declaration for the given FunctionDecl. This will
 // usually be the first declaration in current translation unit with the
 // exception of template specialization.
 // For those we return first declaration different than the canonical one.
 // Because canonical declaration points to template decl instead of
 // specialization.
 const FunctionDecl *findTarget(const FunctionDecl *FD) {
-  auto CanonDecl = FD->getCanonicalDecl();
+  const auto *CanonDecl = FD->getCanonicalDecl();
   if (!FD->isFunctionTemplateSpecialization() || CanonDecl == FD)
     return CanonDecl;
   // For specializations CanonicalDecl is the TemplatedDecl, which is not the
   // target we want to inline into. Instead we traverse previous decls to find
   // the first forward decl for this specialization.
-  auto PrevDecl = FD;
+  const auto *PrevDecl = FD;
   while (PrevDecl->getPreviousDecl() != CanonDecl) {
     PrevDecl = PrevDecl->getPreviousDecl();
     assert(PrevDecl && "Found specialization without template decl");
   }
   return PrevDecl;
 }
 
 // Returns the beginning location for a FunctionDecl. Returns location of

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

 ///   CallExpr
 ///   |-DeclRefExpr fcall
 ///   `-StringLiteral "foo"
 class DumpAST : public Tweak {
 public:
   const char *id() const override final;
 
   bool prepare(const Selection &Inputs) override {
-    for (auto N = Inputs.ASTSelection.commonAncestor(); N && !Node;
+    for (const auto *N = Inputs.ASTSelection.commonAncestor(); N && !Node;
          N = N->Parent)
       if (dumpable(N->ASTNode))
         Node = N->ASTNode;
     return Node.hasValue();
   }
   Expected<Effect> apply(const Selection &Inputs) override;
   std::string title() const override {
     return std::string(

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

 REGISTER_TWEAK(ExpandMacro)
 
 /// Finds a spelled token that the cursor is pointing at.
 static const syntax::Token *
 findTokenUnderCursor(const SourceManager &SM,
                      llvm::ArrayRef<syntax::Token> Spelled,
                      unsigned CursorOffset) {
   // Find the token that strats after the offset, then look at a previous one.
-  auto It = llvm::partition_point(Spelled, [&](const syntax::Token &T) {
+  const auto *It = llvm::partition_point(Spelled, [&](const syntax::Token &T) {
     assert(T.location().isFileID());
     return SM.getFileOffset(T.location()) <= CursorOffset;
   });
   if (It == Spelled.begin())
     return nullptr;
   // Check the token we found actually touches the cursor position.
   --It;
   return It->range(SM).touches(CursorOffset) ? It : nullptr;

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

 }
 
 TEST(ClangdServerTest, ParseWithHeader) {
   parseSourceAndDumpAST("foo.cpp", "#include \"foo.h\"", {},
                         /*ExpectErrors=*/true);
   parseSourceAndDumpAST("foo.cpp", "#include \"foo.h\"", {{"foo.h", ""}},
                         /*ExpectErrors=*/false);
 
-  const auto SourceContents = R"cpp(
+  const auto *const SourceContents = R"cpp(
 #include "foo.h"
 int b = a;
 )cpp";
   parseSourceAndDumpAST("foo.cpp", SourceContents, {{"foo.h", ""}},
                         /*ExpectErrors=*/true);
   parseSourceAndDumpAST("foo.cpp", SourceContents, {{"foo.h", "int a;"}},
                         /*ExpectErrors=*/false);
 }
 
 TEST(ClangdServerTest, Reparse) {
   MockFS FS;
   ErrorCheckingCallbacks DiagConsumer;
   MockCompilationDatabase CDB;
   ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &DiagConsumer);
 
-  const auto SourceContents = R"cpp(
+  const auto *const SourceContents = R"cpp(
 #include "foo.h"
 int b = a;
 )cpp";
 
   auto FooCpp = testPath("foo.cpp");
 
   FS.Files[testPath("foo.h")] = "int a;";
   FS.Files[FooCpp] = SourceContents;

 }
 
 TEST(ClangdServerTest, ReparseOnHeaderChange) {
   MockFS FS;
   ErrorCheckingCallbacks DiagConsumer;
   MockCompilationDatabase CDB;
   ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &DiagConsumer);
 
-  const auto SourceContents = R"cpp(
+  const auto *const SourceContents = R"cpp(
 #include "foo.h"
 int b = a;
 )cpp";
 
   auto FooCpp = testPath("foo.cpp");
   auto FooH = testPath("foo.h");
 
   FS.Files[FooH] = "int a;";
TEST(ClangdServerTest, SearchLibDir) {
   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 {};";
 
   auto FooCpp = testPath("foo.cpp");
-  const auto SourceContents = R"cpp(
+  const auto *const SourceContents = R"cpp(
 #include <string>
 mock_string x;
 )cpp";
   FS.Files[FooCpp] = SourceContents;
 
   runAddDocument(Server, FooCpp, SourceContents);
   EXPECT_FALSE(DiagConsumer.hadErrorInLastDiags());
 
-  const auto SourceContentsWithError = R"cpp(
+  const auto *const SourceContentsWithError = R"cpp(
 #include <string>
 std::string x;
 )cpp";
   runAddDocument(Server, FooCpp, SourceContentsWithError);
   EXPECT_TRUE(DiagConsumer.hadErrorInLastDiags());
 }
 #endif // LLVM_ON_UNIX
 
 TEST(ClangdServerTest, ForceReparseCompileCommand) {
   MockFS FS;
   ErrorCheckingCallbacks DiagConsumer;
   MockCompilationDatabase CDB;
   ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &DiagConsumer);
 
   auto FooCpp = testPath("foo.cpp");
-  const auto SourceContents1 = R"cpp(
+  const auto *const SourceContents1 = R"cpp(
 template <class T>
 struct foo { T x; };
 )cpp";
-  const auto SourceContents2 = R"cpp(
+  const auto *const SourceContents2 = R"cpp(
 template <class T>
 struct bar { T x; };
 )cpp";
 
   FS.Files[FooCpp] = "";
 
   // First parse files in C mode and check they produce errors.
   CDB.ExtraClangFlags = {"-xc"};

 
 TEST(ClangdServerTest, ForceReparseCompileCommandDefines) {
   MockFS FS;
   ErrorCheckingCallbacks DiagConsumer;
   MockCompilationDatabase CDB;
   ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &DiagConsumer);
 
   auto FooCpp = testPath("foo.cpp");
-  const auto SourceContents = R"cpp(
+  const auto *const SourceContents = R"cpp(
 #ifdef WITH_ERROR
 this
 #endif
 
 int main() { return 0; }
 )cpp";
   FS.Files[FooCpp] = "";
 

 
 TEST(ClangdServerTest, FileStats) {
   MockFS FS;
   ErrorCheckingCallbacks DiagConsumer;
   MockCompilationDatabase CDB;
   ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &DiagConsumer);
 
   Path FooCpp = testPath("foo.cpp");
-  const auto SourceContents = R"cpp(
+  const auto *const SourceContents = R"cpp(
 struct Something {
   int method();
 };
 )cpp";
   Path BarCpp = testPath("bar.cpp");
 
   FS.Files[FooCpp] = "";
   FS.Files[BarCpp] = "";
TEST(ClangdThreadingTest, StressTest) {
   // Without 'static' clang gives an error for a usage inside TestDiagConsumer.
   static const unsigned FilesCount = 5;
   const unsigned RequestsCount = 500;
   // Blocking requests wait for the parsing to complete, they slow down the test
   // dramatically, so they are issued rarely. Each
   // BlockingRequestInterval-request will be a blocking one.
   const unsigned BlockingRequestInterval = 40;
 
-  const auto SourceContentsWithoutErrors = R"cpp(
+  const auto *const SourceContentsWithoutErrors = R"cpp(
 int a;
 int b;
 int c;
 int d;
 )cpp";
 
-  const auto SourceContentsWithErrors = R"cpp(
+  const auto *const SourceContentsWithErrors = R"cpp(
 int a = x;
 int b;
 int c;
 int d;
 )cpp";
 
   // Giving invalid line and column number should not crash ClangdServer, but
   // just to make sure we're sometimes hitting the bounds inside the file we
public:
     }
 
   private:
     std::mutex Mutex;
     bool FirstRequest = true;
     std::promise<void> StartSecondReparse;
   };
 
-  const auto SourceContentsWithoutErrors = R"cpp(
+  const auto *const SourceContentsWithoutErrors = R"cpp(
 int a;
 int b;
 int c;
 int d;
 )cpp";
 
-  const auto SourceContentsWithErrors = R"cpp(
+  const auto *const SourceContentsWithErrors = R"cpp(
 int a = x;
 int b;
 int c;
 int d;
 )cpp";
 
   auto FooCpp = testPath("foo.cpp");
   MockFS FS;

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

TEST(FileIndexTest, HasSystemHeaderMappingsInPreamble) {
 
   auto Symbols = runFuzzyFind(*TU.index(), "");
   EXPECT_THAT(Symbols, ElementsAre(_));
   EXPECT_THAT(Symbols.begin()->IncludeHeaders.front().IncludeHeader,
               "<algorithm>");
 }
 
 TEST(FileIndexTest, TemplateParamsInLabel) {
-  auto Source = R"cpp(
+  const auto *Source = R"cpp(
 template <class Ty>
 class vector {
 };
 
 template <class Ty, class Arg>
 vector<Ty> make_vector(Arg A) {}
 )cpp";
 

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

TEST(Hover, DocsFromMostSpecial) {
   void foo() {
     X$doc1^<char>();
     X$doc2^<int>();
     X$doc3^<int*>();
   })cpp");
 
   TestTU TU = TestTU::withCode(T.code());
   auto AST = TU.build();
-  for (auto Comment : {"doc1", "doc2", "doc3"}) {
+  for (const auto *Comment : {"doc1", "doc2", "doc3"}) {
     for (const auto &P : T.points(Comment)) {
       auto H = getHover(AST, P, format::getLLVMStyle(), nullptr);
       ASSERT_TRUE(H);
       EXPECT_EQ(H->Documentation, Comment);
     }
   }
 }
 

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

public:
       void onFailedAST(PathRef File, llvm::StringRef Version,
                        std::vector<Diag> Diags, PublishFn Publish) override {
         reportDiagnostics(File, Diags, Publish);
       }
 
     private:
       void reportDiagnostics(PathRef File, llvm::ArrayRef<Diag> Diags,
                              PublishFn Publish) {
-        auto D = Context::current().get(DiagsCallbackKey);
+        const auto *D = Context::current().get(DiagsCallbackKey);
         if (!D)
           return;
         Publish([&]() {
           const_cast<
               llvm::unique_function<void(PathRef, std::vector<Diag>)> &> (*D)(
               File, std::move(Diags));
         });
       }

 TEST_F(TUSchedulerTests, EmptyPreamble) {
   TUScheduler S(CDB, optsForTest());
 
   auto Foo = testPath("foo.cpp");
   auto Header = testPath("foo.h");
 
   FS.Files[Header] = "void foo()";
   FS.Timestamps[Header] = time_t(0);
-  auto WithPreamble = R"cpp(
+  const auto *WithPreamble = R"cpp(
     #include "foo.h"
     int main() {}
   )cpp";
-  auto WithEmptyPreamble = R"cpp(int main() {})cpp";
+  const auto *WithEmptyPreamble = R"cpp(int main() {})cpp";
   S.update(Foo, getInputs(Foo, WithPreamble), WantDiagnostics::Auto);
   S.runWithPreamble(
       "getNonEmptyPreamble", Foo, TUScheduler::Stale,
       [&](Expected<InputsAndPreamble> Preamble) {
         // We expect to get a non-empty preamble.
         EXPECT_GT(
             cantFail(std::move(Preamble)).Preamble->Preamble.getBounds().Size,
             0u);
TEST_F(TUSchedulerTests, ASTSignalsSmokeTests) {
   TaskRun.wait();
 }
 
 TEST_F(TUSchedulerTests, RunWaitsForPreamble) {
   // Testing strategy: we update the file and schedule a few preamble reads at
   // the same time. All reads should get the same non-null preamble.
   TUScheduler S(CDB, optsForTest());
   auto Foo = testPath("foo.cpp");
-  auto NonEmptyPreamble = R"cpp(
+  const auto *NonEmptyPreamble = R"cpp(
     #define FOO 1
     #define BAR 2
 
     int main() {}
   )cpp";
   constexpr int ReadsToSchedule = 10;
   std::mutex PreamblesMut;
   std::vector<const void *> Preambles(ReadsToSchedule, nullptr);
TEST_F(TUSchedulerTests, MissingHeader) {
   FS.Files.try_emplace("a/__unused__");
   FS.Files.try_emplace("b/__unused__");
   TUScheduler S(CDB, optsForTest(), captureDiags());
 
   auto Source = testPath("foo.cpp");
   auto HeaderA = testPath("a/foo.h");
   auto HeaderB = testPath("b/foo.h");
 
-  auto SourceContents = R"cpp(
+  const auto *SourceContents = R"cpp(
       #include "foo.h"
       int c = b;
     )cpp";
 
   ParseInputs Inputs = getInputs(Source, SourceContents);
   std::atomic<size_t> DiagCount(0);
 
   // Update the source contents, which should trigger an initial build with

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

TEST_F(DefineInlineTest, UsingShadowDecls) {
 
   template <typename T>
   void b^ar() {
     foo(T());
   })cpp");
 }
 
 TEST_F(DefineInlineTest, TransformNestedNamespaces) {
-  auto Test = R"cpp(
+  const auto *Test = R"cpp(
     namespace a {
       void bar();
       namespace b {
         void baz();
         namespace c {
           void aux();
         }
       }
void f^oo() {
       b::baz();
       a::b::baz();
 
       aux();
       c::aux();
       b::c::aux();
       a::b::c::aux();
     })cpp";
-  auto Expected = R"cpp(
+  const auto *Expected = R"cpp(
     namespace a {
       void bar();
       namespace b {
         void baz();
         namespace c {
           void aux();
         }
       }
const auto *Expected = R"cpp(
     using namespace a;
     using namespace b;
     using namespace c;
     )cpp";
   EXPECT_EQ(apply(Test), Expected);
 }
 
 TEST_F(DefineInlineTest, TransformUsings) {
-  auto Test = R"cpp(
+  const auto *Test = R"cpp(
     namespace a { namespace b { namespace c { void aux(); } } }
 
     void foo();
     void f^oo() {
       using namespace a;
       using namespace b;
       using namespace c;
       using c::aux;
       namespace d = c;
     })cpp";
-  auto Expected = R"cpp(
+  const auto *Expected = R"cpp(
     namespace a { namespace b { namespace c { void aux(); } } }
 
     void foo(){
       using namespace a;
       using namespace a::b;
       using namespace a::b::c;
       using a::b::c::aux;
       namespace d = a::b::c;
     }
     )cpp";
   EXPECT_EQ(apply(Test), Expected);
 }
 
 TEST_F(DefineInlineTest, TransformDecls) {
-  auto Test = R"cpp(
+  const auto *Test = R"cpp(
     void foo();
     void f^oo() {
       class Foo {
       public:
         void foo();
         int x;
       };
 
       enum En { Zero, One };
       En x = Zero;
 
       enum class EnClass { Zero, One };
       EnClass y = EnClass::Zero;
     })cpp";
-  auto Expected = R"cpp(
+  const auto *Expected = R"cpp(
     void foo(){
       class Foo {
       public:
         void foo();
         int x;
       };
 
       enum En { Zero, One };
       En x = Zero;
 
       enum class EnClass { Zero, One };
       EnClass y = EnClass::Zero;
     }
     )cpp";
   EXPECT_EQ(apply(Test), Expected);
 }
 
 TEST_F(DefineInlineTest, TransformTemplDecls) {
-  auto Test = R"cpp(
+  const auto *Test = R"cpp(
     namespace a {
       template <typename T> class Bar {
       public:
         void bar();
       };
       template <typename T> T bar;
       template <typename T> void aux() {}
     }
 
     void foo();
 
     using namespace a;
     void f^oo() {
       bar<Bar<int>>.bar();
       aux<Bar<int>>();
     })cpp";
-  auto Expected = R"cpp(
+  const auto *Expected = R"cpp(
     namespace a {
       template <typename T> class Bar {
       public:
         void bar();
       };
       template <typename T> T bar;
       template <typename T> void aux() {}
     }
 
     void foo(){
       a::bar<a::Bar<int>>.bar();
       a::aux<a::Bar<int>>();
     }
 
     using namespace a;
     )cpp";
   EXPECT_EQ(apply(Test), Expected);
 }
 
 TEST_F(DefineInlineTest, TransformMembers) {
-  auto Test = R"cpp(
+  const auto *Test = R"cpp(
     class Foo {
       void foo();
     };
 
     void Foo::f^oo() {
       return;
     })cpp";
-  auto Expected = R"cpp(
+  const auto *Expected = R"cpp(
     class Foo {
       void foo(){
       return;
     }
     };
 
     )cpp";
   EXPECT_EQ(apply(Test), Expected);
class Foo {
       return;
     }
     };)cpp";
   EXPECT_THAT(EditedFiles,
               ElementsAre(FileWithContents(testPath("a.h"), Expected)));
 }
 
 TEST_F(DefineInlineTest, TransformDependentTypes) {
-  auto Test = R"cpp(
+  const auto *Test = R"cpp(
     namespace a {
       template <typename T> class Bar {};
     }
 
     template <typename T>
     void foo();
 
     using namespace a;
     template <typename T>
     void f^oo() {
       Bar<T> B;
       Bar<Bar<T>> q;
     })cpp";
-  auto Expected = R"cpp(
+  const auto *Expected = R"cpp(
     namespace a {
       template <typename T> class Bar {};
     }
 
     template <typename T>
     void foo(){
       a::Bar<T> B;
       a::Bar<a::Bar<T>> q;
std::pair<llvm::StringRef, llvm::StringRef> Cases[] = {
 
           )cpp"},
   };
   for (const auto &Case : Cases)
     EXPECT_EQ(apply(Case.first), Case.second) << Case.first;
 }
 
 TEST_F(DefineInlineTest, TransformTypeLocs) {
-  auto Test = R"cpp(
+  const auto *Test = R"cpp(
     namespace a {
       template <typename T> class Bar {
       public:
         template <typename Q> class Baz {};
       };
       class Foo{};
     }
 
     void foo();
 
     using namespace a;
     void f^oo() {
       Bar<int> B;
       Foo foo;
       a::Bar<Bar<int>>::Baz<Bar<int>> q;
     })cpp";
-  auto Expected = R"cpp(
+  const auto *Expected = R"cpp(
     namespace a {
       template <typename T> class Bar {
       public:
         template <typename Q> class Baz {};
       };
       class Foo{};
     }
 
     void foo(){
       a::Bar<int> B;
       a::Foo foo;
       a::Bar<a::Bar<int>>::Baz<a::Bar<int>> q;
     }
 
     using namespace a;
     )cpp";
   EXPECT_EQ(apply(Test), Expected);
 }
 
 TEST_F(DefineInlineTest, TransformDeclRefs) {
-  auto Test = R"cpp(
+  const auto *Test = R"cpp(
     namespace a {
       template <typename T> class Bar {
       public:
         void foo();
         static void bar();
         int x;
         static int y;
       };
void f^oo() {
       a::bar();
       Bar<Bar<int>>::bar();
       a::Bar<int>::bar();
       B.x = Bar<int>::y;
       Bar<int>::y = 3;
       bar();
       a::test();
     })cpp";
-  auto Expected = R"cpp(
+  const auto *Expected = R"cpp(
     namespace a {
       template <typename T> class Bar {
       public:
         void foo();
         static void bar();
         int x;
         static int y;
       };
void foo(){
       a::test();
     }
     using namespace a;
     )cpp";
   EXPECT_EQ(apply(Test), Expected);
 }
 
 TEST_F(DefineInlineTest, StaticMembers) {
-  auto Test = R"cpp(
+  const auto *Test = R"cpp(
     namespace ns { class X { static void foo(); void bar(); }; }
     void ns::X::b^ar() {
       foo();
     })cpp";
-  auto Expected = R"cpp(
+  const auto *Expected = R"cpp(
     namespace ns { class X { static void foo(); void bar(){
       foo();
     } }; }
     )cpp";
   EXPECT_EQ(apply(Test), Expected);
 }
 
 TEST_F(DefineInlineTest, TransformParamNames) {
est);
         void foo(PARAM, TYPE b, TYPE c, TYPE d = BODY(x)){}
         )cpp"},
   };
   for (const auto &Case : Cases)
     EXPECT_EQ(apply(Case.first), Case.second) << Case.first;
 }
 
 TEST_F(DefineInlineTest, TransformTemplParamNames) {
-  auto Test = R"cpp(
+  const auto *Test = R"cpp(
     struct Foo {
       struct Bar {
         template <class, class X,
                   template<typename> class, template<typename> class Y,
                   int, int Z>
         void foo(X, Y<X>, int W = 5 * Z + 2);
       };
     };
 
     template <class T, class U,
               template<typename> class V, template<typename> class W,
               int X, int Y>
     void Foo::Bar::f^oo(U, W<U>, int Q) {})cpp";
-  auto Expected = R"cpp(
+  const auto *Expected = R"cpp(
     struct Foo {
       struct Bar {
         template <class T, class U,
                   template<typename> class V, template<typename> class W,
                   int X, int Y>
         void foo(U, W<U>, int Q = 5 * Y + 2){}
       };
     };
 
     )cpp";
   EXPECT_EQ(apply(Test), Expected);
 }
 
 TEST_F(DefineInlineTest, TransformInlineNamespaces) {
-  auto Test = R"cpp(
+  const auto *Test = R"cpp(
     namespace a { inline namespace b { namespace { struct Foo{}; } } }
     void foo();
 
     using namespace a;
     void ^foo() {Foo foo;})cpp";
-  auto Expected = R"cpp(
+  const auto *Expected = R"cpp(
     namespace a { inline namespace b { namespace { struct Foo{}; } } }
     void foo(){a::Foo foo;}
 
     using namespace a;
     )cpp";
   EXPECT_EQ(apply(Test), Expected);
 }