[FileCheck] Remove llvm:: prefix

[thopre]

Summary

Remove all llvm:: prefixes in FileCheck library header and implementation except for calls to make_unique since both files already use the llvm namespace.

[probinson]

LGTM, although I commonly see llvm::make_unique to document that we are specifically not using the std:: one. On occasion it is actually ambiguous.

[thopre]

Reintroduce llvm:: prefix for calls to make_unique

llvm/trunk/include/llvm/Support/FileCheck.h

 /// Class representing a numeric variable with a given value in a numeric
 /// expression.
 class FileCheckNumericVariable {
 private:
   /// Name of the numeric variable.
   StringRef Name;
 
   /// Value of numeric variable, if defined, or None otherwise.
-  llvm::Optional<uint64_t> Value;
+  Optional<uint64_t> Value;
 
 public:
   /// Constructor for numeric variable \p Name with a known \p Value at parse
   /// time (e.g. the @LINE numeric variable).
   FileCheckNumericVariable(StringRef Name, uint64_t Value)
       : Name(Name), Value(Value) {}
 
   /// \returns name of that numeric variable.
   StringRef getName() const { return Name; }
 
   /// \returns value of this numeric variable.
-  llvm::Optional<uint64_t> getValue() const { return Value; }
+  Optional<uint64_t> getValue() const { return Value; }
 
   /// Sets value of this numeric variable if not defined. \returns whether the
   /// variable was already defined.
   bool setValue(uint64_t Value);
 
   /// Clears value of this numeric variable. \returns whether the variable was
   /// already undefined.
   bool clearValue();

 public:
   FileCheckNumExpr(binop_eval_t EvalBinop,
                    FileCheckNumericVariable *OperandLeft, uint64_t OperandRight)
       : LeftOp(OperandLeft), RightOp(OperandRight), EvalBinop(EvalBinop) {}
 
   /// Evaluates the value of this numeric expression, using EvalBinop to
   /// perform the binary operation it consists of. \returns None if the numeric
   /// variable used is undefined, or the expression value otherwise.
-  llvm::Optional<uint64_t> eval() const;
+  Optional<uint64_t> eval() const;
 
   /// \returns the name of the undefined variable used in this expression if
   /// any or an empty string otherwise.
   StringRef getUndefVarName() const;
 };
 
 class FileCheckPatternContext;
 
public:
   /// \returns the string to be substituted for something else.
   StringRef getFromString() const { return FromStr; }
 
   /// \returns the index where the substitution is to be performed in RegExStr.
   size_t getIndex() const { return InsertIdx; }
 
   /// \returns a string containing the result of the substitution represented
   /// by this class instance or None if substitution failed.
-  virtual llvm::Optional<std::string> getResult() const = 0;
+  virtual Optional<std::string> getResult() const = 0;
 
   /// \returns the name of the variable used in this substitution if undefined,
   /// or an empty string otherwise.
   virtual StringRef getUndefVarName() const = 0;
 };
 
 class FileCheckStringSubstitution : public FileCheckSubstitution {
 public:
   FileCheckStringSubstitution(FileCheckPatternContext *Context,
                               StringRef VarName, size_t InsertIdx)
       : FileCheckSubstitution(Context, VarName, InsertIdx) {}
 
   /// \returns the text that the string variable in this substitution matched
   /// when defined, or None if the variable is undefined.
-  llvm::Optional<std::string> getResult() const override;
+  Optional<std::string> getResult() const override;
 
   /// \returns the name of the string variable used in this substitution if
   /// undefined, or an empty string otherwise.
   StringRef getUndefVarName() const override;
 };
 
 class FileCheckNumericSubstitution : public FileCheckSubstitution {
 private:
   /// Pointer to the class representing the numeric expression whose value is
   /// to be substituted.
   FileCheckNumExpr *NumExpr;
 
 public:
   FileCheckNumericSubstitution(FileCheckPatternContext *Context, StringRef Expr,
                                FileCheckNumExpr *NumExpr, size_t InsertIdx)
       : FileCheckSubstitution(Context, Expr, InsertIdx), NumExpr(NumExpr) {}
 
   /// \returns a string containing the result of evaluating the numeric
   /// expression in this substitution, or None if evaluation failed.
-  llvm::Optional<std::string> getResult() const override;
+  Optional<std::string> getResult() const override;
 
   /// \returns the name of the numeric variable used in this substitution if
   /// undefined, or an empty string otherwise.
   StringRef getUndefVarName() const override;
 };
 
 //===----------------------------------------------------------------------===//
 // Pattern handling code.
private:
 
   /// Vector holding pointers to all substitutions. Used to automatically free
   /// them once they are guaranteed to no longer be used.
   std::vector<std::unique_ptr<FileCheckSubstitution>> Substitutions;
 
 public:
   /// \returns the value of string variable \p VarName or None if no such
   /// variable has been defined.
-  llvm::Optional<StringRef> getPatternVarValue(StringRef VarName);
+  Optional<StringRef> getPatternVarValue(StringRef VarName);
 
   /// Defines string and numeric variables from definitions given on the
   /// command line, passed as a vector of [#]VAR=VAL strings in
   /// \p CmdlineDefines. Reports any error to \p SM and \returns whether an
   /// error occured.
   bool defineCmdlineVariables(std::vector<std::string> &CmdlineDefines,
                               SourceMgr &SM);
 

llvm/trunk/lib/Support/FileCheck.cpp

if (Value)
     return true;
   Value = NewValue;
   return false;
 }
 
 bool FileCheckNumericVariable::clearValue() {
   if (!Value)
     return true;
-  Value = llvm::None;
+  Value = None;
   return false;
 }
 
-llvm::Optional<uint64_t> FileCheckNumExpr::eval() const {
-  llvm::Optional<uint64_t> LeftOp = this->LeftOp->getValue();
+Optional<uint64_t> FileCheckNumExpr::eval() const {
+  Optional<uint64_t> LeftOp = this->LeftOp->getValue();
   // Variable is undefined.
   if (!LeftOp)
-    return llvm::None;
+    return None;
   return EvalBinop(*LeftOp, RightOp);
 }
 
 StringRef FileCheckNumExpr::getUndefVarName() const {
   if (!LeftOp->getValue())
     return LeftOp->getName();
   return StringRef();
 }
 
-llvm::Optional<std::string> FileCheckNumericSubstitution::getResult() const {
-  llvm::Optional<uint64_t> EvaluatedValue = NumExpr->eval();
+Optional<std::string> FileCheckNumericSubstitution::getResult() const {
+  Optional<uint64_t> EvaluatedValue = NumExpr->eval();
   if (!EvaluatedValue)
-    return llvm::None;
+    return None;
   return utostr(*EvaluatedValue);
 }
 
-llvm::Optional<std::string> FileCheckStringSubstitution::getResult() const {
+Optional<std::string> FileCheckStringSubstitution::getResult() const {
   // Look up the value and escape it so that we can put it into the regex.
-  llvm::Optional<StringRef> VarVal = Context->getPatternVarValue(FromStr);
+  Optional<StringRef> VarVal = Context->getPatternVarValue(FromStr);
   if (!VarVal)
-    return llvm::None;
+    return None;
   return Regex::escape(*VarVal);
 }
 
 StringRef FileCheckNumericSubstitution::getUndefVarName() const {
   // Although a use of an undefined numeric variable is detected at parse
   // time, a numeric variable can be undefined later by ClearLocalVariables.
   return NumExpr->getUndefVarName();
 }
if (!Substitutions.empty()) {
     TmpStr = RegExStr;
 
     size_t InsertOffset = 0;
     // Substitute all string variables and numeric expressions whose values are
     // only now known. Use of string variables defined on the same line are
     // handled by back-references.
     for (const auto &Substitution : Substitutions) {
       // Substitute and check for failure (e.g. use of undefined variable).
-      llvm::Optional<std::string> Value = Substitution->getResult();
+      Optional<std::string> Value = Substitution->getResult();
       if (!Value)
         return StringRef::npos;
 
       // Plop it into the regex at the adjusted offset.
       TmpStr.insert(TmpStr.begin() + Substitution->getIndex() + InsertOffset,
                     Value->begin(), Value->end());
       InsertOffset += Value->size();
     }

 
 void FileCheckPattern::printSubstitutions(const SourceMgr &SM, StringRef Buffer,
                                           SMRange MatchRange) const {
   // Print what we know about substitutions.
   if (!Substitutions.empty()) {
     for (const auto &Substitution : Substitutions) {
       SmallString<256> Msg;
       raw_svector_ostream OS(Msg);
-      llvm::Optional<std::string> MatchedValue = Substitution->getResult();
+      Optional<std::string> MatchedValue = Substitution->getResult();
 
       // Substitution failed or is not known at match time, print the undefined
       // variable it uses.
       if (!MatchedValue) {
         StringRef UndefVarName = Substitution->getUndefVarName();
         if (UndefVarName.empty())
           continue;
         OS << "uses undefined variable \"";
if (Best && Best != StringRef::npos && BestQuality < 50) {
     SM.PrintMessage(MatchRange.Start, SourceMgr::DK_Note,
                     "possible intended match here");
 
     // FIXME: If we wanted to be really friendly we would show why the match
     // failed, as it can be hard to spot simple one character differences.
   }
 }
 
-llvm::Optional<StringRef>
+Optional<StringRef>
 FileCheckPatternContext::getPatternVarValue(StringRef VarName) {
   auto VarIter = GlobalVariableTable.find(VarName);
   if (VarIter == GlobalVariableTable.end())
-    return llvm::None;
+    return None;
 
   return VarIter->second;
 }
 
 FileCheckNumExpr *
 FileCheckPatternContext::makeNumExpr(binop_eval_t EvalBinop,
                                      FileCheckNumericVariable *OperandLeft,
                                      uint64_t OperandRight) {
if (Str[0] == '\\') {
       Str = Str.substr(1);
       Offset++;
     }
   }
 
   return StringRef::npos;
 }
 
-StringRef
-llvm::FileCheck::CanonicalizeFile(MemoryBuffer &MB,
+StringRef FileCheck::CanonicalizeFile(MemoryBuffer &MB,
                                       SmallVectorImpl<char> &OutputBuffer) {
   OutputBuffer.reserve(MB.getBufferSize());
 
   for (const char *Ptr = MB.getBufferStart(), *End = MB.getBufferEnd();
        Ptr != End; ++Ptr) {
     // Eliminate trailing dosish \r.
     if (Ptr <= End - 2 && Ptr[0] == '\r' && Ptr[1] == '\n') {
       continue;
     }
while (!Buffer.empty()) {
     // matched and any additional parts of that check-like word.
     Buffer = Buffer.drop_front(SkipWord(Buffer, Prefix.size()));
   }
 
   // We ran out of buffer while skipping partial matches so give up.
   return {StringRef(), StringRef()};
 }
 
-bool llvm::FileCheck::ReadCheckFile(
-    SourceMgr &SM, StringRef Buffer, Regex &PrefixRE,
+bool FileCheck::ReadCheckFile(SourceMgr &SM, StringRef Buffer, Regex &PrefixRE,
                               std::vector<FileCheckString> &CheckStrings) {
   if (PatternContext.defineCmdlineVariables(Req.GlobalDefines, SM))
     return true;
 
   std::vector<FileCheckPattern> ImplicitNegativeChecks;
   for (const auto &PatternString : Req.ImplicitCheckNot) {
     // Create a buffer with fake command line content in order to display the
     // command line option responsible for the specific implicit CHECK-NOT.
     std::string Prefix = "-implicit-check-not='";

 }
 
 // A check prefix must contain only alphanumeric, hyphens and underscores.
 static bool ValidateCheckPrefix(StringRef CheckPrefix) {
   Regex Validator("^[a-zA-Z0-9_-]*$");
   return Validator.match(CheckPrefix);
 }
 
-bool llvm::FileCheck::ValidateCheckPrefixes() {
+bool FileCheck::ValidateCheckPrefixes() {
   StringSet<> PrefixSet;
 
   for (StringRef Prefix : Req.CheckPrefixes) {
     // Reject empty prefixes.
     if (Prefix == "")
       return false;
 
     if (!PrefixSet.insert(Prefix).second)
       return false;
 
     if (!ValidateCheckPrefix(Prefix))
       return false;
   }
 
   return true;
 }
 
-Regex llvm::FileCheck::buildCheckPrefixRegex() {
+Regex FileCheck::buildCheckPrefixRegex() {
   // I don't think there's a way to specify an initial value for cl::list,
   // so if nothing was specified, add the default
   if (Req.CheckPrefixes.empty())
     Req.CheckPrefixes.push_back("CHECK");
 
   // We already validated the contents of CheckPrefixes so just concatenate
   // them as alternatives.
   SmallString<32> PrefixRegexStr;
for (const auto &Var : GlobalNumericVariableTable)
     }
 
   for (const auto &Var : LocalPatternVars)
     GlobalVariableTable.erase(Var);
   for (const auto &Var : LocalNumericVars)
     GlobalNumericVariableTable.erase(Var);
 }
 
-bool llvm::FileCheck::CheckInput(SourceMgr &SM, StringRef Buffer,
-                                 ArrayRef<FileCheckString> CheckStrings,
-                                 std::vector<FileCheckDiag> *Diags) {
+bool FileCheck::CheckInput(SourceMgr &SM, StringRef Buffer,
   bool ChecksFailed = false;
 
   unsigned i = 0, j = 0, e = CheckStrings.size();
   while (true) {
     StringRef CheckRegion;
     if (j == e) {
       CheckRegion = Buffer;
     } else {