[clang-format] DO NOT COMMIT - Demo of East/West Const Fixer on clang-format

[MyDeveloperDay]

Summary

The revision is not for committing it is a demonstration of the East/West const fixer in clang-format working on clang/lib/Format.

[JonasToth]

Yeah! nice work :)

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:
   }
 
   /// 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,
                  llvm::Regex &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,

 };
 
 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,
                  llvm::Regex &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,
                          llvm::Regex &CommentPragmasRegex) const = 0;
 
   // Contains the original text of the lines of the block comment.
   //
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,
                  llvm::Regex &CommentPragmasRegex) const override;
   unsigned getRangeLength(unsigned LineIndex, unsigned Offset,
                           StringRef::size_type Length,
                           unsigned StartColumn) const override;
   unsigned getRemainingLength(unsigned LineIndex, unsigned Offset,
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,
                               unsigned OriginalStartColumn, bool FirstInLine,
                               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;

clang/lib/Format/BreakableToken.cpp

 #include "llvm/Support/Debug.h"
 #include <algorithm>
 
 #define DEBUG_TYPE "format-token-breaker"
 
 namespace clang {
 namespace format {
 
-static const char *const Blanks = " \t\v\f\r";
+static char const *const Blanks = " \t\v\f\r";
 static bool IsBlank(char C) {
   switch (C) {
   case ' ':
   case '\t':
   case '\v':
   case '\f':
   case '\r':
     return true;
   default:
     return false;
   }
 }
 
 static StringRef getLineCommentIndentPrefix(StringRef Comment,
-                                            const FormatStyle &Style) {
-  static const char *const KnownCStylePrefixes[] = {"///<", "//!<", "///", "//",
+                                            FormatStyle const &Style) {
+  static char const *const KnownCStylePrefixes[] = {"///<", "//!<", "///", "//",
                                                     "//!"};
-  static const char *const KnownTextProtoPrefixes[] = {"//", "#", "##", "###",
+  static char const *const KnownTextProtoPrefixes[] = {"//", "#", "##", "###",
                                                        "####"};
-  ArrayRef<const char *> KnownPrefixes(KnownCStylePrefixes);
+  ArrayRef<char const *> KnownPrefixes(KnownCStylePrefixes);
   if (Style.Language == FormatStyle::LK_TextProto)
     KnownPrefixes = KnownTextProtoPrefixes;
 
   StringRef LongestPrefix;
   for (StringRef KnownPrefix : KnownPrefixes) {
     if (Comment.startswith(KnownPrefix)) {
       size_t PrefixLength = KnownPrefix.size();
       while (PrefixLength < Comment.size() && Comment[PrefixLength] == ' ')
         ++PrefixLength;
       if (PrefixLength > LongestPrefix.size())
         LongestPrefix = Comment.substr(0, PrefixLength);
     }
   }
   return LongestPrefix;
 }
 
 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 (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, llvm::Regex &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,
void BreakableComment::compressWhitespace(
   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;
static bool mayReflowContent(StringRef Content) {
   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("*/"));
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,
+    FormatToken const &Token, unsigned StartColumn,
     unsigned OriginalStartColumn, bool FirstInLine, bool InPPDirective,
-    encoding::Encoding Encoding, const FormatStyle &Style)
+    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;
-  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");

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;
+  RawStringFormatStyleManager const 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), 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) {}
 
   /// \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 {
   /// The start of a nested block (e.g. lambda introducer in C++ or
   /// "function" in JavaScript) is not wrapped to a new line.
   bool NestedBlockInlined : 1;
 
   /// \c true if the current \c ParenState represents an Objective-C
   /// array literal.
   bool IsInsideObjCArrayLiteral : 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,
+static unsigned getLengthToMatchingParen(FormatToken const &Tok,
                                          const std::vector<ParenState> &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) {
     if (Format.Language == Language)
       return StringRef(Format.CanonicalDelimiter);
   }
   return "";
 }
 
 RawStringFormatStyleManager::RawStringFormatStyleManager(
-    const FormatStyle &CodeStyle) {
+    FormatStyle const &CodeStyle) {
   for (const auto &RawStringFormat : CodeStyle.RawStringFormats) {
     llvm::Optional<FormatStyle> LanguageStyle =
         CodeStyle.GetLanguageStyle(RawStringFormat.Language);
     if (!LanguageStyle) {
       FormatStyle PredefinedStyle;
       if (!getPredefinedStyle(RawStringFormat.BasedOnStyle,
                               RawStringFormat.Language, &PredefinedStyle)) {
         PredefinedStyle = getLLVMStyle();

 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.BlockKind == 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 (Current.MustBreakBefore || Current.is(TT_InlineASMColon))
     return true;
   if (State.Stack.back().BreakBeforeClosingBrace &&
       Current.closesBlockOrBlockTypeList(Style))
     return true;
   if (Previous.is(tok::semi) && State.LineContainsContinuedForLoopSection)
     return true;
   if (Style.Language == FormatStyle::LK_ObjC &&
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;
-  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);
if (State.Stack.back().Indent == State.FirstIndent && PreviousNonComment &&
     // just flushing continuations left.
     return State.Stack.back().Indent + Style.ContinuationIndentWidth;
   return State.Stack.back().Indent;
 }
 
 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.isOneOf(tok::comma, TT_BinaryOperator))
     State.Stack.back().NoLineBreakInOperand = false;
   if (Current.is(TT_InheritanceColon))
     State.Stack.back().AvoidBinPacking = true;
   if (Current.is(tok::lessless) && Current.isNot(TT_OverloadedOperator)) {
     if (State.Stack.back().FirstLessLess == 0)
       State.Stack.back().FirstLessLess = State.Column;
     else
       State.Stack.back().LastOperatorWrapped = Newline;
   }
   if (Current.is(TT_BinaryOperator) && Current.isNot(tok::lessless))
     State.Stack.back().LastOperatorWrapped = Newline;
   if (Current.is(TT_ConditionalExpr) && Current.Previous &&
       !Current.Previous->is(TT_ConditionalExpr))
     State.Stack.back().LastOperatorWrapped = Newline;
   if (Current.is(TT_ArraySubscriptLSquare) &&
       State.Stack.back().StartOfArraySubscripts == 0)
     State.Stack.back().StartOfArraySubscripts = State.Column;
   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;
 
   if (Current.MatchingParen && Current.BlockKind == BK_Block) {
     moveStateToNewBlock(State);
     return;
   }
 
   unsigned NewIndent;
   unsigned LastSpace = State.Stack.back().LastSpace;
   bool AvoidBinPacking;
   bool BreakBeforeParameter = false;
   unsigned NestedBlockIndent = std::max(State.Stack.back().StartOfFunctionCall,
                                         State.Stack.back().NestedBlockIndent);
   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().BreakBeforeParameter = BreakBeforeParameter;
   State.Stack.back().HasMultipleNestedBlocks = Current.BlockParameterCount > 1;
   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() || OldDelimiter.empty())
     NewDelimiter = OldDelimiter;
   // The text of a raw string is between the leading 'R"delimiter(' and the
   // trailing 'delimiter)"'.
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 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 (Current.isStringLiteral()) {
     return std::make_unique<BreakableLineCommentSection>(
         Current, StartColumn, Current.OriginalColumn, !Current.Previous,
         /*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/Format.cpp

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() {
-  static const ParseErrorCategory C{};
+  static ParseErrorCategory const 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) {
   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";
   }
   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 = {false, false, FormatStyle::BWACS_Never,
                             false, false, false,
                             false, false, false,
                             false, false, false,
                             false, true,  true,
if (!LanguageFound) {
     FormatStyle DefaultStyle = Styles[0];
     DefaultStyle.Language = Language;
     StyleSet.Add(std::move(DefaultStyle));
   }
   *Style = *StyleSet.Get(Language);
   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;
public:
   }
 
 private:
   static bool inputUsesCRLF(StringRef Text) {
     return Text.count('\r') * 2 > Text.count('\n');
   }
 
   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->PackingKind == PPK_BinPacked)
private:
   bool BinPackInconclusiveFunctions;
   FormattingAttemptStatus *Status;
 };
 
 // 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[] = {
         "NSURLQueryItem",
         "NSUUID",
         "NSValue",
         "UIImage",
         "UIView",
     };
 
     for (auto Line : AnnotatedLines) {
-      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];

 
 // 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 = 0;
   unsigned SearchFrom = 0;
   llvm::Regex IncludeRegex(CppIncludeRegexPattern);
   SmallVector<StringRef, 4> Matches;
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);
 
     if (!FormattingOff && !Line.endswith("\\")) {
       if (IncludeRegex.match(Line, &Matches)) {
         StringRef IncludeName = Matches[2];
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)
     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) {
+                    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) {
+                   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) {
   return Replace.getOffset() == UINT_MAX && Replace.getLength() == 0 &&
          llvm::Regex(CppIncludeRegexPattern)
              .match(Replace.getReplacementText());
 }
 
 inline bool isHeaderDeletion(const tooling::Replacement &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) {
+                        FormatStyle const &Style) {
   if (!Style.isCpp())
     return Replaces;
 
   tooling::Replacements HeaderInsertions;
   std::set<llvm::StringRef> HeadersToDelete;
   tooling::Replacements Result;
   for (const auto &R : Replaces) {
     if (isHeaderInsertion(R)) {
fixCppIncludeInsertions(StringRef Code, const tooling::Replacements &Replaces,
   }
   return Result;
 }
 
 } // anonymous namespace
 
 llvm::Expected<tooling::Replacements>
 cleanupAroundReplacements(StringRef Code, const tooling::Replacements &Replaces,
-                          const FormatStyle &Style) {
+                          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 (Expanded.Language == FormatStyle::LK_JavaScript && isMpegTS(Code))
     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.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();
   });
 
   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;
   LangOpts.CPlusPlus11 = LexingStd >= FormatStyle::LS_Cpp11;
   LangOpts.CPlusPlus14 = LexingStd >= FormatStyle::LS_Cpp14;
   LangOpts.CPlusPlus17 = LexingStd >= FormatStyle::LS_Cpp17;
   LangOpts.CPlusPlus2a = LexingStd >= FormatStyle::LS_Cpp20;
 
   LangOpts.LineComment = 1;
   bool AlternativeOperators = Style.isCpp();
   LangOpts.CXXOperatorNames = AlternativeOperators ? 1 : 0;
   LangOpts.Bool = 1;
   LangOpts.ObjC = 1;
   LangOpts.MicrosoftExt = 1;    // To get kw___try, kw___finally.
   LangOpts.DeclSpecKeyword = 1; // To get __declspec.
   return LangOpts;
 }
 
-const char *StyleOptionHelpDescription =
+char const *StyleOptionHelpDescription =
     "Coding style, currently supports:\n"
     "  LLVM, Google, Chromium, 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"
if (Extension.empty() || Extension == ".h") {
       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) {
   if (!FS) {
     FS = llvm::vfs::getRealFileSystem().get();
   }

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 {
 #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 };
struct FormatToken {
 
   /// If \c true, this token has been fully formatted (indented and
   /// potentially re-formatted inside), and we do not allow further formatting
   /// changes.
   bool Finalized = false;
 
   bool is(tok::TokenKind Kind) const { return Tok.is(Kind); }
   bool is(TokenType TT) const { return Type == 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;
   }
   template <typename A, typename B> bool isOneOf(A K1, B K2) const {
     return is(K1) || is(K2);
struct FormatToken {
   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 {
     if (is(TT_TemplateString) && opensScope())
       return true;
     return is(TT_ArrayInitializerLSquare) || is(TT_ProtoExtensionLSquare) ||
            (is(tok::l_brace) &&
             (BlockKind == 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;
   }
 
 private:
   // Disallow copying.
-  FormatToken(const FormatToken &) = delete;
-  void operator=(const FormatToken &) = delete;
+  FormatToken(FormatToken const &) = delete;
+  void operator=(FormatToken const &) = delete;
 
   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_uint;
   IdentifierInfo *kw_ulong;
   IdentifierInfo *kw_unchecked;
   IdentifierInfo *kw_unsafe;
   IdentifierInfo *kw_ushort;
 
   /// Returns \c true if \p Tok is a true JavaScript identifier, returns
   /// \c false if it is a keyword or a pseudo keyword.
-  bool IsJavaScriptIdentifier(const FormatToken &Tok) const {
+  bool IsJavaScriptIdentifier(FormatToken const &Tok) const {
     return Tok.is(tok::identifier) &&
            JsExtraKeywords.find(Tok.Tok.getIdentifierInfo()) ==
                JsExtraKeywords.end();
   }
 
   /// 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_decltype:
     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->BlockKind == BK_Block || LBrace->Type == TT_DictLiteral ||
       LBrace->Next->Type == 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 {
if (Format.TotalWidth > Style.ColumnLimit && Columns > 1)
       continue;
 
     Formats.push_back(Format);
   }
 }
 
 const CommaSeparatedList::ColumnFormat *
 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);
 
   ArrayRef<FormatToken *> lex();
 
-  const AdditionalKeywords &getKeywords() { return Keywords; }
+  AdditionalKeywords const &getKeywords() { return Keywords; }
 
 private:
   void tryMergePreviousTokens();
 
   bool tryMergeLessLess();
   bool tryMergeNSStringLiteral();
   bool tryMergeJSPrivateIdentifier();
   bool tryMergeCSharpVerbatimStringLiteral();
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/SourceLocation.h"
 #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,
+FormatTokenLexer::FormatTokenLexer(SourceManager const &SourceMgr, FileID ID,
+                                   unsigned Column, FormatStyle const &Style,
                                    encoding::Encoding Encoding)
     : FormatTok(nullptr), IsFirstToken(true), StateStack({LexerState::NORMAL}),
       Column(Column), TrailingWhitespace(0), SourceMgr(SourceMgr), ID(ID),
       Style(Style), IdentTable(getFormattingLangOpts(Style)),
       Keywords(IdentTable), Encoding(Encoding), FirstInLineIndex(0),
       FormattingDisabled(false), MacroBlockBeginRegex(Style.MacroBlockBegin),
       MacroBlockEndRegex(Style.MacroBlockEnd) {
   Lex.reset(new Lexer(ID, SourceMgr.getBuffer(ID), SourceMgr,
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::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->Type = 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/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 {
 // The maximal number of unwrapped lines that a short namespace spans.
 // Short namespaces don't need an end comment.
-static const int kShortNamespaceMaxLines = 1;
+static int const kShortNamespaceMaxLines = 1;
 
 // 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) {
   std::string text = "// ";
   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 llvm::Regex *const NamespaceCommentPattern =
       new llvm::Regex("^/[/*] *(end (of )?)? *(anonymous|unnamed)? *"
                       "namespace( +([a-zA-Z0-9:_]+))?\\.? *(\\*/)?$",
                       llvm::Regex::IgnoreCase);
   static llvm::Regex *const NamespaceMacroCommentPattern =
if (NamespaceName.empty() && !NamespaceNameInComment.empty())
     return false;
   StringRef AnonymousInComment = Groups.size() > 3 ? Groups[3] : "";
   // Named namespace comments must not mention anonymous namespace.
   if (!NamespaceName.empty() && !AnonymousInComment.empty())
     return false;
   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;
   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 {
   StringRef Prefix;
   // Symbols from `import {SymbolA, SymbolB, ...} from ...;`.
   SmallVector<JsImportedSymbol, 1> Symbols;
   // 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));
   }
 
   // Appends ``Reference`` to ``Buffer``, returning true if text within the
   // ``Reference`` changed (e.g. symbol order).
   bool appendReference(std::string &Buffer, JsModuleReference &Reference) {
     // 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_lower(RHS.Symbol) < 0;
         });
     if (Symbols == Reference.Symbols) {
       // No change in symbol order.
       StringRef ReferenceStmt = getSourceText(Reference.Range);
       Buffer += ReferenceStmt;
       return false;
     }
bool appendReference(std::string &Buffer, JsModuleReference &Reference) {
     Buffer += getSourceText(SymbolsEnd, Reference.Range.getEnd());
     return true;
   }
 
   // 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;
     for (auto Line : AnnotatedLines) {
       Current = Line->First;
       LineEnd = Line->Last;
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) {
     if (Current->is(tok::identifier)) {
       nextToken();
       if (Current->is(Keywords.kw_from))
         return true;
       if (Current->isNot(tok::comma))
         return false;
       nextToken(); // eat comma.
while (Current->isNot(tok::r_brace)) {
       if (!Current->isOneOf(tok::r_brace, tok::comma))
         return false;
     }
     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,
   SourceLocation StartOfFile = SM.getLocForStartOfFile(ID);
   for (const tooling::Range &Range : Ranges) {
     SourceLocation Start = StartOfFile.getLocWithOffset(Range.getOffset());
     SourceLocation End = Start.getLocWithOffset(Range.getLength());
     CharRanges.push_back(CharSourceRange::getCharRange(Start, End));
   }
 }
 
-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")
for (const auto &R : RunResult.first) {
         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_ObjCProperty, // An @property line.
   LT_Other,
   LT_PreprocessorDirective,
   LT_VirtualFunctionDecl
 };
 
 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) {
         Children.push_back(new AnnotatedLine(Child));
         Current->Children.push_back(Children.back());
       }
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);
 
-  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);
 }
 
 /// 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;
 
-    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;
case tok::colon:
         Tok->Type = TT_DictLiteral;
         if (Style.Language == FormatStyle::LK_TextProto) {
           if (FormatToken *Previous = Tok->getPreviousNonComment())
             Previous->Type = TT_SelectorName;
         }
       } else if (Contexts.back().ColonIsObjCMethodExpr ||
                  Line.startsWith(TT_ObjCMethodSpecifier)) {
         Tok->Type = 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) ||
if (Line.startsWith(TT_ObjCMethodSpecifier)) {
             Contexts.back().LongestObjCSelectorName;
       return LT_ObjCMethodDecl;
     }
 
     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(AnnotatingParser &P, tok::TokenKind ContextKind,
       P.Contexts.push_back(Context(ContextKind,
                                    P.Contexts.back().BindingStrength + Increase,
                                    P.Contexts.back().IsExpression));
     }
 
     ~ScopedContextCreator() { 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.Type = 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.Type = TT_LeadingJavaAnnotation;
         else
           Current.Type = TT_JavaAnnotation;
       } else if (Current.Previous->is(tok::period) &&
                  Current.Previous->isOneOf(TT_JavaAnnotation,
                                            TT_LeadingJavaAnnotation)) {
         Current.Type = Current.Previous->Type;
       }
     }
   }
 
   /// 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++ and Java.
     if (!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;
 
-    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_const,
                            tok::kw_noexcept) ||
         (NextToken->is(tok::l_brace) && !NextToken->getNextNonComment()))
       return TT_PointerOrReference;
 
     if (PrevToken->is(tok::coloncolon))
       return TT_PointerOrReference;
if (PrevToken->Tok.isLiteral() ||
       return TT_BinaryOperator;
 
     // "&&(" is quite unlikely to be two successive unary "&".
     if (Tok.is(tok::ampamp) && NextToken && NextToken->is(tok::l_paren))
       return TT_BinaryOperator;
 
     // This catches some cases where evaluation order is used as control flow:
     //   aaa && aaa->f();
-    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))
       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)
     Result = std::max(Result, Tok->NestingLevel);
   return Result;
 }
 
 void TokenAnnotator::annotate(AnnotatedLine &Line) {
   for (SmallVectorImpl<AnnotatedLine *>::iterator I = Line.Children.begin(),
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 && Next->Next->is(tok::l_square) && Next->Next->Next &&
             Next->Next->Next->is(tok::r_square))
           Next = Next->Next->Next;
         continue;
       }
 
       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->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;
while (Current) {
     } else {
       UnbreakableTailLength +=
           Current->ColumnWidth + Current->SpacesRequiredBefore;
     }
     Current = Current->Previous;
   }
 }
 
-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 (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)
     return true;
   if (Right.is(tok::hashhash))
return Right.Tok.isLiteral() || Right.is(TT_BlockComment) ||
             (Style.PointerAlignment != FormatStyle::PAS_Right &&
              !Line.IsMultiVariableDeclStmt) &&
             Left.Previous &&
             !Left.Previous->isOneOf(tok::l_paren, tok::coloncolon,
                                     tok::l_square));
   if (Right.is(tok::star) && Left.is(tok::l_paren))
     return false;
   const auto SpaceRequiredForArrayInitializerLSquare =
-      [](const FormatToken &LSquareTok, const FormatStyle &Style) {
+      [](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.Type == 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 Style.PointerAlignment != 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;
   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 (Right.is(tok::l_brace) && Right.BlockKind == BK_BracedInit &&
         !Left.opensScope() && Style.SpaceBeforeCpp11BracedList)
       return true;
if (Style.isCpp()) {
     if (Left.is(TT_JsFatArrow))
       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_JsFatArrow))
         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.BlockKind == BK_Block &&
          !Tok.isOneOf(TT_ObjCBlockLBrace, TT_LambdaLBrace, 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.Language == FormatStyle::LK_JavaScript) {
     // FIXME: This might apply to other languages and token kinds.
     if (Right.is(tok::string_literal) && Left.is(tok::plus) && Left.Previous &&
         Left.Previous->is(tok::string_literal))
       return true;
if (Left.isStringLiteral() && Right.isStringLiteral())
       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.BlockKind != 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.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 (Right.NestingLevel == 0 &&
         (Left.Tok.getIdentifierInfo() ||
          Left.isOneOf(tok::r_square, tok::r_paren)) &&
         Right.isOneOf(tok::l_square, tok::l_paren))
       return false; // Otherwise automatic semicolon insertion would trigger.
     if (Left.is(TT_JsFatArrow) && Right.is(tok::l_brace))
       return false;
     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->Type)
                  << " S=" << Tok->SpacesRequiredBefore
                  << " B=" << Tok->BlockParameterCount
                  << " BK=" << Tok->BlockKind << " P=" << Tok->SplitPenalty
                  << " Name=" << Tok->Tok.getName() << " L=" << Tok->TotalLength

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 SmallVectorImpl<AnnotatedLine *> &Lines,
+  void formatFirstToken(AnnotatedLine const &Line,
+                        AnnotatedLine const *PreviousLine,
+                        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) {
       Indent = Line.Level * Style.IndentWidth + AdditionalIndent;
     } else {
       IndentForLevel.resize(Line.Level + 1);
       Indent = getIndent(IndentForLevel, Line.Level);
     }
     if (static_cast<int>(Indent) + Offset >= 0)
       Indent += Offset;
   }
 
   /// 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)))
       return Style.AccessModifierOffset;
     return 0;
   }
 
   /// Get the indent of \p Level from \p IndentForLevel.
   ///
   /// \p IndentForLevel must contain the indent for the level \c l
   /// at \p IndentForLevel[l], or a value < 0 if the indent for
   /// that level is unknown.
   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 (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->BlockKind != 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) {
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 *PreviousLine = nullptr;
-  const AnnotatedLine *NextLine = 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)
if (!DryRun)
       markFinalized(TheLine.First);
     PreviousLine = &TheLine;
   }
   PenaltyCache[CacheKey] = Penalty;
   return Penalty;
 }
 
 void UnwrappedLineFormatter::formatFirstToken(
-    const AnnotatedLine &Line, const AnnotatedLine *PreviousLine,
-    const SmallVectorImpl<AnnotatedLine *> &Lines, unsigned Indent,
+    AnnotatedLine const &Line, AnnotatedLine const *PreviousLine,
+    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;
void UnwrappedLineFormatter::formatFirstToken(
 
   Whitespaces->replaceWhitespace(RootToken, Newlines, Indent, Indent,
                                  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 {
   /// opening line. Otherwise, \c MatchingOpeningBlockLineIndex must be
   /// \c kInvalidIndex.
   size_t MatchingOpeningBlockLineIndex = kInvalidIndex;
 
   /// If this \c UnwrappedLine opens a block, stores the index of the
   /// line with the corresponding closing brace.
   size_t MatchingClosingBlockLineIndex = kInvalidIndex;
 
-  static const size_t kInvalidIndex = -1;
+  static size_t const 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;
for (unsigned i = 0, e = LBraceStack.size(); i != e; ++i) {
     if (LBraceStack[i]->BlockKind == BK_Unknown)
       LBraceStack[i]->BlockKind = BK_Block;
   }
 
   FormatTok = Tokens->setPosition(StoredPosition);
 }
 
 template <class T>
-static inline void hash_combine(std::size_t &seed, const T &v) {
+static inline void hash_combine(std::size_t &seed, T const &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) {
     hash_combine(h, size_t(i.Kind));
     hash_combine(h, i.Line);
   }
   return h;
 }
 
 void UnwrappedLineParser::parseBlock(bool MustBeDeclaration, bool AddLevel,
                                      bool MunchSemi) {
   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->BlockKind = BK_Block;
 
   size_t PPStartHash = computePPHash();
 
   unsigned InitialLevel = Line->Level;
   nextToken(/*LevelDifference=*/AddLevel ? 1 : 0);
 
   if (MacroBlock && FormatTok->is(tok::l_paren))
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;
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->Type = TT_LambdaLBrace;
   LSquare.Type = 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.
   while (FormatTok->isOneOf(tok::identifier, tok::coloncolon, tok::hashhash,
                             tok::kw___attribute, tok::kw___declspec,
                             tok::kw_alignas) ||
          ((Style.Language == FormatStyle::LK_Java ||
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=" << I->Tok->Type << ", 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,
+static bool continuesLineCommentSection(FormatToken const &FormatTok,
+                                        UnwrappedLine const &Line,
                                         llvm::Regex &CommentPragmasRegex) {
   if (Line.Tokens.empty())
     return false;
 
   StringRef IndentContent = FormatTok.TokenText;
   if (FormatTok.TokenText.startswith("//") ||
       FormatTok.TokenText.startswith("/*"))
     IndentContent = FormatTok.TokenText.substr(2);
static bool 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_lower(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, const std::string &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;
     if (AnnotatedLines[I]->InPPDirective ||
         !AnnotatedLines[I]->startsWith(tok::kw_using) || FirstTok->Finalized) {
       endUsingDeclarationBlock(&UsingDeclarations, SourceMgr, &Fixes);

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 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);
 
   /// 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();
 
   /// 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 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;
 
     // A combination of indent level and nesting level, which are used in
     // tandem to compute lexical scope, for the purposes of deciding
     // when to stop consecutive alignment runs.
     std::pair<unsigned, unsigned> indentAndNestingLevel() const {
       return std::make_pair(Tok->IndentLevel, Tok->NestingLevel);
     }
private:
   void appendNewlineText(std::string &Text, unsigned Newlines);
   void appendEscapedNewlineText(std::string &Text, unsigned Newlines,
                                 unsigned PreviousEndOfTokenColumn,
                                 unsigned EscapedNewlineColumn);
   void appendIndentText(std::string &Text, unsigned IndentLevel,
                         unsigned Spaces, unsigned WhitespaceStartColumn);
 
   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 "WhitespaceManager.h"
 #include "llvm/ADT/STLExtras.h"
 
 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 ContinuesPPDirective, bool IsInsideToken)
     : Tok(&Tok), CreateReplacement(CreateReplacement),
if (Tok.Finalized)
     return;
   Tok.Decision = (Newlines > 0) ? FD_Break : FD_Continue;
   Changes.push_back(Change(Tok, /*CreateReplacement=*/true, Tok.WhitespaceRange,
                            Spaces, StartOfTokenColumn, Newlines, "", "",
                            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, "", "",
                            InPPDirective && !Tok.IsFirst,
                            /*IsInsideToken=*/false));
 }
 
 llvm::Error
 WhitespaceManager::addReplacement(const tooling::Replacement &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,
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:
     //

 // function, when it comes time to align a sequence of tokens, we run the
 // 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,
+static unsigned AlignTokens(FormatStyle const &Style, F &&Matches,
                             SmallVector<WhitespaceManager::Change, 16> &Changes,
                             unsigned StartAt) {
   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;
static void AlignMacroSequence(
   StartOfSequence = 0;
   EndOfSequence = 0;
 }
 
 void WhitespaceManager::alignConsecutiveMacros() {
   if (!Style.AlignConsecutiveMacros)
     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)
     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;
 
if (C.NewlinesBefore > 0) {
       else
         C.EscapedNewlineColumn = Column;
     }
   }
 }
 
 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)