FileCheck: Improve FileCheck variable terminology

[thopre]

Summary

Terminology introduced by # blocks is confusing and does not
integrate well with existing terminology.

First, variables referred by [[]] blocks are called "pattern variables"
while the text a CHECK directive needs to match is called a "CHECK
pattern". This is inconsistent with variables in # blocks since
# blocks are also found in CHECK pattern yet those variables are
called "numeric variable".

Second, the replacing of both [[]] and # blocks by the value of the
variable or expression they contain is represented by a
FileCheckPatternSubstitution class. The naming refers to being a
substitution in a CHECK pattern but could be wrongly understood as being
a substitution of a pattern variable.

Third and lastly, comments use "numeric expression" to refer both to the
# blocks as well as to the numeric expressions these blocks contain
which get evaluated at match time.

This patch solves these confusions by

• calling variables in [[]] and # blocks as string and numeric variables respectively;
• referring to [[]] and # as substitution *blocks*, with the former being a string substitution block and the latter a numeric substitution block;
• calling [[]] and # blocks to be replaced by the value of a variable or expression they contain a substitution (as opposed to definition when these blocks are used to defined a variable), with the former being a string substitution and the latter a numeric substitution;
• renaming the FileCheckPatternSubstitution as a FileCheckSubstitution class with FileCheckStringSubstitution and FileCheckNumericSubstitution subclasses;
• restricting the use of "numeric expression" to refer to the expression that is evaluated in a numeric substitution.

While numeric substitution blocks only support numeric substitutions of
numeric expressions at the moment there are plans to augment numeric
substitution blocks to support numeric definitions as well as both a
numeric definition and numeric substitution in the same numeric
substitution block.

[thopre]

Fix typo

[thopre]

llvm/include/llvm/Support/FileCheck.h

295

Self note: this needs to become a vector of std::unique_ptr

[thopre]

Add memory management for substitutions

[jhenderson]

There's quite a bit more functional changes here than I was expecting. I was expecting this to be a pure renaming exercise.

llvm/docs/CommandGuide/FileCheck.rst

502–503

This line needs shortening, or the docs will probably fail to build.

594

which substitution -> which substitute

llvm/include/llvm/Support/FileCheck.h

106

Does FileCheckPatternContext still make sense as a name?

108–117

I don't think you need "to match" here, if you are naming the variable directly.

111

This isn't just a naming change here...!

114

for the text -> with the text
defined to -> defined as

115

expression -> expressions

116

access directly -> directly access

219

Does FileCheckPattern still make sense in the new naming scheme?

llvm/lib/Support/FileCheck.cpp

313–315

subtituion -> substitution

[thopre]

• Split new substitution hierarchy into a separate patch
• address review comments

[thopre]

llvm/include/llvm/Support/FileCheck.h

106

Yes, it refers to a FileCheckPattern which is the part after the colon in a CHECK (or similar) directive. String variables were called pattern variables because patterns only supported one type of variables. Now we have patterns supporting string and numeric variable. The pattern context holds the current live string and numeric variables.

219

I think so, a pattern refers to what a CHECK directive need to match. In the end it becomes a regular expression pattern that is being matched, whether it includes no variable, string variables, numeric expressions or both.

[jhenderson]

A few more phrasing issues, otherwise LGTM.

llvm/include/llvm/Support/FileCheck.h

262

Is the i.e. referring to just the two Global* variables, or is the "and ..." included?

Also:
variable -> variables
clear -> clears
I'd probably change:
"for numeric variable clear their value as well" to "also clears the value of numeric variables".

llvm/lib/Support/FileCheck.cpp

387

pattern or substitution -> patterns or subsitutions

470

only known now -> only now known (this sounds clearer to me)

llvm/unittests/Support/FileCheckTest.cpp

231

of undefined -> of an undefined

[thopre]

Address review comments

[probinson]

A few small things, and LGTM too.

llvm/docs/CommandGuide/FileCheck.rst

547

blocks

llvm/include/llvm/Support/FileCheck.h

371

pattern -> string
remove "such"

llvm/lib/Support/FileCheck.cpp

387

comma after "patterns"

469–470

value is -> values are

[thopre]

Address review comments

llvm/docs/CommandGuide/FileCheck.rst

 failures to be detected in a single invocation.
 
 There is no requirement that ``CHECK-LABEL:`` directives contain strings that
 correspond to actual syntactic labels in a source or output language: they must
 simply uniquely match a single line in the file being verified.
 
 ``CHECK-LABEL:`` directives cannot contain variable definitions or uses.
 
-FileCheck Pattern Matching Syntax
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+FileCheck Regex Matching Syntax
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 All FileCheck directives take a pattern to match.
 For most uses of FileCheck, fixed string matching is perfectly sufficient.  For
 some things, a more flexible form of matching is desired.  To support this,
 FileCheck allows you to specify regular expressions in matching strings,
 surrounded by double braces: ``{{yourregex}}``. FileCheck implements a POSIX
 regular expression matcher; it supports Extended POSIX regular expressions
 (ERE). Because we want to use fixed string matching for a majority of what we
 do, FileCheck has been designed to support mixing and matching fixed string
 matching with regular expressions.  This allows you to write things like this:
 
 .. code-block:: llvm
 
    ; CHECK: movhpd  {{[0-9]+}}(%esp), {{%xmm[0-7]}}
 
 In this case, any offset from the ESP register will be allowed, and any xmm
 register will be allowed.
 
 Because regular expressions are enclosed with double braces, they are
 visually distinct, and you don't need to use escape characters within the double
 braces like you would in C.  In the rare case that you want to match double
 braces explicitly from the input, you can use something ugly like
 ``{{[{][{]}}`` as your pattern.
 
-FileCheck Pattern Expressions
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+FileCheck String Substitution Blocks
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 It is often useful to match a pattern and then verify that it occurs again
-later in the file.  For codegen tests, this can be useful to allow any register,
-but verify that that register is used consistently later.  To do this,
-:program:`FileCheck` supports pattern expressions that allow pattern variables
-to be defined and substituted into patterns.  Here is a simple example:
+later in the file.  For codegen tests, this can be useful to allow any
+register, but verify that that register is used consistently later.  To do
+this, :program:`FileCheck` supports string substitution blocks that allow
+string variables to be defined and substituted into patterns.  Here is a simple
+example:
 
 .. code-block:: llvm
 
    ; CHECK: test5:
    ; CHECK:    notw [[REGISTER:%[a-z]+]]
    ; CHECK:    andw {{.*}}[[REGISTER]]
 
 The first check line matches a regex ``%[a-z]+`` and captures it into the
-variable ``REGISTER``.  The second line verifies that whatever is in
-``REGISTER`` occurs later in the file after an "``andw``".  :program:`FileCheck`
-variable references are always contained in ``[[ ]]`` pairs, and their names can
-be formed with the regex ``[a-zA-Z_][a-zA-Z0-9_]*``.  If a colon follows the name,
-then it is a definition of the variable; otherwise, it is a use.
-
-:program:`FileCheck` variables can be defined multiple times, and uses always
-get the latest value.  Variables can also be used later on the same line they
-were defined on. For example:
+string variable ``REGISTER``.  The second line verifies that whatever is in
+``REGISTER`` occurs later in the file after an "``andw``". :program:`FileCheck`
+string substitution block are always contained in ``[[ ]]`` pairs, and string
+variable names can be formed with the regex ``[a-zA-Z_][a-zA-Z0-9_]*``.  If a
+colon follows the name, then it is a definition of the variable; otherwise, it
+is a substitution.
+
+:program:`FileCheck` variables can be defined multiple times, and substitutions
+always get the latest value.  Variables can also be substituted later on the
+same line they were defined on. For example:
 
 .. code-block:: llvm
 
     ; CHECK: op [[REG:r[0-9]+]], [[REG]]
 
 Can be useful if you want the operands of ``op`` to be the same register,
 and don't care exactly which register it is.
 
 If ``--enable-var-scope`` is in effect, variables with names that
 start with ``$`` are considered to be global. All others variables are
 local.  All local variables get undefined at the beginning of each
 CHECK-LABEL block. Global variables are not affected by CHECK-LABEL.
 This makes it easier to ensure that individual tests are not affected
 by variables set in preceding tests.
 
-FileCheck Numeric Variables and Expressions
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+FileCheck Numeric Substitution Blocks
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-:program:`FileCheck` also allows checking for numeric values that satisfy a
-numeric expression constraint based on numeric variables. This allows
-``CHECK:`` directives to verify a numeric relation between two numbers, such as
-the need for consecutive registers to be used.
+:program:`FileCheck` also supports numeric substitution blocks that allow
+checking for numeric values that satisfy a numeric expression constraint based
+on numeric variables. This allows ``CHECK:`` directives to verify a numeric
+relation between two numbers, such as the need for consecutive registers to be
+used.
 
-The syntax to check a numeric expression constraint is
-``[[#<NUMVAR><op><offset>]]`` where:
+The syntax of a numeric substitution block is ``[[#<NUMVAR><op><offset>]]``
+where:
 
 * ``<NUMVAR>`` is the name of a numeric variable defined on the command line.
 
 * ``<op>`` is an optional numeric operation to perform on the value of
   ``<NUMVAR>``. Currently supported numeric 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.
 
+Spaces are accepted before, after and between any of these elements.
+
+Unlike string substitution blocks, numeric substitution blocks only introduce
+numeric substitutions which substitute a numeric expression for its value.
 For example:
 
 .. code-block:: llvm
 
     ; CHECK: add r[[#REG]], r[[#REG]], r[[#REG+1]]
 
 The above example would match the line:
 
 .. code-block:: gas
 
     add r5, r5, r6
 
 but would not match the line:
 
 .. code-block:: gas
 
     add r5, r5, r7
 
 due to ``7`` being unequal to ``5 + 1``.
 
 The ``--enable-var-scope`` option has the same effect on numeric variables as
-on pattern variables.
+on string variables.
 
 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

 .. code-block:: c++
 
    // CHECK: test.cpp:[[# @LINE + 4]]:6: error: expected ';' after top level declarator
    // CHECK-NEXT: {{^int a}}
    // CHECK-NEXT: {{^     \^}}
    // CHECK-NEXT: {{^     ;}}
    int a
 
-To support legacy uses of ``@LINE`` as a special pattern variable,
-:program:`FileCheck` also accepts the following uses of ``@LINE`` with pattern
-variable syntax: ``[[@LINE]]``, ``[[@LINE+<offset>]]`` and
+To support legacy uses of ``@LINE`` as a special string variable,
+:program:`FileCheck` also accepts the following uses of ``@LINE`` with string
+substitution block syntax: ``[[@LINE]]``, ``[[@LINE+<offset>]]`` and
 ``[[@LINE-<offset>]]`` without any spaces inside the brackets and where
 ``offset`` is an integer.
 
 Matching Newline Characters
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 To match newline characters in regular expressions the character class
 ``[[:space:]]`` can be used. For example, the following pattern:

llvm/include/llvm/Support/FileCheck.h

struct FileCheckRequest {
   bool MatchFullLines = false;
   bool EnableVarScope = false;
   bool AllowDeprecatedDagOverlap = false;
   bool Verbose = false;
   bool VerboseVerbose = false;
 };
 
 //===----------------------------------------------------------------------===//
-// Numeric expression handling code.
+// Numeric substitution handling code.
 //===----------------------------------------------------------------------===//
 
 /// Class representing a numeric variable with a given value in a numeric
 /// expression.
 class FileCheckNumericVariable {
 private:
   /// Name of the numeric variable.
   StringRef Name;
public:
   /// variable used is undefined, or the expression value otherwise.
   llvm::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;
 
-/// Class representing a substitution to perform in the string to match.
-class FileCheckPatternSubstitution {
-private:
-  /// Pointer to a class instance holding the table with the values of live
-  /// pattern variables at the start of any given CHECK line. Used for
-  /// substituting pattern variables (numeric variables have their value in the
-  /// FileCheckNumExpr class instance pointed to by NumExpr).
+/// 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
+  /// parse time and directly access the value of the numeric variable to
+  /// evaluate their value.
   FileCheckPatternContext *Context;
 
   /// Whether this represents a numeric expression substitution.
-  bool IsNumExpr;
+  bool IsNumSubst;
 
   /// The string that needs to be substituted for something else. For a
-  /// pattern variable this is its name, otherwise this is the whole numeric
+  /// string variable this is its name, otherwise this is the whole numeric
   /// expression.
   StringRef FromStr;
 
   /// If this is a numeric expression substitution, this is the pointer to the
-  /// class representing that numeric expression.
+  /// class representing the numeric expression whose value is to be
+  /// substituted.
   FileCheckNumExpr *NumExpr = nullptr;
 
   // Index in RegExStr of where to do the substitution.
   size_t InsertIdx;
 
 public:
   /// Constructor for a pattern variable substitution.
-  FileCheckPatternSubstitution(FileCheckPatternContext *Context,
-                               StringRef VarName, size_t InsertIdx)
-      : Context(Context), IsNumExpr(false), FromStr(VarName),
+  FileCheckSubstitution(FileCheckPatternContext *Context,
+      : Context(Context), IsNumSubst(false), FromStr(VarName),
         InsertIdx(InsertIdx) {}
 
   /// Constructor for a numeric expression substitution.
-  FileCheckPatternSubstitution(FileCheckPatternContext *Context, StringRef Expr,
-                               FileCheckNumExpr *NumExpr, size_t InsertIdx)
-      : Context(Context), IsNumExpr(true), FromStr(Expr), NumExpr(NumExpr),
+  FileCheckSubstitution(FileCheckPatternContext *Context, StringRef Expr,
+      : Context(Context), IsNumSubst(true), FromStr(Expr), NumExpr(NumExpr),
         InsertIdx(InsertIdx) {}
 
   /// \returns whether this is a numeric expression substitution.
-  bool isNumExpr() const { return IsNumExpr; }
+  bool isNumSubst() const { return IsNumSubst; }
 
-  /// \returns the string to be substituted.
+  /// \returns the string to be substituted for something else.
   StringRef getFromString() const { return FromStr; }
 
-  /// \returns the index where the substitution is to be performed.
+  /// \returns the index where the substitution is to be performed in RegExStr.
   size_t getIndex() const { return InsertIdx; }
 
   /// \returns the result of the substitution represented by this class
   /// instance or None if substitution failed. Numeric expressions are
-  /// substituted by their values. Pattern variables are simply replaced by the
+  /// substituted by their values. String variables are simply replaced by the
   /// text their definition matched.
   llvm::Optional<std::string> getResult() const;
 
   /// \returns the name of the undefined variable used in this substitution, if
   /// any, or an empty string otherwise.
   StringRef getUndefVarName() const;
 };
 

 } // namespace Check
 
 struct FileCheckDiag;
 
 /// Class holding the FileCheckPattern global state, shared by all patterns:
 /// tables holding values of variables and whether they are defined or not at
 /// any given time in the matching process.
 class FileCheckPatternContext {
   friend class FileCheckPattern;
 
 private:
-  /// When matching a given pattern, this holds the value of all the FileCheck
-  /// pattern variables defined in previous patterns. In a pattern, only the
-  /// last definition for a given variable is recorded in this table.
+  /// When matching a given pattern, this holds the value of all the string
+  /// variables defined in previous patterns. In a pattern, only the last
+  /// definition for a given variable is recorded in this table.
   /// Back-references are used for uses after any the other definition.
   StringMap<StringRef> GlobalVariableTable;
 
-  /// Map of all pattern variables defined so far. Used at parse time to detect
-  /// a name conflict between a numeric variable and a pattern variable when
+  /// Map of all string variables defined so far. Used at parse time to detect
+  /// a name conflict between a numeric variable and a string variable when
   /// the former is defined on a later line than the latter.
   StringMap<bool> DefinedVariableTable;
 
   /// When matching a given pattern, this holds the pointers to the classes
   /// representing the last definitions of numeric variables defined in
   /// previous patterns. Earlier definition of the variables, if any, have
   /// their own class instance not referenced by this table.
   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 numeric variables. Used to
   /// automatically free them once they are guaranteed to no longer be used.
   std::vector<std::unique_ptr<FileCheckNumericVariable>> NumericVariables;
 
 public:
-  /// \returns the value of pattern variable \p VarName or None if no such
+  /// \returns the value of string variable \p VarName or None if no such
   /// variable has been defined.
   llvm::Optional<StringRef> getPatternVarValue(StringRef VarName);
 
-  /// Defines pattern and numeric variables from definitions given on the
+  /// 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);
 
   /// Undefines local variables (variables whose name does not start with a '$'
-  /// sign), i.e. removes them from GlobalVariableTable.
+  /// sign), i.e. removes them from GlobalVariableTable and
+  /// GlobalNumericVariableTable and for numeric variable clear their value as
+  /// well.
   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,
                                 FileCheckNumericVariable *OperandLeft,
                                 uint64_t OperandRight);
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 uses of a pattern variable or a numeric
-  /// expression in the pattern that need to be substituted in the regexp
-  /// pattern at match time, e.g. "foo[[bar]]baz[[#N+1]]". In this case, the
+  /// 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]]",
   /// RegExStr will contain "foobaz" and we'll get two entries in this vector
-  /// that tells us to insert the value of pattern variable "bar" at offset 3
-  /// and the value of numeric expression "N+1" at offset 6. Uses are
-  /// represented by a FileCheckPatternSubstitution class to abstract whether
-  /// it is a pattern variable or a numeric expression.
-  std::vector<FileCheckPatternSubstitution> Substitutions;
+  /// 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.
+  std::vector<FileCheckSubstitution> Substitutions;
 
-  /// Maps names of pattern variables defined in a pattern to the parenthesized
+  /// Maps names of string variables defined in a pattern to the parenthesized
   /// capture numbers of their last definition.
   ///
   /// E.g. for the pattern "foo[[bar:.*]]baz[[bar]]quux[[bar:.*]]",
   /// VariableDefs will map "bar" to 2 corresponding to 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;
 
   /// Pointer to a class instance holding the global state shared by all
   /// patterns:
-  /// - separate tables with the values of live pattern and numeric variables
+  /// - separate tables with the values of live string and numeric variables
   ///   respectively at the start of any given CHECK line;
-  /// - table holding whether a pattern variable has been defined at any given
+  /// - table holding whether a string variable has been defined at any given
   ///   point during the parsing phase.
   FileCheckPatternContext *Context;
 
   Check::FileCheckType CheckTy;
 
   /// Contains the number of line this pattern is in.
   unsigned LineNumber;
 
public:
   /// \returns whether \p C is a valid first character for a variable name.
   static bool isValidVarNameStart(char C);
   /// Verifies that the string at the start of \p Str is a well formed
   /// variable. \returns false if it is and sets \p IsPseudo to indicate if it
   /// is a pseudo variable and \p TrailIdx to the position of the last
   /// character that is part of the variable name. Otherwise, only
   /// \returns true.
   static bool parseVariable(StringRef Str, bool &IsPseudo, unsigned &TrailIdx);
-  /// Parses a numeric expression involving (pseudo if \p IsPseudo is true)
+  /// Parses a numeric substitution involving (pseudo if \p IsPseudo is true)
   /// variable \p Name with the string corresponding to the operation being
   /// performed in \p Trailer. \returns the class representing the numeric
-  /// expression or nullptr if parsing fails in which case errors are reported
-  /// on \p SM.
-  FileCheckNumExpr *parseNumericExpression(StringRef Name, bool IsPseudo,
+  /// expression being substituted or nullptr if parsing fails, in which case
+  /// errors are reported on \p SM.
+  FileCheckNumExpr *parseNumericSubstitution(StringRef Name, bool IsPseudo,
                                              StringRef Trailer,
                                              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
   /// canonicalization, \p SM provides the SourceMgr used for error reports,
   /// and \p LineNumber is the line number in the input file from which the
   /// pattern string was read. \returns true in case of an error, false
   /// otherwise.
   bool ParsePattern(StringRef PatternStr, StringRef Prefix, SourceMgr &SM,
                     unsigned LineNumber, const FileCheckRequest &Req);
   /// Matches the pattern string against the input buffer \p Buffer
   ///
   /// \returns the position that is matched or npos if there is no match. If
   /// there is a match, updates \p MatchLen with the size of the matched
   /// string.
   ///
   /// The GlobalVariableTable StringMap in the FileCheckPatternContext class
-  /// instance provides the current values of FileCheck pattern variables and
+  /// instance provides the current values of FileCheck string variables and
   /// is updated if this match defines new values.
   size_t match(StringRef Buffer, size_t &MatchLen) const;
   /// Prints the value of successful substitutions or the name of the undefined
   /// pattern or numeric variable preventing such a successful substitution.
   void printSubstitutions(const SourceMgr &SM, StringRef Buffer,
                           SMRange MatchRange = None) const;
   void printFuzzyMatch(const SourceMgr &SM, StringRef Buffer,
                        std::vector<FileCheckDiag> *Diags) const;
 
   bool hasVariable() const {
     return !(Substitutions.empty() && VariableDefs.empty());
   }

llvm/lib/Support/FileCheck.cpp

 }
 
 StringRef FileCheckNumExpr::getUndefVarName() const {
   if (!LeftOp->getValue())
     return LeftOp->getName();
   return StringRef();
 }
 
-llvm::Optional<std::string> FileCheckPatternSubstitution::getResult() const {
-  if (IsNumExpr) {
+llvm::Optional<std::string> FileCheckSubstitution::getResult() const {
+  if (IsNumSubst) {
     llvm::Optional<uint64_t> EvaluatedValue = NumExpr->eval();
     if (!EvaluatedValue)
       return llvm::None;
     return utostr(*EvaluatedValue);
   }
 
   // Look up the value and escape it so that we can put it into the regex.
   llvm::Optional<StringRef> VarVal = Context->getPatternVarValue(FromStr);
   if (!VarVal)
     return llvm::None;
   return Regex::escape(*VarVal);
 }
 
-StringRef FileCheckPatternSubstitution::getUndefVarName() const {
-  if (IsNumExpr)
+StringRef FileCheckSubstitution::getUndefVarName() const {
+  if (IsNumSubst)
     // 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 (!Context->getPatternVarValue(FromStr))
     return FromStr;
 
   return StringRef();

 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;
 }
 
 FileCheckNumExpr *
-FileCheckPattern::parseNumericExpression(StringRef Name, bool IsPseudo,
+FileCheckPattern::parseNumericSubstitution(StringRef Name, bool IsPseudo,
                                            StringRef Trailer,
                                            const SourceMgr &SM) const {
   if (IsPseudo && !Name.equals("@LINE")) {
     SM.PrintMessage(SMLoc::getFromPointer(Name.data()), SourceMgr::DK_Error,
                     "invalid pseudo numeric variable '" + Name + "'");
     return nullptr;
   }
 
   // This method is indirectly called from ParsePattern for all numeric
   // variable definitions and uses in the order in which they appear in the
if (PatternStr.startswith("{{")) {
       if (AddRegExToRegEx(PatternStr.substr(2, End - 2), CurParen, SM))
         return true;
       RegExStr += ')';
 
       PatternStr = PatternStr.substr(End + 2);
       continue;
     }
 
-    // Pattern and numeric expression matches. Pattern expressions come in two
-    // forms: [[foo:.*]] and [[foo]]. The former matches .* (or some other
-    // regex) and assigns it to the FileCheck variable 'foo'. The latter
-    // substitutes foo's value. Numeric expressions start with a '#' sign after
-    // the double brackets and only have the substitution form. Both pattern
-    // and numeric variables must satisfy the regular expression
+    // String and numeric substitution blocks. String substitution blocks come
+    // in two forms: [[foo:.*]] and [[foo]]. The former matches .* (or some
+    // other regex) and assigns it to the string variable 'foo'. The latter
+    // substitutes foo's value. Numeric substitution blocks start with a
+    // '#' sign after the double brackets and only have the substitution form.
+    // Both string and numeric variables must satisfy the regular expression
     // "[a-zA-Z_][0-9a-zA-Z_]*" to be valid, as this helps catch some common
     // errors.
     if (PatternStr.startswith("[[")) {
       StringRef UnparsedPatternStr = PatternStr.substr(2);
       // Find the closing bracket pair ending the match.  End is going to be an
       // offset relative to the beginning of the match string.
       size_t End = FindRegexVarEnd(UnparsedPatternStr, SM);
       StringRef MatchStr = UnparsedPatternStr.substr(0, End);
-      bool IsNumExpr = MatchStr.consume_front("#");
-      const char *RefTypeStr =
-          IsNumExpr ? "numeric expression" : "pattern variable";
+      bool IsNumBlock = MatchStr.consume_front("#");
 
       if (End == StringRef::npos) {
-        SM.PrintMessage(
-            SMLoc::getFromPointer(PatternStr.data()), SourceMgr::DK_Error,
-            Twine("Invalid ") + RefTypeStr + " reference, no ]] found");
+        SM.PrintMessage(SMLoc::getFromPointer(PatternStr.data()),
+                        SourceMgr::DK_Error,
+                        "Invalid substitution block, no ]] found");
         return true;
       }
-      // Strip the subtitution we are parsing. End points to the start of the
-      // "]]" closing the expression so account for it in computing the index
-      // of the first unparsed character.
+      // Strip the substitution block we are parsing. End points to the start
+      // of the "]]" closing the expression so account for it in computing the
+      // index of the first unparsed character.
       PatternStr = UnparsedPatternStr.substr(End + 2);
 
       size_t VarEndIdx = MatchStr.find(":");
-      if (IsNumExpr)
+      if (IsNumBlock)
         MatchStr = MatchStr.ltrim(SpaceChars);
       else {
         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;
         }
       }
 
-      // Get the regex name (e.g. "foo") and verify it is well formed.
+      // Get the variable name (e.g. "foo") and verify it is well formed.
       bool IsPseudo;
       unsigned TrailIdx;
       if (parseVariable(MatchStr, IsPseudo, TrailIdx)) {
         SM.PrintMessage(SMLoc::getFromPointer(MatchStr.data()),
                         SourceMgr::DK_Error, "invalid variable name");
         return true;
       }
 
       size_t SubstInsertIdx = RegExStr.size();
       FileCheckNumExpr *NumExpr;
 
       StringRef Name = MatchStr.substr(0, TrailIdx);
       StringRef Trailer = MatchStr.substr(TrailIdx);
       bool IsVarDef = (VarEndIdx != StringRef::npos);
 
       if (IsVarDef) {
         if (IsPseudo || !Trailer.consume_front(":")) {
           SM.PrintMessage(SMLoc::getFromPointer(MatchStr.data()),
                           SourceMgr::DK_Error,
-                          "invalid name in pattern variable definition");
+                          "invalid name in string variable definition");
           return true;
         }
 
-        // Detect collisions between pattern and numeric variables when the
+        // Detect collisions between string and numeric variables when the
         // former is created later than the latter.
         if (Context->GlobalNumericVariableTable.find(Name) !=
             Context->GlobalNumericVariableTable.end()) {
           SM.PrintMessage(
               SMLoc::getFromPointer(MatchStr.data()), SourceMgr::DK_Error,
               "numeric variable with name '" + Name + "' already exists");
           return true;
         }
       }
 
-      if (IsNumExpr || (!IsVarDef && IsPseudo)) {
-        NumExpr = parseNumericExpression(Name, IsPseudo, Trailer, SM);
+      if (IsNumBlock || (!IsVarDef && IsPseudo)) {
+        NumExpr = parseNumericSubstitution(Name, IsPseudo, Trailer, SM);
         if (NumExpr == nullptr)
           return true;
-        IsNumExpr = true;
+        IsNumBlock = true;
       }
 
-      // Handle variable use: [[foo]] and [[#<foo expr>]].
+      // Handle substitutions: [[foo]] and [[#<foo expr>]].
       if (!IsVarDef) {
-        // Handle use of pattern variables that were defined earlier on the
-        // same line by emitting a backreference.
-        if (!IsNumExpr && VariableDefs.find(Name) != VariableDefs.end()) {
+        // Handle substitution of string variables that were defined earlier on
+        // the same line by emitting a backreference.
+        if (!IsNumBlock && VariableDefs.find(Name) != VariableDefs.end()) {
           unsigned CaptureParen = VariableDefs[Name];
           if (CaptureParen < 1 || CaptureParen > 9) {
             SM.PrintMessage(SMLoc::getFromPointer(Name.data()),
                             SourceMgr::DK_Error,
                             "Can't back-reference more than 9 variables");
             return true;
           }
           AddBackrefToRegEx(CaptureParen);
         } else {
-          // Handle use of pattern variables ([[<var>]]) defined in previous
-          // CHECK pattern or use of a numeric expression.
-          FileCheckPatternSubstitution Substitution =
-              IsNumExpr ? FileCheckPatternSubstitution(Context, MatchStr,
-                                                       NumExpr, SubstInsertIdx)
-                        : FileCheckPatternSubstitution(Context, MatchStr,
-                                                       SubstInsertIdx);
+          // Handle substitution of string variables ([[<var>]]) defined in
+          // previous CHECK pattern or substitution of a numeric expression.
+          FileCheckSubstitution Substitution =
+              IsNumBlock ? FileCheckSubstitution(Context, MatchStr, NumExpr,
+                                                 SubstInsertIdx)
+                         : FileCheckSubstitution(Context, MatchStr,
           Substitutions.push_back(Substitution);
         }
         continue;
       }
 
-      // Handle [[foo:.*]].
+      // Handle variable definitions: [[foo:.*]].
       VariableDefs[Name] = CurParen;
       RegExStr += '(';
       ++CurParen;
 
       if (AddRegExToRegEx(Trailer, CurParen, SM))
         return true;
 
       RegExStr += ')';
size_t FileCheckPattern::match(StringRef Buffer, size_t &MatchLen) const {
   // If this is a fixed string pattern, just match it now.
   if (!FixedStr.empty()) {
     MatchLen = FixedStr.size();
     return Buffer.find(FixedStr);
   }
 
   // Regex match.
 
-  // If there are variable uses, we need to create a temporary string with the
+  // 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 pattern variables and numeric expressions whose value is
-    // known just now. Use of pattern variables defined on the same line are
+    // Substitute all string variables and numeric expressions whose value is
+    // only known now. 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();
       if (!Value)
         return StringRef::npos;
 
       // Plop it into the regex at the adjusted offset.
size_t FileCheckPattern::match(StringRef Buffer, size_t &MatchLen) const {
   SmallVector<StringRef, 4> MatchInfo;
   if (!Regex(RegExToMatch, Regex::Newline).match(Buffer, &MatchInfo))
     return StringRef::npos;
 
   // Successful regex match.
   assert(!MatchInfo.empty() && "Didn't get any match");
   StringRef FullMatch = MatchInfo[0];
 
-  // If this defines any pattern variables, remember their values.
+  // If this defines any string variables, remember their values.
   for (const auto &VariableDef : VariableDefs) {
     assert(VariableDef.second < MatchInfo.size() && "Internal paren error");
     Context->GlobalVariableTable[VariableDef.first] =
         MatchInfo[VariableDef.second];
   }
 
   // Like CHECK-NEXT, CHECK-EMPTY's match range is considered to start after
   // the required preceding newline, which is consumed by the pattern in the
unsigned FileCheckPattern::computeMatchDistance(StringRef Buffer) const {
   // Only compare up to the first line in the buffer, or the string size.
   StringRef BufferPrefix = Buffer.substr(0, ExampleString.size());
   BufferPrefix = BufferPrefix.split('\n').first;
   return BufferPrefix.edit_distance(ExampleString);
 }
 
 void FileCheckPattern::printSubstitutions(const SourceMgr &SM, StringRef Buffer,
                                           SMRange MatchRange) const {
-  // Print what we know about substitutions. This covers both uses of pattern
-  // variables and numeric subsitutions.
+  // Print what we know about substitutions.
   if (!Substitutions.empty()) {
     for (const auto &Substitution : Substitutions) {
       SmallString<256> Msg;
       raw_svector_ostream OS(Msg);
-      bool IsNumExpr = Substitution.isNumExpr();
+      bool IsNumSubst = Substitution.isNumSubst();
       llvm::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 \"";
         OS.write_escaped(UndefVarName) << "\"";
       } else {
         // Substitution succeeded. Print substituted value.
-        if (IsNumExpr)
+        if (IsNumSubst)
           OS << "with numeric expression \"";
         else
-          OS << "with variable \"";
+          OS << "with string variable \"";
         OS.write_escaped(Substitution.getFromString()) << "\" equal to \"";
         OS.write_escaped(*MatchedValue) << "\"";
       }
 
       if (MatchRange.isValid())
         SM.PrintMessage(MatchRange.Start, SourceMgr::DK_Note, OS.str(),
                         {MatchRange});
       else
if (CmdlineDef[0] == '#') {
         SM.PrintMessage(SMLoc::getFromPointer(CmdlineName.data()),
                         SourceMgr::DK_Error,
                         "invalid name in numeric variable definition '" +
                             CmdlineName + "'");
         ErrorFound = true;
         continue;
       }
 
-      // Detect collisions between pattern and numeric variables when the
-      // latter is created later than the former.
+      // Detect collisions between string and numeric variables when the latter
+      // is created later than the former.
       if (DefinedVariableTable.find(CmdlineName) !=
           DefinedVariableTable.end()) {
         SM.PrintMessage(
             SMLoc::getFromPointer(CmdlineName.data()), SourceMgr::DK_Error,
-            "pattern variable with name '" + CmdlineName + "' already exists");
+            "string variable with name '" + CmdlineName + "' already exists");
         ErrorFound = true;
         continue;
       }
 
       StringRef CmdlineVal = CmdlineDef.substr(EqIdx + 1);
       uint64_t Val;
       if (CmdlineVal.getAsInteger(10, Val)) {
         SM.PrintMessage(SMLoc::getFromPointer(CmdlineVal.data()),
                         SourceMgr::DK_Error,
                         "invalid value in numeric variable definition '" +
                             CmdlineVal + "'");
         ErrorFound = true;
         continue;
       }
       auto DefinedNumericVariable = makeNumericVariable(CmdlineName, Val);
 
       // Record this variable definition.
       GlobalNumericVariableTable[CmdlineName] = DefinedNumericVariable;
     } else {
-      // Pattern variable definition.
+      // String variable definition.
       std::pair<StringRef, StringRef> CmdlineNameVal = CmdlineDef.split('=');
       StringRef Name = CmdlineNameVal.first;
       bool IsPseudo;
       unsigned TrailIdx;
       if (FileCheckPattern::parseVariable(Name, IsPseudo, TrailIdx) ||
           IsPseudo || TrailIdx != Name.size() || Name.empty()) {
         SM.PrintMessage(SMLoc::getFromPointer(Name.data()), SourceMgr::DK_Error,
-                        "invalid name in pattern variable definition '" + Name +
+                        "invalid name in string variable definition '" + Name +
                             "'");
         ErrorFound = true;
         continue;
       }
 
-      // Detect collisions between pattern and numeric variables when the
-      // former is created later than the latter.
+      // Detect collisions between string and numeric variables when the former
+      // is created later than the latter.
       if (GlobalNumericVariableTable.find(Name) !=
           GlobalNumericVariableTable.end()) {
         SM.PrintMessage(SMLoc::getFromPointer(Name.data()), SourceMgr::DK_Error,
                         "numeric variable with name '" + Name +
                             "' already exists");
         ErrorFound = true;
         continue;
       }
       GlobalVariableTable.insert(CmdlineNameVal);
-      // Mark the pattern variable as defined to detect collisions between
-      // pattern and numeric variables in DefineCmdlineVariables when the
-      // latter is created later than the former. We cannot reuse
-      // GlobalVariableTable for that by populating it with an empty string
-      // since we would then lose the ability to detect the use of an undefined
-      // variable in Match().
+      // Mark the string variable as defined to detect collisions between
+      // string and numeric variables in DefineCmdlineVariables when the latter
+      // is created later than the former. We cannot reuse GlobalVariableTable
+      // for that by populating it with an empty string since we would then
+      // lose the ability to detect the use of an undefined variable in
+      // match().
       DefinedVariableTable[Name] = true;
     }
   }
 
   return ErrorFound;
 }
 
 void FileCheckPatternContext::clearLocalVars() {
   SmallVector<StringRef, 16> LocalPatternVars, LocalNumericVars;
   for (const StringMapEntry<StringRef> &Var : GlobalVariableTable)
     if (Var.first()[0] != '$')
       LocalPatternVars.push_back(Var.first());
 
-  // Numeric expression substitution reads the value of a variable directly,
-  // not via GlobalNumericVariableTable. Therefore, we clear local variables by
-  // clearing their value which will lead to a numeric expression substitution
-  // failure. We also mark the variable for removal from
-  // GlobalNumericVariableTable since this is what defineCmdlineVariables
-  // checks to decide that no global variable has been defined.
+  // Numeric substitution reads the value of a variable directly, not via
+  // GlobalNumericVariableTable. Therefore, we clear local variables by
+  // clearing their value which will lead to a numeric substitution failure. We
+  // also mark the variable for removal from GlobalNumericVariableTable since
+  // this is what defineCmdlineVariables checks to decide that no global
+  // variable has been defined.
   for (const auto &Var : GlobalNumericVariableTable)
     if (Var.first()[0] != '$') {
       Var.getValue()->clearValue();
       LocalNumericVars.push_back(Var.first());
     }
 
   for (const auto &Var : LocalPatternVars)
     GlobalVariableTable.erase(Var);

llvm/test/FileCheck/line-count.txt

 18 CHECK: [[@LINE-3]] {{b}}bb
 19 CHECK: [[@LINE-3]] {{c}}cc
 20 foobar
 21 CHECK: [[@LINE-1]] {{foo}}bar
 22
 23 arst CHECK: [[@LINE]] {{a}}rst
 24
 25 BAD1: [[@LINE:cant-have-regex]]
-26 ERR1: line-count.txt:[[#@LINE-1]]:12: error: invalid name in pattern variable definition
+26 ERR1: line-count.txt:[[#@LINE-1]]:12: error: invalid name in string variable definition
 27
 28 BAD2: [[ @LINE]]
 29 ERR2: line-count.txt:[[#@LINE-1]]:12: error: unexpected whitespace
 30
 31 BAD3: [[@LINE ]]
 32 ERR3: line-count.txt:[[#@LINE-1]]:17: error: unexpected whitespace
 33
 34 BAD4: [[ @LINE-1]]

llvm/test/FileCheck/numeric-expression.txt

 INVALID OPERATOR
 VAR1*2: 22
 INVAL-OP-LABEL: INVALID OPERATOR
 INVAL-OP-NEXT: VAR1*2: [[#VAR1*2]]
 INVAL-OP-MSG: numeric-expression.txt:[[#@LINE-1]]:31: error: unsupported numeric operation '*'
 INVAL-OP-MSG-NEXT: {{I}}NVAL-OP-NEXT: VAR1*2: {{\[\[#VAR1\*2\]\]}}
 INVAL-OP-MSG-NEXT: {{^                              \^$}}
 
-; Name conflict between Numeric variable definition and pattern variable
+; Name conflict between Numeric variable definition and string variable
 ; definition
 RUN: not FileCheck -D#VAR1=11 -D#NUMVAR=42 --check-prefixes CONFLICT,CONFLICT1 --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix CLI-INPUT-PAT-CONFLICT %s
 RUN: not FileCheck -D#VAR1=11 -D#NUMVAR=42 -DNUMVAR=foobar --check-prefix CONFLICT --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix CLI-CLI-PAT-CONFLICT %s
 RUN: not FileCheck -D#VAR1=11 -DPATVAR=foobar -D#PATVAR=42 --check-prefix CONFLICT --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix CLI-CLI-NUM-CONFLICT %s
 
 PATVAR NUMVAR CONFLICT
 foobar
 CONFLICT-LABEL: PATVAR NUMVAR CONFLICT
 CONFLICT1-NEXT: [[NUMVAR:foo.*]]
 CLI-INPUT-PAT-CONFLICT: numeric-expression.txt:[[#@LINE-1]]:19: error: numeric variable with name 'NUMVAR' already exists
 CLI-INPUT-PAT-CONFLICT-NEXT: {{C}}ONFLICT1-NEXT: {{\[\[NUMVAR:foo\.\*\]\]}}
 CLI-INPUT-PAT-CONFLICT-NEXT: {{^                  \^$}}
 CLI-CLI-PAT-CONFLICT: Global defines:3:19: error: numeric variable with name 'NUMVAR' already exists
 CLI-CLI-PAT-CONFLICT-NEXT: Global define #3: NUMVAR=foobar
 CLI-CLI-PAT-CONFLICT-NEXT: {{^                  \^$}}
-CLI-CLI-NUM-CONFLICT: Global defines:3:20: error: pattern variable with name 'PATVAR' already exists
+CLI-CLI-NUM-CONFLICT: Global defines:3:20: error: string variable with name 'PATVAR' already exists
 CLI-CLI-NUM-CONFLICT-NEXT: Global define #3: #PATVAR=42
 CLI-CLI-NUM-CONFLICT-NEXT: {{^                   \^$}}

llvm/test/FileCheck/string-defines-diagnostics.txt

 RUN:   | FileCheck %s --check-prefix ERRCLIEQ2
 
 ERRCLIEQ2: {{F|f}}ile{{C|c}}heck{{[^:]*}}: for the -D option: requires a value!
 
 ; Missing variable name.
 RUN: not FileCheck -D=10 --input-file %s %s 2>&1 \
 RUN:   | FileCheck %s --check-prefix ERRCLIVAR1
 
-ERRCLIVAR1: Missing pattern variable name in command-line definition '-D=10'
+ERRCLIVAR1: Missing variable name in command-line definition '-D=10'
 
 ; Missing variable name.
 RUN: not FileCheck -D= --input-file %s %s 2>&1 \
 RUN:   | FileCheck %s --check-prefix ERRCLIVAR2
 
-ERRCLIVAR2: Missing pattern variable name in command-line definition '-D='
+ERRCLIVAR2: Missing variable name in command-line definition '-D='
 
 ; Invalid variable name: starts with a digit.
 RUN: not FileCheck -D10VALUE=10 --input-file %s %s 2>&1 \
 RUN:   | FileCheck %s --strict-whitespace --check-prefix ERRCLIFMT
 
-ERRCLIFMT: Global defines:1:19: error: invalid name in pattern variable definition '10VALUE'
+ERRCLIFMT: Global defines:1:19: error: invalid name in string variable definition '10VALUE'
 ERRCLIFMT-NEXT: Global define #1: 10VALUE=10
 ERRCLIFMT-NEXT: {{^                  \^$}}
 
 ; Invalid definition of pseudo variable.
 RUN: not FileCheck -D@VALUE=10 --input-file %s %s 2>&1 \
 RUN:   | FileCheck %s --strict-whitespace --check-prefix ERRCLIPSEUDO
 
-ERRCLIPSEUDO: Global defines:1:19: error: invalid name in pattern variable definition '@VALUE'
+ERRCLIPSEUDO: Global defines:1:19: error: invalid name in string variable definition '@VALUE'
 ERRCLIPSEUDO-NEXT: Global define #1: @VALUE=10
 ERRCLIPSEUDO-NEXT: {{^                  \^$}}
 
 ; Invalid definition of an expression.
 RUN: not FileCheck -D'VALUE + 2=10' --input-file %s %s 2>&1 \
 RUN:   | FileCheck %s --strict-whitespace --check-prefix ERRCLITRAIL
 
-ERRCLITRAIL: Global defines:1:19: error: invalid name in pattern variable definition 'VALUE + 2'
+ERRCLITRAIL: Global defines:1:19: error: invalid name in string variable definition 'VALUE + 2'
 ERRCLITRAIL-NEXT: Global define #1: VALUE + 2=10
 ERRCLITRAIL-NEXT: {{^                  \^$}}

llvm/test/FileCheck/string-defines.txt

-; Test functionality of -D option: pattern variables are defined to the right
+; Test functionality of -D option: string variables are defined to the right
 ; value and CHECK directives using them match as expected given the value set.
 
-; Pattern variable correctly defined to a non-empty string.
+; String variable correctly defined to a non-empty string.
 RUN: FileCheck -DVALUE=10 --input-file %s %s
 RUN: not FileCheck -DVALUE=20 --input-file %s %s 2>&1 \
 RUN:   | FileCheck %s --check-prefix ERRMSG
 RUN: not FileCheck -DVALUE=10 --check-prefix NOT --input-file %s %s 2>&1 \
 RUN:   | FileCheck %s --check-prefix NOT-ERRMSG
 RUN: FileCheck -DVALUE=20 --check-prefix NOT --input-file %s %s
 
 Value = 10
 CHECK: Value = [[VALUE]]
 NOT-NOT: Value = [[VALUE]]
 
 ERRMSG: defines.txt:[[@LINE-3]]:8: error: CHECK: expected string not found in input
 ERRMSG: defines.txt:1:1: note: scanning from here
-ERRMSG: defines.txt:1:1: note: with variable "VALUE" equal to "20"
+ERRMSG: defines.txt:1:1: note: with string variable "VALUE" equal to "20"
 ERRMSG: defines.txt:[[@LINE-7]]:1: note: possible intended match here
 
 NOT-ERRMSG: defines.txt:[[@LINE-7]]:10: error: {{NOT}}-NOT: excluded string found in input
 NOT-ERRMSG: defines.txt:[[@LINE-10]]:1: note: found here
-NOT-ERRMSG: defines.txt:[[@LINE-11]]:1: note: with variable "VALUE" equal to "10"
+NOT-ERRMSG: defines.txt:[[@LINE-11]]:1: note: with string variable "VALUE" equal to "10"
 
-; Definition of pattern variable to an empty string.
+; Definition of string variable to an empty string.
 RUN: FileCheck -DVALUE= --check-prefix EMPTY --input-file %s %s 2>&1
 
 Empty value = @@
 EMPTY: Empty value = @[[VALUE]]@

llvm/unittests/Support/FileCheckTest.cpp

public:
   }
 
   bool parseExpect(std::string &VarName, std::string &Trailer) {
     bool IsPseudo = VarName[0] == '@';
     std::string NameTrailer = VarName + Trailer;
     StringRef NameTrailerRef = bufferize(SM, NameTrailer);
     StringRef VarNameRef = NameTrailerRef.substr(0, VarName.size());
     StringRef TrailerRef = NameTrailerRef.substr(VarName.size());
-    return P.parseNumericExpression(VarNameRef, IsPseudo, TrailerRef, SM) ==
+    return P.parseNumericSubstitution(VarNameRef, IsPseudo, TrailerRef, SM) ==
            nullptr;
   }
 };
 
 TEST_F(FileCheckTest, ParseExpr) {
   ExprTester Tester;
 
   // @LINE with offset.

 
 TEST_F(FileCheckTest, Substitution) {
   SourceMgr SM;
   FileCheckPatternContext Context;
   std::vector<std::string> GlobalDefines;
   GlobalDefines.emplace_back(std::string("FOO=BAR"));
   Context.defineCmdlineVariables(GlobalDefines, SM);
 
-  // Substitution of undefined pattern variable fails.
-  FileCheckPatternSubstitution PatternSubstitution =
-      FileCheckPatternSubstitution(&Context, "VAR404", 42);
-  EXPECT_FALSE(PatternSubstitution.getResult());
+  // Substitution of undefined string variable fails.
+  FileCheckSubstitution Substitution =
+      FileCheckSubstitution(&Context, "VAR404", 42);
+  EXPECT_FALSE(Substitution.getResult());
 
   // 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);
-  FileCheckPatternSubstitution SubstitutionLine =
-      FileCheckPatternSubstitution(&Context, "@LINE", &NumExprLine, 12);
-  FileCheckPatternSubstitution SubstitutionN =
-      FileCheckPatternSubstitution(&Context, "N", &NumExprN, 30);
+  FileCheckSubstitution SubstitutionLine =
+      FileCheckSubstitution(&Context, "@LINE", &NumExprLine, 12);
+  FileCheckSubstitution SubstitutionN =
+      FileCheckSubstitution(&Context, "N", &NumExprN, 30);
   llvm::Optional<std::string> Value = SubstitutionLine.getResult();
   EXPECT_TRUE(Value);
   EXPECT_EQ("42", *Value);
   Value = SubstitutionN.getResult();
   EXPECT_TRUE(Value);
   EXPECT_EQ("13", *Value);
 
   // Substitution of undefined numeric variable fails.
   LineVar.clearValue();
   EXPECT_FALSE(SubstitutionLine.getResult());
   NVar.clearValue();
   EXPECT_FALSE(SubstitutionN.getResult());
 
-  // Substitution of defined pattern variable returns the right value.
+  // Substitution of a defined string variable returns the right value.
   FileCheckPattern P = FileCheckPattern(Check::CheckPlain, &Context);
-  PatternSubstitution = FileCheckPatternSubstitution(&Context, "FOO", 42);
-  Value = PatternSubstitution.getResult();
+  Substitution = FileCheckSubstitution(&Context, "FOO", 42);
+  Value = Substitution.getResult();
   EXPECT_TRUE(Value);
   EXPECT_EQ("BAR", *Value);
 }
 
 TEST_F(FileCheckTest, UndefVars) {
   SourceMgr SM;
   FileCheckPatternContext Context;
   std::vector<std::string> GlobalDefines;
   GlobalDefines.emplace_back(std::string("FOO=BAR"));
   Context.defineCmdlineVariables(GlobalDefines, SM);
 
-  // getUndefVarName() on a pattern variable substitution with an undefined
-  // variable returns that variable.
-  FileCheckPatternSubstitution Substitution =
-      FileCheckPatternSubstitution(&Context, "VAR404", 42);
+  // getUndefVarName() on a string substitution with an undefined variable
+  // returns that variable.
+  FileCheckSubstitution Substitution =
+      FileCheckSubstitution(&Context, "VAR404", 42);
   StringRef UndefVar = Substitution.getUndefVarName();
   EXPECT_EQ("VAR404", UndefVar);
 
-  // getUndefVarName() on a pattern variable substitution with a defined
-  // variable returns an empty string.
-  Substitution = FileCheckPatternSubstitution(&Context, "FOO", 42);
+  // getUndefVarName() on a string substitution with a defined variable returns
+  // an empty string.
+  Substitution = FileCheckSubstitution(&Context, "FOO", 42);
   UndefVar = Substitution.getUndefVarName();
   EXPECT_EQ("", UndefVar);
 
-  // getUndefVarName() on a numeric expression substitution with a defined
-  // variable returns an empty string.
+  // getUndefVarName() on a numeric substitution with a defined variable
+  // returns an empty string.
   FileCheckNumericVariable LineVar = FileCheckNumericVariable("@LINE", 42);
   FileCheckNumExpr NumExpr = FileCheckNumExpr(doAdd, &LineVar, 0);
-  Substitution = FileCheckPatternSubstitution(&Context, "@LINE", &NumExpr, 12);
+  Substitution = FileCheckSubstitution(&Context, "@LINE", &NumExpr, 12);
   UndefVar = Substitution.getUndefVarName();
   EXPECT_EQ("", UndefVar);
 
-  // getUndefVarName() on a numeric expression substitution with an undefined
-  // variable returns that variable.
+  // getUndefVarName() on a numeric substitution with an undefined variable
+  // returns that variable.
   LineVar.clearValue();
   UndefVar = Substitution.getUndefVarName();
   EXPECT_EQ("@LINE", UndefVar);
 }
 
 TEST_F(FileCheckTest, FileCheckContext) {
   FileCheckPatternContext Cxt = FileCheckPatternContext();
   std::vector<std::string> GlobalDefines;
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";
   llvm::Optional<StringRef> LocalVar = Cxt.getPatternVarValue(LocalVarStr);
   FileCheckPattern P = FileCheckPattern(Check::CheckPlain, &Cxt);
   FileCheckNumExpr *NumExpr =
-      P.parseNumericExpression(LocalNumVarRef, false /*IsPseudo*/, "", SM);
+      P.parseNumericSubstitution(LocalNumVarRef, false /*IsPseudo*/, "", SM);
   llvm::Optional<StringRef> EmptyVar = Cxt.getPatternVarValue(EmptyVarStr);
   llvm::Optional<StringRef> UnknownVar = Cxt.getPatternVarValue(UnknownVarStr);
   EXPECT_TRUE(LocalVar);
   EXPECT_EQ(*LocalVar, "FOO");
   EXPECT_TRUE(NumExpr);
   llvm::Optional<uint64_t> NumExprVal = NumExpr->eval();
   EXPECT_TRUE(NumExprVal);
   EXPECT_EQ(*NumExprVal, 18U);
   EXPECT_TRUE(EmptyVar);
   EXPECT_EQ(*EmptyVar, "");
   EXPECT_FALSE(UnknownVar);
 
   // Clear local variables and check they become absent.
   Cxt.clearLocalVars();
   LocalVar = Cxt.getPatternVarValue(LocalVarStr);
   EXPECT_FALSE(LocalVar);
   // 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_FALSE(NumExpr->eval());
   P = FileCheckPattern(Check::CheckPlain, &Cxt);
   NumExpr =
-      P.parseNumericExpression(LocalNumVarRef, false /*IsPseudo*/, "", SM);
+      P.parseNumericSubstitution(LocalNumVarRef, false /*IsPseudo*/, "", SM);
   EXPECT_FALSE(NumExpr);
   EmptyVar = Cxt.getPatternVarValue(EmptyVarStr);
   EXPECT_FALSE(EmptyVar);
 
   // Redefine global variables and check variables are defined again.
   GlobalDefines.emplace_back(std::string("$GlobalVar=BAR"));
   GlobalDefines.emplace_back(std::string("#$GlobalNumVar=36"));
   GotError = Cxt.defineCmdlineVariables(GlobalDefines, SM);
   EXPECT_FALSE(GotError);
   StringRef GlobalVarStr = "$GlobalVar";
   StringRef GlobalNumVarRef = bufferize(SM, "$GlobalNumVar");
   llvm::Optional<StringRef> GlobalVar = Cxt.getPatternVarValue(GlobalVarStr);
   EXPECT_TRUE(GlobalVar);
   EXPECT_EQ(*GlobalVar, "BAR");
   P = FileCheckPattern(Check::CheckPlain, &Cxt);
   NumExpr =
-      P.parseNumericExpression(GlobalNumVarRef, false /*IsPseudo*/, "", SM);
+      P.parseNumericSubstitution(GlobalNumVarRef, false /*IsPseudo*/, "", SM);
   EXPECT_TRUE(NumExpr);
   NumExprVal = NumExpr->eval();
   EXPECT_TRUE(NumExprVal);
   EXPECT_EQ(*NumExprVal, 36U);
 
   // Clear local variables and check global variables remain defined.
   Cxt.clearLocalVars();
   GlobalVar = Cxt.getPatternVarValue(GlobalVarStr);
   EXPECT_TRUE(GlobalVar);
   P = FileCheckPattern(Check::CheckPlain, &Cxt);
   NumExpr =
-      P.parseNumericExpression(GlobalNumVarRef, false /*IsPseudo*/, "", SM);
+      P.parseNumericSubstitution(GlobalNumVarRef, false /*IsPseudo*/, "", SM);
   EXPECT_TRUE(NumExpr);
   NumExprVal = NumExpr->eval();
   EXPECT_TRUE(NumExprVal);
   EXPECT_EQ(*NumExprVal, 36U);
 }
 } // namespace

llvm/utils/FileCheck/FileCheck.cpp

for (auto G : GlobalDefines) {
     size_t EqIdx = G.find('=');
     if (EqIdx == std::string::npos) {
       errs() << "Missing equal sign in command-line definition '-D" << G
              << "'\n";
       GlobalDefineError = true;
       continue;
     }
     if (EqIdx == 0) {
-      errs() << "Missing pattern variable name in command-line definition '-D"
-             << G << "'\n";
+      errs() << "Missing variable name in command-line definition '-D" << G
+             << "'\n";
       GlobalDefineError = true;
       continue;
     }
     Req.GlobalDefines.push_back(G);
   }
   if (GlobalDefineError)
     return 2;