[clangd] Use ref counted strings throughout for File Contents

[njames93]

clang-tools-extra/clangd/ClangdServer.h

195–198 ↗

(On Diff #329722)

This overload is now only used for tests, should it be removed and update all the tests that use it to the new version.

clang-tools-extra/clangd/DraftStore.h

25–28

This is here for convenience, but should probably go into another header, just unsure if any of them fit the purpose.

[sammccall]

Avoiding copies seems nice, but this makes some interfaces more awkward. Do you have any measurements that some of these copies matter?

(The dirty FS changes avoided coping all the dirty buffers at once, but it seems like these changes will mostly save ~1 file copy per operation)

clang-tools-extra/clangd/ClangdServer.h

190 ↗

(On Diff #329722)

what's the purpose of changing this interface?

The only callers that matter are in ClangdLSPServer, and this signature requires it to copy anyway. So why not copy inside ClangdServer?

(StringRef is more convenient to for tests and C++ embedders, and just a bit less churn)

clang-tools-extra/clangd/Preamble.cpp

230

I don't think this change makes sense, we don't need ownership here

322

again, no need for ownership

375

and here

[njames93]

Remove some unneeded changes.

[njames93]

Remove other unnecessary ownership.

[njames93]

I've cleaned some changes up a bit. I do agree its not as important as the dirty buffer case, but this is about uniformity as much as anything.

[sammccall]

clang-tools-extra/clangd/ClangdLSPServer.cpp

678

you're moving into a stringref here

clang-tools-extra/clangd/ClangdServer.cpp

214

nit: we generally prefer to qualify the types, can you revert here?

clang-tools-extra/clangd/ClangdLSPServer.cpp

void ClangdLSPServer::onSync(const NoParams &, Callback<std::nullptr_t> Reply) {
   else
     Reply(error("Not idle after a minute"));
 }
 
 void ClangdLSPServer::onDocumentDidOpen(
     const DidOpenTextDocumentParams &Params) {
   PathRef File = Params.textDocument.uri.file();
 
-  const std::string &Contents = Params.textDocument.text;
-
-  Server->addDocument(File, Contents,
+  Server->addDocument(File, Params.textDocument.text,
                       encodeVersion(Params.textDocument.version),
                       WantDiagnostics::Yes);
 }
 
 void ClangdLSPServer::onDocumentDidChange(
     const DidChangeTextDocumentParams &Params) {
   auto WantDiags = WantDiagnostics::Auto;
   if (Params.wantDiagnostics.hasValue())
if (auto Err = applyChange(NewCode, Change)) {
       // If this fails, we are most likely going to be not in sync anymore with
       // the client.  It is better to remove the draft and let further
       // operations fail rather than giving wrong results.
       Server->removeDocument(File);
       elog("Failed to update {0}: {1}", File, std::move(Err));
       return;
     }
   }
-  Server->addDocument(File, NewCode, encodeVersion(Params.textDocument.version),
-                      WantDiags, Params.forceRebuild);
+  Server->addDocument(File, std::move(NewCode),
+                      encodeVersion(Params.textDocument.version), WantDiags,
+                      Params.forceRebuild);
 }
 
 void ClangdLSPServer::onDocumentDidSave(
     const DidSaveTextDocumentParams &Params) {
   Server->reparseOpenFilesIfNeeded([](llvm::StringRef) { return true; });
 }
 
 void ClangdLSPServer::onFileEvent(const DidChangeWatchedFilesParams &Params) {

clang-tools-extra/clangd/ClangdServer.cpp

ClangdServer::~ClangdServer() {
   if (FeatureModules) {
     for (auto &Mod : *FeatureModules)
       Mod.stop();
     for (auto &Mod : *FeatureModules)
       Mod.blockUntilIdle(Deadline::infinity());
   }
 }
 
-void ClangdServer::addDocument(PathRef File, llvm::StringRef Contents,
+void ClangdServer::addDocument(PathRef File, StringRef Contents,
                                llvm::StringRef Version,
                                WantDiagnostics WantDiags, bool ForceRebuild) {
-  std::string ActualVersion = DraftMgr.addDraft(File, Version, Contents);
+  auto RefContents = std::make_shared<std::string>(Contents);
+  std::string ActualVersion = DraftMgr.addDraft(File, Version, RefContents);
   ParseOptions Opts;
 
   // Compile command is set asynchronously during update, as it can be slow.
   ParseInputs Inputs;
   Inputs.TFS = &TFS;
-  Inputs.Contents = std::string(Contents);
+  Inputs.Contents = std::move(RefContents);
   Inputs.Version = std::move(ActualVersion);
   Inputs.ForceRebuild = ForceRebuild;
   Inputs.Opts = std::move(Opts);
   Inputs.Index = Index;
   Inputs.ClangTidyProvider = ClangTidyProvider;
   bool NewFile = WorkScheduler->update(File, Inputs, WantDiags);
   // If we loaded Foo.h, we want to make sure Foo.cpp is indexed.
   if (NewFile && BackgroundIdx)
if (!IP->Preamble) {
       vlog("Build for file {0} is not ready. Enter fallback mode.", File);
     } else if (CodeCompleteOpts.Index) {
       SpecFuzzyFind.emplace();
       {
         std::lock_guard<std::mutex> Lock(CachedCompletionFuzzyFindRequestMutex);
         SpecFuzzyFind->CachedReq = CachedCompletionFuzzyFindRequestByFile[File];
       }
     }
-    ParseInputs ParseInput{IP->Command, &TFS, IP->Contents.str()};
+    ParseInputs ParseInput{IP->Command, &TFS, IP->Contents};
     ParseInput.Index = Index;
 
     CodeCompleteOpts.MainFileSignals = IP->Signals;
     // FIXME(ibiryukov): even if Preamble is non-null, we may want to check
     // both the old and the new version in case only one of them matches.
     CodeCompleteResult Result = clangd::codeComplete(
         File, Pos, IP->Preamble, ParseInput, CodeCompleteOpts,
         SpecFuzzyFind ? SpecFuzzyFind.getPointer() : nullptr);
auto Action = [Pos, File = File.str(), CB = std::move(CB),
                  this](llvm::Expected<InputsAndPreamble> IP) mutable {
     if (!IP)
       return CB(IP.takeError());
 
     const auto *PreambleData = IP->Preamble;
     if (!PreambleData)
       return CB(error("Failed to parse includes"));
 
-    ParseInputs ParseInput{IP->Command, &TFS, IP->Contents.str()};
+    ParseInputs ParseInput{IP->Command, &TFS, IP->Contents};
     ParseInput.Index = Index;
     CB(clangd::signatureHelp(File, Pos, *PreambleData, ParseInput));
   };
 
   // Unlike code completion, we wait for a preamble here.
   WorkScheduler->runWithPreamble("SignatureHelp", File, TUScheduler::Stale,
                                  std::move(Action));
 }
auto Action = [File = File.str(), NewName = NewName.str(), Pos, Opts,
     if (!InpAST)
       return CB(InpAST.takeError());
     auto R = clangd::rename({Pos, NewName, InpAST->AST, File,
                              DirtyFS->view(llvm::None), Index, Opts});
     if (!R)
       return CB(R.takeError());
 
     if (Opts.WantFormat) {
-      auto Style = getFormatStyleForFile(File, InpAST->Inputs.Contents,
+      auto Style = getFormatStyleForFile(File, *InpAST->Inputs.Contents,
                                          *InpAST->Inputs.TFS);
       llvm::Error Err = llvm::Error::success();
       for (auto &E : R->GlobalChanges)
         Err =
             llvm::joinErrors(reformatEdit(E.getValue(), Style), std::move(Err));
 
       if (Err)
         return CB(std::move(Err));
     }
     RenameFiles.record(R->GlobalChanges.size());
     return CB(*R);
   };
   WorkScheduler->runWithAST("Rename", File, std::move(Action));
 }
 
 // May generate several candidate selections, due to SelectionTree ambiguity.
 // vector of pointers because GCC doesn't like non-copyable Selection.
 static llvm::Expected<std::vector<std::unique_ptr<Tweak::Selection>>>
 tweakSelection(const Range &Sel, const InputsAndAST &AST) {
-  auto Begin = positionToOffset(AST.Inputs.Contents, Sel.start);
+  auto Begin = positionToOffset(*AST.Inputs.Contents, Sel.start);
   if (!Begin)
     return Begin.takeError();
-  auto End = positionToOffset(AST.Inputs.Contents, Sel.end);
+  auto End = positionToOffset(*AST.Inputs.Contents, Sel.end);
   if (!End)
     return End.takeError();
   std::vector<std::unique_ptr<Tweak::Selection>> Result;
   SelectionTree::createEach(
       AST.AST.getASTContext(), AST.AST.getTokens(), *Begin, *End,
       [&](SelectionTree T) {
         Result.push_back(std::make_unique<Tweak::Selection>(
             AST.Inputs.Index, AST.AST, *Begin, *End, std::move(T)));

 
 void ClangdServer::findHover(PathRef File, Position Pos,
                              Callback<llvm::Optional<HoverInfo>> CB) {
   auto Action = [File = File.str(), Pos, CB = std::move(CB),
                  this](llvm::Expected<InputsAndAST> InpAST) mutable {
     if (!InpAST)
       return CB(InpAST.takeError());
     format::FormatStyle Style = getFormatStyleForFile(
-        File, InpAST->Inputs.Contents, *InpAST->Inputs.TFS);
+        File, *InpAST->Inputs.Contents, *InpAST->Inputs.TFS);
     CB(clangd::getHover(InpAST->AST, Pos, std::move(Style), Index));
   };
 
   WorkScheduler->runWithAST("Hover", File, std::move(Action),
                             TUScheduler::InvalidateOnUpdate);
 }
 
 void ClangdServer::typeHierarchy(PathRef File, Position Pos, int Resolve,

 
 void ClangdServer::getAST(PathRef File, Range R,
                           Callback<llvm::Optional<ASTNode>> CB) {
   auto Action =
       [R, CB(std::move(CB))](llvm::Expected<InputsAndAST> Inputs) mutable {
         if (!Inputs)
           return CB(Inputs.takeError());
         unsigned Start, End;
-        if (auto Offset = positionToOffset(Inputs->Inputs.Contents, R.start))
+        if (auto Offset = positionToOffset(*Inputs->Inputs.Contents, R.start))
           Start = *Offset;
         else
           return CB(Offset.takeError());
-        if (auto Offset = positionToOffset(Inputs->Inputs.Contents, R.end))
+        if (auto Offset = positionToOffset(*Inputs->Inputs.Contents, R.end))
           End = *Offset;
         else
           return CB(Offset.takeError());
 
         bool Success = SelectionTree::createEach(
             Inputs->AST.getASTContext(), Inputs->AST.getTokens(), Start, End,
             [&](SelectionTree T) {
               if (const SelectionTree::Node *N = T.commonAncestor()) {

clang-tools-extra/clangd/CodeComplete.cpp

bool semaCodeComplete(std::unique_ptr<CodeCompleteConsumer> Consumer,
   // This is on-by-default in windows to allow parsing SDK headers; we're only
   // disabling it for the main-file (not preamble).
   CI->getLangOpts()->DelayedTemplateParsing = false;
   // Setup code completion.
   FrontendOpts.CodeCompleteOpts = Options;
   FrontendOpts.CodeCompletionAt.FileName = std::string(Input.FileName);
   std::tie(FrontendOpts.CodeCompletionAt.Line,
            FrontendOpts.CodeCompletionAt.Column) =
-      offsetToClangLineColumn(Input.ParseInput.Contents, Input.Offset);
+      offsetToClangLineColumn(*Input.ParseInput.Contents, Input.Offset);
 
   std::unique_ptr<llvm::MemoryBuffer> ContentsBuffer =
-      llvm::MemoryBuffer::getMemBuffer(Input.ParseInput.Contents,
+      llvm::MemoryBuffer::getMemBuffer(*Input.ParseInput.Contents,
                                        Input.FileName);
   // The diagnostic options must be set before creating a CompilerInstance.
   CI->getDiagnosticOpts().IgnoreWarnings = true;
   // We reuse the preamble whether it's valid or not. This is a
   // correctness/performance tradeoff: building without a preamble is slow, and
   // completion is latency-sensitive.
   // However, if we're completing *inside* the preamble section of the draft,
   // overriding the preamble will break sema completion. Fortunately we can just
public:
   CodeCompleteFlow(PathRef FileName, const IncludeStructure &Includes,
                    SpeculativeFuzzyFind *SpecFuzzyFind,
                    const CodeCompleteOptions &Opts)
       : FileName(FileName), Includes(Includes), SpecFuzzyFind(SpecFuzzyFind),
         Opts(Opts) {}
 
   CodeCompleteResult run(const SemaCompleteInput &SemaCCInput) && {
     trace::Span Tracer("CodeCompleteFlow");
-    HeuristicPrefix = guessCompletionPrefix(SemaCCInput.ParseInput.Contents,
+    HeuristicPrefix = guessCompletionPrefix(*SemaCCInput.ParseInput.Contents,
                                             SemaCCInput.Offset);
-    populateContextWords(SemaCCInput.ParseInput.Contents);
+    populateContextWords(*SemaCCInput.ParseInput.Contents);
     if (Opts.Index && SpecFuzzyFind && SpecFuzzyFind->CachedReq.hasValue()) {
       assert(!SpecFuzzyFind->Result.valid());
       SpecReq = speculativeFuzzyFindRequestForCompletion(
           *SpecFuzzyFind->CachedReq, HeuristicPrefix);
       SpecFuzzyFind->Result = startAsyncFuzzyFind(*Opts.Index, *SpecReq);
     }
 
     // We run Sema code completion first. It builds an AST and calculates:
     //   - completion results based on the AST.
     //   - partial identifier and context. We need these for the index query.
     CodeCompleteResult Output;
     auto RecorderOwner = std::make_unique<CompletionRecorder>(Opts, [&]() {
       assert(Recorder && "Recorder is not set");
       CCContextKind = Recorder->CCContext.getKind();
       IsUsingDeclaration = Recorder->CCContext.isUsingDeclaration();
       auto Style = getFormatStyleForFile(SemaCCInput.FileName,
-                                         SemaCCInput.ParseInput.Contents,
+                                         *SemaCCInput.ParseInput.Contents,
                                          *SemaCCInput.ParseInput.TFS);
       const auto NextToken = Lexer::findNextToken(
           Recorder->CCSema->getPreprocessor().getCodeCompletionLoc(),
           Recorder->CCSema->getSourceManager(), Recorder->CCSema->LangOpts);
       if (NextToken)
         NextTokenKind = NextToken->getKind();
       // If preprocessor was run, inclusions from preprocessor callback should
       // already be added to Includes.
       Inserter.emplace(
-          SemaCCInput.FileName, SemaCCInput.ParseInput.Contents, Style,
+          SemaCCInput.FileName, *SemaCCInput.ParseInput.Contents, Style,
           SemaCCInput.ParseInput.CompileCommand.Directory,
           &Recorder->CCSema->getPreprocessor().getHeaderSearchInfo());
       for (const auto &Inc : Includes.MainFileIncludes)
         Inserter->addExisting(Inc);
 
       // Most of the cost of file proximity is in initializing the FileDistance
       // structures based on the observed includes, once per query. Conceptually
       // that happens here (though the per-URI-scheme initialization is lazy).
CompletionPrefix guessCompletionPrefix(llvm::StringRef Content,
   return Result;
 }
 
 CodeCompleteResult codeComplete(PathRef FileName, Position Pos,
                                 const PreambleData *Preamble,
                                 const ParseInputs &ParseInput,
                                 CodeCompleteOptions Opts,
                                 SpeculativeFuzzyFind *SpecFuzzyFind) {
-  auto Offset = positionToOffset(ParseInput.Contents, Pos);
+  auto Offset = positionToOffset(*ParseInput.Contents, Pos);
   if (!Offset) {
     elog("Code completion position was invalid {0}", Offset.takeError());
     return CodeCompleteResult();
   }
   auto Flow = CodeCompleteFlow(
       FileName, Preamble ? Preamble->Includes : IncludeStructure(),
       SpecFuzzyFind, Opts);
   return (!Preamble || Opts.RunParser == CodeCompleteOptions::NeverParse)
-             ? std::move(Flow).runWithoutSema(ParseInput.Contents, *Offset,
+             ? std::move(Flow).runWithoutSema(*ParseInput.Contents, *Offset,
                                               *ParseInput.TFS)
              : std::move(Flow).run({FileName, *Offset, *Preamble,
                                     // We want to serve code completions with
                                     // low latency, so don't bother patching.
                                     /*PreamblePatch=*/llvm::None, ParseInput});
 }
 
 SignatureHelp signatureHelp(PathRef FileName, Position Pos,
                             const PreambleData &Preamble,
                             const ParseInputs &ParseInput) {
-  auto Offset = positionToOffset(ParseInput.Contents, Pos);
+  auto Offset = positionToOffset(*ParseInput.Contents, Pos);
   if (!Offset) {
     elog("Signature help position was invalid {0}", Offset.takeError());
     return SignatureHelp();
   }
   SignatureHelp Result;
   clang::CodeCompleteOptions Options;
   Options.IncludeGlobals = false;
   Options.IncludeMacros = false;

clang-tools-extra/clangd/Compiler.h

 struct ParseOptions {
   // (empty at present, formerly controlled recovery AST, include-fixer etc)
 };
 
 /// Information required to run clang, e.g. to parse AST or do code completion.
 struct ParseInputs {
   tooling::CompileCommand CompileCommand;
   const ThreadsafeFS *TFS;
-  std::string Contents;
+  std::shared_ptr<const std::string> Contents;
   // Version identifier for Contents, provided by the client and opaque to us.
   std::string Version = "null";
   // Prevent reuse of the cached preamble/AST. Slow! Useful to workaround
   // clangd's assumption that missing header files will stay missing.
   bool ForceRebuild = false;
   // Used to recover from diagnostics (e.g. find missing includes for symbol).
   const SymbolIndex *Index = nullptr;
   ParseOptions Opts = ParseOptions();

clang-tools-extra/clangd/DraftStore.h

 //===--- DraftStore.h - File contents container -----------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_DRAFTSTORE_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_DRAFTSTORE_H
 
 #include "Protocol.h"
 #include "support/Path.h"
 #include "clang/Basic/LLVM.h"
 #include "llvm/ADT/StringMap.h"
+#include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include <mutex>
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace clangd {
 
+std::unique_ptr<llvm::MemoryBuffer>
+getSharedStringBuffer(std::shared_ptr<const std::string> Contents,
+                      StringRef BufferName = "");
+
 /// A thread-safe container for files opened in a workspace, addressed by
 /// filenames. The contents are owned by the DraftStore.
 /// Each time a draft is updated, it is assigned a version. This can be
 /// specified by the caller or incremented from the previous version.
 class DraftStore {
 public:
   struct Draft {
     std::shared_ptr<const std::string> Contents;
     std::string Version;
   };
 
   /// \return Contents of the stored document.
   /// For untracked files, a llvm::None is returned.
   llvm::Optional<Draft> getDraft(PathRef File) const;
 
   /// \return List of names of the drafts in this store.
   std::vector<Path> getActiveFiles() const;
 
   /// Replace contents of the draft for \p File with \p Contents.
   /// If version is empty, one will be automatically assigned.
   /// Returns the version.
   std::string addDraft(PathRef File, llvm::StringRef Version,
-                       StringRef Contents);
+                       std::shared_ptr<const std::string> Contents);
 
   /// Remove the draft from the store.
   void removeDraft(PathRef File);
 
   llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> asVFS() const;
 
 private:
   struct DraftAndTime {

clang-tools-extra/clangd/DraftStore.cpp

if (!SpecifiedVersion.empty()) {
     D.Version = SpecifiedVersion.str();
   } else {
     // Note that if D was newly-created, this will bump D.Version from "" to 1.
     increment(D.Version);
   }
 }
 
 std::string DraftStore::addDraft(PathRef File, llvm::StringRef Version,
-                                 llvm::StringRef Contents) {
+                                 std::shared_ptr<const std::string> Contents) {
   std::lock_guard<std::mutex> Lock(Mutex);
 
   auto &D = Drafts[File];
   updateVersion(D.D, Version);
   std::time(&D.MTime);
-  D.D.Contents = std::make_shared<std::string>(Contents);
+  D.D.Contents = std::move(Contents);
   return D.D.Version;
 }
 
 void DraftStore::removeDraft(PathRef File) {
   std::lock_guard<std::mutex> Lock(Mutex);
 
   Drafts.erase(File);
 }
public:
   }
 };
 } // namespace
 
 llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> DraftStore::asVFS() const {
   auto MemFS = llvm::makeIntrusiveRefCnt<llvm::vfs::InMemoryFileSystem>();
   std::lock_guard<std::mutex> Guard(Mutex);
   for (const auto &Draft : Drafts)
-    MemFS->addFile(Draft.getKey(), Draft.getValue().MTime,
-                   std::make_unique<SharedStringBuffer>(
-                       Draft.getValue().D.Contents, Draft.getKey()));
+    MemFS->addFile(
+        Draft.getKey(), Draft.getValue().MTime,
+        getSharedStringBuffer(Draft.getValue().D.Contents, Draft.getKey()));
   return MemFS;
 }
+std::unique_ptr<llvm::MemoryBuffer>
+getSharedStringBuffer(std::shared_ptr<const std::string> Contents,
+                      StringRef BufferName) {
+  return std::make_unique<SharedStringBuffer>(std::move(Contents), BufferName);
+}
+
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/ParsedAST.cpp

 //===--- ParsedAST.cpp -------------------------------------------*- C++-*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "ParsedAST.h"
 #include "../clang-tidy/ClangTidyCheck.h"
 #include "../clang-tidy/ClangTidyDiagnosticConsumer.h"
 #include "../clang-tidy/ClangTidyModuleRegistry.h"
 #include "AST.h"
 #include "Compiler.h"
 #include "Config.h"
 #include "Diagnostics.h"
+#include "DraftStore.h"
 #include "Headers.h"
 #include "IncludeFixer.h"
 #include "Preamble.h"
 #include "SourceCode.h"
 #include "TidyProvider.h"
 #include "index/CanonicalIncludes.h"
 #include "index/Index.h"
 #include "support/Logger.h"
ParsedAST::build(llvm::StringRef Filename, const ParseInputs &Inputs,
 
   llvm::Optional<PreamblePatch> Patch;
   if (Preamble) {
     Patch = PreamblePatch::create(Filename, Inputs, *Preamble);
     Patch->apply(*CI);
   }
   auto Clang = prepareCompilerInstance(
       std::move(CI), PreamblePCH,
-      llvm::MemoryBuffer::getMemBufferCopy(Inputs.Contents, Filename), VFS,
-      ASTDiags);
+      getSharedStringBuffer(Inputs.Contents, Filename), VFS, ASTDiags);
   if (!Clang)
     return None;
 
   auto Action = std::make_unique<ClangdFrontendAction>();
   const FrontendInputFile &MainInput = Clang->getFrontendOpts().Inputs[0];
   if (!Action->BeginSourceFile(*Clang, MainInput)) {
     log("BeginSourceFile() failed when building AST for {0}",
         MainInput.getFile());
llvm::Optional<tidy::ClangTidyContext> CTContext;
     });
   }
 
   // Add IncludeFixer which can recover diagnostics caused by missing includes
   // (e.g. incomplete type) and attach include insertion fixes to diagnostics.
   llvm::Optional<IncludeFixer> FixIncludes;
   auto BuildDir = VFS->getCurrentWorkingDirectory();
   if (Inputs.Index && !BuildDir.getError()) {
-    auto Style = getFormatStyleForFile(Filename, Inputs.Contents, *Inputs.TFS);
+    auto Style = getFormatStyleForFile(Filename, *Inputs.Contents, *Inputs.TFS);
     auto Inserter = std::make_shared<IncludeInserter>(
-        Filename, Inputs.Contents, Style, BuildDir.get(),
+        Filename, *Inputs.Contents, Style, BuildDir.get(),
         &Clang->getPreprocessor().getHeaderSearchInfo());
     if (Preamble) {
       for (const auto &Inc : Preamble->Includes.MainFileIncludes)
         Inserter->addExisting(Inc);
     }
     FixIncludes.emplace(Filename, Inserter, *Inputs.Index,
                         /*IndexRequestLimit=*/5);
     ASTDiags.contributeFixes([&FixIncludes](DiagnosticsEngine::Level DiagLevl,

clang-tools-extra/clangd/Preamble.cpp

struct ScannedPreamble {
   PreambleBounds Bounds = {0, false};
 };
 
 /// Scans the preprocessor directives in the preamble section of the file by
 /// running preprocessor over \p Contents. Returned includes do not contain
 /// resolved paths. \p Cmd is used to build the compiler invocation, which might
 /// stat/read files.
 llvm::Expected<ScannedPreamble>
 scanPreamble(llvm::StringRef Contents, const tooling::CompileCommand &Cmd) {
   class EmptyFS : public ThreadsafeFS {
   private:
     llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> viewImpl() const override {
       return new llvm::vfs::InMemoryFileSystem;
     }
   };
   EmptyFS FS;
   // Build and run Preprocessor over the preamble.
   ParseInputs PI;
-  PI.Contents = Contents.str();
   PI.TFS = &FS;
   PI.CompileCommand = Cmd;
   IgnoringDiagConsumer IgnoreDiags;
   auto CI = buildCompilerInvocation(PI, IgnoreDiags);
   if (!CI)
     return error("failed to create compiler invocation");
   CI->getDiagnosticOpts().IgnoreWarnings = true;
   auto ContentsBuffer = llvm::MemoryBuffer::getMemBuffer(Contents);

 
 std::shared_ptr<const PreambleData>
 buildPreamble(PathRef FileName, CompilerInvocation CI,
               const ParseInputs &Inputs, bool StoreInMemory,
               PreambleParsedCallback PreambleCallback) {
   // Note that we don't need to copy the input contents, preamble can live
   // without those.
   auto ContentsBuffer =
-      llvm::MemoryBuffer::getMemBuffer(Inputs.Contents, FileName);
+      llvm::MemoryBuffer::getMemBuffer(*Inputs.Contents, FileName);
   auto Bounds = ComputePreambleBounds(*CI.getLangOpts(), *ContentsBuffer, 0);
 
   trace::Span Tracer("BuildPreamble");
   SPAN_ATTACH(Tracer, "File", FileName);
   StoreDiags PreambleDiagnostics;
   llvm::IntrusiveRefCntPtr<DiagnosticsEngine> PreambleDiagsEngine =
       CompilerInstance::createDiagnostics(&CI.getDiagnosticOpts(),
                                           &PreambleDiagnostics, false);
if (BuiltPreamble) {
     return nullptr;
   }
 }
 
 bool isPreambleCompatible(const PreambleData &Preamble,
                           const ParseInputs &Inputs, PathRef FileName,
                           const CompilerInvocation &CI) {
   auto ContentsBuffer =
-      llvm::MemoryBuffer::getMemBuffer(Inputs.Contents, FileName);
+      llvm::MemoryBuffer::getMemBuffer(*Inputs.Contents, FileName);
   auto Bounds = ComputePreambleBounds(*CI.getLangOpts(), *ContentsBuffer, 0);
   auto VFS = Inputs.TFS->view(Inputs.CompileCommand.Directory);
   return compileCommandsAreEqual(Inputs.CompileCommand,
                                  Preamble.CompileCommand) &&
          Preamble.Preamble.CanReuse(CI, *ContentsBuffer, Bounds, *VFS);
 }
 
 void escapeBackslashAndQuotes(llvm::StringRef Text, llvm::raw_ostream &OS) {
PreamblePatch PreamblePatch::create(llvm::StringRef FileName,
   auto BaselineScan = scanPreamble(
       // Contents needs to be null-terminated.
       Baseline.Preamble.getContents().str(), Modified.CompileCommand);
   if (!BaselineScan) {
     elog("Failed to scan baseline of {0}: {1}", FileName,
          BaselineScan.takeError());
     return PreamblePatch::unmodified(Baseline);
   }
-  auto ModifiedScan = scanPreamble(Modified.Contents, Modified.CompileCommand);
+  auto ModifiedScan = scanPreamble(*Modified.Contents, Modified.CompileCommand);
   if (!ModifiedScan) {
     elog("Failed to scan modified contents of {0}: {1}", FileName,
          ModifiedScan.takeError());
     return PreamblePatch::unmodified(Baseline);
   }
 
   bool IncludesChanged = BaselineScan->Includes != ModifiedScan->Includes;
   bool DirectivesChanged =
for (auto &Inc : ModifiedScan->Includes) {
       // put into preamble includes.
       if (It != ExistingIncludes.end()) {
         Inc.Resolved = It->second.str();
         PP.PreambleIncludes.push_back(Inc);
         continue;
       }
       // Include is new in the modified preamble. Inject it into the patch and
       // use #line to set the presumed location to where it is spelled.
-      auto LineCol = offsetToClangLineColumn(Modified.Contents, Inc.HashOffset);
+      auto LineCol =
+          offsetToClangLineColumn(*Modified.Contents, Inc.HashOffset);
       Patch << llvm::formatv("#line {0}\n", LineCol.first);
       Patch << llvm::formatv(
           "#{0} {1}\n", spellingForIncDirective(Inc.Directive), Inc.Written);
     }
   }
 
   if (DirectivesChanged) {
     // We need to patch all the directives, since they are order dependent. e.g:

clang-tools-extra/clangd/TUScheduler.h

 unsigned getDefaultAsyncThreadsCount();
 
 struct InputsAndAST {
   const ParseInputs &Inputs;
   ParsedAST *
 };
 
 struct InputsAndPreamble {
-  llvm::StringRef Contents;
+  std::shared_ptr<const std::string> Contents;
   const tooling::CompileCommand &Command;
   // This can be nullptr if no preamble is available.
   const PreambleData *Preamble;
   // This can be nullptr if no ASTSignals are available.
   const ASTSignals *Signals;
 };
 
 /// Determines whether diagnostics should be generated for a file snapshot.

clang-tools-extra/clangd/TUScheduler.cpp

 #ifndef NDEBUG
   std::lock_guard<std::mutex> Lock(Mutex);
   assert(Done && "handle was not destroyed");
   assert(Requests.empty() && !CurrentRequest &&
          "unprocessed requests when destroying ASTWorker");
 #endif
 }
 
+static bool areInputsSame(const ParseInputs &L, const ParseInputs &R) {
+  if (L.CompileCommand != R.CompileCommand)
+    return false;
+  StringRef LContents = L.Contents ? StringRef(*L.Contents) : "";
+  StringRef RContents = R.Contents ? StringRef(*R.Contents) : "";
+  return LContents == RContents;
+}
+
 void ASTWorker::update(ParseInputs Inputs, WantDiagnostics WantDiags,
                        bool ContentChanged) {
   std::string TaskName = llvm::formatv("Update ({0})", Inputs.Version);
   auto Task = [=]() mutable {
     // Get the actual command as `Inputs` does not have a command.
     // FIXME: some build systems like Bazel will take time to preparing
     // environment to build the file, it would be nice if we could emit a
     // "PreparingBuild" status to inform users, it is non-trivial given the
if (!Cmd || !isReliable(*Cmd)) {
         }
       }
     }
     if (Cmd)
       Inputs.CompileCommand = std::move(*Cmd);
     else
       Inputs.CompileCommand = CDB.getFallbackCommand(FileName);
 
-    bool InputsAreTheSame =
-        std::tie(FileInputs.CompileCommand, FileInputs.Contents) ==
-        std::tie(Inputs.CompileCommand, Inputs.Contents);
+    bool InputsAreTheSame = areInputsSame(FileInputs, Inputs);
     // Cached AST is invalidated.
     if (!InputsAreTheSame) {
       IdleASTs.take(this);
       RanASTCallback = false;
     }
 
     // Update current inputs so that subsequent reads can see them.
     {
void ASTWorker::generateDiagnostics(
   assert(LatestPreamble);
   // No need to rebuild the AST if we won't send the diagnostics.
   {
     std::lock_guard<std::mutex> Lock(PublishMu);
     if (!CanPublishResults)
       return;
   }
   // Used to check whether we can update AST cache.
-  bool InputsAreLatest =
-      std::tie(FileInputs.CompileCommand, FileInputs.Contents) ==
-      std::tie(Inputs.CompileCommand, Inputs.Contents);
+  bool InputsAreLatest = areInputsSame(FileInputs, Inputs);
   // Take a shortcut and don't report the diagnostics, since they should be the
   // same. All the clients should handle the lack of OnUpdated() call anyway to
   // handle empty result from buildAST.
   // FIXME: the AST could actually change if non-preamble includes changed,
   // but we choose to ignore it.
   if (InputsAreLatest && RanASTCallback)
     return;
 
FileStatus TUStatus::render(PathRef File) const {
   FileStatus FStatus;
   FStatus.uri = URIForFile::canonicalize(File, /*TUPath=*/File);
   FStatus.state = renderTUAction(PreambleActivity, ASTActivity);
   return FStatus;
 }
 
 struct TUScheduler::FileData {
   /// Latest inputs, passed to TUScheduler::update().
-  std::string Contents;
+  std::shared_ptr<const std::string> Contents;
   ASTWorkerHandle Worker;
 };
 
 TUScheduler::TUScheduler(const GlobalCompilationDatabase &CDB,
                          const Options &Opts,
                          std::unique_ptr<ParsingCallbacks> Callbacks)
     : CDB(CDB), Opts(Opts),
       Callbacks(Callbacks ? move(Callbacks)
if (!FD) {
     // Create a new worker to process the AST-related tasks.
     ASTWorkerHandle Worker =
         ASTWorker::create(File, CDB, *IdleASTs, *HeaderIncluders,
                           WorkerThreads ? WorkerThreads.getPointer() : nullptr,
                           Barrier, Opts, *Callbacks);
     FD = std::unique_ptr<FileData>(
         new FileData{Inputs.Contents, std::move(Worker)});
     ContentChanged = true;
-  } else if (FD->Contents != Inputs.Contents) {
+  } else if (*FD->Contents != *Inputs.Contents) {
     ContentChanged = true;
     FD->Contents = Inputs.Contents;
   }
   FD->Worker->update(std::move(Inputs), WantDiags, ContentChanged);
   return NewFile;
 }
 
 void TUScheduler::remove(PathRef File) {

clang-tools-extra/clangd/tool/Check.cpp

public:
   bool buildInvocation(const ThreadsafeFS &TFS,
                        llvm::Optional<std::string> Contents) {
     StoreDiags CaptureInvocationDiags;
     std::vector<std::string> CC1Args;
     Inputs.CompileCommand = Cmd;
     Inputs.TFS = &TFS;
     Inputs.ClangTidyProvider = Opts.ClangTidyProvider;
     if (Contents.hasValue()) {
-      Inputs.Contents = *Contents;
-      log("Imaginary source file contents:\n{0}", Inputs.Contents);
+      Inputs.Contents = std::make_shared<std::string>(*Contents);
+      log("Imaginary source file contents:\n{0}", *Inputs.Contents);
     } else {
       if (auto Contents = TFS.view(llvm::None)->getBufferForFile(File)) {
-        Inputs.Contents = Contents->get()->getBuffer().str();
+        Inputs.Contents =
+            std::make_shared<std::string>(Contents->get()->getBuffer());
       } else {
         elog("Couldn't read {0}: {1}", File, Contents.getError().message());
         return false;
       }
     }
     log("Parsing command...");
     Invocation =
         buildCompilerInvocation(Inputs, CaptureInvocationDiags, &CC1Args);
     auto InvocationDiags = CaptureInvocationDiags.take();
     ErrCount += showErrors(InvocationDiags);
     log("internal (cc1) args are: {0}", printArgv(CC1Args));
     if (!Invocation) {
       elog("Failed to parse command line");
       return false;
     }
 
     // FIXME: Check that resource-dir/built-in-headers exist?
 
-    Style = getFormatStyleForFile(File, Inputs.Contents, TFS);
+    Style = getFormatStyleForFile(File, *Inputs.Contents, TFS);
 
     return true;
   }
 
   // Build preamble and AST, and index them.
   bool buildAST() {
     log("Building preamble...");
     Preamble =
public:
   // Run AST-based features at each token in the file.
   void testLocationFeatures() {
     log("Testing features at each token (may be slow in large files)");
     auto SpelledTokens =
         AST->getTokens().spelledTokens(AST->getSourceManager().getMainFileID());
     for (const auto &Tok : SpelledTokens) {
       unsigned Start = AST->getSourceManager().getFileOffset(Tok.location());
       unsigned End = Start + Tok.length();
-      Position Pos = offsetToPosition(Inputs.Contents, Start);
+      Position Pos = offsetToPosition(*Inputs.Contents, Start);
       // FIXME: dumping the tokens may leak sensitive code into bug reports.
       // Add an option to turn this off, once we decide how options work.
       vlog("  {0} {1}", Pos, Tok.text(AST->getSourceManager()));
       auto Tree = SelectionTree::createRight(AST->getASTContext(),
                                              AST->getTokens(), Start, End);
       Tweak::Selection Selection(&Index, *AST, Start, End, std::move(Tree));
       for (const auto &T : prepareTweaks(Selection, Opts.TweakFilter)) {
         auto Result = T->apply(Selection);

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

CodeCompleteResult completionsNoCompile(llvm::StringRef Text,
   if (!IndexSymbols.empty()) {
     assert(!Opts.Index && "both Index and IndexSymbols given!");
     OverrideIndex = memIndex(std::move(IndexSymbols));
     Opts.Index = OverrideIndex.get();
   }
 
   MockFS FS;
   Annotations Test(Text);
-  ParseInputs ParseInput{tooling::CompileCommand(), &FS, Test.code().str()};
+  ParseInputs ParseInput{tooling::CompileCommand(), &FS,
+                         std::make_shared<std::string>(Test.code())};
   return codeComplete(FilePath, Test.point(), /*Preamble=*/nullptr, ParseInput,
                       Opts);
 }
 
 Symbol withReferences(int N, Symbol S) {
   S.References = N;
   return S;
 }

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

 namespace clang {
 namespace clangd {
 namespace {
 
 TEST(DraftStore, Versions) {
   DraftStore DS;
   Path File = "foo.cpp";
 
-  EXPECT_EQ("25", DS.addDraft(File, "25", ""));
+  EXPECT_EQ("25", DS.addDraft(File, "25", std::make_shared<std::string>("")));
   EXPECT_EQ("25", DS.getDraft(File)->Version);
   EXPECT_EQ("", *DS.getDraft(File)->Contents);
 
-  EXPECT_EQ("26", DS.addDraft(File, "", "x"));
+  EXPECT_EQ("26", DS.addDraft(File, "", std::make_shared<std::string>("x")));
   EXPECT_EQ("26", DS.getDraft(File)->Version);
   EXPECT_EQ("x", *DS.getDraft(File)->Contents);
 
-  EXPECT_EQ("27", DS.addDraft(File, "", "x")) << "no-op change";
+  EXPECT_EQ("27", DS.addDraft(File, "", std::make_shared<std::string>("x")))
+      << "no-op change";
   EXPECT_EQ("27", DS.getDraft(File)->Version);
   EXPECT_EQ("x", *DS.getDraft(File)->Contents);
 
   // We allow versions to go backwards.
-  EXPECT_EQ("7", DS.addDraft(File, "7", "y"));
+  EXPECT_EQ("7", DS.addDraft(File, "7", std::make_shared<std::string>("y")));
   EXPECT_EQ("7", DS.getDraft(File)->Version);
   EXPECT_EQ("y", *DS.getDraft(File)->Contents);
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang

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

TEST(FileIndexTest, RebuildWithPreamble) {
   FS.Files[FooCpp] = "";
   FS.Files[FooH] = R"cpp(
     namespace ns_in_header {
       int func_in_header();
     }
   )cpp";
   PI.TFS = &FS;
 
-  PI.Contents = R"cpp(
+  PI.Contents = std::make_shared<std::string>(R"cpp(
     #include "foo.h"
     namespace ns_in_source {
       int func_in_source();
     }
-  )cpp";
+  )cpp");
 
   // Rebuild the file.
   IgnoreDiagnostics IgnoreDiags;
   auto CI = buildCompilerInvocation(PI, IgnoreDiags);
 
   FileIndex Index;
   bool IndexUpdated = false;
   buildPreamble(FooCpp, *CI, PI,

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

 }
 
 class TUSchedulerTests : public ::testing::Test {
 protected:
   ParseInputs getInputs(PathRef File, std::string Contents) {
     ParseInputs Inputs;
     Inputs.CompileCommand = *CDB.getCompileCommand(File);
     Inputs.TFS = &FS;
-    Inputs.Contents = std::move(Contents);
+    Inputs.Contents = std::make_shared<std::string>(std::move(Contents));
     Inputs.Opts = ParseOptions();
     return Inputs;
   }
 
   void updateWithCallback(TUScheduler &S, PathRef File,
                           llvm::StringRef Contents, WantDiagnostics WD,
                           llvm::unique_function<void()> CB) {
     updateWithCallback(S, File, getInputs(File, std::string(Contents)), WD,
for (int FileI = 0; FileI < FilesCount; ++FileI) {
           S.runWithAST(
               "CheckAST", File,
               [File, Inputs, Nonce, &Mut,
                &TotalASTReads](Expected<InputsAndAST> AST) {
                 EXPECT_THAT(Context::current().get(NonceKey), Pointee(Nonce));
                 EXPECT_EQ(File, boundPath());
 
                 ASSERT_TRUE((bool)AST);
-                EXPECT_EQ(AST->Inputs.Contents, Inputs.Contents);
+                EXPECT_EQ(*AST->Inputs.Contents, *Inputs.Contents);
                 EXPECT_EQ(AST->Inputs.Version, Inputs.Version);
                 EXPECT_EQ(AST->AST.version(), Inputs.Version);
 
                 std::lock_guard<std::mutex> Lock(Mut);
                 ++TotalASTReads;
                 EXPECT_EQ(File, *TUScheduler::getFileBeingProcessedInContext());
               });
         }
 
         {
           WithContextValue WithNonce(NonceKey, ++Nonce);
           S.runWithPreamble(
               "CheckPreamble", File, TUScheduler::Stale,
               [File, Inputs, Nonce, &Mut,
                &TotalPreambleReads](Expected<InputsAndPreamble> Preamble) {
                 EXPECT_THAT(Context::current().get(NonceKey), Pointee(Nonce));
                 EXPECT_EQ(File, boundPath());
 
                 ASSERT_TRUE((bool)Preamble);
-                EXPECT_EQ(Preamble->Contents, Inputs.Contents);
+                EXPECT_EQ(*Preamble->Contents, *Inputs.Contents);
 
                 std::lock_guard<std::mutex> Lock(Mut);
                 ++TotalPreambleReads;
                 EXPECT_EQ(File, *TUScheduler::getFileBeingProcessedInContext());
               });
         }
       }
     }

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

if (ImplicitHeaderGuard)
       Inputs.CompileCommand.CommandLine.push_back("-fno-ms-compatibility");
   }
   Argv.insert(Argv.end(), ExtraArgs.begin(), ExtraArgs.end());
   // Put the file name at the end -- this allows the extra arg (-xc++) to
   // override the language setting.
   Argv.push_back(FullFilename);
   Inputs.CompileCommand.Filename = FullFilename;
   Inputs.CompileCommand.Directory = testRoot();
-  Inputs.Contents = Code;
+  Inputs.Contents = std::make_shared<std::string>(Code);
   if (OverlayRealFileSystemForModules)
     FS.OverlayRealFileSystemForModules = true;
   Inputs.TFS = &FS;
   Inputs.Opts = ParseOptions();
   if (ClangTidyProvider)
     Inputs.ClangTidyProvider = ClangTidyProvider;
   Inputs.Index = ExternalIndex;
   return Inputs;