FileCheck [4/12]: Introduce @LINE numeric expressions

[thopre]

Summary

This patch is part of a patch series to add support for FileCheck
numeric expressions. This specific patch introduces the @LINE numeric
expressions.

This commit introduces a new syntax to express a relation a numeric
value in the input text must have with the line number of a given CHECK
pattern: #<@LINE numeric expression>. Further commits build on that
to express relations between several numeric values in the input text.
To help with naming, regular variables are renamed into pattern
variables and old @LINE expression syntax is referred to as legacy
numeric expression.

Compared to existing @LINE expressions, this new syntax allow arbitrary
spacing between the component of the expression. It offers otherwise the
same functionality but the commit serves to introduce some of the data
structure needed to support more general numeric expressions.

Copyright:

• Linaro (changes up to diff 183612 of revision D55940)
• GraphCore (changes in later versions of revision D55940 and in new revision created off D55940)

[thopre]

Use camel case for new functions

[thopre]

Rebase

[thopre]

Make numeric value constructor explicit

[arsenm]

llvm/include/llvm/Support/FileCheck.h

78–80

shared_ptr is almost always overkill

114–116

It seems silly to me to use Optional when you can use an empty string, and empty string isn't a valid name

[thopre]

• Stop using shared_ptr
• Make getUndefVarName return a StringRef rather than an optional one using an empty one if no variable is undefined
• Add unit tests

[thopre]

Rebase on top of latest changes

[thopre]

Rebase on latest changes

[thopre]

Rebase on top of latest master

[jhenderson]

Not had time to go over the unit tests yet, but I've made lots of other comments.

llvm/docs/CommandGuide/FileCheck.rst

573

[[#@LINE]], [[#@LINE+<offset>]], and [[#@LINE-<offset>]]

574

"with an arbitrary number of spaces between each element of the expression"

575

a number -> the number

592

... without any space where -> ..., without any spaces, where

I think you can just delete the word "immediate" from the end of this sentence.

llvm/include/llvm/Support/FileCheck.h

44

I don't think this is a strict requirement, but I think it would be worth putting everything in a namespace, to allow these classes to all be called NumericExpression, PatternContext etc without any abbreviations (or with fewer). That would make this code a little more descriptive and less repetitive everywhere.

If you did that, you should probably do it in a different change.

46

Nit: too many full stops.

62

Subst -> Substitution.

64

I'd delete the phrase "among other thing" (aside: it should be among other things)

76

Maybe worth calling this SubstitutionStr or TargetStr or similar. "Substr" isn't necessarily an obvious abbreviation.

80

= nullptr;

83

size_t would be more appropriate than unsigned (also in the constructors).

102

Same comments as above re. abbreviation

111

Maybe call this function getResult to avoid ambiguity?

113–114

... if any ... -> ..., if any, ...

172–173

table, back-references -> table. Back-references

176

numeric expressions parsed -> parsed numeric expressions

181–183

Spurious double space between "command" and "line". Also add a comma after "line".

193

This should probably include "for destruction" somewhere in its function name, as the name does not imply this at all.

213

Substs -> Substitutions.

256

printSubstitutions

llvm/lib/Support/FileCheck.cpp

97

I'm not sure this function gives us anything? Just do it directly in the code. Also, inline here is unnecessary.

If you're bothered by the repeated " \t", then pull that out into a string literal.

253–255

You're mixing your grammar options here! Either "come in two forms. The first is [[foo:.*]]..." or later "variable 'foo', and [[foo]], which is..."

257–259

I'd restructure this whole comment slightly from <pattern variable forms><pattern variable names><numeric expression forms><numeric variable names> to <pattern variable forms><numberic expression forms><variable names (for both kinds>.

272

Use StringRef/Twine here instead of std::string.

277

It's not really clear to me why the numbers in this expression have been picked. Assuming they represent string lengths, use something like sizeof("string") for the first, and use a ternary for the second (i.e. + IsNumExpr ? sizeof("#") : 0).

300

size_t here.

337

As earlier: Subst -> Substitution

425–426

Not something you've written, but this should be a size_t too.

491

Delete "what".

502

print undefined -> print the undefined.

llvm/test/FileCheck/line-count.txt

1

Nit: double space.

12

Missed this previously. This should be BAD11 and ERR11, right?

[probinson]

First pass looking at docs and commentary.

llvm/docs/CommandGuide/FileCheck.rst

574

with an arbitrary number of spaces

575

expand to the number of the line where the pattern

592

with no spaces inside the brackets and where

llvm/include/llvm/Support/FileCheck.h

46

Extra trailing period.

llvm/lib/Support/FileCheck.cpp

253

Hm. The *variable* does not come in two forms; perhaps we should call these "pattern expressions"? Which come in two forms, one that defines a pattern variable and one that uses it.

259

I thought numeric variables didn't exist until a later patch?

[thopre]

Address all outstanding review comments except for the namespace one

llvm/include/llvm/Support/FileCheck.h

44

You mean put all FileCheck classes in a FileCheck namespace?

llvm/lib/Support/FileCheck.cpp

259

Regular numeric variables yes but this patch rebrand @LINE as being a pseudo numeric variable and expressions being based on it as being a numeric expression (if of the form #<something>) or legacy numeric expression.

llvm/test/FileCheck/line-count.txt

12

Oops good catch. Had to fix the test as well so I've put it as a separate patch

[thopre]

Rename registerNumExprForDestruction into makeNumExpr

[thopre]

Fix codestyle

[jhenderson]

llvm/include/llvm/Support/FileCheck.h

44

Yes, that was what I was referring to (or similar to that anyway). Quite possibly this was discussed before.

llvm/lib/Support/FileCheck.cpp

258

help -> helps

llvm/unittests/Support/FileCheckTest.cpp

149 ↗

(On Diff #197485)

Substitute -> Substitution

[thopre]

• help -> helps
• Substitute -> Substitution

[thopre]

Pattern variables and numeric expressions -> Pattern and numeric expressions

[jhenderson]

I'm happy with the detail, but Paul may have other comments, especially higher level ones (he has a better eye for them than I do).

llvm/lib/Support/FileCheck.cpp

252–259

expressions -> expression. You don't need to pluralise both that and matches.

[thopre]

• without no space -> with no space
• pattern variables and numeric variables -> pattern and numeric variables

[thopre]

expressions matches -> expression matches

[probinson]

Another round of commentary nits, plus a couple more substantive remarks. If you accept them all, LGTM.

llvm/docs/CommandGuide/FileCheck.rst

529–530

supports pattern expressions that allow

529–530

allow

566

which -> that

574

each element

592

"without any spaces" or "with no spaces"

llvm/include/llvm/Support/FileCheck.h

44

+1 for namespace, eventually, although most namespaces are lowercase so I'd prefer 'filecheck'.

108

or None if substitution failed.

llvm/lib/Support/FileCheck.cpp

259

Right, however the comment is describing the naming rule, and right now the naming rule for numeric variables is "@LINE".
I recognize that when we're done, the comment will be right, but for this patch it is not, and the commentary should describe the code as-it-is and not as-we-wish-it-to-be-later.

[thopre]

Address Paul's review comments

[probinson]

LGTM

llvm/docs/CommandGuide/FileCheck.rst

.. option:: --enable-var-scope
 
   Variables with names that start with ``$`` are considered global and
   remain set throughout the file.
 
   All other variables get undefined after each encountered ``CHECK-LABEL``.
 
 .. option:: -D<VAR=VALUE>
 
-  Sets a filecheck variable ``VAR`` with value ``VALUE`` that can be used in
-  ``CHECK:`` lines.
+  Sets a filecheck pattern variable ``VAR`` with value ``VALUE`` that can be
+  used in ``CHECK:`` lines.
 
 .. option:: -version
 
  Show the version number of this program.
 
 .. option:: -v
 
   Print good directive pattern matches.  However, if ``-input-dump=fail`` or

 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 Variables
-~~~~~~~~~~~~~~~~~~~
+FileCheck Pattern Variables
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 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` allows named variables to be defined and substituted into
-patterns.  Here is a simple example:
+:program:`FileCheck` allows pattern 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

 
 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 Expressions
-~~~~~~~~~~~~~~~~~~~~~
+FileCheck Numeric Expressions
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Sometimes there's a need to verify output which refers line numbers of the
+Sometimes there's a need to verify output which 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 allows using ``[[@LINE]]``,
-``[[@LINE+<offset>]]``, ``[[@LINE-<offset>]]`` expressions in patterns. These
-expressions expand to a number of the line where a pattern is located (with an
-optional integer offset).
+To support this case, FileCheck allows using ``[[#@LINE]]``,
+``[[#@LINE+<offset>]]``, ``[[#@LINE-<offset>]]`` numeric expressions in
+patterns, with arbitrary number of space between each elements of the
+expression. These expressions expand to a number of the line where a pattern
+is located (with an optional integer offset).
 
 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: 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
+``[[@LINE-<offset>]]`` without any space where ``offset`` is an integer
+immediate.
+
 Matching Newline Characters
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 To match newline characters in regular expressions the character class
 ``[[:space:]]`` can be used. For example, the following pattern:
 
 .. code-block:: c++
 

llvm/include/llvm/Support/FileCheck.h

struct FileCheckRequest {
   bool AllowEmptyInput = false;
   bool MatchFullLines = false;
   bool EnableVarScope = false;
   bool AllowDeprecatedDagOverlap = false;
   bool Verbose = false;
   bool VerboseVerbose = false;
 };
 
+//===----------------------------------------------------------------------===//
+// Numeric expression handling code.
+//===----------------------------------------------------------------------===//
+
+/// Class representing a numeric expression.
+class FileCheckNumExpr {
+private:
+  /// Value of the numeric expression..
+  uint64_t Value;
+
+public:
+  /// Constructor for a numeric expression with a known value at parse time,
+  /// e.g. the implicit numeric expression defining the @LINE numeric pseudo
+  /// variable.
+  explicit FileCheckNumExpr(uint64_t Value) : Value(Value) {}
+
+  /// Return the value being matched against.
+  uint64_t getValue() const { return Value; }
+};
+
+class FileCheckPatternContext;
+
+/// Class representing a substitution to perform in the string to match.
+class FileCheckPatternSubst {
+private:
+  /// Pointer to a class instance holding among other thing 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).
+  FileCheckPatternContext *Context;
+
+  /// Whether this represents a numeric expression substitution.
+  bool IsNumExpr;
+
+  /// The string that needs to be substituted for something else. For a
+  /// pattern variable this is its name, otherwise this is the whole numeric
+  /// expression.
+  StringRef SubstStr;
+
+  /// If this is a numeric expression substitution, this is the pointer to the
+  /// class representing that numeric expression.
+  std::shared_ptr<FileCheckNumExpr> NumExpr;
+
+  // Index in RegExStr of where to do the substitution.
+  unsigned InsertIdx;
+
+public:
+  /// Constructor for a pattern variable substitution.
+  FileCheckPatternSubst(FileCheckPatternContext *Context, StringRef VarName,
+                        unsigned InsertIdx)
+      : Context(Context), IsNumExpr(false), SubstStr(VarName),
+        InsertIdx(InsertIdx) {}
+
+  /// Constructor for a numeric expression substitution.
+  FileCheckPatternSubst(FileCheckPatternContext *Context, StringRef Expr,
+                        std::shared_ptr<FileCheckNumExpr> NumExpr,
+                        unsigned InsertIdx)
+      : Context(Context), IsNumExpr(true), SubstStr(Expr), NumExpr(NumExpr),
+        InsertIdx(InsertIdx) {}
+
+  /// Return whether this is a numeric expression substitution.
+  bool isNumExpr() const { return IsNumExpr; }
+
+  /// Return the string to be substituted.
+  StringRef getSubstString() const { return SubstStr; }
+
+  /// Return the index where the substitution is to be performed.
+  unsigned getIndex() const { return InsertIdx; }
+
+  /// Return the result of the substitution represented by this class instance
+  /// or nothing if substitution failed. For a numeric expression we substitute
+  /// it by its value. For a pattern variable we simply replace it by the text
+  /// its definition matched.
+  llvm::Optional<std::string> getSubstitute() const;
+
+  /// Return the name of the undefined variable used in this substitution if
+  /// any.
+  llvm::Optional<StringRef> getUndefVarName() const;
+};
 
 //===----------------------------------------------------------------------===//
-// Pattern Handling Code.
+// Pattern handling code.
 //===----------------------------------------------------------------------===//
 
 namespace Check {
 
 enum FileCheckKind {
   CheckNone = 0,
   CheckPlain,
   CheckNext,

 /// 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
-  /// 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.
+  /// pattern 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;
 
 public:
-  /// Return the value of variable \p VarName or nothing if no such variable has
-  /// been defined.
+  /// Return the value of pattern variable \p VarName or nothing if no such
+  /// variable has been defined.
   llvm::Optional<StringRef> getPatternVarValue(StringRef VarName);
 
   /// Define pattern and numeric variables from definitions given on the
   /// command line passed as a vector of VAR=VAL strings in \p CmdlineDefines.
   /// Report any error to \p SM and return whether an error occured.
   bool defineCmdlineVariables(std::vector<std::string> &CmdlineDefines,
                               SourceMgr &SM);
 
   /// Undefine local variables (variables whose name does not start with a '$'
   /// sign), ie remove them from GlobalVariableTable.
   void clearLocalVars(void);
 };
 
 struct FileCheckDiag;
 
 class FileCheckPattern {
   SMLoc PatternLoc;
 
   /// 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 map to uses of a variable in the pattern, e.g.
-  /// "foo[[bar]]baz".  In this case, the RegExStr will contain "foobaz" and
-  /// we'll get an entry in this vector that tells us to insert the value of
-  /// bar at offset 3.
-  std::vector<std::pair<StringRef, unsigned>> VariableUses;
+  /// 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[[#@LINE+1]]". In this case,
+  /// the 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 "@LINE+1" at offset 6. Uses
+  /// are represented by a FileCheckPatternSubst class to abstract whether it
+  /// is a pattern variable or a numeric expression.
+  std::vector<FileCheckPatternSubst> Substs;
 
-  /// Maps definitions of variables to their parenthesized capture numbers.
+  /// Maps names of pattern 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".
   ///
-  /// E.g. for the pattern "foo[[bar:.*]]baz", VariableDefs will map "bar" to
-  /// 1.
+  /// 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 a table with the values of live
   /// variables at the start of any given CHECK line.
   FileCheckPatternContext *Context;
 
   Check::FileCheckType CheckTy;
 
   /// Contains the number of line this pattern is in.
   unsigned LineNumber;
 
 public:
   explicit FileCheckPattern(Check::FileCheckType Ty,
                             FileCheckPatternContext *Context)
       : Context(Context), CheckTy(Ty) {}
 
   /// Returns the location in source code.
   SMLoc getLoc() const { return PatternLoc; }
 
   /// Returns the pointer to the global state for all patterns in this
   /// FileCheck instance.
   FileCheckPatternContext *getContext() const { return Context; }
 
   static bool parseVariable(StringRef Str, bool &IsPseudo, unsigned &TrailIdx);
-  bool parseExpression(StringRef Name, StringRef Trailer,
+  std::shared_ptr<FileCheckNumExpr>
+  parseNumericExpression(StringRef Name, StringRef Trailer,
                          const SourceMgr &SM) const;
   bool ParsePattern(StringRef PatternStr, StringRef Prefix, SourceMgr &SM,
                     unsigned LineNumber, const FileCheckRequest &Req);
   size_t match(StringRef Buffer, size_t &MatchLen) const;
-  void printVariableUses(const SourceMgr &SM, StringRef Buffer,
-                         SMRange MatchRange = None) const;
+  void printSubsts(const SourceMgr &SM, StringRef Buffer,
   void printFuzzyMatch(const SourceMgr &SM, StringRef Buffer,
                        std::vector<FileCheckDiag> *Diags) const;
 
-  bool hasVariable() const {
-    return !(VariableUses.empty() && VariableDefs.empty());
-  }
+  bool hasVariable() const { return !(Substs.empty() && VariableDefs.empty()); }
 
   Check::FileCheckType getCheckTy() const { return CheckTy; }
 
   int getCount() const { return CheckTy.getCount(); }
 
 private:
   bool AddRegExToRegEx(StringRef RS, unsigned &CurParen, SourceMgr &SM);
   void AddBackrefToRegEx(unsigned BackrefNum);
   unsigned computeMatchDistance(StringRef Buffer) const;
-  void evaluateExpression(StringRef Expr, std::string &Value) const;
   size_t FindRegexVarEnd(StringRef Str, SourceMgr &SM);
 };
 
 //===----------------------------------------------------------------------===//
 /// Summary of a FileCheck diagnostic.
 //===----------------------------------------------------------------------===//
 
 struct FileCheckDiag {

llvm/lib/Support/FileCheck.cpp

 #include <cstdint>
 #include <list>
 #include <map>
 #include <tuple>
 #include <utility>
 
 using namespace llvm;
 
+/// Return the result of the substitution represented by this class instance or
+/// nothing if substitution failed. For a numeric variable we substitute it by
+/// its value. For a pattern variable we simply replace it by the text its
+/// definition matched.
+llvm::Optional<std::string> FileCheckPatternSubst::getSubstitute() const {
+  if (IsNumExpr) {
+    return utostr(NumExpr->getValue());
+  } else {
+    // Look up the value and escape it so that we can put it into the
+    // regex.
+    llvm::Optional<StringRef> OptVarVal;
+    OptVarVal = Context->getPatternVarValue(SubstStr);
+    if (!OptVarVal.hasValue())
+      return llvm::None;
+    return Regex::escape(OptVarVal.getValue());
+  }
+}
+
+/// Return the name of the undefined variable used in this substitution if any.
+llvm::Optional<StringRef> FileCheckPatternSubst::getUndefVarName() const {
+  // Parsing guarantees only @LINE is ever referenced and it is not undefined
+  // by ClearLocalVars.
+  if (IsNumExpr)
+    return llvm::None;
+
+  if (!Context->getPatternVarValue(SubstStr).hasValue())
+    return SubstStr;
+
+  return llvm::None;
+}
+
 // Verify that the string in \p Str or at the start of \p Str (if \p
 // AllowTrailer is true) is a well formed variable name. Also set IsPseudo to
 // true if it is a pseudo variable.
 bool FileCheckPattern::parseVariable(StringRef Str, bool &IsPseudo,
                                      unsigned &TrailIdx) {
   bool ParsedOneChar = false;
   unsigned i = 0;
   IsPseudo = false;
bool FileCheckPattern::parseVariable(StringRef Str, bool &IsPseudo,
 
   // Name can't start with a digit.
   if (isdigit(static_cast<unsigned char>(Name[0])))
     return true;
 
   return false;
 }
 
+/// Parsing helper function that strips all leading whitespace from \p s.
+static inline void SkipWhitespace(StringRef &s) { s = s.ltrim(" \t"); }
+
 /// Parsing helper function that strips the first character in \p s and returns
 /// it.
 static char next(StringRef &s) {
   char c = s.front();
   s = s.drop_front();
   return c;
 }
 
 /// Parse a numeric expression involving pseudo variable \p Name with the
 /// string corresponding to the operation being performed in \p Trailer.
-/// Return whether parsing failed in which case errors are reported on \p SM.
-bool FileCheckPattern::parseExpression(StringRef Name, StringRef Trailer,
+/// Return the class representing the numeric expression or nullptr if
+/// parsing fails in which case errors are reported on \p SM.
+std::shared_ptr<FileCheckNumExpr>
+FileCheckPattern::parseNumericExpression(StringRef Name, StringRef Trailer,
                                          const SourceMgr &SM) const {
   if (!Name.equals("@LINE")) {
     SM.PrintMessage(SMLoc::getFromPointer(Name.data()), SourceMgr::DK_Error,
-                    "Invalid pseudo variable '" + Name + "'");
-    return true;
+                    "Invalid pseudo numeric variable '" + Name + "'");
+    return nullptr;
   }
 
   // Check if this is a supported operation and select function to perform it.
+  SkipWhitespace(Trailer);
   if (Trailer.empty())
-    return false;
+    return std::make_shared<FileCheckNumExpr>(LineNumber);
   SMLoc oploc = SMLoc::getFromPointer(Trailer.data());
   char Operator = next(Trailer);
-  switch (Operator) {
-  case '+':
-  case '-':
-    break;
-  default:
-    SM.PrintMessage(oploc, SourceMgr::DK_Error,
-                    std::string("Unsupported numeric operation '") + Operator +
-                        "'");
-    return true;
-  }
 
   // Parse right operand.
+  SkipWhitespace(Trailer);
   if (Trailer.empty()) {
     SM.PrintMessage(SMLoc::getFromPointer(Trailer.data()), SourceMgr::DK_Error,
                     "Missing operand in numeric expression '" + Trailer + "'");
-    return true;
+    return nullptr;
   }
   uint64_t Offset;
   if (Trailer.consumeInteger(10, Offset)) {
     SM.PrintMessage(SMLoc::getFromPointer(Trailer.data()), SourceMgr::DK_Error,
                     "Invalid offset in numeric expression '" + Trailer + "'");
-    return true;
+    return nullptr;
   }
+  SkipWhitespace(Trailer);
   if (!Trailer.empty()) {
     SM.PrintMessage(SMLoc::getFromPointer(Trailer.data()), SourceMgr::DK_Error,
                     "Unexpected characters at end of numeric expression '" +
                         Trailer + "'");
-    return true;
+    return nullptr;
   }
-  return false;
+
+  uint64_t Value;
+  switch (Operator) {
+  case '+':
+    Value = LineNumber + Offset;
+    break;
+  case '-':
+    Value = LineNumber - Offset;
+    break;
+  default:
+    SM.PrintMessage(oploc, SourceMgr::DK_Error,
+                    std::string("Unsupported numeric operation '") + Operator +
+                        "'");
+    return nullptr;
+  }
+  return std::make_shared<FileCheckNumExpr>(Value);
 }
 
 /// Parses the given string into the Pattern.
 ///
 /// \p Prefix provides which prefix is being matched, \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.
if (PatternStr.startswith("{{")) {
       if (AddRegExToRegEx(PatternStr.substr(2, End - 2), CurParen, SM))
         return true;
       RegExStr += ')';
 
       PatternStr = PatternStr.substr(End + 2);
       continue;
     }
 
-    // Named RegEx matches.  These are of two forms: [[foo:.*]] which matches .*
-    // (or some other regex) and assigns it to the FileCheck variable 'foo'. The
-    // second form is [[foo]] which is a reference to foo.  The variable name
-    // itself must be of the form "[a-zA-Z_][0-9a-zA-Z_]*", otherwise we reject
-    // it.  This is to catch some common errors.
+    // Pattern variable and numeric expressions matches. Pattern variables
+    // come in two forms: [[foo:.*]] which matches .* (or some other regex) and
+    // assigns it to the FileCheck variable 'foo'. The second form is [[foo]]
+    // which is a substitution of foo's value. Variable names themselves must
+    // be of the form "[a-zA-Z_][0-9a-zA-Z_]*", otherwise we reject it. This is
+    // to catch some common errors. Numeric expressions only have the
+    // substitution mode. Numeric variable names have the same restriction as
+    // their pattern variable counterpart.
     if (PatternStr.startswith("[[")) {
       StringRef MatchStr = PatternStr.substr(2);
+      bool IsNumExpr = MatchStr.consume_front("#");
+      const char *RefTypeStr =
+          IsNumExpr ? "numeric expression" : "pattern variable";
       // 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(MatchStr, SM);
 
       if (End == StringRef::npos) {
-        SM.PrintMessage(SMLoc::getFromPointer(PatternStr.data()),
-                        SourceMgr::DK_Error,
-                        "invalid named regex reference, no ]] found");
+        SM.PrintMessage(
+            SMLoc::getFromPointer(PatternStr.data()), SourceMgr::DK_Error,
+            std::string("Invalid ") + RefTypeStr + " reference, no ]] found");
         return true;
       }
 
       MatchStr = MatchStr.substr(0, End);
-      PatternStr = PatternStr.substr(End + 4);
+      PatternStr = PatternStr.substr(End + 4 + (int)IsNumExpr);
 
       size_t DefSepIdx = MatchStr.find(":");
+      if (IsNumExpr)
+        SkipWhitespace(MatchStr);
+      else {
         size_t SpacePos = MatchStr.substr(0, DefSepIdx).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.
       bool IsPseudo;
       unsigned TrailIdx;
       if (parseVariable(MatchStr, IsPseudo, TrailIdx)) {
         SM.PrintMessage(SMLoc::getFromPointer(MatchStr.data()),
-                        SourceMgr::DK_Error, "Invalid name in named regex");
+                        SourceMgr::DK_Error, "Invalid variable name");
         return true;
       }
 
+      unsigned SubstInsertIdx = RegExStr.size();
+      std::shared_ptr<FileCheckNumExpr> NumExpr;
+
       StringRef Name = MatchStr.substr(0, TrailIdx);
       StringRef Trailer = MatchStr.substr(TrailIdx);
       bool IsVarDef = (DefSepIdx != StringRef::npos);
 
       if (IsVarDef && (IsPseudo || !Trailer.consume_front(":"))) {
         SM.PrintMessage(SMLoc::getFromPointer(MatchStr.data()),
                         SourceMgr::DK_Error,
-                        "Invalid name in named regex definition");
+                        "Invalid name in pattern variable definition");
         return true;
       }
 
       if (!IsVarDef && IsPseudo) {
-        if (parseExpression(Name, Trailer, SM))
+        NumExpr = parseNumericExpression(Name, Trailer, SM);
+        if (NumExpr == nullptr)
           return true;
       }
 
       // Handle [[foo]].
       if (!IsVarDef) {
-        // Handle variables that were defined earlier on the same line by
-        // emitting a backreference.
-        if (VariableDefs.find(Name) != VariableDefs.end()) {
-          unsigned VarParenNum = VariableDefs[Name];
-          if (VarParenNum < 1 || VarParenNum > 9) {
+        // Handle use of pattern variables that were defined earlier on the
+        // same line by emitting a backreference.
+        if (NumExpr == nullptr &&
+            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(VarParenNum);
+          AddBackrefToRegEx(CaptureParen);
         } else {
-          VariableUses.push_back(std::make_pair(MatchStr, RegExStr.size()));
+          // Handle use of pattern variables ([[<var>]]) defined in previous
+          // CHECK pattern or use of a numeric expression.
+          FileCheckPatternSubst Subst =
+              NumExpr != nullptr
+                  ? FileCheckPatternSubst(Context, MatchStr, NumExpr,
+                                          SubstInsertIdx)
+                  : FileCheckPatternSubst(Context, MatchStr, SubstInsertIdx);
+          Substs.push_back(Subst);
         }
         continue;
       }
 
       // Handle [[foo:.*]].
       VariableDefs[Name] = CurParen;
       RegExStr += '(';
       ++CurParen;

 }
 
 void FileCheckPattern::AddBackrefToRegEx(unsigned BackrefNum) {
   assert(BackrefNum >= 1 && BackrefNum <= 9 && "Invalid backref number");
   std::string Backref = std::string("\\") + std::string(1, '0' + BackrefNum);
   RegExStr += Backref;
 }
 
-/// Evaluates expression and stores the result to \p Value.
-void FileCheckPattern::evaluateExpression(StringRef Expr, std::string &Value) const {
-  Expr = Expr.substr(StringRef("@LINE").size());
-  int Offset = 0;
-  if (!Expr.empty()) {
-    if (Expr[0] == '+')
-      Expr = Expr.substr(1);
-    Expr.getAsInteger(10, Offset);
-  }
-  Value = llvm::itostr(LineNumber + Offset);
-}
-
 /// Matches the pattern string against the input buffer \p Buffer
 ///
 /// This returns the position that is matched or npos if there is no match. If
 /// there is a match, the size of the matched string is returned in \p
 /// MatchLen.
 ///
 /// The GlobalVariableTable StringMap provides the current values of FileCheck
-/// variables and is updated if this match defines new values.
+/// pattern variables and is updated if this match defines new values.
 size_t FileCheckPattern::match(StringRef Buffer, size_t &MatchLen) const {
   // If this is the EOF pattern, match it immediately.
   if (CheckTy == Check::CheckEOF) {
     MatchLen = 0;
     return Buffer.size();
   }
 
   // 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
   // actual value.
   StringRef RegExToMatch = RegExStr;
   std::string TmpStr;
-  if (!VariableUses.empty()) {
+  if (!Substs.empty()) {
     TmpStr = RegExStr;
 
     unsigned InsertOffset = 0;
-    for (const auto &VariableUse : VariableUses) {
-      std::string Value;
-
-      if (VariableUse.first[0] == '@') {
-        evaluateExpression(VariableUse.first, Value);
-      } else {
-        llvm::Optional<StringRef> OptValue =
-            Context->getPatternVarValue(VariableUse.first);
-        // If the variable is undefined, return an error.
-        if (!OptValue.hasValue())
-          return StringRef::npos;
-
-        // Look up the value and escape it so that we can put it into the regex.
-        Value += Regex::escape(OptValue.getValue());
-      }
+    // Substitute all pattern variables and numeric expressions whose value is
+    // known just now. Use of pattern variables defined on the same line are
+    // handled by back-references.
+    for (const auto &Subst : Substs) {
+      // Substitute and check for failure (e.g. use of undefined variable).
+      llvm::Optional<std::string> OptValue = Subst.getSubstitute();
+      std::string Value = OptValue.getValue();
 
       // Plop it into the regex at the adjusted offset.
-      TmpStr.insert(TmpStr.begin() + VariableUse.second + InsertOffset,
+      TmpStr.insert(TmpStr.begin() + Subst.getIndex() + InsertOffset,
                     Value.begin(), Value.end());
       InsertOffset += Value.size();
     }
 
     // Match the newly constructed regex.
     RegExToMatch = TmpStr;
   }
 
   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 variables, remember their values.
+  // If this defines any pattern 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
if (ExampleString.empty())
     ExampleString = RegExStr;
 
   // 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);
 }
 
-/// Print value of successful substitutions or name of undefined pattern
-/// variables preventing such a successful substitution.
-void FileCheckPattern::printVariableUses(const SourceMgr &SM, StringRef Buffer,
-                                         SMRange MatchRange) const {
-  // If this was a regular expression using variables, print the current
-  // variable values.
-  if (!VariableUses.empty()) {
-    for (const auto &VariableUse : VariableUses) {
+/// Print value of successful substitutions or name of undefined pattern or
+/// numeric variables preventing such a successful substitution.
+void FileCheckPattern::printSubsts(const SourceMgr &SM, StringRef Buffer,
+  // Print info what we know about substitutions. This covers both uses of
+  // pattern variables and numeric subsitutions.
+  if (!Substs.empty()) {
+    for (const auto &Subst : Substs) {
       SmallString<256> Msg;
       raw_svector_ostream OS(Msg);
-      StringRef Var = VariableUse.first;
-      if (Var[0] == '@') {
-        std::string Value;
-        evaluateExpression(Var, Value);
-        OS << "with expression \"";
-        OS.write_escaped(Var) << "\" equal to \"";
-        OS.write_escaped(Value) << "\"";
-      } else {
-        llvm::Optional<StringRef> OptValue = Context->getPatternVarValue(Var);
+      bool IsNumExpr = Subst.isNumExpr();
+      llvm::Optional<std::string> OptMatchedValue = Subst.getSubstitute();
 
-        // Check for undefined variable references.
-        if (!OptValue.hasValue()) {
-          OS << "uses undefined variable \"";
-          OS.write_escaped(Var) << "\"";
-        } else {
+      // Substitution failed or is not known at match time, print undefined
+      // variable it uses.
+      if (!OptMatchedValue.hasValue()) {
+        llvm::Optional<StringRef> OptUndefVarName = Subst.getUndefVarName();
+        if (!OptUndefVarName.hasValue())
+          continue;
+        StringRef UndefVarName = OptUndefVarName.getValue();
+        OS.write_escaped(UndefVarName) << "\"";
+        // Substitution succeeded. Print substituted value.
+        std::string MatchedValue = OptMatchedValue.getValue();
+        if (IsNumExpr)
+          OS << "with numeric expression \"";
+        else
           OS << "with variable \"";
-          OS.write_escaped(Var) << "\" equal to \"";
-          OS.write_escaped(OptValue.getValue()) << "\"";
-        }
+        OS.write_escaped(Subst.getSubstString()) << "\" equal to \"";
+        OS.write_escaped(MatchedValue) << "\"";
       }
 
       if (MatchRange.isValid())
         SM.PrintMessage(MatchRange.Start, SourceMgr::DK_Note, OS.str(),
                         {MatchRange});
       else
         SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()),
                         SourceMgr::DK_Note, OS.str());
if (Best && Best != StringRef::npos && BestQuality < 50) {
     SM.PrintMessage(MatchRange.Start, SourceMgr::DK_Note,
                     "possible intended match here");
 
     // FIXME: If we wanted to be really friendly we would show why the match
     // failed, as it can be hard to spot simple one character differences.
   }
 }
 
-/// Return the value of variable \p VarName or nothing if no such variable
-/// has been defined.
+/// Return the value of pattern variable \p VarName or nothing if no such
+/// variable has been defined.
 llvm::Optional<StringRef>
 FileCheckPatternContext::getPatternVarValue(StringRef VarName) {
   auto git = GlobalVariableTable.find(VarName);
   if (git == GlobalVariableTable.end())
     return llvm::None;
 
   return git->second;
 }
std::string Message = formatv("{0}: {1} string found in input",
                             .str();
   if (Pat.getCount() > 1)
     Message += formatv(" ({0} out of {1})", MatchedCount, Pat.getCount()).str();
 
   SM.PrintMessage(
       Loc, ExpectedMatch ? SourceMgr::DK_Remark : SourceMgr::DK_Error, Message);
   SM.PrintMessage(MatchRange.Start, SourceMgr::DK_Note, "found here",
                   {MatchRange});
-  Pat.printVariableUses(SM, Buffer, MatchRange);
+  Pat.printSubsts(SM, Buffer, MatchRange);
 }
 
 static void PrintMatch(bool ExpectedMatch, const SourceMgr &SM,
                        const FileCheckString &CheckStr, int MatchedCount,
                        StringRef Buffer, size_t MatchPos, size_t MatchLen,
                        FileCheckRequest &Req,
                        std::vector<FileCheckDiag> *Diags) {
   PrintMatch(ExpectedMatch, SM, CheckStr.Prefix, CheckStr.Loc, CheckStr.Pat,
if (Pat.getCount() > 1)
     Message += formatv(" ({0} out of {1})", MatchedCount, Pat.getCount()).str();
   SM.PrintMessage(
       Loc, ExpectedMatch ? SourceMgr::DK_Error : SourceMgr::DK_Remark, Message);
 
   // Print the "scanning from here" line.
   SM.PrintMessage(SearchRange.Start, SourceMgr::DK_Note, "scanning from here");
 
   // Allow the pattern to print additional information if desired.
-  Pat.printVariableUses(SM, Buffer);
+  Pat.printSubsts(SM, Buffer);
 
   if (ExpectedMatch)
     Pat.printFuzzyMatch(SM, Buffer, Diags);
 }
 
 static void PrintNoMatch(bool ExpectedMatch, const SourceMgr &SM,
                          const FileCheckString &CheckStr, int MatchedCount,
                          StringRef Buffer, bool VerboseVerbose,

llvm/test/FileCheck/line-count.txt

 ; RUN: FileCheck  -input-file %s %s
 ; RUN: not FileCheck -check-prefix BAD1 -input-file %s %s 2>&1 | FileCheck -check-prefix ERR1 %s
 ; RUN: not FileCheck -check-prefix BAD2 -input-file %s %s 2>&1 | FileCheck -check-prefix ERR2 %s
 ; RUN: not FileCheck -check-prefix BAD3 -input-file %s %s 2>&1 | FileCheck -check-prefix ERR3 %s
 ; RUN: not FileCheck -check-prefix BAD4 -input-file %s %s 2>&1 | FileCheck -check-prefix ERR4 %s
 ; RUN: not FileCheck -check-prefix BAD5 -input-file %s %s 2>&1 | FileCheck -check-prefix ERR5 %s
 ; RUN: not FileCheck -check-prefix BAD6 -input-file %s %s 2>&1 | FileCheck -check-prefix ERR6 %s
 ; RUN: not FileCheck -check-prefix BAD7 -input-file %s %s 2>&1 | FileCheck -check-prefix ERR7 %s
 ; RUN: not FileCheck -check-prefix BAD8 -input-file %s %s 2>&1 | FileCheck -check-prefix ERR8 %s
 ; RUN: not FileCheck -check-prefix BAD9 -input-file %s %s 2>&1 | FileCheck -check-prefix ERR9 %s
 ; RUN: not FileCheck -check-prefix BAD10 -input-file %s %s 2>&1 | FileCheck -check-prefix ERR10 %s
 ; RUN: not FileCheck -check-prefix BAD10 -input-file %s %s 2>&1 | FileCheck -check-prefix ERR10 %s
 13
 14 aaa
 15 bbb
 16 ccc
 17 CHECK: [[@LINE-3]] {{a}}aa
 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 named regex definition
+26 ERR1: line-count.txt:[[#@LINE-1]]:12: error: Invalid name in pattern variable definition
 27
 28 BAD2: [[ @LINE]]
-29 ERR2: line-count.txt:[[@LINE-1]]:12: error: Unexpected whitespace
+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
+32 ERR3: line-count.txt:[[#@LINE-1]]:17: error: Unexpected whitespace
 33
 34 BAD4: [[ @LINE-1]]
-35 ERR4: line-count.txt:[[@LINE-1]]:12: error: Unexpected whitespace
+35 ERR4: line-count.txt:[[#@LINE-1]]:12: error: Unexpected whitespace
 36
 37 BAD5: [[@LINE -1]]
-38 ERR5: line-count.txt:[[@LINE-1]]:17: error: Unexpected whitespace
+38 ERR5: line-count.txt:[[#@LINE-1]]:17: error: Unexpected whitespace
 39
 40 BAD6: [[@LINE- 1]]
-41 ERR6: line-count.txt:[[@LINE-1]]:18: error: Unexpected whitespace
+41 ERR6: line-count.txt:[[#@LINE-1]]:18: error: Unexpected whitespace
 42
 43 BAD7: [[@LINE-1 ]]
-44 ERR7: line-count.txt:[[@LINE-1]]:19: error: Unexpected whitespace
+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 variable '@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 numeric 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 numeric expression 'x'
 54
 55 BAD11: [[@LINE-1x]]
-56 ERR11: line-count.txt:[[@LINE-1]]:19: error: Unexpected characters at end of numeric expression 'x'
+56 ERR11: line-count.txt:[[#@LINE-1]]:19: error: Unexpected characters at end of numeric 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