[clang][NFC] Make various uses of Regex const

[nlguillemot]

Summary

The const-correctness of match() was fixed in rL372764, which allows
uses of Regex objects to be const in cases they couldn't be before. This
patch tightens up the const-ness of Regex in various such cases.

[thopre]

LGTM.

[thopre]

My sincere apologies, I forgot to change the author in the commit. I don't often commit on behalf of others so didn't think enough.

[nlguillemot]

In D68155#1751826, @thopre wrote:

My sincere apologies, I forgot to change the author in the commit. I don't often commit on behalf of others so didn't think enough.

No worries. Thanks again for helping with the commit!

include/clang/Tooling/Inclusions/HeaderIncludes.h

 private:
   bool isMainHeader(StringRef IncludeName) const;
 
   const IncludeStyle Style;
   bool IsMainFile;
   std::string FileName;
   // This refers to a substring in FileName.
   StringRef FileStem;
-  // Regex is not thread-safe.
-  mutable SmallVector<llvm::Regex, 4> CategoryRegexs;
+  SmallVector<llvm::Regex, 4> CategoryRegexs;
 };
 
 /// Generates replacements for inserting or deleting #include directives in a
 /// file.
 class HeaderIncludes {
 public:
   HeaderIncludes(llvm::StringRef FileName, llvm::StringRef Code,
                  const IncludeStyle &Style);

lib/Format/BreakableToken.h

public:
 
   /// Returns a range (offset, length) at which to break the line at
   /// \p LineIndex, if previously broken at \p TailOffset. If possible, do not
   /// violate \p ColumnLimit, assuming the text starting at \p TailOffset in
   /// the token is formatted starting at ContentStartColumn in the reformatted
   /// file.
   virtual Split getSplit(unsigned LineIndex, unsigned TailOffset,
                          unsigned ColumnLimit, unsigned ContentStartColumn,
-                         llvm::Regex &CommentPragmasRegex) const = 0;
+                         const llvm::Regex &CommentPragmasRegex) const = 0;
 
   /// Emits the previously retrieved \p Split via \p Whitespaces.
   virtual void insertBreak(unsigned LineIndex, unsigned TailOffset, Split Split,
                            unsigned ContentIndent,
                            WhitespaceManager &Whitespaces) const = 0;
 
   /// Returns the number of columns needed to format
   /// \p RemainingTokenColumns, assuming that Split is within the range measured
public:
   /// Returning (StringRef::npos, 0) indicates reflowing is not possible.
   ///
   /// The range will include any whitespace preceding the specified line's
   /// content.
   ///
   /// If the split is not contained within one token, for example when reflowing
   /// line comments, returns (0, <length>).
   virtual Split getReflowSplit(unsigned LineIndex,
-                               llvm::Regex &CommentPragmasRegex) const {
+                               const llvm::Regex &CommentPragmasRegex) const {
     return Split(StringRef::npos, 0);
   }
 
   /// Reflows the current line into the end of the previous one.
   virtual void reflow(unsigned LineIndex,
                       WhitespaceManager &Whitespaces) const {}
 
   /// Returns whether there will be a line break at the start of the
public:
   /// after formatting.
   BreakableStringLiteral(const FormatToken &Tok, unsigned StartColumn,
                          StringRef Prefix, StringRef Postfix,
                          unsigned UnbreakableTailLength, bool InPPDirective,
                          encoding::Encoding Encoding, const FormatStyle &Style);
 
   Split getSplit(unsigned LineIndex, unsigned TailOffset, unsigned ColumnLimit,
                  unsigned ContentStartColumn,
-                 llvm::Regex &CommentPragmasRegex) const override;
+                 const 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,
                           WhitespaceManager &Whitespaces) const override {}
   unsigned getLineCount() const override;
   unsigned getRangeLength(unsigned LineIndex, unsigned Offset,
                           StringRef::size_type Length,
BreakableComment(const FormatToken &Token, unsigned StartColumn,
                    bool InPPDirective, encoding::Encoding Encoding,
                    const FormatStyle &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;
+                 const 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;
 
   // Checks if the content of line LineIndex may be reflown with the previous
   // line.
   virtual bool mayReflow(unsigned LineIndex,
-                         llvm::Regex &CommentPragmasRegex) const = 0;
+                         const llvm::Regex &CommentPragmasRegex) const = 0;
 
   // Contains the original text of the lines of the block comment.
   //
   // In case of a block comments, excludes the leading /* in the first line and
   // trailing */ in the last line. In case of line comments, excludes the
   // leading // and spaces.
   SmallVector<StringRef, 16> Lines;
 

 public:
   BreakableBlockComment(const FormatToken &Token, unsigned StartColumn,
                         unsigned OriginalStartColumn, bool FirstInLine,
                         bool InPPDirective, encoding::Encoding Encoding,
                         const FormatStyle &Style, bool UseCRLF);
 
   Split getSplit(unsigned LineIndex, unsigned TailOffset, unsigned ColumnLimit,
                  unsigned ContentStartColumn,
-                 llvm::Regex &CommentPragmasRegex) const override;
+                 const 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,
                               unsigned StartColumn) const override;
   unsigned getContentStartColumn(unsigned LineIndex, bool Break) const override;
   unsigned getContentIndent(unsigned LineIndex) const override;
   void insertBreak(unsigned LineIndex, unsigned TailOffset, Split Split,
                    unsigned ContentIndent,
                    WhitespaceManager &Whitespaces) const override;
   Split getReflowSplit(unsigned LineIndex,
-                       llvm::Regex &CommentPragmasRegex) const override;
+                       const llvm::Regex &CommentPragmasRegex) const override;
   void reflow(unsigned LineIndex,
               WhitespaceManager &Whitespaces) const override;
   bool introducesBreakBeforeToken() const override;
   void adaptStartOfLine(unsigned LineIndex,
                         WhitespaceManager &Whitespaces) const override;
   Split getSplitAfterLastLine(unsigned TailOffset) const override;
 
   bool mayReflow(unsigned LineIndex,
-                 llvm::Regex &CommentPragmasRegex) const override;
+                 const llvm::Regex &CommentPragmasRegex) const override;
 
   // Contains Javadoc annotations that require additional indent when continued
   // on multiple lines.
   static const llvm::StringSet<> ContentIndentingJavadocAnnotations;
 
 private:
   // Rearranges the whitespace between Lines[LineIndex-1] and Lines[LineIndex].
   //
public:
   unsigned getRangeLength(unsigned LineIndex, unsigned Offset,
                           StringRef::size_type Length,
                           unsigned StartColumn) const override;
   unsigned getContentStartColumn(unsigned LineIndex, bool Break) const override;
   void insertBreak(unsigned LineIndex, unsigned TailOffset, Split Split,
                    unsigned ContentIndent,
                    WhitespaceManager &Whitespaces) const override;
   Split getReflowSplit(unsigned LineIndex,
-                       llvm::Regex &CommentPragmasRegex) const override;
+                       const llvm::Regex &CommentPragmasRegex) const override;
   void reflow(unsigned LineIndex,
               WhitespaceManager &Whitespaces) const override;
   void adaptStartOfLine(unsigned LineIndex,
                         WhitespaceManager &Whitespaces) const override;
   void updateNextToken(LineState &State) const override;
   bool mayReflow(unsigned LineIndex,
-                 llvm::Regex &CommentPragmasRegex) const override;
+                 const llvm::Regex &CommentPragmasRegex) const override;
 
 private:
   // OriginalPrefix[i] contains the original prefix of line i, including
   // trailing whitespace before the start of the content. The indentation
   // preceding the prefix is not included.
   // For example, if the line is:
   // // content
   // then the original prefix is "// ".

lib/Format/BreakableToken.cpp

for (unsigned NumChars = 0;
     NumChars +=
         encoding::columnWidthWithTabs(Text.substr(MaxSplitBytes, BytesInChar),
                                       ContentStartColumn, TabWidth, Encoding);
     MaxSplitBytes += BytesInChar;
   }
 
   StringRef::size_type SpaceOffset = Text.find_last_of(Blanks, MaxSplitBytes);
 
-  static auto *const kNumberedListRegexp = new llvm::Regex("^[1-9][0-9]?\\.");
+  static const auto kNumberedListRegexp = llvm::Regex("^[1-9][0-9]?\\.");
   while (SpaceOffset != StringRef::npos) {
     // Do not split before a number followed by a dot: this would be interpreted
     // as a numbered list, which would prevent re-flowing in subsequent passes.
-    if (kNumberedListRegexp->match(Text.substr(SpaceOffset).ltrim(Blanks)))
+    if (kNumberedListRegexp.match(Text.substr(SpaceOffset).ltrim(Blanks)))
       SpaceOffset = Text.find_last_of(Blanks, SpaceOffset);
     // In JavaScript, some @tags can be followed by {, and machinery that parses
     // these comments will fail to understand the comment if followed by a line
     // break. So avoid ever breaking before a {.
     else if (Style.Language == FormatStyle::LK_JavaScript &&
              SpaceOffset + 1 < Text.size() && Text[SpaceOffset + 1] == '{')
       SpaceOffset = Text.find_last_of(Blanks, SpaceOffset);
     else
: BreakableToken(Tok, InPPDirective, Encoding, Style),
       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 {
+    unsigned ContentStartColumn, const 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 {
BreakableComment::BreakableComment(const FormatToken &Token,
     : 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,
-                           llvm::Regex &CommentPragmasRegex) const {
+                           const llvm::Regex &CommentPragmasRegex) const {
   // Don't break lines matching the comment pragmas regex.
   if (CommentPragmasRegex.match(Content[LineIndex]))
     return Split(StringRef::npos, 0);
   return getCommentSplit(Content[LineIndex].substr(TailOffset),
                          ContentStartColumn, ColumnLimit, Style.TabWidth,
                          Encoding, Style);
 }
 
if (Content.startswith(Prefix)) {
       hasSpecialMeaningPrefix = true;
       break;
     }
   }
 
   // Numbered lists may also start with a number followed by '.'
   // To avoid issues if a line starts with a number which is actually the end
   // of a previous line, we only consider numbers with up to 2 digits.
-  static auto *const kNumberedListRegexp = new llvm::Regex("^[1-9][0-9]?\\. ");
+  static const auto kNumberedListRegexp = llvm::Regex("^[1-9][0-9]?\\. ");
   hasSpecialMeaningPrefix =
-      hasSpecialMeaningPrefix || kNumberedListRegexp->match(Content);
+      hasSpecialMeaningPrefix || kNumberedListRegexp.match(Content);
 
   // Simple heuristic for what to reflow: content should contain at least two
   // characters and either the first or second character must be
   // non-punctuation.
   return Content.size() >= 2 && !hasSpecialMeaningPrefix &&
          !Content.endswith("\\") &&
          // Note that this is UTF-8 safe, since if isPunctuation(Content[0]) is
          // true, then the first code point must be 1 byte long.
for (size_t i = 0; i < Lines.size(); ++i) {
                    << "CC=" << ContentColumn[i] << "| "
                    << "IN=" << (Content[i].data() - Lines[i].data()) << "\n";
     }
   });
 }
 
 BreakableToken::Split BreakableBlockComment::getSplit(
     unsigned LineIndex, unsigned TailOffset, unsigned ColumnLimit,
-    unsigned ContentStartColumn, llvm::Regex &CommentPragmasRegex) const {
+    unsigned ContentStartColumn, const llvm::Regex &CommentPragmasRegex) const {
   // Don't break lines matching the comment pragmas regex.
   if (CommentPragmasRegex.match(Content[LineIndex]))
     return Split(StringRef::npos, 0);
   return getCommentSplit(Content[LineIndex].substr(TailOffset),
                          ContentStartColumn, ColumnLimit, Style.TabWidth,
                          Encoding, Style, Decoration.endswith("*"));
 }
 
for (unsigned I = 0; I < ContentIndent; ++I)
     PrefixWithTrailingIndent += " ";
   Whitespaces.replaceWhitespaceInToken(
       tokenAt(LineIndex), BreakOffsetInToken, CharsToRemove, "",
       PrefixWithTrailingIndent, InPPDirective, /*Newlines=*/1,
       /*Spaces=*/LocalIndentAtLineBreak + ContentIndent -
           PrefixWithTrailingIndent.size());
 }
 
-BreakableToken::Split
-BreakableBlockComment::getReflowSplit(unsigned LineIndex,
-                                      llvm::Regex &CommentPragmasRegex) const {
+BreakableToken::Split BreakableBlockComment::getReflowSplit(
+    unsigned LineIndex, const llvm::Regex &CommentPragmasRegex) const {
   if (!mayReflow(LineIndex, CommentPragmasRegex))
     return Split(StringRef::npos, 0);
 
   // If we're reflowing into a line with content indent, only reflow the next
   // line if its starting whitespace matches the content indent.
   size_t Trimmed = Content[LineIndex].find_first_not_of(Blanks);
   if (LineIndex) {
     unsigned PreviousContentIndent = getContentIndent(LineIndex - 1);
if (DelimitersOnNewline) {
     StringRef Line = Content.back().substr(TailOffset);
     StringRef TrimmedLine = Line.rtrim(Blanks);
     if (!TrimmedLine.empty())
       return Split(TrimmedLine.size(), Line.size() - TrimmedLine.size());
   }
   return Split(StringRef::npos, 0);
 }
 
-bool BreakableBlockComment::mayReflow(unsigned LineIndex,
-                                      llvm::Regex &CommentPragmasRegex) const {
+bool BreakableBlockComment::mayReflow(
+    unsigned LineIndex, const llvm::Regex &CommentPragmasRegex) const {
   // Content[LineIndex] may exclude the indent after the '*' decoration. In that
   // case, we compute the start of the comment pragma manually.
   StringRef IndentContent = Content[LineIndex];
   if (Lines[LineIndex].ltrim(Blanks).startswith("*")) {
     IndentContent = Lines[LineIndex].ltrim(Blanks).substr(1);
   }
   return LineIndex > 0 && !CommentPragmasRegex.match(IndentContent) &&
          mayReflowContent(Content[LineIndex]) && !Tok.Finalized &&
void BreakableLineCommentSection::insertBreak(
   assert(IndentAtLineBreak >= Prefix[LineIndex].size());
   Whitespaces.replaceWhitespaceInToken(
       tokenAt(LineIndex), BreakOffsetInToken, CharsToRemove, "",
       Prefix[LineIndex], InPPDirective, /*Newlines=*/1,
       /*Spaces=*/IndentAtLineBreak - Prefix[LineIndex].size());
 }
 
 BreakableComment::Split BreakableLineCommentSection::getReflowSplit(
-    unsigned LineIndex, llvm::Regex &CommentPragmasRegex) const {
+    unsigned LineIndex, const llvm::Regex &CommentPragmasRegex) const {
   if (!mayReflow(LineIndex, CommentPragmasRegex))
     return Split(StringRef::npos, 0);
 
   size_t Trimmed = Content[LineIndex].find_first_not_of(Blanks);
 
   // In a line comment section each line is a separate token; thus, after a
   // split we replace all whitespace before the current line comment token
   // (which does not need to be included in the split), plus the start of the

 
 void BreakableLineCommentSection::updateNextToken(LineState &State) const {
   if (LastLineTok) {
     State.NextToken = LastLineTok->Next;
   }
 }
 
 bool BreakableLineCommentSection::mayReflow(
-    unsigned LineIndex, llvm::Regex &CommentPragmasRegex) const {
+    unsigned LineIndex, const llvm::Regex &CommentPragmasRegex) const {
   // Line comments have the indent as part of the prefix, so we need to
   // recompute the start of the line.
   StringRef IndentContent = Content[LineIndex];
   if (Lines[LineIndex].startswith("//")) {
     IndentContent = Lines[LineIndex].substr(2);
   }
   // FIXME: Decide whether we want to reflow non-regular indents:
   // Currently, we only reflow when the OriginalPrefix[LineIndex] matches the

lib/Format/NamespaceEndCommentsFixer.cpp

 
 bool validEndComment(const FormatToken *RBraceTok, StringRef NamespaceName,
                      const FormatToken *NamespaceTok) {
   assert(hasEndComment(RBraceTok));
   const FormatToken *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 =
-      new llvm::Regex("^/[/*] *(end (of )?)? *(anonymous|unnamed)? *"
-                      "([a-zA-Z0-9_]+)\\(([a-zA-Z0-9:_]*)\\)\\.? *(\\*/)?$",
-                      llvm::Regex::IgnoreCase);
+  static const llvm::Regex NamespaceCommentPattern =
+      llvm::Regex("^/[/*] *(end (of )?)? *(anonymous|unnamed)? *"
+  static const llvm::Regex NamespaceMacroCommentPattern =
+      llvm::Regex("^/[/*] *(end (of )?)? *(anonymous|unnamed)? *"
 
   SmallVector<StringRef, 8> Groups;
   if (NamespaceTok->is(TT_NamespaceMacro) &&
-      NamespaceMacroCommentPattern->match(Comment->TokenText, &Groups)) {
+      NamespaceMacroCommentPattern.match(Comment->TokenText, &Groups)) {
     StringRef NamespaceTokenText = Groups.size() > 4 ? Groups[4] : "";
     // The name of the macro must be used.
     if (NamespaceTokenText != NamespaceTok->TokenText)
       return false;
   } else if (NamespaceTok->isNot(tok::kw_namespace) ||
-             !NamespaceCommentPattern->match(Comment->TokenText, &Groups)) {
+             !NamespaceCommentPattern.match(Comment->TokenText, &Groups)) {
     // Comment does not match regex.
     return false;
   }
   StringRef NamespaceNameInComment = Groups.size() > 5 ? Groups[5] : "";
   // Anonymous namespace comments must not mention a namespace name.
   if (NamespaceName.empty() && !NamespaceNameInComment.empty())
     return false;
   StringRef AnonymousInComment = Groups.size() > 3 ? Groups[3] : "";

lib/Format/UnwrappedLineParser.cpp

 
 bool UnwrappedLineParser::isOnNewLine(const FormatToken &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,
-                                        llvm::Regex &CommentPragmasRegex) {
+static bool
+continuesLineCommentSection(const FormatToken &FormatTok,
+                            const 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);
   if (CommentPragmasRegex.match(IndentContent))

tools/clang-refactor/TestSupport.cpp

if (!ErrOrFile) {
     llvm::errs() << "error: -selection=test:" << Filename
                  << " : could not open the given file";
     return None;
   }
   StringRef Source = ErrOrFile.get()->getBuffer();
 
   // See the doc comment for this function for the explanation of this
   // syntax.
-  static Regex RangeRegex("range[[:blank:]]*([[:alpha:]_]*)?[[:blank:]]*=[[:"
-                          "blank:]]*(\\+[[:digit:]]+)?[[:blank:]]*(->[[:blank:]"
-                          "]*[\\+\\:[:digit:]]+)?");
+  static const Regex RangeRegex(
+      "range[[:blank:]]*([[:alpha:]_]*)?[[:blank:]]*=[[:"
 
   std::map<std::string, SmallVector<TestSelectionRange, 8>> GroupedRanges;
 
   LangOptions LangOpts;
   LangOpts.CPlusPlus = 1;
   LangOpts.CPlusPlus11 = 1;
   Lexer Lex(SourceLocation::getFromRawEncoding(0), LangOpts, Source.begin(),
             Source.begin(), Source.end());
if (!Matches[2].empty()) {
       // Don't forget to drop the '+'!
       if (Matches[2].drop_front().getAsInteger(10, ColumnOffset))
         assert(false && "regex should have produced a number");
     }
     Offset = addColumnOffset(Source, Offset, ColumnOffset);
     unsigned EndOffset;
 
     if (!Matches[3].empty()) {
-      static Regex EndLocRegex(
+      static const Regex EndLocRegex(
           "->[[:blank:]]*(\\+[[:digit:]]+):([[:digit:]]+)");
       SmallVector<StringRef, 4> EndLocMatches;
       if (!EndLocRegex.match(Matches[3], &EndLocMatches)) {
         if (DetectMistypedCommand())
           return None;
         continue;
       }
       unsigned EndLineOffset = 0, EndColumn = 0;