[clang-format] test revision (NOT FOR COMMIT) to demonstrate east/west const fixer capability

[MyDeveloperDay]

Summary

This is a demo revision to show the capability of D69764: [clang-format] Add Left/Right Const fixer capability

I won't be committing this.

[MyDeveloperDay]

Further Demonstration of D69764: [clang-format] Add Left/Right Const fixer capability with new QualifierOrder

clang/lib/Format/AffectedRangeManager.h

 namespace clang {
 namespace format {
 
 struct FormatToken;
 class AnnotatedLine;
 
 class AffectedRangeManager {
 public:
-  AffectedRangeManager(const SourceManager &SourceMgr,
-                       const ArrayRef<CharSourceRange> Ranges)
+  AffectedRangeManager(SourceManager const &SourceMgr,
+                       ArrayRef<CharSourceRange> const 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 in \p Lines or one of their
   // children is affected.
   bool computeAffectedLines(SmallVectorImpl<AnnotatedLine *> &Lines);
 
   // Returns true if 'Range' intersects with one of the input ranges.
-  bool affectsCharSourceRange(const CharSourceRange &Range);
+  bool affectsCharSourceRange(CharSourceRange const &Range);
 
 private:
   // Returns true if the range from 'First' to 'Last' intersects with one of the
   // input ranges.
-  bool affectsTokenRange(const FormatToken &First, const FormatToken &Last,
+  bool affectsTokenRange(FormatToken const &First, FormatToken const &Last,
                          bool IncludeLeadingNewlines);
 
   // Returns true if one of the input ranges intersect the leading empty lines
   // before 'Tok'.
-  bool affectsLeadingEmptyLines(const FormatToken &Tok);
+  bool affectsLeadingEmptyLines(FormatToken const &Tok);
 
   // 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,
+  bool nonPPLineAffected(AnnotatedLine *Line, AnnotatedLine const *PreviousLine,
                          SmallVectorImpl<AnnotatedLine *> &Lines);
 
-  const SourceManager &SourceMgr;
-  const SmallVector<CharSourceRange, 8> Ranges;
+  SourceManager const &SourceMgr;
+  SmallVector<CharSourceRange, 8> const Ranges;
 };
 
 } // namespace format
 } // namespace clang
 
 #endif // LLVM_CLANG_LIB_FORMAT_AFFECTEDRANGEMANAGER_H

clang/lib/Format/AffectedRangeManager.cpp

 namespace clang {
 namespace format {
 
 bool AffectedRangeManager::computeAffectedLines(
     SmallVectorImpl<AnnotatedLine *> &Lines) {
   SmallVectorImpl<AnnotatedLine *>::iterator I = Lines.begin();
   SmallVectorImpl<AnnotatedLine *>::iterator E = Lines.end();
   bool SomeLineAffected = false;
-  const AnnotatedLine *PreviousLine = nullptr;
+  AnnotatedLine const *PreviousLine = nullptr;
   while (I != E) {
     AnnotatedLine *Line = *I;
     Line->LeadingEmptyLinesAffected = affectsLeadingEmptyLines(*Line->First);
 
     // If a line is part of a preprocessor directive, it needs to be formatted
     // if any token within the directive is affected.
     if (Line->InPPDirective) {
       FormatToken *Last = Line->Last;
while (I != E) {
 
     PreviousLine = Line;
     ++I;
   }
   return SomeLineAffected;
 }
 
 bool AffectedRangeManager::affectsCharSourceRange(
-    const CharSourceRange &Range) {
+    CharSourceRange const &Range) {
   for (SmallVectorImpl<CharSourceRange>::const_iterator I = Ranges.begin(),
                                                         E = Ranges.end();
        I != E; ++I) {
     if (!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(), I->getBegin()) &&
         !SourceMgr.isBeforeInTranslationUnit(I->getEnd(), Range.getBegin()))
       return true;
   }
   return false;
 }
 
-bool AffectedRangeManager::affectsTokenRange(const FormatToken &First,
-                                             const FormatToken &Last,
+bool AffectedRangeManager::affectsTokenRange(FormatToken const &First,
+                                             FormatToken const &Last,
                                              bool IncludeLeadingNewlines) {
   SourceLocation Start = First.WhitespaceRange.getBegin();
   if (!IncludeLeadingNewlines)
     Start = Start.getLocWithOffset(First.LastNewlineOffset);
   SourceLocation End = Last.getStartOfNonWhitespace();
   End = End.getLocWithOffset(Last.TokenText.size());
   CharSourceRange Range = CharSourceRange::getCharRange(Start, End);
   return affectsCharSourceRange(Range);
 }
 
-bool AffectedRangeManager::affectsLeadingEmptyLines(const FormatToken &Tok) {
+bool AffectedRangeManager::affectsLeadingEmptyLines(FormatToken const &Tok) {
   CharSourceRange EmptyLineRange = CharSourceRange::getCharRange(
       Tok.WhitespaceRange.getBegin(),
       Tok.WhitespaceRange.getBegin().getLocWithOffset(Tok.LastNewlineOffset));
   return affectsCharSourceRange(EmptyLineRange);
 }
 
 void AffectedRangeManager::markAllAsAffected(
     SmallVectorImpl<AnnotatedLine *>::iterator I,
     SmallVectorImpl<AnnotatedLine *>::iterator E) {
   while (I != E) {
     (*I)->Affected = true;
     markAllAsAffected((*I)->Children.begin(), (*I)->Children.end());
     ++I;
   }
 }
 
 bool AffectedRangeManager::nonPPLineAffected(
-    AnnotatedLine *Line, const AnnotatedLine *PreviousLine,
+    AnnotatedLine *Line, AnnotatedLine const *PreviousLine,
     SmallVectorImpl<AnnotatedLine *> &Lines) {
   bool SomeLineAffected = false;
   Line->ChildrenAffected = computeAffectedLines(Line->Children);
   if (Line->ChildrenAffected)
     SomeLineAffected = true;
 
   // Stores whether one of the line's tokens is directly affected.
   bool SomeTokenAffected = false;

clang/lib/Format/BreakableToken.h

 #include "llvm/Support/Regex.h"
 #include <utility>
 
 namespace clang {
 namespace format {
 
 /// Checks if \p Token switches formatting, like /* clang-format off */.
 /// \p Token must be a comment.
-bool switchesFormatting(const FormatToken &Token);
+bool switchesFormatting(FormatToken const &Token);
 
 struct FormatStyle;
 
 /// Base class for tokens / ranges of tokens that can allow breaking
 /// within the tokens - for example, to avoid whitespace beyond the column
 /// limit, or to reflow text.
 ///
 /// Generally, a breakable token consists of logical lines, addressed by a line
public:
 
   /// Returns a range (offset, length) at which to break the line at
   /// \p LineIndex, if previously broken at \p TailOffset. If possible, do not
   /// violate \p ColumnLimit, assuming the text starting at \p TailOffset in
   /// the token is formatted starting at ContentStartColumn in the reformatted
   /// file.
   virtual Split getSplit(unsigned LineIndex, unsigned TailOffset,
                          unsigned ColumnLimit, unsigned ContentStartColumn,
-                         const llvm::Regex &CommentPragmasRegex) const = 0;
+                         llvm::Regex const &CommentPragmasRegex) const = 0;
 
   /// Emits the previously retrieved \p Split via \p Whitespaces.
   virtual void insertBreak(unsigned LineIndex, unsigned TailOffset, Split Split,
                            unsigned ContentIndent,
                            WhitespaceManager &Whitespaces) const = 0;
 
   /// Returns the number of columns needed to format
   /// \p RemainingTokenColumns, assuming that Split is within the range measured
public:
   /// Returning (StringRef::npos, 0) indicates reflowing is not possible.
   ///
   /// The range will include any whitespace preceding the specified line's
   /// content.
   ///
   /// If the split is not contained within one token, for example when reflowing
   /// line comments, returns (0, <length>).
   virtual Split getReflowSplit(unsigned LineIndex,
-                               const llvm::Regex &CommentPragmasRegex) const {
+                               llvm::Regex const &CommentPragmasRegex) const {
     return Split(StringRef::npos, 0);
   }
 
   /// Reflows the current line into the end of the previous one.
   virtual void reflow(unsigned LineIndex,
                       WhitespaceManager &Whitespaces) const {}
 
   /// Returns whether there will be a line break at the start of the
public:
   }
 
   /// Updates the next token of \p State to the next token after this
   /// one. This can be used when this token manages a set of underlying tokens
   /// as a unit and is responsible for the formatting of the them.
   virtual void updateNextToken(LineState &State) const {}
 
 protected:
-  BreakableToken(const FormatToken &Tok, bool InPPDirective,
-                 encoding::Encoding Encoding, const FormatStyle &Style)
+  BreakableToken(FormatToken const &Tok, bool InPPDirective,
+                 encoding::Encoding Encoding, FormatStyle const &Style)
       : Tok(Tok), InPPDirective(InPPDirective), Encoding(Encoding),
         Style(Style) {}
 
-  const FormatToken &Tok;
-  const bool InPPDirective;
+  FormatToken const &Tok;
+  bool const InPPDirective;
   const encoding::Encoding Encoding;
-  const FormatStyle &Style;
+  FormatStyle const &Style;
 };
 
 class BreakableStringLiteral : public BreakableToken {
 public:
   /// Creates a breakable token for a single line string literal.
   ///
   /// \p StartColumn specifies the column in which the token will start
   /// after formatting.
-  BreakableStringLiteral(const FormatToken &Tok, unsigned StartColumn,
+  BreakableStringLiteral(FormatToken const &Tok, unsigned StartColumn,
                          StringRef Prefix, StringRef Postfix,
                          unsigned UnbreakableTailLength, bool InPPDirective,
-                         encoding::Encoding Encoding, const FormatStyle &Style);
+                         encoding::Encoding Encoding, FormatStyle const &Style);
 
   Split getSplit(unsigned LineIndex, unsigned TailOffset, unsigned ColumnLimit,
                  unsigned ContentStartColumn,
-                 const llvm::Regex &CommentPragmasRegex) const override;
+                 llvm::Regex const &CommentPragmasRegex) const override;
   void insertBreak(unsigned LineIndex, unsigned TailOffset, Split Split,
                    unsigned ContentIndent,
                    WhitespaceManager &Whitespaces) const override;
   void compressWhitespace(unsigned LineIndex, unsigned TailOffset, Split Split,
                           WhitespaceManager &Whitespaces) const override {}
   unsigned getLineCount() const override;
   unsigned getRangeLength(unsigned LineIndex, unsigned Offset,
                           StringRef::size_type Length,

 };
 
 class BreakableComment : public BreakableToken {
 protected:
   /// Creates a breakable token for a comment.
   ///
   /// \p StartColumn specifies the column in which the comment will start after
   /// formatting.
-  BreakableComment(const FormatToken &Token, unsigned StartColumn,
+  BreakableComment(FormatToken const &Token, unsigned StartColumn,
                    bool InPPDirective, encoding::Encoding Encoding,
-                   const FormatStyle &Style);
+                   FormatStyle const &Style);
 
 public:
   bool supportsReflow() const override { return true; }
   unsigned getLineCount() const override;
   Split getSplit(unsigned LineIndex, unsigned TailOffset, unsigned ColumnLimit,
                  unsigned ContentStartColumn,
-                 const llvm::Regex &CommentPragmasRegex) const override;
+                 llvm::Regex const &CommentPragmasRegex) const override;
   void compressWhitespace(unsigned LineIndex, unsigned TailOffset, Split Split,
                           WhitespaceManager &Whitespaces) const override;
 
 protected:
   // Returns the token containing the line at LineIndex.
-  const FormatToken &tokenAt(unsigned LineIndex) const;
+  FormatToken const &tokenAt(unsigned LineIndex) const;
 
   // Checks if the content of line LineIndex may be reflown with the previous
   // line.
   virtual bool mayReflow(unsigned LineIndex,
-                         const llvm::Regex &CommentPragmasRegex) const = 0;
+                         llvm::Regex const &CommentPragmasRegex) const = 0;
 
   // Contains the original text of the lines of the block comment.
   //
   // In case of a block comments, excludes the leading /* in the first line and
   // trailing */ in the last line. In case of line comments, excludes the
   // leading // and spaces.
   SmallVector<StringRef, 16> Lines;
 
protected:
   // // comment 1 comment 2
   // and not:
   // // comment 1comment 2
   StringRef ReflowPrefix = " ";
 };
 
 class BreakableBlockComment : public BreakableComment {
 public:
-  BreakableBlockComment(const FormatToken &Token, unsigned StartColumn,
+  BreakableBlockComment(FormatToken const &Token, unsigned StartColumn,
                         unsigned OriginalStartColumn, bool FirstInLine,
                         bool InPPDirective, encoding::Encoding Encoding,
-                        const FormatStyle &Style, bool UseCRLF);
+                        FormatStyle const &Style, bool UseCRLF);
 
   Split getSplit(unsigned LineIndex, unsigned TailOffset, unsigned ColumnLimit,
                  unsigned ContentStartColumn,
-                 const llvm::Regex &CommentPragmasRegex) const override;
+                 llvm::Regex const &CommentPragmasRegex) const override;
   unsigned getRangeLength(unsigned LineIndex, unsigned Offset,
                           StringRef::size_type Length,
                           unsigned StartColumn) const override;
   unsigned getRemainingLength(unsigned LineIndex, unsigned Offset,
                               unsigned StartColumn) const override;
   unsigned getContentStartColumn(unsigned LineIndex, bool Break) const override;
   unsigned getContentIndent(unsigned LineIndex) const override;
   void insertBreak(unsigned LineIndex, unsigned TailOffset, Split Split,
                    unsigned ContentIndent,
                    WhitespaceManager &Whitespaces) const override;
   Split getReflowSplit(unsigned LineIndex,
-                       const llvm::Regex &CommentPragmasRegex) const override;
+                       llvm::Regex const &CommentPragmasRegex) const override;
   void reflow(unsigned LineIndex,
               WhitespaceManager &Whitespaces) const override;
   bool introducesBreakBeforeToken() const override;
   void adaptStartOfLine(unsigned LineIndex,
                         WhitespaceManager &Whitespaces) const override;
   Split getSplitAfterLastLine(unsigned TailOffset) const override;
 
   bool mayReflow(unsigned LineIndex,
-                 const llvm::Regex &CommentPragmasRegex) const override;
+                 llvm::Regex const &CommentPragmasRegex) const override;
 
   // Contains Javadoc annotations that require additional indent when continued
   // on multiple lines.
   static const llvm::StringSet<> ContentIndentingJavadocAnnotations;
 
 private:
   // Rearranges the whitespace between Lines[LineIndex-1] and Lines[LineIndex].
   //
private:
 
   // Length of the sequence of tokens after this string literal that cannot
   // contain line breaks.
   unsigned UnbreakableTailLength;
 };
 
 class BreakableLineCommentSection : public BreakableComment {
 public:
-  BreakableLineCommentSection(const FormatToken &Token, unsigned StartColumn,
+  BreakableLineCommentSection(FormatToken const &Token, unsigned StartColumn,
                               bool InPPDirective, encoding::Encoding Encoding,
-                              const FormatStyle &Style);
+                              FormatStyle const &Style);
 
   unsigned getRangeLength(unsigned LineIndex, unsigned Offset,
                           StringRef::size_type Length,
                           unsigned StartColumn) const override;
   unsigned getContentStartColumn(unsigned LineIndex, bool Break) const override;
   void insertBreak(unsigned LineIndex, unsigned TailOffset, Split Split,
                    unsigned ContentIndent,
                    WhitespaceManager &Whitespaces) const override;
   Split getReflowSplit(unsigned LineIndex,
-                       const llvm::Regex &CommentPragmasRegex) const override;
+                       llvm::Regex const &CommentPragmasRegex) const override;
   void reflow(unsigned LineIndex,
               WhitespaceManager &Whitespaces) const override;
   void adaptStartOfLine(unsigned LineIndex,
                         WhitespaceManager &Whitespaces) const override;
   void updateNextToken(LineState &State) const override;
   bool mayReflow(unsigned LineIndex,
-                 const llvm::Regex &CommentPragmasRegex) const override;
+                 llvm::Regex const &CommentPragmasRegex) const override;
 
 private:
   // OriginalPrefix[i] contains the original prefix of line i, including
   // trailing whitespace before the start of the content. The indentation
   // preceding the prefix is not included.
   // For example, if the line is:
   // // content
   // then the original prefix is "// ".

clang/lib/Format/BreakableToken.cpp

static bool IsBlank(char C) {
   case '\r':
     return true;
   default:
     return false;
   }
 }
 
 static StringRef getLineCommentIndentPrefix(StringRef Comment,
-                                            const FormatStyle &Style) {
+                                            FormatStyle const &Style) {
   static constexpr StringRef KnownCStylePrefixes[] = {"///<", "//!<", "///",
                                                       "//!",  "//:",  "//"};
   static constexpr StringRef KnownTextProtoPrefixes[] = {"####", "###", "##",
                                                          "//", "#"};
   ArrayRef<StringRef> KnownPrefixes(KnownCStylePrefixes);
   if (Style.Language == FormatStyle::LK_TextProto)
     KnownPrefixes = KnownTextProtoPrefixes;
 
   assert(std::is_sorted(KnownPrefixes.begin(), KnownPrefixes.end(),
                         [](StringRef Lhs, StringRef Rhs) noexcept {
                           return Lhs.size() > Rhs.size();
                         }));
 
   for (StringRef KnownPrefix : KnownPrefixes) {
     if (Comment.startswith(KnownPrefix)) {
-      const auto PrefixLength =
+      auto const PrefixLength =
           Comment.find_first_not_of(' ', KnownPrefix.size());
       return Comment.substr(0, PrefixLength);
     }
   }
   return {};
 }
 
 static BreakableToken::Split
 getCommentSplit(StringRef Text, unsigned ContentStartColumn,
                 unsigned ColumnLimit, unsigned TabWidth,
-                encoding::Encoding Encoding, const FormatStyle &Style,
+                encoding::Encoding Encoding, FormatStyle const &Style,
                 bool DecorationEndsWithStar = false) {
   LLVM_DEBUG(llvm::dbgs() << "Comment split: \"" << Text
                           << "\", Column limit: " << ColumnLimit
                           << ", Content start: " << ContentStartColumn << "\n");
   if (ColumnLimit <= ContentStartColumn + 1)
     return BreakableToken::Split(StringRef::npos, 0);
 
   unsigned MaxSplit = ColumnLimit - ContentStartColumn + 1;
if (Style.Language == FormatStyle::LK_JavaScript) {
     if (SpaceOffset != StringRef::npos && SpaceOffset + 1 < Text.size() &&
         Text[SpaceOffset + 1] == '{') {
       MaxSplitBytes = SpaceOffset + 1;
     }
   }
 
   StringRef::size_type SpaceOffset = Text.find_last_of(Blanks, MaxSplitBytes);
 
-  static const auto kNumberedListRegexp = llvm::Regex("^[1-9][0-9]?\\.");
+  static auto const kNumberedListRegexp = llvm::Regex("^[1-9][0-9]?\\.");
   // Some spaces are unacceptable to break on, rewind past them.
   while (SpaceOffset != StringRef::npos) {
     // If a line-comment ends with `\`, the next line continues the comment,
     // whether or not it starts with `//`. This is confusing and triggers
     // -Wcomment.
     // Avoid introducing multiline comments by not allowing a break right
     // after '\'.
     if (Style.isCpp()) {
if (SlashOffset != 0)
     return BreakableToken::Split(SlashOffset + 1, 0);
   if (WordStartOffset != 0)
     return BreakableToken::Split(WordStartOffset + 1, 0);
   if (SplitPoint != 0)
     return BreakableToken::Split(SplitPoint, 0);
   return BreakableToken::Split(StringRef::npos, 0);
 }
 
-bool switchesFormatting(const FormatToken &Token) {
+bool switchesFormatting(FormatToken const &Token) {
   assert((Token.is(TT_BlockComment) || Token.is(TT_LineComment)) &&
          "formatting regions are switched by comment tokens");
   StringRef Content = Token.TokenText.substr(2).ltrim();
   return Content.startswith("clang-format on") ||
          Content.startswith("clang-format off");
 }
 
 unsigned

 }
 
 unsigned BreakableStringLiteral::getContentStartColumn(unsigned LineIndex,
                                                        bool Break) const {
   return StartColumn + Prefix.size();
 }
 
 BreakableStringLiteral::BreakableStringLiteral(
-    const FormatToken &Tok, unsigned StartColumn, StringRef Prefix,
+    FormatToken const &Tok, unsigned StartColumn, StringRef Prefix,
     StringRef Postfix, unsigned UnbreakableTailLength, bool InPPDirective,
-    encoding::Encoding Encoding, const FormatStyle &Style)
+    encoding::Encoding Encoding, FormatStyle const &Style)
     : BreakableToken(Tok, InPPDirective, Encoding, Style),
       StartColumn(StartColumn), Prefix(Prefix), Postfix(Postfix),
       UnbreakableTailLength(UnbreakableTailLength) {
   assert(Tok.TokenText.startswith(Prefix) && Tok.TokenText.endswith(Postfix));
   Line = Tok.TokenText.substr(
       Prefix.size(), Tok.TokenText.size() - Prefix.size() - Postfix.size());
 }
 
 BreakableToken::Split BreakableStringLiteral::getSplit(
     unsigned LineIndex, unsigned TailOffset, unsigned ColumnLimit,
-    unsigned ContentStartColumn, const llvm::Regex &CommentPragmasRegex) const {
+    unsigned ContentStartColumn, llvm::Regex const &CommentPragmasRegex) const {
   return getStringSplit(Line.substr(TailOffset), ContentStartColumn,
                         ColumnLimit - Postfix.size(), Style.TabWidth, Encoding);
 }
 
 void BreakableStringLiteral::insertBreak(unsigned LineIndex,
                                          unsigned TailOffset, Split Split,
                                          unsigned ContentIndent,
                                          WhitespaceManager &Whitespaces) const {
   Whitespaces.replaceWhitespaceInToken(
       Tok, Prefix.size() + TailOffset + Split.first, Split.second, Postfix,
       Prefix, InPPDirective, 1, StartColumn);
 }
 
-BreakableComment::BreakableComment(const FormatToken &Token,
+BreakableComment::BreakableComment(FormatToken const &Token,
                                    unsigned StartColumn, bool InPPDirective,
                                    encoding::Encoding Encoding,
-                                   const FormatStyle &Style)
+                                   FormatStyle const &Style)
     : BreakableToken(Token, InPPDirective, Encoding, Style),
       StartColumn(StartColumn) {}
 
 unsigned BreakableComment::getLineCount() const { return Lines.size(); }
 
 BreakableToken::Split
 BreakableComment::getSplit(unsigned LineIndex, unsigned TailOffset,
                            unsigned ColumnLimit, unsigned ContentStartColumn,
-                           const llvm::Regex &CommentPragmasRegex) const {
+                           llvm::Regex const &CommentPragmasRegex) const {
   // Don't break lines matching the comment pragmas regex.
   if (CommentPragmasRegex.match(Content[LineIndex]))
     return Split(StringRef::npos, 0);
   return getCommentSplit(Content[LineIndex].substr(TailOffset),
                          ContentStartColumn, ColumnLimit, Style.TabWidth,
                          Encoding, Style);
 }
 
 void BreakableComment::compressWhitespace(
     unsigned LineIndex, unsigned TailOffset, Split Split,
     WhitespaceManager &Whitespaces) const {
   StringRef Text = Content[LineIndex].substr(TailOffset);
   // Text is relative to the content line, but Whitespaces operates relative to
   // the start of the corresponding token, so compute the start of the Split
   // that needs to be compressed into a single space relative to the start of
   // its token.
   unsigned BreakOffsetInToken =
       Text.data() - tokenAt(LineIndex).TokenText.data() + Split.first;
   unsigned CharsToRemove = Split.second;
   Whitespaces.replaceWhitespaceInToken(
       tokenAt(LineIndex), BreakOffsetInToken, CharsToRemove, "", "",
       /*InPPDirective=*/false, /*Newlines=*/0, /*Spaces=*/1);
 }
 
-const FormatToken &BreakableComment::tokenAt(unsigned LineIndex) const {
+FormatToken const &BreakableComment::tokenAt(unsigned LineIndex) const {
   return Tokens[LineIndex] ? *Tokens[LineIndex] : Tok;
 }
 
 static bool mayReflowContent(StringRef Content) {
   Content = Content.trim(Blanks);
   // Lines starting with '@' commonly have special meaning.
   // Lines starting with '-', '-#', '+' or '*' are bulleted/numbered lists.
   bool hasSpecialMeaningPrefix = false;
   for (StringRef Prefix :
        {"@", "TODO", "FIXME", "XXX", "-# ", "- ", "+ ", "* "}) {
     if (Content.startswith(Prefix)) {
       hasSpecialMeaningPrefix = true;
       break;
     }
   }
 
   // Numbered lists may also start with a number followed by '.'
   // To avoid issues if a line starts with a number which is actually the end
   // of a previous line, we only consider numbers with up to 2 digits.
-  static const auto kNumberedListRegexp = llvm::Regex("^[1-9][0-9]?\\. ");
+  static auto const kNumberedListRegexp = llvm::Regex("^[1-9][0-9]?\\. ");
   hasSpecialMeaningPrefix =
       hasSpecialMeaningPrefix || kNumberedListRegexp.match(Content);
 
   // Simple heuristic for what to reflow: content should contain at least two
   // characters and either the first or second character must be
   // non-punctuation.
   return Content.size() >= 2 && !hasSpecialMeaningPrefix &&
          !Content.endswith("\\") &&
          // Note that this is UTF-8 safe, since if isPunctuation(Content[0]) is
          // true, then the first code point must be 1 byte long.
          (!isPunctuation(Content[0]) || !isPunctuation(Content[1]));
 }
 
 BreakableBlockComment::BreakableBlockComment(
-    const FormatToken &Token, unsigned StartColumn,
+    FormatToken const &Token, unsigned StartColumn,
     unsigned OriginalStartColumn, bool FirstInLine, bool InPPDirective,
-    encoding::Encoding Encoding, const FormatStyle &Style, bool UseCRLF)
+    encoding::Encoding Encoding, FormatStyle const &Style, bool UseCRLF)
     : BreakableComment(Token, StartColumn, InPPDirective, Encoding, Style),
       DelimitersOnNewline(false),
       UnbreakableTailLength(Token.UnbreakableTailLength) {
   assert(Tok.is(TT_BlockComment) &&
          "block comment section must start with a block comment");
 
   StringRef TokenText(Tok.TokenText);
   assert(TokenText.startswith("/*") && TokenText.endswith("*/"));
for (size_t i = 0; i < Lines.size(); ++i) {
                    << "CC=" << ContentColumn[i] << "| "
                    << "IN=" << (Content[i].data() - Lines[i].data()) << "\n";
     }
   });
 }
 
 BreakableToken::Split BreakableBlockComment::getSplit(
     unsigned LineIndex, unsigned TailOffset, unsigned ColumnLimit,
-    unsigned ContentStartColumn, const llvm::Regex &CommentPragmasRegex) const {
+    unsigned ContentStartColumn, llvm::Regex const &CommentPragmasRegex) const {
   // Don't break lines matching the comment pragmas regex.
   if (CommentPragmasRegex.match(Content[LineIndex]))
     return Split(StringRef::npos, 0);
   return getCommentSplit(Content[LineIndex].substr(TailOffset),
                          ContentStartColumn, ColumnLimit, Style.TabWidth,
                          Encoding, Style, Decoration.endswith("*"));
 }
 
void BreakableBlockComment::insertBreak(unsigned LineIndex, unsigned TailOffset,
   Whitespaces.replaceWhitespaceInToken(
       tokenAt(LineIndex), BreakOffsetInToken, CharsToRemove, "",
       PrefixWithTrailingIndent, InPPDirective, /*Newlines=*/1,
       /*Spaces=*/LocalIndentAtLineBreak + ContentIndent -
           PrefixWithTrailingIndent.size());
 }
 
 BreakableToken::Split BreakableBlockComment::getReflowSplit(
-    unsigned LineIndex, const llvm::Regex &CommentPragmasRegex) const {
+    unsigned LineIndex, llvm::Regex const &CommentPragmasRegex) const {
   if (!mayReflow(LineIndex, CommentPragmasRegex))
     return Split(StringRef::npos, 0);
 
   // If we're reflowing into a line with content indent, only reflow the next
   // line if its starting whitespace matches the content indent.
   size_t Trimmed = Content[LineIndex].find_first_not_of(Blanks);
   if (LineIndex) {
     unsigned PreviousContentIndent = getContentIndent(LineIndex - 1);
if (DelimitersOnNewline) {
     StringRef TrimmedLine = Line.rtrim(Blanks);
     if (!TrimmedLine.empty())
       return Split(TrimmedLine.size(), Line.size() - TrimmedLine.size());
   }
   return Split(StringRef::npos, 0);
 }
 
 bool BreakableBlockComment::mayReflow(
-    unsigned LineIndex, const llvm::Regex &CommentPragmasRegex) const {
+    unsigned LineIndex, llvm::Regex const &CommentPragmasRegex) const {
   // Content[LineIndex] may exclude the indent after the '*' decoration. In that
   // case, we compute the start of the comment pragma manually.
   StringRef IndentContent = Content[LineIndex];
   if (Lines[LineIndex].ltrim(Blanks).startswith("*")) {
     IndentContent = Lines[LineIndex].ltrim(Blanks).substr(1);
   }
   return LineIndex > 0 && !CommentPragmasRegex.match(IndentContent) &&
          mayReflowContent(Content[LineIndex]) && !Tok.Finalized &&
          !switchesFormatting(tokenAt(LineIndex));
 }
 
 BreakableLineCommentSection::BreakableLineCommentSection(
-    const FormatToken &Token, unsigned StartColumn, bool InPPDirective,
-    encoding::Encoding Encoding, const FormatStyle &Style)
+    FormatToken const &Token, unsigned StartColumn, bool InPPDirective,
+    encoding::Encoding Encoding, FormatStyle const &Style)
     : BreakableComment(Token, StartColumn, InPPDirective, Encoding, Style) {
   assert(Tok.is(TT_LineComment) &&
          "line comment section must start with a line comment");
   FormatToken *LineTok = nullptr;
   // How many spaces we changed in the first line of the section, this will be
   // applied in all following lines
   int FirstLineSpaceChange = 0;
-  for (const FormatToken *CurrentTok = &Tok;
+  for (FormatToken const *CurrentTok = &Tok;
        CurrentTok && CurrentTok->is(TT_LineComment);
        CurrentTok = CurrentTok->Next) {
     LastLineTok = LineTok;
     StringRef TokenText(CurrentTok->TokenText);
     assert((TokenText.startswith("//") || TokenText.startswith("#")) &&
            "unsupported line comment prefix, '//' and '#' are supported");
     size_t FirstLineIndex = Lines.size();
     TokenText.split(Lines, "\n");
     Content.resize(Lines.size());
     ContentColumn.resize(Lines.size());
     PrefixSpaceChange.resize(Lines.size());
     Tokens.resize(Lines.size());
     Prefix.resize(Lines.size());
     OriginalPrefix.resize(Lines.size());
     for (size_t i = FirstLineIndex, e = Lines.size(); i < e; ++i) {
       Lines[i] = Lines[i].ltrim(Blanks);
       StringRef IndentPrefix = getLineCommentIndentPrefix(Lines[i], Style);
       OriginalPrefix[i] = IndentPrefix;
-      const unsigned SpacesInPrefix =
+      unsigned const SpacesInPrefix =
           std::count(IndentPrefix.begin(), IndentPrefix.end(), ' ');
 
       // On the first line of the comment section we calculate how many spaces
       // are to be added or removed, all lines after that just get only the
       // change and we will not look at the maximum anymore. Additionally to the
       // actual first line, we calculate that when the non space Prefix changes,
       // e.g. from "///" to "//".
       if (i == 0 || OriginalPrefix[i].rtrim(Blanks) !=
for (size_t i = FirstLineIndex, e = Lines.size(); i < e; ++i) {
 
         if (SpacesInPrefix + PrefixSpaceChange[i] <
             Style.SpacesInLineCommentPrefix.Minimum) {
           PrefixSpaceChange[i] += Style.SpacesInLineCommentPrefix.Minimum -
                                   (SpacesInPrefix + PrefixSpaceChange[i]);
         }
 
         assert(Lines[i].size() > IndentPrefix.size());
-        const auto FirstNonSpace = Lines[i][IndentPrefix.size()];
-        const auto AllowsSpaceChange =
+        auto const FirstNonSpace = Lines[i][IndentPrefix.size()];
+        auto const AllowsSpaceChange =
             SpacesInPrefix != 0 ||
             (isAlphanumeric(FirstNonSpace) ||
              (FirstNonSpace == '}' && FirstLineSpaceChange != 0));
 
         if (PrefixSpaceChange[i] > 0 && AllowsSpaceChange) {
           Prefix[i] = IndentPrefix.str();
           Prefix[i].append(PrefixSpaceChange[i], ' ');
         } else if (PrefixSpaceChange[i] < 0 && AllowsSpaceChange) {
void BreakableLineCommentSection::insertBreak(
   unsigned CharsToRemove = Split.second;
   Whitespaces.replaceWhitespaceInToken(
       tokenAt(LineIndex), BreakOffsetInToken, CharsToRemove, "",
       Prefix[LineIndex], InPPDirective, /*Newlines=*/1,
       /*Spaces=*/ContentColumn[LineIndex] - Prefix[LineIndex].size());
 }
 
 BreakableComment::Split BreakableLineCommentSection::getReflowSplit(
-    unsigned LineIndex, const llvm::Regex &CommentPragmasRegex) const {
+    unsigned LineIndex, llvm::Regex const &CommentPragmasRegex) const {
   if (!mayReflow(LineIndex, CommentPragmasRegex))
     return Split(StringRef::npos, 0);
 
   size_t Trimmed = Content[LineIndex].find_first_not_of(Blanks);
 
   // In a line comment section each line is a separate token; thus, after a
   // split we replace all whitespace before the current line comment token
   // (which does not need to be included in the split), plus the start of the
Whitespaces.replaceWhitespace(*Tokens[LineIndex],
                                   /*Newlines=*/1,
                                   /*Spaces=*/LineColumn,
                                   /*StartOfTokenColumn=*/LineColumn,
                                   /*IsAligned=*/true,
                                   /*InPPDirective=*/false);
   }
   if (OriginalPrefix[LineIndex] != Prefix[LineIndex]) {
     // Adjust the prefix if necessary.
-    const auto SpacesToRemove = -std::min(PrefixSpaceChange[LineIndex], 0);
-    const auto SpacesToAdd = std::max(PrefixSpaceChange[LineIndex], 0);
+    auto const SpacesToRemove = -std::min(PrefixSpaceChange[LineIndex], 0);
+    auto const SpacesToAdd = std::max(PrefixSpaceChange[LineIndex], 0);
     Whitespaces.replaceWhitespaceInToken(
         tokenAt(LineIndex), OriginalPrefix[LineIndex].size() - SpacesToRemove,
         /*ReplaceChars=*/SpacesToRemove, "", "", /*InPPDirective=*/false,
         /*Newlines=*/0, /*Spaces=*/SpacesToAdd);
   }
 }
 
 void BreakableLineCommentSection::updateNextToken(LineState &State) const {
   if (LastLineTok) {
     State.NextToken = LastLineTok->Next;
   }
 }
 
 bool BreakableLineCommentSection::mayReflow(
-    unsigned LineIndex, const llvm::Regex &CommentPragmasRegex) const {
+    unsigned LineIndex, llvm::Regex const &CommentPragmasRegex) const {
   // Line comments have the indent as part of the prefix, so we need to
   // recompute the start of the line.
   StringRef IndentContent = Content[LineIndex];
   if (Lines[LineIndex].startswith("//")) {
     IndentContent = Lines[LineIndex].substr(2);
   }
   // FIXME: Decide whether we want to reflow non-regular indents:
   // Currently, we only reflow when the OriginalPrefix[LineIndex] matches the

clang/lib/Format/CMakeLists.txt

add_clang_library(clangFormat
   MacroExpander.cpp
   NamespaceEndCommentsFixer.cpp
   SortJavaScriptImports.cpp
   TokenAnalyzer.cpp
   TokenAnnotator.cpp
   UnwrappedLineFormatter.cpp
   UnwrappedLineParser.cpp
   UsingDeclarationsSorter.cpp
+  EastWestConstFixer.cpp
   WhitespaceManager.cpp
 
   LINK_LIBS
   clangBasic
   clangLex
   clangToolingCore
   clangToolingInclusions
   )

clang/lib/Format/ContinuationIndenter.h

 struct ParenState;
 struct RawStringFormatStyleManager;
 class WhitespaceManager;
 
 struct RawStringFormatStyleManager {
   llvm::StringMap<FormatStyle> DelimiterStyle;
   llvm::StringMap<FormatStyle> EnclosingFunctionStyle;
 
-  RawStringFormatStyleManager(const FormatStyle &CodeStyle);
+  RawStringFormatStyleManager(FormatStyle const &CodeStyle);
 
   llvm::Optional<FormatStyle> getDelimiterStyle(StringRef Delimiter) const;
 
   llvm::Optional<FormatStyle>
   getEnclosingFunctionStyle(StringRef EnclosingFunction) const;
 };
 
 class ContinuationIndenter {
 public:
   /// Constructs a \c ContinuationIndenter to format \p Line starting in
   /// column \p FirstIndent.
-  ContinuationIndenter(const FormatStyle &Style,
-                       const AdditionalKeywords &Keywords,
-                       const SourceManager &SourceMgr,
+  ContinuationIndenter(FormatStyle const &Style,
+                       AdditionalKeywords const &Keywords,
+                       SourceManager const &SourceMgr,
                        WhitespaceManager &Whitespaces,
                        encoding::Encoding Encoding,
                        bool BinPackInconclusiveFunctions);
 
   /// Get the initial state, i.e. the state after placing \p Line's
   /// first token at \p FirstIndent. When reformatting a fragment of code, as in
   /// the case of formatting inside raw string literals, \p FirstStartColumn is
   /// the column at which the state of the parent formatter is.
   LineState getInitialState(unsigned FirstIndent, unsigned FirstStartColumn,
-                            const AnnotatedLine *Line, bool DryRun);
+                            AnnotatedLine const *Line, bool DryRun);
 
   // FIXME: canBreak and mustBreak aren't strictly indentation-related. Find a
   // better home.
   /// Returns \c true, if a line break after \p State is allowed.
-  bool canBreak(const LineState &State);
+  bool canBreak(LineState const &State);
 
   /// Returns \c true, if a line break after \p State is mandatory.
-  bool mustBreak(const LineState &State);
+  bool mustBreak(LineState const &State);
 
   /// Appends the next token to \p State and updates information
   /// necessary for indentation.
   ///
   /// Puts the token on the current line if \p Newline is \c false and adds a
   /// line break and necessary indentation otherwise.
   ///
   /// If \p DryRun is \c false, also creates and stores the required
   /// \c Replacement.
   unsigned addTokenToState(LineState &State, bool Newline, bool DryRun,
                            unsigned ExtraSpaces = 0);
 
   /// Get the column limit for this line. This is the style's column
   /// limit, potentially reduced for preprocessor definitions.
-  unsigned getColumnLimit(const LineState &State) const;
+  unsigned getColumnLimit(LineState const &State) const;
 
 private:
   /// Mark the next token as consumed in \p State and modify its stacks
   /// accordingly.
   unsigned moveStateToNextToken(LineState &State, bool DryRun, bool Newline);
 
   /// Update 'State' according to the next token's fake left parentheses.
   void moveStatePastFakeLParens(LineState &State, bool Newline);
   /// Update 'State' according to the next token's fake r_parens.
   void moveStatePastFakeRParens(LineState &State);
 
   /// Update 'State' according to the next token being one of "(<{[".
   void moveStatePastScopeOpener(LineState &State, bool Newline);
   /// Update 'State' according to the next token being one of ")>}]".
   void moveStatePastScopeCloser(LineState &State);
   /// Update 'State' with the next token opening a nested block.
   void moveStateToNewBlock(LineState &State);
 
   /// Reformats a raw string literal.
   ///
   /// \returns An extra penalty induced by reformatting the token.
-  unsigned reformatRawStringLiteral(const FormatToken &Current,
+  unsigned reformatRawStringLiteral(FormatToken const &Current,
                                     LineState &State,
-                                    const FormatStyle &RawStringStyle,
+                                    FormatStyle const &RawStringStyle,
                                     bool DryRun, bool Newline);
 
   /// If the current token is at the end of the current line, handle
   /// the transition to the next line.
-  unsigned handleEndOfLine(const FormatToken &Current, LineState &State,
+  unsigned handleEndOfLine(FormatToken const &Current, LineState &State,
                            bool DryRun, bool AllowBreak, bool Newline);
 
   /// If \p Current is a raw string that is configured to be reformatted,
   /// return the style to be used.
-  llvm::Optional<FormatStyle> getRawStringStyle(const FormatToken &Current,
-                                                const LineState &State);
+  llvm::Optional<FormatStyle> getRawStringStyle(FormatToken const &Current,
+                                                LineState const &State);
 
   /// If the current token sticks out over the end of the line, break
   /// it if possible.
   ///
   /// \returns A pair (penalty, exceeded), where penalty is the extra penalty
   /// when tokens are broken or lines exceed the column limit, and exceeded
   /// indicates whether the algorithm purposefully left lines exceeding the
   /// column limit.
   ///
   /// The returned penalty will cover the cost of the additional line breaks
   /// and column limit violation in all lines except for the last one. The
   /// penalty for the column limit violation in the last line (and in single
   /// line tokens) is handled in \c addNextStateToQueue.
   ///
   /// \p Strict indicates whether reflowing is allowed to leave characters
   /// protruding the column limit; if true, lines will be split strictly within
   /// the column limit where possible; if false, words are allowed to protrude
   /// over the column limit as long as the penalty is less than the penalty
   /// of a break.
-  std::pair<unsigned, bool> breakProtrudingToken(const FormatToken &Current,
+  std::pair<unsigned, bool> breakProtrudingToken(FormatToken const &Current,
                                                  LineState &State,
                                                  bool AllowBreak, bool DryRun,
                                                  bool Strict);
 
   /// Returns the \c BreakableToken starting at \p Current, or nullptr
   /// if the current token cannot be broken.
   std::unique_ptr<BreakableToken>
-  createBreakableToken(const FormatToken &Current, LineState &State,
+  createBreakableToken(FormatToken const &Current, LineState &State,
                        bool AllowBreak);
 
   /// Appends the next token to \p State and updates information
   /// necessary for indentation.
   ///
   /// Puts the token on the current line.
   ///
   /// If \p DryRun is \c false, also creates and stores the required
   /// \c Replacement.
   void addTokenOnCurrentLine(LineState &State, bool DryRun,
                              unsigned ExtraSpaces);
 
   /// Appends the next token to \p State and updates information
   /// necessary for indentation.
   ///
   /// Adds a line break and necessary indentation.
   ///
   /// If \p DryRun is \c false, also creates and stores the required
   /// \c Replacement.
   unsigned addTokenOnNewLine(LineState &State, bool DryRun);
 
   /// Calculate the new column for a line wrap before the next token.
-  unsigned getNewLineColumn(const LineState &State);
+  unsigned getNewLineColumn(LineState const &State);
 
   /// Adds a multiline token to the \p State.
   ///
   /// \returns Extra penalty for the first line of the literal: last line is
   /// handled in \c addNextStateToQueue, and the penalty for other lines doesn't
   /// matter, as we don't change them.
-  unsigned addMultilineToken(const FormatToken &Current, LineState &State);
+  unsigned addMultilineToken(FormatToken const &Current, LineState &State);
 
   /// Returns \c true if the next token starts a multiline string
   /// 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);
+  bool nextIsMultilineString(LineState const &State);
 
   FormatStyle Style;
-  const AdditionalKeywords &Keywords;
-  const SourceManager &SourceMgr;
+  AdditionalKeywords const &Keywords;
+  SourceManager const &SourceMgr;
   WhitespaceManager &Whitespaces;
   encoding::Encoding Encoding;
   bool BinPackInconclusiveFunctions;
   llvm::Regex CommentPragmasRegex;
   const RawStringFormatStyleManager RawStringFormats;
 };
 
 struct ParenState {
-  ParenState(const FormatToken *Tok, unsigned Indent, unsigned LastSpace,
+  ParenState(FormatToken const *Tok, unsigned Indent, unsigned LastSpace,
              bool AvoidBinPacking, bool NoLineBreak)
       : Tok(Tok), Indent(Indent), LastSpace(LastSpace),
         NestedBlockIndent(Indent), IsAligned(false),
         BreakBeforeClosingBrace(false), AvoidBinPacking(AvoidBinPacking),
         BreakBeforeParameter(false), NoLineBreak(NoLineBreak),
         NoLineBreakInOperand(false), LastOperatorWrapped(true),
         ContainsLineBreak(false), ContainsUnwrappedBuilder(false),
         AlignColons(true), ObjCSelectorNameFound(false),
         HasMultipleNestedBlocks(false), NestedBlockInlined(false),
         IsInsideObjCArrayLiteral(false), IsCSharpGenericTypeConstraint(false),
         IsChainedConditional(false), IsWrappedConditional(false),
         UnindentOperator(false) {}
 
   /// \brief The token opening this parenthesis level, or nullptr if this level
   /// is opened by fake parenthesis.
   ///
   /// Not considered for memoization as it will always have the same value at
   /// the same token.
-  const FormatToken *Tok;
+  FormatToken const *Tok;
 
   /// The position to which a specific parenthesis level needs to be
   /// indented.
   unsigned Indent;
 
   /// The position of the last space on each level.
   ///
   /// Used e.g. to break like:
struct ParenState {
   /// \brief true if there conditionnal was wrapped on the first operator (the
   /// question mark)
   bool IsWrappedConditional : 1;
 
   /// \brief Indicates the indent should be reduced by the length of the
   /// operator.
   bool UnindentOperator : 1;
 
-  bool operator<(const ParenState &Other) const {
+  bool operator<(ParenState const &Other) const {
     if (Indent != Other.Indent)
       return Indent < Other.Indent;
     if (LastSpace != Other.LastSpace)
       return LastSpace < Other.LastSpace;
     if (NestedBlockIndent != Other.NestedBlockIndent)
       return NestedBlockIndent < Other.NestedBlockIndent;
     if (FirstLessLess != Other.FirstLessLess)
       return FirstLessLess < Other.FirstLessLess;
struct LineState {
   bool IgnoreStackForComparison;
 
   /// The indent of the first token.
   unsigned FirstIndent;
 
   /// The line that is being formatted.
   ///
   /// Does not need to be considered for memoization because it doesn't change.
-  const AnnotatedLine *Line;
+  AnnotatedLine const *Line;
 
   /// Comparison operator to be able to used \c LineState in \c map.
-  bool operator<(const LineState &Other) const {
+  bool operator<(LineState const &Other) const {
     if (NextToken != Other.NextToken)
       return NextToken < Other.NextToken;
     if (Column != Other.Column)
       return Column < Other.Column;
     if (LineContainsContinuedForLoopSection !=
         Other.LineContainsContinuedForLoopSection)
       return LineContainsContinuedForLoopSection;
     if (NoContinuation != Other.NoContinuation)

clang/lib/Format/ContinuationIndenter.cpp

 
 #define DEBUG_TYPE "format-indenter"
 
 namespace clang {
 namespace format {
 
 // Returns true if a TT_SelectorName should be indented when wrapped,
 // false otherwise.
-static bool shouldIndentWrappedSelectorName(const FormatStyle &Style,
+static bool shouldIndentWrappedSelectorName(FormatStyle const &Style,
                                             LineType LineType) {
   return Style.IndentWrappedFunctionNames || LineType == LT_ObjCMethodDecl;
 }
 
 // Returns the length of everything up to the first possible line break after
 // the ), ], } or > matching \c Tok.
-static unsigned getLengthToMatchingParen(const FormatToken &Tok,
-                                         const std::vector<ParenState> &Stack) {
+static unsigned getLengthToMatchingParen(FormatToken const &Tok,
+                                         std::vector<ParenState> const &Stack) {
   // Normally whether or not a break before T is possible is calculated and
   // stored in T.CanBreakBefore. Braces, array initializers and text proto
   // messages like `key: < ... >` are an exception: a break is possible
   // before a closing brace R if a break was inserted after the corresponding
   // opening brace. The information about whether or not a break is needed
   // before a closing brace R is stored in the ParenState field
   // S.BreakBeforeClosingBrace where S is the state that R closes.
   //
if (!Tok.MatchingParen)
     return 0;
   FormatToken *End = Tok.MatchingParen;
   // Maintains a stack level corresponding to the current End token.
   int MatchingStackIndex = Stack.size() - 1;
   // Traverses the stack downwards, looking for the level to which LBrace
   // corresponds. Returns either a pointer to the matching level or nullptr if
   // LParen is not found in the initial portion of the stack up to
   // MatchingStackIndex.
-  auto FindParenState = [&](const FormatToken *LBrace) -> const ParenState * {
+  auto FindParenState = [&](FormatToken const *LBrace) -> ParenState const * {
     while (MatchingStackIndex >= 0 && Stack[MatchingStackIndex].Tok != LBrace)
       --MatchingStackIndex;
     return MatchingStackIndex >= 0 ? &Stack[MatchingStackIndex] : nullptr;
   };
   for (; End->Next; End = End->Next) {
     if (End->Next->CanBreakBefore)
       break;
     if (!End->Next->closesScope())
       continue;
     if (End->Next->MatchingParen &&
         End->Next->MatchingParen->isOneOf(
             tok::l_brace, TT_ArrayInitializerLSquare, tok::less)) {
-      const ParenState *State = FindParenState(End->Next->MatchingParen);
+      ParenState const *State = FindParenState(End->Next->MatchingParen);
       if (State && State->BreakBeforeClosingBrace)
         break;
     }
   }
   return End->TotalLength - Tok.TotalLength + 1;
 }
 
-static unsigned getLengthToNextOperator(const FormatToken &Tok) {
+static unsigned getLengthToNextOperator(FormatToken const &Tok) {
   if (!Tok.NextOperator)
     return 0;
   return Tok.NextOperator->TotalLength - Tok.TotalLength;
 }
 
 // Returns \c true if \c Tok is the "." or "->" of a call and starts the next
 // segment of a builder type call.
-static bool startsSegmentOfBuilderTypeCall(const FormatToken &Tok) {
+static bool startsSegmentOfBuilderTypeCall(FormatToken const &Tok) {
   return Tok.isMemberAccess() && Tok.Previous && Tok.Previous->closesScope();
 }
 
 // Returns \c true if \c Current starts a new parameter.
-static bool startsNextParameter(const FormatToken &Current,
-                                const FormatStyle &Style) {
-  const FormatToken &Previous = *Current.Previous;
+static bool startsNextParameter(FormatToken const &Current,
+                                FormatStyle const &Style) {
+  FormatToken const &Previous = *Current.Previous;
   if (Current.is(TT_CtorInitializerComma) &&
       Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeComma)
     return true;
   if (Style.Language == FormatStyle::LK_Proto && Current.is(TT_SelectorName))
     return true;
   return Previous.is(tok::comma) && !Current.isTrailingComment() &&
          ((Previous.isNot(TT_CtorInitializerComma) ||
            Style.BreakConstructorInitializers !=
                FormatStyle::BCIS_BeforeComma) &&
           (Previous.isNot(TT_InheritanceComma) ||
            Style.BreakInheritanceList != FormatStyle::BILS_BeforeComma));
 }
 
-static bool opensProtoMessageField(const FormatToken &LessTok,
-                                   const FormatStyle &Style) {
+static bool opensProtoMessageField(FormatToken const &LessTok,
+                                   FormatStyle const &Style) {
   if (LessTok.isNot(tok::less))
     return false;
   return Style.Language == FormatStyle::LK_TextProto ||
          (Style.Language == FormatStyle::LK_Proto &&
           (LessTok.NestingLevel > 0 ||
            (LessTok.Previous && LessTok.Previous->is(tok::equal))));
 }
 
static llvm::Optional<StringRef> getRawStringDelimiter(StringRef TokenText) {
   if (!TokenText.substr(RParenPos + 1).startswith(Delimiter))
     return None;
   return Delimiter;
 }
 
 // Returns the canonical delimiter for \p Language, or the empty string if no
 // canonical delimiter is specified.
 static StringRef
-getCanonicalRawStringDelimiter(const FormatStyle &Style,
+getCanonicalRawStringDelimiter(FormatStyle const &Style,
                                FormatStyle::LanguageKind Language) {
-  for (const auto &Format : Style.RawStringFormats) {
+  for (auto const &Format : Style.RawStringFormats) {
     if (Format.Language == Language)
       return StringRef(Format.CanonicalDelimiter);
   }
   return "";
 }
 
 RawStringFormatStyleManager::RawStringFormatStyleManager(
-    const FormatStyle &CodeStyle) {
-  for (const auto &RawStringFormat : CodeStyle.RawStringFormats) {
+    FormatStyle const &CodeStyle) {
+  for (auto const &RawStringFormat : CodeStyle.RawStringFormats) {
     llvm::Optional<FormatStyle> LanguageStyle =
         CodeStyle.GetLanguageStyle(RawStringFormat.Language);
     if (!LanguageStyle) {
       FormatStyle PredefinedStyle;
       if (!getPredefinedStyle(RawStringFormat.BasedOnStyle,
                               RawStringFormat.Language, &PredefinedStyle)) {
         PredefinedStyle = getLLVMStyle();
         PredefinedStyle.Language = RawStringFormat.Language;

 RawStringFormatStyleManager::getEnclosingFunctionStyle(
     StringRef EnclosingFunction) const {
   auto It = EnclosingFunctionStyle.find(EnclosingFunction);
   if (It == EnclosingFunctionStyle.end())
     return None;
   return It->second;
 }
 
-ContinuationIndenter::ContinuationIndenter(const FormatStyle &Style,
-                                           const AdditionalKeywords &Keywords,
-                                           const SourceManager &SourceMgr,
+ContinuationIndenter::ContinuationIndenter(FormatStyle const &Style,
+                                           AdditionalKeywords const &Keywords,
+                                           SourceManager const &SourceMgr,
                                            WhitespaceManager &Whitespaces,
                                            encoding::Encoding Encoding,
                                            bool BinPackInconclusiveFunctions)
     : Style(Style), Keywords(Keywords), SourceMgr(SourceMgr),
       Whitespaces(Whitespaces), Encoding(Encoding),
       BinPackInconclusiveFunctions(BinPackInconclusiveFunctions),
       CommentPragmasRegex(Style.CommentPragmas), RawStringFormats(Style) {}
 
 LineState ContinuationIndenter::getInitialState(unsigned FirstIndent,
                                                 unsigned FirstStartColumn,
-                                                const AnnotatedLine *Line,
+                                                AnnotatedLine const *Line,
                                                 bool DryRun) {
   LineState State;
   State.FirstIndent = FirstIndent;
   if (FirstStartColumn && Line->First->NewlinesBefore == 0)
     State.Column = FirstStartColumn;
   else
     State.Column = FirstIndent;
   // With preprocessor directive indentation, the line starts on column 0
if (Style.Language == FormatStyle::LK_TextProto) {
     State.Stack.back().AlignColons = false;
   }
 
   // The first token has already been indented and thus consumed.
   moveStateToNextToken(State, DryRun, /*Newline=*/false);
   return State;
 }
 
-bool ContinuationIndenter::canBreak(const LineState &State) {
-  const FormatToken &Current = *State.NextToken;
-  const FormatToken &Previous = *Current.Previous;
+bool ContinuationIndenter::canBreak(LineState const &State) {
+  FormatToken const &Current = *State.NextToken;
+  FormatToken const &Previous = *Current.Previous;
   assert(&Previous == Current.Previous);
   if (!Current.CanBreakBefore && !(State.Stack.back().BreakBeforeClosingBrace &&
                                    Current.closesBlockOrBlockTypeList(Style)))
     return false;
   // The opening "{" of a braced list has to be on the same line as the first
   // element if it is nested in another braced init list or function call.
   if (!Current.MustBreakBefore && Previous.is(tok::l_brace) &&
       Previous.isNot(TT_DictLiteral) && Previous.is(BK_BracedInit) &&
if (!Current.isOneOf(TT_BinaryOperator, tok::comma) &&
     return false;
 
   if (Previous.is(tok::l_square) && Previous.is(TT_ObjCMethodExpr))
     return false;
 
   return !State.Stack.back().NoLineBreak;
 }
 
-bool ContinuationIndenter::mustBreak(const LineState &State) {
-  const FormatToken &Current = *State.NextToken;
-  const FormatToken &Previous = *Current.Previous;
+bool ContinuationIndenter::mustBreak(LineState const &State) {
+  FormatToken const &Current = *State.NextToken;
+  FormatToken const &Previous = *Current.Previous;
   if (Style.BraceWrapping.BeforeLambdaBody && Current.CanBreakBefore &&
       Current.is(TT_LambdaLBrace) && Previous.isNot(TT_LineComment)) {
     auto LambdaBodyLength = getLengthToMatchingParen(Current, State.Stack);
     return (LambdaBodyLength > getColumnLimit(State));
   }
   if (Current.MustBreakBefore || Current.is(TT_InlineASMColon))
     return true;
   if (State.Stack.back().BreakBeforeClosingBrace &&
if (((Previous.is(TT_DictLiteral) && Previous.is(tok::l_brace)) ||
        (Previous.is(TT_ArrayInitializerLSquare) &&
         Previous.ParameterCount > 1) ||
        opensProtoMessageField(Previous, Style)) &&
       Style.ColumnLimit > 0 &&
       getLengthToMatchingParen(Previous, State.Stack) + State.Column - 1 >
           getColumnLimit(State))
     return true;
 
-  const FormatToken &BreakConstructorInitializersToken =
+  FormatToken const &BreakConstructorInitializersToken =
       Style.BreakConstructorInitializers == FormatStyle::BCIS_AfterColon
           ? Previous
           : Current;
   if (BreakConstructorInitializersToken.is(TT_CtorInitializerColon) &&
       (State.Column + State.Line->Last->TotalLength - Previous.TotalLength >
            getColumnLimit(State) ||
        State.Stack.back().BreakBeforeParameter) &&
       (Style.AllowShortFunctionsOnASingleLine != FormatStyle::SFS_All ||
if (State.NoContinuation)
     return true;
 
   return false;
 }
 
 unsigned ContinuationIndenter::addTokenToState(LineState &State, bool Newline,
                                                bool DryRun,
                                                unsigned ExtraSpaces) {
-  const FormatToken &Current = *State.NextToken;
+  FormatToken const &Current = *State.NextToken;
 
   assert(!State.Stack.empty());
   State.NoContinuation = false;
 
   if ((Current.is(TT_ImplicitStringLiteral) &&
        (Current.Previous->Tok.getIdentifierInfo() == nullptr ||
         Current.Previous->Tok.getIdentifierInfo()->getPPKeywordID() ==
             tok::pp_not_keyword))) {
else
     addTokenOnCurrentLine(State, DryRun, ExtraSpaces);
 
   return moveStateToNextToken(State, DryRun, Newline) + Penalty;
 }
 
 void ContinuationIndenter::addTokenOnCurrentLine(LineState &State, bool DryRun,
                                                  unsigned ExtraSpaces) {
   FormatToken &Current = *State.NextToken;
-  const FormatToken &Previous = *State.NextToken->Previous;
+  FormatToken const &Previous = *State.NextToken->Previous;
   if (Current.is(tok::equal) &&
       (State.Line->First->is(tok::kw_for) || Current.NestingLevel == 0) &&
       State.Stack.back().VariablePos == 0) {
     State.Stack.back().VariablePos = State.Column;
     // Move over * and & if they are bound to the variable name.
-    const FormatToken *Tok = &Previous;
+    FormatToken const *Tok = &Previous;
     while (Tok && State.Stack.back().VariablePos >= Tok->ColumnWidth) {
       State.Stack.back().VariablePos -= Tok->ColumnWidth;
       if (Tok->SpacesRequiredBefore != 0)
         break;
       Tok = Tok->Previous;
     }
     if (Previous.PartOfMultiVariableDeclStmt)
       State.Stack.back().LastSpace = State.Stack.back().VariablePos;
if (Current.isMemberAccess() && Previous.is(tok::r_paren) &&
     // We don't want to do this for short parameters as they can just be
     // indexes.
     State.Stack.back().NoLineBreak = true;
 
   // Don't allow the RHS of an operator to be split over multiple lines unless
   // there is a line-break right after the operator.
   // Exclude relational operators, as there, it is always more desirable to
   // have the LHS 'left' of the RHS.
-  const FormatToken *P = Current.getPreviousNonComment();
+  FormatToken const *P = Current.getPreviousNonComment();
   if (!Current.is(tok::comment) && P &&
       (P->isOneOf(TT_BinaryOperator, tok::comma) ||
        (P->is(TT_ConditionalExpr) && P->is(tok::colon))) &&
       !P->isOneOf(TT_OverloadedOperator, TT_CtorInitializerComma) &&
       P->getPrecedence() != prec::Assignment &&
       P->getPrecedence() != prec::Relational &&
       P->getPrecedence() != prec::Spaceship) {
     bool BreakBeforeOperator =
void ContinuationIndenter::addTokenOnCurrentLine(LineState &State, bool DryRun,
   } else if (Previous.opensScope()) {
     // If a function has a trailing call, indent all parameters from the
     // opening parenthesis. This avoids confusing indents like:
     //   OuterFunction(InnerFunctionCall( // break
     //       ParameterToInnerFunction))   // break
     //       .SecondInnerFunctionCall();
     bool HasTrailingCall = false;
     if (Previous.MatchingParen) {
-      const FormatToken *Next = Previous.MatchingParen->getNextNonComment();
+      FormatToken const *Next = Previous.MatchingParen->getNextNonComment();
       HasTrailingCall = Next && Next->isMemberAccess();
     }
     if (HasTrailingCall && State.Stack.size() > 1 &&
         State.Stack[State.Stack.size() - 2].CallContinuation == 0)
       State.Stack.back().LastSpace = State.Column;
   }
 }
 
 unsigned ContinuationIndenter::addTokenOnNewLine(LineState &State,
                                                  bool DryRun) {
   FormatToken &Current = *State.NextToken;
-  const FormatToken &Previous = *State.NextToken->Previous;
+  FormatToken const &Previous = *State.NextToken->Previous;
 
   // Extra penalty that needs to be added because of the way certain line
   // breaks are chosen.
   unsigned Penalty = 0;
 
-  const FormatToken *PreviousNonComment = Current.getPreviousNonComment();
-  const FormatToken *NextNonComment = Previous.getNextNonComment();
+  FormatToken const *PreviousNonComment = Current.getPreviousNonComment();
+  FormatToken const *NextNonComment = Previous.getNextNonComment();
   if (!NextNonComment)
     NextNonComment = &Current;
   // The first line break on any NestingLevel causes an extra penalty in order
   // prefer similar line breaks.
   if (!State.Stack.back().ContainsLineBreak)
     Penalty += 15;
   State.Stack.back().ContainsLineBreak = true;
 
if (State.Stack.back().AvoidBinPacking) {
     if (PreviousIsBreakingCtorInitializerColon &&
         Style.AllowAllConstructorInitializersOnNextLine)
       State.Stack.back().BreakBeforeParameter = false;
   }
 
   return Penalty;
 }
 
-unsigned ContinuationIndenter::getNewLineColumn(const LineState &State) {
+unsigned ContinuationIndenter::getNewLineColumn(LineState const &State) {
   if (!State.NextToken || !State.NextToken->Previous)
     return 0;
 
   FormatToken &Current = *State.NextToken;
 
   if (State.Stack.back().IsCSharpGenericTypeConstraint &&
       Current.isNot(TT_CSharpGenericTypeConstraint))
     return State.Stack.back().ColonPos + 2;
 
-  const FormatToken &Previous = *Current.Previous;
+  FormatToken const &Previous = *Current.Previous;
   // If we are continuing an expression, we want to use the continuation indent.
   unsigned ContinuationIndent =
       std::max(State.Stack.back().LastSpace, State.Stack.back().Indent) +
       Style.ContinuationIndentWidth;
-  const FormatToken *PreviousNonComment = Current.getPreviousNonComment();
-  const FormatToken *NextNonComment = Previous.getNextNonComment();
+  FormatToken const *PreviousNonComment = Current.getPreviousNonComment();
+  FormatToken const *NextNonComment = Previous.getNextNonComment();
   if (!NextNonComment)
     NextNonComment = &Current;
 
   // Java specific bits.
   if (Style.Language == FormatStyle::LK_Java &&
       Current.isOneOf(Keywords.kw_implements, Keywords.kw_extends))
     return std::max(State.Stack.back().LastSpace,
                     State.Stack.back().Indent + Style.ContinuationIndentWidth);
unsigned ContinuationIndenter::getNewLineColumn(LineState const &State) {
   if (State.Stack.back().Indent == State.FirstIndent && PreviousNonComment &&
       !PreviousNonComment->isOneOf(tok::r_brace, TT_CtorInitializerComma))
     // Ensure that we fall back to the continuation indent width instead of
     // just flushing continuations left.
     return State.Stack.back().Indent + Style.ContinuationIndentWidth;
   return State.Stack.back().Indent;
 }
 
-static bool hasNestedBlockInlined(const FormatToken *Previous,
-                                  const FormatToken &Current,
-                                  const FormatStyle &Style) {
+static bool hasNestedBlockInlined(FormatToken const *Previous,
+                                  FormatToken const &Current,
+                                  FormatStyle const &Style) {
   if (Previous->isNot(tok::l_paren))
     return true;
   if (Previous->ParameterCount > 1)
     return true;
 
   // Also a nested block if contains a lambda inside function with 1 parameter
   return (Style.BraceWrapping.BeforeLambdaBody && Current.is(TT_LambdaLSquare));
 }
 
 unsigned ContinuationIndenter::moveStateToNextToken(LineState &State,
                                                     bool DryRun, bool Newline) {
   assert(State.Stack.size());
-  const FormatToken &Current = *State.NextToken;
+  FormatToken const &Current = *State.NextToken;
 
   if (Current.is(TT_CSharpGenericTypeConstraint))
     State.Stack.back().IsCSharpGenericTypeConstraint = true;
   if (Current.isOneOf(tok::comma, TT_BinaryOperator))
     State.Stack.back().NoLineBreakInOperand = false;
   if (Current.isOneOf(TT_InheritanceColon, TT_CSharpGenericTypeConstraintColon))
     State.Stack.back().AvoidBinPacking = true;
   if (Current.is(tok::lessless) && Current.isNot(TT_OverloadedOperator)) {
unsigned ContinuationIndenter::moveStateToNextToken(LineState &State,
   if (Current.is(TT_ConditionalExpr) && Current.is(tok::question) &&
       ((Current.MustBreakBefore) ||
        (Current.getNextNonComment() &&
         Current.getNextNonComment()->MustBreakBefore)))
     State.Stack.back().IsWrappedConditional = true;
   if (Style.BreakBeforeTernaryOperators && Current.is(tok::question))
     State.Stack.back().QuestionColumn = State.Column;
   if (!Style.BreakBeforeTernaryOperators && Current.isNot(tok::colon)) {
-    const FormatToken *Previous = Current.Previous;
+    FormatToken const *Previous = Current.Previous;
     while (Previous && Previous->isTrailingComment())
       Previous = Previous->Previous;
     if (Previous && Previous->is(tok::question))
       State.Stack.back().QuestionColumn = State.Column;
   }
   if (!Current.opensScope() && !Current.closesScope() &&
       !Current.is(TT_PointerOrReference))
     State.LowestLevelOnLine =
State.Stack.back().Indent =
         State.FirstIndent + Style.ConstructorInitializerIndentWidth;
   if (Current.isOneOf(TT_BinaryOperator, TT_ConditionalExpr) && Newline)
     State.Stack.back().NestedBlockIndent =
         State.Column + Current.ColumnWidth + 1;
   if (Current.isOneOf(TT_LambdaLSquare, TT_LambdaArrow))
     State.Stack.back().LastSpace = State.Column;
 
   // Insert scopes created by fake parenthesis.
-  const FormatToken *Previous = Current.getPreviousNonComment();
+  FormatToken const *Previous = Current.getPreviousNonComment();
 
   // Add special behavior to support a format commonly used for JavaScript
   // closures:
   //   SomeFunction(function() {
   //     foo();
   //     bar();
   //   }, a, b, c);
   if (Current.isNot(tok::comment) && Previous &&
unsigned ContinuationIndenter::moveStateToNextToken(LineState &State,
   if (Previous && Previous->Role)
     Penalty += Previous->Role->formatAfterToken(State, this, DryRun);
 
   return Penalty;
 }
 
 void ContinuationIndenter::moveStatePastFakeLParens(LineState &State,
                                                     bool Newline) {
-  const FormatToken &Current = *State.NextToken;
-  const FormatToken *Previous = Current.getPreviousNonComment();
+  FormatToken const &Current = *State.NextToken;
+  FormatToken const *Previous = Current.getPreviousNonComment();
 
   // Don't add extra indentation for the first fake parenthesis after
   // 'return', assignments or opening <({[. The indentation for these cases
   // is special cased.
   bool SkipFirstExtraIndent =
       (Previous && (Previous->opensScope() ||
                     Previous->isOneOf(tok::semi, tok::kw_return) ||
                     (Previous->getPrecedence() == prec::Assignment &&
for (unsigned i = 0, e = State.NextToken->FakeRParens; i != e; ++i) {
     }
     State.Stack.pop_back();
     State.Stack.back().VariablePos = VariablePos;
   }
 }
 
 void ContinuationIndenter::moveStatePastScopeOpener(LineState &State,
                                                     bool Newline) {
-  const FormatToken &Current = *State.NextToken;
+  FormatToken const &Current = *State.NextToken;
   if (!Current.opensScope())
     return;
 
   // Don't allow '<' or '(' in C# generic type constraints to start new scopes.
   if (Current.isOneOf(tok::less, tok::l_paren) &&
       State.Stack.back().IsCSharpGenericTypeConstraint)
     return;
 
void ContinuationIndenter::moveStatePastScopeOpener(LineState &State,
   if (Current.isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) ||
       opensProtoMessageField(Current, Style)) {
     if (Current.opensBlockOrBlockTypeList(Style)) {
       NewIndent = Style.IndentWidth +
                   std::min(State.Column, State.Stack.back().NestedBlockIndent);
     } else {
       NewIndent = State.Stack.back().LastSpace + Style.ContinuationIndentWidth;
     }
-    const FormatToken *NextNoComment = Current.getNextNonComment();
+    FormatToken const *NextNoComment = Current.getNextNonComment();
     bool EndsInComma = Current.MatchingParen &&
                        Current.MatchingParen->Previous &&
                        Current.MatchingParen->Previous->is(tok::comma);
     AvoidBinPacking = EndsInComma || Current.is(TT_DictLiteral) ||
                       Style.Language == FormatStyle::LK_Proto ||
                       Style.Language == FormatStyle::LK_TextProto ||
                       !Style.BinPackArguments ||
                       (NextNoComment &&
if (Current.is(TT_ObjCMethodExpr) && Current.MatchingParen &&
         // If this '[' opens an ObjC call, determine whether all parameters fit
         // into one line and put one per line if they don't.
         if (getLengthToMatchingParen(Current, State.Stack) + State.Column >
             getColumnLimit(State))
           BreakBeforeParameter = true;
       } else {
         // For ColumnLimit = 0, we have to figure out whether there is or has to
         // be a line break within this call.
-        for (const FormatToken *Tok = &Current;
+        for (FormatToken const *Tok = &Current;
              Tok && Tok != Current.MatchingParen; Tok = Tok->Next) {
           if (Tok->MustBreakBefore ||
               (Tok->CanBreakBefore && Tok->NewlinesBefore > 0)) {
             BreakBeforeParameter = true;
             break;
           }
         }
       }
void ContinuationIndenter::moveStatePastScopeOpener(LineState &State,
   }
 
   State.Stack.back().IsInsideObjCArrayLiteral =
       Current.is(TT_ArrayInitializerLSquare) && Current.Previous &&
       Current.Previous->is(tok::at);
 }
 
 void ContinuationIndenter::moveStatePastScopeCloser(LineState &State) {
-  const FormatToken &Current = *State.NextToken;
+  FormatToken const &Current = *State.NextToken;
   if (!Current.closesScope())
     return;
 
   // If we encounter a closing ), ], } or >, we can remove a level from our
   // stacks.
   if (State.Stack.size() > 1 &&
       (Current.isOneOf(tok::r_paren, tok::r_square, TT_TemplateString) ||
        (Current.is(tok::r_brace) && State.NextToken != State.Line->First) ||
        State.NextToken->is(TT_TemplateCloser) ||
        (Current.is(tok::greater) && Current.is(TT_DictLiteral))))
     State.Stack.pop_back();
 
   // Reevaluate whether ObjC message arguments fit into one line.
   // If a receiver spans multiple lines, e.g.:
   //   [[object block:^{
   //     return 42;
   //   }] a:42 b:42];
   // BreakBeforeParameter is calculated based on an incorrect assumption
   // (it is checked whether the whole expression fits into one line without
   // considering a line break inside a message receiver).
   // We check whether arguements fit after receiver scope closer (into the same
   // line).
   if (State.Stack.back().BreakBeforeParameter && Current.MatchingParen &&
       Current.MatchingParen->Previous) {
-    const FormatToken &CurrentScopeOpener = *Current.MatchingParen->Previous;
+    FormatToken const &CurrentScopeOpener = *Current.MatchingParen->Previous;
     if (CurrentScopeOpener.is(TT_ObjCMethodExpr) &&
         CurrentScopeOpener.MatchingParen) {
       int NecessarySpaceInLine =
           getLengthToMatchingParen(CurrentScopeOpener, State.Stack) +
           CurrentScopeOpener.TotalLength - Current.TotalLength - 1;
       if (State.Column + Current.ColumnWidth + NecessarySpaceInLine <=
           Style.ColumnLimit)
         State.Stack.back().BreakBeforeParameter = false;
     }
   }
 
   if (Current.is(tok::r_square)) {
     // If this ends the array subscript expr, reset the corresponding value.
-    const FormatToken *NextNonComment = Current.getNextNonComment();
+    FormatToken const *NextNonComment = Current.getNextNonComment();
     if (NextNonComment && NextNonComment->isNot(tok::l_square))
       State.Stack.back().StartOfArraySubscripts = 0;
   }
 }
 
 void ContinuationIndenter::moveStateToNewBlock(LineState &State) {
   unsigned NestedBlockIndent = State.Stack.back().NestedBlockIndent;
   // ObjC block sometimes follow special indentation rules.
return StartColumn +
            encoding::columnWidthWithTabs(Text, StartColumn, TabWidth, Encoding);
   } else {
     return encoding::columnWidthWithTabs(Text.substr(LastNewlinePos),
                                          /*StartColumn=*/0, TabWidth, Encoding);
   }
 }
 
 unsigned ContinuationIndenter::reformatRawStringLiteral(
-    const FormatToken &Current, LineState &State,
-    const FormatStyle &RawStringStyle, bool DryRun, bool Newline) {
+    FormatToken const &Current, LineState &State,
+    FormatStyle const &RawStringStyle, bool DryRun, bool Newline) {
   unsigned StartColumn = State.Column - Current.ColumnWidth;
   StringRef OldDelimiter = *getRawStringDelimiter(Current.TokenText);
   StringRef NewDelimiter =
       getCanonicalRawStringDelimiter(Style, RawStringStyle.Language);
   if (NewDelimiter.empty())
     NewDelimiter = OldDelimiter;
   // The text of a raw string is between the leading 'R"delimiter(' and the
   // trailing 'delimiter)"'.
if (NewDelimiter != OldDelimiter) {
       if (SuffixErr) {
         llvm::errs()
             << "Failed to update the suffix delimiter of a raw string: "
             << llvm::toString(std::move(SuffixErr)) << "\n";
       }
     }
     SourceLocation OriginLoc =
         Current.Tok.getLocation().getLocWithOffset(OldPrefixSize);
-    for (const tooling::Replacement &Fix : Fixes.first) {
+    for (tooling::Replacement const &Fix : Fixes.first) {
       auto Err = Whitespaces.addReplacement(tooling::Replacement(
           SourceMgr, OriginLoc.getLocWithOffset(Fix.getOffset()),
           Fix.getLength(), Fix.getReplacementText()));
       if (Err) {
         llvm::errs() << "Failed to reformat raw string: "
                      << llvm::toString(std::move(Err)) << "\n";
       }
     }
unsigned ContinuationIndenter::reformatRawStringLiteral(
   if (IsMultiline) {
     // Break before further function parameters on all levels.
     for (unsigned i = 0, e = State.Stack.size(); i != e; ++i)
       State.Stack[i].BreakBeforeParameter = true;
   }
   return Fixes.second + PrefixExcessCharacters * Style.PenaltyExcessCharacter;
 }
 
-unsigned ContinuationIndenter::addMultilineToken(const FormatToken &Current,
+unsigned ContinuationIndenter::addMultilineToken(FormatToken const &Current,
                                                  LineState &State) {
   // Break before further function parameters on all levels.
   for (unsigned i = 0, e = State.Stack.size(); i != e; ++i)
     State.Stack[i].BreakBeforeParameter = true;
 
   unsigned ColumnsUsed = State.Column;
   // We can only affect layout of the first and the last line, so the penalty
   // for all other lines is constant, and we ignore it.
   State.Column = Current.LastLineColumnWidth;
 
   if (ColumnsUsed > getColumnLimit(State))
     return Style.PenaltyExcessCharacter * (ColumnsUsed - getColumnLimit(State));
   return 0;
 }
 
-unsigned ContinuationIndenter::handleEndOfLine(const FormatToken &Current,
+unsigned ContinuationIndenter::handleEndOfLine(FormatToken const &Current,
                                                LineState &State, bool DryRun,
                                                bool AllowBreak, bool Newline) {
   unsigned Penalty = 0;
   // Compute the raw string style to use in case this is a raw string literal
   // that can be reformatted.
   auto RawStringStyle = getRawStringStyle(Current, State);
   if (RawStringStyle && !Current.Finalized) {
     Penalty = reformatRawStringLiteral(Current, State, *RawStringStyle, DryRun,
if (State.Column > getColumnLimit(State)) {
     unsigned ExcessCharacters = State.Column - getColumnLimit(State);
     Penalty += Style.PenaltyExcessCharacter * ExcessCharacters;
   }
   return Penalty;
 }
 
 // Returns the enclosing function name of a token, or the empty string if not
 // found.
-static StringRef getEnclosingFunctionName(const FormatToken &Current) {
+static StringRef getEnclosingFunctionName(FormatToken const &Current) {
   // Look for: 'function(' or 'function<templates>(' before Current.
   auto Tok = Current.getPreviousNonComment();
   if (!Tok || !Tok->is(tok::l_paren))
     return "";
   Tok = Tok->getPreviousNonComment();
   if (!Tok)
     return "";
   if (Tok->is(TT_TemplateCloser)) {
     Tok = Tok->MatchingParen;
     if (Tok)
       Tok = Tok->getPreviousNonComment();
   }
   if (!Tok || !Tok->is(tok::identifier))
     return "";
   return Tok->TokenText;
 }
 
 llvm::Optional<FormatStyle>
-ContinuationIndenter::getRawStringStyle(const FormatToken &Current,
-                                        const LineState &State) {
+ContinuationIndenter::getRawStringStyle(FormatToken const &Current,
+                                        LineState const &State) {
   if (!Current.isStringLiteral())
     return None;
   auto Delimiter = getRawStringDelimiter(Current.TokenText);
   if (!Delimiter)
     return None;
   auto RawStringStyle = RawStringFormats.getDelimiterStyle(*Delimiter);
   if (!RawStringStyle && Delimiter->empty())
     RawStringStyle = RawStringFormats.getEnclosingFunctionStyle(
         getEnclosingFunctionName(Current));
   if (!RawStringStyle)
     return None;
   RawStringStyle->ColumnLimit = getColumnLimit(State);
   return RawStringStyle;
 }
 
 std::unique_ptr<BreakableToken>
-ContinuationIndenter::createBreakableToken(const FormatToken &Current,
+ContinuationIndenter::createBreakableToken(FormatToken const &Current,
                                            LineState &State, bool AllowBreak) {
   unsigned StartColumn = State.Column - Current.ColumnWidth;
   if (Current.isStringLiteral()) {
     // FIXME: String literal breaking is currently disabled for C#, Java, Json
     // and JavaScript, as it requires strings to be merged using "+" which we
     // don't support.
     if (Style.Language == FormatStyle::LK_Java ||
         Style.Language == FormatStyle::LK_JavaScript || Style.isCSharp() ||
if (!Style.ReflowComments ||
       return nullptr;
     return std::make_unique<BreakableLineCommentSection>(
         Current, StartColumn, /*InPPDirective=*/false, Encoding, Style);
   }
   return nullptr;
 }
 
 std::pair<unsigned, bool>
-ContinuationIndenter::breakProtrudingToken(const FormatToken &Current,
+ContinuationIndenter::breakProtrudingToken(FormatToken const &Current,
                                            LineState &State, bool AllowBreak,
                                            bool DryRun, bool Strict) {
   std::unique_ptr<const BreakableToken> Token =
       createBreakableToken(Current, State, AllowBreak);
   if (!Token)
     return {0, false};
   assert(Token->getLineCount() > 0);
   unsigned ColumnLimit = getColumnLimit(State);
if (BreakInserted) {
     State.Stack.back().LastSpace = StartColumn;
   }
 
   Token->updateNextToken(State);
 
   return {Penalty, Exceeded};
 }
 
-unsigned ContinuationIndenter::getColumnLimit(const LineState &State) const {
+unsigned ContinuationIndenter::getColumnLimit(LineState const &State) const {
   // In preprocessor directives reserve two chars for trailing " \"
   return Style.ColumnLimit - (State.Line->InPPDirective ? 2 : 0);
 }
 
-bool ContinuationIndenter::nextIsMultilineString(const LineState &State) {
-  const FormatToken &Current = *State.NextToken;
+bool ContinuationIndenter::nextIsMultilineString(LineState const &State) {
+  FormatToken const &Current = *State.NextToken;
   if (!Current.isStringLiteral() || Current.is(TT_ImplicitStringLiteral))
     return false;
   // We never consider raw string literals "multiline" for the purpose of
   // AlwaysBreakBeforeMultilineStrings implementation as they are special-cased
   // (see TokenAnnotator::mustBreakBefore().
   if (Current.TokenText.startswith("R\""))
     return false;
   if (Current.IsMultiline)

clang/lib/Format/Encoding.h

 enum Encoding {
   Encoding_UTF8,
   Encoding_Unknown // We treat all other encodings as 8-bit encodings.
 };
 
 /// Detects encoding of the Text. If the Text can be decoded using UTF-8,
 /// it is considered UTF8, otherwise we treat it as some 8-bit encoding.
 inline Encoding detectEncoding(StringRef Text) {
-  const llvm::UTF8 *Ptr = reinterpret_cast<const llvm::UTF8 *>(Text.begin());
-  const llvm::UTF8 *BufEnd = reinterpret_cast<const llvm::UTF8 *>(Text.end());
+  llvm::UTF8 const *Ptr = reinterpret_cast<llvm::UTF8 const *>(Text.begin());
+  llvm::UTF8 const *BufEnd = reinterpret_cast<llvm::UTF8 const *>(Text.end());
   if (llvm::isLegalUTF8String(&Ptr, BufEnd))
     return Encoding_UTF8;
   return Encoding_Unknown;
 }
 
 /// Returns the number of columns required to display the \p Text on a
 /// generic Unicode-capable terminal. Text is assumed to use the specified
 /// \p Encoding.

clang/lib/Format/Format.cpp

 /// split into separate files as we go.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "clang/Format/Format.h"
 #include "AffectedRangeManager.h"
 #include "BreakableToken.h"
 #include "ContinuationIndenter.h"
+#include "EastWestConstFixer.h"
 #include "FormatInternal.h"
 #include "FormatTokenLexer.h"
 #include "NamespaceEndCommentsFixer.h"
 #include "SortJavaScriptImports.h"
 #include "TokenAnalyzer.h"
 #include "TokenAnnotator.h"
 #include "UnwrappedLineFormatter.h"
 #include "UnwrappedLineParser.h"
static void enumeration(IO &IO, FormatStyle::ShortBlockStyle &Value) {
     IO.enumCase(Value, "Never", FormatStyle::SBS_Never);
     IO.enumCase(Value, "false", FormatStyle::SBS_Never);
     IO.enumCase(Value, "Always", FormatStyle::SBS_Always);
     IO.enumCase(Value, "true", FormatStyle::SBS_Always);
     IO.enumCase(Value, "Empty", FormatStyle::SBS_Empty);
   }
 };
 
+template <> struct ScalarEnumerationTraits<FormatStyle::ConstPlacementStyle> {
+  static void enumeration(IO &IO, FormatStyle::ConstPlacementStyle &Value) {
+    IO.enumCase(Value, "Leave", FormatStyle::CS_Leave);
+    IO.enumCase(Value, "West", FormatStyle::CS_West);
+    IO.enumCase(Value, "East", FormatStyle::CS_East);
+
+    IO.enumCase(Value, "Left", FormatStyle::CS_West);
+    IO.enumCase(Value, "Right", FormatStyle::CS_East);
+  }
+};
+
 template <> struct ScalarEnumerationTraits<FormatStyle::ShortFunctionStyle> {
   static void enumeration(IO &IO, FormatStyle::ShortFunctionStyle &Value) {
     IO.enumCase(Value, "None", FormatStyle::SFS_None);
     IO.enumCase(Value, "false", FormatStyle::SFS_None);
     IO.enumCase(Value, "All", FormatStyle::SFS_All);
     IO.enumCase(Value, "true", FormatStyle::SFS_All);
     IO.enumCase(Value, "Inline", FormatStyle::SFS_Inline);
     IO.enumCase(Value, "InlineOnly", FormatStyle::SFS_InlineOnly);
if (BreakConstructorInitializersBeforeComma &&
         Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeColon)
       Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
 
     IO.mapOptional("BreakAfterJavaFieldAnnotations",
                    Style.BreakAfterJavaFieldAnnotations);
     IO.mapOptional("BreakStringLiterals", Style.BreakStringLiterals);
     IO.mapOptional("ColumnLimit", Style.ColumnLimit);
     IO.mapOptional("CommentPragmas", Style.CommentPragmas);
+    IO.mapOptional("ConstPlacement", Style.ConstPlacement);
     IO.mapOptional("CompactNamespaces", Style.CompactNamespaces);
     IO.mapOptional("ConstructorInitializerAllOnOneLineOrOnePerLine",
                    Style.ConstructorInitializerAllOnOneLineOrOnePerLine);
     IO.mapOptional("ConstructorInitializerIndentWidth",
                    Style.ConstructorInitializerIndentWidth);
     IO.mapOptional("ContinuationIndentWidth", Style.ContinuationIndentWidth);
     IO.mapOptional("Cpp11BracedListStyle", Style.Cpp11BracedListStyle);
     IO.mapOptional("DeriveLineEnding", Style.DeriveLineEnding);
template <> struct DocumentListTraits<std::vector<FormatStyle>> {
   static FormatStyle &element(IO &IO, std::vector<FormatStyle> &Seq,
                               size_t Index) {
     if (Index >= Seq.size()) {
       assert(Index == Seq.size());
       FormatStyle Template;
       if (!Seq.empty() && Seq[0].Language == FormatStyle::LK_None) {
         Template = Seq[0];
       } else {
-        Template = *((const FormatStyle *)IO.getContext());
+        Template = *((FormatStyle const *)IO.getContext());
         Template.Language = FormatStyle::LK_None;
       }
       Seq.resize(Index + 1, Template);
     }
     return Seq[Index];
   }
 };
 } // namespace yaml
 } // namespace llvm
 
 namespace clang {
 namespace format {
 
-const std::error_category &getParseCategory() {
+std::error_category const &getParseCategory() {
   static const ParseErrorCategory C{};
   return C;
 }
 std::error_code make_error_code(ParseError e) {
   return std::error_code(static_cast<int>(e), getParseCategory());
 }
 
-inline llvm::Error make_string_error(const llvm::Twine &Message) {
+inline llvm::Error make_string_error(llvm::Twine const &Message) {
   return llvm::make_error<llvm::StringError>(Message,
                                              llvm::inconvertibleErrorCode());
 }
 
-const char *ParseErrorCategory::name() const noexcept {
+char const *ParseErrorCategory::name() const noexcept {
   return "clang-format.parse_error";
 }
 
 std::string ParseErrorCategory::message(int EV) const {
   switch (static_cast<ParseError>(EV)) {
   case ParseError::Success:
     return "Success";
   case ParseError::Error:
     return "Invalid argument";
   case ParseError::Unsuitable:
     return "Unsuitable";
   case ParseError::BinPackTrailingCommaConflict:
     return "trailing comma insertion cannot be used with bin packing";
   }
   llvm_unreachable("unexpected parse error");
 }
 
-static FormatStyle expandPresets(const FormatStyle &Style) {
+static FormatStyle expandPresets(FormatStyle const &Style) {
   if (Style.BreakBeforeBraces == FormatStyle::BS_Custom)
     return Style;
   FormatStyle Expanded = Style;
   Expanded.BraceWrapping = {/*AfterCaseLabel=*/false,
                             /*AfterClass=*/false,
                             /*AfterControlStatement=*/FormatStyle::BWACS_Never,
                             /*AfterEnum=*/false,
                             /*AfterFunction=*/false,
LLVMStyle.BraceWrapping = {/*AfterCaseLabel=*/false,
                              /*SplitEmptyNamespace=*/true};
   LLVMStyle.IndentExternBlock = FormatStyle::IEBS_AfterExternBlock;
   LLVMStyle.BreakAfterJavaFieldAnnotations = false;
   LLVMStyle.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
   LLVMStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
   LLVMStyle.BreakStringLiterals = true;
   LLVMStyle.ColumnLimit = 80;
   LLVMStyle.CommentPragmas = "^ IWYU pragma:";
+  LLVMStyle.ConstPlacement = FormatStyle::CS_Leave;
   LLVMStyle.CompactNamespaces = false;
   LLVMStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = false;
   LLVMStyle.ConstructorInitializerIndentWidth = 4;
   LLVMStyle.ContinuationIndentWidth = 4;
   LLVMStyle.Cpp11BracedListStyle = true;
   LLVMStyle.DeriveLineEnding = true;
   LLVMStyle.DerivePointerAlignment = false;
   LLVMStyle.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Never;
if (Language == FormatStyle::LK_Java) {
     GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
     // TODO: still under discussion whether to switch to SLS_All.
     GoogleStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty;
     GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
     GoogleStyle.BreakBeforeTernaryOperators = false;
     // taze:, triple slash directives (`/// <...`), tslint:, and @see, which is
     // commonly followed by overlong URLs.
     GoogleStyle.CommentPragmas = "(taze:|^/[ \t]*<|tslint:|@see)";
+    GoogleStyle.ConstPlacement = FormatStyle::CS_Leave;
     // TODO: enable once decided, in particular re disabling bin packing.
     // https://google.github.io/styleguide/jsguide.html#features-arrays-trailing-comma
     // GoogleStyle.InsertTrailingCommas = FormatStyle::TCS_Wrapped;
     GoogleStyle.MaxEmptyLinesToKeep = 3;
     GoogleStyle.NamespaceIndentation = FormatStyle::NI_All;
     GoogleStyle.SpacesInContainerLiterals = false;
     GoogleStyle.JavaScriptQuotes = FormatStyle::JSQS_Single;
     GoogleStyle.JavaScriptWrapImports = false;
FormatStyle getChromiumStyle(FormatStyle::LanguageKind Language) {
   //   on that.
   // - Finally, "If include reordering is harmful, put things in different
   //   blocks to prevent it" has been a recommendation for a long time that
   //   people are used to. We'll need a dev education push to change this to
   //   "If include reordering is harmful, put things in a different block and
   //   _prepend that with a comment_ to prevent it" before changing behavior.
   ChromiumStyle.IncludeStyle.IncludeBlocks =
       tooling::IncludeStyle::IBS_Preserve;
+  ChromiumStyle.ConstPlacement = FormatStyle::CS_Leave;
 
   if (Language == FormatStyle::LK_Java) {
     ChromiumStyle.AllowShortIfStatementsOnASingleLine =
         FormatStyle::SIS_WithoutElse;
     ChromiumStyle.BreakAfterJavaFieldAnnotations = true;
     ChromiumStyle.ContinuationIndentWidth = 8;
     ChromiumStyle.IndentWidth = 4;
     // See styleguide for import groups:
FormatStyle getMozillaStyle() {
   MozillaStyle.Cpp11BracedListStyle = false;
   MozillaStyle.FixNamespaceComments = false;
   MozillaStyle.IndentCaseLabels = true;
   MozillaStyle.ObjCSpaceAfterProperty = true;
   MozillaStyle.ObjCSpaceBeforeProtocolList = false;
   MozillaStyle.PenaltyReturnTypeOnItsOwnLine = 200;
   MozillaStyle.PointerAlignment = FormatStyle::PAS_Left;
   MozillaStyle.SpaceAfterTemplateKeyword = false;
+  MozillaStyle.ConstPlacement = FormatStyle::CS_Leave;
   return MozillaStyle;
 }
 
 FormatStyle getWebKitStyle() {
   FormatStyle Style = getLLVMStyle();
   Style.AccessModifierOffset = -4;
   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
   Style.AlignOperands = FormatStyle::OAS_DontAlign;
   Style.AlignTrailingComments = false;
   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
   Style.BreakBeforeBraces = FormatStyle::BS_WebKit;
   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
   Style.Cpp11BracedListStyle = false;
   Style.ColumnLimit = 0;
   Style.FixNamespaceComments = false;
   Style.IndentWidth = 4;
   Style.NamespaceIndentation = FormatStyle::NI_Inner;
   Style.ObjCBlockIndentWidth = 4;
   Style.ObjCSpaceAfterProperty = true;
   Style.PointerAlignment = FormatStyle::PAS_Left;
   Style.SpaceBeforeCpp11BracedList = true;
   Style.SpaceInEmptyBlock = true;
+  Style.ConstPlacement = FormatStyle::CS_Leave;
   return Style;
 }
 
 FormatStyle getGNUStyle() {
   FormatStyle Style = getLLVMStyle();
   Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
   Style.BreakBeforeBraces = FormatStyle::BS_GNU;
   Style.BreakBeforeTernaryOperators = true;
   Style.Cpp11BracedListStyle = false;
   Style.ColumnLimit = 79;
   Style.FixNamespaceComments = false;
   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
   Style.Standard = FormatStyle::LS_Cpp03;
+  Style.ConstPlacement = FormatStyle::CS_Leave;
   return Style;
 }
 
 FormatStyle getMicrosoftStyle(FormatStyle::LanguageKind Language) {
   FormatStyle Style = getLLVMStyle(Language);
   Style.ColumnLimit = 120;
   Style.TabWidth = 4;
   Style.IndentWidth = 4;
FormatStyle getMicrosoftStyle(FormatStyle::LanguageKind Language) {
   Style.PenaltyReturnTypeOnItsOwnLine = 1000;
   Style.AllowShortEnumsOnASingleLine = false;
   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
   Style.AllowShortCaseLabelsOnASingleLine = false;
   Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Never;
   Style.AllowShortLoopsOnASingleLine = false;
   Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_None;
   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
+  Style.ConstPlacement = FormatStyle::CS_Leave;
   return Style;
 }
 
 FormatStyle getNoStyle() {
   FormatStyle NoStyle = getLLVMStyle();
   NoStyle.DisableFormat = true;
   NoStyle.SortIncludes = FormatStyle::SI_Never;
   NoStyle.SortUsingDeclarations = false;
+  NoStyle.ConstPlacement = FormatStyle::CS_Leave;
   return NoStyle;
 }
 
 bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language,
                         FormatStyle *Style) {
   if (Name.equals_insensitive("llvm")) {
     *Style = getLLVMStyle(Language);
   } else if (Name.equals_insensitive("chromium")) {
std::error_code parseConfiguration(llvm::MemoryBufferRef Config,
   if (Style->InsertTrailingCommas != FormatStyle::TCS_None &&
       Style->BinPackArguments) {
     // See comment on FormatStyle::TSC_Wrapped.
     return make_error_code(ParseError::BinPackTrailingCommaConflict);
   }
   return make_error_code(ParseError::Success);
 }
 
-std::string configurationAsText(const FormatStyle &Style) {
+std::string configurationAsText(FormatStyle const &Style) {
   std::string Text;
   llvm::raw_string_ostream Stream(Text);
   llvm::yaml::Output Output(Stream);
   // We use the same mapping method for input and output, so we need a non-const
   // reference here.
   FormatStyle NonConstStyle = expandPresets(Style);
   Output << NonConstStyle;
   return Stream.str();

 FormatStyle::GetLanguageStyle(FormatStyle::LanguageKind Language) const {
   return StyleSet.Get(Language);
 }
 
 namespace {
 
 class JavaScriptRequoter : public TokenAnalyzer {
 public:
-  JavaScriptRequoter(const Environment &Env, const FormatStyle &Style)
+  JavaScriptRequoter(Environment const &Env, FormatStyle const &Style)
       : TokenAnalyzer(Env, Style) {}
 
   std::pair<tooling::Replacements, unsigned>
   analyze(TokenAnnotator &Annotator,
           SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
           FormatTokenLexer &Tokens) override {
     AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
     tooling::Replacements Result;
for (AnnotatedLine *Line : Lines) {
         }
       }
     }
   }
 };
 
 class Formatter : public TokenAnalyzer {
 public:
-  Formatter(const Environment &Env, const FormatStyle &Style,
+  Formatter(Environment const &Env, FormatStyle const &Style,
             FormattingAttemptStatus *Status)
       : TokenAnalyzer(Env, Style), Status(Status) {}
 
   std::pair<tooling::Replacements, unsigned>
   analyze(TokenAnnotator &Annotator,
           SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
           FormatTokenLexer &Tokens) override {
     tooling::Replacements Result;
unsigned Penalty =
                                Tokens.getKeywords(), Env.getSourceManager(),
                                Status)
             .format(AnnotatedLines, /*DryRun=*/false,
                     /*AdditionalIndent=*/0,
                     /*FixBadIndentation=*/false,
                     /*FirstStartColumn=*/Env.getFirstStartColumn(),
                     /*NextStartColumn=*/Env.getNextStartColumn(),
                     /*LastStartColumn=*/Env.getLastStartColumn());
-    for (const auto &R : Whitespaces.generateReplacements())
+    for (auto const &R : Whitespaces.generateReplacements())
       if (Result.add(R))
         return std::make_pair(Result, 0);
     return std::make_pair(Result, Penalty);
   }
 
 private:
   static bool inputUsesCRLF(StringRef Text, bool DefaultToCRLF) {
     size_t LF = Text.count('\n');
     size_t CR = Text.count('\r') * 2;
     return LF == CR ? DefaultToCRLF : CR > LF;
   }
 
   bool
-  hasCpp03IncompatibleFormat(const SmallVectorImpl<AnnotatedLine *> &Lines) {
-    for (const AnnotatedLine *Line : Lines) {
+  hasCpp03IncompatibleFormat(SmallVectorImpl<AnnotatedLine *> const &Lines) {
+    for (AnnotatedLine const *Line : Lines) {
       if (hasCpp03IncompatibleFormat(Line->Children))
         return true;
       for (FormatToken *Tok = Line->First->Next; Tok; Tok = Tok->Next) {
         if (Tok->WhitespaceRange.getBegin() == Tok->WhitespaceRange.getEnd()) {
           if (Tok->is(tok::coloncolon) && Tok->Previous->is(TT_TemplateOpener))
             return true;
           if (Tok->is(TT_TemplateCloser) &&
               Tok->Previous->is(TT_TemplateCloser))
             return true;
         }
       }
     }
     return false;
   }
 
-  int countVariableAlignments(const SmallVectorImpl<AnnotatedLine *> &Lines) {
+  int countVariableAlignments(SmallVectorImpl<AnnotatedLine *> const &Lines) {
     int AlignmentDiff = 0;
-    for (const AnnotatedLine *Line : Lines) {
+    for (AnnotatedLine const *Line : Lines) {
       AlignmentDiff += countVariableAlignments(Line->Children);
       for (FormatToken *Tok = Line->First; Tok && Tok->Next; Tok = Tok->Next) {
         if (!Tok->is(TT_PointerOrReference))
           continue;
         bool SpaceBefore =
             Tok->WhitespaceRange.getBegin() != Tok->WhitespaceRange.getEnd();
         bool SpaceAfter = Tok->Next->WhitespaceRange.getBegin() !=
                           Tok->Next->WhitespaceRange.getEnd();
         if (SpaceBefore && !SpaceAfter)
           ++AlignmentDiff;
         if (!SpaceBefore && SpaceAfter)
           --AlignmentDiff;
       }
     }
     return AlignmentDiff;
   }
 
   void
-  deriveLocalStyle(const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
+  deriveLocalStyle(SmallVectorImpl<AnnotatedLine *> const &AnnotatedLines) {
     bool HasBinPackedFunction = false;
     bool HasOnePerLineFunction = false;
     for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
       if (!AnnotatedLines[i]->First->Next)
         continue;
       FormatToken *Tok = AnnotatedLines[i]->First->Next;
       while (Tok->Next) {
         if (Tok->is(PPK_BinPacked))

 /// TrailingCommaInserter runs after formatting. To avoid causing a required
 /// reformatting (and thus reflow), it never inserts a comma that'd exceed the
 /// ColumnLimit.
 ///
 /// Because trailing commas disable binpacking of arrays, TrailingCommaInserter
 /// is conceptually incompatible with bin packing.
 class TrailingCommaInserter : public TokenAnalyzer {
 public:
-  TrailingCommaInserter(const Environment &Env, const FormatStyle &Style)
+  TrailingCommaInserter(Environment const &Env, FormatStyle const &Style)
       : TokenAnalyzer(Env, Style) {}
 
   std::pair<tooling::Replacements, unsigned>
   analyze(TokenAnnotator &Annotator,
           SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
           FormatTokenLexer &Tokens) override {
     AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
     tooling::Replacements Result;
void insertTrailingCommas(SmallVectorImpl<AnnotatedLine *> &Lines,
     }
   }
 };
 
 // This class clean up the erroneous/redundant code around the given ranges in
 // file.
 class Cleaner : public TokenAnalyzer {
 public:
-  Cleaner(const Environment &Env, const FormatStyle &Style)
+  Cleaner(Environment const &Env, FormatStyle const &Style)
       : TokenAnalyzer(Env, Style),
         DeletedTokens(FormatTokenLess(Env.getSourceManager())) {}
 
   // FIXME: eliminate unused parameters.
   std::pair<tooling::Replacements, unsigned>
   analyze(TokenAnnotator &Annotator,
           SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
           FormatTokenLexer &Tokens) override {
if (Line->Affected) {
       cleanupRight(Line->First, tok::l_paren, tok::comma);
       cleanupLeft(Line->First, tok::comma, tok::r_paren);
       cleanupLeft(Line->First, TT_CtorInitializerComma, tok::l_brace);
       cleanupLeft(Line->First, TT_CtorInitializerColon, tok::l_brace);
       cleanupLeft(Line->First, TT_CtorInitializerColon, tok::equal);
     }
   }
 
-  bool containsOnlyComments(const AnnotatedLine &Line) {
+  bool containsOnlyComments(AnnotatedLine const &Line) {
     for (FormatToken *Tok = Line.First; Tok != nullptr; Tok = Tok->Next) {
       if (Tok->isNot(tok::comment))
         return false;
     }
     return true;
   }
 
   // Iterate through all lines and remove any empty (nested) namespaces.
private:
 
   // Checks pairs {start, start->next},..., {end->previous, end} and deletes one
   // of the token in the pair if the left token has \p LK token kind and the
   // right token has \p RK token kind. If \p DeleteLeft is true, the left token
   // is deleted on match; otherwise, the right token is deleted.
   template <typename LeftKind, typename RightKind>
   void cleanupPair(FormatToken *Start, LeftKind LK, RightKind RK,
                    bool DeleteLeft) {
-    auto NextNotDeleted = [this](const FormatToken &Tok) -> FormatToken * {
+    auto NextNotDeleted = [this](FormatToken const &Tok) -> FormatToken * {
       for (auto *Res = Tok.Next; Res; Res = Res->Next)
         if (!Res->is(tok::comment) &&
             DeletedTokens.find(Res) == DeletedTokens.end())
           return Res;
       return nullptr;
     };
     for (auto *Left = Start; Left;) {
       auto *Right = NextNotDeleted(*Left);
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(const SourceManager &SM) : SM(SM) {}
+    FormatTokenLess(SourceManager const &SM) : SM(SM) {}
 
-    bool operator()(const FormatToken *LHS, const FormatToken *RHS) const {
+    bool operator()(FormatToken const *LHS, FormatToken const *RHS) const {
       return SM.isBeforeInTranslationUnit(LHS->Tok.getLocation(),
                                           RHS->Tok.getLocation());
     }
-    const SourceManager &SM;
+    SourceManager const &SM;
   };
 
   // Tokens to be deleted.
   std::set<FormatToken *, FormatTokenLess> DeletedTokens;
 };
 
 class ObjCHeaderStyleGuesser : public TokenAnalyzer {
 public:
-  ObjCHeaderStyleGuesser(const Environment &Env, const FormatStyle &Style)
+  ObjCHeaderStyleGuesser(Environment const &Env, FormatStyle const &Style)
       : TokenAnalyzer(Env, Style), IsObjC(false) {}
 
   std::pair<tooling::Replacements, unsigned>
   analyze(TokenAnnotator &Annotator,
           SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
           FormatTokenLexer &Tokens) override {
     assert(Style.Language == FormatStyle::LK_Cpp);
     IsObjC = guessIsObjC(Env.getSourceManager(), AnnotatedLines,
                          Tokens.getKeywords());
     tooling::Replacements Result;
     return {Result, 0};
   }
 
   bool isObjC() { return IsObjC; }
 
 private:
   static bool
-  guessIsObjC(const SourceManager &SourceManager,
-              const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
-              const AdditionalKeywords &Keywords) {
+  guessIsObjC(SourceManager const &SourceManager,
+              SmallVectorImpl<AnnotatedLine *> const &AnnotatedLines,
+              AdditionalKeywords const &Keywords) {
     // Keep this array sorted, since we are binary searching over it.
     static constexpr llvm::StringLiteral FoundationIdentifiers[] = {
         "CGFloat",
         "CGPoint",
         "CGPointMake",
         "CGPointZero",
         "CGRect",
         "CGRectEdge",
static constexpr llvm::StringLiteral FoundationIdentifiers[] = {
         "UIView",
     };
 
     for (auto Line : AnnotatedLines) {
       if (Line->First && (Line->First->TokenText.startswith("#") ||
                           Line->First->TokenText == "__pragma" ||
                           Line->First->TokenText == "_Pragma"))
         continue;
-      for (const FormatToken *FormatTok = Line->First; FormatTok;
+      for (FormatToken const *FormatTok = Line->First; FormatTok;
            FormatTok = FormatTok->Next) {
         if ((FormatTok->Previous && FormatTok->Previous->is(tok::at) &&
              (FormatTok->Tok.getObjCKeywordID() != tok::objc_not_keyword ||
               FormatTok->isOneOf(tok::numeric_constant, tok::l_square,
                                  tok::l_brace))) ||
             (FormatTok->Tok.isAnyIdentifier() &&
              std::binary_search(std::begin(FoundationIdentifiers),
                                 std::end(FoundationIdentifiers),

 // Returns a pair (Index, OffsetToEOL) describing the position of the cursor
 // before sorting/deduplicating. Index is the index of the include under the
 // cursor in the original set of includes. If this include has duplicates, it is
 // the index of the first of the duplicates as the others are going to be
 // removed. OffsetToEOL describes the cursor's position relative to the end of
 // its current line.
 // If `Cursor` is not on any #include, `Index` will be UINT_MAX.
 static std::pair<unsigned, unsigned>
-FindCursorIndex(const SmallVectorImpl<IncludeDirective> &Includes,
-                const SmallVectorImpl<unsigned> &Indices, unsigned Cursor) {
+FindCursorIndex(SmallVectorImpl<IncludeDirective> const &Includes,
+                SmallVectorImpl<unsigned> const &Indices, unsigned Cursor) {
   unsigned CursorIndex = UINT_MAX;
   unsigned OffsetToEOL = 0;
   for (int i = 0, e = Includes.size(); i != e; ++i) {
     unsigned Start = Includes[Indices[i]].Offset;
     unsigned End = Start + Includes[Indices[i]].Text.size();
     if (!(Cursor >= Start && Cursor < End))
       continue;
     CursorIndex = Indices[i];
     OffsetToEOL = End - Cursor;
     // Put the cursor on the only remaining #include among the duplicate
     // #includes.
     while (--i >= 0 && Includes[CursorIndex].Text == Includes[Indices[i]].Text)
       CursorIndex = i;
     break;
   }
   return std::make_pair(CursorIndex, OffsetToEOL);
 }
 
 // Replace all "\r\n" with "\n".
-std::string replaceCRLF(const std::string &Code) {
+std::string replaceCRLF(std::string const &Code) {
   std::string NewCode;
   size_t Pos = 0, LastPos = 0;
 
   do {
     Pos = Code.find("\r\n", LastPos);
     if (Pos == LastPos) {
       LastPos++;
       continue;

 
 // Sorts and deduplicate a block of includes given by 'Includes' alphabetically
 // adding the necessary replacement to 'Replaces'. 'Includes' must be in strict
 // source order.
 // #include directives with the same text will be deduplicated, and only the
 // first #include in the duplicate #includes remains. If the `Cursor` is
 // provided and put on a deleted #include, it will be moved to the remaining
 // #include in the duplicate #includes.
-static void sortCppIncludes(const FormatStyle &Style,
-                            const SmallVectorImpl<IncludeDirective> &Includes,
+static void sortCppIncludes(FormatStyle const &Style,
+                            SmallVectorImpl<IncludeDirective> const &Includes,
                             ArrayRef<tooling::Range> Ranges, StringRef FileName,
                             StringRef Code, tooling::Replacements &Replaces,
                             unsigned *Cursor) {
   tooling::IncludeCategoryManager Categories(Style.IncludeStyle, FileName);
   unsigned IncludesBeginOffset = Includes.front().Offset;
   unsigned IncludesEndOffset =
       Includes.back().Offset + Includes.back().Text.size();
   unsigned IncludesBlockSize = IncludesEndOffset - IncludesBeginOffset;
static void sortCppIncludes(FormatStyle const &Style,
   if (Err) {
     llvm::errs() << llvm::toString(std::move(Err)) << "\n";
     assert(false);
   }
 }
 
 namespace {
 
-const char CppIncludeRegexPattern[] =
+char const CppIncludeRegexPattern[] =
     R"(^[\t\ ]*#[\t\ ]*(import|include)[^"<]*(["<][^">]*[">]))";
 
 } // anonymous namespace
 
-tooling::Replacements sortCppIncludes(const FormatStyle &Style, StringRef Code,
+tooling::Replacements sortCppIncludes(FormatStyle const &Style, StringRef Code,
                                       ArrayRef<tooling::Range> Ranges,
                                       StringRef FileName,
                                       tooling::Replacements &Replaces,
                                       unsigned *Cursor) {
   unsigned Prev = llvm::StringSwitch<size_t>(Code)
                       .StartsWith("\xEF\xBB\xBF", 3) // UTF-8 BOM
                       .Default(0);
   unsigned SearchFrom = 0;
for (;;) {
 
     StringRef Trimmed = Line.trim();
     if (Trimmed == "// clang-format off" || Trimmed == "/* clang-format off */")
       FormattingOff = true;
     else if (Trimmed == "// clang-format on" ||
              Trimmed == "/* clang-format on */")
       FormattingOff = false;
 
-    const bool EmptyLineSkipped =
+    bool const EmptyLineSkipped =
         Trimmed.empty() &&
         (Style.IncludeStyle.IncludeBlocks == tooling::IncludeStyle::IBS_Merge ||
          Style.IncludeStyle.IncludeBlocks ==
              tooling::IncludeStyle::IBS_Regroup);
 
     bool MergeWithNextLine = Trimmed.endswith("\\");
     if (!FormattingOff && !MergeWithNextLine) {
       if (IncludeRegex.match(Line, &Matches)) {
if (!IncludesInBlock.empty()) {
     sortCppIncludes(Style, IncludesInBlock, Ranges, FileName, Code, Replaces,
                     Cursor);
   }
   return Replaces;
 }
 
 // Returns group number to use as a first order sort on imports. Gives UINT_MAX
 // if the import does not match any given groups.
-static unsigned findJavaImportGroup(const FormatStyle &Style,
+static unsigned findJavaImportGroup(FormatStyle const &Style,
                                     StringRef ImportIdentifier) {
   unsigned LongestMatchIndex = UINT_MAX;
   unsigned LongestMatchLength = 0;
   for (unsigned I = 0; I < Style.JavaImportGroups.size(); I++) {
     std::string GroupPrefix = Style.JavaImportGroups[I];
     if (ImportIdentifier.startswith(GroupPrefix) &&
         GroupPrefix.length() > LongestMatchLength) {
       LongestMatchIndex = I;
       LongestMatchLength = GroupPrefix.length();
     }
   }
   return LongestMatchIndex;
 }
 
 // Sorts and deduplicates a block of includes given by 'Imports' based on
 // JavaImportGroups, then adding the necessary replacement to 'Replaces'.
 // Import declarations with the same text will be deduplicated. Between each
 // import group, a newline is inserted, and within each import group, a
 // lexicographic sort based on ASCII value is performed.
-static void sortJavaImports(const FormatStyle &Style,
-                            const SmallVectorImpl<JavaImportDirective> &Imports,
+static void sortJavaImports(FormatStyle const &Style,
+                            SmallVectorImpl<JavaImportDirective> const &Imports,
                             ArrayRef<tooling::Range> Ranges, StringRef FileName,
                             StringRef Code, tooling::Replacements &Replaces) {
   unsigned ImportsBeginOffset = Imports.front().Offset;
   unsigned ImportsEndOffset =
       Imports.back().Offset + Imports.back().Text.size();
   unsigned ImportsBlockSize = ImportsEndOffset - ImportsBeginOffset;
   if (!affectsRange(Ranges, ImportsBeginOffset, ImportsEndOffset))
     return;
static void sortJavaImports(FormatStyle const &Style,
   if (Err) {
     llvm::errs() << llvm::toString(std::move(Err)) << "\n";
     assert(false);
   }
 }
 
 namespace {
 
-const char JavaImportRegexPattern[] =
+char const JavaImportRegexPattern[] =
     "^[\t ]*import[\t ]+(static[\t ]*)?([^\t ]*)[\t ]*;";
 
 } // anonymous namespace
 
-tooling::Replacements sortJavaImports(const FormatStyle &Style, StringRef Code,
+tooling::Replacements sortJavaImports(FormatStyle const &Style, StringRef Code,
                                       ArrayRef<tooling::Range> Ranges,
                                       StringRef FileName,
                                       tooling::Replacements &Replaces) {
   unsigned Prev = 0;
   unsigned SearchFrom = 0;
   llvm::Regex ImportRegex(JavaImportRegexPattern);
   SmallVector<StringRef, 4> Matches;
   SmallVector<JavaImportDirective, 16> ImportsInBlock;
bool isMpegTS(StringRef Code) {
   // MPEG transport streams use the ".ts" file extension. clang-format should
   // not attempt to format those. MPEG TS' frame format starts with 0x47 every
   // 189 bytes - detect that and return.
   return Code.size() > 188 && Code[0] == 0x47 && Code[188] == 0x47;
 }
 
 bool isLikelyXml(StringRef Code) { return Code.ltrim().startswith("<"); }
 
-tooling::Replacements sortIncludes(const FormatStyle &Style, StringRef Code,
+tooling::Replacements sortIncludes(FormatStyle const &Style, StringRef Code,
                                    ArrayRef<tooling::Range> Ranges,
                                    StringRef FileName, unsigned *Cursor) {
   tooling::Replacements Replaces;
   if (!Style.SortIncludes || Style.DisableFormat)
     return Replaces;
   if (isLikelyXml(Code))
     return Replaces;
   if (Style.Language == FormatStyle::LanguageKind::LK_JavaScript &&
       isMpegTS(Code))
     return Replaces;
   if (Style.Language == FormatStyle::LanguageKind::LK_JavaScript)
     return sortJavaScriptImports(Style, Code, Ranges, FileName);
   if (Style.Language == FormatStyle::LanguageKind::LK_Java)
     return sortJavaImports(Style, Code, Ranges, FileName, Replaces);
   sortCppIncludes(Style, Code, Ranges, FileName, Replaces, Cursor);
   return Replaces;
 }
 
 template <typename T>
 static llvm::Expected<tooling::Replacements>
 processReplacements(T ProcessFunc, StringRef Code,
-                    const tooling::Replacements &Replaces,
-                    const FormatStyle &Style) {
+                    tooling::Replacements const &Replaces,
+                    FormatStyle const &Style) {
   if (Replaces.empty())
     return tooling::Replacements();
 
   auto NewCode = applyAllReplacements(Code, Replaces);
   if (!NewCode)
     return NewCode.takeError();
   std::vector<tooling::Range> ChangedRanges = Replaces.getAffectedRanges();
   StringRef FileName = Replaces.begin()->getFilePath();
 
   tooling::Replacements FormatReplaces =
       ProcessFunc(Style, *NewCode, ChangedRanges, FileName);
 
   return Replaces.merge(FormatReplaces);
 }
 
 llvm::Expected<tooling::Replacements>
-formatReplacements(StringRef Code, const tooling::Replacements &Replaces,
-                   const FormatStyle &Style) {
+formatReplacements(StringRef Code, tooling::Replacements const &Replaces,
+                   FormatStyle const &Style) {
   // We need to use lambda function here since there are two versions of
   // `sortIncludes`.
-  auto SortIncludes = [](const FormatStyle &Style, StringRef Code,
+  auto SortIncludes = [](FormatStyle const &Style, StringRef Code,
                          std::vector<tooling::Range> Ranges,
                          StringRef FileName) -> tooling::Replacements {
     return sortIncludes(Style, Code, Ranges, FileName);
   };
   auto SortedReplaces =
       processReplacements(SortIncludes, Code, Replaces, Style);
   if (!SortedReplaces)
     return SortedReplaces.takeError();
 
   // We need to use lambda function here since there are two versions of
   // `reformat`.
-  auto Reformat = [](const FormatStyle &Style, StringRef Code,
+  auto Reformat = [](FormatStyle const &Style, StringRef Code,
                      std::vector<tooling::Range> Ranges,
                      StringRef FileName) -> tooling::Replacements {
     return reformat(Style, Code, Ranges, FileName);
   };
   return processReplacements(Reformat, Code, *SortedReplaces, Style);
 }
 
 namespace {
 
-inline bool isHeaderInsertion(const tooling::Replacement &Replace) {
+inline bool isHeaderInsertion(tooling::Replacement const &Replace) {
   return Replace.getOffset() == UINT_MAX && Replace.getLength() == 0 &&
          llvm::Regex(CppIncludeRegexPattern)
              .match(Replace.getReplacementText());
 }
 
-inline bool isHeaderDeletion(const tooling::Replacement &Replace) {
+inline bool isHeaderDeletion(tooling::Replacement const &Replace) {
   return Replace.getOffset() == UINT_MAX && Replace.getLength() == 1;
 }
 
 // FIXME: insert empty lines between newly created blocks.
 tooling::Replacements
-fixCppIncludeInsertions(StringRef Code, const tooling::Replacements &Replaces,
-                        const FormatStyle &Style) {
+fixCppIncludeInsertions(StringRef Code, tooling::Replacements const &Replaces,
+                        FormatStyle const &Style) {
   if (!Style.isCpp())
     return Replaces;
 
   tooling::Replacements HeaderInsertions;
   std::set<llvm::StringRef> HeadersToDelete;
   tooling::Replacements Result;
-  for (const auto &R : Replaces) {
+  for (auto const &R : Replaces) {
     if (isHeaderInsertion(R)) {
       // Replacements from \p Replaces must be conflict-free already, so we can
       // simply consume the error.
       llvm::consumeError(HeaderInsertions.add(R));
     } else if (isHeaderDeletion(R)) {
       HeadersToDelete.insert(R.getReplacementText());
     } else if (R.getOffset() == UINT_MAX) {
       llvm::errs() << "Insertions other than header #include insertion are "
                       "not supported! "
                    << R.getReplacementText() << "\n";
     } else {
       llvm::consumeError(Result.add(R));
     }
   }
   if (HeaderInsertions.empty() && HeadersToDelete.empty())
     return Replaces;
 
   StringRef FileName = Replaces.begin()->getFilePath();
   tooling::HeaderIncludes Includes(FileName, Code, Style.IncludeStyle);
 
-  for (const auto &Header : HeadersToDelete) {
+  for (auto const &Header : HeadersToDelete) {
     tooling::Replacements Replaces =
         Includes.remove(Header.trim("\"<>"), Header.startswith("<"));
-    for (const auto &R : Replaces) {
+    for (auto const &R : Replaces) {
       auto Err = Result.add(R);
       if (Err) {
         // Ignore the deletion on conflict.
         llvm::errs() << "Failed to add header deletion replacement for "
                      << Header << ": " << llvm::toString(std::move(Err))
                      << "\n";
       }
     }
   }
 
   llvm::Regex IncludeRegex = llvm::Regex(CppIncludeRegexPattern);
   llvm::SmallVector<StringRef, 4> Matches;
-  for (const auto &R : HeaderInsertions) {
+  for (auto const &R : HeaderInsertions) {
     auto IncludeDirective = R.getReplacementText();
     bool Matched = IncludeRegex.match(IncludeDirective, &Matches);
     assert(Matched && "Header insertion replacement must have replacement text "
                       "'#include ...'");
     (void)Matched;
     auto IncludeName = Matches[2];
     auto Replace =
         Includes.insert(IncludeName.trim("\"<>"), IncludeName.startswith("<"));
for (auto const &R : HeaderInsertions) {
     }
   }
   return Result;
 }
 
 } // anonymous namespace
 
 llvm::Expected<tooling::Replacements>
-cleanupAroundReplacements(StringRef Code, const tooling::Replacements &Replaces,
-                          const FormatStyle &Style) {
+cleanupAroundReplacements(StringRef Code, tooling::Replacements const &Replaces,
+                          FormatStyle const &Style) {
   // We need to use lambda function here since there are two versions of
   // `cleanup`.
-  auto Cleanup = [](const FormatStyle &Style, StringRef Code,
+  auto Cleanup = [](FormatStyle const &Style, StringRef Code,
                     std::vector<tooling::Range> Ranges,
                     StringRef FileName) -> tooling::Replacements {
     return cleanup(Style, Code, Ranges, FileName);
   };
   // Make header insertion replacements insert new headers into correct blocks.
   tooling::Replacements NewReplaces =
       fixCppIncludeInsertions(Code, Replaces, Style);
   return processReplacements(Cleanup, Code, NewReplaces, Style);
 }
 
 namespace internal {
 std::pair<tooling::Replacements, unsigned>
-reformat(const FormatStyle &Style, StringRef Code,
+reformat(FormatStyle const &Style, StringRef Code,
          ArrayRef<tooling::Range> Ranges, unsigned FirstStartColumn,
          unsigned NextStartColumn, unsigned LastStartColumn, StringRef FileName,
          FormattingAttemptStatus *Status) {
   FormatStyle Expanded = expandPresets(Style);
   if (Expanded.DisableFormat)
     return {tooling::Replacements(), 0};
   if (isLikelyXml(Code))
     return {tooling::Replacements(), 0};
if (!Replaces.add(tooling::Replacement(FileName, 0, 4, ""))) {
       if (applyAllReplacements(Code, Replaces)) {
         return {Replaces, 0};
       }
     }
     return {tooling::Replacements(), 0};
   }
 
   typedef std::function<std::pair<tooling::Replacements, unsigned>(
-      const Environment &)>
+      Environment const &)>
       AnalyzerPass;
   SmallVector<AnalyzerPass, 4> Passes;
 
   if (Style.Language == FormatStyle::LK_Cpp) {
     if (Style.FixNamespaceComments)
-      Passes.emplace_back([&](const Environment &Env) {
+      Passes.emplace_back([&](Environment const &Env) {
         return NamespaceEndCommentsFixer(Env, Expanded).process();
       });
 
     if (Style.SortUsingDeclarations)
-      Passes.emplace_back([&](const Environment &Env) {
+      Passes.emplace_back([&](Environment const &Env) {
         return UsingDeclarationsSorter(Env, Expanded).process();
       });
   }
 
+  if (Style.isCpp() && Style.ConstPlacement != FormatStyle::CS_Leave)
+    Passes.emplace_back([&](Environment const &Env) {
+      return EastWestConstFixer(Env, Expanded).process();
+    });
+
   if (Style.Language == FormatStyle::LK_JavaScript &&
       Style.JavaScriptQuotes != FormatStyle::JSQS_Leave)
-    Passes.emplace_back([&](const Environment &Env) {
+    Passes.emplace_back([&](Environment const &Env) {
       return JavaScriptRequoter(Env, Expanded).process();
     });
 
-  Passes.emplace_back([&](const Environment &Env) {
+  Passes.emplace_back([&](Environment const &Env) {
     return Formatter(Env, Expanded, Status).process();
   });
 
   if (Style.Language == FormatStyle::LK_JavaScript &&
       Style.InsertTrailingCommas == FormatStyle::TCS_Wrapped)
-    Passes.emplace_back([&](const Environment &Env) {
+    Passes.emplace_back([&](Environment const &Env) {
       return TrailingCommaInserter(Env, Expanded).process();
     });
 
   auto Env =
       std::make_unique<Environment>(Code, FileName, Ranges, FirstStartColumn,
                                     NextStartColumn, LastStartColumn);
   llvm::Optional<std::string> CurrentCode = None;
   tooling::Replacements Fixes;
if (NewCode) {
       }
     }
   }
 
   return {Fixes, Penalty};
 }
 } // namespace internal
 
-tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
+tooling::Replacements reformat(FormatStyle const &Style, StringRef Code,
                                ArrayRef<tooling::Range> Ranges,
                                StringRef FileName,
                                FormattingAttemptStatus *Status) {
   return internal::reformat(Style, Code, Ranges,
                             /*FirstStartColumn=*/0,
                             /*NextStartColumn=*/0,
                             /*LastStartColumn=*/0, FileName, Status)
       .first;
 }
 
-tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code,
+tooling::Replacements cleanup(FormatStyle const &Style, StringRef Code,
                               ArrayRef<tooling::Range> Ranges,
                               StringRef FileName) {
   // cleanups only apply to C++ (they mostly concern ctor commas etc.)
   if (Style.Language != FormatStyle::LK_Cpp)
     return tooling::Replacements();
   return Cleaner(Environment(Code, FileName, Ranges), Style).process().first;
 }
 
-tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
+tooling::Replacements reformat(FormatStyle const &Style, StringRef Code,
                                ArrayRef<tooling::Range> Ranges,
                                StringRef FileName, bool *IncompleteFormat) {
   FormattingAttemptStatus Status;
   auto Result = reformat(Style, Code, Ranges, FileName, &Status);
   if (!Status.FormatComplete)
     *IncompleteFormat = true;
   return Result;
 }
 
-tooling::Replacements fixNamespaceEndComments(const FormatStyle &Style,
+tooling::Replacements fixNamespaceEndComments(FormatStyle const &Style,
                                               StringRef Code,
                                               ArrayRef<tooling::Range> Ranges,
                                               StringRef FileName) {
   return NamespaceEndCommentsFixer(Environment(Code, FileName, Ranges), Style)
       .process()
       .first;
 }
 
-tooling::Replacements sortUsingDeclarations(const FormatStyle &Style,
+tooling::Replacements sortUsingDeclarations(FormatStyle const &Style,
                                             StringRef Code,
                                             ArrayRef<tooling::Range> Ranges,
                                             StringRef FileName) {
   return UsingDeclarationsSorter(Environment(Code, FileName, Ranges), Style)
       .process()
       .first;
 }
 
-LangOptions getFormattingLangOpts(const FormatStyle &Style) {
+LangOptions getFormattingLangOpts(FormatStyle const &Style) {
   LangOptions LangOpts;
 
   FormatStyle::LanguageStandard LexingStd = Style.Standard;
   if (LexingStd == FormatStyle::LS_Auto)
     LexingStd = FormatStyle::LS_Latest;
   if (LexingStd == FormatStyle::LS_Latest)
     LexingStd = FormatStyle::LS_Cpp20;
   LangOpts.CPlusPlus = 1;
LangOptions getFormattingLangOpts(FormatStyle const &Style) {
   LangOpts.Bool = 1;
   LangOpts.ObjC = 1;
   LangOpts.MicrosoftExt = 1;    // To get kw___try, kw___finally.
   LangOpts.DeclSpecKeyword = 1; // To get __declspec.
   LangOpts.C99 = 1; // To get kw_restrict for non-underscore-prefixed restrict.
   return LangOpts;
 }
 
-const char *StyleOptionHelpDescription =
+char const *StyleOptionHelpDescription =
     "Coding style, currently supports:\n"
     "  LLVM, GNU, Google, Chromium, Microsoft, Mozilla, WebKit.\n"
     "Use -style=file to load style configuration from\n"
     ".clang-format file located in one of the parent\n"
     "directories of the source file (or current\n"
     "directory for stdin).\n"
     "Use -style=\"{key: value, ...}\" to set specific\n"
     "parameters, e.g.:\n"
static FormatStyle::LanguageKind getLanguageByFileName(StringRef FileName) {
   if (FileName.endswith_insensitive(".cs"))
     return FormatStyle::LK_CSharp;
   if (FileName.endswith_insensitive(".json"))
     return FormatStyle::LK_Json;
   return FormatStyle::LK_Cpp;
 }
 
 FormatStyle::LanguageKind guessLanguage(StringRef FileName, StringRef Code) {
-  const auto GuessedLanguage = getLanguageByFileName(FileName);
+  auto const GuessedLanguage = getLanguageByFileName(FileName);
   if (GuessedLanguage == FormatStyle::LK_Cpp) {
     auto Extension = llvm::sys::path::extension(FileName);
     // If there's no file extension (or it's .h), we need to check the contents
     // of the code to see if it contains Objective-C.
     if (Extension.empty() || Extension == ".h") {
       auto NonEmptyFileName = FileName.empty() ? "guess.h" : FileName;
       Environment Env(Code, NonEmptyFileName, /*Ranges=*/{});
       ObjCHeaderStyleGuesser Guesser(Env, getLLVMStyle());
       Guesser.process();
       if (Guesser.isObjC())
         return FormatStyle::LK_ObjC;
     }
   }
   return GuessedLanguage;
 }
 
-const char *DefaultFormatStyle = "file";
+char const *DefaultFormatStyle = "file";
 
-const char *DefaultFallbackStyle = "LLVM";
+char const *DefaultFallbackStyle = "LLVM";
 
 llvm::Expected<FormatStyle> getStyle(StringRef StyleName, StringRef FileName,
                                      StringRef FallbackStyleName,
                                      StringRef Code, llvm::vfs::FileSystem *FS,
                                      bool AllowUnknownOptions) {
   if (!FS) {
     FS = llvm::vfs::getRealFileSystem().get();
   }
llvm::Expected<FormatStyle> getStyle(StringRef StyleName, StringRef FileName,
   SmallString<128> Path(FileName);
   if (std::error_code EC = FS->makeAbsolute(Path))
     return make_string_error(EC.message());
 
   llvm::SmallVector<std::string, 2> FilesToLookFor;
   FilesToLookFor.push_back(".clang-format");
   FilesToLookFor.push_back("_clang-format");
 
-  auto dropDiagnosticHandler = [](const llvm::SMDiagnostic &, void *) {};
+  auto dropDiagnosticHandler = [](llvm::SMDiagnostic const &, void *) {};
 
   for (StringRef Directory = Path; !Directory.empty();
        Directory = llvm::sys::path::parent_path(Directory)) {
 
     auto Status = FS->status(Directory);
     if (!Status ||
         Status->getType() != llvm::sys::fs::file_type::directory_file) {
       continue;
     }
 
-    for (const auto &F : FilesToLookFor) {
+    for (auto const &F : FilesToLookFor) {
       SmallString<128> ConfigFile(Directory);
 
       llvm::sys::path::append(ConfigFile, F);
       LLVM_DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n");
 
       Status = FS->status(ConfigFile.str());
 
       if (Status &&
for (auto const &F : FilesToLookFor) {
                    << "Using configuration file " << ConfigFile << "\n");
 
         if (!Style.InheritsParentConfig) {
           if (ChildFormatTextToApply.empty())
             return Style;
 
           LLVM_DEBUG(llvm::dbgs() << "Applying child configurations\n");
 
-          for (const auto &MemBuf : llvm::reverse(ChildFormatTextToApply)) {
+          for (auto const &MemBuf : llvm::reverse(ChildFormatTextToApply)) {
             auto Ec = parseConfiguration(*MemBuf, &Style, AllowUnknownOptions,
                                          dropDiagnosticHandler);
             // It was already correctly parsed.
             assert(!Ec);
             static_cast<void>(Ec);
           }
 
           return Style;

clang/lib/Format/FormatInternal.h

 ///     with \p Style.
 ///   * P.second is the penalty induced by formatting the fragment \p Code.
 ///     If the formatting of the fragment doesn't have a notion of penalty,
 ///     returns 0.
 ///
 /// If ``Status`` is non-null, its value will be populated with the status of
 /// this formatting attempt. See \c FormattingAttemptStatus.
 std::pair<tooling::Replacements, unsigned>
-reformat(const FormatStyle &Style, StringRef Code,
+reformat(FormatStyle const &Style, StringRef Code,
          ArrayRef<tooling::Range> Ranges, unsigned FirstStartColumn,
          unsigned NextStartColumn, unsigned LastStartColumn, StringRef FileName,
          FormattingAttemptStatus *Status);
 
 } // namespace internal
 } // namespace format
 } // namespace clang
 
 #endif

clang/lib/Format/FormatToken.h

 enum TokenType : uint8_t {
 #define TYPE(X) TT_##X,
   LIST_TOKEN_TYPES
 #undef TYPE
       NUM_TOKEN_TYPES
 };
 
 /// Determines the name of a token type.
-const char *getTokenTypeName(TokenType Type);
+char const *getTokenTypeName(TokenType Type);
 
 // Represents what type of block a set of braces open.
 enum BraceBlockKind { BK_Unknown, BK_Block, BK_BracedInit };
 
 // The packing kind of a function's parameters.
 enum ParameterPackingKind { PPK_BinPacked, PPK_OnePerLine, PPK_Inconclusive };
 
 enum FormatDecision { FD_Unformatted, FD_Continue, FD_Break };
public:
   SmallVector<AnnotatedLine *, 1> Children;
 
   // Contains all attributes related to how this token takes part
   // in a configured macro expansion.
   llvm::Optional<MacroExpansion> MacroCtx;
 
   bool is(tok::TokenKind Kind) const { return Tok.is(Kind); }
   bool is(TokenType TT) const { return getType() == TT; }
-  bool is(const IdentifierInfo *II) const {
+  bool is(IdentifierInfo const *II) const {
     return II && II == Tok.getIdentifierInfo();
   }
   bool is(tok::PPKeywordKind Kind) const {
     return Tok.getIdentifierInfo() &&
            Tok.getIdentifierInfo()->getPPKeywordID() == Kind;
   }
   bool is(BraceBlockKind BBK) const { return getBlockKind() == BBK; }
   bool is(ParameterPackingKind PPK) const { return getPackingKind() == PPK; }
public:
   FormatToken *getPreviousNonComment() const {
     FormatToken *Tok = Previous;
     while (Tok && Tok->is(tok::comment))
       Tok = Tok->Previous;
     return Tok;
   }
 
   /// Returns the next token ignoring comments.
-  const FormatToken *getNextNonComment() const {
-    const FormatToken *Tok = Next;
+  FormatToken const *getNextNonComment() const {
+    FormatToken const *Tok = Next;
     while (Tok && Tok->is(tok::comment))
       Tok = Tok->Next;
     return Tok;
   }
 
   /// Returns \c true if this tokens starts a block-type list, i.e. a
   /// list that should be indented with a block indent.
-  bool opensBlockOrBlockTypeList(const FormatStyle &Style) const {
+  bool opensBlockOrBlockTypeList(FormatStyle const &Style) const {
     // C# Does not indent object initialisers as continuations.
     if (is(tok::l_brace) && getBlockKind() == BK_BracedInit && Style.isCSharp())
       return true;
     if (is(TT_TemplateString) && opensScope())
       return true;
     return is(TT_ArrayInitializerLSquare) || is(TT_ProtoExtensionLSquare) ||
            (is(tok::l_brace) &&
             (getBlockKind() == BK_Block || is(TT_DictLiteral) ||
              (!Style.Cpp11BracedListStyle && NestingLevel == 0))) ||
            (is(tok::less) && (Style.Language == FormatStyle::LK_Proto ||
                               Style.Language == FormatStyle::LK_TextProto));
   }
 
   /// Returns whether the token is the left square bracket of a C++
   /// structured binding declaration.
-  bool isCppStructuredBinding(const FormatStyle &Style) const {
+  bool isCppStructuredBinding(FormatStyle const &Style) const {
     if (!Style.isCpp() || isNot(tok::l_square))
       return false;
-    const FormatToken *T = this;
+    FormatToken const *T = this;
     do {
       T = T->getPreviousNonComment();
     } while (T && T->isOneOf(tok::kw_const, tok::kw_volatile, tok::amp,
                              tok::ampamp));
     return T && T->is(tok::kw_auto);
   }
 
   /// Same as opensBlockOrBlockTypeList, but for the closing token.
-  bool closesBlockOrBlockTypeList(const FormatStyle &Style) const {
+  bool closesBlockOrBlockTypeList(FormatStyle const &Style) const {
     if (is(TT_TemplateString) && closesScope())
       return true;
     return MatchingParen && MatchingParen->opensBlockOrBlockTypeList(Style);
   }
 
   /// Return the actual namespace token, if this token starts a namespace
   /// block.
-  const FormatToken *getNamespaceToken() const {
-    const FormatToken *NamespaceTok = this;
+  FormatToken const *getNamespaceToken() const {
+    FormatToken const *NamespaceTok = this;
     if (is(tok::comment))
       NamespaceTok = NamespaceTok->getNextNonComment();
     // Detect "(inline|export)? namespace" in the beginning of a line.
     if (NamespaceTok && NamespaceTok->isOneOf(tok::kw_inline, tok::kw_export))
       NamespaceTok = NamespaceTok->getNextNonComment();
     return NamespaceTok &&
                    NamespaceTok->isOneOf(tok::kw_namespace, TT_NamespaceMacro)
                ? NamespaceTok
                : nullptr;
   }
 
-  void copyFrom(const FormatToken &Tok) { *this = Tok; }
+  void copyFrom(FormatToken const &Tok) { *this = Tok; }
 
 private:
   // Only allow copying via the explicit copyFrom method.
-  FormatToken(const FormatToken &) = delete;
-  FormatToken &operator=(const FormatToken &) = default;
+  FormatToken(FormatToken const &) = delete;
+  FormatToken &operator=(FormatToken const &) = default;
 
   template <typename A, typename... Ts>
   bool startsSequenceInternal(A K1, Ts... Tokens) const {
     if (is(tok::comment) && Next)
       return Next->startsSequenceInternal(K1, Tokens...);
     return is(K1) && Next && Next->startsSequenceInternal(Tokens...);
   }
 
private:
   }
 };
 
 class ContinuationIndenter;
 struct LineState;
 
 class TokenRole {
 public:
-  TokenRole(const FormatStyle &Style) : Style(Style) {}
+  TokenRole(FormatStyle const &Style) : Style(Style) {}
   virtual ~TokenRole();
 
   /// After the \c TokenAnnotator has finished annotating all the tokens,
   /// this function precomputes required information for formatting.
-  virtual void precomputeFormattingInfos(const FormatToken *Token);
+  virtual void precomputeFormattingInfos(FormatToken const *Token);
 
   /// Apply the special formatting that the given role demands.
   ///
   /// Assumes that the token having this role is already formatted.
   ///
   /// Continues formatting from \p State leaving indentation to \p Indenter and
   /// returns the total penalty that this formatting incurs.
   virtual unsigned formatFromToken(LineState &State,
                                    ContinuationIndenter *Indenter,
                                    bool DryRun) {
     return 0;
   }
 
   /// Same as \c formatFromToken, but assumes that the first token has
   /// already been set thereby deciding on the first line break.
   virtual unsigned formatAfterToken(LineState &State,
                                     ContinuationIndenter *Indenter,
                                     bool DryRun) {
     return 0;
   }
 
   /// Notifies the \c Role that a comma was found.
-  virtual void CommaFound(const FormatToken *Token) {}
+  virtual void CommaFound(FormatToken const *Token) {}
 
-  virtual const FormatToken *lastComma() { return nullptr; }
+  virtual FormatToken const *lastComma() { return nullptr; }
 
 protected:
-  const FormatStyle &Style;
+  FormatStyle const &Style;
 };
 
 class CommaSeparatedList : public TokenRole {
 public:
-  CommaSeparatedList(const FormatStyle &Style)
+  CommaSeparatedList(FormatStyle const &Style)
       : TokenRole(Style), HasNestedBracedList(false) {}
 
-  void precomputeFormattingInfos(const FormatToken *Token) override;
+  void precomputeFormattingInfos(FormatToken const *Token) override;
 
   unsigned formatAfterToken(LineState &State, ContinuationIndenter *Indenter,
                             bool DryRun) override;
 
   unsigned formatFromToken(LineState &State, ContinuationIndenter *Indenter,
                            bool DryRun) override;
 
   /// Adds \p Token as the next comma to the \c CommaSeparated list.
-  void CommaFound(const FormatToken *Token) override {
+  void CommaFound(FormatToken const *Token) override {
     Commas.push_back(Token);
   }
 
-  const FormatToken *lastComma() override {
+  FormatToken const *lastComma() override {
     if (Commas.empty())
       return nullptr;
     return Commas.back();
   }
 
 private:
   /// A struct that holds information on how to format a given list with
   /// a specific number of columns.
   struct ColumnFormat {
     /// The number of columns to use.
     unsigned Columns;
 
     /// The total width in characters.
     unsigned TotalWidth;
 
     /// The number of lines required for this format.
     unsigned LineCount;
 
     /// The size of each column in characters.
     SmallVector<unsigned, 8> ColumnSizes;
   };
 
   /// Calculate which \c ColumnFormat fits best into
   /// \p RemainingCharacters.
-  const ColumnFormat *getColumnFormat(unsigned RemainingCharacters) const;
+  ColumnFormat const *getColumnFormat(unsigned RemainingCharacters) const;
 
   /// The ordered \c FormatTokens making up the commas of this list.
-  SmallVector<const FormatToken *, 8> Commas;
+  SmallVector<FormatToken const *, 8> Commas;
 
   /// The length of each of the list's items in characters including the
   /// trailing comma.
   SmallVector<unsigned, 8> ItemLengths;
 
   /// Precomputed formats that can be used for this list.
   SmallVector<ColumnFormat, 4> Formats;
 
struct AdditionalKeywords {
   IdentifierInfo *kw_when;
   IdentifierInfo *kw_where;
 
   /// Returns \c true if \p Tok is a true JavaScript identifier, returns
   /// \c false if it is a keyword or a pseudo keyword.
   /// If \c AcceptIdentifierName is true, returns true not only for keywords,
   // but also for IdentifierName tokens (aka pseudo-keywords), such as
   // ``yield``.
-  bool IsJavaScriptIdentifier(const FormatToken &Tok,
+  bool IsJavaScriptIdentifier(FormatToken const &Tok,
                               bool AcceptIdentifierName = true) const {
     // Based on the list of JavaScript & TypeScript keywords here:
     // https://github.com/microsoft/TypeScript/blob/master/src/compiler/scanner.ts#L74
     switch (Tok.Tok.getKind()) {
     case tok::kw_break:
     case tok::kw_case:
     case tok::kw_catch:
     case tok::kw_class:
#include "clang/Basic/TokenKinds.def"
     default:
       // All other tokens (punctuation etc) are not JS identifiers.
       return false;
     }
   }
 
   /// Returns \c true if \p Tok is a C# keyword, returns
   /// \c false if it is a anything else.
-  bool isCSharpKeyword(const FormatToken &Tok) const {
+  bool isCSharpKeyword(FormatToken const &Tok) const {
     switch (Tok.Tok.getKind()) {
     case tok::kw_bool:
     case tok::kw_break:
     case tok::kw_case:
     case tok::kw_catch:
     case tok::kw_char:
     case tok::kw_class:
     case tok::kw_const:

clang/lib/Format/FormatToken.cpp

 #include "ContinuationIndenter.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Debug.h"
 #include <climits>
 
 namespace clang {
 namespace format {
 
-const char *getTokenTypeName(TokenType Type) {
-  static const char *const TokNames[] = {
+char const *getTokenTypeName(TokenType Type) {
+  static char const *const TokNames[] = {
 #define TYPE(X) #X,
       LIST_TOKEN_TYPES
 #undef TYPE
       nullptr};
 
   if (Type < NUM_TOKEN_TYPES)
     return TokNames[Type];
   llvm_unreachable("unknown TokenType");
case tok::kw__Atomic:
     return true;
   default:
     return false;
   }
 }
 
 TokenRole::~TokenRole() {}
 
-void TokenRole::precomputeFormattingInfos(const FormatToken *Token) {}
+void TokenRole::precomputeFormattingInfos(FormatToken const *Token) {}
 
 unsigned CommaSeparatedList::formatAfterToken(LineState &State,
                                               ContinuationIndenter *Indenter,
                                               bool DryRun) {
   if (State.NextToken == nullptr || !State.NextToken->Previous)
     return 0;
 
   if (Formats.size() == 1)
     return 0; // Handled by formatFromToken
 
   // Ensure that we start on the opening brace.
-  const FormatToken *LBrace =
+  FormatToken const *LBrace =
       State.NextToken->Previous->getPreviousNonComment();
   if (!LBrace || !LBrace->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) ||
       LBrace->is(BK_Block) || LBrace->is(TT_DictLiteral) ||
       LBrace->Next->is(TT_DesignatedInitializerPeriod))
     return 0;
 
   // Calculate the number of code points we have to format this list. As the
   // first token is already placed, we have to subtract it.
   unsigned RemainingCodePoints =
       Style.ColumnLimit - State.Column + State.NextToken->Previous->ColumnWidth;
 
   // Find the best ColumnFormat, i.e. the best number of columns to use.
-  const ColumnFormat *Format = getColumnFormat(RemainingCodePoints);
+  ColumnFormat const *Format = getColumnFormat(RemainingCodePoints);
 
   // If no ColumnFormat can be used, the braced list would generally be
   // bin-packed. Add a severe penalty to this so that column layouts are
   // preferred if possible.
   if (!Format)
     return 10000;
 
   // Format the entire list.
unsigned CommaSeparatedList::formatFromToken(LineState &State,
   // special logic here. We can just avoid bin packing any of the parameters.
   if (Formats.size() == 1 || HasNestedBracedList)
     State.Stack.back().AvoidBinPacking = true;
   return 0;
 }
 
 // Returns the lengths in code points between Begin and End (both included),
 // assuming that the entire sequence is put on a single line.
-static unsigned CodePointsBetween(const FormatToken *Begin,
-                                  const FormatToken *End) {
+static unsigned CodePointsBetween(FormatToken const *Begin,
+                                  FormatToken const *End) {
   assert(End->TotalLength >= Begin->TotalLength);
   return End->TotalLength - Begin->TotalLength + Begin->ColumnWidth;
 }
 
-void CommaSeparatedList::precomputeFormattingInfos(const FormatToken *Token) {
+void CommaSeparatedList::precomputeFormattingInfos(FormatToken const *Token) {
   // FIXME: At some point we might want to do this for other lists, too.
   if (!Token->MatchingParen ||
       !Token->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare))
     return;
 
   // In C++11 braced list style, we should not format in columns unless they
   // have many items (20 or more) or we allow bin-packing of function call
   // arguments.
for (unsigned i = 0, e = Commas.size() + 1; i != e; ++i) {
     while (ItemBegin->HasUnescapedNewline && ItemBegin->isTrailingComment()) {
       ItemBegin = ItemBegin->Next;
       HasSeparatingComment = i > 0;
     }
 
     MustBreakBeforeItem.push_back(ItemBegin->MustBreakBefore);
     if (ItemBegin->is(tok::l_brace))
       HasNestedBracedList = true;
-    const FormatToken *ItemEnd = nullptr;
+    FormatToken const *ItemEnd = nullptr;
     if (i == Commas.size()) {
       ItemEnd = Token->MatchingParen;
-      const FormatToken *NonCommentEnd = ItemEnd->getPreviousNonComment();
+      FormatToken const *NonCommentEnd = ItemEnd->getPreviousNonComment();
       ItemLengths.push_back(CodePointsBetween(ItemBegin, NonCommentEnd));
       if (Style.Cpp11BracedListStyle &&
           !ItemEnd->Previous->isTrailingComment()) {
         // In Cpp11 braced list style, the } and possibly other subsequent
         // tokens will need to stay on a line with the last element.
         while (ItemEnd->Next && !ItemEnd->Next->CanBreakBefore)
           ItemEnd = ItemEnd->Next;
       } else {
for (unsigned Columns = 1; Columns <= MaxItems; ++Columns) {
     // Ignore layouts that are bound to violate the column limit.
     if (Format.TotalWidth > Style.ColumnLimit && Columns > 1)
       continue;
 
     Formats.push_back(Format);
   }
 }
 
-const CommaSeparatedList::ColumnFormat *
+CommaSeparatedList::ColumnFormat const *
 CommaSeparatedList::getColumnFormat(unsigned RemainingCharacters) const {
-  const ColumnFormat *BestFormat = nullptr;
+  ColumnFormat const *BestFormat = nullptr;
   for (SmallVector<ColumnFormat, 4>::const_reverse_iterator
            I = Formats.rbegin(),
            E = Formats.rend();
        I != E; ++I) {
     if (I->TotalWidth <= RemainingCharacters || I->Columns == 1) {
       if (BestFormat && I->LineCount > BestFormat->LineCount)
         break;
       BestFormat = &*I;
     }
   }
   return BestFormat;
 }
 
 } // namespace format
 } // namespace clang

clang/lib/Format/FormatTokenLexer.h

 enum LexerState {
   NORMAL,
   TEMPLATE_STRING,
   TOKEN_STASHED,
 };
 
 class FormatTokenLexer {
 public:
-  FormatTokenLexer(const SourceManager &SourceMgr, FileID ID, unsigned Column,
-                   const FormatStyle &Style, encoding::Encoding Encoding,
+  FormatTokenLexer(SourceManager const &SourceMgr, FileID ID, unsigned Column,
+                   FormatStyle const &Style, encoding::Encoding Encoding,
                    llvm::SpecificBumpPtrAllocator<FormatToken> &Allocator,
                    IdentifierTable &IdentTable);
 
   ArrayRef<FormatToken *> lex();
 
-  const AdditionalKeywords &getKeywords() { return Keywords; }
+  AdditionalKeywords const &getKeywords() { return Keywords; }
 
 private:
   void tryMergePreviousTokens();
 
   bool tryMergeLessLess();
   bool tryMergeNSStringLiteral();
   bool tryMergeJSPrivateIdentifier();
   bool tryMergeCSharpStringLiteral();
private:
   FormatToken *getNextToken();
 
   FormatToken *FormatTok;
   bool IsFirstToken;
   std::stack<LexerState> StateStack;
   unsigned Column;
   unsigned TrailingWhitespace;
   std::unique_ptr<Lexer> Lex;
-  const SourceManager &SourceMgr;
+  SourceManager const &SourceMgr;
   FileID ID;
-  const FormatStyle &Style;
+  FormatStyle const &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;
   SmallVector<FormatToken *, 16> Tokens;
 

clang/lib/Format/FormatTokenLexer.cpp

 #include "clang/Basic/SourceManager.h"
 #include "clang/Format/Format.h"
 #include "llvm/Support/Regex.h"
 
 namespace clang {
 namespace format {
 
 FormatTokenLexer::FormatTokenLexer(
-    const SourceManager &SourceMgr, FileID ID, unsigned Column,
-    const FormatStyle &Style, encoding::Encoding Encoding,
+    SourceManager const &SourceMgr, FileID ID, unsigned Column,
+    FormatStyle const &Style, encoding::Encoding Encoding,
     llvm::SpecificBumpPtrAllocator<FormatToken> &Allocator,
     IdentifierTable &IdentTable)
     : FormatTok(nullptr), IsFirstToken(true), StateStack({LexerState::NORMAL}),
       Column(Column), TrailingWhitespace(0), SourceMgr(SourceMgr), ID(ID),
       Style(Style), IdentTable(IdentTable), Keywords(IdentTable),
       Encoding(Encoding), Allocator(Allocator), FirstInLineIndex(0),
       FormattingDisabled(false), MacroBlockBeginRegex(Style.MacroBlockBegin),
       MacroBlockEndRegex(Style.MacroBlockEnd) {
   Lex.reset(new Lexer(ID, SourceMgr.getBufferOrFake(ID), SourceMgr,
                       getFormattingLangOpts(Style)));
   Lex->SetKeepWhitespaceMode(true);
 
-  for (const std::string &ForEachMacro : Style.ForEachMacros)
+  for (std::string const &ForEachMacro : Style.ForEachMacros)
     Macros.insert({&IdentTable.get(ForEachMacro), TT_ForEachMacro});
-  for (const std::string &IfMacro : Style.IfMacros)
+  for (std::string const &IfMacro : Style.IfMacros)
     Macros.insert({&IdentTable.get(IfMacro), TT_IfMacro});
-  for (const std::string &AttributeMacro : Style.AttributeMacros)
+  for (std::string const &AttributeMacro : Style.AttributeMacros)
     Macros.insert({&IdentTable.get(AttributeMacro), TT_AttributeMacro});
-  for (const std::string &StatementMacro : Style.StatementMacros)
+  for (std::string const &StatementMacro : Style.StatementMacros)
     Macros.insert({&IdentTable.get(StatementMacro), TT_StatementMacro});
-  for (const std::string &TypenameMacro : Style.TypenameMacros)
+  for (std::string const &TypenameMacro : Style.TypenameMacros)
     Macros.insert({&IdentTable.get(TypenameMacro), TT_TypenameMacro});
-  for (const std::string &NamespaceMacro : Style.NamespaceMacros)
+  for (std::string const &NamespaceMacro : Style.NamespaceMacros)
     Macros.insert({&IdentTable.get(NamespaceMacro), TT_NamespaceMacro});
-  for (const std::string &WhitespaceSensitiveMacro :
+  for (std::string const &WhitespaceSensitiveMacro :
        Style.WhitespaceSensitiveMacros) {
     Macros.insert(
         {&IdentTable.get(WhitespaceSensitiveMacro), TT_UntouchableMacroFunc});
   }
-  for (const std::string &StatementAttributeLikeMacro :
+  for (std::string const &StatementAttributeLikeMacro :
        Style.StatementAttributeLikeMacros)
     Macros.insert({&IdentTable.get(StatementAttributeLikeMacro),
                    TT_StatementAttributeLikeMacro});
 }
 
 ArrayRef<FormatToken *> FormatTokenLexer::lex() {
   assert(Tokens.empty());
   assert(FirstInLineIndex == 0);
if ((*I)->isNot(tok::comment)) {
       break;
     }
   }
 
   if (!canPrecedeRegexLiteral(Prev))
     return;
 
   // 'Manually' lex ahead in the current file buffer.
-  const char *Offset = Lex->getBufferLocation();
-  const char *RegexBegin = Offset - RegexToken->TokenText.size();
+  char const *Offset = Lex->getBufferLocation();
+  char const *RegexBegin = Offset - RegexToken->TokenText.size();
   StringRef Buffer = Lex->getBuffer();
   bool InCharacterClass = false;
   bool HaveClosingSlash = false;
   for (; !HaveClosingSlash && Offset != Buffer.end(); ++Offset) {
     // Regular expressions are terminated with a '/', which can only be
     // escaped using '\' or a character class between '[' and ']'.
     // See http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.5.
     switch (*Offset) {
void FormatTokenLexer::handleCSharpVerbatimAndInterpolatedStrings() {
   if (CSharpStringLiteral->getType() != TT_CSharpStringLiteral)
     return;
 
   // Deal with multiline strings.
   if (!(CSharpStringLiteral->TokenText.startswith(R"(@")") ||
         CSharpStringLiteral->TokenText.startswith(R"($@")")))
     return;
 
-  const char *StrBegin =
+  char const *StrBegin =
       Lex->getBufferLocation() - CSharpStringLiteral->TokenText.size();
-  const char *Offset = StrBegin;
+  char const *Offset = StrBegin;
   if (CSharpStringLiteral->TokenText.startswith(R"(@")"))
     Offset += 2;
   else // CSharpStringLiteral->TokenText.startswith(R"($@")")
     Offset += 3;
 
   // Look for a terminating '"' in the current file buffer.
   // Make no effort to format code within an interpolated or verbatim string.
   for (; Offset != Lex->getBuffer().end(); ++Offset) {
void FormatTokenLexer::handleTemplateStrings() {
   } else if (BacktickToken->is(tok::unknown) &&
              BacktickToken->TokenText == "`") {
     StateStack.push(LexerState::TEMPLATE_STRING);
   } else {
     return; // Not actually a template
   }
 
   // 'Manually' lex ahead in the current file buffer.
-  const char *Offset = Lex->getBufferLocation();
-  const char *TmplBegin = Offset - BacktickToken->TokenText.size(); // at "`"
+  char const *Offset = Lex->getBufferLocation();
+  char const *TmplBegin = Offset - BacktickToken->TokenText.size(); // at "`"
   for (; Offset != Lex->getBuffer().end(); ++Offset) {
     if (Offset[0] == '`') {
       StateStack.pop();
       break;
     }
     if (Offset[0] == '\\') {
       ++Offset; // Skip the escaped character.
     } else if (Offset + 1 < Lex->getBuffer().end() && Offset[0] == '$' &&
void FormatTokenLexer::handleTemplateStrings() {
   resetLexer(SourceMgr.getFileOffset(loc));
 }
 
 void FormatTokenLexer::tryParsePythonComment() {
   FormatToken *HashToken = Tokens.back();
   if (!HashToken->isOneOf(tok::hash, tok::hashhash))
     return;
   // Turn the remainder of this line into a comment.
-  const char *CommentBegin =
+  char const *CommentBegin =
       Lex->getBufferLocation() - HashToken->TokenText.size(); // at "#"
   size_t From = CommentBegin - Lex->getBuffer().begin();
   size_t To = Lex->getBuffer().find_first_of('\n', From);
   if (To == StringRef::npos)
     To = Lex->getBuffer().size();
   size_t Len = To - From;
   HashToken->setType(TT_LineComment);
   HashToken->Tok.setKind(tok::comment);
bool FormatTokenLexer::tryMerge_TMacro() {
 
   if (!Tokens[Tokens.size() - 3]->is(tok::l_paren))
     return false;
 
   FormatToken *Macro = Tokens[Tokens.size() - 4];
   if (Macro->TokenText != "_T")
     return false;
 
-  const char *Start = Macro->TokenText.data();
-  const char *End = Last->TokenText.data() + Last->TokenText.size();
+  char const *Start = Macro->TokenText.data();
+  char const *End = Last->TokenText.data() + Last->TokenText.size();
   String->TokenText = StringRef(Start, End - Start);
   String->IsFirst = Macro->IsFirst;
   String->LastNewlineOffset = Macro->LastNewlineOffset;
   String->WhitespaceRange = Macro->WhitespaceRange;
   String->OriginalColumn = Macro->OriginalColumn;
   String->ColumnWidth = encoding::columnWidthWithTabs(
       String->TokenText, String->OriginalColumn, Style.TabWidth, Encoding);
   String->NewlinesBefore = Macro->NewlinesBefore;
FormatToken *FormatTokenLexer::getNextToken() {
   // the backslash.
   if ((Style.Language == FormatStyle::LK_JavaScript ||
        Style.Language == FormatStyle::LK_Java) &&
       FormatTok->is(tok::comment) && FormatTok->TokenText.startswith("//")) {
     size_t BackslashPos = FormatTok->TokenText.find('\\');
     while (BackslashPos != StringRef::npos) {
       if (BackslashPos + 1 < FormatTok->TokenText.size() &&
           FormatTok->TokenText[BackslashPos + 1] == '\n') {
-        const char *Offset = Lex->getBufferLocation();
+        char const *Offset = Lex->getBufferLocation();
         Offset -= FormatTok->TokenText.size();
         Offset += BackslashPos + 1;
         resetLexer(SourceMgr.getFileOffset(Lex->getSourceLocation(Offset)));
         FormatTok->TokenText = FormatTok->TokenText.substr(0, BackslashPos + 1);
         FormatTok->ColumnWidth = encoding::columnWidthWithTabs(
             FormatTok->TokenText, FormatTok->OriginalColumn, Style.TabWidth,
             Encoding);
         break;

clang/lib/Format/MacroExpander.cpp

private:
 
   size_t Pos = 0;
   FormatToken *Current = nullptr;
   Definition Def;
   ArrayRef<FormatToken *> Tokens;
 };
 
 MacroExpander::MacroExpander(
-    const std::vector<std::string> &Macros, clang::SourceManager &SourceMgr,
-    const FormatStyle &Style,
+    std::vector<std::string> const &Macros, clang::SourceManager &SourceMgr,
+    FormatStyle const &Style,
     llvm::SpecificBumpPtrAllocator<FormatToken> &Allocator,
     IdentifierTable &IdentTable)
     : SourceMgr(SourceMgr), Style(Style), Allocator(Allocator),
       IdentTable(IdentTable) {
-  for (const std::string &Macro : Macros) {
+  for (std::string const &Macro : Macros) {
     parseDefinition(Macro);
   }
 }
 
 MacroExpander::~MacroExpander() = default;
 
-void MacroExpander::parseDefinition(const std::string &Macro) {
+void MacroExpander::parseDefinition(std::string const &Macro) {
   Buffers.push_back(
       llvm::MemoryBuffer::getMemBufferCopy(Macro, "<scratch space>"));
   clang::FileID FID = SourceMgr.createFileID(Buffers.back()->getMemBufferRef());
   FormatTokenLexer Lex(SourceMgr, FID, 0, Style, encoding::Encoding_UTF8,
                        Allocator, IdentTable);
-  const auto Tokens = Lex.lex();
+  auto const Tokens = Lex.lex();
   if (!Tokens.empty()) {
     DefinitionParser Parser(Tokens);
     auto Definition = Parser.parse();
     Definitions[Definition.Name] = std::move(Definition);
   }
 }
 
 bool MacroExpander::defined(llvm::StringRef Name) const {
   return Definitions.find(Name) != Definitions.end();
 }
 
 bool MacroExpander::objectLike(llvm::StringRef Name) const {
   return Definitions.find(Name)->second.ObjectLike;
 }
 
 llvm::SmallVector<FormatToken *, 8> MacroExpander::expand(FormatToken *ID,
                                                           ArgsList Args) const {
   assert(defined(ID->TokenText));
   SmallVector<FormatToken *, 8> Result;
-  const Definition &Def = Definitions.find(ID->TokenText)->second;
+  Definition const &Def = Definitions.find(ID->TokenText)->second;
 
   // Expand each argument at most once.
   llvm::StringSet<> ExpandedArgs;
 
   // Adds the given token to Result.
   auto pushToken = [&](FormatToken *Tok) {
     Tok->MacroCtx->ExpandedFrom.push_back(ID);
     Result.push_back(Tok);

clang/lib/Format/Macros.h

public:
   /// <definition> ::= <id> <expansion> | <id> "(" <params> ")" <expansion>
   /// <params>     ::= <id-list> | ""
   /// <id-list>    ::= <id> | <id> "," <params>
   /// <expansion>  ::= "=" <tail> | <eof>
   /// <tail>       ::= <tok> <tail> | <eof>
   ///
   /// Macros that cannot be parsed will be silently discarded.
   ///
-  MacroExpander(const std::vector<std::string> &Macros,
-                clang::SourceManager &SourceMgr, const FormatStyle &Style,
+  MacroExpander(std::vector<std::string> const &Macros,
+                clang::SourceManager &SourceMgr, FormatStyle const &Style,
                 llvm::SpecificBumpPtrAllocator<FormatToken> &Allocator,
                 IdentifierTable &IdentTable);
   ~MacroExpander();
 
   /// Returns whether a macro \p Name is defined.
   bool defined(llvm::StringRef Name) const;
 
   /// Returns whether the macro has no arguments and should not consume
   /// subsequent parentheses.
   bool objectLike(llvm::StringRef Name) const;
 
   /// Returns the expanded stream of format tokens for \p ID, where
   /// each element in \p Args is a positional argument to the macro call.
   llvm::SmallVector<FormatToken *, 8> expand(FormatToken *ID,
                                              ArgsList Args) const;
 
 private:
   struct Definition;
   class DefinitionParser;
 
-  void parseDefinition(const std::string &Macro);
+  void parseDefinition(std::string const &Macro);
 
   clang::SourceManager &SourceMgr;
-  const FormatStyle &Style;
+  FormatStyle const &Style;
   llvm::SpecificBumpPtrAllocator<FormatToken> &Allocator;
   IdentifierTable &IdentTable;
   std::vector<std::unique_ptr<llvm::MemoryBuffer>> Buffers;
   llvm::StringMap<Definition> Definitions;
 };
 
 } // namespace format
 } // namespace clang
 
 #endif

clang/lib/Format/NamespaceEndCommentsFixer.h

 namespace format {
 
 // Finds the namespace token corresponding to a closing namespace `}`, if that
 // is to be formatted.
 // If \p Line contains the closing `}` of a namespace, is affected and is not in
 // a preprocessor directive, the result will be the matching namespace token.
 // Otherwise returns null.
 // \p AnnotatedLines is the sequence of lines from which \p Line is a member of.
-const FormatToken *
-getNamespaceToken(const AnnotatedLine *Line,
-                  const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines);
+FormatToken const *
+getNamespaceToken(AnnotatedLine const *Line,
+                  SmallVectorImpl<AnnotatedLine *> const &AnnotatedLines);
 
 class NamespaceEndCommentsFixer : public TokenAnalyzer {
 public:
-  NamespaceEndCommentsFixer(const Environment &Env, const FormatStyle &Style);
+  NamespaceEndCommentsFixer(Environment const &Env, FormatStyle const &Style);
 
   std::pair<tooling::Replacements, unsigned>
   analyze(TokenAnnotator &Annotator,
           SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
           FormatTokenLexer &Tokens) override;
 };
 
 } // end namespace format
 } // end namespace clang
 
 #endif

clang/lib/Format/NamespaceEndCommentsFixer.cpp

 #define DEBUG_TYPE "namespace-end-comments-fixer"
 
 namespace clang {
 namespace format {
 
 namespace {
 // Computes the name of a namespace given the namespace token.
 // Returns "" for anonymous namespace.
-std::string computeName(const FormatToken *NamespaceTok) {
+std::string computeName(FormatToken const *NamespaceTok) {
   assert(NamespaceTok &&
          NamespaceTok->isOneOf(tok::kw_namespace, TT_NamespaceMacro) &&
          "expecting a namespace token");
   std::string name = "";
-  const FormatToken *Tok = NamespaceTok->getNextNonComment();
+  FormatToken const *Tok = NamespaceTok->getNextNonComment();
   if (NamespaceTok->is(TT_NamespaceMacro)) {
     // Collects all the non-comment tokens between opening parenthesis
     // and closing parenthesis or comma.
     assert(Tok && Tok->is(tok::l_paren) && "expected an opening parenthesis");
     Tok = Tok->getNextNonComment();
     while (Tok && !Tok->isOneOf(tok::r_paren, tok::comma)) {
       name += Tok->TokenText;
       Tok = Tok->getNextNonComment();
     }
   } else {
     // For `namespace [[foo]] A::B::inline C {` or
     // `namespace MACRO1 MACRO2 A::B::inline C {`, returns "A::B::inline C".
     // Peek for the first '::' (or '{') and then return all tokens from one
     // token before that up until the '{'.
-    const FormatToken *FirstNSTok = Tok;
+    FormatToken const *FirstNSTok = Tok;
     while (Tok && !Tok->is(tok::l_brace) && !Tok->is(tok::coloncolon)) {
       FirstNSTok = Tok;
       Tok = Tok->getNextNonComment();
     }
 
     Tok = FirstNSTok;
     while (Tok && !Tok->is(tok::l_brace)) {
       name += Tok->TokenText;
       if (Tok->is(tok::kw_inline))
         name += " ";
       Tok = Tok->getNextNonComment();
     }
   }
   return name;
 }
 
 std::string computeEndCommentText(StringRef NamespaceName, bool AddNewline,
-                                  const FormatToken *NamespaceTok,
+                                  FormatToken const *NamespaceTok,
                                   unsigned SpacesToAdd) {
   std::string text = "//";
   text.append(SpacesToAdd, ' ');
   text += NamespaceTok->TokenText;
   if (NamespaceTok->is(TT_NamespaceMacro))
     text += "(";
   else if (!NamespaceName.empty())
     text += ' ';
   text += NamespaceName;
   if (NamespaceTok->is(TT_NamespaceMacro))
     text += ")";
   if (AddNewline)
     text += '\n';
   return text;
 }
 
-bool hasEndComment(const FormatToken *RBraceTok) {
+bool hasEndComment(FormatToken const *RBraceTok) {
   return RBraceTok->Next && RBraceTok->Next->is(tok::comment);
 }
 
-bool validEndComment(const FormatToken *RBraceTok, StringRef NamespaceName,
-                     const FormatToken *NamespaceTok) {
+bool validEndComment(FormatToken const *RBraceTok, StringRef NamespaceName,
+                     FormatToken const *NamespaceTok) {
   assert(hasEndComment(RBraceTok));
-  const FormatToken *Comment = RBraceTok->Next;
+  FormatToken const *Comment = RBraceTok->Next;
 
   // Matches a valid namespace end comment.
   // Valid namespace end comments don't need to be edited.
   static const llvm::Regex NamespaceCommentPattern =
       llvm::Regex("^/[/*] *(end (of )?)? *(anonymous|unnamed)? *"
                   "namespace( +([a-zA-Z0-9:_]+))?\\.? *(\\*/)?$",
                   llvm::Regex::IgnoreCase);
   static const llvm::Regex NamespaceMacroCommentPattern =
bool validEndComment(FormatToken const *RBraceTok, StringRef NamespaceName,
   if (!CommentPattern.match(Comment->Next->TokenText, &Groups)) {
     return false;
   }
   NamespaceNameInComment = Groups.size() > 2 ? Groups[2] : "";
 
   return (NamespaceNameInComment == NamespaceName);
 }
 
-void addEndComment(const FormatToken *RBraceTok, StringRef EndCommentText,
-                   const SourceManager &SourceMgr,
+void addEndComment(FormatToken const *RBraceTok, StringRef EndCommentText,
+                   SourceManager const &SourceMgr,
                    tooling::Replacements *Fixes) {
   auto EndLoc = RBraceTok->Tok.getEndLoc();
   auto Range = CharSourceRange::getCharRange(EndLoc, EndLoc);
   auto Err = Fixes->add(tooling::Replacement(SourceMgr, Range, EndCommentText));
   if (Err) {
     llvm::errs() << "Error while adding namespace end comment: "
                  << llvm::toString(std::move(Err)) << "\n";
   }
 }
 
-void updateEndComment(const FormatToken *RBraceTok, StringRef EndCommentText,
-                      const SourceManager &SourceMgr,
+void updateEndComment(FormatToken const *RBraceTok, StringRef EndCommentText,
+                      SourceManager const &SourceMgr,
                       tooling::Replacements *Fixes) {
   assert(hasEndComment(RBraceTok));
-  const FormatToken *Comment = RBraceTok->Next;
+  FormatToken const *Comment = RBraceTok->Next;
   auto Range = CharSourceRange::getCharRange(Comment->getStartOfNonWhitespace(),
                                              Comment->Tok.getEndLoc());
   auto Err = Fixes->add(tooling::Replacement(SourceMgr, Range, EndCommentText));
   if (Err) {
     llvm::errs() << "Error while updating namespace end comment: "
                  << llvm::toString(std::move(Err)) << "\n";
   }
 }
 } // namespace
 
-const FormatToken *
-getNamespaceToken(const AnnotatedLine *Line,
-                  const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
+FormatToken const *
+getNamespaceToken(AnnotatedLine const *Line,
+                  SmallVectorImpl<AnnotatedLine *> const &AnnotatedLines) {
   if (!Line->Affected || Line->InPPDirective || !Line->startsWith(tok::r_brace))
     return nullptr;
   size_t StartLineIndex = Line->MatchingOpeningBlockLineIndex;
   if (StartLineIndex == UnwrappedLine::kInvalidIndex)
     return nullptr;
   assert(StartLineIndex < AnnotatedLines.size());
-  const FormatToken *NamespaceTok = AnnotatedLines[StartLineIndex]->First;
+  FormatToken const *NamespaceTok = AnnotatedLines[StartLineIndex]->First;
   if (NamespaceTok->is(tok::l_brace)) {
     // "namespace" keyword can be on the line preceding '{', e.g. in styles
     // where BraceWrapping.AfterNamespace is true.
     if (StartLineIndex > 0)
       NamespaceTok = AnnotatedLines[StartLineIndex - 1]->First;
   }
   return NamespaceTok->getNamespaceToken();
 }
 
 StringRef
-getNamespaceTokenText(const AnnotatedLine *Line,
-                      const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
-  const FormatToken *NamespaceTok = getNamespaceToken(Line, AnnotatedLines);
+getNamespaceTokenText(AnnotatedLine const *Line,
+                      SmallVectorImpl<AnnotatedLine *> const &AnnotatedLines) {
+  FormatToken const *NamespaceTok = getNamespaceToken(Line, AnnotatedLines);
   return NamespaceTok ? NamespaceTok->TokenText : StringRef();
 }
 
-NamespaceEndCommentsFixer::NamespaceEndCommentsFixer(const Environment &Env,
-                                                     const FormatStyle &Style)
+NamespaceEndCommentsFixer::NamespaceEndCommentsFixer(Environment const &Env,
+                                                     FormatStyle const &Style)
     : TokenAnalyzer(Env, Style) {}
 
 std::pair<tooling::Replacements, unsigned> NamespaceEndCommentsFixer::analyze(
     TokenAnnotator &Annotator, SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
     FormatTokenLexer &Tokens) {
-  const SourceManager &SourceMgr = Env.getSourceManager();
+  SourceManager const &SourceMgr = Env.getSourceManager();
   AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
   tooling::Replacements Fixes;
 
   // Spin through the lines and ensure we have balanced braces.
   int Braces = 0;
   for (size_t I = 0, E = AnnotatedLines.size(); I != E; ++I) {
     FormatToken *Tok = AnnotatedLines[I]->First;
     while (Tok) {
       Braces += Tok->is(tok::l_brace) ? 1 : Tok->is(tok::r_brace) ? -1 : 0;
       Tok = Tok->Next;
     }
   }
   // Don't attempt to comment unbalanced braces or this can
   // lead to comments being placed on the closing brace which isn't
   // the matching brace of the namespace. (occurs during incomplete editing).
   if (Braces != 0) {
     return {Fixes, 0};
   }
 
   std::string AllNamespaceNames = "";
   size_t StartLineIndex = SIZE_MAX;
   StringRef NamespaceTokenText;
   unsigned int CompactedNamespacesCount = 0;
   for (size_t I = 0, E = AnnotatedLines.size(); I != E; ++I) {
-    const AnnotatedLine *EndLine = AnnotatedLines[I];
-    const FormatToken *NamespaceTok =
+    AnnotatedLine const *EndLine = AnnotatedLines[I];
+    FormatToken const *NamespaceTok =
         getNamespaceToken(EndLine, AnnotatedLines);
     if (!NamespaceTok)
       continue;
     FormatToken *RBraceTok = EndLine->First;
     if (RBraceTok->Finalized)
       continue;
     RBraceTok->Finalized = true;
-    const FormatToken *EndCommentPrevTok = RBraceTok;
+    FormatToken const *EndCommentPrevTok = RBraceTok;
     // Namespaces often end with '};'. In that case, attach namespace end
     // comments to the semicolon tokens.
     if (RBraceTok->Next && RBraceTok->Next->is(tok::semi)) {
       EndCommentPrevTok = RBraceTok->Next;
     }
     if (StartLineIndex == SIZE_MAX)
       StartLineIndex = EndLine->MatchingOpeningBlockLineIndex;
     std::string NamespaceName = computeName(NamespaceTok);
if (Style.CompactNamespaces) {
       }
       NamespaceName += AllNamespaceNames;
       CompactedNamespacesCount = 0;
       AllNamespaceNames = std::string();
     }
     // The next token in the token stream after the place where the end comment
     // token must be. This is either the next token on the current line or the
     // first token on the next line.
-    const FormatToken *EndCommentNextTok = EndCommentPrevTok->Next;
+    FormatToken const *EndCommentNextTok = EndCommentPrevTok->Next;
     if (EndCommentNextTok && EndCommentNextTok->is(tok::comment))
       EndCommentNextTok = EndCommentNextTok->Next;
     if (!EndCommentNextTok && I + 1 < E)
       EndCommentNextTok = AnnotatedLines[I + 1]->First;
     bool AddNewline = EndCommentNextTok &&
                       EndCommentNextTok->NewlinesBefore == 0 &&
                       EndCommentNextTok->isNot(tok::eof);
     const std::string EndCommentText =

clang/lib/Format/SortJavaScriptImports.h

 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace clang {
 namespace format {
 
 // Sort JavaScript ES6 imports/exports in ``Code``. The generated replacements
 // only monotonically increase the length of the given code.
-tooling::Replacements sortJavaScriptImports(const FormatStyle &Style,
+tooling::Replacements sortJavaScriptImports(FormatStyle const &Style,
                                             StringRef Code,
                                             ArrayRef<tooling::Range> Ranges,
                                             StringRef FileName);
 
 } // end namespace format
 } // end namespace clang
 
 #endif

clang/lib/Format/SortJavaScriptImports.cpp

 using clang::format::FormatStyle;
 
 // An imported symbol in a JavaScript ES6 import/export, possibly aliased.
 struct JsImportedSymbol {
   StringRef Symbol;
   StringRef Alias;
   SourceRange Range;
 
-  bool operator==(const JsImportedSymbol &RHS) const {
+  bool operator==(JsImportedSymbol const &RHS) const {
     // Ignore Range for comparison, it is only used to stitch code together,
     // but imports at different code locations are still conceptually the same.
     return Symbol == RHS.Symbol && Alias == RHS.Alias;
   }
 };
 
 // An ES6 module reference.
 //
struct JsModuleReference {
   // The source location just after { and just before } in the import.
   // Extracted eagerly to allow modification of Symbols later on.
   SourceLocation SymbolsStart, SymbolsEnd;
   // Textual position of the import/export, including preceding and trailing
   // comments.
   SourceRange Range;
 };
 
-bool operator<(const JsModuleReference &LHS, const JsModuleReference &RHS) {
+bool operator<(JsModuleReference const &LHS, JsModuleReference const &RHS) {
   if (LHS.IsExport != RHS.IsExport)
     return LHS.IsExport < RHS.IsExport;
   if (LHS.Category != RHS.Category)
     return LHS.Category < RHS.Category;
   if (LHS.Category == JsModuleReference::ReferenceCategory::SIDE_EFFECT)
     // Side effect imports might be ordering sensitive. Consider them equal so
     // that they maintain their relative order in the stable sort below.
     // This retains transitivity because LHS.Category == RHS.Category here.
bool operator<(JsModuleReference const &LHS, JsModuleReference const &RHS) {
   return false;
 }
 
 // JavaScriptImportSorter sorts JavaScript ES6 imports and exports. It is
 // implemented as a TokenAnalyzer because ES6 imports have substantial syntactic
 // structure, making it messy to sort them using regular expressions.
 class JavaScriptImportSorter : public TokenAnalyzer {
 public:
-  JavaScriptImportSorter(const Environment &Env, const FormatStyle &Style)
+  JavaScriptImportSorter(Environment const &Env, FormatStyle const &Style)
       : TokenAnalyzer(Env, Style),
         FileContents(Env.getSourceManager().getBufferData(Env.getFileID())) {}
 
   std::pair<tooling::Replacements, unsigned>
   analyze(TokenAnnotator &Annotator,
           SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
           FormatTokenLexer &Tokens) override {
     tooling::Replacements Result;
     AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
 
-    const AdditionalKeywords &Keywords = Tokens.getKeywords();
+    AdditionalKeywords const &Keywords = Tokens.getKeywords();
     SmallVector<JsModuleReference, 16> References;
     AnnotatedLine *FirstNonImportLine;
     std::tie(References, FirstNonImportLine) =
         parseModuleReferences(Keywords, AnnotatedLines);
 
     if (References.empty())
       return {Result, 0};
 
void nextToken() {
     }
   }
 
   StringRef getSourceText(SourceRange Range) {
     return getSourceText(Range.getBegin(), Range.getEnd());
   }
 
   StringRef getSourceText(SourceLocation Begin, SourceLocation End) {
-    const SourceManager &SM = Env.getSourceManager();
+    SourceManager const &SM = Env.getSourceManager();
     return FileContents.substr(SM.getFileOffset(Begin),
                                SM.getFileOffset(End) - SM.getFileOffset(Begin));
   }
 
   // Sorts the given module references.
   // Imports can have formatting disabled (FormattingOff), so the code below
   // skips runs of "no-formatting" module references, and sorts/merges the
   // references that have formatting enabled in individual chunks.
   SmallVector<JsModuleReference, 16>
-  sortModuleReferences(const SmallVector<JsModuleReference, 16> &References) {
+  sortModuleReferences(SmallVector<JsModuleReference, 16> const &References) {
     // Sort module references.
     // Imports can have formatting disabled (FormattingOff), so the code below
     // skips runs of "no-formatting" module references, and sorts other
     // references per group.
-    const auto *Start = References.begin();
+    auto const *Start = References.begin();
     SmallVector<JsModuleReference, 16> ReferencesSorted;
     while (Start != References.end()) {
       while (Start != References.end() && Start->FormattingOff) {
         // Skip over all imports w/ disabled formatting.
         ReferencesSorted.push_back(*Start);
         Start++;
       }
       SmallVector<JsModuleReference, 16> SortChunk;
if (Reference.FormattingOff) {
       Buffer +=
           getSourceText(Reference.Range.getBegin(), Reference.Range.getEnd());
       return;
     }
     // Sort the individual symbols within the import.
     // E.g. `import {b, a} from 'x';` -> `import {a, b} from 'x';`
     SmallVector<JsImportedSymbol, 1> Symbols = Reference.Symbols;
     llvm::stable_sort(
-        Symbols, [&](const JsImportedSymbol &LHS, const JsImportedSymbol &RHS) {
+        Symbols, [&](JsImportedSymbol const &LHS, JsImportedSymbol const &RHS) {
           return LHS.Symbol.compare_insensitive(RHS.Symbol) < 0;
         });
     if (!Reference.SymbolsMerged && Symbols == Reference.Symbols) {
       // Symbols didn't change, just emit the entire module reference.
       StringRef ReferenceStmt = getSourceText(Reference.Range);
       Buffer += ReferenceStmt;
       return;
     }
     // Stitch together the module reference start...
     Buffer += getSourceText(Reference.Range.getBegin(), Reference.SymbolsStart);
     // ... then the references in order ...
     for (auto I = Symbols.begin(), E = Symbols.end(); I != E; ++I) {
       if (I != Symbols.begin())
         Buffer += ",";
       Buffer += getSourceText(I->Range);
     }
     // ... followed by the module reference end.
     Buffer += getSourceText(Reference.SymbolsEnd, Reference.Range.getEnd());
   }
 
   // Parses module references in the given lines. Returns the module references,
   // and a pointer to the first "main code" line if that is adjacent to the
   // affected lines of module references, nullptr otherwise.
   std::pair<SmallVector<JsModuleReference, 16>, AnnotatedLine *>
-  parseModuleReferences(const AdditionalKeywords &Keywords,
+  parseModuleReferences(AdditionalKeywords const &Keywords,
                         SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
     SmallVector<JsModuleReference, 16> References;
     SourceLocation Start;
     AnnotatedLine *FirstNonImportLine = nullptr;
     bool AnyImportAffected = false;
     bool FormattingOff = false;
     for (auto *Line : AnnotatedLines) {
       Current = Line->First;
parseModuleReferences(AdditionalKeywords const &Keywords,
     if (!AnyImportAffected)
       References.clear();
     return std::make_pair(References, FirstNonImportLine);
   }
 
   // Parses a JavaScript/ECMAScript 6 module reference.
   // See http://www.ecma-international.org/ecma-262/6.0/#sec-scripts-and-modules
   // for grammar EBNF (production ModuleItem).
-  bool parseModuleReference(const AdditionalKeywords &Keywords,
+  bool parseModuleReference(AdditionalKeywords const &Keywords,
                             JsModuleReference &Reference) {
     if (!Current || !Current->isOneOf(Keywords.kw_import, tok::kw_export))
       return false;
     Reference.IsExport = Current->is(tok::kw_export);
 
     nextToken();
     if (Current->isStringLiteral() && !Reference.IsExport) {
       // "import 'side-effect';"
if (Current->is(Keywords.kw_from)) {
         Reference.Category = JsModuleReference::ReferenceCategory::ABSOLUTE;
     } else {
       // w/o URL groups with "empty".
       Reference.Category = JsModuleReference::ReferenceCategory::RELATIVE;
     }
     return true;
   }
 
-  bool parseModuleBindings(const AdditionalKeywords &Keywords,
+  bool parseModuleBindings(AdditionalKeywords const &Keywords,
                            JsModuleReference &Reference) {
     if (parseStarBinding(Keywords, Reference))
       return true;
     return parseNamedBindings(Keywords, Reference);
   }
 
-  bool parseStarBinding(const AdditionalKeywords &Keywords,
+  bool parseStarBinding(AdditionalKeywords const &Keywords,
                         JsModuleReference &Reference) {
     // * as prefix from '...';
     if (Current->isNot(tok::star))
       return false;
     nextToken();
     if (Current->isNot(Keywords.kw_as))
       return false;
     nextToken();
     if (Current->isNot(tok::identifier))
       return false;
     Reference.Prefix = Current->TokenText;
     nextToken();
     return true;
   }
 
-  bool parseNamedBindings(const AdditionalKeywords &Keywords,
+  bool parseNamedBindings(AdditionalKeywords const &Keywords,
                           JsModuleReference &Reference) {
     // eat a potential "import X, " prefix.
     if (Current->is(tok::identifier)) {
       Reference.DefaultImport = Current->TokenText;
       nextToken();
       if (Current->is(Keywords.kw_from))
         return true;
       if (Current->isNot(tok::comma))
bool parseNamedBindings(AdditionalKeywords const &Keywords,
     // comma to be the end of the import list, so that it doesn't get removed.
     if (Current->Previous->is(tok::comma))
       Reference.SymbolsEnd = Current->Previous->Tok.getLocation();
     nextToken(); // consume r_brace
     return true;
   }
 };
 
-tooling::Replacements sortJavaScriptImports(const FormatStyle &Style,
+tooling::Replacements sortJavaScriptImports(FormatStyle const &Style,
                                             StringRef Code,
                                             ArrayRef<tooling::Range> Ranges,
                                             StringRef FileName) {
   // FIXME: Cursor support.
   return JavaScriptImportSorter(Environment(Code, FileName, Ranges), Style)
       .process()
       .first;
 }
 
 } // end namespace format
 } // end namespace clang

clang/lib/Format/TokenAnalyzer.h

public:
   // that \p Code should end at \p LastStartColumn if it ends in newline.
   // See also the documentation of clang::format::internal::reformat.
   Environment(StringRef Code, StringRef FileName,
               ArrayRef<tooling::Range> Ranges, unsigned FirstStartColumn = 0,
               unsigned NextStartColumn = 0, unsigned LastStartColumn = 0);
 
   FileID getFileID() const { return ID; }
 
-  const SourceManager &getSourceManager() const { return SM; }
+  SourceManager const &getSourceManager() const { return SM; }
 
   ArrayRef<CharSourceRange> getCharRanges() const { return CharRanges; }
 
   // Returns the column at which the fragment of code managed by this
   // environment starts.
   unsigned getFirstStartColumn() const { return FirstStartColumn; }
 
   // Returns the column at which subsequent lines of the fragment of code
private:
   SmallVector<CharSourceRange, 8> CharRanges;
   unsigned FirstStartColumn;
   unsigned NextStartColumn;
   unsigned LastStartColumn;
 };
 
 class TokenAnalyzer : public UnwrappedLineConsumer {
 public:
-  TokenAnalyzer(const Environment &Env, const FormatStyle &Style);
+  TokenAnalyzer(Environment const &Env, FormatStyle const &Style);
 
   std::pair<tooling::Replacements, unsigned> process();
 
 protected:
   virtual std::pair<tooling::Replacements, unsigned>
   analyze(TokenAnnotator &Annotator,
           SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
           FormatTokenLexer &Tokens) = 0;
 
-  void consumeUnwrappedLine(const UnwrappedLine &TheLine) override;
+  void consumeUnwrappedLine(UnwrappedLine const &TheLine) override;
 
   void finishRun() override;
 
   FormatStyle Style;
   // Stores Style, FileID and SourceManager etc.
-  const Environment &Env;
+  Environment const &Env;
   // AffectedRangeMgr stores ranges to be fixed.
   AffectedRangeManager AffectedRangeMgr;
   SmallVector<SmallVector<UnwrappedLine, 16>, 2> UnwrappedLines;
   encoding::Encoding Encoding;
 };
 
 } // end namespace format
 } // end namespace clang
 
 #endif

clang/lib/Format/TokenAnalyzer.cpp

 Environment::Environment(StringRef Code, StringRef FileName,
                          ArrayRef<tooling::Range> Ranges,
                          unsigned FirstStartColumn, unsigned NextStartColumn,
                          unsigned LastStartColumn)
     : VirtualSM(new SourceManagerForFile(FileName, Code)), SM(VirtualSM->get()),
       ID(VirtualSM->get().getMainFileID()), FirstStartColumn(FirstStartColumn),
       NextStartColumn(NextStartColumn), LastStartColumn(LastStartColumn) {
   SourceLocation StartOfFile = SM.getLocForStartOfFile(ID);
-  for (const tooling::Range &Range : Ranges) {
+  for (tooling::Range const &Range : Ranges) {
     SourceLocation Start = StartOfFile.getLocWithOffset(Range.getOffset());
     SourceLocation End = Start.getLocWithOffset(Range.getLength());
     CharRanges.push_back(CharSourceRange::getCharRange(Start, End));
   }
 }
 
-TokenAnalyzer::TokenAnalyzer(const Environment &Env, const FormatStyle &Style)
+TokenAnalyzer::TokenAnalyzer(Environment const &Env, FormatStyle const &Style)
     : Style(Style), Env(Env),
       AffectedRangeMgr(Env.getSourceManager(), Env.getCharRanges()),
       UnwrappedLines(1),
       Encoding(encoding::detectEncoding(
           Env.getSourceManager().getBufferData(Env.getFileID()))) {
   LLVM_DEBUG(
       llvm::dbgs() << "File encoding: "
                    << (Encoding == encoding::Encoding_UTF8 ? "UTF8" : "unknown")
LLVM_DEBUG({
         llvm::dbgs() << I->toString() << "\n";
       }
     });
     for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
       delete AnnotatedLines[i];
     }
 
     Penalty += RunResult.second;
-    for (const auto &R : RunResult.first) {
+    for (auto const &R : RunResult.first) {
       auto Err = Result.add(R);
       // FIXME: better error handling here. For now, simply return an empty
       // Replacements to indicate failure.
       if (Err) {
         llvm::errs() << llvm::toString(std::move(Err)) << "\n";
         return {tooling::Replacements(), 0};
       }
     }
   }
   return {Result, Penalty};
 }
 
-void TokenAnalyzer::consumeUnwrappedLine(const UnwrappedLine &TheLine) {
+void TokenAnalyzer::consumeUnwrappedLine(UnwrappedLine const &TheLine) {
   assert(!UnwrappedLines.empty());
   UnwrappedLines.back().push_back(TheLine);
 }
 
 void TokenAnalyzer::finishRun() {
   UnwrappedLines.push_back(SmallVector<UnwrappedLine, 16>());
 }
 
 } // end namespace format
 } // end namespace clang

clang/lib/Format/TokenAnnotator.h

enum LineType {
   LT_Other,
   LT_PreprocessorDirective,
   LT_VirtualFunctionDecl,
   LT_ArrayOfStructInitializer,
 };
 
 class AnnotatedLine {
 public:
-  AnnotatedLine(const UnwrappedLine &Line)
+  AnnotatedLine(UnwrappedLine const &Line)
       : First(Line.Tokens.front().Tok), Level(Line.Level),
         MatchingOpeningBlockLineIndex(Line.MatchingOpeningBlockLineIndex),
         MatchingClosingBlockLineIndex(Line.MatchingClosingBlockLineIndex),
         InPPDirective(Line.InPPDirective),
         MustBeDeclaration(Line.MustBeDeclaration), MightBeFunctionDecl(false),
         IsMultiVariableDeclStmt(false), Affected(false),
         LeadingEmptyLinesAffected(false), ChildrenAffected(false),
         FirstStartColumn(Line.FirstStartColumn) {
     assert(!Line.Tokens.empty());
 
     // Calculate Next and Previous for all tokens. Note that we must overwrite
     // Next and Previous for every token, as previous formatting runs might have
     // left them in a different state.
     First->Previous = nullptr;
     FormatToken *Current = First;
     for (std::list<UnwrappedLineNode>::const_iterator I = ++Line.Tokens.begin(),
                                                       E = Line.Tokens.end();
          I != E; ++I) {
-      const UnwrappedLineNode &Node = *I;
+      UnwrappedLineNode const &Node = *I;
       Current->Next = I->Tok;
       I->Tok->Previous = Current;
       Current = Current->Next;
       Current->Children.clear();
-      for (const auto &Child : Node.Children) {
+      for (auto const &Child : Node.Children) {
         Children.push_back(new AnnotatedLine(Child));
         Current->Children.push_back(Children.back());
       }
     }
     Last = Current;
     Last->Next = nullptr;
   }
 
public:
 
   /// \c True if one of this line's children intersects with an input range.
   bool ChildrenAffected;
 
   unsigned FirstStartColumn;
 
 private:
   // Disallow copying.
-  AnnotatedLine(const AnnotatedLine &) = delete;
-  void operator=(const AnnotatedLine &) = delete;
+  AnnotatedLine(AnnotatedLine const &) = delete;
+  void operator=(AnnotatedLine const &) = delete;
 };
 
 /// Determines extra information about the tokens comprising an
 /// \c UnwrappedLine.
 class TokenAnnotator {
 public:
-  TokenAnnotator(const FormatStyle &Style, const AdditionalKeywords &Keywords)
+  TokenAnnotator(FormatStyle const &Style, AdditionalKeywords const &Keywords)
       : Style(Style), Keywords(Keywords) {}
 
   /// Adapts the indent levels of comment lines to the indent of the
   /// subsequent line.
   // FIXME: Can/should this be done in the UnwrappedLineParser?
   void setCommentLineLevels(SmallVectorImpl<AnnotatedLine *> &Lines);
 
   void annotate(AnnotatedLine &Line);
   void calculateFormattingInformation(AnnotatedLine &Line);
 
 private:
   /// Calculate the penalty for splitting before \c Tok.
-  unsigned splitPenalty(const AnnotatedLine &Line, const FormatToken &Tok,
+  unsigned splitPenalty(AnnotatedLine const &Line, FormatToken const &Tok,
                         bool InFunctionDecl);
 
-  bool spaceRequiredBeforeParens(const FormatToken &Right) const;
+  bool spaceRequiredBeforeParens(FormatToken const &Right) const;
 
-  bool spaceRequiredBetween(const AnnotatedLine &Line, const FormatToken &Left,
-                            const FormatToken &Right);
+  bool spaceRequiredBetween(AnnotatedLine const &Line, FormatToken const &Left,
+                            FormatToken const &Right);
 
-  bool spaceRequiredBefore(const AnnotatedLine &Line, const FormatToken &Right);
+  bool spaceRequiredBefore(AnnotatedLine const &Line, FormatToken const &Right);
 
-  bool mustBreakBefore(const AnnotatedLine &Line, const FormatToken &Right);
+  bool mustBreakBefore(AnnotatedLine const &Line, FormatToken const &Right);
 
-  bool canBreakBefore(const AnnotatedLine &Line, const FormatToken &Right);
+  bool canBreakBefore(AnnotatedLine const &Line, FormatToken const &Right);
 
-  bool mustBreakForReturnType(const AnnotatedLine &Line) const;
+  bool mustBreakForReturnType(AnnotatedLine const &Line) const;
 
-  void printDebugInfo(const AnnotatedLine &Line);
+  void printDebugInfo(AnnotatedLine const &Line);
 
   void calculateUnbreakableTailLengths(AnnotatedLine &Line);
 
   void calculateArrayInitializerColumnList(AnnotatedLine &Line);
 
   FormatToken *calculateInitializerColumnList(AnnotatedLine &Line,
                                               FormatToken *CurrentToken,
                                               unsigned Depth);
   FormatStyle::PointerAlignmentStyle
-  getTokenReferenceAlignment(const FormatToken &PointerOrReference);
+  getTokenReferenceAlignment(FormatToken const &PointerOrReference);
 
   FormatStyle::PointerAlignmentStyle
-  getTokenPointerOrReferenceAlignment(const FormatToken &PointerOrReference);
+  getTokenPointerOrReferenceAlignment(FormatToken const &PointerOrReference);
 
-  const FormatStyle &Style;
+  FormatStyle const &Style;
 
-  const AdditionalKeywords &Keywords;
+  AdditionalKeywords const &Keywords;
 };
 
 } // end namespace format
 } // end namespace clang
 
 #endif

clang/lib/Format/TokenAnnotator.cpp

 /// Because getFormattingLangOpts() always lexes source code as
 /// Objective-C++, C++ keywords like \c new and \c delete are
 /// lexed as tok::kw_*, not tok::identifier, even for Objective-C.
 ///
 /// For Objective-C and Objective-C++, both identifiers and keywords
 /// are valid inside @selector(...) (or a macro which
 /// invokes @selector(...)). So, we allow treat any identifier or
 /// keyword as a potential Objective-C selector component.
-static bool canBeObjCSelectorComponent(const FormatToken &Tok) {
+static bool canBeObjCSelectorComponent(FormatToken const &Tok) {
   return Tok.Tok.getIdentifierInfo() != nullptr;
 }
 
 /// With `Left` being '(', check if we're at either `[...](` or
 /// `[...]<...>(`, where the [ opens a lambda capture list.
-static bool isLambdaParameterList(const FormatToken *Left) {
+static bool isLambdaParameterList(FormatToken const *Left) {
   // Skip <...> if present.
   if (Left->Previous && Left->Previous->is(tok::greater) &&
       Left->Previous->MatchingParen &&
       Left->Previous->MatchingParen->is(TT_TemplateOpener))
     Left = Left->Previous->MatchingParen;
 
   // Check for `[...]`.
   return Left->Previous && Left->Previous->is(tok::r_square) &&
          Left->Previous->MatchingParen &&
          Left->Previous->MatchingParen->is(TT_LambdaLSquare);
 }
 
 /// Returns \c true if the token is followed by a boolean condition, \c false
 /// otherwise.
-static bool isKeywordWithCondition(const FormatToken &Tok) {
+static bool isKeywordWithCondition(FormatToken const &Tok) {
   return Tok.isOneOf(tok::kw_if, tok::kw_for, tok::kw_while, tok::kw_switch,
                      tok::kw_constexpr, tok::kw_catch);
 }
 
 /// A parser that gathers additional information about tokens.
 ///
 /// The \c TokenAnnotator tries to match parenthesis and square brakets and
 /// store a parenthesis levels. It also tries to resolve matching "<" and ">"
 /// into template parameter lists.
 class AnnotatingParser {
 public:
-  AnnotatingParser(const FormatStyle &Style, AnnotatedLine &Line,
-                   const AdditionalKeywords &Keywords)
+  AnnotatingParser(FormatStyle const &Style, AnnotatedLine &Line,
+                   AdditionalKeywords const &Keywords)
       : Style(Style), Line(Line), CurrentToken(Line.First), AutoFound(false),
         Keywords(Keywords) {
     Contexts.push_back(Context(tok::unknown, 1, /*IsExpression=*/false));
     resetTokenMetadata(CurrentToken);
   }
 
 private:
   bool parseAngle() {
     if (!CurrentToken || !CurrentToken->Previous)
       return false;
     if (NonTemplateLess.count(CurrentToken->Previous))
       return false;
 
-    const FormatToken &Previous = *CurrentToken->Previous; // The '<'.
+    FormatToken const &Previous = *CurrentToken->Previous; // The '<'.
     if (Previous.Previous) {
       if (Previous.Previous->Tok.isLiteral())
         return false;
       if (Previous.Previous->is(tok::r_paren) && Contexts.size() > 1 &&
           (!Previous.Previous->MatchingParen ||
            !Previous.Previous->MatchingParen->is(TT_OverloadedOperatorLParen)))
         return false;
     }
while (CurrentToken) {
         return false;
       updateParameterCount(Left, Tok);
       if (CurrentToken && CurrentToken->HasUnescapedNewline)
         HasMultipleLines = true;
     }
     return false;
   }
 
-  bool isCSharpAttributeSpecifier(const FormatToken &Tok) {
+  bool isCSharpAttributeSpecifier(FormatToken const &Tok) {
     if (!Style.isCSharp())
       return false;
 
     // `identifier[i]` is not an attribute.
     if (Tok.Previous && Tok.Previous->is(tok::identifier))
       return false;
 
     // Chains of [] in `identifier[i][j][k]` are not attributes.
     if (Tok.Previous && Tok.Previous->is(tok::r_square)) {
       auto *MatchingParen = Tok.Previous->MatchingParen;
       if (!MatchingParen || MatchingParen->is(TT_ArraySubscriptLSquare))
         return false;
     }
 
-    const FormatToken *AttrTok = Tok.Next;
+    FormatToken const *AttrTok = Tok.Next;
     if (!AttrTok)
       return false;
 
     // Just an empty declaration e.g. string [].
     if (AttrTok->is(tok::r_square))
       return false;
 
     // Move along the tokens inbetween the '[' and ']' e.g. [STAThread].
bool isCSharpAttributeSpecifier(FormatToken const &Tok) {
     // incase its a [XXX] retval func(....
     if (AttrTok->Next &&
         AttrTok->Next->startsSequence(tok::identifier, tok::l_paren))
       return true;
 
     return false;
   }
 
-  bool isCpp11AttributeSpecifier(const FormatToken &Tok) {
+  bool isCpp11AttributeSpecifier(FormatToken const &Tok) {
     if (!Style.isCpp() || !Tok.startsSequence(tok::l_square, tok::l_square))
       return false;
     // The first square bracket is part of an ObjC array literal
     if (Tok.Previous && Tok.Previous->is(tok::at)) {
       return false;
     }
-    const FormatToken *AttrTok = Tok.Next->Next;
+    FormatToken const *AttrTok = Tok.Next->Next;
     if (!AttrTok)
       return false;
     // C++17 '[[using ns: foo, bar(baz, blech)]]'
     // We assume nobody will name an ObjC variable 'using'.
     if (AttrTok->startsSequence(tok::kw_using, tok::identifier, tok::colon))
       return true;
     if (AttrTok->isNot(tok::identifier))
       return false;
bool parseSquare() {
     return false;
   }
 
   bool couldBeInStructArrayInitializer() const {
     if (Contexts.size() < 2)
       return false;
     // We want to back up no more then 2 context levels i.e.
     // . { { <-
-    const auto End = std::next(Contexts.rbegin(), 2);
+    auto const End = std::next(Contexts.rbegin(), 2);
     auto Last = Contexts.rbegin();
     unsigned Depth = 0;
     for (; Last != End; ++Last) {
       if (Last->ContextKind == tok::l_brace)
         ++Depth;
     }
     return Depth == 2 && Last->ContextKind != tok::l_brace;
   }
case tok::colon:
         Tok->setType(TT_DictLiteral);
         if (Style.Language == FormatStyle::LK_TextProto) {
           if (FormatToken *Previous = Tok->getPreviousNonComment())
             Previous->setType(TT_SelectorName);
         }
       } else if (Contexts.back().ColonIsObjCMethodExpr ||
                  Line.startsWith(TT_ObjCMethodSpecifier)) {
         Tok->setType(TT_ObjCMethodExpr);
-        const FormatToken *BeforePrevious = Tok->Previous->Previous;
+        FormatToken const *BeforePrevious = Tok->Previous->Previous;
         // Ensure we tag all identifiers in method declarations as
         // TT_SelectorName.
         bool UnknownIdentifierInMethodDeclaration =
             Line.startsWith(TT_ObjCMethodSpecifier) &&
             Tok->Previous->is(tok::identifier) && Tok->Previous->is(TT_Unknown);
         if (!BeforePrevious ||
             // FIXME(bug 36976): ObjC return types shouldn't use TT_CastRParen.
             !(BeforePrevious->is(TT_CastRParen) ||
LineType parseLine() {
 
     if (Line.startsWith(TT_ObjCMethodSpecifier)) {
       if (Contexts.back().FirstObjCSelectorName)
         Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName =
             Contexts.back().LongestObjCSelectorName;
       return LT_ObjCMethodDecl;
     }
 
-    for (const auto &ctx : Contexts) {
+    for (auto const &ctx : Contexts) {
       if (ctx.InStructArrayInitializer) {
         return LT_ArrayOfStructInitializer;
       }
     }
 
     return LT_Other;
   }
 
 private:
-  bool isClosureImportStatement(const FormatToken &Tok) {
+  bool isClosureImportStatement(FormatToken const &Tok) {
     // FIXME: Closure-library specific stuff should not be hard-coded but be
     // configurable.
     return Tok.TokenText == "goog" && Tok.Next && Tok.Next->is(tok::period) &&
            Tok.Next->Next &&
            (Tok.Next->Next->TokenText == "module" ||
             Tok.Next->Next->TokenText == "provide" ||
             Tok.Next->Next->TokenText == "require" ||
             Tok.Next->Next->TokenText == "requireType" ||
~ScopedContextCreator() {
           P.Contexts.back().InStructArrayInitializer = true;
           return;
         }
       }
       P.Contexts.pop_back();
     }
   };
 
-  void modifyContext(const FormatToken &Current) {
+  void modifyContext(FormatToken const &Current) {
     if (Current.getPrecedence() == prec::Assignment &&
         !Line.First->isOneOf(tok::kw_template, tok::kw_using, tok::kw_return) &&
         // Type aliases use `type X = ...;` in TypeScript and can be exported
         // using `export type ...`.
         !(Style.Language == FormatStyle::LK_JavaScript &&
           (Line.startsWith(Keywords.kw_type, tok::identifier) ||
            Line.startsWith(tok::kw_export, Keywords.kw_type,
                            tok::identifier))) &&
if (Current.is(Keywords.kw_instanceof)) {
       // Line.MightBeFunctionDecl can only be true after the parentheses of a
       // function declaration have been found.
       Current.setType(TT_TrailingAnnotation);
     } else if ((Style.Language == FormatStyle::LK_Java ||
                 Style.Language == FormatStyle::LK_JavaScript) &&
                Current.Previous) {
       if (Current.Previous->is(tok::at) &&
           Current.isNot(Keywords.kw_interface)) {
-        const FormatToken &AtToken = *Current.Previous;
-        const FormatToken *Previous = AtToken.getPreviousNonComment();
+        FormatToken const &AtToken = *Current.Previous;
+        FormatToken const *Previous = AtToken.getPreviousNonComment();
         if (!Previous || Previous->is(TT_LeadingJavaAnnotation))
           Current.setType(TT_LeadingJavaAnnotation);
         else
           Current.setType(TT_JavaAnnotation);
       } else if (Current.Previous->is(tok::period) &&
                  Current.Previous->isOneOf(TT_JavaAnnotation,
                                            TT_LeadingJavaAnnotation)) {
         Current.setType(Current.Previous->getType());
       }
     }
   }
 
   /// Take a guess at whether \p Tok starts a name of a function or
   /// variable declaration.
   ///
   /// This is a heuristic based on whether \p Tok is an identifier following
   /// something that is likely a type.
-  bool isStartOfName(const FormatToken &Tok) {
+  bool isStartOfName(FormatToken const &Tok) {
     if (Tok.isNot(tok::identifier) || !Tok.Previous)
       return false;
 
     if (Tok.Previous->isOneOf(TT_LeadingJavaAnnotation, Keywords.kw_instanceof,
                               Keywords.kw_as))
       return false;
     if (Style.Language == FormatStyle::LK_JavaScript &&
         Tok.Previous->is(Keywords.kw_in))
bool isStartOfName(FormatToken const &Tok) {
 
     return (!IsPPKeyword &&
             PreviousNotConst->isOneOf(tok::identifier, tok::kw_auto)) ||
            PreviousNotConst->is(TT_PointerOrReference) ||
            PreviousNotConst->isSimpleTypeSpecifier();
   }
 
   /// Determine whether ')' is ending a cast.
-  bool rParenEndsCast(const FormatToken &Tok) {
+  bool rParenEndsCast(FormatToken const &Tok) {
     // C-style casts are only used in C++, C# and Java.
     if (!Style.isCSharp() && !Style.isCpp() &&
         Style.Language != FormatStyle::LK_Java)
       return false;
 
     // Empty parens aren't casts and there are no casts at the end of the line.
     if (Tok.Previous == Tok.MatchingParen || !Tok.Next || !Tok.MatchingParen)
       return false;
bool rParenEndsCast(FormatToken const &Tok) {
     // At this point, we heuristically assume that there are no casts at the
     // start of the line. We assume that we have found most cases where there
     // are by the logic above, e.g. "(void)x;".
     if (!LeftOfParens)
       return false;
 
     // Certain token types inside the parentheses mean that this can't be a
     // cast.
-    for (const FormatToken *Token = Tok.MatchingParen->Next; Token != &Tok;
+    for (FormatToken const *Token = Tok.MatchingParen->Next; Token != &Tok;
          Token = Token->Next)
       if (Token->is(TT_BinaryOperator))
         return false;
 
     // If the following token is an identifier or 'this', this is a cast. All
     // cases where this can be something else are handled above.
     if (Tok.Next->isOneOf(tok::identifier, tok::kw_this))
       return true;
for (FormatToken *Prev = Tok.Previous; Prev != Tok.MatchingParen;
          Prev = Prev->Previous) {
       if (!Prev->isOneOf(tok::kw_const, tok::identifier, tok::coloncolon))
         return false;
     }
     return true;
   }
 
   /// Return the type of the given token assuming it is * or &.
-  TokenType determineStarAmpUsage(const FormatToken &Tok, bool IsExpression,
+  TokenType determineStarAmpUsage(FormatToken const &Tok, bool IsExpression,
                                   bool InTemplateArgument) {
     if (Style.Language == FormatStyle::LK_JavaScript)
       return TT_BinaryOperator;
 
     // && in C# must be a binary operator.
     if (Style.isCSharp() && Tok.is(tok::ampamp))
       return TT_BinaryOperator;
 
-    const FormatToken *PrevToken = Tok.getPreviousNonComment();
+    FormatToken const *PrevToken = Tok.getPreviousNonComment();
     if (!PrevToken)
       return TT_UnaryOperator;
 
-    const FormatToken *NextToken = Tok.getNextNonComment();
+    FormatToken const *NextToken = Tok.getNextNonComment();
     if (!NextToken ||
         NextToken->isOneOf(tok::arrow, tok::equal, tok::kw_noexcept) ||
         NextToken->canBePointerOrReferenceQualifier() ||
         (NextToken->is(tok::l_brace) && !NextToken->getNextNonComment()))
       return TT_PointerOrReference;
 
     if (PrevToken->is(tok::coloncolon))
       return TT_PointerOrReference;
TokenType determineStarAmpUsage(FormatToken const &Tok, bool IsExpression,
 
     // "&&(" is quite unlikely to be two successive unary "&".
     if (Tok.is(tok::ampamp) && NextToken->is(tok::l_paren))
       return TT_BinaryOperator;
 
     // This catches some cases where evaluation order is used as control flow:
     //   aaa && aaa->f();
     if (NextToken->Tok.isAnyIdentifier()) {
-      const FormatToken *NextNextToken = NextToken->getNextNonComment();
+      FormatToken const *NextNextToken = NextToken->getNextNonComment();
       if (NextNextToken && NextNextToken->is(tok::arrow))
         return TT_BinaryOperator;
     }
 
     // It is very unlikely that we are going to find a pointer or reference type
     // definition on the RHS of an assignment.
     if (IsExpression && !Contexts.back().CaretFound)
       return TT_BinaryOperator;
 
     return TT_PointerOrReference;
   }
 
-  TokenType determinePlusMinusCaretUsage(const FormatToken &Tok) {
-    const FormatToken *PrevToken = Tok.getPreviousNonComment();
+  TokenType determinePlusMinusCaretUsage(FormatToken const &Tok) {
+    FormatToken const *PrevToken = Tok.getPreviousNonComment();
     if (!PrevToken)
       return TT_UnaryOperator;
 
     if (PrevToken->isOneOf(TT_CastRParen, TT_UnaryOperator))
       // This must be a sequence of leading unary operators.
       return TT_UnaryOperator;
 
     // Use heuristics to recognize unary operators.
     if (PrevToken->isOneOf(tok::equal, tok::l_paren, tok::comma, tok::l_square,
                            tok::question, tok::colon, tok::kw_return,
                            tok::kw_case, tok::at, tok::l_brace, tok::kw_throw,
                            tok::kw_co_return, tok::kw_co_yield))
       return TT_UnaryOperator;
 
     // There can't be two consecutive binary operators.
     if (PrevToken->is(TT_BinaryOperator))
       return TT_UnaryOperator;
 
     // Fall back to marking the token as binary operator.
     return TT_BinaryOperator;
   }
 
   /// Determine whether ++/-- are pre- or post-increments/-decrements.
-  TokenType determineIncrementUsage(const FormatToken &Tok) {
-    const FormatToken *PrevToken = Tok.getPreviousNonComment();
+  TokenType determineIncrementUsage(FormatToken const &Tok) {
+    FormatToken const *PrevToken = Tok.getPreviousNonComment();
     if (!PrevToken || PrevToken->is(TT_CastRParen))
       return TT_UnaryOperator;
     if (PrevToken->isOneOf(tok::r_paren, tok::r_square, tok::identifier))
       return TT_TrailingUnaryOperator;
 
     return TT_UnaryOperator;
   }
 
   SmallVector<Context, 8> Contexts;
 
-  const FormatStyle &Style;
+  FormatStyle const &Style;
   AnnotatedLine &Line;
   FormatToken *CurrentToken;
   bool AutoFound;
-  const AdditionalKeywords &Keywords;
+  AdditionalKeywords const &Keywords;
 
   // Set of "<" tokens that do not open a template parameter list. If parseAngle
   // determines that a specific token can't be a template opener, it will make
   // same decision irrespective of the decisions for tokens leading up to it.
   // Store this information to prevent this from causing exponential runtime.
   llvm::SmallPtrSet<FormatToken *, 16> NonTemplateLess;
 };
 
-static const int PrecedenceUnaryOperator = prec::PointerToMember + 1;
-static const int PrecedenceArrowAndPeriod = prec::PointerToMember + 2;
+static int const PrecedenceUnaryOperator = prec::PointerToMember + 1;
+static int const PrecedenceArrowAndPeriod = prec::PointerToMember + 2;
 
 /// Parses binary expressions by inserting fake parenthesis based on
 /// operator precedence.
 class ExpressionParser {
 public:
-  ExpressionParser(const FormatStyle &Style, const AdditionalKeywords &Keywords,
+  ExpressionParser(FormatStyle const &Style, AdditionalKeywords const &Keywords,
                    AnnotatedLine &Line)
       : Style(Style), Keywords(Keywords), Current(Line.First) {}
 
   /// Parse expressions with the given operator precedence.
   void parse(int Precedence = 0) {
     // Skip 'return' and ObjC selector colons as they are not part of a binary
     // expression.
     while (Current && (Current->is(tok::kw_return) ||
void parse(int Precedence = 0) {
     }
   }
 
 private:
   /// Gets the precedence (+1) of the given token for binary operators
   /// and other tokens that we treat like binary operators.
   int getCurrentPrecedence() {
     if (Current) {
-      const FormatToken *NextNonComment = Current->getNextNonComment();
+      FormatToken const *NextNonComment = Current->getNextNonComment();
       if (Current->is(TT_ConditionalExpr))
         return prec::Conditional;
       if (NextNonComment && Current->is(TT_SelectorName) &&
           (NextNonComment->isOneOf(TT_DictLiteral, TT_JsTypeColon) ||
            ((Style.Language == FormatStyle::LK_Proto ||
              Style.Language == FormatStyle::LK_TextProto) &&
             NextNonComment->is(tok::less))))
         return prec::Assignment;
void next(bool SkipPastLeadingComments = true) {
     if (Current)
       Current = Current->Next;
     while (Current &&
            (Current->NewlinesBefore == 0 || SkipPastLeadingComments) &&
            Current->isTrailingComment())
       Current = Current->Next;
   }
 
-  const FormatStyle &Style;
-  const AdditionalKeywords &Keywords;
+  FormatStyle const &Style;
+  AdditionalKeywords const &Keywords;
   FormatToken *Current;
 };
 
 } // end anonymous namespace
 
 void TokenAnnotator::setCommentLineLevels(
     SmallVectorImpl<AnnotatedLine *> &Lines) {
-  const AnnotatedLine *NextNonCommentLine = nullptr;
+  AnnotatedLine const *NextNonCommentLine = nullptr;
   for (SmallVectorImpl<AnnotatedLine *>::reverse_iterator I = Lines.rbegin(),
                                                           E = Lines.rend();
        I != E; ++I) {
     bool CommentLine = true;
-    for (const FormatToken *Tok = (*I)->First; Tok; Tok = Tok->Next) {
+    for (FormatToken const *Tok = (*I)->First; Tok; Tok = Tok->Next) {
       if (!Tok->is(tok::comment)) {
         CommentLine = false;
         break;
       }
     }
 
     // If the comment is currently aligned with the line immediately following
     // it, that's probably intentional and we should keep it.
for (SmallVectorImpl<AnnotatedLine *>::reverse_iterator I = Lines.rbegin(),
     } else {
       NextNonCommentLine = (*I)->First->isNot(tok::r_brace) ? (*I) : nullptr;
     }
 
     setCommentLineLevels((*I)->Children);
   }
 }
 
-static unsigned maxNestingDepth(const AnnotatedLine &Line) {
+static unsigned maxNestingDepth(AnnotatedLine const &Line) {
   unsigned Result = 0;
-  for (const auto *Tok = Line.First; Tok != nullptr; Tok = Tok->Next)
+  for (auto const *Tok = Line.First; Tok != nullptr; Tok = Tok->Next)
     Result = std::max(Result, Tok->NestingLevel);
   return Result;
 }
 
 void TokenAnnotator::annotate(AnnotatedLine &Line) {
   for (SmallVectorImpl<AnnotatedLine *>::iterator I = Line.Children.begin(),
                                                   E = Line.Children.end();
        I != E; ++I) {
else if (Line.startsWith(TT_ObjCProperty))
     Line.Type = LT_ObjCProperty;
 
   Line.First->SpacesRequiredBefore = 1;
   Line.First->CanBreakBefore = Line.First->MustBreakBefore;
 }
 
 // This function heuristically determines whether 'Current' starts the name of a
 // function declaration.
-static bool isFunctionDeclarationName(const FormatToken &Current,
-                                      const AnnotatedLine &Line) {
-  auto skipOperatorName = [](const FormatToken *Next) -> const FormatToken * {
+static bool isFunctionDeclarationName(FormatToken const &Current,
+                                      AnnotatedLine const &Line) {
+  auto skipOperatorName = [](FormatToken const *Next) -> FormatToken const * {
     for (; Next; Next = Next->Next) {
       if (Next->is(TT_OverloadedOperatorLParen))
         return Next;
       if (Next->is(TT_OverloadedOperator))
         continue;
       if (Next->isOneOf(tok::kw_new, tok::kw_delete)) {
         // For 'new[]' and 'delete[]'.
         if (Next->Next &&
for (; Next; Next = Next->Next) {
       }
 
       break;
     }
     return nullptr;
   };
 
   // Find parentheses of parameter list.
-  const FormatToken *Next = Current.Next;
+  FormatToken const *Next = Current.Next;
   if (Current.is(tok::kw_operator)) {
     if (Current.Previous && Current.Previous->is(tok::coloncolon))
       return false;
     Next = skipOperatorName(Next);
   } else {
     if (!Current.is(TT_StartOfName) || Current.NestingLevel != 0)
       return false;
     for (; Next; Next = Next->Next) {
static bool isFunctionDeclarationName(FormatToken const &Current,
   if (Line.Last->is(tok::l_brace))
     return true;
   if (Next->Next == Next->MatchingParen)
     return true; // Empty parentheses.
   // If there is an &/&& after the r_paren, this is likely a function.
   if (Next->MatchingParen->Next &&
       Next->MatchingParen->Next->is(TT_PointerOrReference))
     return true;
-  for (const FormatToken *Tok = Next->Next; Tok && Tok != Next->MatchingParen;
+  for (FormatToken const *Tok = Next->Next; Tok && Tok != Next->MatchingParen;
        Tok = Tok->Next) {
     if (Tok->is(TT_TypeDeclarationParen))
       return true;
     if (Tok->isOneOf(tok::l_paren, TT_TemplateOpener) && Tok->MatchingParen) {
       Tok = Tok->MatchingParen;
       continue;
     }
     if (Tok->is(tok::kw_const) || Tok->isSimpleTypeSpecifier() ||
         Tok->isOneOf(TT_PointerOrReference, TT_StartOfName, tok::ellipsis))
       return true;
     if (Tok->isOneOf(tok::l_brace, tok::string_literal, TT_ObjCMethodExpr) ||
         Tok->Tok.isLiteral())
       return false;
   }
   return false;
 }
 
-bool TokenAnnotator::mustBreakForReturnType(const AnnotatedLine &Line) const {
+bool TokenAnnotator::mustBreakForReturnType(AnnotatedLine const &Line) const {
   assert(Line.MightBeFunctionDecl);
 
   if ((Style.AlwaysBreakAfterReturnType == FormatStyle::RTBS_TopLevel ||
        Style.AlwaysBreakAfterReturnType ==
            FormatStyle::RTBS_TopLevelDefinitions) &&
       Line.Level > 0)
     return false;
 
while (Current) {
     Current->CanBreakBefore =
         Current->MustBreakBefore || canBreakBefore(Line, *Current);
     unsigned ChildSize = 0;
     if (Current->Previous->Children.size() == 1) {
       FormatToken &LastOfChild = *Current->Previous->Children[0]->Last;
       ChildSize = LastOfChild.isTrailingComment() ? Style.ColumnLimit
                                                   : LastOfChild.TotalLength + 1;
     }
-    const FormatToken *Prev = Current->Previous;
+    FormatToken const *Prev = Current->Previous;
     if (Current->MustBreakBefore || Prev->Children.size() > 1 ||
         (Prev->Children.size() == 1 &&
          Prev->Children[0]->First->MustBreakBefore) ||
         Current->IsMultiline)
       Current->TotalLength = Prev->TotalLength + Style.ColumnLimit;
     else
       Current->TotalLength = Prev->TotalLength + Current->ColumnWidth +
                              ChildSize + Current->SpacesRequiredBefore;
if (Depth == 2 && CurrentToken->isOneOf(tok::l_brace, tok::comma)) {
       CurrentToken->StartsColumn = true;
       CurrentToken = CurrentToken->Previous;
     }
     CurrentToken = CurrentToken->Next;
   }
   return CurrentToken;
 }
 
-unsigned TokenAnnotator::splitPenalty(const AnnotatedLine &Line,
-                                      const FormatToken &Tok,
+unsigned TokenAnnotator::splitPenalty(AnnotatedLine const &Line,
+                                      FormatToken const &Tok,
                                       bool InFunctionDecl) {
-  const FormatToken &Left = *Tok.Previous;
-  const FormatToken &Right = Tok;
+  FormatToken const &Left = *Tok.Previous;
+  FormatToken const &Right = Tok;
 
   if (Left.is(tok::semi))
     return 0;
 
   if (Style.Language == FormatStyle::LK_Java) {
     if (Right.isOneOf(Keywords.kw_extends, Keywords.kw_throws))
       return 1;
     if (Right.is(Keywords.kw_implements))
unsigned TokenAnnotator::splitPenalty(AnnotatedLine const &Line,
   if (Level == prec::Assignment)
     return Style.PenaltyBreakAssignment;
   if (Level != prec::Unknown)
     return Level;
 
   return 3;
 }
 
-bool TokenAnnotator::spaceRequiredBeforeParens(const FormatToken &Right) const {
+bool TokenAnnotator::spaceRequiredBeforeParens(FormatToken const &Right) const {
   return Style.SpaceBeforeParens == FormatStyle::SBPO_Always ||
          (Style.SpaceBeforeParens == FormatStyle::SBPO_NonEmptyParentheses &&
           Right.ParameterCount > 0);
 }
 
-bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line,
-                                          const FormatToken &Left,
-                                          const FormatToken &Right) {
+bool TokenAnnotator::spaceRequiredBetween(AnnotatedLine const &Line,
+                                          FormatToken const &Left,
+                                          FormatToken const &Right) {
   if (Left.is(tok::kw_return) && Right.isNot(tok::semi))
     return true;
   if (Style.isJson() && Left.is(tok::string_literal) && Right.is(tok::colon))
     return false;
   if (Left.is(Keywords.kw_assert) && Style.Language == FormatStyle::LK_Java)
     return true;
   if (Style.ObjCSpaceAfterProperty && Line.Type == LT_ObjCProperty &&
       Left.Tok.getObjCKeywordID() == tok::objc_property)
if (Left.is(tok::ellipsis) && Left.Previous &&
       Left.Previous->isOneOf(tok::star, tok::amp, tok::ampamp))
     return Style.PointerAlignment != FormatStyle::PAS_Right;
 
   if (Right.is(tok::star) && Left.is(tok::l_paren))
     return false;
   if (Left.is(tok::star) && Right.isOneOf(tok::star, tok::amp, tok::ampamp))
     return false;
   if (Right.isOneOf(tok::star, tok::amp, tok::ampamp)) {
-    const FormatToken *Previous = &Left;
+    FormatToken const *Previous = &Left;
     while (Previous && !Previous->is(tok::kw_operator)) {
       if (Previous->is(tok::identifier) || Previous->isSimpleTypeSpecifier()) {
         Previous = Previous->getPreviousNonComment();
         continue;
       }
       if (Previous->is(TT_TemplateCloser) && Previous->MatchingParen) {
         Previous = Previous->MatchingParen->getPreviousNonComment();
         continue;
if (Previous) {
         return (Style.PointerAlignment != FormatStyle::PAS_Left);
       if (Previous->is(tok::kw_const) || Previous->is(tok::kw_volatile))
         return (Style.PointerAlignment != FormatStyle::PAS_Left) ||
                (Style.SpaceAroundPointerQualifiers ==
                 FormatStyle::SAPQ_After) ||
                (Style.SpaceAroundPointerQualifiers == FormatStyle::SAPQ_Both);
     }
   }
-  const auto SpaceRequiredForArrayInitializerLSquare =
-      [](const FormatToken &LSquareTok, const FormatStyle &Style) {
+  auto const SpaceRequiredForArrayInitializerLSquare =
+      [](FormatToken const &LSquareTok, FormatStyle const &Style) {
         return Style.SpacesInContainerLiterals ||
                ((Style.Language == FormatStyle::LK_Proto ||
                  Style.Language == FormatStyle::LK_TextProto) &&
                 !Style.Cpp11BracedListStyle &&
                 LSquareTok.endsSequence(tok::l_square, tok::colon,
                                         TT_SelectorName));
       };
   if (Left.is(tok::l_square))
if (Right.getType() == TT_TrailingAnnotation &&
       (!Right.Next || Right.Next->is(tok::semi)))
     // Match const and volatile ref-qualifiers without any additional
     // qualifiers such as
     // void Fn() const &;
     return getTokenReferenceAlignment(Right) != FormatStyle::PAS_Left;
   return true;
 }
 
-bool TokenAnnotator::spaceRequiredBefore(const AnnotatedLine &Line,
-                                         const FormatToken &Right) {
-  const FormatToken &Left = *Right.Previous;
+bool TokenAnnotator::spaceRequiredBefore(AnnotatedLine const &Line,
+                                         FormatToken const &Right) {
+  FormatToken const &Left = *Right.Previous;
   auto HasExistingWhitespace = [&Right]() {
     return Right.WhitespaceRange.getBegin() != Right.WhitespaceRange.getEnd();
   };
   if (Right.Tok.getIdentifierInfo() && Left.Tok.getIdentifierInfo())
     return true; // Never ever merge two identifiers.
   if (Style.isCpp()) {
     if (Left.is(tok::kw_operator))
       return Right.is(tok::coloncolon);
if (Style.isCpp()) {
     if (Left.is(TT_FatArrow))
       return true;
     // for await ( ...
     if (Right.is(tok::l_paren) && Left.is(Keywords.kw_await) && Left.Previous &&
         Left.Previous->is(tok::kw_for))
       return true;
     if (Left.is(Keywords.kw_async) && Right.is(tok::l_paren) &&
         Right.MatchingParen) {
-      const FormatToken *Next = Right.MatchingParen->getNextNonComment();
+      FormatToken const *Next = Right.MatchingParen->getNextNonComment();
       // An async arrow function, for example: `x = async () => foo();`,
       // as opposed to calling a function called async: `x = async();`
       if (Next && Next->is(TT_FatArrow))
         return true;
     }
     if ((Left.is(TT_TemplateString) && Left.TokenText.endswith("${")) ||
         (Right.is(TT_TemplateString) && Right.TokenText.startswith("}")))
       return false;
bool TokenAnnotator::spaceRequiredBefore(AnnotatedLine const &Line,
   if (Right.is(TT_TrailingUnaryOperator))
     return false;
   if (Left.is(TT_RegexLiteral))
     return false;
   return spaceRequiredBetween(Line, Left, Right);
 }
 
 // Returns 'true' if 'Tok' is a brace we'd want to break before in Allman style.
-static bool isAllmanBrace(const FormatToken &Tok) {
+static bool isAllmanBrace(FormatToken const &Tok) {
   return Tok.is(tok::l_brace) && Tok.is(BK_Block) &&
          !Tok.isOneOf(TT_ObjCBlockLBrace, TT_LambdaLBrace, TT_DictLiteral);
 }
 
 // Returns 'true' if 'Tok' is an function argument.
-static bool IsFunctionArgument(const FormatToken &Tok) {
+static bool IsFunctionArgument(FormatToken const &Tok) {
   return Tok.MatchingParen && Tok.MatchingParen->Next &&
          Tok.MatchingParen->Next->isOneOf(tok::comma, tok::r_paren);
 }
 
 static bool
-isItAnEmptyLambdaAllowed(const FormatToken &Tok,
+isItAnEmptyLambdaAllowed(FormatToken const &Tok,
                          FormatStyle::ShortLambdaStyle ShortLambdaOption) {
   return Tok.Children.empty() && ShortLambdaOption != FormatStyle::SLS_None;
 }
 
-static bool isAllmanLambdaBrace(const FormatToken &Tok) {
+static bool isAllmanLambdaBrace(FormatToken const &Tok) {
   return (Tok.is(tok::l_brace) && Tok.is(BK_Block) &&
           !Tok.isOneOf(TT_ObjCBlockLBrace, TT_DictLiteral));
 }
 
-bool TokenAnnotator::mustBreakBefore(const AnnotatedLine &Line,
-                                     const FormatToken &Right) {
-  const FormatToken &Left = *Right.Previous;
+bool TokenAnnotator::mustBreakBefore(AnnotatedLine const &Line,
+                                     FormatToken const &Right) {
+  FormatToken const &Left = *Right.Previous;
   if (Right.NewlinesBefore > 1 && Style.MaxEmptyLinesToKeep > 0)
     return true;
 
   if (Style.isCSharp()) {
     if (Right.is(TT_CSharpNamedArgumentColon) ||
         Left.is(TT_CSharpNamedArgumentColon))
       return false;
     if (Right.is(TT_CSharpGenericTypeConstraint))
if (Left.is(tok::comma))
       return true;
   }
 
   // If the last token before a '}', ']', or ')' is a comma or a trailing
   // comment, the intention is to insert a line break after it in order to make
   // shuffling around entries easier. Import statements, especially in
   // JavaScript, can be an exception to this rule.
   if (Style.JavaScriptWrapImports || Line.Type != LT_ImportStatement) {
-    const FormatToken *BeforeClosingBrace = nullptr;
+    FormatToken const *BeforeClosingBrace = nullptr;
     if ((Left.isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) ||
          (Style.Language == FormatStyle::LK_JavaScript &&
           Left.is(tok::l_paren))) &&
         Left.isNot(BK_Block) && Left.MatchingParen)
       BeforeClosingBrace = Left.MatchingParen->Previous;
     else if (Right.MatchingParen &&
              (Right.MatchingParen->isOneOf(tok::l_brace,
                                            TT_ArrayInitializerLSquare) ||
if (!Next)
       return false;
     if (!Next->isOneOf(TT_LambdaLSquare, tok::l_brace, tok::caret))
       return true;
   }
 
   return false;
 }
 
-bool TokenAnnotator::canBreakBefore(const AnnotatedLine &Line,
-                                    const FormatToken &Right) {
-  const FormatToken &Left = *Right.Previous;
+bool TokenAnnotator::canBreakBefore(AnnotatedLine const &Line,
+                                    FormatToken const &Right) {
+  FormatToken const &Left = *Right.Previous;
   // Language-specific stuff.
   if (Style.isCSharp()) {
     if (Left.isOneOf(TT_CSharpNamedArgumentColon, TT_AttributeColon) ||
         Right.isOneOf(TT_CSharpNamedArgumentColon, TT_AttributeColon))
       return false;
     // Only break after commas for generic type constraints.
     if (Line.First->is(TT_CSharpGenericTypeConstraint))
       return Left.is(TT_CSharpGenericTypeConstraintComma);
     // Keep nullable operators attached to their identifiers.
     if (Right.is(TT_CSharpNullable)) {
       return false;
     }
   } else if (Style.Language == FormatStyle::LK_Java) {
     if (Left.isOneOf(Keywords.kw_throws, Keywords.kw_extends,
                      Keywords.kw_implements))
       return false;
     if (Right.isOneOf(Keywords.kw_throws, Keywords.kw_extends,
                       Keywords.kw_implements))
       return true;
   } else if (Style.Language == FormatStyle::LK_JavaScript) {
-    const FormatToken *NonComment = Right.getPreviousNonComment();
+    FormatToken const *NonComment = Right.getPreviousNonComment();
     if (NonComment &&
         NonComment->isOneOf(
             tok::kw_return, Keywords.kw_yield, tok::kw_continue, tok::kw_break,
             tok::kw_throw, Keywords.kw_interface, Keywords.kw_type,
             tok::kw_static, tok::kw_public, tok::kw_private, tok::kw_protected,
             Keywords.kw_readonly, Keywords.kw_abstract, Keywords.kw_get,
             Keywords.kw_set, Keywords.kw_async, Keywords.kw_await))
       return false; // Otherwise automatic semicolon insertion would trigger.
if (Left.is(TT_JsTypeColon))
       return true;
     // Don't wrap between ":" and "!" of a strict prop init ("field!: type;").
     if (Left.is(tok::exclaim) && Right.is(tok::colon))
       return false;
     // Look for is type annotations like:
     // function f(): a is B { ... }
     // Do not break before is in these cases.
     if (Right.is(Keywords.kw_is)) {
-      const FormatToken *Next = Right.getNextNonComment();
+      FormatToken const *Next = Right.getNextNonComment();
       // If `is` is followed by a colon, it's likely that it's a dict key, so
       // ignore it for this check.
       // For example this is common in Polymer:
       // Polymer({
       //   is: 'name',
       //   ...
       // });
       if (!Next || !Next->is(tok::colon))
return Left.isOneOf(tok::comma, tok::coloncolon, tok::semi, tok::l_brace,
          Right.isOneOf(TT_TrailingReturnArrow, TT_LambdaArrow, tok::lessless,
                        tok::colon, tok::l_square, tok::at) ||
          (Left.is(tok::r_paren) &&
           Right.isOneOf(tok::identifier, tok::kw_const)) ||
          (Left.is(tok::l_paren) && !Right.is(tok::r_paren)) ||
          (Left.is(TT_TemplateOpener) && !Right.is(TT_TemplateCloser));
 }
 
-void TokenAnnotator::printDebugInfo(const AnnotatedLine &Line) {
+void TokenAnnotator::printDebugInfo(AnnotatedLine const &Line) {
   llvm::errs() << "AnnotatedTokens(L=" << Line.Level << "):\n";
-  const FormatToken *Tok = Line.First;
+  FormatToken const *Tok = Line.First;
   while (Tok) {
     llvm::errs() << " M=" << Tok->MustBreakBefore
                  << " C=" << Tok->CanBreakBefore
                  << " T=" << getTokenTypeName(Tok->getType())
                  << " S=" << Tok->SpacesRequiredBefore
                  << " F=" << Tok->Finalized << " B=" << Tok->BlockParameterCount
                  << " BK=" << Tok->getBlockKind() << " P=" << Tok->SplitPenalty
                  << " Name=" << Tok->Tok.getName() << " L=" << Tok->TotalLength
                  << " PPK=" << Tok->getPackingKind() << " FakeLParens=";
     for (unsigned i = 0, e = Tok->FakeLParens.size(); i != e; ++i)
       llvm::errs() << Tok->FakeLParens[i] << "/";
     llvm::errs() << " FakeRParens=" << Tok->FakeRParens;
     llvm::errs() << " II=" << Tok->Tok.getIdentifierInfo();
     llvm::errs() << " Text='" << Tok->TokenText << "'\n";
     if (!Tok->Next)
       assert(Tok == Line.Last);
     Tok = Tok->Next;
   }
   llvm::errs() << "----\n";
 }
 
 FormatStyle::PointerAlignmentStyle
-TokenAnnotator::getTokenReferenceAlignment(const FormatToken &Reference) {
+TokenAnnotator::getTokenReferenceAlignment(FormatToken const &Reference) {
   assert(Reference.isOneOf(tok::amp, tok::ampamp));
   switch (Style.ReferenceAlignment) {
   case FormatStyle::RAS_Pointer:
     return Style.PointerAlignment;
   case FormatStyle::RAS_Left:
     return FormatStyle::PAS_Left;
   case FormatStyle::RAS_Right:
     return FormatStyle::PAS_Right;
   case FormatStyle::RAS_Middle:
     return FormatStyle::PAS_Middle;
   }
   assert(0); //"Unhandled value of ReferenceAlignment"
   return Style.PointerAlignment;
 }
 
 FormatStyle::PointerAlignmentStyle
 TokenAnnotator::getTokenPointerOrReferenceAlignment(
-    const FormatToken &PointerOrReference) {
+    FormatToken const &PointerOrReference) {
   if (PointerOrReference.isOneOf(tok::amp, tok::ampamp)) {
     switch (Style.ReferenceAlignment) {
     case FormatStyle::RAS_Pointer:
       return Style.PointerAlignment;
     case FormatStyle::RAS_Left:
       return FormatStyle::PAS_Left;
     case FormatStyle::RAS_Right:
       return FormatStyle::PAS_Right;

clang/lib/Format/UnwrappedLineFormatter.h

 
 class ContinuationIndenter;
 class WhitespaceManager;
 
 class UnwrappedLineFormatter {
 public:
   UnwrappedLineFormatter(ContinuationIndenter *Indenter,
                          WhitespaceManager *Whitespaces,
-                         const FormatStyle &Style,
-                         const AdditionalKeywords &Keywords,
-                         const SourceManager &SourceMgr,
+                         FormatStyle const &Style,
+                         AdditionalKeywords const &Keywords,
+                         SourceManager const &SourceMgr,
                          FormattingAttemptStatus *Status)
       : Indenter(Indenter), Whitespaces(Whitespaces), Style(Style),
         Keywords(Keywords), SourceMgr(SourceMgr), Status(Status) {}
 
   /// Format the current block and return the penalty.
-  unsigned format(const SmallVectorImpl<AnnotatedLine *> &Lines,
+  unsigned format(SmallVectorImpl<AnnotatedLine *> const &Lines,
                   bool DryRun = false, int AdditionalIndent = 0,
                   bool FixBadIndentation = false, unsigned FirstStartColumn = 0,
                   unsigned NextStartColumn = 0, unsigned LastStartColumn = 0);
 
 private:
   /// Add a new line and the required indent before the first Token
   /// of the \c UnwrappedLine if there was no structural parsing error.
-  void formatFirstToken(const AnnotatedLine &Line,
-                        const AnnotatedLine *PreviousLine,
-                        const AnnotatedLine *PrevPrevLine,
-                        const SmallVectorImpl<AnnotatedLine *> &Lines,
+  void formatFirstToken(AnnotatedLine const &Line,
+                        AnnotatedLine const *PreviousLine,
+                        AnnotatedLine const *PrevPrevLine,
+                        SmallVectorImpl<AnnotatedLine *> const &Lines,
                         unsigned Indent, unsigned NewlineIndent);
 
   /// Returns the column limit for a line, taking into account whether we
   /// need an escaped newline due to a continued preprocessor directive.
   unsigned getColumnLimit(bool InPPDirective,
-                          const AnnotatedLine *NextLine) const;
+                          AnnotatedLine const *NextLine) const;
 
   // Cache to store the penalty of formatting a vector of AnnotatedLines
   // starting from a specific additional offset. Improves performance if there
   // are many nested blocks.
-  std::map<std::pair<const SmallVectorImpl<AnnotatedLine *> *, unsigned>,
+  std::map<std::pair<SmallVectorImpl<AnnotatedLine *> const *, unsigned>,
            unsigned>
       PenaltyCache;
 
   ContinuationIndenter *Indenter;
   WhitespaceManager *Whitespaces;
-  const FormatStyle &Style;
-  const AdditionalKeywords &Keywords;
-  const SourceManager &SourceMgr;
+  FormatStyle const &Style;
+  AdditionalKeywords const &Keywords;
+  SourceManager const &SourceMgr;
   FormattingAttemptStatus *Status;
 };
 } // end namespace format
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_FORMAT_UNWRAPPEDLINEFORMATTER_H

clang/lib/Format/UnwrappedLineFormatter.cpp

 
 #define DEBUG_TYPE "format-formatter"
 
 namespace clang {
 namespace format {
 
 namespace {
 
-bool startsExternCBlock(const AnnotatedLine &Line) {
-  const FormatToken *Next = Line.First->getNextNonComment();
-  const FormatToken *NextNext = Next ? Next->getNextNonComment() : nullptr;
+bool startsExternCBlock(AnnotatedLine const &Line) {
+  FormatToken const *Next = Line.First->getNextNonComment();
+  FormatToken const *NextNext = Next ? Next->getNextNonComment() : nullptr;
   return Line.startsWith(tok::kw_extern) && Next && Next->isStringLiteral() &&
          NextNext && NextNext->is(tok::l_brace);
 }
 
 /// Tracks the indent level of \c AnnotatedLines across levels.
 ///
 /// \c nextLine must be called for each \c AnnotatedLine, after which \c
 /// getIndent() will return the indent for the last line \c nextLine was called
 /// with.
 /// If the line is not formatted (and thus the indent does not change), calling
 /// \c adjustToUnmodifiedLine after the call to \c nextLine will cause
 /// subsequent lines on the same level to be indented at the same level as the
 /// given line.
 class LevelIndentTracker {
 public:
-  LevelIndentTracker(const FormatStyle &Style,
-                     const AdditionalKeywords &Keywords, unsigned StartLevel,
+  LevelIndentTracker(FormatStyle const &Style,
+                     AdditionalKeywords const &Keywords, unsigned StartLevel,
                      int AdditionalIndent)
       : Style(Style), Keywords(Keywords), AdditionalIndent(AdditionalIndent) {
     for (unsigned i = 0; i != StartLevel; ++i)
       IndentForLevel.push_back(Style.IndentWidth * i + AdditionalIndent);
   }
 
   /// Returns the indent for the current line.
   unsigned getIndent() const { return Indent; }
 
   /// Update the indent state given that \p Line is going to be formatted
   /// next.
-  void nextLine(const AnnotatedLine &Line) {
+  void nextLine(AnnotatedLine const &Line) {
     Offset = getIndentOffset(*Line.First);
     // Update the indent level cache size so that we can rely on it
     // having the right size in adjustToUnmodifiedline.
     while (IndentForLevel.size() <= Line.Level)
       IndentForLevel.push_back(-1);
     if (Line.InPPDirective) {
       unsigned IndentWidth =
           (Style.PPIndentWidth >= 0) ? Style.PPIndentWidth : Style.IndentWidth;
       Indent = Line.Level * IndentWidth + AdditionalIndent;
     } else {
       IndentForLevel.resize(Line.Level + 1);
       Indent = getIndent(IndentForLevel, Line.Level);
     }
     if (static_cast<int>(Indent) + Offset >= 0)
       Indent += Offset;
     if (Line.First->is(TT_CSharpGenericTypeConstraint))
       Indent = Line.Level * Style.IndentWidth + Style.ContinuationIndentWidth;
   }
 
   /// Update the indent state given that \p Line indent should be
   /// skipped.
-  void skipLine(const AnnotatedLine &Line) {
+  void skipLine(AnnotatedLine const &Line) {
     while (IndentForLevel.size() <= Line.Level)
       IndentForLevel.push_back(Indent);
   }
 
   /// Update the level indent to adapt to the given \p Line.
   ///
   /// When a line is not formatted, we move the subsequent lines on the same
   /// level to the same indent.
   /// Note that \c nextLine must have been called before this method.
-  void adjustToUnmodifiedLine(const AnnotatedLine &Line) {
+  void adjustToUnmodifiedLine(AnnotatedLine const &Line) {
     unsigned LevelIndent = Line.First->OriginalColumn;
     if (static_cast<int>(LevelIndent) - Offset >= 0)
       LevelIndent -= Offset;
     if ((!Line.First->is(tok::comment) || IndentForLevel[Line.Level] == -1) &&
         !Line.InPPDirective)
       IndentForLevel[Line.Level] = LevelIndent;
   }
 
 private:
   /// Get the offset of the line relatively to the level.
   ///
   /// For example, 'public:' labels in classes are offset by 1 or 2
   /// characters to the left from their level.
-  int getIndentOffset(const FormatToken &RootToken) {
+  int getIndentOffset(FormatToken const &RootToken) {
     if (Style.Language == FormatStyle::LK_Java ||
         Style.Language == FormatStyle::LK_JavaScript || Style.isCSharp())
       return 0;
     if (RootToken.isAccessSpecifier(false) ||
         RootToken.isObjCAccessSpecifier() ||
         (RootToken.isOneOf(Keywords.kw_signals, Keywords.kw_qsignals) &&
          RootToken.Next && RootToken.Next->is(tok::colon))) {
       // The AccessModifierOffset may be overriden by IndentAccessModifiers,
private:
   unsigned getIndent(ArrayRef<int> IndentForLevel, unsigned Level) {
     if (IndentForLevel[Level] != -1)
       return IndentForLevel[Level];
     if (Level == 0)
       return 0;
     return getIndent(IndentForLevel, Level - 1) + Style.IndentWidth;
   }
 
-  const FormatStyle &Style;
-  const AdditionalKeywords &Keywords;
-  const unsigned AdditionalIndent;
+  FormatStyle const &Style;
+  AdditionalKeywords const &Keywords;
+  unsigned const AdditionalIndent;
 
   /// The indent in characters for each level.
   std::vector<int> IndentForLevel;
 
   /// Offset of the current line relative to the indent level.
   ///
   /// For example, the 'public' keywords is often indented with a negative
   /// offset.
   int Offset = 0;
 
   /// The current line's indent.
   unsigned Indent = 0;
 };
 
-const FormatToken *getMatchingNamespaceToken(
-    const AnnotatedLine *Line,
-    const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
+FormatToken const *getMatchingNamespaceToken(
+    AnnotatedLine const *Line,
+    SmallVectorImpl<AnnotatedLine *> const &AnnotatedLines) {
   if (!Line->startsWith(tok::r_brace))
     return nullptr;
   size_t StartLineIndex = Line->MatchingOpeningBlockLineIndex;
   if (StartLineIndex == UnwrappedLine::kInvalidIndex)
     return nullptr;
   assert(StartLineIndex < AnnotatedLines.size());
   return AnnotatedLines[StartLineIndex]->First->getNamespaceToken();
 }
 
-StringRef getNamespaceTokenText(const AnnotatedLine *Line) {
-  const FormatToken *NamespaceToken = Line->First->getNamespaceToken();
+StringRef getNamespaceTokenText(AnnotatedLine const *Line) {
+  FormatToken const *NamespaceToken = Line->First->getNamespaceToken();
   return NamespaceToken ? NamespaceToken->TokenText : StringRef();
 }
 
 StringRef getMatchingNamespaceTokenText(
-    const AnnotatedLine *Line,
-    const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
-  const FormatToken *NamespaceToken =
+    AnnotatedLine const *Line,
+    SmallVectorImpl<AnnotatedLine *> const &AnnotatedLines) {
+  FormatToken const *NamespaceToken =
       getMatchingNamespaceToken(Line, AnnotatedLines);
   return NamespaceToken ? NamespaceToken->TokenText : StringRef();
 }
 
 class LineJoiner {
 public:
-  LineJoiner(const FormatStyle &Style, const AdditionalKeywords &Keywords,
-             const SmallVectorImpl<AnnotatedLine *> &Lines)
+  LineJoiner(FormatStyle const &Style, AdditionalKeywords const &Keywords,
+             SmallVectorImpl<AnnotatedLine *> const &Lines)
       : Style(Style), Keywords(Keywords), End(Lines.end()), Next(Lines.begin()),
         AnnotatedLines(Lines) {}
 
   /// Returns the next line, merging multiple lines into one if possible.
-  const AnnotatedLine *getNextMergedLine(bool DryRun,
+  AnnotatedLine const *getNextMergedLine(bool DryRun,
                                          LevelIndentTracker &IndentTracker) {
     if (Next == End)
       return nullptr;
-    const AnnotatedLine *Current = *Next;
+    AnnotatedLine const *Current = *Next;
     IndentTracker.nextLine(*Current);
     unsigned MergedLines = tryFitMultipleLinesInOne(IndentTracker, Next, End);
     if (MergedLines > 0 && Style.ColumnLimit == 0)
       // Disallow line merging if there is a break at the start of one of the
       // input lines.
       for (unsigned i = 0; i < MergedLines; ++i)
         if (Next[i + 1]->First->NewlinesBefore > 0)
           MergedLines = 0;
     if (!DryRun)
       for (unsigned i = 0; i < MergedLines; ++i)
         join(*Next[0], *Next[i + 1]);
     Next = Next + MergedLines + 1;
     return Current;
   }
 
 private:
   /// Calculates how many lines can be merged into 1 starting at \p I.
   unsigned
   tryFitMultipleLinesInOne(LevelIndentTracker &IndentTracker,
                            SmallVectorImpl<AnnotatedLine *>::const_iterator I,
                            SmallVectorImpl<AnnotatedLine *>::const_iterator E) {
-    const unsigned Indent = IndentTracker.getIndent();
+    unsigned const Indent = IndentTracker.getIndent();
 
     // Can't join the last line with anything.
     if (I + 1 == E)
       return 0;
     // We can never merge stuff if there are trailing line comments.
-    const AnnotatedLine *TheLine = *I;
+    AnnotatedLine const *TheLine = *I;
     if (TheLine->Last->is(TT_LineComment))
       return 0;
     if (I[1]->Type == LT_Invalid || I[1]->First->MustBreakBefore)
       return 0;
     if (TheLine->InPPDirective &&
         (!I[1]->InPPDirective || I[1]->First->HasUnescapedNewline))
       return 0;
 
if (TheLine->Last->is(TT_FunctionLBrace) &&
         I[1]->First->is(tok::r_brace))
       return tryMergeSimpleBlock(I, E, Limit);
 
     // Handle empty record blocks where the brace has already been wrapped
     if (TheLine->Last->is(tok::l_brace) && TheLine->First == TheLine->Last &&
         I != AnnotatedLines.begin()) {
       bool EmptyBlock = I[1]->First->is(tok::r_brace);
 
-      const FormatToken *Tok = I[-1]->First;
+      FormatToken const *Tok = I[-1]->First;
       if (Tok && Tok->is(tok::comment))
         Tok = Tok->getNextNonComment();
 
       if (Tok && Tok->getNamespaceToken())
         return !Style.BraceWrapping.SplitEmptyNamespace && EmptyBlock
                    ? tryMergeSimpleBlock(I, E, Limit)
                    : 0;
 
if (TheLine->First->is(tok::l_brace) && I != AnnotatedLines.begin() &&
         I[-1]->First->isOneOf(tok::kw_case, tok::kw_default))
       return 0;
 
     // Don't merge an empty template class or struct if SplitEmptyRecords
     // is defined.
     if (Style.BraceWrapping.SplitEmptyRecord &&
         TheLine->Last->is(tok::l_brace) && I != AnnotatedLines.begin() &&
         I[-1]->Last) {
-      const FormatToken *Previous = I[-1]->Last;
+      FormatToken const *Previous = I[-1]->Last;
       if (Previous) {
         if (Previous->is(tok::comment))
           Previous = Previous->getPreviousNonComment();
         if (Previous) {
           if (Previous->is(tok::greater) && !I[-1]->InPPDirective)
             return 0;
           if (Previous->is(tok::identifier)) {
-            const FormatToken *PreviousPrevious =
+            FormatToken const *PreviousPrevious =
                 Previous->getPreviousNonComment();
             if (PreviousPrevious &&
                 PreviousPrevious->isOneOf(tok::kw_class, tok::kw_struct))
               return 0;
           }
         }
       }
     }
if (Limit == 0 || I + 1 == E ||
         I[1]->First->isOneOf(tok::kw_case, tok::kw_default))
       return 0;
     if (I[0]->Last->is(tok::l_brace) || I[1]->First->is(tok::l_brace))
       return 0;
     unsigned NumStmts = 0;
     unsigned Length = 0;
     bool EndsWithComment = false;
     bool InPPDirective = I[0]->InPPDirective;
-    const unsigned Level = I[0]->Level;
+    unsigned const Level = I[0]->Level;
     for (; NumStmts < 3; ++NumStmts) {
       if (I + 1 + NumStmts == E)
         break;
-      const AnnotatedLine *Line = I[1 + NumStmts];
+      AnnotatedLine const *Line = I[1 + NumStmts];
       if (Line->InPPDirective != InPPDirective)
         break;
       if (Line->First->isOneOf(tok::kw_case, tok::kw_default, tok::r_brace))
         break;
       if (Line->First->isOneOf(tok::kw_if, tok::kw_for, tok::kw_switch,
                                tok::kw_while) ||
           EndsWithComment)
         return 0;
tryMergeSimpleBlock(SmallVectorImpl<AnnotatedLine *>::const_iterator I,
 
     // Check that the current line allows merging. This depends on whether we
     // are in a control flow statements as well as several style flags.
     if (Line.First->isOneOf(tok::kw_else, tok::kw_case) ||
         (Line.First->Next && Line.First->Next->is(tok::kw_else)))
       return 0;
     // default: in switch statement
     if (Line.First->is(tok::kw_default)) {
-      const FormatToken *Tok = Line.First->getNextNonComment();
+      FormatToken const *Tok = Line.First->getNextNonComment();
       if (Tok && Tok->is(tok::colon))
         return 0;
     }
     if (Line.First->isOneOf(tok::kw_if, tok::kw_while, tok::kw_do, tok::kw_try,
                             tok::kw___try, tok::kw_catch, tok::kw___finally,
                             tok::kw_for, tok::r_brace, Keywords.kw___except)) {
       if (Style.AllowShortBlocksOnASingleLine == FormatStyle::SBS_Never)
         return 0;
private:
 
   bool nextTwoLinesFitInto(SmallVectorImpl<AnnotatedLine *>::const_iterator I,
                            unsigned Limit) {
     if (I[1]->First->MustBreakBefore || I[2]->First->MustBreakBefore)
       return false;
     return 1 + I[1]->Last->TotalLength + 1 + I[2]->Last->TotalLength <= Limit;
   }
 
-  bool containsMustBreak(const AnnotatedLine *Line) {
-    for (const FormatToken *Tok = Line->First; Tok; Tok = Tok->Next) {
+  bool containsMustBreak(AnnotatedLine const *Line) {
+    for (FormatToken const *Tok = Line->First; Tok; Tok = Tok->Next) {
       if (Tok->MustBreakBefore)
         return true;
     }
     return false;
   }
 
-  void join(AnnotatedLine &A, const AnnotatedLine &B) {
+  void join(AnnotatedLine &A, AnnotatedLine const &B) {
     assert(!A.Last->Next);
     assert(!B.First->Previous);
     if (B.Affected)
       A.Affected = true;
     A.Last->Next = B.First;
     B.First->Previous = A.Last;
     B.First->CanBreakBefore = true;
     unsigned LengthA = A.Last->TotalLength + B.First->SpacesRequiredBefore;
     for (FormatToken *Tok = B.First; Tok; Tok = Tok->Next) {
       Tok->TotalLength += LengthA;
       A.Last = Tok;
     }
   }
 
-  const FormatStyle &Style;
-  const AdditionalKeywords &Keywords;
-  const SmallVectorImpl<AnnotatedLine *>::const_iterator End;
+  FormatStyle const &Style;
+  AdditionalKeywords const &Keywords;
+  SmallVectorImpl<AnnotatedLine *>::const_iterator const End;
 
   SmallVectorImpl<AnnotatedLine *>::const_iterator Next;
-  const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines;
+  SmallVectorImpl<AnnotatedLine *> const &AnnotatedLines;
 };
 
 static void markFinalized(FormatToken *Tok) {
   for (; Tok; Tok = Tok->Next) {
     Tok->Finalized = true;
     for (AnnotatedLine *Child : Tok->Children)
       markFinalized(Child->First);
   }
 }
 
 #ifndef NDEBUG
-static void printLineState(const LineState &State) {
+static void printLineState(LineState const &State) {
   llvm::dbgs() << "State: ";
-  for (const ParenState &P : State.Stack) {
+  for (ParenState const &P : State.Stack) {
     llvm::dbgs() << (P.Tok ? P.Tok->TokenText : "F") << "|" << P.Indent << "|"
                  << P.LastSpace << "|" << P.NestedBlockIndent << " ";
   }
   llvm::dbgs() << State.NextToken->TokenText << "\n";
 }
 #endif
 
 /// Base class for classes that format one \c AnnotatedLine.
 class LineFormatter {
 public:
   LineFormatter(ContinuationIndenter *Indenter, WhitespaceManager *Whitespaces,
-                const FormatStyle &Style,
+                FormatStyle const &Style,
                 UnwrappedLineFormatter *BlockFormatter)
       : Indenter(Indenter), Whitespaces(Whitespaces), Style(Style),
         BlockFormatter(BlockFormatter) {}
   virtual ~LineFormatter() {}
 
   /// Formats an \c AnnotatedLine and returns the penalty.
   ///
   /// If \p DryRun is \c false, directly applies the changes.
-  virtual unsigned formatLine(const AnnotatedLine &Line, unsigned FirstIndent,
+  virtual unsigned formatLine(AnnotatedLine const &Line, unsigned FirstIndent,
                               unsigned FirstStartColumn, bool DryRun) = 0;
 
 protected:
   /// If the \p State's next token is an r_brace closing a nested block,
   /// format the nested block before it.
   ///
   /// Returns \c true if all children could be placed successfully and adapts
   /// \p Penalty as well as \p State. If \p DryRun is false, also directly
protected:
   /// break after the "{", format all lines with correct indentation and the put
   /// the closing "}" on yet another new line.
   ///
   /// This enables us to keep the simple structure of the
   /// \c UnwrappedLineFormatter, where we only have two options for each token:
   /// break or don't break.
   bool formatChildren(LineState &State, bool NewLine, bool DryRun,
                       unsigned &Penalty) {
-    const FormatToken *LBrace = State.NextToken->getPreviousNonComment();
+    FormatToken const *LBrace = State.NextToken->getPreviousNonComment();
     FormatToken &Previous = *State.NextToken->Previous;
     if (!LBrace || LBrace->isNot(tok::l_brace) || LBrace->isNot(BK_Block) ||
         Previous.Children.size() == 0)
       // The previous token does not open a block. Nothing to do. We don't
       // assert so that we can simply call this function for all tokens.
       return true;
 
     if (NewLine) {
-      const ParenState &P = State.Stack.back();
+      ParenState const &P = State.Stack.back();
 
       int AdditionalIndent =
           P.Indent - Previous.Children[0]->Level * Style.IndentWidth;
 
       if (Style.LambdaBodyIndentation == FormatStyle::LBI_OuterScope &&
           P.NestedBlockIndent == P.LastSpace) {
         if (State.NextToken->MatchingParen &&
             State.NextToken->MatchingParen->is(TT_LambdaLBrace)) {
bool formatChildren(LineState &State, bool NewLine, bool DryRun,
     // Cannot merge into one line if this line ends on a comment.
     if (Previous.is(tok::comment))
       return false;
 
     // Cannot merge multiple statements into a single line.
     if (Previous.Children.size() > 1)
       return false;
 
-    const AnnotatedLine *Child = Previous.Children[0];
+    AnnotatedLine const *Child = Previous.Children[0];
     // We can't put the closing "}" on a line with a trailing comment.
     if (Child->Last->isTrailingComment())
       return false;
 
     // If the child line exceeds the column limit, we wouldn't want to merge it.
     // We add +2 for the trailing " }".
     if (Style.ColumnLimit > 0 &&
         Child->Last->TotalLength + State.Column + 2 > Style.ColumnLimit)
bool formatChildren(LineState &State, bool NewLine, bool DryRun,
     State.Column += 1 + Child->Last->TotalLength;
     return true;
   }
 
   ContinuationIndenter *Indenter;
 
 private:
   WhitespaceManager *Whitespaces;
-  const FormatStyle &Style;
+  FormatStyle const &Style;
   UnwrappedLineFormatter *BlockFormatter;
 };
 
 /// Formatter that keeps the existing line breaks.
 class NoColumnLimitLineFormatter : public LineFormatter {
 public:
   NoColumnLimitLineFormatter(ContinuationIndenter *Indenter,
                              WhitespaceManager *Whitespaces,
-                             const FormatStyle &Style,
+                             FormatStyle const &Style,
                              UnwrappedLineFormatter *BlockFormatter)
       : LineFormatter(Indenter, Whitespaces, Style, BlockFormatter) {}
 
   /// Formats the line, simply keeping all of the input's line breaking
   /// decisions.
-  unsigned formatLine(const AnnotatedLine &Line, unsigned FirstIndent,
+  unsigned formatLine(AnnotatedLine const &Line, unsigned FirstIndent,
                       unsigned FirstStartColumn, bool DryRun) override {
     assert(!DryRun);
     LineState State = Indenter->getInitialState(FirstIndent, FirstStartColumn,
                                                 &Line, /*DryRun=*/false);
     while (State.NextToken) {
       bool Newline =
           Indenter->mustBreak(State) ||
           (Indenter->canBreak(State) && State.NextToken->NewlinesBefore > 0);
       unsigned Penalty = 0;
       formatChildren(State, Newline, /*DryRun=*/false, Penalty);
       Indenter->addTokenToState(State, Newline, /*DryRun=*/false);
     }
     return 0;
   }
 };
 
 /// Formatter that puts all tokens into a single line without breaks.
 class NoLineBreakFormatter : public LineFormatter {
 public:
   NoLineBreakFormatter(ContinuationIndenter *Indenter,
-                       WhitespaceManager *Whitespaces, const FormatStyle &Style,
+                       WhitespaceManager *Whitespaces, FormatStyle const &Style,
                        UnwrappedLineFormatter *BlockFormatter)
       : LineFormatter(Indenter, Whitespaces, Style, BlockFormatter) {}
 
   /// Puts all tokens into a single line.
-  unsigned formatLine(const AnnotatedLine &Line, unsigned FirstIndent,
+  unsigned formatLine(AnnotatedLine const &Line, unsigned FirstIndent,
                       unsigned FirstStartColumn, bool DryRun) override {
     unsigned Penalty = 0;
     LineState State =
         Indenter->getInitialState(FirstIndent, FirstStartColumn, &Line, DryRun);
     while (State.NextToken) {
       formatChildren(State, /*NewLine=*/false, DryRun, Penalty);
       Indenter->addTokenToState(
           State, /*Newline=*/State.NextToken->MustBreakBefore, DryRun);
     }
     return Penalty;
   }
 };
 
 /// Finds the best way to break lines.
 class OptimizingLineFormatter : public LineFormatter {
 public:
   OptimizingLineFormatter(ContinuationIndenter *Indenter,
                           WhitespaceManager *Whitespaces,
-                          const FormatStyle &Style,
+                          FormatStyle const &Style,
                           UnwrappedLineFormatter *BlockFormatter)
       : LineFormatter(Indenter, Whitespaces, Style, BlockFormatter) {}
 
   /// Formats the line by finding the best line breaks with line lengths
   /// below the column limit.
-  unsigned formatLine(const AnnotatedLine &Line, unsigned FirstIndent,
+  unsigned formatLine(AnnotatedLine const &Line, unsigned FirstIndent,
                       unsigned FirstStartColumn, bool DryRun) override {
     LineState State =
         Indenter->getInitialState(FirstIndent, FirstStartColumn, &Line, DryRun);
 
     // If the ObjC method declaration does not fit on a line, we should format
     // it with one arg per line.
     if (State.Line->Type == LT_ObjCMethodDecl)
       State.Stack.back().BreakBeforeParameter = true;
private:
   /// In case of equal penalties, we want to prefer states that were inserted
   /// first. During state generation we make sure that we insert states first
   /// that break the line as late as possible.
   typedef std::pair<unsigned, unsigned> OrderedPenalty;
 
   /// An edge in the solution space from \c Previous->State to \c State,
   /// inserting a newline dependent on the \c NewLine.
   struct StateNode {
-    StateNode(const LineState &State, bool NewLine, StateNode *Previous)
+    StateNode(LineState const &State, bool NewLine, StateNode *Previous)
         : State(State), NewLine(NewLine), Previous(Previous) {}
     LineState State;
     bool NewLine;
     StateNode *Previous;
   };
 
   /// An item in the prioritized BFS search queue. The \c StateNode's
   /// \c State has the given \c OrderedPenalty.
private:
   }
 
   llvm::SpecificBumpPtrAllocator<StateNode> Allocator;
 };
 
 } // anonymous namespace
 
 unsigned UnwrappedLineFormatter::format(
-    const SmallVectorImpl<AnnotatedLine *> &Lines, bool DryRun,
+    SmallVectorImpl<AnnotatedLine *> const &Lines, bool DryRun,
     int AdditionalIndent, bool FixBadIndentation, unsigned FirstStartColumn,
     unsigned NextStartColumn, unsigned LastStartColumn) {
   LineJoiner Joiner(Style, Keywords, Lines);
 
   // Try to look up already computed penalty in DryRun-mode.
-  std::pair<const SmallVectorImpl<AnnotatedLine *> *, unsigned> CacheKey(
+  std::pair<SmallVectorImpl<AnnotatedLine *> const *, unsigned> CacheKey(
       &Lines, AdditionalIndent);
   auto CacheIt = PenaltyCache.find(CacheKey);
   if (DryRun && CacheIt != PenaltyCache.end())
     return CacheIt->second;
 
   assert(!Lines.empty());
   unsigned Penalty = 0;
   LevelIndentTracker IndentTracker(Style, Keywords, Lines[0]->Level,
                                    AdditionalIndent);
-  const AnnotatedLine *PrevPrevLine = nullptr;
-  const AnnotatedLine *PreviousLine = nullptr;
-  const AnnotatedLine *NextLine = nullptr;
+  AnnotatedLine const *PrevPrevLine = nullptr;
+  AnnotatedLine const *PreviousLine = nullptr;
+  AnnotatedLine const *NextLine = nullptr;
 
   // The minimum level of consecutive lines that have been formatted.
   unsigned RangeMinLevel = UINT_MAX;
 
   bool FirstLine = true;
-  for (const AnnotatedLine *Line =
+  for (AnnotatedLine const *Line =
            Joiner.getNextMergedLine(DryRun, IndentTracker);
        Line; Line = NextLine, FirstLine = false) {
-    const AnnotatedLine &TheLine = *Line;
+    AnnotatedLine const &TheLine = *Line;
     unsigned Indent = IndentTracker.getIndent();
 
     // We continue formatting unchanged lines to adjust their indent, e.g. if a
     // scope was added. However, we need to carefully stop doing this when we
     // exit the scope of affected lines to prevent indenting a the entire
     // remaining file if it currently missing a closing brace.
     bool PreviousRBrace =
         PreviousLine && PreviousLine->startsWith(tok::r_brace);
if (ShouldFormat && TheLine.Type != LT_Invalid) {
         Penalty += OptimizingLineFormatter(Indenter, Whitespaces, Style, this)
                        .formatLine(TheLine, NextStartColumn + Indent,
                                    FirstLine ? FirstStartColumn : 0, DryRun);
       RangeMinLevel = std::min(RangeMinLevel, TheLine.Level);
     } else {
       // If no token in the current line is affected, we still need to format
       // affected children.
       if (TheLine.ChildrenAffected)
-        for (const FormatToken *Tok = TheLine.First; Tok; Tok = Tok->Next)
+        for (FormatToken const *Tok = TheLine.First; Tok; Tok = Tok->Next)
           if (!Tok->Children.empty())
             format(Tok->Children, DryRun);
 
       // Adapt following lines on the current indent level to the same level
       // unless the current \c AnnotatedLine is not at the beginning of a line.
       bool StartsNewLine =
           TheLine.First->NewlinesBefore > 0 || TheLine.First->IsFirst;
       if (StartsNewLine)
for (AnnotatedLine const *Line =
     PrevPrevLine = PreviousLine;
     PreviousLine = &TheLine;
   }
   PenaltyCache[CacheKey] = Penalty;
   return Penalty;
 }
 
 void UnwrappedLineFormatter::formatFirstToken(
-    const AnnotatedLine &Line, const AnnotatedLine *PreviousLine,
-    const AnnotatedLine *PrevPrevLine,
-    const SmallVectorImpl<AnnotatedLine *> &Lines, unsigned Indent,
+    AnnotatedLine const &Line, AnnotatedLine const *PreviousLine,
+    AnnotatedLine const *PrevPrevLine,
+    SmallVectorImpl<AnnotatedLine *> const &Lines, unsigned Indent,
     unsigned NewlineIndent) {
   FormatToken &RootToken = *Line.First;
   if (RootToken.is(tok::eof)) {
     unsigned Newlines = std::min(RootToken.NewlinesBefore, 1u);
     unsigned TokenIndent = Newlines ? NewlineIndent : 0;
     Whitespaces->replaceWhitespace(RootToken, Newlines, TokenIndent,
                                    TokenIndent);
     return;
case FormatStyle::ELBAMS_Leave:
       break;
     case FormatStyle::ELBAMS_LogicalBlock:
       if (PreviousLine->Last->isOneOf(tok::semi, tok::r_brace) && Newlines <= 1)
         Newlines = 2;
       if (PreviousLine->First->isAccessSpecifier())
         Newlines = 1; // Previous is an access modifier remove all new lines.
       break;
     case FormatStyle::ELBAMS_Always: {
-      const FormatToken *previousToken;
+      FormatToken const *previousToken;
       if (PreviousLine->Last->is(tok::comment))
         previousToken = PreviousLine->Last->getPreviousNonComment();
       else
         previousToken = PreviousLine->Last;
       if ((!previousToken || !previousToken->is(tok::l_brace)) && Newlines <= 1)
         Newlines = 2;
     } break;
     }
void UnwrappedLineFormatter::formatFirstToken(
   Whitespaces->replaceWhitespace(RootToken, Newlines, Indent, Indent,
                                  /*IsAligned=*/false,
                                  Line.InPPDirective &&
                                      !RootToken.HasUnescapedNewline);
 }
 
 unsigned
 UnwrappedLineFormatter::getColumnLimit(bool InPPDirective,
-                                       const AnnotatedLine *NextLine) const {
+                                       AnnotatedLine const *NextLine) const {
   // In preprocessor directives reserve two chars for trailing " \" if the
   // next line continues the preprocessor directive.
   bool ContinuesPPDirective =
       InPPDirective &&
       // If there is no next line, this is likely a child line and the parent
       // continues the preprocessor directive.
       (!NextLine ||
        (NextLine->InPPDirective &&
         // If there is an unescaped newline between this line and the next, the
         // next line starts a new preprocessor directive.
         !NextLine->First->HasUnescapedNewline));
   return Style.ColumnLimit - (ContinuesPPDirective ? 2 : 0);
 }
 
 } // namespace format
 } // namespace clang

clang/lib/Format/UnwrappedLineParser.h

struct UnwrappedLine {
   static const size_t kInvalidIndex = -1;
 
   unsigned FirstStartColumn = 0;
 };
 
 class UnwrappedLineConsumer {
 public:
   virtual ~UnwrappedLineConsumer() {}
-  virtual void consumeUnwrappedLine(const UnwrappedLine &Line) = 0;
+  virtual void consumeUnwrappedLine(UnwrappedLine const &Line) = 0;
   virtual void finishRun() = 0;
 };
 
 class FormatTokenSource;
 
 class UnwrappedLineParser {
 public:
-  UnwrappedLineParser(const FormatStyle &Style,
-                      const AdditionalKeywords &Keywords,
+  UnwrappedLineParser(FormatStyle const &Style,
+                      AdditionalKeywords const &Keywords,
                       unsigned FirstStartColumn, ArrayRef<FormatToken *> Tokens,
                       UnwrappedLineConsumer &Callback);
 
   void parse();
 
 private:
   void reset();
   void parseFile();
private:
   //
   // Comments specifies the sequence of comment tokens to analyze. They get
   // either pushed to the current line or added to the comments before the next
   // token.
   //
   // NextTok specifies the next token. A null pointer NextTok is supported, and
   // signifies either the absence of a next token, or that the next token
   // shouldn't be taken into accunt for the analysis.
-  void distributeComments(const SmallVectorImpl<FormatToken *> &Comments,
-                          const FormatToken *NextTok);
+  void distributeComments(SmallVectorImpl<FormatToken *> const &Comments,
+                          FormatToken const *NextTok);
 
   // Adds the comment preceding the next token to unwrapped lines.
   void flushComments(bool NewlineBeforeNext);
   void pushToken(FormatToken *Tok);
   void calculateBraceTypes(bool ExpectClassBody = false);
 
   // Marks a conditional compilation edge (for example, an '#if', '#ifdef',
   // '#else' or merge conflict marker). If 'Unreachable' is true, assumes
   // this branch either cannot be taken (for example '#if false'), or should
   // not be taken in this round.
   void conditionalCompilationCondition(bool Unreachable);
   void conditionalCompilationStart(bool Unreachable);
   void conditionalCompilationAlternative();
   void conditionalCompilationEnd();
 
-  bool isOnNewLine(const FormatToken &FormatTok);
+  bool isOnNewLine(FormatToken const &FormatTok);
 
   // Compute hash of the current preprocessor branch.
   // This is used to identify the different branches, and thus track if block
   // open and close in the same branch.
   size_t computePPHash() const;
 
   // FIXME: We are constantly running into bugs where Line.Level is incorrectly
   // subtracted from beyond 0. Introduce a method to subtract from Line.Level
private:
   // there is an unfinished previous unwrapped line, will point to
   // \c &PreprocessorDirectives.
   SmallVectorImpl<UnwrappedLine> *CurrentLines;
 
   // We store for each line whether it must be a declaration depending on
   // whether we are in a compound statement or not.
   std::vector<bool> DeclarationScopeStack;
 
-  const FormatStyle &Style;
-  const AdditionalKeywords &Keywords;
+  FormatStyle const &Style;
+  AdditionalKeywords const &Keywords;
 
   llvm::Regex CommentPragmasRegex;
 
   FormatTokenSource *Tokens;
   UnwrappedLineConsumer &Callback;
 
   // FIXME: This is a temporary measure until we have reworked the ownership
   // of the format tokens. The goal is to have the actual tokens created and

clang/lib/Format/UnwrappedLineParser.cpp

else
       Line.MustBeDeclaration = true;
   }
 
 private:
   UnwrappedLine &Line;
   std::vector<bool> &Stack;
 };
 
-static bool isLineComment(const FormatToken &FormatTok) {
+static bool isLineComment(FormatToken const &FormatTok) {
   return FormatTok.is(tok::comment) && !FormatTok.TokenText.startswith("/*");
 }
 
 // Checks if \p FormatTok is a line comment that continues the line comment
 // \p Previous. The original column of \p MinColumnToken is used to determine
 // whether \p FormatTok is indented enough to the right to continue \p Previous.
-static bool continuesLineComment(const FormatToken &FormatTok,
-                                 const FormatToken *Previous,
-                                 const FormatToken *MinColumnToken) {
+static bool continuesLineComment(FormatToken const &FormatTok,
+                                 FormatToken const *Previous,
+                                 FormatToken const *MinColumnToken) {
   if (!Previous || !MinColumnToken)
     return false;
   unsigned MinContinueColumn =
       MinColumnToken->OriginalColumn + (isLineComment(*MinColumnToken) ? 0 : 1);
   return isLineComment(FormatTok) && FormatTok.NewlinesBefore == 1 &&
          isLineComment(*Previous) &&
          FormatTok.OriginalColumn >= MinContinueColumn;
 }
private:
 
   std::unique_ptr<UnwrappedLine> PreBlockLine;
   SmallVectorImpl<UnwrappedLine> *OriginalLines;
 };
 
 class CompoundStatementIndenter {
 public:
   CompoundStatementIndenter(UnwrappedLineParser *Parser,
-                            const FormatStyle &Style, unsigned &LineLevel)
+                            FormatStyle const &Style, unsigned &LineLevel)
       : CompoundStatementIndenter(Parser, LineLevel,
                                   Style.BraceWrapping.AfterControlStatement,
                                   Style.BraceWrapping.IndentBraces) {}
   CompoundStatementIndenter(UnwrappedLineParser *Parser, unsigned &LineLevel,
                             bool WrapBrace, bool IndentBrace)
       : LineLevel(LineLevel), OldLineLevel(LineLevel) {
     if (WrapBrace)
       Parser->addUnwrappedLine();

 
 private:
   ArrayRef<FormatToken *> Tokens;
   int Position;
 };
 
 } // end anonymous namespace
 
-UnwrappedLineParser::UnwrappedLineParser(const FormatStyle &Style,
-                                         const AdditionalKeywords &Keywords,
+UnwrappedLineParser::UnwrappedLineParser(FormatStyle const &Style,
+                                         AdditionalKeywords const &Keywords,
                                          unsigned FirstStartColumn,
                                          ArrayRef<FormatToken *> Tokens,
                                          UnwrappedLineConsumer &Callback)
     : Line(new UnwrappedLine), MustBreakBeforeNextToken(false),
       CurrentLines(&Lines), Style(Style), Keywords(Keywords),
       CommentPragmasRegex(Style.CommentPragmas), Tokens(nullptr),
       Callback(Callback), AllTokens(Tokens), PPBranchLevel(-1),
       IncludeGuard(Style.IndentPPDirectives == FormatStyle::PPDIS_None

 
 void UnwrappedLineParser::calculateBraceTypes(bool ExpectClassBody) {
   // We'll parse forward through the tokens until we hit
   // a closing brace or eof - note that getNextToken() will
   // parse macros, so this will magically work inside macro
   // definitions, too.
   unsigned StoredPosition = Tokens->getPosition();
   FormatToken *Tok = FormatTok;
-  const FormatToken *PrevTok = Tok->Previous;
+  FormatToken const *PrevTok = Tok->Previous;
   // Keep a stack of positions of lbrace tokens. We will
   // update information about whether an lbrace starts a
   // braced init list or a different block during the loop.
   SmallVector<FormatToken *, 8> LBraceStack;
   assert(Tok->Tok.is(tok::l_brace));
   do {
     // Get next non-comment token.
     FormatToken *NextTok;

 template <class T>
 static inline void hash_combine(std::size_t &seed, const T &v) {
   std::hash<T> hasher;
   seed ^= hasher(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
 }
 
 size_t UnwrappedLineParser::computePPHash() const {
   size_t h = 0;
-  for (const auto &i : PPStack) {
+  for (auto const &i : PPStack) {
     hash_combine(h, size_t(i.Kind));
     hash_combine(h, i.Line);
   }
   return h;
 }
 
 void UnwrappedLineParser::parseBlock(bool MustBeDeclaration, unsigned AddLevels,
                                      bool MunchSemi,
                                      bool UnindentWhitesmithsBraces) {
   assert(FormatTok->isOneOf(tok::l_brace, TT_MacroBlockBegin) &&
          "'{' or macro block token expected");
-  const bool MacroBlock = FormatTok->is(TT_MacroBlockBegin);
+  bool const MacroBlock = FormatTok->is(TT_MacroBlockBegin);
   FormatTok->setBlockKind(BK_Block);
 
   // For Whitesmiths mode, jump to the next level prior to skipping over the
   // braces.
   if (AddLevels > 0 && Style.BreakBeforeBraces == FormatStyle::BS_Whitesmiths)
     ++Line->Level;
 
   size_t PPStartHash = computePPHash();
if (PPStartHash == PPEndHash) {
     if (OpeningLineIndex != UnwrappedLine::kInvalidIndex) {
       // Update the opening line to add the forward reference as well
       (*CurrentLines)[OpeningLineIndex].MatchingClosingBlockLineIndex =
           CurrentLines->size() - 1;
     }
   }
 }
 
-static bool isGoogScope(const UnwrappedLine &Line) {
+static bool isGoogScope(UnwrappedLine const &Line) {
   // FIXME: Closure-library specific stuff should not be hard-coded but be
   // configurable.
   if (Line.Tokens.size() < 4)
     return false;
   auto I = Line.Tokens.begin();
   if (I->Tok->TokenText != "goog")
     return false;
   ++I;
   if (I->Tok->isNot(tok::period))
     return false;
   ++I;
   if (I->Tok->TokenText != "scope")
     return false;
   ++I;
   return I->Tok->is(tok::l_paren);
 }
 
-static bool isIIFE(const UnwrappedLine &Line,
-                   const AdditionalKeywords &Keywords) {
+static bool isIIFE(UnwrappedLine const &Line,
+                   AdditionalKeywords const &Keywords) {
   // Look for the start of an immediately invoked anonymous function.
   // https://en.wikipedia.org/wiki/Immediately-invoked_function_expression
   // This is commonly done in JavaScript to create a new, anonymous scope.
   // Example: (function() { ... })()
   if (Line.Tokens.size() < 3)
     return false;
   auto I = Line.Tokens.begin();
   if (I->Tok->isNot(tok::l_paren))
     return false;
   ++I;
   if (I->Tok->isNot(Keywords.kw_function))
     return false;
   ++I;
   return I->Tok->is(tok::l_paren);
 }
 
-static bool ShouldBreakBeforeBrace(const FormatStyle &Style,
-                                   const FormatToken &InitialToken) {
+static bool ShouldBreakBeforeBrace(FormatStyle const &Style,
+                                   FormatToken const &InitialToken) {
   if (InitialToken.isOneOf(tok::kw_namespace, TT_NamespaceMacro))
     return Style.BraceWrapping.AfterNamespace;
   if (InitialToken.is(tok::kw_class))
     return Style.BraceWrapping.AfterClass;
   if (InitialToken.is(tok::kw_union))
     return Style.BraceWrapping.AfterUnion;
   if (InitialToken.is(tok::kw_struct))
     return Style.BraceWrapping.AfterStruct;
void UnwrappedLineParser::parsePPUnknown() {
   if (Style.IndentPPDirectives != FormatStyle::PPDIS_None)
     Line->Level += PPBranchLevel + 1;
   addUnwrappedLine();
 }
 
 // Here we exclude certain tokens that are not usually the first token in an
 // unwrapped line. This is used in attempt to distinguish macro calls without
 // trailing semicolons from other constructs split to several lines.
-static bool tokenCanStartNewLine(const FormatToken &Tok) {
+static bool tokenCanStartNewLine(FormatToken const &Tok) {
   // Semicolon can be a null-statement, l_square can be a start of a macro or
   // a C++11 attribute, but this doesn't seem to be common.
   return Tok.isNot(tok::semi) && Tok.isNot(tok::l_brace) &&
          Tok.isNot(TT_AttributeSquare) &&
          // Tokens that can only be used as binary operators and a part of
          // overloaded operator names.
          Tok.isNot(tok::period) && Tok.isNot(tok::periodstar) &&
          Tok.isNot(tok::arrow) && Tok.isNot(tok::arrowstar) &&
return Tok.isNot(tok::semi) && Tok.isNot(tok::l_brace) &&
          // Colon is used in labels, base class lists, initializer lists,
          // range-based for loops, ternary operator, but should never be the
          // first token in an unwrapped line.
          Tok.isNot(tok::colon) &&
          // 'noexcept' is a trailing annotation.
          Tok.isNot(tok::kw_noexcept);
 }
 
-static bool mustBeJSIdent(const AdditionalKeywords &Keywords,
-                          const FormatToken *FormatTok) {
+static bool mustBeJSIdent(AdditionalKeywords const &Keywords,
+                          FormatToken const *FormatTok) {
   // FIXME: This returns true for C/C++ keywords like 'struct'.
   return FormatTok->is(tok::identifier) &&
          (FormatTok->Tok.getIdentifierInfo() == nullptr ||
           !FormatTok->isOneOf(
               Keywords.kw_in, Keywords.kw_of, Keywords.kw_as, Keywords.kw_async,
               Keywords.kw_await, Keywords.kw_yield, Keywords.kw_finally,
               Keywords.kw_function, Keywords.kw_import, Keywords.kw_is,
               Keywords.kw_let, Keywords.kw_var, tok::kw_const,
               Keywords.kw_abstract, Keywords.kw_extends, Keywords.kw_implements,
               Keywords.kw_instanceof, Keywords.kw_interface, Keywords.kw_throws,
               Keywords.kw_from));
 }
 
-static bool mustBeJSIdentOrValue(const AdditionalKeywords &Keywords,
-                                 const FormatToken *FormatTok) {
+static bool mustBeJSIdentOrValue(AdditionalKeywords const &Keywords,
+                                 FormatToken const *FormatTok) {
   return FormatTok->Tok.isLiteral() ||
          FormatTok->isOneOf(tok::kw_true, tok::kw_false) ||
          mustBeJSIdent(Keywords, FormatTok);
 }
 
 // isJSDeclOrStmt returns true if |FormatTok| starts a declaration or statement
 // when encountered after a value (see mustBeJSIdentOrValue).
-static bool isJSDeclOrStmt(const AdditionalKeywords &Keywords,
-                           const FormatToken *FormatTok) {
+static bool isJSDeclOrStmt(AdditionalKeywords const &Keywords,
+                           FormatToken const *FormatTok) {
   return FormatTok->isOneOf(
       tok::kw_return, Keywords.kw_yield,
       // conditionals
       tok::kw_if, tok::kw_else,
       // loops
       tok::kw_for, tok::kw_while, tok::kw_do, tok::kw_continue, tok::kw_break,
       // switch/case
       tok::kw_switch, tok::kw_case,
if (Style.isCpp() && FormatTok->is(TT_NamespaceMacro)) {
       return;
     }
     // In all other cases, parse the declaration.
     break;
   default:
     break;
   }
   do {
-    const FormatToken *Previous = FormatTok->Previous;
+    FormatToken const *Previous = FormatTok->Previous;
     switch (FormatTok->Tok.getKind()) {
     case tok::at:
       nextToken();
       if (FormatTok->Tok.is(tok::l_brace)) {
         nextToken();
         parseBracedList();
         break;
       } else if (Style.Language == FormatStyle::LK_Java &&
bool UnwrappedLineParser::tryToParseLambda() {
   }
   FormatTok->setType(TT_LambdaLBrace);
   LSquare.setType(TT_LambdaLSquare);
   parseChildBlock();
   return true;
 }
 
 bool UnwrappedLineParser::tryToParseLambdaIntroducer() {
-  const FormatToken *Previous = FormatTok->Previous;
+  FormatToken const *Previous = FormatTok->Previous;
   if (Previous &&
       (Previous->isOneOf(tok::identifier, tok::kw_operator, tok::kw_new,
                          tok::kw_delete, tok::l_square) ||
        FormatTok->isCppStructuredBinding(Style) || Previous->closesScope() ||
        Previous->isSimpleTypeSpecifier())) {
     nextToken();
     return false;
   }
void UnwrappedLineParser::parseTryCatch() {
   if (NeedsUnwrappedLine)
     addUnwrappedLine();
 }
 
 void UnwrappedLineParser::parseNamespace() {
   assert(FormatTok->isOneOf(tok::kw_namespace, TT_NamespaceMacro) &&
          "'namespace' expected");
 
-  const FormatToken &InitialToken = *FormatTok;
+  FormatToken const &InitialToken = *FormatTok;
   nextToken();
   if (InitialToken.is(TT_NamespaceMacro)) {
     parseParens();
   } else {
     while (FormatTok->isOneOf(tok::identifier, tok::coloncolon, tok::kw_inline,
                               tok::l_square)) {
       if (FormatTok->is(tok::l_square))
         parseSquare();
void UnwrappedLineParser::parseJavaEnumBody() {
   // Parse the class body after the enum's ";" if any.
   parseLevel(/*HasOpeningBrace=*/true);
   nextToken();
   --Line->Level;
   addUnwrappedLine();
 }
 
 void UnwrappedLineParser::parseRecord(bool ParseAsExpr) {
-  const FormatToken &InitialToken = *FormatTok;
+  FormatToken const &InitialToken = *FormatTok;
   nextToken();
 
   // The actual identifier can be a nested name specifier, and in macros
   // it is often token-pasted.
   // An [[attribute]] can be before the identifier.
   while (FormatTok->isOneOf(tok::identifier, tok::coloncolon, tok::hashhash,
                             tok::kw___attribute, tok::kw___declspec,
                             tok::kw_alignas, tok::l_square, tok::r_square) ||
void UnwrappedLineParser::parseStatementMacro() {
   nextToken();
   if (FormatTok->is(tok::l_paren))
     parseParens();
   if (FormatTok->is(tok::semi))
     nextToken();
   addUnwrappedLine();
 }
 
-LLVM_ATTRIBUTE_UNUSED static void printDebugInfo(const UnwrappedLine &Line,
+LLVM_ATTRIBUTE_UNUSED static void printDebugInfo(UnwrappedLine const &Line,
                                                  StringRef Prefix = "") {
   llvm::dbgs() << Prefix << "Line(" << Line.Level
                << ", FSC=" << Line.FirstStartColumn << ")"
                << (Line.InPPDirective ? " MACRO" : "") << ": ";
   for (std::list<UnwrappedLineNode>::const_iterator I = Line.Tokens.begin(),
                                                     E = Line.Tokens.end();
        I != E; ++I) {
     llvm::dbgs() << I->Tok->Tok.getName() << "["
                  << "T=" << (unsigned)I->Tok->getType()
                  << ", OC=" << I->Tok->OriginalColumn << "] ";
   }
   for (std::list<UnwrappedLineNode>::const_iterator I = Line.Tokens.begin(),
                                                     E = Line.Tokens.end();
        I != E; ++I) {
-    const UnwrappedLineNode &Node = *I;
+    UnwrappedLineNode const &Node = *I;
     for (SmallVectorImpl<UnwrappedLine>::const_iterator
              I = Node.Children.begin(),
              E = Node.Children.end();
          I != E; ++I) {
       printDebugInfo(*I, "\nChild: ");
     }
   }
   llvm::dbgs() << "\n";
if (CurrentLines == &Lines && !PreprocessorDirectives.empty()) {
     PreprocessorDirectives.clear();
   }
   // Disconnect the current token from the last token on the previous line.
   FormatTok->Previous = nullptr;
 }
 
 bool UnwrappedLineParser::eof() const { return FormatTok->Tok.is(tok::eof); }
 
-bool UnwrappedLineParser::isOnNewLine(const FormatToken &FormatTok) {
+bool UnwrappedLineParser::isOnNewLine(FormatToken const &FormatTok) {
   return (Line->InPPDirective || FormatTok.HasUnescapedNewline) &&
          FormatTok.NewlinesBefore > 0;
 }
 
 // Checks if \p FormatTok is a line comment that continues the line comment
 // section on \p Line.
 static bool
-continuesLineCommentSection(const FormatToken &FormatTok,
-                            const UnwrappedLine &Line,
-                            const llvm::Regex &CommentPragmasRegex) {
+continuesLineCommentSection(FormatToken const &FormatTok,
+                            UnwrappedLine const &Line,
+                            llvm::Regex const &CommentPragmasRegex) {
   if (Line.Tokens.empty())
     return false;
 
   StringRef IndentContent = FormatTok.TokenText;
   if (FormatTok.TokenText.startswith("//") ||
       FormatTok.TokenText.startswith("/*"))
     IndentContent = FormatTok.TokenText.substr(2);
   if (CommentPragmasRegex.match(IndentContent))
continuesLineCommentSection(FormatToken const &FormatTok,
   // } while (true);
   //
   // and:
   //
   // enum {
   //   a, // first line
   //   // second line
   // };
-  const FormatToken *MinColumnToken = Line.Tokens.front().Tok;
+  FormatToken const *MinColumnToken = Line.Tokens.front().Tok;
 
   // Scan for '{//'. If found, use the column of '{' as a min column for line
   // comment section continuation.
-  const FormatToken *PreviousToken = nullptr;
-  for (const UnwrappedLineNode &Node : Line.Tokens) {
+  FormatToken const *PreviousToken = nullptr;
+  for (UnwrappedLineNode const &Node : Line.Tokens) {
     if (PreviousToken && PreviousToken->is(tok::l_brace) &&
         isLineComment(*Node.Tok)) {
       MinColumnToken = PreviousToken;
       break;
     }
     PreviousToken = Node.Tok;
 
     // Grab the last newline preceding a token in this unwrapped line.
void UnwrappedLineParser::nextToken(int LevelDifference) {
   if (Style.Language != FormatStyle::LK_JavaScript)
     readToken(LevelDifference);
   else
     readTokenWithJavaScriptASI();
   FormatTok->Previous = Previous;
 }
 
 void UnwrappedLineParser::distributeComments(
-    const SmallVectorImpl<FormatToken *> &Comments,
-    const FormatToken *NextTok) {
+    SmallVectorImpl<FormatToken *> const &Comments,
+    FormatToken const *NextTok) {
   // Whether or not a line comment token continues a line is controlled by
   // the method continuesLineCommentSection, with the following caveat:
   //
   // Define a trail of Comments to be a nonempty proper postfix of Comments such
   // that each comment line from the trail is aligned with the next token, if
   // the next token exists. If a trail exists, the beginning of the maximal
   // trail is marked as a start of a new comment section.
   //

clang/lib/Format/UsingDeclarationsSorter.h

 
 #include "TokenAnalyzer.h"
 
 namespace clang {
 namespace format {
 
 class UsingDeclarationsSorter : public TokenAnalyzer {
 public:
-  UsingDeclarationsSorter(const Environment &Env, const FormatStyle &Style);
+  UsingDeclarationsSorter(Environment const &Env, FormatStyle const &Style);
 
   std::pair<tooling::Replacements, unsigned>
   analyze(TokenAnnotator &Annotator,
           SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
           FormatTokenLexer &Tokens) override;
 };
 
 } // end namespace format
 } // end namespace clang
 
 #endif

clang/lib/Format/UsingDeclarationsSorter.cpp

for (size_t I = 0, E = std::min(SizeA, SizeB); I < E; ++I) {
     int C = NamesA[I].compare_insensitive(NamesB[I]);
     if (C != 0)
       return C;
   }
   return 0;
 }
 
 struct UsingDeclaration {
-  const AnnotatedLine *Line;
+  AnnotatedLine const *Line;
   std::string Label;
 
-  UsingDeclaration(const AnnotatedLine *Line, const std::string &Label)
+  UsingDeclaration(AnnotatedLine const *Line, std::string const &Label)
       : Line(Line), Label(Label) {}
 
-  bool operator<(const UsingDeclaration &Other) const {
+  bool operator<(UsingDeclaration const &Other) const {
     return compareLabels(Label, Other.Label) < 0;
   }
 };
 
 /// Computes the label of a using declaration starting at tthe using token
 /// \p UsingTok.
 /// If \p UsingTok doesn't begin a using declaration, returns the empty string.
 /// Note that this detects specifically using declarations, as in:
 /// using A::B::C;
 /// and not type aliases, as in:
 /// using A = B::C;
 /// Type aliases are in general not safe to permute.
-std::string computeUsingDeclarationLabel(const FormatToken *UsingTok) {
+std::string computeUsingDeclarationLabel(FormatToken const *UsingTok) {
   assert(UsingTok && UsingTok->is(tok::kw_using) && "Expecting a using token");
   std::string Label;
-  const FormatToken *Tok = UsingTok->Next;
+  FormatToken const *Tok = UsingTok->Next;
   if (Tok && Tok->is(tok::kw_typename)) {
     Label.append("typename ");
     Tok = Tok->Next;
   }
   if (Tok && Tok->is(tok::coloncolon)) {
     Label.append("::");
     Tok = Tok->Next;
   }
std::string computeUsingDeclarationLabel(FormatToken const *UsingTok) {
   }
   if (HasIdentifier && Tok && Tok->isOneOf(tok::semi, tok::comma))
     return Label;
   return "";
 }
 
 void endUsingDeclarationBlock(
     SmallVectorImpl<UsingDeclaration> *UsingDeclarations,
-    const SourceManager &SourceMgr, tooling::Replacements *Fixes) {
+    SourceManager const &SourceMgr, tooling::Replacements *Fixes) {
   bool BlockAffected = false;
-  for (const UsingDeclaration &Declaration : *UsingDeclarations) {
+  for (UsingDeclaration const &Declaration : *UsingDeclarations) {
     if (Declaration.Line->Affected) {
       BlockAffected = true;
       break;
     }
   }
   if (!BlockAffected) {
     UsingDeclarations->clear();
     return;
   }
   SmallVector<UsingDeclaration, 4> SortedUsingDeclarations(
       UsingDeclarations->begin(), UsingDeclarations->end());
   llvm::stable_sort(SortedUsingDeclarations);
   SortedUsingDeclarations.erase(
       std::unique(SortedUsingDeclarations.begin(),
                   SortedUsingDeclarations.end(),
-                  [](const UsingDeclaration &a, const UsingDeclaration &b) {
+                  [](UsingDeclaration const &a, UsingDeclaration const &b) {
                     return a.Label == b.Label;
                   }),
       SortedUsingDeclarations.end());
   for (size_t I = 0, E = UsingDeclarations->size(); I < E; ++I) {
     if (I >= SortedUsingDeclarations.size()) {
       // This using declaration has been deduplicated, delete it.
       auto Begin =
           (*UsingDeclarations)[I].Line->First->WhitespaceRange.getBegin();
if (Err) {
                    << llvm::toString(std::move(Err)) << "\n";
     }
   }
   UsingDeclarations->clear();
 }
 
 } // namespace
 
-UsingDeclarationsSorter::UsingDeclarationsSorter(const Environment &Env,
-                                                 const FormatStyle &Style)
+UsingDeclarationsSorter::UsingDeclarationsSorter(Environment const &Env,
+                                                 FormatStyle const &Style)
     : TokenAnalyzer(Env, Style) {}
 
 std::pair<tooling::Replacements, unsigned> UsingDeclarationsSorter::analyze(
     TokenAnnotator &Annotator, SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
     FormatTokenLexer &Tokens) {
-  const SourceManager &SourceMgr = Env.getSourceManager();
+  SourceManager const &SourceMgr = Env.getSourceManager();
   AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
   tooling::Replacements Fixes;
   SmallVector<UsingDeclaration, 4> UsingDeclarations;
   for (size_t I = 0, E = AnnotatedLines.size(); I != E; ++I) {
-    const auto *FirstTok = AnnotatedLines[I]->First;
+    auto const *FirstTok = AnnotatedLines[I]->First;
     if (AnnotatedLines[I]->InPPDirective ||
         !AnnotatedLines[I]->startsWith(tok::kw_using) || FirstTok->Finalized) {
       endUsingDeclarationBlock(&UsingDeclarations, SourceMgr, &Fixes);
       continue;
     }
     if (FirstTok->NewlinesBefore > 1)
       endUsingDeclarationBlock(&UsingDeclarations, SourceMgr, &Fixes);
-    const auto *UsingTok =
+    auto const *UsingTok =
         FirstTok->is(tok::comment) ? FirstTok->getNextNonComment() : FirstTok;
     std::string Label = computeUsingDeclarationLabel(UsingTok);
     if (Label.empty()) {
       endUsingDeclarationBlock(&UsingDeclarations, SourceMgr, &Fixes);
       continue;
     }
     UsingDeclarations.push_back(UsingDeclaration(AnnotatedLines[I], Label));
   }
   endUsingDeclarationBlock(&UsingDeclarations, SourceMgr, &Fixes);
   return {Fixes, 0};
 }
 
 } // namespace format
 } // namespace clang

clang/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(const SourceManager &SourceMgr, const FormatStyle &Style,
+  WhitespaceManager(SourceManager const &SourceMgr, FormatStyle const &Style,
                     bool UseCRLF)
       : SourceMgr(SourceMgr), Style(Style), UseCRLF(UseCRLF) {}
 
   bool useCRLF() const { return UseCRLF; }
 
   /// Replaces the whitespace in front of \p Tok. Only call once for
   /// each \c AnnotatedToken.
   ///
   /// \p StartOfTokenColumn is the column at which the token will start after
   /// this replacement. It is needed for determining how \p Spaces is turned
   /// into tabs and spaces for some format styles.
   void replaceWhitespace(FormatToken &Tok, unsigned Newlines, unsigned Spaces,
                          unsigned StartOfTokenColumn, bool isAligned = false,
                          bool InPPDirective = false);
 
   /// Adds information about an unchangeable token's whitespace.
   ///
   /// Needs to be called for every token for which \c replaceWhitespace
   /// was not called.
-  void addUntouchableToken(const FormatToken &Tok, bool InPPDirective);
+  void addUntouchableToken(FormatToken const &Tok, bool InPPDirective);
 
-  llvm::Error addReplacement(const tooling::Replacement &Replacement);
+  llvm::Error addReplacement(tooling::Replacement const &Replacement);
 
   /// Inserts or replaces whitespace in the middle of a token.
   ///
   /// Inserts \p PreviousPostfix, \p Newlines, \p Spaces and \p CurrentPrefix
   /// (in this order) at \p Offset inside \p Tok, replacing \p ReplaceChars
   /// characters.
   ///
   /// Note: \p Spaces can be negative to retain information about initial
   /// relative column offset between a line of a block comment and the start of
   /// the comment. This negative offset may be compensated by trailing comment
   /// alignment here. In all other cases negative \p Spaces will be truncated to
   /// 0.
   ///
   /// When \p InPPDirective is true, escaped newlines are inserted. \p Spaces is
   /// used to align backslashes correctly.
-  void replaceWhitespaceInToken(const FormatToken &Tok, unsigned Offset,
+  void replaceWhitespaceInToken(FormatToken const &Tok, unsigned Offset,
                                 unsigned ReplaceChars,
                                 StringRef PreviousPostfix,
                                 StringRef CurrentPrefix, bool InPPDirective,
                                 unsigned Newlines, int Spaces);
 
   /// Returns all the \c Replacements created during formatting.
-  const tooling::Replacements &generateReplacements();
+  tooling::Replacements const &generateReplacements();
 
   /// Represents a change before a token, a break inside a token,
   /// or the layout of an unchanged token (or whitespace within).
   struct Change {
     /// Functor to sort changes in original source order.
     class IsBeforeInFile {
     public:
-      IsBeforeInFile(const SourceManager &SourceMgr) : SourceMgr(SourceMgr) {}
-      bool operator()(const Change &C1, const Change &C2) const;
+      IsBeforeInFile(SourceManager const &SourceMgr) : SourceMgr(SourceMgr) {}
+      bool operator()(Change const &C1, Change const &C2) const;
 
     private:
-      const SourceManager &SourceMgr;
+      SourceManager const &SourceMgr;
     };
 
     /// Creates a \c Change.
     ///
     /// The generated \c Change will replace the characters at
     /// \p OriginalWhitespaceRange with a concatenation of
     /// \p PreviousLinePostfix, \p NewlinesBefore line breaks, \p Spaces spaces
     /// and \p CurrentLinePrefix.
     ///
     /// \p StartOfTokenColumn and \p InPPDirective will be used to lay out
     /// trailing comments and escaped newlines.
-    Change(const FormatToken &Tok, bool CreateReplacement,
+    Change(FormatToken const &Tok, bool CreateReplacement,
            SourceRange OriginalWhitespaceRange, int Spaces,
            unsigned StartOfTokenColumn, unsigned NewlinesBefore,
            StringRef PreviousLinePostfix, StringRef CurrentLinePrefix,
            bool IsAligned, bool ContinuesPPDirective, bool IsInsideToken);
 
     // The kind of the token whose whitespace this change replaces, or in which
     // this change inserts whitespace.
     // FIXME: Currently this is not set correctly for breaks inside comments, as
     // the \c BreakableToken is still doing its own alignment.
-    const FormatToken *Tok;
+    FormatToken const *Tok;
 
     bool CreateReplacement;
     // Changes might be in the middle of a token, so we cannot just keep the
     // FormatToken around to query its information.
     SourceRange OriginalWhitespaceRange;
     unsigned StartOfTokenColumn;
     unsigned NewlinesBefore;
     std::string PreviousLinePostfix;
struct Change {
     // These fields are used to retain correct relative line indentation in a
     // block comment when aligning trailing comments.
     //
     // If this Change represents a continuation of a block comment,
     // \c StartOfBlockComment is pointer to the first Change in the block
     // comment. \c IndentationOffset is a relative column offset to this
     // change, so that the correct column can be reconstructed at the end of
     // the alignment process.
-    const Change *StartOfBlockComment;
+    Change const *StartOfBlockComment;
     int IndentationOffset;
 
     // Depth of conditionals. Computed from tracking fake parenthesis, except
     // it does not increase the indent for "chained" conditionals.
     int ConditionalsLevel;
 
     // A combination of indent, nesting and conditionals levels, which are used
     // in tandem to compute lexical scope, for the purposes of deciding
     // when to stop consecutive alignment runs.
     std::tuple<unsigned, unsigned, unsigned> indentAndNestingLevel() const {
       return std::make_tuple(Tok->IndentLevel, Tok->NestingLevel,
                              ConditionalsLevel);
     }
   };
 
 private:
   struct CellDescription {
     unsigned Index = 0;
     unsigned Cell = 0;
     unsigned EndIndex = 0;
     bool HasSplit = false;
     CellDescription *NextColumnElement = nullptr;
 
-    constexpr bool operator==(const CellDescription &Other) const {
+    constexpr bool operator==(CellDescription const &Other) const {
       return Index == Other.Index && Cell == Other.Cell &&
              EndIndex == Other.EndIndex;
     }
-    constexpr bool operator!=(const CellDescription &Other) const {
+    constexpr bool operator!=(CellDescription const &Other) const {
       return !(*this == Other);
     }
   };
 
   struct CellDescriptions {
     SmallVector<CellDescription> Cells;
     unsigned CellCount = 0;
     unsigned InitialSpaces = 0;
private:
   unsigned calculateCellWidth(unsigned Start, unsigned End,
                               bool WithSpaces = false) const;
 
   /// Get a set of fully specified CellDescriptions between \p Start and
   /// \p End of the change list.
   CellDescriptions getCells(unsigned Start, unsigned End);
 
   /// Does this \p Cell contain a split element?
-  static bool isSplitCell(const CellDescription &Cell);
+  static bool isSplitCell(CellDescription const &Cell);
 
   /// Get the width of the preceeding cells from \p Start to \p End.
   template <typename I>
   auto getNetWidth(const I &Start, const I &End, unsigned InitialSpaces) const {
     auto NetWidth = InitialSpaces;
     for (auto PrevIter = Start; PrevIter != End; ++PrevIter) {
       // If we broke the line the initial spaces are already
       // accounted for.
       if (Changes[PrevIter->Index].NewlinesBefore > 0)
         NetWidth = 0;
       NetWidth +=
           calculateCellWidth(PrevIter->Index, PrevIter->EndIndex, true) + 1;
     }
     return NetWidth;
   }
 
   /// Get the maximum width of a cell in a sequence of columns.
   template <typename I>
   unsigned getMaximumCellWidth(I CellIter, unsigned NetWidth) const {
     unsigned CellWidth =
         calculateCellWidth(CellIter->Index, CellIter->EndIndex, true);
     if (Changes[CellIter->Index].NewlinesBefore == 0)
       CellWidth += NetWidth;
-    for (const auto *Next = CellIter->NextColumnElement; Next != nullptr;
+    for (auto const *Next = CellIter->NextColumnElement; Next != nullptr;
          Next = Next->NextColumnElement) {
       auto ThisWidth = calculateCellWidth(Next->Index, Next->EndIndex, true);
       if (Changes[Next->Index].NewlinesBefore == 0)
         ThisWidth += NetWidth;
       CellWidth = std::max(CellWidth, ThisWidth);
     }
     return CellWidth;
   }
 
   /// Get The maximum width of all columns to a given cell.
   template <typename I>
   unsigned getMaximumNetWidth(const I &CellStart, const I &CellStop,
                               unsigned InitialSpaces,
                               unsigned CellCount) const {
     auto MaxNetWidth = getNetWidth(CellStart, CellStop, InitialSpaces);
     auto RowCount = 1U;
     auto Offset = std::distance(CellStart, CellStop);
-    for (const auto *Next = CellStop->NextColumnElement; Next != nullptr;
+    for (auto const *Next = CellStop->NextColumnElement; Next != nullptr;
          Next = Next->NextColumnElement) {
       auto Start = (CellStart + RowCount * CellCount);
       auto End = Start + Offset;
       MaxNetWidth =
           std::max(MaxNetWidth, getNetWidth(Start, End, InitialSpaces));
       ++RowCount;
     }
     return MaxNetWidth;
void appendEscapedNewlineText(std::string &Text, unsigned Newlines,
                                 unsigned EscapedNewlineColumn);
   void appendIndentText(std::string &Text, unsigned IndentLevel,
                         unsigned Spaces, unsigned WhitespaceStartColumn,
                         bool IsAligned);
   unsigned appendTabIndent(std::string &Text, unsigned Spaces,
                            unsigned Indentation);
 
   SmallVector<Change, 16> Changes;
-  const SourceManager &SourceMgr;
+  SourceManager const &SourceMgr;
   tooling::Replacements Replaces;
-  const FormatStyle &Style;
+  FormatStyle const &Style;
   bool UseCRLF;
 };
 
 } // namespace format
 } // namespace clang
 
 #endif

clang/lib/Format/WhitespaceManager.cpp

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include <algorithm>
 
 namespace clang {
 namespace format {
 
 bool WhitespaceManager::Change::IsBeforeInFile::operator()(
-    const Change &C1, const Change &C2) const {
+    Change const &C1, Change const &C2) const {
   return SourceMgr.isBeforeInTranslationUnit(
       C1.OriginalWhitespaceRange.getBegin(),
       C2.OriginalWhitespaceRange.getBegin());
 }
 
-WhitespaceManager::Change::Change(const FormatToken &Tok,
+WhitespaceManager::Change::Change(FormatToken const &Tok,
                                   bool CreateReplacement,
                                   SourceRange OriginalWhitespaceRange,
                                   int Spaces, unsigned StartOfTokenColumn,
                                   unsigned NewlinesBefore,
                                   StringRef PreviousLinePostfix,
                                   StringRef CurrentLinePrefix, bool IsAligned,
                                   bool ContinuesPPDirective, bool IsInsideToken)
     : Tok(&Tok), CreateReplacement(CreateReplacement),
if (Tok.Finalized)
     return;
   Tok.setDecision((Newlines > 0) ? FD_Break : FD_Continue);
   Changes.push_back(Change(Tok, /*CreateReplacement=*/true, Tok.WhitespaceRange,
                            Spaces, StartOfTokenColumn, Newlines, "", "",
                            IsAligned, InPPDirective && !Tok.IsFirst,
                            /*IsInsideToken=*/false));
 }
 
-void WhitespaceManager::addUntouchableToken(const FormatToken &Tok,
+void WhitespaceManager::addUntouchableToken(FormatToken const &Tok,
                                             bool InPPDirective) {
   if (Tok.Finalized)
     return;
   Changes.push_back(Change(Tok, /*CreateReplacement=*/false,
                            Tok.WhitespaceRange, /*Spaces=*/0,
                            Tok.OriginalColumn, Tok.NewlinesBefore, "", "",
                            /*IsAligned=*/false, InPPDirective && !Tok.IsFirst,
                            /*IsInsideToken=*/false));
 }
 
 llvm::Error
-WhitespaceManager::addReplacement(const tooling::Replacement &Replacement) {
+WhitespaceManager::addReplacement(tooling::Replacement const &Replacement) {
   return Replaces.add(Replacement);
 }
 
 void WhitespaceManager::replaceWhitespaceInToken(
-    const FormatToken &Tok, unsigned Offset, unsigned ReplaceChars,
+    FormatToken const &Tok, unsigned Offset, unsigned ReplaceChars,
     StringRef PreviousPostfix, StringRef CurrentPrefix, bool InPPDirective,
     unsigned Newlines, int Spaces) {
   if (Tok.Finalized)
     return;
   SourceLocation Start = Tok.getStartOfNonWhitespace().getLocWithOffset(Offset);
   Changes.push_back(
       Change(Tok, /*CreateReplacement=*/true,
              SourceRange(Start, Start.getLocWithOffset(ReplaceChars)), Spaces,
              std::max(0, Spaces), Newlines, PreviousPostfix, CurrentPrefix,
              /*IsAligned=*/true, InPPDirective && !Tok.IsFirst,
              /*IsInsideToken=*/true));
 }
 
-const tooling::Replacements &WhitespaceManager::generateReplacements() {
+tooling::Replacements const &WhitespaceManager::generateReplacements() {
   if (Changes.empty())
     return Replaces;
 
   llvm::sort(Changes, Change::IsBeforeInFile(SourceMgr));
   calculateLineBreakInformation();
   alignConsecutiveMacros();
   alignConsecutiveDeclarations();
   alignConsecutiveBitFields();
for (unsigned i = 1, e = Changes.size(); i != e; ++i) {
     SourceLocation PreviousOriginalWhitespaceEnd =
         Changes[i - 1].OriginalWhitespaceRange.getEnd();
     unsigned OriginalWhitespaceStartOffset =
         SourceMgr.getFileOffset(OriginalWhitespaceStart);
     unsigned PreviousOriginalWhitespaceEndOffset =
         SourceMgr.getFileOffset(PreviousOriginalWhitespaceEnd);
     assert(PreviousOriginalWhitespaceEndOffset <=
            OriginalWhitespaceStartOffset);
-    const char *const PreviousOriginalWhitespaceEndData =
+    char const *const PreviousOriginalWhitespaceEndData =
         SourceMgr.getCharacterData(PreviousOriginalWhitespaceEnd);
     StringRef Text(PreviousOriginalWhitespaceEndData,
                    SourceMgr.getCharacterData(OriginalWhitespaceStart) -
                        PreviousOriginalWhitespaceEndData);
     // Usually consecutive changes would occur in consecutive tokens. This is
     // not the case however when analyzing some preprocessor runs of the
     // annotated lines. For example, in this code:
     //
Changes[i - 1].IsTrailingComment =
         // comments.
         OriginalWhitespaceStart != PreviousOriginalWhitespaceEnd;
   }
   // FIXME: The last token is currently not always an eof token; in those
   // cases, setting TokenLength of the last token to 0 is wrong.
   Changes.back().TokenLength = 0;
   Changes.back().IsTrailingComment = Changes.back().Tok->is(tok::comment);
 
-  const WhitespaceManager::Change *LastBlockComment = nullptr;
+  WhitespaceManager::Change const *LastBlockComment = nullptr;
   for (auto &Change : Changes) {
     // Reset the IsTrailingComment flag for changes inside of trailing comments
     // so they don't get realigned later. Comment line breaks however still need
     // to be aligned.
     if (Change.IsInsideToken && Change.NewlinesBefore == 0)
       Change.IsTrailingComment = false;
     Change.StartOfBlockComment = nullptr;
     Change.IndentationOffset = 0;
for (unsigned i = Change.Tok->FakeRParens; i > 0 && ScopeStack.size();
         --ConditionalsLevel;
     }
   }
 }
 
 // Align a single sequence of tokens, see AlignTokens below.
 template <typename F>
 static void
-AlignTokenSequence(const FormatStyle &Style, unsigned Start, unsigned End,
+AlignTokenSequence(FormatStyle const &Style, unsigned Start, unsigned End,
                    unsigned Column, F &&Matches,
                    SmallVector<WhitespaceManager::Change, 16> &Changes) {
   bool FoundMatchOnLine = false;
   int Shift = 0;
 
   // ScopeStack keeps track of the current scope depth. It contains indices of
   // the first token on each scope.
   // We only run the "Matches" function on tokens from the outer-most scope.

 // alignment on the entire sequence, including the nested levels.
 // When doing so, most of the nested tokens are skipped, because their
 // alignment was already handled by the recursive invocations of this function.
 // However, the special exception is that we do NOT skip function parameters
 // that are split across multiple lines. See the test case in FormatTest.cpp
 // that mentions "split function parameter alignment" for an example of this.
 template <typename F>
 static unsigned AlignTokens(
-    const FormatStyle &Style, F &&Matches,
+    FormatStyle const &Style, F &&Matches,
     SmallVector<WhitespaceManager::Change, 16> &Changes, unsigned StartAt,
-    const FormatStyle::AlignConsecutiveStyle &ACS = FormatStyle::ACS_None) {
+    FormatStyle::AlignConsecutiveStyle const &ACS = FormatStyle::ACS_None) {
   unsigned MinColumn = 0;
   unsigned MaxColumn = UINT_MAX;
 
   // Line number of the start and the end of the current token sequence.
   unsigned StartOfSequence = 0;
   unsigned EndOfSequence = 0;
 
   // Measure the scope level (i.e. depth of (), [], {}) of the first token, and

 // Sequences start from the first matching token to align, and end at the
 // first token of the first line that doesn't need to be aligned.
 //
 // We need to adjust the StartOfTokenColumn of each Change that is on a line
 // containing any matching token to be aligned and located after such token.
 static void AlignMacroSequence(
     unsigned &StartOfSequence, unsigned &EndOfSequence, unsigned &MinColumn,
     unsigned &MaxColumn, bool &FoundMatchOnLine,
-    std::function<bool(const WhitespaceManager::Change &C)> AlignMacrosMatches,
+    std::function<bool(WhitespaceManager::Change const &C)> AlignMacrosMatches,
     SmallVector<WhitespaceManager::Change, 16> &Changes) {
   if (StartOfSequence > 0 && StartOfSequence < EndOfSequence) {
 
     FoundMatchOnLine = false;
     int Shift = 0;
 
     for (unsigned I = StartOfSequence; I != EndOfSequence; ++I) {
       if (Changes[I].NewlinesBefore > 0) {
static void AlignMacroSequence(
   StartOfSequence = 0;
   EndOfSequence = 0;
 }
 
 void WhitespaceManager::alignConsecutiveMacros() {
   if (Style.AlignConsecutiveMacros == FormatStyle::ACS_None)
     return;
 
-  auto AlignMacrosMatches = [](const Change &C) {
+  auto AlignMacrosMatches = [](Change const &C) {
     const FormatToken *Current = C.Tok;
     unsigned SpacesRequiredBefore = 1;
 
     if (Current->SpacesRequiredBefore == 0 || !Current->Previous)
       return false;
 
     Current = Current->Previous;
 

 }
 
 void WhitespaceManager::alignConsecutiveAssignments() {
   if (Style.AlignConsecutiveAssignments == FormatStyle::ACS_None)
     return;
 
   AlignTokens(
       Style,
-      [&](const Change &C) {
+      [&](Change const &C) {
         // Do not align on equal signs that are first on a line.
         if (C.NewlinesBefore > 0)
           return false;
 
         // Do not align on equal signs that are last on a line.
         if (&C != &Changes.back() && (&C + 1)->NewlinesBefore > 0)
           return false;
 
for (auto i = 0U; i < CellDescs.CellCount; i++, ++CellIter) {
     auto CellWidth = getMaximumCellWidth(CellIter, NetWidth);
 
     if (Changes[CellIter->Index].Tok->is(tok::r_brace)) {
       // So in here we want to see if there is a brace that falls
       // on a line that was split. If so on that line we make sure that
       // the spaces in front of the brace are enough.
       Changes[CellIter->Index].NewlinesBefore = 0;
       Changes[CellIter->Index].Spaces = 0;
-      for (const auto *Next = CellIter->NextColumnElement; Next != nullptr;
+      for (auto const *Next = CellIter->NextColumnElement; Next != nullptr;
            Next = Next->NextColumnElement) {
         Changes[Next->Index].Spaces = 0;
         Changes[Next->Index].NewlinesBefore = 0;
       }
       // Unless the array is empty, we need the position of all the
       // immediately adjacent cells
       if (CellIter != Cells.begin()) {
         auto ThisNetWidth =
             getNetWidth(Cells.begin(), CellIter, CellDescs.InitialSpaces);
         auto MaxNetWidth =
             getMaximumNetWidth(Cells.begin(), CellIter, CellDescs.InitialSpaces,
                                CellDescs.CellCount);
         if (ThisNetWidth < MaxNetWidth)
           Changes[CellIter->Index].Spaces = (MaxNetWidth - ThisNetWidth);
         auto RowCount = 1U;
         auto Offset = std::distance(Cells.begin(), CellIter);
-        for (const auto *Next = CellIter->NextColumnElement; Next != nullptr;
+        for (auto const *Next = CellIter->NextColumnElement; Next != nullptr;
              Next = Next->NextColumnElement) {
           auto *Start = (Cells.begin() + RowCount * CellDescs.CellCount);
           auto *End = Start + Offset;
           ThisNetWidth = getNetWidth(Start, End, CellDescs.InitialSpaces);
           if (ThisNetWidth < MaxNetWidth)
             Changes[Next->Index].Spaces = (MaxNetWidth - ThisNetWidth);
           ++RowCount;
         }
       }
     } else {
       auto ThisWidth =
           calculateCellWidth(CellIter->Index, CellIter->EndIndex, true) +
           NetWidth;
       if (Changes[CellIter->Index].NewlinesBefore == 0) {
         Changes[CellIter->Index].Spaces = (CellWidth - (ThisWidth + NetWidth));
         Changes[CellIter->Index].Spaces += (i > 0) ? 1 : 0;
       }
       alignToStartOfCell(CellIter->Index, CellIter->EndIndex);
-      for (const auto *Next = CellIter->NextColumnElement; Next != nullptr;
+      for (auto const *Next = CellIter->NextColumnElement; Next != nullptr;
            Next = Next->NextColumnElement) {
         ThisWidth =
             calculateCellWidth(Next->Index, Next->EndIndex, true) + NetWidth;
         if (Changes[Next->Index].NewlinesBefore == 0) {
           Changes[Next->Index].Spaces = (CellWidth - ThisWidth);
           Changes[Next->Index].Spaces += (i > 0) ? 1 : 0;
         }
         alignToStartOfCell(Next->Index, Next->EndIndex);
auto ThisNetWidth =
         getNetWidth(Cells.begin(), CellIter, CellDescs.InitialSpaces);
     if (Changes[CellIter->Index].NewlinesBefore == 0) {
       Changes[CellIter->Index].Spaces =
           MaxNetWidth - ThisNetWidth +
           (Changes[CellIter->Index].Tok->isNot(tok::r_brace) ? 1 : 0);
     }
     auto RowCount = 1U;
     auto Offset = std::distance(Cells.begin(), CellIter);
-    for (const auto *Next = CellIter->NextColumnElement; Next != nullptr;
+    for (auto const *Next = CellIter->NextColumnElement; Next != nullptr;
          Next = Next->NextColumnElement) {
       auto *Start = (Cells.begin() + RowCount * CellDescs.CellCount);
       auto *End = Start + Offset;
       auto ThisNetWidth = getNetWidth(Start, End, CellDescs.InitialSpaces);
       if (Changes[Next->Index].NewlinesBefore == 0) {
         Changes[Next->Index].Spaces =
             MaxNetWidth - ThisNetWidth +
             (Changes[Next->Index].Tok->isNot(tok::r_brace) ? 1 : 0);
       }
       ++RowCount;
     }
   }
 }
 
-bool WhitespaceManager::isSplitCell(const CellDescription &Cell) {
+bool WhitespaceManager::isSplitCell(CellDescription const &Cell) {
   if (Cell.HasSplit)
     return true;
-  for (const auto *Next = Cell.NextColumnElement; Next != nullptr;
+  for (auto const *Next = Cell.NextColumnElement; Next != nullptr;
        Next = Next->NextColumnElement) {
     if (Next->HasSplit)
       return true;
   }
   return false;
 }
 
 WhitespaceManager::CellDescriptions WhitespaceManager::getCells(unsigned Start,
                                                                 unsigned End) {
 
   unsigned Depth = 0;
   unsigned Cell = 0;
   unsigned CellCount = 0;
   unsigned InitialSpaces = 0;
   unsigned InitialTokenLength = 0;
   unsigned EndSpaces = 0;
   SmallVector<CellDescription> Cells;
-  const FormatToken *MatchingParen = nullptr;
+  FormatToken const *MatchingParen = nullptr;
   for (unsigned i = Start; i < End; ++i) {
     auto &C = Changes[i];
     if (C.Tok->is(tok::l_brace))
       ++Depth;
     else if (C.Tok->is(tok::r_brace))
       --Depth;
     if (Depth == 2) {
       if (C.Tok->is(tok::l_brace)) {
if (Depth == 2) {
       }
     } else if (Depth == 1) {
       if (C.Tok == MatchingParen) {
         if (!Cells.empty())
           Cells.back().EndIndex = i;
         Cells.push_back(CellDescription{i, ++Cell, i + 1, false, nullptr});
         CellCount = Cell + 1;
         // Go to the next non-comment and ensure there is a break in front
-        const auto *NextNonComment = C.Tok->getNextNonComment();
+        auto const *NextNonComment = C.Tok->getNextNonComment();
         while (NextNonComment->is(tok::comma))
           NextNonComment = NextNonComment->getNextNonComment();
         auto j = i;
         while (Changes[j].Tok != NextNonComment && j < End)
           j++;
         if (j < End && Changes[j].NewlinesBefore == 0 &&
             Changes[j].Tok->isNot(tok::r_brace)) {
           Changes[j].NewlinesBefore = 1;
if (CellIter->NextColumnElement == nullptr &&
       }
     }
   }
   return std::move(CellDesc);
 }
 
 void WhitespaceManager::generateChanges() {
   for (unsigned i = 0, e = Changes.size(); i != e; ++i) {
-    const Change &C = Changes[i];
+    Change const &C = Changes[i];
     if (i > 0) {
       assert(Changes[i - 1].OriginalWhitespaceRange.getBegin() !=
                  C.OriginalWhitespaceRange.getBegin() &&
              "Generating two replacements for the same location");
     }
     if (C.CreateReplacement) {
       std::string ReplacementText = C.PreviousLinePostfix;
       if (C.ContinuesPPDirective)