Addressed reviewer's post-submission comments from http://reviews.llvm.org/D18551.

[ioeric]

Summary

Make SourceManager in Environment, WhitespaceManager, and FormatTokenAnalyzer etc constant members.

[djasper]

lib/Format/AffectedRangeManager.h

68

??

[djasper]

Otherwise looks good.

[ioeric]

• removed redundant '#'

lib/Format/AffectedRangeManager.h

 namespace clang {
 namespace format {
 
 struct FormatToken;
 class AnnotatedLine;
 
 class AffectedRangeManager {
 public:
-  AffectedRangeManager(SourceManager &SourceMgr,
+  AffectedRangeManager(const SourceManager &SourceMgr,
                        const ArrayRef<CharSourceRange> Ranges)
       : SourceMgr(SourceMgr), Ranges(Ranges.begin(), Ranges.end()) {}
 
   // Determines which lines are affected by the SourceRanges given as input.
   // Returns \c true if at least one line between I and E or one of their
   // children is affected.
   bool computeAffectedLines(SmallVectorImpl<AnnotatedLine *>::iterator I,
                             SmallVectorImpl<AnnotatedLine *>::iterator E);
private:
   // Marks all lines between I and E as well as all their children as affected.
   void markAllAsAffected(SmallVectorImpl<AnnotatedLine *>::iterator I,
                          SmallVectorImpl<AnnotatedLine *>::iterator E);
 
   // Determines whether 'Line' is affected by the SourceRanges given as input.
   // Returns \c true if line or one if its children is affected.
   bool nonPPLineAffected(AnnotatedLine *Line,
                          const AnnotatedLine *PreviousLine);
-  SourceManager &SourceMgr;
+
+  const SourceManager &SourceMgr;
   const SmallVector<CharSourceRange, 8> Ranges;
 };
 
 } // namespace format
 } // namespace clang
 
-#endif // LLVM_CLANG_LIB_FORMAT_WHITESPACEMANAGER_H
+#endif // LLVM_CLANG_LIB_FORMAT_AFFECTEDRANGEMANAGER_H
+#

lib/Format/ContinuationIndenter.h

 class WhitespaceManager;
 
 class ContinuationIndenter {
 public:
   /// \brief Constructs a \c ContinuationIndenter to format \p Line starting in
   /// column \p FirstIndent.
   ContinuationIndenter(const FormatStyle &Style,
                        const AdditionalKeywords &Keywords,
-                       SourceManager &SourceMgr, WhitespaceManager &Whitespaces,
+                       const SourceManager &SourceMgr,
+                       WhitespaceManager &Whitespaces,
                        encoding::Encoding Encoding,
                        bool BinPackInconclusiveFunctions);
 
   /// \brief Get the initial state, i.e. the state after placing \p Line's
   /// first token at \p FirstIndent.
   LineState getInitialState(unsigned FirstIndent, const AnnotatedLine *Line,
                             bool DryRun);
 
private:
   /// literal.
   ///
   /// This includes implicitly concatenated strings, strings that will be broken
   /// by clang-format and string literals with escaped newlines.
   bool nextIsMultilineString(const LineState &State);
 
   FormatStyle Style;
   const AdditionalKeywords &Keywords;
-  SourceManager &SourceMgr;
+  const SourceManager &SourceMgr;
   WhitespaceManager &Whitespaces;
   encoding::Encoding Encoding;
   bool BinPackInconclusiveFunctions;
   llvm::Regex CommentPragmasRegex;
 };
 
 struct ParenState {
   ParenState(unsigned Indent, unsigned IndentLevel, unsigned LastSpace,

lib/Format/ContinuationIndenter.cpp

if (Current.is(TT_CtorInitializerComma) &&
     return true;
   return Previous.is(tok::comma) && !Current.isTrailingComment() &&
          (Previous.isNot(TT_CtorInitializerComma) ||
           !Style.BreakConstructorInitializersBeforeComma);
 }
 
 ContinuationIndenter::ContinuationIndenter(const FormatStyle &Style,
                                            const AdditionalKeywords &Keywords,
-                                           SourceManager &SourceMgr,
+                                           const SourceManager &SourceMgr,
                                            WhitespaceManager &Whitespaces,
                                            encoding::Encoding Encoding,
                                            bool BinPackInconclusiveFunctions)
     : Style(Style), Keywords(Keywords), SourceMgr(SourceMgr),
       Whitespaces(Whitespaces), Encoding(Encoding),
       BinPackInconclusiveFunctions(BinPackInconclusiveFunctions),
       CommentPragmasRegex(Style.CommentPragmas) {}
 

lib/Format/Format.cpp

std::string configurationAsText(const FormatStyle &Style) {
   Output << NonConstStyle;
   return Stream.str();
 }
 
 namespace {
 
 class FormatTokenLexer {
 public:
-  FormatTokenLexer(SourceManager &SourceMgr, FileID ID,
+  FormatTokenLexer(const SourceManager &SourceMgr, FileID ID,
                    const FormatStyle &Style, encoding::Encoding Encoding)
       : FormatTok(nullptr), IsFirstToken(true), GreaterStashed(false),
         LessStashed(false), Column(0), TrailingWhitespace(0),
         SourceMgr(SourceMgr), ID(ID), Style(Style),
         IdentTable(getFormattingLangOpts(Style)), Keywords(IdentTable),
         Encoding(Encoding), FirstInLineIndex(0), FormattingDisabled(false),
         MacroBlockBeginRegex(Style.MacroBlockBegin),
         MacroBlockEndRegex(Style.MacroBlockEnd) {
private:
   }
 
   FormatToken *FormatTok;
   bool IsFirstToken;
   bool GreaterStashed, LessStashed;
   unsigned Column;
   unsigned TrailingWhitespace;
   std::unique_ptr<Lexer> Lex;
-  SourceManager &SourceMgr;
+  const SourceManager &SourceMgr;
   FileID ID;
   const FormatStyle &Style;
   IdentifierTable IdentTable;
   AdditionalKeywords Keywords;
   encoding::Encoding Encoding;
   llvm::SpecificBumpPtrAllocator<FormatToken> Allocator;
   // Index (in 'Tokens') of the last token that starts a new line.
   unsigned FirstInLineIndex;
case FormatStyle::LK_Proto:
     return "Proto";
   default:
     return "Unknown";
   }
 }
 
 class Environment {
 public:
-  Environment(const FormatStyle &Style, SourceManager &SM, FileID ID,
-              ArrayRef<CharSourceRange> Ranges)
-      : Style(Style), ID(ID), CharRanges(Ranges.begin(), Ranges.end()), SM(SM) {
-  }
+  Environment(SourceManager &SM, FileID ID, ArrayRef<CharSourceRange> Ranges)
+      : ID(ID), CharRanges(Ranges.begin(), Ranges.end()), SM(SM) {}
 
-  Environment(const FormatStyle &Style, FileID ID,
-              std::unique_ptr<FileManager> FileMgr,
+  Environment(FileID ID, std::unique_ptr<FileManager> FileMgr,
               std::unique_ptr<SourceManager> VirtualSM,
               std::unique_ptr<DiagnosticsEngine> Diagnostics,
-              std::vector<CharSourceRange> CharRanges)
-      : Style(Style), ID(ID), CharRanges(CharRanges.begin(), CharRanges.end()),
+              const std::vector<CharSourceRange> &CharRanges)
+      : ID(ID), CharRanges(CharRanges.begin(), CharRanges.end()),
         SM(*VirtualSM), FileMgr(std::move(FileMgr)),
         VirtualSM(std::move(VirtualSM)), Diagnostics(std::move(Diagnostics)) {}
 
   // This sets up an virtual file system with file \p FileName containing \p
   // Code.
   static std::unique_ptr<Environment>
-  CreateVirtualEnvironment(const FormatStyle &Style, StringRef Code,
-                           StringRef FileName,
+  CreateVirtualEnvironment(StringRef Code, StringRef FileName,
                            ArrayRef<tooling::Range> Ranges) {
     // This is referenced by `FileMgr` and will be released by `FileMgr` when it
     // is deleted.
     IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
         new vfs::InMemoryFileSystem);
     // This is passed to `SM` as reference, so the pointer has to be referenced
     // in `Environment` so that `FileMgr` can out-live this function scope.
     std::unique_ptr<FileManager> FileMgr(
CreateVirtualEnvironment(StringRef Code, StringRef FileName,
     assert(ID.isValid());
     SourceLocation StartOfFile = VirtualSM->getLocForStartOfFile(ID);
     std::vector<CharSourceRange> CharRanges;
     for (const tooling::Range &Range : Ranges) {
       SourceLocation Start = StartOfFile.getLocWithOffset(Range.getOffset());
       SourceLocation End = Start.getLocWithOffset(Range.getLength());
       CharRanges.push_back(CharSourceRange::getCharRange(Start, End));
     }
-    return llvm::make_unique<Environment>(Style, ID, std::move(FileMgr),
+    return llvm::make_unique<Environment>(ID, std::move(FileMgr),
                                           std::move(VirtualSM),
                                           std::move(Diagnostics), CharRanges);
   }
 
-  FormatStyle &getFormatStyle() { return Style; }
-
-  const FormatStyle &getFormatStyle() const { return Style; }
-
   FileID getFileID() const { return ID; }
 
   StringRef getFileName() const { return FileName; }
 
   ArrayRef<CharSourceRange> getCharRanges() const { return CharRanges; }
 
-  SourceManager &getSourceManager() { return SM; }
+  const SourceManager &getSourceManager() const { return SM; }
 
 private:
-  FormatStyle Style;
   FileID ID;
   StringRef FileName;
   SmallVector<CharSourceRange, 8> CharRanges;
   SourceManager &SM;
 
   // The order of these fields are important - they should be in the same order
   // as they are created in `CreateVirtualEnvironment` so that they can be
   // deleted in the reverse order as they are created.
   std::unique_ptr<FileManager> FileMgr;
   std::unique_ptr<SourceManager> VirtualSM;
   std::unique_ptr<DiagnosticsEngine> Diagnostics;
 };
 
 class TokenAnalyzer : public UnwrappedLineConsumer {
 public:
-  TokenAnalyzer(Environment &Env)
-      : Env(Env), AffectedRangeMgr(Env.getSourceManager(), Env.getCharRanges()),
+  TokenAnalyzer(const Environment &Env, const FormatStyle &Style)
+      : Style(Style), Env(Env),
+        AffectedRangeMgr(Env.getSourceManager(), Env.getCharRanges()),
         UnwrappedLines(1),
         Encoding(encoding::detectEncoding(
             Env.getSourceManager().getBufferData(Env.getFileID()))) {
     DEBUG(llvm::dbgs() << "File encoding: "
                        << (Encoding == encoding::Encoding_UTF8 ? "UTF8"
                                                                : "unknown")
                        << "\n");
-    DEBUG(llvm::dbgs() << "Language: "
-                       << getLanguageName(Env.getFormatStyle().Language)
+    DEBUG(llvm::dbgs() << "Language: " << getLanguageName(Style.Language)
                        << "\n");
   }
 
   tooling::Replacements process() {
     tooling::Replacements Result;
-    FormatTokenLexer Tokens(Env.getSourceManager(), Env.getFileID(),
-                            Env.getFormatStyle(), Encoding);
+    FormatTokenLexer Tokens(Env.getSourceManager(), Env.getFileID(), Style,
+                            Encoding);
 
-    UnwrappedLineParser Parser(Env.getFormatStyle(), Tokens.getKeywords(),
-                               Tokens.lex(), *this);
+    UnwrappedLineParser Parser(Style, Tokens.getKeywords(), Tokens.lex(),
+                               *this);
     Parser.parse();
     assert(UnwrappedLines.rbegin()->empty());
     for (unsigned Run = 0, RunE = UnwrappedLines.size(); Run + 1 != RunE;
          ++Run) {
       DEBUG(llvm::dbgs() << "Run " << Run << "...\n");
       SmallVector<AnnotatedLine *, 16> AnnotatedLines;
 
-      TokenAnnotator Annotator(Env.getFormatStyle(), Tokens.getKeywords());
+      TokenAnnotator Annotator(Style, Tokens.getKeywords());
       for (unsigned i = 0, e = UnwrappedLines[Run].size(); i != e; ++i) {
         AnnotatedLines.push_back(new AnnotatedLine(UnwrappedLines[Run][i]));
         Annotator.annotate(*AnnotatedLines.back());
       }
 
       tooling::Replacements RunResult =
           analyze(Annotator, AnnotatedLines, Tokens, Result);
 
void consumeUnwrappedLine(const UnwrappedLine &TheLine) override {
     assert(!UnwrappedLines.empty());
     UnwrappedLines.back().push_back(TheLine);
   }
 
   void finishRun() override {
     UnwrappedLines.push_back(SmallVector<UnwrappedLine, 16>());
   }
 
+  FormatStyle Style;
   // Stores Style, FileID and SourceManager etc.
-  Environment &Env;
+  const Environment &Env;
   // AffectedRangeMgr stores ranges to be fixed.
   AffectedRangeManager AffectedRangeMgr;
   SmallVector<SmallVector<UnwrappedLine, 16>, 2> UnwrappedLines;
   encoding::Encoding Encoding;
 };
 
 class Formatter : public TokenAnalyzer {
 public:
-  Formatter(Environment &Env, bool *IncompleteFormat)
-      : TokenAnalyzer(Env), IncompleteFormat(IncompleteFormat) {}
+  Formatter(const Environment &Env, const FormatStyle &Style,
+            bool *IncompleteFormat)
+      : TokenAnalyzer(Env, Style), IncompleteFormat(IncompleteFormat) {}
 
   tooling::Replacements
   analyze(TokenAnnotator &Annotator,
           SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
           FormatTokenLexer &Tokens, tooling::Replacements &Result) override {
     deriveLocalStyle(AnnotatedLines);
     AffectedRangeMgr.computeAffectedLines(AnnotatedLines.begin(),
                                           AnnotatedLines.end());
 
-    if (Env.getFormatStyle().Language == FormatStyle::LK_JavaScript &&
-        Env.getFormatStyle().JavaScriptQuotes != FormatStyle::JSQS_Leave)
+    if (Style.Language == FormatStyle::LK_JavaScript &&
+        Style.JavaScriptQuotes != FormatStyle::JSQS_Leave)
       requoteJSStringLiteral(AnnotatedLines, Result);
 
     for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
       Annotator.calculateFormattingInformation(*AnnotatedLines[i]);
     }
 
     Annotator.setCommentLineLevels(AnnotatedLines);
 
     WhitespaceManager Whitespaces(
-        Env.getSourceManager(), Env.getFormatStyle(),
+        Env.getSourceManager(), Style,
         inputUsesCRLF(Env.getSourceManager().getBufferData(Env.getFileID())));
-    ContinuationIndenter Indenter(Env.getFormatStyle(), Tokens.getKeywords(),
+    ContinuationIndenter Indenter(Style, Tokens.getKeywords(),
                                   Env.getSourceManager(), Whitespaces, Encoding,
                                   BinPackInconclusiveFunctions);
-    UnwrappedLineFormatter(&Indenter, &Whitespaces, Env.getFormatStyle(),
-                           Tokens.getKeywords(), IncompleteFormat)
+    UnwrappedLineFormatter(&Indenter, &Whitespaces, Style, Tokens.getKeywords(),
+                           IncompleteFormat)
         .format(AnnotatedLines);
     return Whitespaces.generateReplacements();
   }
 
 private:
   // If the last token is a double/single-quoted string literal, generates a
   // replacement with a single/double quoted string literal, re-escaping the
   // contents in the process.
   void requoteJSStringLiteral(SmallVectorImpl<AnnotatedLine *> &Lines,
                               tooling::Replacements &Result) {
     for (AnnotatedLine *Line : Lines) {
       requoteJSStringLiteral(Line->Children, Result);
       if (!Line->Affected)
         continue;
       for (FormatToken *FormatTok = Line->First; FormatTok;
            FormatTok = FormatTok->Next) {
         StringRef Input = FormatTok->TokenText;
         if (!FormatTok->isStringLiteral() ||
             // NB: testing for not starting with a double quote to avoid
             // breaking
             // `template strings`.
-            (Env.getFormatStyle().JavaScriptQuotes ==
-                 FormatStyle::JSQS_Single &&
+            (Style.JavaScriptQuotes == FormatStyle::JSQS_Single &&
              !Input.startswith("\"")) ||
-            (Env.getFormatStyle().JavaScriptQuotes ==
-                 FormatStyle::JSQS_Double &&
+            (Style.JavaScriptQuotes == FormatStyle::JSQS_Double &&
              !Input.startswith("\'")))
           continue;
 
         // Change start and end quote.
-        bool IsSingle =
-            Env.getFormatStyle().JavaScriptQuotes == FormatStyle::JSQS_Single;
+        bool IsSingle = Style.JavaScriptQuotes == FormatStyle::JSQS_Single;
         SourceLocation Start = FormatTok->Tok.getLocation();
         auto Replace = [&](SourceLocation Start, unsigned Length,
                            StringRef ReplacementText) {
           Result.insert(tooling::Replacement(Env.getSourceManager(), Start,
                                              Length, ReplacementText));
         };
         Replace(Start, 1, IsSingle ? "'" : "\"");
         Replace(FormatTok->Tok.getEndLoc().getLocWithOffset(-1), 1,
for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
         if (Tok->PackingKind == PPK_BinPacked)
           HasBinPackedFunction = true;
         if (Tok->PackingKind == PPK_OnePerLine)
           HasOnePerLineFunction = true;
 
         Tok = Tok->Next;
       }
     }
-    if (Env.getFormatStyle().DerivePointerAlignment)
-      Env.getFormatStyle().PointerAlignment =
-          countVariableAlignments(AnnotatedLines) <= 0 ? FormatStyle::PAS_Left
-                                                       : FormatStyle::PAS_Right;
-    if (Env.getFormatStyle().Standard == FormatStyle::LS_Auto)
-      Env.getFormatStyle().Standard = hasCpp03IncompatibleFormat(AnnotatedLines)
-                                          ? FormatStyle::LS_Cpp11
-                                          : FormatStyle::LS_Cpp03;
+    if (Style.DerivePointerAlignment)
+      Style.PointerAlignment = countVariableAlignments(AnnotatedLines) <= 0
+                                   ? FormatStyle::PAS_Left
+    if (Style.Standard == FormatStyle::LS_Auto)
+      Style.Standard = hasCpp03IncompatibleFormat(AnnotatedLines)
     BinPackInconclusiveFunctions =
         HasBinPackedFunction || !HasOnePerLineFunction;
   }
 
   bool BinPackInconclusiveFunctions;
   bool *IncompleteFormat;
 };
 
 // This class clean up the erroneous/redundant code around the given ranges in
 // file.
 class Cleaner : public TokenAnalyzer {
 public:
-  Cleaner(Environment &Env)
-      : TokenAnalyzer(Env),
+  Cleaner(const Environment &Env, const FormatStyle &Style)
+      : TokenAnalyzer(Env, Style),
         DeletedTokens(FormatTokenLess(Env.getSourceManager())) {}
 
   // FIXME: eliminate unused parameters.
   tooling::Replacements
   analyze(TokenAnnotator &Annotator,
           SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
           FormatTokenLexer &Tokens, tooling::Replacements &Result) override {
     // FIXME: in the current implementation the granularity of affected range
private:
 
   // The function checks if the namespace, which starts from \p CurrentLine, and
   // its nested namespaces are empty and delete them if they are empty. It also
   // sets \p NewLine to the last line checked.
   // Returns true if the current namespace is empty.
   bool checkEmptyNamespace(SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
                            unsigned CurrentLine, unsigned &NewLine) {
     unsigned InitLine = CurrentLine, End = AnnotatedLines.size();
-    if (Env.getFormatStyle().BraceWrapping.AfterNamespace) {
+    if (Style.BraceWrapping.AfterNamespace) {
       // If the left brace is in a new line, we should consume it first so that
       // it does not make the namespace non-empty.
       // FIXME: error handling if there is no left brace.
       if (!AnnotatedLines[++CurrentLine]->startsWith(tok::l_brace)) {
         NewLine = CurrentLine;
         return false;
       }
     } else if (!AnnotatedLines[CurrentLine]->endsWith(tok::l_brace)) {
tooling::Replacements generateFixes() {
 
     return Fixes;
   }
 
   // Class for less-than inequality comparason for the set `RedundantTokens`.
   // We store tokens in the order they appear in the translation unit so that
   // we do not need to sort them in `generateFixes()`.
   struct FormatTokenLess {
-    FormatTokenLess(SourceManager &SM) : SM(SM) {}
+    FormatTokenLess(const SourceManager &SM) : SM(SM) {}
 
     bool operator()(const FormatToken *LHS, const FormatToken *RHS) {
       return SM.isBeforeInTranslationUnit(LHS->Tok.getLocation(),
                                           RHS->Tok.getLocation());
     }
-    SourceManager &SM;
+    const SourceManager &SM;
   };
 
   // Tokens to be deleted.
   std::set<FormatToken *, FormatTokenLess> DeletedTokens;
   // The line numbers of lines to be deleted.
   std::set<unsigned> DeletedLines;
 };
 

 
 tooling::Replacements reformat(const FormatStyle &Style, SourceManager &SM,
                                FileID ID, ArrayRef<CharSourceRange> Ranges,
                                bool *IncompleteFormat) {
   FormatStyle Expanded = expandPresets(Style);
   if (Expanded.DisableFormat)
     return tooling::Replacements();
 
-  Environment Env(Expanded, SM, ID, Ranges);
-  Formatter Format(Env, IncompleteFormat);
+  Environment Env(SM, ID, Ranges);
+  Formatter Format(Env, Expanded, IncompleteFormat);
   return Format.process();
 }
 
 tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
                                ArrayRef<tooling::Range> Ranges,
                                StringRef FileName, bool *IncompleteFormat) {
   FormatStyle Expanded = expandPresets(Style);
   if (Expanded.DisableFormat)
     return tooling::Replacements();
 
   std::unique_ptr<Environment> Env =
-      Environment::CreateVirtualEnvironment(Expanded, Code, FileName, Ranges);
-  Formatter Format(*Env, IncompleteFormat);
+      Environment::CreateVirtualEnvironment(Code, FileName, Ranges);
+  Formatter Format(*Env, Expanded, IncompleteFormat);
   return Format.process();
 }
 
 tooling::Replacements cleanup(const FormatStyle &Style, SourceManager &SM,
                               FileID ID, ArrayRef<CharSourceRange> Ranges) {
-  Environment Env(Style, SM, ID, Ranges);
-  Cleaner Clean(Env);
+  Environment Env(SM, ID, Ranges);
+  Cleaner Clean(Env, Style);
   return Clean.process();
 }
 
 tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code,
                               ArrayRef<tooling::Range> Ranges,
                               StringRef FileName) {
   std::unique_ptr<Environment> Env =
-      Environment::CreateVirtualEnvironment(Style, Code, FileName, Ranges);
-  Cleaner Clean(*Env);
+      Environment::CreateVirtualEnvironment(Code, FileName, Ranges);
+  Cleaner Clean(*Env, Style);
   return Clean.process();
 }
 
 LangOptions getFormattingLangOpts(const FormatStyle &Style) {
   LangOptions LangOpts;
   LangOpts.CPlusPlus = 1;
   LangOpts.CPlusPlus11 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
   LangOpts.CPlusPlus14 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;

lib/Format/WhitespaceManager.h

 /// To guarantee correctness of alignment operations, the \c WhitespaceManager
 /// must be informed about every token in the source file; for each token, there
 /// must be exactly one call to either \c replaceWhitespace or
 /// \c addUntouchableToken.
 ///
 /// There may be multiple calls to \c breakToken for a given token.
 class WhitespaceManager {
 public:
-  WhitespaceManager(SourceManager &SourceMgr, const FormatStyle &Style,
+  WhitespaceManager(const SourceManager &SourceMgr, const FormatStyle &Style,
                     bool UseCRLF)
       : SourceMgr(SourceMgr), Style(Style), UseCRLF(UseCRLF) {}
 
   /// \brief Prepares the \c WhitespaceManager for another run.
   void reset();
 
   /// \brief Replaces the whitespace in front of \p Tok. Only call once for
   /// each \c AnnotatedToken.
private:
   void appendNewlineText(std::string &Text, unsigned Newlines);
   void appendNewlineText(std::string &Text, unsigned Newlines,
                          unsigned PreviousEndOfTokenColumn,
                          unsigned EscapedNewlineColumn);
   void appendIndentText(std::string &Text, unsigned IndentLevel,
                         unsigned Spaces, unsigned WhitespaceStartColumn);
 
   SmallVector<Change, 16> Changes;
-  SourceManager &SourceMgr;
+  const SourceManager &SourceMgr;
   tooling::Replacements Replaces;
   const FormatStyle &Style;
   bool UseCRLF;
 };
 
 } // namespace format
 } // namespace clang
 
 #endif