[LLVM/Support] - Make match() method of llvm::Regex to be const

[grimar]

Summary

This can help to D23829.
I have a std::vector of Regex and use ArrayRefs to pass it.
The fact of match() is not const forces me to use const_cast for
removing it. Also there is no way to call match() on
Regex const reference, at the same time the only thing match()
can change is error field and method name and job it do does not sounds
like something not-const.

include/llvm/Support/Regex.h

public:
 
     /// matches - Match the regex against a given \p String.
     ///
     /// \param Matches - If given, on a successful match this will be filled in
     /// with references to the matched group expressions (inside \p String),
     /// the first group is always the entire pattern.
     ///
     /// This returns true on a successful match.
-    bool match(StringRef String, SmallVectorImpl<StringRef> *Matches = nullptr);
+    bool match(StringRef String,
+               SmallVectorImpl<StringRef> *Matches = nullptr) const;
 
     /// sub - Return the result of replacing the first match of the regex in
     /// \p String with the \p Repl string. Backreferences like "\0" in the
     /// replacement string are replaced with the appropriate match substring.
     ///
     /// Note that the replacement string has backslash escaping performed on
     /// it. Invalid backreferences are ignored (replaced by empty strings).
     ///
     /// \param Error If non-null, any errors in the substitution (invalid
     /// backreferences, trailing backslashes) will be recorded as a non-empty
     /// string.
     std::string sub(StringRef Repl, StringRef String,
                     std::string *Error = nullptr);
 
     /// \brief If this function returns true, ^Str$ is an extended regular
     /// expression that matches Str and only Str.
     static bool isLiteralERE(StringRef Str);
 
     /// \brief Turn String into a regex by escaping its special characters.
     static std::string escape(StringRef String);
 
   private:
     struct llvm_regex *preg;
-    int error;
+    mutable int error;
   };
 }
 
 #endif // LLVM_SUPPORT_REGEX_H

lib/Support/Regex.cpp

 }
 
 /// getNumMatches - In a valid regex, return the number of parenthesized
 /// matches it contains.
 unsigned Regex::getNumMatches() const {
   return preg->re_nsub;
 }
 
-bool Regex::match(StringRef String, SmallVectorImpl<StringRef> *Matches){
+bool Regex::match(StringRef String, SmallVectorImpl<StringRef> *Matches) const {
   unsigned nmatch = Matches ? preg->re_nsub+1 : 0;
 
   // pmatch needs to have at least one element.
   SmallVector<llvm_regmatch_t, 8> pm;
   pm.resize(nmatch > 0 ? nmatch : 1);
   pm[0].rm_so = 0;
   pm[0].rm_eo = String.size();