[FileCheck] Remove FileCheck prefix in API

Summary:
When FileCheck was made a library, types in the public API were renamed
to add a FileCheck prefix, such as Pattern to FileCheckPattern. Many
types were moved into a private interface and thus don't need this
prefix anymore. This commit removes those unneeded prefixes.

Reviewers: jhenderson, jdenny, probinson, grimar, arichardson, rnk

Reviewed By: jhenderson

Subscribers: hiraditya, llvm-commits

Tags: #llvm

Differential Revision: https://reviews.llvm.org/D72186

1 files changed, 71 insertions, 73 deletions

diff --git a/llvm/unittests/Support/FileCheckTest.cpp b/llvm/unittests/Support/FileCheckTest.cpp
index 66465f1..8ca0af7 100644
--- a/llvm/unittests/Support/FileCheckTest.cpp
+++ b/llvm/unittests/Support/FileCheckTest.cpp
@@ -19,13 +19,13 @@ class FileCheckTest : public ::testing::Test {};
 
 TEST_F(FileCheckTest, Literal) {
   // Eval returns the literal's value.
-  FileCheckExpressionLiteral Ten(10);
+  ExpressionLiteral Ten(10);
   Expected<uint64_t> Value = Ten.eval();
   ASSERT_TRUE(bool(Value));
   EXPECT_EQ(10U, *Value);
 
   // Max value can be correctly represented.
-  FileCheckExpressionLiteral Max(std::numeric_limits<uint64_t>::max());
+  ExpressionLiteral Max(std::numeric_limits<uint64_t>::max());
   Value = Max.eval();
   ASSERT_TRUE(bool(Value));
   EXPECT_EQ(std::numeric_limits<uint64_t>::max(), *Value);
@@ -45,14 +45,14 @@ static std::string toString(const std::unordered_set<std::string> &Set) {
 static void
 expectUndefErrors(std::unordered_set<std::string> ExpectedUndefVarNames,
                   Error Err) {
-  handleAllErrors(std::move(Err), [&](const FileCheckUndefVarError &E) {
+  handleAllErrors(std::move(Err), [&](const UndefVarError &E) {
     ExpectedUndefVarNames.erase(E.getVarName());
   });
   EXPECT_TRUE(ExpectedUndefVarNames.empty()) << toString(ExpectedUndefVarNames);
 }
 
-// Return whether Err contains any FileCheckUndefVarError whose associated name
-// is not ExpectedUndefVarName.
+// Return whether Err contains any UndefVarError whose associated name is not
+// ExpectedUndefVarName.
 static void expectUndefError(const Twine &ExpectedUndefVarName, Error Err) {
   expectUndefErrors({ExpectedUndefVarName.str()}, std::move(Err));
 }
@@ -62,9 +62,9 @@ uint64_t doAdd(uint64_t OpL, uint64_t OpR) { return OpL + OpR; }
 TEST_F(FileCheckTest, NumericVariable) {
   // Undefined variable: getValue and eval fail, error returned by eval holds
   // the name of the undefined variable.
-  FileCheckNumericVariable FooVar("FOO", 1);
+  NumericVariable FooVar("FOO", 1);
   EXPECT_EQ("FOO", FooVar.getName());
-  FileCheckNumericVariableUse FooVarUse("FOO", &FooVar);
+  NumericVariableUse FooVarUse("FOO", &FooVar);
   EXPECT_FALSE(FooVar.getValue());
   Expected<uint64_t> EvalResult = FooVarUse.eval();
   ASSERT_FALSE(EvalResult);
@@ -90,15 +90,15 @@ TEST_F(FileCheckTest, NumericVariable) {
 }
 
 TEST_F(FileCheckTest, Binop) {
-  FileCheckNumericVariable FooVar("FOO", 1);
+  NumericVariable FooVar("FOO", 1);
   FooVar.setValue(42);
-  std::unique_ptr<FileCheckNumericVariableUse> FooVarUse =
-      std::make_unique<FileCheckNumericVariableUse>("FOO", &FooVar);
-  FileCheckNumericVariable BarVar("BAR", 2);
+  std::unique_ptr<NumericVariableUse> FooVarUse =
+      std::make_unique<NumericVariableUse>("FOO", &FooVar);
+  NumericVariable BarVar("BAR", 2);
   BarVar.setValue(18);
-  std::unique_ptr<FileCheckNumericVariableUse> BarVarUse =
-      std::make_unique<FileCheckNumericVariableUse>("BAR", &BarVar);
-  FileCheckASTBinop Binop(doAdd, std::move(FooVarUse), std::move(BarVarUse));
+  std::unique_ptr<NumericVariableUse> BarVarUse =
+      std::make_unique<NumericVariableUse>("BAR", &BarVar);
+  BinaryOperation Binop(doAdd, std::move(FooVarUse), std::move(BarVarUse));
 
   // Defined variable: eval returns right value.
   Expected<uint64_t> Value = Binop.eval();
@@ -121,15 +121,15 @@ TEST_F(FileCheckTest, Binop) {
 }
 
 TEST_F(FileCheckTest, ValidVarNameStart) {
-  EXPECT_TRUE(FileCheckPattern::isValidVarNameStart('a'));
-  EXPECT_TRUE(FileCheckPattern::isValidVarNameStart('G'));
-  EXPECT_TRUE(FileCheckPattern::isValidVarNameStart('_'));
-  EXPECT_FALSE(FileCheckPattern::isValidVarNameStart('2'));
-  EXPECT_FALSE(FileCheckPattern::isValidVarNameStart('$'));
-  EXPECT_FALSE(FileCheckPattern::isValidVarNameStart('@'));
-  EXPECT_FALSE(FileCheckPattern::isValidVarNameStart('+'));
-  EXPECT_FALSE(FileCheckPattern::isValidVarNameStart('-'));
-  EXPECT_FALSE(FileCheckPattern::isValidVarNameStart(':'));
+  EXPECT_TRUE(Pattern::isValidVarNameStart('a'));
+  EXPECT_TRUE(Pattern::isValidVarNameStart('G'));
+  EXPECT_TRUE(Pattern::isValidVarNameStart('_'));
+  EXPECT_FALSE(Pattern::isValidVarNameStart('2'));
+  EXPECT_FALSE(Pattern::isValidVarNameStart('$'));
+  EXPECT_FALSE(Pattern::isValidVarNameStart('@'));
+  EXPECT_FALSE(Pattern::isValidVarNameStart('+'));
+  EXPECT_FALSE(Pattern::isValidVarNameStart('-'));
+  EXPECT_FALSE(Pattern::isValidVarNameStart(':'));
 }
 
 static StringRef bufferize(SourceMgr &SM, StringRef Str) {
@@ -144,65 +144,65 @@ TEST_F(FileCheckTest, ParseVar) {
   SourceMgr SM;
   StringRef OrigVarName = bufferize(SM, "GoodVar42");
   StringRef VarName = OrigVarName;
-  Expected<FileCheckPattern::VariableProperties> ParsedVarResult =
-      FileCheckPattern::parseVariable(VarName, SM);
+  Expected<Pattern::VariableProperties> ParsedVarResult =
+      Pattern::parseVariable(VarName, SM);
   ASSERT_TRUE(bool(ParsedVarResult));
   EXPECT_EQ(ParsedVarResult->Name, OrigVarName);
   EXPECT_TRUE(VarName.empty());
   EXPECT_FALSE(ParsedVarResult->IsPseudo);
 
   VarName = OrigVarName = bufferize(SM, "$GoodGlobalVar");
-  ParsedVarResult = FileCheckPattern::parseVariable(VarName, SM);
+  ParsedVarResult = Pattern::parseVariable(VarName, SM);
   ASSERT_TRUE(bool(ParsedVarResult));
   EXPECT_EQ(ParsedVarResult->Name, OrigVarName);
   EXPECT_TRUE(VarName.empty());
   EXPECT_FALSE(ParsedVarResult->IsPseudo);
 
   VarName = OrigVarName = bufferize(SM, "@GoodPseudoVar");
-  ParsedVarResult = FileCheckPattern::parseVariable(VarName, SM);
+  ParsedVarResult = Pattern::parseVariable(VarName, SM);
   ASSERT_TRUE(bool(ParsedVarResult));
   EXPECT_EQ(ParsedVarResult->Name, OrigVarName);
   EXPECT_TRUE(VarName.empty());
   EXPECT_TRUE(ParsedVarResult->IsPseudo);
 
   VarName = bufferize(SM, "42BadVar");
-  ParsedVarResult = FileCheckPattern::parseVariable(VarName, SM);
+  ParsedVarResult = Pattern::parseVariable(VarName, SM);
   EXPECT_TRUE(errorToBool(ParsedVarResult.takeError()));
 
   VarName = bufferize(SM, "$@");
-  ParsedVarResult = FileCheckPattern::parseVariable(VarName, SM);
+  ParsedVarResult = Pattern::parseVariable(VarName, SM);
   EXPECT_TRUE(errorToBool(ParsedVarResult.takeError()));
 
   VarName = OrigVarName = bufferize(SM, "B@dVar");
-  ParsedVarResult = FileCheckPattern::parseVariable(VarName, SM);
+  ParsedVarResult = Pattern::parseVariable(VarName, SM);
   ASSERT_TRUE(bool(ParsedVarResult));
   EXPECT_EQ(VarName, OrigVarName.substr(1));
   EXPECT_EQ(ParsedVarResult->Name, "B");
   EXPECT_FALSE(ParsedVarResult->IsPseudo);
 
   VarName = OrigVarName = bufferize(SM, "B$dVar");
-  ParsedVarResult = FileCheckPattern::parseVariable(VarName, SM);
+  ParsedVarResult = Pattern::parseVariable(VarName, SM);
   ASSERT_TRUE(bool(ParsedVarResult));
   EXPECT_EQ(VarName, OrigVarName.substr(1));
   EXPECT_EQ(ParsedVarResult->Name, "B");
   EXPECT_FALSE(ParsedVarResult->IsPseudo);
 
   VarName = bufferize(SM, "BadVar+");
-  ParsedVarResult = FileCheckPattern::parseVariable(VarName, SM);
+  ParsedVarResult = Pattern::parseVariable(VarName, SM);
   ASSERT_TRUE(bool(ParsedVarResult));
   EXPECT_EQ(VarName, "+");
   EXPECT_EQ(ParsedVarResult->Name, "BadVar");
   EXPECT_FALSE(ParsedVarResult->IsPseudo);
 
   VarName = bufferize(SM, "BadVar-");
-  ParsedVarResult = FileCheckPattern::parseVariable(VarName, SM);
+  ParsedVarResult = Pattern::parseVariable(VarName, SM);
   ASSERT_TRUE(bool(ParsedVarResult));
   EXPECT_EQ(VarName, "-");
   EXPECT_EQ(ParsedVarResult->Name, "BadVar");
   EXPECT_FALSE(ParsedVarResult->IsPseudo);
 
   VarName = bufferize(SM, "BadVar:");
-  ParsedVarResult = FileCheckPattern::parseVariable(VarName, SM);
+  ParsedVarResult = Pattern::parseVariable(VarName, SM);
   ASSERT_TRUE(bool(ParsedVarResult));
   EXPECT_EQ(VarName, ":");
   EXPECT_EQ(ParsedVarResult->Name, "BadVar");
@@ -215,7 +215,7 @@ private:
   SourceMgr SM;
   FileCheckRequest Req;
   FileCheckPatternContext Context;
-  FileCheckPattern P{Check::CheckPlain, &Context, LineNumber++};
+  Pattern P{Check::CheckPlain, &Context, LineNumber++};
 
 public:
   PatternTester() {
@@ -236,12 +236,12 @@ public:
   }
 
   void initNextPattern() {
-    P = FileCheckPattern(Check::CheckPlain, &Context, LineNumber++);
+    P = Pattern(Check::CheckPlain, &Context, LineNumber++);
   }
 
   bool parseSubstExpect(StringRef Expr) {
     StringRef ExprBufferRef = bufferize(SM, Expr);
-    Optional<FileCheckNumericVariable *> DefinedNumericVariable;
+    Optional<NumericVariable *> DefinedNumericVariable;
     return errorToBool(
         P.parseNumericSubstitutionBlock(ExprBufferRef, DefinedNumericVariable,
                                         false, LineNumber - 1, &Context, SM)
@@ -406,24 +406,22 @@ TEST_F(FileCheckTest, Substitution) {
 
   // Substitution of an undefined string variable fails and error holds that
   // variable's name.
-  FileCheckStringSubstitution StringSubstitution(&Context, "VAR404", 42);
+  StringSubstitution StringSubstitution(&Context, "VAR404", 42);
   Expected<std::string> SubstValue = StringSubstitution.getResult();
   ASSERT_FALSE(bool(SubstValue));
   expectUndefError("VAR404", SubstValue.takeError());
 
   // Substitutions of defined pseudo and non-pseudo numeric variables return
   // the right value.
-  FileCheckNumericVariable LineVar("@LINE", 1);
-  FileCheckNumericVariable NVar("N", 1);
+  NumericVariable LineVar("@LINE", 1);
+  NumericVariable NVar("N", 1);
   LineVar.setValue(42);
   NVar.setValue(10);
-  auto LineVarUse =
-      std::make_unique<FileCheckNumericVariableUse>("@LINE", &LineVar);
-  auto NVarUse = std::make_unique<FileCheckNumericVariableUse>("N", &NVar);
-  FileCheckNumericSubstitution SubstitutionLine(&Context, "@LINE",
-                                                std::move(LineVarUse), 12);
-  FileCheckNumericSubstitution SubstitutionN(&Context, "N", std::move(NVarUse),
-                                             30);
+  auto LineVarUse = std::make_unique<NumericVariableUse>("@LINE", &LineVar);
+  auto NVarUse = std::make_unique<NumericVariableUse>("N", &NVar);
+  NumericSubstitution SubstitutionLine(&Context, "@LINE", std::move(LineVarUse),
+                                       12);
+  NumericSubstitution SubstitutionN(&Context, "N", std::move(NVarUse), 30);
   SubstValue = SubstitutionLine.getResult();
   ASSERT_TRUE(bool(SubstValue));
   EXPECT_EQ("42", *SubstValue);
@@ -443,8 +441,8 @@ TEST_F(FileCheckTest, Substitution) {
   expectUndefError("N", SubstValue.takeError());
 
   // Substitution of a defined string variable returns the right value.
-  FileCheckPattern P(Check::CheckPlain, &Context, 1);
-  StringSubstitution = FileCheckStringSubstitution(&Context, "FOO", 42);
+  Pattern P(Check::CheckPlain, &Context, 1);
+  StringSubstitution = llvm::StringSubstitution(&Context, "FOO", 42);
   SubstValue = StringSubstitution.getResult();
   ASSERT_TRUE(bool(SubstValue));
   EXPECT_EQ("BAR", *SubstValue);
@@ -514,9 +512,9 @@ TEST_F(FileCheckTest, FileCheckContext) {
   StringRef EmptyVarStr = "EmptyVar";
   StringRef UnknownVarStr = "UnknownVar";
   Expected<StringRef> LocalVar = Cxt.getPatternVarValue(LocalVarStr);
-  FileCheckPattern P(Check::CheckPlain, &Cxt, 1);
-  Optional<FileCheckNumericVariable *> DefinedNumericVariable;
-  Expected<std::unique_ptr<FileCheckExpressionAST>> ExpressionAST =
+  Pattern P(Check::CheckPlain, &Cxt, 1);
+  Optional<NumericVariable *> DefinedNumericVariable;
+  Expected<std::unique_ptr<ExpressionAST>> ExpressionASTPointer =
       P.parseNumericSubstitutionBlock(LocalNumVar1Ref, DefinedNumericVariable,
                                       /*IsLegacyLineExpr=*/false,
                                       /*LineNumber=*/1, &Cxt, SM);
@@ -524,16 +522,16 @@ TEST_F(FileCheckTest, FileCheckContext) {
   EXPECT_EQ(*LocalVar, "FOO");
   Expected<StringRef> EmptyVar = Cxt.getPatternVarValue(EmptyVarStr);
   Expected<StringRef> UnknownVar = Cxt.getPatternVarValue(UnknownVarStr);
-  ASSERT_TRUE(bool(ExpressionAST));
-  Expected<uint64_t> ExpressionVal = (*ExpressionAST)->eval();
+  ASSERT_TRUE(bool(ExpressionASTPointer));
+  Expected<uint64_t> ExpressionVal = (*ExpressionASTPointer)->eval();
   ASSERT_TRUE(bool(ExpressionVal));
   EXPECT_EQ(*ExpressionVal, 18U);
-  ExpressionAST =
+  ExpressionASTPointer =
       P.parseNumericSubstitutionBlock(LocalNumVar2Ref, DefinedNumericVariable,
                                       /*IsLegacyLineExpr=*/false,
                                       /*LineNumber=*/1, &Cxt, SM);
-  ASSERT_TRUE(bool(ExpressionAST));
-  ExpressionVal = (*ExpressionAST)->eval();
+  ASSERT_TRUE(bool(ExpressionASTPointer));
+  ExpressionVal = (*ExpressionASTPointer)->eval();
   ASSERT_TRUE(bool(ExpressionVal));
   EXPECT_EQ(*ExpressionVal, 20U);
   ASSERT_TRUE(bool(EmptyVar));
@@ -548,19 +546,19 @@ TEST_F(FileCheckTest, FileCheckContext) {
   // local variables, if it was created before. This is important because local
   // variable clearing due to --enable-var-scope happens after numeric
   // expressions are linked to the numeric variables they use.
-  EXPECT_TRUE(errorToBool((*ExpressionAST)->eval().takeError()));
-  P = FileCheckPattern(Check::CheckPlain, &Cxt, 2);
-  ExpressionAST = P.parseNumericSubstitutionBlock(
+  EXPECT_TRUE(errorToBool((*ExpressionASTPointer)->eval().takeError()));
+  P = Pattern(Check::CheckPlain, &Cxt, 2);
+  ExpressionASTPointer = P.parseNumericSubstitutionBlock(
       LocalNumVar1Ref, DefinedNumericVariable, /*IsLegacyLineExpr=*/false,
       /*LineNumber=*/2, &Cxt, SM);
-  ASSERT_TRUE(bool(ExpressionAST));
-  ExpressionVal = (*ExpressionAST)->eval();
+  ASSERT_TRUE(bool(ExpressionASTPointer));
+  ExpressionVal = (*ExpressionASTPointer)->eval();
   EXPECT_TRUE(errorToBool(ExpressionVal.takeError()));
-  ExpressionAST = P.parseNumericSubstitutionBlock(
+  ExpressionASTPointer = P.parseNumericSubstitutionBlock(
       LocalNumVar2Ref, DefinedNumericVariable, /*IsLegacyLineExpr=*/false,
       /*LineNumber=*/2, &Cxt, SM);
-  ASSERT_TRUE(bool(ExpressionAST));
-  ExpressionVal = (*ExpressionAST)->eval();
+  ASSERT_TRUE(bool(ExpressionASTPointer));
+  ExpressionVal = (*ExpressionASTPointer)->eval();
   EXPECT_TRUE(errorToBool(ExpressionVal.takeError()));
   EmptyVar = Cxt.getPatternVarValue(EmptyVarStr);
   EXPECT_TRUE(errorToBool(EmptyVar.takeError()));
@@ -577,24 +575,24 @@ TEST_F(FileCheckTest, FileCheckContext) {
   Expected<StringRef> GlobalVar = Cxt.getPatternVarValue(GlobalVarStr);
   ASSERT_TRUE(bool(GlobalVar));
   EXPECT_EQ(*GlobalVar, "BAR");
-  P = FileCheckPattern(Check::CheckPlain, &Cxt, 3);
-  ExpressionAST = P.parseNumericSubstitutionBlock(
+  P = Pattern(Check::CheckPlain, &Cxt, 3);
+  ExpressionASTPointer = P.parseNumericSubstitutionBlock(
       GlobalNumVarRef, DefinedNumericVariable, /*IsLegacyLineExpr=*/false,
       /*LineNumber=*/3, &Cxt, SM);
-  ASSERT_TRUE(bool(ExpressionAST));
-  ExpressionVal = (*ExpressionAST)->eval();
+  ASSERT_TRUE(bool(ExpressionASTPointer));
+  ExpressionVal = (*ExpressionASTPointer)->eval();
   ASSERT_TRUE(bool(ExpressionVal));
   EXPECT_EQ(*ExpressionVal, 36U);
 
   // Clear local variables and check global variables remain defined.
   Cxt.clearLocalVars();
   EXPECT_FALSE(errorToBool(Cxt.getPatternVarValue(GlobalVarStr).takeError()));
-  P = FileCheckPattern(Check::CheckPlain, &Cxt, 4);
-  ExpressionAST = P.parseNumericSubstitutionBlock(
+  P = Pattern(Check::CheckPlain, &Cxt, 4);
+  ExpressionASTPointer = P.parseNumericSubstitutionBlock(
       GlobalNumVarRef, DefinedNumericVariable, /*IsLegacyLineExpr=*/false,
       /*LineNumber=*/4, &Cxt, SM);
-  ASSERT_TRUE(bool(ExpressionAST));
-  ExpressionVal = (*ExpressionAST)->eval();
+  ASSERT_TRUE(bool(ExpressionASTPointer));
+  ExpressionVal = (*ExpressionASTPointer)->eval();
   ASSERT_TRUE(bool(ExpressionVal));
   EXPECT_EQ(*ExpressionVal, 36U);
 }