[FileCheck] Stop qualifying expressions as numeric

[thopre]

Summary

Stop referring to "numeric expression", using simply the term
"expression" instead. Likewise for numeric operation since operations
are only used in numeric expressions.

[probinson]

I think this is a definite improvement in readability, once you fix the two places that seem to have lost a line of commentary.

llvm/docs/CommandGuide/FileCheck.rst

599

Some sort of mis-edit here.

llvm/include/llvm/Support/FileCheck.h

473–478

Looks like a line was lost by accident?

[thopre]

Add back line removed in bad conflict resolution

[thopre]

Re-add line erroneously removed in interactive git add session

[probinson]

LGTM

llvm/docs/CommandGuide/FileCheck.rst

.. code-block:: llvm
     ; CHECK: mov r[[#REG:]], 42
 
 would match ``mov r5, 42`` and set ``REG`` to the value ``5``.
 
 The syntax of a numeric substitution is ``[[#<NUMVAR><op><offset>]]`` where:
 
 * ``<NUMVAR>`` is the name of a defined numeric variable.
 
-* ``<op>`` is an optional numeric operation to perform on the value of
-  ``<NUMVAR>``. Currently supported numeric operations are ``+`` and ``-``.
+* ``<op>`` is an optional operation to perform on the value of ``<NUMVAR>``.
+  Currently supported operations are ``+`` and ``-``.
 
-* ``<offset>`` is the immediate value that constitutes the second operand of
-  the numeric operation <op>. It must be present if ``<op>`` is present,
-  absent otherwise.
+  the operation <op>. It must be present if ``<op>`` is present, absent
+  otherwise.
 
 Spaces are accepted before, after and between any of these elements.
 
 For example:
 
 .. code-block:: llvm
 
     ; CHECK: load r[[#REG:]], [r0]
.. code-block:: gas
     load r5, [r0]
     load r7, [r1]
 
 due to ``7`` being unequal to ``5 + 1``.
 
 The ``--enable-var-scope`` option has the same effect on numeric variables as
 on string variables.
 
-Important note: In its current implementation, a numeric expression cannot use
-a numeric variable defined on the same line.
+Important note: In its current implementation, an expression cannot use a
+numeric variable defined on the same line.
 
 FileCheck Pseudo Numeric Variables
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Sometimes there's a need to verify output that contains line numbers of the
 match file, e.g. when testing compiler diagnostics.  This introduces a certain
 fragility of the match file structure, as "``CHECK:``" lines contain absolute
 line numbers in the same file, which have to be updated whenever line numbers
 change due to text addition or deletion.
 
-To support this case, FileCheck numeric expressions understand the ``@LINE``
-pseudo numeric variable which evaluates to the line number of the CHECK pattern
-where it is found.
+To support this case, FileCheck expressions understand the ``@LINE`` pseudo
+numeric variable which evaluates to the line number of the CHECK pattern where
+it is found.
 
 This way match patterns can be put near the relevant test lines and include
 relative line number references, for example:
 
 .. code-block:: c++
 
    // CHECK: test.cpp:[[# @LINE + 4]]:6: error: expected ';' after top level declarator
    // CHECK-NEXT: {{^int a}}

llvm/include/llvm/Support/FileCheck.h

public:
   FileCheckNumericVariable(size_t DefLineNumber, StringRef Name)
       : Name(Name), DefLineNumber(DefLineNumber) {}
 
   /// 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), DefLineNumber(0) {}
 
-  /// \returns name of that numeric variable.
+  /// \returns name of this numeric variable.
   StringRef getName() const { return Name; }
 
-  /// \returns value of this numeric variable.
+  /// \returns this variable's 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.
public:
 
   /// Print name of variable associated with this error.
   void log(raw_ostream &OS) const override {
     OS << "\"";
     OS.write_escaped(VarName) << "\"";
   }
 };
 
-/// Class representing a numeric expression consisting of either a single
-/// numeric variable or a binary operation between a numeric variable and an
+/// Class representing an expression consisting of either a single numeric
+/// variable or a binary operation between a numeric variable and an
 /// immediate.
-class FileCheckNumExpr {
+class FileCheckExpression {
 private:
   /// Left operand.
   FileCheckNumericVariable *LeftOp;
 
   /// Right operand.
   uint64_t RightOp;
 
   /// Pointer to function that can evaluate this binary operation.
   binop_eval_t EvalBinop;
 
 public:
-  FileCheckNumExpr(binop_eval_t EvalBinop,
-                   FileCheckNumericVariable *OperandLeft, uint64_t OperandRight)
+  FileCheckExpression(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 an error if the
-  /// numeric variable used is undefined, or the expression value otherwise.
+  /// Evaluates the value of this expression, using EvalBinop to perform the
+  /// binary operation it consists of. \returns an error if the numeric
+  /// variable used is undefined, or the expression value otherwise.
   Expected<uint64_t> eval() const;
 };
 
 class FileCheckPatternContext;
 
 /// Class representing a substitution to perform in the RegExStr string.
 class FileCheckSubstitution {
 protected:
   /// Pointer to a class instance holding, among other things, the table with
   /// the values of live string variables at the start of any given CHECK line.
   /// Used for substituting string variables with the text they were defined
-  /// as. Numeric expressions are linked to the numeric variables they use at
+  /// as. Expressions are linked to the numeric variables they use at
   /// parse time and directly access the value of the numeric variable to
   /// evaluate their value.
   FileCheckPatternContext *Context;
 
   /// The string that needs to be substituted for something else. For a
-  /// string variable this is its name, otherwise this is the whole numeric
-  /// expression.
+  /// string variable this is its name, otherwise this is the whole expression.
   StringRef FromStr;
 
   // Index in RegExStr of where to do the substitution.
   size_t InsertIdx;
 
 public:
   FileCheckSubstitution(FileCheckPatternContext *Context, StringRef VarName,
                         size_t InsertIdx)
public:
 
   /// \returns the text that the string variable in this substitution matched
   /// when defined, or an error if the variable is undefined.
   Expected<std::string> getResult() const override;
 };
 
 class FileCheckNumericSubstitution : public FileCheckSubstitution {
 private:
-  /// Pointer to the class representing the numeric expression whose value is
-  /// to be substituted.
-  FileCheckNumExpr *NumExpr;
+  /// Pointer to the class representing the expression whose value is to be
+  /// substituted.
+  FileCheckExpression *Expression;
 
 public:
-  FileCheckNumericSubstitution(FileCheckPatternContext *Context, StringRef Expr,
-                               FileCheckNumExpr *NumExpr, size_t InsertIdx)
-      : FileCheckSubstitution(Context, Expr, InsertIdx), NumExpr(NumExpr) {}
+  FileCheckNumericSubstitution(FileCheckPatternContext *Context,
+                               StringRef ExpressionStr,
+                               FileCheckExpression *Expression,
+                               size_t InsertIdx)
+      : FileCheckSubstitution(Context, ExpressionStr, InsertIdx),
+        Expression(Expression) {}
 
-  /// \returns a string containing the result of evaluating the numeric
-  /// expression in this substitution, or an error if evaluation failed.
+  /// \returns a string containing the result of evaluating the expression in
+  /// this substitution, or an error if evaluation failed.
   Expected<std::string> getResult() const override;
 };
 
 //===----------------------------------------------------------------------===//
 // Pattern handling code.
 //===----------------------------------------------------------------------===//
 
 namespace Check {
private:
   /// representing the last definitions of numeric variables defined in
   /// previous patterns. Earlier definitions of the variables, if any, have
   /// their own class instance not referenced by this table. When matching a
   /// pattern all definitions for that pattern are recorded in the
   /// NumericVariableDefs table in the FileCheckPattern instance of that
   /// pattern.
   StringMap<FileCheckNumericVariable *> GlobalNumericVariableTable;
 
-  /// Vector holding pointers to all parsed numeric expressions. Used to
-  /// automatically free the numeric expressions once they are guaranteed to no
-  /// longer be used.
-  std::vector<std::unique_ptr<FileCheckNumExpr>> NumExprs;
+  /// Vector holding pointers to all parsed expressions. Used to automatically
+  /// free the expressions once they are guaranteed to no longer be used.
+  std::vector<std::unique_ptr<FileCheckExpression>> Expressions;
 
   /// Vector holding pointers to all parsed numeric variables. Used to
   /// automatically free them once they are guaranteed to no longer be used.
   std::vector<std::unique_ptr<FileCheckNumericVariable>> NumericVariables;
 
   /// 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:
 
   /// Undefines local variables (variables whose name does not start with a '$'
   /// sign), i.e. removes them from GlobalVariableTable and from
   /// GlobalNumericVariableTable and also clears the value of numeric
   /// variables.
   void clearLocalVars();
 
 private:
-  /// Makes a new numeric expression instance and registers it for destruction
-  /// when the context is destroyed.
-  FileCheckNumExpr *makeNumExpr(binop_eval_t EvalBinop,
+  /// Makes a new expression instance and registers it for destruction when
+  /// the context is destroyed.
+  FileCheckExpression *makeExpression(binop_eval_t EvalBinop,
                                       FileCheckNumericVariable *OperandLeft,
                                       uint64_t OperandRight);
 
   /// Makes a new numeric variable and registers it for destruction when the
   /// context is destroyed.
   template <class... Types>
   FileCheckNumericVariable *makeNumericVariable(Types... args);
 
   /// Makes a new string substitution and registers it for destruction when the
   /// context is destroyed.
   FileCheckSubstitution *makeStringSubstitution(StringRef VarName,
                                                 size_t InsertIdx);
 
   /// Makes a new numeric substitution and registers it for destruction when
   /// the context is destroyed.
-  FileCheckSubstitution *makeNumericSubstitution(StringRef Expr,
-                                                 FileCheckNumExpr *NumExpr,
-                                                 size_t InsertIdx);
+  FileCheckSubstitution *
+  makeNumericSubstitution(StringRef ExpressionStr,
+                          FileCheckExpression *Expression, size_t InsertIdx);
 };
 
 /// Class to represent an error holding a diagnostic with location information
 /// used when printing it.
 class FileCheckErrorDiagnostic : public ErrorInfo<FileCheckErrorDiagnostic> {
 private:
   SMDiagnostic Diagnostic;
 
class FileCheckPattern {
   /// A fixed string to match as the pattern or empty if this pattern requires
   /// a regex match.
   StringRef FixedStr;
 
   /// A regex string to match as the pattern or empty if this pattern requires
   /// a fixed string to match.
   std::string RegExStr;
 
-  /// Entries in this vector represent a substitution of a string variable or a
-  /// numeric expression in the RegExStr regex at match time. For example, in
-  /// the case of a CHECK directive with the pattern "foo[[bar]]baz[[#N+1]]",
+  /// Entries in this vector represent a substitution of a string variable or
+  /// an expression in the RegExStr regex at match time. For example, in the
+  /// case of a CHECK directive with the pattern "foo[[bar]]baz[[#N+1]]",
   /// RegExStr will contain "foobaz" and we'll get two entries in this vector
   /// that tells us to insert the value of string variable "bar" at offset 3
-  /// and the value of numeric expression "N+1" at offset 6.
+  /// and the value of expression "N+1" at offset 6.
   std::vector<FileCheckSubstitution *> Substitutions;
 
   /// Maps names of string variables defined in a pattern to the number of
   /// their parenthesis group in RegExStr capturing their last definition.
   ///
   /// E.g. for the pattern "foo[[bar:.*]]baz([[bar]][[QUUX]][[bar:.*]])",
   /// RegExStr will be "foo(.*)baz(\1<quux value>(.*))" where <quux value> is
   /// the value captured for QUUX on the earlier line where it was defined, and
   /// VariableDefs will map "bar" to the third parenthesis group which captures
   /// the second definition of "bar".
   ///
   /// Note: uses std::map rather than StringMap to be able to get the key when
   /// iterating over values.
   std::map<StringRef, unsigned> VariableDefs;
 
   /// Structure representing the definition of a numeric variable in a pattern.
   /// It holds the pointer to the class representing the numeric variable whose
   /// value is being defined and the number of the parenthesis group in
   /// RegExStr to capture that value.
-  struct FileCheckNumExprMatch {
+  struct FileCheckNumericVariableMatch {
     /// Pointer to class representing the numeric variable whose value is being
     /// defined.
     FileCheckNumericVariable *DefinedNumericVariable;
 
     /// Number of the parenthesis group in RegExStr that captures the value of
     /// this numeric variable definition.
     unsigned CaptureParenGroup;
   };
 
   /// Holds the number of the parenthesis group in RegExStr and pointer to the
   /// corresponding FileCheckNumericVariable class instance of all numeric
   /// variable definitions. Used to set the matched value of all those
   /// variables.
-  StringMap<FileCheckNumExprMatch> NumericVariableDefs;
+  StringMap<FileCheckNumericVariableMatch> NumericVariableDefs;
 
   /// Pointer to a class instance holding the global state shared by all
   /// patterns:
   /// - separate tables with the values of live string and numeric variables
   ///   respectively at the start of any given CHECK line;
   /// - table holding whether a string variable has been defined at any given
   ///   point during the parsing phase.
   FileCheckPatternContext *Context;
public:
   /// Parses \p Expr for the name of a numeric variable to be defined. \returns
   /// an error holding a diagnostic against \p SM should defining such a
   /// variable be invalid, or Success otherwise. In the latter case, sets
   /// \p Name to the name of the parsed numeric variable name.
   static Error parseNumericVariableDefinition(StringRef &Expr, StringRef &Name,
                                               FileCheckPatternContext *Context,
                                               const SourceMgr &SM);
   /// Parses \p Expr for a numeric substitution block. \returns the class
-  /// representing the AST of the numeric expression whose value must be
-  /// substituted, or an error holding a diagnostic against \p SM if parsing
-  /// fails. If substitution was successful, sets \p DefinedNumericVariable to
-  /// point to the class representing the numeric variable defined in this
-  /// numeric substitution block, or None if this block does not define any
-  /// variable.
-  Expected<FileCheckNumExpr *> parseNumericSubstitutionBlock(
+  /// representing the AST of the expression whose value must be substituted,
+  /// or an error holding a diagnostic against \p SM if parsing fails. If
+  /// substitution was successful, sets \p DefinedNumericVariable to point to
+  /// the class representing the numeric variable defined in this numeric
+  /// substitution block, or None if this block does not define any variable.
+  Expected<FileCheckExpression *> parseNumericSubstitutionBlock(
       StringRef Expr,
       Optional<FileCheckNumericVariable *> &DefinedNumericVariable,
       const SourceMgr &SM) const;
   /// Parses the pattern in \p PatternStr and initializes this FileCheckPattern
   /// instance accordingly.
   ///
   /// \p Prefix provides which prefix is being matched, \p Req describes the
   /// global options that influence the parsing such as whitespace
private:
   size_t FindRegexVarEnd(StringRef Str, SourceMgr &SM);
 
   /// Parses \p Expr for the use of a numeric variable. \returns the pointer to
   /// the class instance representing that variable if successful, or an error
   /// holding a diagnostic against \p SM otherwise.
   Expected<FileCheckNumericVariable *>
   parseNumericVariableUse(StringRef &Expr, const SourceMgr &SM) const;
   /// Parses \p Expr for a binary operation.
-  /// \returns the class representing the binary operation of the numeric
-  /// expression, or an error holding a diagnostic against \p SM otherwise.
-  Expected<FileCheckNumExpr *> parseBinop(StringRef &Expr,
+  /// \returns the class representing the binary operation of the expression,
+  /// or an error holding a diagnostic against \p SM otherwise.
+  Expected<FileCheckExpression *> parseBinop(StringRef &Expr,
                                              const SourceMgr &SM) const;
 };
 
 //===----------------------------------------------------------------------===//
 /// Summary of a FileCheck diagnostic.
 //===----------------------------------------------------------------------===//
 
 struct FileCheckDiag {
   /// What is the FileCheck directive for this diagnostic?

llvm/lib/Support/FileCheck.cpp

 
 bool FileCheckNumericVariable::clearValue() {
   if (!Value)
     return true;
   Value = None;
   return false;
 }
 
-Expected<uint64_t> FileCheckNumExpr::eval() const {
-  assert(LeftOp && "Evaluating an empty numeric expression");
+Expected<uint64_t> FileCheckExpression::eval() const {
+  assert(LeftOp && "Evaluating an empty expression");
   Optional<uint64_t> LeftOpValue = LeftOp->getValue();
   // Variable is undefined.
   if (!LeftOpValue)
     return make_error<FileCheckUndefVarError>(LeftOp->getName());
   return EvalBinop(*LeftOpValue, RightOp);
 }
 
 Expected<std::string> FileCheckNumericSubstitution::getResult() const {
-  Expected<uint64_t> EvaluatedValue = NumExpr->eval();
+  Expected<uint64_t> EvaluatedValue = Expression->eval();
   if (!EvaluatedValue)
     return EvaluatedValue.takeError();
   return utostr(*EvaluatedValue);
 }
 
 Expected<std::string> FileCheckStringSubstitution::getResult() const {
   // Look up the value and escape it so that we can put it into the regex.
   Expected<StringRef> VarVal = Context->getPatternVarValue(FromStr);

 static uint64_t add(uint64_t LeftOp, uint64_t RightOp) {
   return LeftOp + RightOp;
 }
 
 static uint64_t sub(uint64_t LeftOp, uint64_t RightOp) {
   return LeftOp - RightOp;
 }
 
-Expected<FileCheckNumExpr *>
+Expected<FileCheckExpression *>
 FileCheckPattern::parseBinop(StringRef &Expr, const SourceMgr &SM) const {
   Expected<FileCheckNumericVariable *> LeftParseResult =
       parseNumericVariableUse(Expr, SM);
   if (!LeftParseResult) {
     return LeftParseResult.takeError();
   }
   FileCheckNumericVariable *LeftOp = *LeftParseResult;
 
   // Check if this is a supported operation and select a function to perform
   // it.
   Expr = Expr.ltrim(SpaceChars);
   if (Expr.empty())
-    return Context->makeNumExpr(add, LeftOp, 0);
+    return Context->makeExpression(add, LeftOp, 0);
   SMLoc OpLoc = SMLoc::getFromPointer(Expr.data());
   char Operator = popFront(Expr);
   binop_eval_t EvalBinop;
   switch (Operator) {
   case '+':
     EvalBinop = add;
     break;
   case '-':
     EvalBinop = sub;
     break;
   default:
     return FileCheckErrorDiagnostic::get(
-        SM, OpLoc,
-        Twine("unsupported numeric operation '") + Twine(Operator) + "'");
+        SM, OpLoc, Twine("unsupported operation '") + Twine(Operator) + "'");
   }
 
   // Parse right operand.
   Expr = Expr.ltrim(SpaceChars);
   if (Expr.empty())
-    return FileCheckErrorDiagnostic::get(
-        SM, Expr, "missing operand in numeric expression");
+    return FileCheckErrorDiagnostic::get(SM, Expr,
+                                         "missing operand in expression");
   uint64_t RightOp;
   if (Expr.consumeInteger(10, RightOp))
     return FileCheckErrorDiagnostic::get(
-        SM, Expr, "invalid offset in numeric expression '" + Expr + "'");
+        SM, Expr, "invalid offset in expression '" + Expr + "'");
   Expr = Expr.ltrim(SpaceChars);
   if (!Expr.empty())
     return FileCheckErrorDiagnostic::get(
-        SM, Expr,
-        "unexpected characters at end of numeric expression '" + Expr + "'");
+        SM, Expr, "unexpected characters at end of expression '" + Expr + "'");
 
-  return Context->makeNumExpr(EvalBinop, LeftOp, RightOp);
+  return Context->makeExpression(EvalBinop, LeftOp, RightOp);
 }
 
-Expected<FileCheckNumExpr *> FileCheckPattern::parseNumericSubstitutionBlock(
+Expected<FileCheckExpression *> FileCheckPattern::parseNumericSubstitutionBlock(
     StringRef Expr,
     Optional<FileCheckNumericVariable *> &DefinedNumericVariable,
     const SourceMgr &SM) const {
   // Parse the numeric variable definition.
   DefinedNumericVariable = None;
   size_t DefEnd = Expr.find(':');
   if (DefEnd != StringRef::npos) {
     StringRef DefExpr = Expr.substr(0, DefEnd);
if (DefEnd != StringRef::npos) {
     if (!DefExpr.empty())
       return FileCheckErrorDiagnostic::get(
           SM, DefExpr, "invalid numeric variable definition");
     UseExpr = UseExpr.ltrim(SpaceChars);
     if (!UseExpr.empty())
       return FileCheckErrorDiagnostic::get(
           SM, UseExpr,
           "unexpected string after variable definition: '" + UseExpr + "'");
-    return Context->makeNumExpr(add, nullptr, 0);
+    return Context->makeExpression(add, nullptr, 0);
   }
 
-  // Parse the numeric expression itself.
+  // Parse the expression itself.
   Expr = Expr.ltrim(SpaceChars);
   return parseBinop(Expr, SM);
 }
 
 bool FileCheckPattern::parsePattern(StringRef PatternStr, StringRef Prefix,
                                     SourceMgr &SM,
                                     const FileCheckRequest &Req) {
   bool MatchFullLinesHere = Req.MatchFullLines && CheckTy != Check::CheckNot;
if (PatternStr.startswith("[[")) {
       PatternStr = UnparsedPatternStr.substr(End + 2);
 
       bool IsDefinition = false;
       StringRef DefName;
       StringRef SubstStr;
       StringRef MatchRegexp;
       size_t SubstInsertIdx = RegExStr.size();
 
-      // Parse string variable or legacy numeric expression.
+      // Parse string variable or legacy expression.
       if (!IsNumBlock) {
         size_t VarEndIdx = MatchStr.find(":");
         size_t SpacePos = MatchStr.substr(0, VarEndIdx).find_first_of(" \t");
         if (SpacePos != StringRef::npos) {
           SM.PrintMessage(SMLoc::getFromPointer(MatchStr.data() + SpacePos),
                           SourceMgr::DK_Error, "unexpected whitespace");
           return true;
         }
if (PatternStr.startswith("[[")) {
             MatchStr = OrigMatchStr;
             IsNumBlock = true;
           } else
             SubstStr = Name;
         }
       }
 
       // Parse numeric substitution block.
-      FileCheckNumExpr *NumExpr;
+      FileCheckExpression *Expression;
       Optional<FileCheckNumericVariable *> DefinedNumericVariable;
       if (IsNumBlock) {
-        Expected<FileCheckNumExpr *> ParseResult =
+        Expected<FileCheckExpression *> ParseResult =
             parseNumericSubstitutionBlock(MatchStr, DefinedNumericVariable, SM);
         if (!ParseResult) {
           logAllUnhandledErrors(ParseResult.takeError(), errs());
           return true;
         }
-        NumExpr = *ParseResult;
+        Expression = *ParseResult;
         if (DefinedNumericVariable) {
           IsDefinition = true;
           DefName = (*DefinedNumericVariable)->getName();
           MatchRegexp = StringRef("[0-9]+");
         } else
           SubstStr = MatchStr;
       }
 
       // Handle substitutions: [[foo]] and [[#<foo expr>]].
       if (!IsDefinition) {
         // Handle substitution of string variables that were defined earlier on
-        // the same line by emitting a backreference. Numeric expressions do
-        // not support substituting a numeric variable defined on the same
-        // line.
+        // the same line by emitting a backreference. Expressions do not
+        // support substituting a numeric variable defined on the same line.
         if (!IsNumBlock && VariableDefs.find(SubstStr) != VariableDefs.end()) {
           unsigned CaptureParenGroup = VariableDefs[SubstStr];
           if (CaptureParenGroup < 1 || CaptureParenGroup > 9) {
             SM.PrintMessage(SMLoc::getFromPointer(SubstStr.data()),
                             SourceMgr::DK_Error,
                             "Can't back-reference more than 9 variables");
             return true;
           }
           AddBackrefToRegEx(CaptureParenGroup);
         } else {
           // Handle substitution of string variables ([[<var>]]) defined in
-          // previous CHECK patterns, and substitution of numeric expressions.
+          // previous CHECK patterns, and substitution of expressions.
           FileCheckSubstitution *Substitution =
               IsNumBlock
-                  ? Context->makeNumericSubstitution(SubstStr, NumExpr,
+                  ? Context->makeNumericSubstitution(SubstStr, Expression,
                                                      SubstInsertIdx)
                   : Context->makeStringSubstitution(SubstStr, SubstInsertIdx);
           Substitutions.push_back(Substitution);
         }
         continue;
       }
 
       // Handle variable definitions: [[<def>:(...)]] and
       // [[#(...)<def>:(...)]].
       if (IsNumBlock) {
-        FileCheckNumExprMatch NumExprDef = {*DefinedNumericVariable, CurParen};
-        NumericVariableDefs[DefName] = NumExprDef;
+        FileCheckNumericVariableMatch NumericVariableDefinition = {
+            *DefinedNumericVariable, CurParen};
+        NumericVariableDefs[DefName] = NumericVariableDefinition;
         // This store is done here rather than in match() to allow
         // parseNumericVariableUse() to get the pointer to the class instance
         // of the right variable definition corresponding to a given numeric
         // variable use.
         Context->GlobalNumericVariableTable[DefName] = *DefinedNumericVariable;
       } else {
         VariableDefs[DefName] = CurParen;
         // Mark the string variable as defined to detect collisions between
Expected<size_t> FileCheckPattern::match(StringRef Buffer, size_t &MatchLen,
   // If there are substitutions, we need to create a temporary string with the
   // actual value.
   StringRef RegExToMatch = RegExStr;
   std::string TmpStr;
   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.
+    // Substitute all string variables and 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).
       Expected<std::string> Value = Substitution->getResult();
       if (!Value)
         return Value.takeError();
 
       // Plop it into the regex at the adjusted offset.
       TmpStr.insert(TmpStr.begin() + Substitution->getIndex() + InsertOffset,
Expected<size_t> FileCheckPattern::match(StringRef Buffer, size_t &MatchLen,
   for (const auto &VariableDef : VariableDefs) {
     assert(VariableDef.second < MatchInfo.size() && "Internal paren error");
     Context->GlobalVariableTable[VariableDef.first] =
         MatchInfo[VariableDef.second];
   }
 
   // If this defines any numeric variables, remember their values.
   for (const auto &NumericVariableDef : NumericVariableDefs) {
-    const FileCheckNumExprMatch &NumericVariableMatch =
+    const FileCheckNumericVariableMatch &NumericVariableMatch =
         NumericVariableDef.getValue();
     unsigned CaptureParenGroup = NumericVariableMatch.CaptureParenGroup;
     assert(CaptureParenGroup < MatchInfo.size() && "Internal paren error");
     FileCheckNumericVariable *DefinedNumericVariable =
         NumericVariableMatch.DefinedNumericVariable;
 
     StringRef MatchedValue = MatchInfo[CaptureParenGroup];
     uint64_t Val;

 FileCheckPatternContext::getPatternVarValue(StringRef VarName) {
   auto VarIter = GlobalVariableTable.find(VarName);
   if (VarIter == GlobalVariableTable.end())
     return make_error<FileCheckUndefVarError>(VarName);
 
   return VarIter->second;
 }
 
-FileCheckNumExpr *
-FileCheckPatternContext::makeNumExpr(binop_eval_t EvalBinop,
+FileCheckExpression *
+FileCheckPatternContext::makeExpression(binop_eval_t EvalBinop,
                                         FileCheckNumericVariable *OperandLeft,
                                         uint64_t OperandRight) {
-  NumExprs.push_back(llvm::make_unique<FileCheckNumExpr>(EvalBinop, OperandLeft,
-                                                         OperandRight));
-  return NumExprs.back().get();
+  Expressions.push_back(llvm::make_unique<FileCheckExpression>(
+      EvalBinop, OperandLeft, OperandRight));
+  return Expressions.back().get();
 }
 
 template <class... Types>
 FileCheckNumericVariable *
 FileCheckPatternContext::makeNumericVariable(Types... args) {
   NumericVariables.push_back(
       llvm::make_unique<FileCheckNumericVariable>(args...));
   return NumericVariables.back().get();
 }
 
 FileCheckSubstitution *
 FileCheckPatternContext::makeStringSubstitution(StringRef VarName,
                                                 size_t InsertIdx) {
   Substitutions.push_back(
       llvm::make_unique<FileCheckStringSubstitution>(this, VarName, InsertIdx));
   return Substitutions.back().get();
 }
 
 FileCheckSubstitution *FileCheckPatternContext::makeNumericSubstitution(
-    StringRef Expr, FileCheckNumExpr *NumExpr, size_t InsertIdx) {
+    StringRef ExpressionStr, FileCheckExpression *Expression,
+    size_t InsertIdx) {
   Substitutions.push_back(llvm::make_unique<FileCheckNumericSubstitution>(
-      this, Expr, NumExpr, InsertIdx));
+      this, ExpressionStr, Expression, InsertIdx));
   return Substitutions.back().get();
 }
 
 size_t FileCheckPattern::FindRegexVarEnd(StringRef Str, SourceMgr &SM) {
   // Offset keeps track of the current offset within the input Str
   size_t Offset = 0;
   // [...] Nesting depth
   size_t BracketDepth = 0;

llvm/test/FileCheck/line-count.txt

 42
 43 BAD7: [[@LINE-1 ]]
 44 ERR7: line-count.txt:[[#@LINE-1]]:19: error: unexpected whitespace
 45
 46 BAD8: [[@LIN]]
 47 ERR8: line-count.txt:[[#@LINE-1]]:12: error: invalid pseudo numeric variable '@LIN'
 48
 49 BAD9: [[@LINE*2]]
-50 ERR9: line-count.txt:[[#@LINE-1]]:17: error: unsupported numeric operation '*'
+50 ERR9: line-count.txt:[[#@LINE-1]]:17: error: unsupported operation '*'
 51
 52 BAD10: [[@LINE-x]]
-53 ERR10: line-count.txt:[[#@LINE-1]]:19: error: invalid offset in numeric expression 'x'
+53 ERR10: line-count.txt:[[#@LINE-1]]:19: error: invalid offset in expression 'x'
 54
 55 BAD11: [[@LINE-1x]]
-56 ERR11: line-count.txt:[[#@LINE-1]]:20: error: unexpected characters at end of numeric expression 'x'
+56 ERR11: line-count.txt:[[#@LINE-1]]:20: error: unexpected characters at end of expression 'x'
 57
 58 CHECK: [[#@LINE]] CHECK
 59 CHECK: [[# @LINE]] CHECK
 60 CHECK: [[# @LINE ]] CHECK
 61
 62 CHECK: [[#@LINE-1]]
 63 CHECK: [[# @LINE-1]] CHECK
 64 CHECK: [[# @LINE -1]] CHECK
 65 CHECK: [[# @LINE - 1]] CHECK
 66 CHECK: [[# @LINE - 1 ]] CHECK

llvm/test/FileCheck/numeric-expression.txt

 ; Numeric expression with unsupported operator.
 RUN: not FileCheck -D#NUMVAR=10 --check-prefix INVAL-OP --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix INVAL-OP-MSG %s
 
 INVALID OPERATOR
 NUMVAR*2: 22
 INVAL-OP-LABEL: INVALID OPERATOR
 INVAL-OP-NEXT: NUMVAR*2: [[#NUMVAR*2]]
-INVAL-OP-MSG: numeric-expression.txt:[[#@LINE-1]]:35: error: unsupported numeric operation '*'
+INVAL-OP-MSG: numeric-expression.txt:[[#@LINE-1]]:35: error: unsupported operation '*'
 INVAL-OP-MSG-NEXT: {{I}}NVAL-OP-NEXT: NUMVAR*2: {{\[\[#NUMVAR\*2\]\]}}
 INVAL-OP-MSG-NEXT: {{^                                  \^$}}
 
 ; Name conflict between Numeric variable definition and string variable
 ; definition whether from the command-line or input text.
 RUN: not FileCheck --check-prefixes CONFLICT,CONFLICT1,CONFLICT2 --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix INPUT-STR-CONFLICT %s
 RUN: not FileCheck -D#NUMVAR=42 --check-prefixes CONFLICT,CONFLICT2 --input-file %s %s 2>&1 \

llvm/unittests/Support/FileCheckTest.cpp

 uint64_t doAdd(uint64_t OpL, uint64_t OpR) { return OpL + OpR; }
 
 static void expectUndefError(const Twine &ExpectedStr, Error Err) {
   handleAllErrors(std::move(Err), [&](const FileCheckUndefVarError &E) {
     EXPECT_EQ(ExpectedStr.str(), E.getVarName());
   });
 }
 
-TEST_F(FileCheckTest, NumExpr) {
+TEST_F(FileCheckTest, Expression) {
   FileCheckNumericVariable FooVar = FileCheckNumericVariable("FOO", 42);
-  FileCheckNumExpr NumExpr = FileCheckNumExpr(doAdd, &FooVar, 18);
+  FileCheckExpression Expression = FileCheckExpression(doAdd, &FooVar, 18);
 
   // Defined variable: eval returns right value.
-  Expected<uint64_t> Value = NumExpr.eval();
+  Expected<uint64_t> Value = Expression.eval();
   EXPECT_TRUE(static_cast<bool>(Value));
   EXPECT_EQ(60U, *Value);
 
   // Undefined variable: eval fails, undefined variable returned. We call
   // getUndefVarName first to check that it can be called without calling
   // eval() first.
   FooVar.clearValue();
-  Error EvalError = NumExpr.eval().takeError();
+  Error EvalError = Expression.eval().takeError();
   EXPECT_TRUE(errorToBool(std::move(EvalError)));
   expectUndefError("FOO", std::move(EvalError));
 }
 
 TEST_F(FileCheckTest, ValidVarNameStart) {
   EXPECT_TRUE(FileCheckPattern::isValidVarNameStart('a'));
   EXPECT_TRUE(FileCheckPattern::isValidVarNameStart('G'));
   EXPECT_TRUE(FileCheckPattern::isValidVarNameStart('_'));
TEST_F(FileCheckTest, Substitution) {
   Expected<std::string> SubstValue = StringSubstitution.getResult();
   EXPECT_FALSE(static_cast<bool>(SubstValue));
   expectUndefError("VAR404", SubstValue.takeError());
 
   // Substitutions of defined pseudo and non-pseudo numeric variables return
   // the right value.
   FileCheckNumericVariable LineVar = FileCheckNumericVariable("@LINE", 42);
   FileCheckNumericVariable NVar = FileCheckNumericVariable("N", 10);
-  FileCheckNumExpr NumExprLine = FileCheckNumExpr(doAdd, &LineVar, 0);
-  FileCheckNumExpr NumExprN = FileCheckNumExpr(doAdd, &NVar, 3);
+  FileCheckExpression LineExpression = FileCheckExpression(doAdd, &LineVar, 0);
+  FileCheckExpression NExpression = FileCheckExpression(doAdd, &NVar, 3);
   FileCheckNumericSubstitution SubstitutionLine =
-      FileCheckNumericSubstitution(&Context, "@LINE", &NumExprLine, 12);
+      FileCheckNumericSubstitution(&Context, "@LINE", &LineExpression, 12);
   FileCheckNumericSubstitution SubstitutionN =
-      FileCheckNumericSubstitution(&Context, "N", &NumExprN, 30);
+      FileCheckNumericSubstitution(&Context, "N", &NExpression, 30);
   Expected<std::string> Value = SubstitutionLine.getResult();
   EXPECT_TRUE(static_cast<bool>(Value));
   EXPECT_EQ("42", *Value);
   Value = SubstitutionN.getResult();
   EXPECT_TRUE(static_cast<bool>(Value));
   EXPECT_EQ("13", *Value);
 
   // Substitution of an undefined numeric variable fails.
TEST_F(FileCheckTest, FileCheckContext) {
   // Check defined variables are present and undefined is absent.
   StringRef LocalVarStr = "LocalVar";
   StringRef LocalNumVarRef = bufferize(SM, "LocalNumVar");
   StringRef EmptyVarStr = "EmptyVar";
   StringRef UnknownVarStr = "UnknownVar";
   Expected<StringRef> LocalVar = Cxt.getPatternVarValue(LocalVarStr);
   FileCheckPattern P = FileCheckPattern(Check::CheckPlain, &Cxt, 1);
   Optional<FileCheckNumericVariable *> DefinedNumericVariable;
-  Expected<FileCheckNumExpr *> NumExpr = P.parseNumericSubstitutionBlock(
+  Expected<FileCheckExpression *> Expression = P.parseNumericSubstitutionBlock(
       LocalNumVarRef, DefinedNumericVariable, SM);
   Expected<StringRef> EmptyVar = Cxt.getPatternVarValue(EmptyVarStr);
   Expected<StringRef> UnknownVar = Cxt.getPatternVarValue(UnknownVarStr);
   EXPECT_TRUE(static_cast<bool>(LocalVar));
   EXPECT_EQ(*LocalVar, "FOO");
-  EXPECT_TRUE(static_cast<bool>(NumExpr));
-  Expected<uint64_t> NumExprVal = (*NumExpr)->eval();
-  EXPECT_TRUE(static_cast<bool>(NumExprVal));
-  EXPECT_EQ(*NumExprVal, 18U);
+  EXPECT_TRUE(static_cast<bool>(Expression));
+  Expected<uint64_t> ExpressionVal = (*Expression)->eval();
+  EXPECT_TRUE(static_cast<bool>(ExpressionVal));
+  EXPECT_EQ(*ExpressionVal, 18U);
   EXPECT_TRUE(static_cast<bool>(EmptyVar));
   EXPECT_EQ(*EmptyVar, "");
   EXPECT_TRUE(errorToBool(UnknownVar.takeError()));
 
   // Clear local variables and check they become absent.
   Cxt.clearLocalVars();
   LocalVar = Cxt.getPatternVarValue(LocalVarStr);
   EXPECT_TRUE(errorToBool(LocalVar.takeError()));
   // Check a numeric expression's evaluation fails if called after clearing of
   // 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((*NumExpr)->eval().takeError()));
+  EXPECT_TRUE(errorToBool((*Expression)->eval().takeError()));
   P = FileCheckPattern(Check::CheckPlain, &Cxt, 2);
-  NumExpr = P.parseNumericSubstitutionBlock(LocalNumVarRef,
+  Expression = P.parseNumericSubstitutionBlock(LocalNumVarRef,
                                                DefinedNumericVariable, SM);
-  EXPECT_TRUE(errorToBool(NumExpr.takeError()));
+  EXPECT_TRUE(errorToBool(Expression.takeError()));
   EmptyVar = Cxt.getPatternVarValue(EmptyVarStr);
   EXPECT_TRUE(errorToBool(EmptyVar.takeError()));
 
   // Redefine global variables and check variables are defined again.
   GlobalDefines.emplace_back(std::string("$GlobalVar=BAR"));
   GlobalDefines.emplace_back(std::string("#$GlobalNumVar=36"));
   EXPECT_FALSE(errorToBool(Cxt.defineCmdlineVariables(GlobalDefines, SM)));
   StringRef GlobalVarStr = "$GlobalVar";
   StringRef GlobalNumVarRef = bufferize(SM, "$GlobalNumVar");
   Expected<StringRef> GlobalVar = Cxt.getPatternVarValue(GlobalVarStr);
   EXPECT_TRUE(static_cast<bool>(GlobalVar));
   EXPECT_EQ(*GlobalVar, "BAR");
   P = FileCheckPattern(Check::CheckPlain, &Cxt, 3);
-  NumExpr = P.parseNumericSubstitutionBlock(GlobalNumVarRef,
+  Expression = P.parseNumericSubstitutionBlock(GlobalNumVarRef,
                                                DefinedNumericVariable, SM);
-  EXPECT_TRUE(static_cast<bool>(NumExpr));
-  NumExprVal = (*NumExpr)->eval();
-  EXPECT_TRUE(static_cast<bool>(NumExprVal));
-  EXPECT_EQ(*NumExprVal, 36U);
+  EXPECT_TRUE(static_cast<bool>(Expression));
+  ExpressionVal = (*Expression)->eval();
+  EXPECT_TRUE(static_cast<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);
-  NumExpr = P.parseNumericSubstitutionBlock(GlobalNumVarRef,
+  Expression = P.parseNumericSubstitutionBlock(GlobalNumVarRef,
                                                DefinedNumericVariable, SM);
-  EXPECT_TRUE(static_cast<bool>(NumExpr));
-  NumExprVal = (*NumExpr)->eval();
-  EXPECT_TRUE(static_cast<bool>(NumExprVal));
-  EXPECT_EQ(*NumExprVal, 36U);
+  EXPECT_TRUE(static_cast<bool>(Expression));
+  ExpressionVal = (*Expression)->eval();
+  EXPECT_TRUE(static_cast<bool>(ExpressionVal));
+  EXPECT_EQ(*ExpressionVal, 36U);
 }
 } // namespace