FileCheck [12/12]: Support use of var defined on same line

[thopre]

Summary

This patch is part of a patch series to add support for FileCheck
numeric expressions. This specific patch adds support for using a
numeric variable with empty numeric expression defined on the same line
either directly or indirectly.

The regex language used to represent a constraint corresponding to a
given CHECK directive does not allow to express a numeric relation. It
is therefore necessary to initially match any number in the appropriate
matching format and check the constraints are verified in a follow-up
step. Such a process must then be repeated as long as the constraints
fail because of cases with a check directive like #N: #N+1
where the input contains lines such as:
10 12
10 11

The first line would match the regex "[0-9]+ [0-9]+" generated for the
CHECK directive but the constraint would fail. The second line would
then need to be tried since it both matches successfully and verifies
the constraints of the CHECK directive. Note that this process would
still fail to match if the input was:
10 12 13
because the regex would match 10 and 12 which fail to verify the
constraints and the process would then skip to the next line since there
is no way to ask the regex engine if the line had other possible
matches. This caveat is documented.

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 casing for new functions

[thopre]

Rebase

[thopre]

Make numeric value constructor explicit

[thopre]

Rebase on latest changes

[thopre]

Rebase on latest changes

[thopre]

Rebase on latest unittest changes

[thopre]

Rebase on top of latest changes

[thopre]

Rebase on top of latest changes

[thopre]

Rebase on top of latest changes

[thopre]

Rebase on top of latest changes

[thopre]

Rebase on top of latest changes

[thopre]

Rebase on top of latest changes

[thopre]

Rebase on top of latest changes

[thopre]

rebase on top of latest changes

[thopre]

rebase on top of latest changes

[thopre]

Rebase on top of latest changes in patch series

[thopre]

Rebase on top of latest changes in the series

[thopre]

Rebase on top of latest changes in patch series

[thopre]

Codebase has changed considerably since last time this review was updated. Patch will need some reworking and before that I want to build consensus on whether the feature should be done given the caveats it has.

[jhenderson]

I don't have a clear solution to the problems you're describing, but I have already run into one or two places where I wanted the behaviour of being able to use a numeric variable on the same line it was defined. CHECK-SAME is a valid workaround, but has its own issues (for example, it doesn't inherently ensure the next match starts immediately after the previous one, and is just simply more verbose). My instinct is that the right approach is to ignore the constraint initially, match a number, and then verify that it is the right number, failing if not, without further search attempts. I think it's relatively easy to workaround that issue in most cases, with additional checks elsewhere, although I can't be positive that is the case.

[thopre]

In D60392#2033357, @jhenderson wrote:

I don't have a clear solution to the problems you're describing, but I have already run into one or two places where I wanted the behaviour of being able to use a numeric variable on the same line it was defined. CHECK-SAME is a valid workaround, but has its own issues (for example, it doesn't inherently ensure the next match starts immediately after the previous one, and is just simply more verbose). My instinct is that the right approach is to ignore the constraint initially, match a number, and then verify that it is the right number, failing if not, without further search attempts. I think it's relatively easy to workaround that issue in most cases, with additional checks elsewhere, although I can't be positive that is the case.

What worries me is the effect on a CHECK-NOT directive since it could lead to the directive being fulfilled in a case where the intent was to forbid it. Consider the following:

CHECK-NOT: [[#VAR:]] [[#VAR+1]]

Say the author of the test was looking a a bug where the output being checked was 10 11 14. The test would pass. Now if the bug wasn't fully fixed, perhaps this doesn't happen anymore but we can have cases like 10 13 14. The above directive will turn into ([[:digit:]]+) ([[:digit:]]+) which will match 10 and 13 and will then check if they are consecutive numbers. They are not and thus the CHECK-NOT is satisfied even though there was 13 14 later on the line. Of course here we could retry after the first number matched but that doesn't work in the general case where regex can appear anywhere (e.g. #VAR: {{.*}} #VAR+1 where the input is now 10 8 11).

Perhaps the solution is to forbid using a variable defined on the same line for a CHECK-NOT directive? In all other cases we'll get a false negative (directive not satisfied) instead of a false positive (directive satisfied).

[jhenderson]

In D60392#2033995, @thopre wrote:

Perhaps the solution is to forbid using a variable defined on the same line for a CHECK-NOT directive? In all other cases we'll get a false negative (directive not satisfied) instead of a false positive (directive satisfied).

Hmm, you make a fair argument, and I think this suggestion might work. I'll need to give it more thought though. Perhaps it needs a mailing list thread to get more eyes on this?

[thopre]

In D60392#2035853, @jhenderson wrote:

In D60392#2033995, @thopre wrote:

Perhaps the solution is to forbid using a variable defined on the same line for a CHECK-NOT directive? In all other cases we'll get a false negative (directive not satisfied) instead of a false positive (directive satisfied).

Hmm, you make a fair argument, and I think this suggestion might work. I'll need to give it more thought though. Perhaps it needs a mailing list thread to get more eyes on this?

That was my intention. I'm focusing on D60390 for now, then I'll start a thread.

[thopre]

Status update: I've started manually rebasing this patch on top of latest FileCheck. Hopefully I'll update this diff in about 2 weeks. Sorry for the delay.

[thopre]

In D60392#2682536, @thopre wrote:

Status update: I've started manually rebasing this patch on top of latest FileCheck. Hopefully I'll update this diff in about 2 weeks. Sorry for the delay.

Sorry, I dropped the ball on that one but recently picked it up again and have a patch ready. It needs clean up but it's feature complete and all tests are already written. Please hang in there.

[thopre]

Rebase and fix issues with variables defined from an expression and with
verification failure failing to restore initial values of variables.

[jhenderson]

Sorry for ignoring this for a couple of weeks - it fell off my radar a bit, when I was swamped with deadline-realted tasks.

I recommend doing the llvm/test/FileCheck/numeric-expressions/numeric-expressions.txt renaming in a separate patch, as it's not really related to this patch.

I've not looked at the testing in depth yet, and I'm a little concerned that I'm very cold on the surrounding code. I think it would be useful if someone else could take a look too (@jdenny maybe?).

llvm/docs/CommandGuide/FileCheck.rst

913–915

Where this refers to "line" should it be "CHECK" directive?

Also, I think it would be valuable to give an example.

917–918

llvm/lib/FileCheck/FileCheck.cpp

382

My general rule is that consumeError should always have a comment explaining why you can just "ignore" the error and continue. In this case, I guess you're not ignoring the error per se, but you are throwing away the context, so a comment would still be useful.

411–415

Do you need this change? Can't you just return the result of EvalBinop directly?

449–450

1184

TODO that needs action still?

1307

(or possibly "using variables with empty expressions")

1311–1312

(or "using variables")

Should this definitely be "line"?

Perhaps change "Known issue" to FIXME and file a bug (bug filing to happen once this patch has landed, or shortly beforehand, with the FIXME to contain a link to that bug).

1322

1323–1324

1385–1386

1403

1424

1425–1426

1431

1433

No need for braces for single line if.

1438

Any reason we can't just use a for loop here?

1487

llvm/lib/FileCheck/FileCheckImpl.h

269

292–294

Seems like TentativeValue and StrTentativeValue are unnecessary? Could you not just set Value and StrValue in this context? If you need to distinguish a tentative versus concrete definition, add a boolean member or similar that states isTentative.

520

578

Nit: add new line after this method declaration.

[jdenny]

In D60392#3137020, @jhenderson wrote:

I've not looked at the testing in depth yet, and I'm a little concerned that I'm very cold on the surrounding code. I think it would be useful if someone else could take a look too (@jdenny maybe?).

Sorry for the delay, but I need a bit more time. I'll plan to take a look next week. Thanks for working on this.

[jdenny]

I understand the desire to be able to define and reference a variable within the same directive. However, as I understand it, this patch adds that ability in a way that introduces a new subtlety to FileCheck: the semantics of numeric variable references are then not always consistent. If you assume the wrong semantics, you can end up with a false pass of a test. I understand you've disabled the case of CHECK-NOT, but it does not appear to be the only case that can lead to false passes.

Example

Let's say we want to check that the very last value of y on an input line is equal to the first value of y plus 3. Thus, the following input line is then erroneous:

x=20, y=30, z=40, x=21, y=31, z=41, x=22, y=33, z=42, x=23, y=32, z=43,

Check version 1

CHECK: y=[[#VAR:]],{{.*}}y=[[#VAR+3]],

The behavior is:

• y=[[#VAR:]], matches y=30,.
• {{.*}} is maximal munch.
• So y=[[#VAR+3]], matches the last y= expression, which is y=32,.

The directive then fails because 32 is not 30+3. OK, that's the exact behavior I was going for. And now I think I understand how numeric variable references work.

(If the above is not the behavior you expect after applying this patch, let me know. Every example I tried after applying this patch produced seg faults or assertion failures, so I couldn't verify.)

Check version 2

Let's say I later realize I'd rather use VAR as defined to 30 by some earlier directive, so I rewrite check version 1 as follows:

CHECK: y=[[#VAR]],{{.*}}y=[[#VAR+3]],

The behavior is:

• y=[[#VAR]], is visibly differently than y=[[#VAR:]],, and its semantics are different too: it now matches a previously defined value instead of capturing a new value. Nevertheless, it still matches y=30,. So far, so good.
• {{.*}} is still maximal munch.
• Given that previous parts of the pattern match as before and VAR ends up with the same value as before, shouldn't the semantics of y=[[#VAR+3]], be the same as before? No. It can only match y=33, now, and so that's what it does.

The directive then accepts the erroneous input. That's pretty subtle.

Check version 3

Or, let's say I decide that splitting check version 1 into two directives would look better:

     CHECK: y=[[#VAR:]],
CHECK-SAME: {{.*}}y=[[#VAR+3]],

That's equivalent to version 1, right? Normally, I think it would be. Not in this case. Again, y=[[#VAR+3]], now has a different behavior: it only matches y=33,, and the erroneous input is now accepted.

Conclusion

I'm leery of letting the semantics of numeric variable references vary depending on where the variable happens to have been defined. It's too subtle.

I think it would be better to introduce the desired functionality with a different syntax to reflect the semantic shift. For example:

CHECK: y=[[#VAR1:]],{{.*}}y=[[#VAR2:]],[[!#VAR2 == VAR1 + 3]]

That introduces the concept of a post-match variable assertion. It would always appear at the end of a pattern to indicate it's evaluated last. It would always be delimited by [[! and ]], which hopefully doesn't collide with any existing syntax.

There's probably a better syntax I haven't thought of. My main point is to demonstrate how a different syntax could eliminate the inconsistent behavior I am concerned about.

[jdenny]

Or maybe a CHECK-ASSERT would be clearer and more generally useful:

CHECK: y=[[#VAR1:]],{{.*}}y=[[#VAR2:]]
CHECK-ASSERT: #VAR2 == VAR1 + 3

[thopre]

Hi Joel,

Thanks for your feedback, good job catching that!

In D60392#3181763, @jdenny wrote:

I understand the desire to be able to define and reference a variable within the same directive. However, as I understand it, this patch adds that ability in a way that introduces a new subtlety to FileCheck: the semantics of numeric variable references are then not always consistent. If you assume the wrong semantics, you can end up with a false pass of a test. I understand you've disabled the case of CHECK-NOT, but it does not appear to be the only case that can lead to false passes.

Example

Let's say we want to check that the very last value of y on an input line is equal to the first value of y plus 3. Thus, the following input line is then erroneous:

x=20, y=30, z=40, x=21, y=31, z=41, x=22, y=33, z=42, x=23, y=32, z=43,

Check version 1

CHECK: y=[[#VAR:]],{{.*}}y=[[#VAR+3]],

The behavior is:

• y=[[#VAR:]], matches y=30,.
• {{.*}} is maximal munch.
• So y=[[#VAR+3]], matches the last y= expression, which is y=32,.

The directive then fails because 32 is not 30+3. OK, that's the exact behavior I was going for. And now I think I understand how numeric variable references work.

(If the above is not the behavior you expect after applying this patch, let me know. Every example I tried after applying this patch produced seg faults or assertion failures, so I couldn't verify.)

I think the real issue here is using a wildcard pattern. I feel most often that not the user actually intended that. I remember someone asking for being able to use variables defined on the same line because using CHECK-SAME was different as pointed in your example below. See I think this is the behaviour people usually expect, judging from https://bugs.llvm.org/show_bug.cgi?id=30198 also about wildcard being a risky business.

Check version 2

Let's say I later realize I'd rather use VAR as defined to 30 by some earlier directive, so I rewrite check version 1 as follows:

CHECK: y=[[#VAR]],{{.*}}y=[[#VAR+3]],

The behavior is:

• y=[[#VAR]], is visibly differently than y=[[#VAR:]],, and its semantics are different too: it now matches a previously defined value instead of capturing a new value. Nevertheless, it still matches y=30,. So far, so good.
• {{.*}} is still maximal munch.
• Given that previous parts of the pattern match as before and VAR ends up with the same value as before, shouldn't the semantics of y=[[#VAR+3]], be the same as before? No. It can only match y=33, now, and so that's what it does.

The directive then accepts the erroneous input. That's pretty subtle.

I think the main issue is the regex was badly written in the first place but I agree this patch is making things worse by having inconsistent behaviour. Someone ought to have written either of those two regex instead depending on intended pattern to be matched:

CHECK: y=[[#VAR:]],{{.*}}y=[[#VAR+3]],{{[^y]*$}}

or

CHECK: y=[[#VAR:]],{{[^y]*}}y=[[#VAR+3]],

I like the suggestion of CHECK-ASSERT or a new syntax. I'll think about it and in the meantime anyone with an opinion on this feel free to chime in.

[jdenny]

In D60392#3182279, @thopre wrote:

Hi Joel,

Hi Thomas.

I like the suggestion of CHECK-ASSERT or a new syntax. I'll think about it

Thanks for considering that.

and in the meantime anyone with an opinion on this feel free to chime in.

Yes, it will be good to get other opinions. @jhenderson?

[jhenderson]

In D60392#3184072, @jdenny wrote:

In D60392#3182279, @thopre wrote:

Hi Joel,

Hi Thomas.

I like the suggestion of CHECK-ASSERT or a new syntax. I'll think about it

Thanks for considering that.

and in the meantime anyone with an opinion on this feel free to chime in.

Yes, it will be good to get other opinions. @jhenderson?

I think @jdenny has hit the nail on the head with regards to a fairly major problem with this patch. I don't think we want to introduce subtleties in behaviour like has been highlighted. Sorry for not considering this before.

Regarding the CHECK-ASSERT suggestion, do we need it? I was under the impression one of the earlier patches added a syntax like [[#VAR2, VAR1 + 3:]] or something to that effect, which achieves the same thing, right? Maybe I'm missing something though.

[thopre]

In D60392#3184688, @jhenderson wrote:

Regarding the CHECK-ASSERT suggestion, do we need it? I was under the impression one of the earlier patches added a syntax like [[#VAR2, VAR1 + 3:]] or something to that effect, which achieves the same thing, right? Maybe I'm missing something though.

You mean [[#VAR2:VAR1+3]]? Why does that prevent the need for something like CHECK-ASSERT? You still can only refer to a variable defined in an earlier line.

[jhenderson]

In D60392#3184854, @thopre wrote:

In D60392#3184688, @jhenderson wrote:

Regarding the CHECK-ASSERT suggestion, do we need it? I was under the impression one of the earlier patches added a syntax like [[#VAR2, VAR1 + 3:]] or something to that effect, which achieves the same thing, right? Maybe I'm missing something though.

You mean [[#VAR2:VAR1+3]]? Why does that prevent the need for something like CHECK-ASSERT? You still can only refer to a variable defined in an earlier line.

Looking back at the example, I guess it doesn't, although you could use CHECK-SAME to achieve the same effect, I think. More generally, I'm not sure how much I like the idea of checks that don't actually match anything, but I could be persuaded, especially if we can leverage the same functionality to support the CHECK-DEFINE concept I proposed previously (but never got as far as finishing off).

[jdenny]

In D60392#3188307, @jhenderson wrote:

In D60392#3184854, @thopre wrote:

In D60392#3184688, @jhenderson wrote:

Regarding the CHECK-ASSERT suggestion, do we need it? I was under the impression one of the earlier patches added a syntax like [[#VAR2, VAR1 + 3:]] or something to that effect, which achieves the same thing, right? Maybe I'm missing something though.

You mean [[#VAR2:VAR1+3]]? Why does that prevent the need for something like CHECK-ASSERT? You still can only refer to a variable defined in an earlier line.

Looking back at the example, I guess it doesn't, although you could use CHECK-SAME to achieve the same effect, I think. More generally, I'm not sure how much I like the idea of checks that don't actually match anything, but I could be persuaded, especially if we can leverage the same functionality to support the CHECK-DEFINE concept I proposed previously (but never got as far as finishing off).

I too would like a CHECK-DEFINE. Conceptually at least, I imagine CHECK-DEFINE or CHECK-ASSERT would match an empty string at the start of its search range (that is, end of the previous match or beginning of input if none). Giving it a match location in this way should help with diagnostics, such as -dump-input.

llvm/docs/CommandGuide/FileCheck.rst

 .. code-block:: gas
 
     mov r4, 0xC
     load r6, [r5, r4]
 
 The ``--enable-var-scope`` option has the same effect on numeric variables as
 on string variables.
 
-Important note: In its current implementation, an expression cannot use a
-numeric variable defined earlier in the same CHECK directive.
+Important note: In its current implementation, an expression using a variable
+defined on the same line can fail to match even though an input line satisfies
+it. This happens when there is more than one possible match in the line when
+ignoring such expressions and considering only their matching format
+(ie. matching an unsigned number with [[:digit:]]+ and the first match does not
+satisfy the constraint. This is due to those expressions not being able to be
+expressed at the regular expression level and the regular expression engine not
+offering the possibility of getting all possible matches for a given regular
+expression. To avoid false positive, using a variable whose value is not known
+at match time is forbidden for ``CHECK-NOT:`` directives.
 
 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

llvm/lib/FileCheck/FileCheck.cpp

 Expected<ExpressionValue> llvm::min(const ExpressionValue &LeftOperand,
                                     const ExpressionValue &RightOperand) {
   if (cantFail(max(LeftOperand, RightOperand)) == LeftOperand)
     return RightOperand;
 
   return LeftOperand;
 }
 
+Expected<ExpressionValue> Expression::eval(bool SetTentative) const {
+  assert(AST != nullptr && "Evaluating empty expression");
+  Expected<ExpressionValue> EvaluatedValue = AST->eval();
+  if (!EvaluatedValue)
+    return EvaluatedValue.takeError();
+  if (SetTentative && DefinedNumericVariable != nullptr)
+    DefinedNumericVariable->setValue(*EvaluatedValue, true);
+  return *EvaluatedValue;
+}
+
+bool Expression::verifyConstraint(ExpressionValue MatchedValue) const {
+  // Nothing to verify: variable definition with empty expression.
+  if (AST == nullptr)
+    return false;
+
+  Expected<ExpressionValue> EvaluatedValue = AST->eval();
+  if (!EvaluatedValue) {
+    consumeError(EvaluatedValue.takeError());
+    return true;
+  }
+  return *EvaluatedValue != MatchedValue;
+}
+
 Expected<ExpressionValue> NumericVariableUse::eval() const {
   Optional<ExpressionValue> Value = Variable->getValue();
   if (Value)
     return *Value;
 
   return make_error<UndefVarError>(getExpressionStr());
 }
 
 Expected<ExpressionValue> BinaryOperation::eval() const {
   Expected<ExpressionValue> LeftOp = LeftOperand->eval();
   Expected<ExpressionValue> RightOp = RightOperand->eval();
 
   // Bubble up any error (e.g. undefined variables) in the recursive
   // evaluation.
   if (!LeftOp || !RightOp) {
     Error Err = Error::success();
     if (!LeftOp)
       Err = joinErrors(std::move(Err), LeftOp.takeError());
     if (!RightOp)
       Err = joinErrors(std::move(Err), RightOp.takeError());
     return std::move(Err);
   }
 
-  return EvalBinop(*LeftOp, *RightOp);
+  Expected<ExpressionValue> ResultValue = EvalBinop(*LeftOp, *RightOp);
+  if (!ResultValue)
+    return ResultValue;
+
+  return ResultValue;
 }
 
 Expected<ExpressionFormat>
 BinaryOperation::getImplicitFormat(const SourceMgr &SM) const {
   Expected<ExpressionFormat> LeftFormat = LeftOperand->getImplicitFormat(SM);
   Expected<ExpressionFormat> RightFormat = RightOperand->getImplicitFormat(SM);
   if (!LeftFormat || !RightFormat) {
     Error Err = Error::success();
return ErrorDiagnostic::get(
             RightOperand->getExpressionStr() + "' (" + RightFormat->toString() +
             "), need an explicit format specifier");
 
   return *LeftFormat != ExpressionFormat::Kind::NoFormat ? *LeftFormat
                                                          : *RightFormat;
 }
 
 Expected<std::string> NumericSubstitution::getResult() const {
-  assert(ExpressionPointer->getAST() != nullptr &&
-         "Substituting empty expression");
+  // Evaluate expression and store result tentatively in any variable it may
+  // define so that subsequent expressions in the directive can use that
+  // variable. This allows them to be substituted with the right value
+  // accordingly rather than match anything and verify later, which introduce
+  // potential false negative match.
   Expected<ExpressionValue> EvaluatedValue =
-      ExpressionPointer->getAST()->eval();
+      ExpressionPointer->eval(/*SetTentative=*/true);
   if (!EvaluatedValue)
     return EvaluatedValue.takeError();
   ExpressionFormat Format = ExpressionPointer->getFormat();
   return Format.getMatchingString(*EvaluatedValue);
 }
 
 Expected<std::string> StringSubstitution::getResult() const {
   // Look up the value and escape it so that we can put it into the regex.
Expected<NumericVariable *> Pattern::parseNumericVariableDefinition(
   Expr = Expr.ltrim(SpaceChars);
   if (!Expr.empty())
     return ErrorDiagnostic::get(
         SM, Expr, "unexpected characters after numeric variable name");
 
   NumericVariable *DefinedNumericVariable;
   auto VarTableIter = Context->GlobalNumericVariableTable.find(Name);
   if (VarTableIter != Context->GlobalNumericVariableTable.end()) {
-    DefinedNumericVariable = VarTableIter->second;
+    DefinedNumericVariable = VarTableIter->second.first;
     if (DefinedNumericVariable->getImplicitFormat() != ImplicitFormat)
       return ErrorDiagnostic::get(
           SM, Expr, "format different from previous variable definition");
   } else
-    DefinedNumericVariable =
-        Context->makeNumericVariable(Name, ImplicitFormat, LineNumber);
+    DefinedNumericVariable = Context->makeNumericVariable(Name, ImplicitFormat);
 
   return DefinedNumericVariable;
 }
 
 Expected<std::unique_ptr<NumericVariableUse>> Pattern::parseNumericVariableUse(
-    StringRef Name, bool IsPseudo, Optional<size_t> LineNumber,
-    FileCheckPatternContext *Context, const SourceMgr &SM) {
+    StringRef Name, bool IsPseudo, bool AllowSameUse, bool &MatchTimeKnown,
+    Optional<size_t> LineNumber, FileCheckPatternContext *Context,
+    const SourceMgr &SM) {
   if (IsPseudo && !Name.equals("@LINE"))
     return ErrorDiagnostic::get(
         SM, Name, "invalid pseudo numeric variable '" + Name + "'");
 
   // Numeric variable definitions and uses are parsed in the order in which
   // they appear in the CHECK patterns. For each definition, the pointer to the
   // class instance of the corresponding numeric variable definition is stored
   // in GlobalNumericVariableTable in parsePattern. Therefore, if the pointer
   // we get below is null, it means no such variable was defined before. When
   // that happens, we create a dummy variable so that parsing can continue. All
   // uses of undefined variables, whether string or numeric, are then diagnosed
   // in printNoMatch() after failing to match.
   auto VarTableIter = Context->GlobalNumericVariableTable.find(Name);
   NumericVariable *NumericVariable;
-  if (VarTableIter != Context->GlobalNumericVariableTable.end())
-    NumericVariable = VarTableIter->second;
-  else {
+  bool MatchTimeKnownDefinition = false;
+  Optional<size_t> DefLineNumber = None;
+  if (VarTableIter != Context->GlobalNumericVariableTable.end()) {
+    NumericVariable = VarTableIter->second.first;
+    DefLineNumber = VarTableIter->second.second;
+    MatchTimeKnownDefinition =
+        Context->NumericVariableDefinitionTable.find(Name)->second;
+  } else {
     NumericVariable = Context->makeNumericVariable(
         Name, ExpressionFormat(ExpressionFormat::Kind::Unsigned));
-    Context->GlobalNumericVariableTable[Name] = NumericVariable;
+    Context->GlobalNumericVariableTable[Name] = {NumericVariable,
+                                                 DefLineNumber};
   }
 
-  Optional<size_t> DefLineNumber = NumericVariable->getDefLineNumber();
-  if (DefLineNumber && LineNumber && *DefLineNumber == *LineNumber)
-    return ErrorDiagnostic::get(
-        SM, Name,
-        "numeric variable '" + Name +
-            "' defined earlier in the same CHECK directive");
+  MatchTimeKnown = !DefLineNumber || !LineNumber ||
+                   *DefLineNumber != *LineNumber || MatchTimeKnownDefinition;
+  if (!MatchTimeKnown && !AllowSameUse)
+    return ErrorDiagnostic::get(SM, Name,
+                                "unknown variable value at match time");
 
   return std::make_unique<NumericVariableUse>(Name, NumericVariable);
 }
 
 Expected<std::unique_ptr<ExpressionAST>> Pattern::parseNumericOperand(
     StringRef &Expr, AllowedOperand AO, bool MaybeInvalidConstraint,
-    Optional<size_t> LineNumber, FileCheckPatternContext *Context,
-    const SourceMgr &SM) {
+    bool AllowSameUse, bool &MatchTimeKnown, Optional<size_t> LineNumber,
+    FileCheckPatternContext *Context, const SourceMgr &SM) {
   if (Expr.startswith("(")) {
     if (AO != AllowedOperand::Any)
       return ErrorDiagnostic::get(
           SM, Expr, "parenthesized expression not permitted here");
-    return parseParenExpr(Expr, LineNumber, Context, SM);
+    return parseParenExpr(Expr, AllowSameUse, MatchTimeKnown, LineNumber,
+                          Context, SM);
   }
 
   if (AO == AllowedOperand::LineVar || AO == AllowedOperand::Any) {
     // Try to parse as a numeric variable use.
     Expected<Pattern::VariableProperties> ParseVarResult =
         parseVariable(Expr, SM);
     if (ParseVarResult) {
       // Try to parse a function call.
       if (Expr.ltrim(SpaceChars).startswith("(")) {
         if (AO != AllowedOperand::Any)
           return ErrorDiagnostic::get(SM, ParseVarResult->Name,
                                       "unexpected function call");
 
-        return parseCallExpr(Expr, ParseVarResult->Name, LineNumber, Context,
-                             SM);
+        return parseCallExpr(Expr, ParseVarResult->Name, AllowSameUse,
+                             MatchTimeKnown, LineNumber, Context, SM);
       }
 
       return parseNumericVariableUse(ParseVarResult->Name,
-                                     ParseVarResult->IsPseudo, LineNumber,
-                                     Context, SM);
+                                     ParseVarResult->IsPseudo, AllowSameUse,
+                                     MatchTimeKnown, LineNumber, Context, SM);
     }
 
     if (AO == AllowedOperand::LineVar)
       return ParseVarResult.takeError();
     // Ignore the error and retry parsing as a literal.
     consumeError(ParseVarResult.takeError());
   }
 
   // Otherwise, parse it as a literal.
   int64_t SignedLiteralValue;
   uint64_t UnsignedLiteralValue;
   StringRef SaveExpr = Expr;
+  MatchTimeKnown = true;
   // Accept both signed and unsigned literal, default to signed literal.
   if (!Expr.consumeInteger((AO == AllowedOperand::LegacyLiteral) ? 10 : 0,
                            UnsignedLiteralValue))
     return std::make_unique<ExpressionLiteral>(SaveExpr.drop_back(Expr.size()),
                                                UnsignedLiteralValue);
   Expr = SaveExpr;
   if (AO == AllowedOperand::Any && !Expr.consumeInteger(0, SignedLiteralValue))
     return std::make_unique<ExpressionLiteral>(SaveExpr.drop_back(Expr.size()),
                                                SignedLiteralValue);
 
   return ErrorDiagnostic::get(
       SM, Expr,
       Twine("invalid ") +
           (MaybeInvalidConstraint ? "matching constraint or " : "") +
           "operand format");
 }
 
 Expected<std::unique_ptr<ExpressionAST>>
-Pattern::parseParenExpr(StringRef &Expr, Optional<size_t> LineNumber,
+Pattern::parseParenExpr(StringRef &Expr, bool AllowSameUse,
+                        bool &MatchTimeKnown, Optional<size_t> LineNumber,
                         FileCheckPatternContext *Context, const SourceMgr &SM) {
   Expr = Expr.ltrim(SpaceChars);
   assert(Expr.startswith("("));
 
   // Parse right operand.
   Expr.consume_front("(");
   Expr = Expr.ltrim(SpaceChars);
   if (Expr.empty())
     return ErrorDiagnostic::get(SM, Expr, "missing operand in expression");
 
   // Note: parseNumericOperand handles nested opening parentheses.
   Expected<std::unique_ptr<ExpressionAST>> SubExprResult = parseNumericOperand(
-      Expr, AllowedOperand::Any, /*MaybeInvalidConstraint=*/false, LineNumber,
-      Context, SM);
+      Expr, AllowedOperand::Any, /*MaybeInvalidConstraint=*/false, AllowSameUse,
+      MatchTimeKnown, LineNumber, Context, SM);
   Expr = Expr.ltrim(SpaceChars);
   while (SubExprResult && !Expr.empty() && !Expr.startswith(")")) {
     StringRef OrigExpr = Expr;
-    SubExprResult = parseBinop(OrigExpr, Expr, std::move(*SubExprResult), false,
-                               LineNumber, Context, SM);
+    SubExprResult =
+        parseBinop(OrigExpr, Expr, std::move(*SubExprResult), false,
+                   AllowSameUse, MatchTimeKnown, LineNumber, Context, SM);
     Expr = Expr.ltrim(SpaceChars);
   }
   if (!SubExprResult)
     return SubExprResult;
 
   if (!Expr.consume_front(")")) {
     return ErrorDiagnostic::get(SM, Expr,
                                 "missing ')' at end of nested expression");
   }
   return SubExprResult;
 }
 
 Expected<std::unique_ptr<ExpressionAST>>
 Pattern::parseBinop(StringRef Expr, StringRef &RemainingExpr,
                     std::unique_ptr<ExpressionAST> LeftOp,
-                    bool IsLegacyLineExpr, Optional<size_t> LineNumber,
+                    bool IsLegacyLineExpr, bool AllowSameUse,
+                    bool &MatchTimeKnown, Optional<size_t> LineNumber,
                     FileCheckPatternContext *Context, const SourceMgr &SM) {
   RemainingExpr = RemainingExpr.ltrim(SpaceChars);
   if (RemainingExpr.empty())
     return std::move(LeftOp);
 
   // Check if this is a supported operation and select a function to perform
   // it.
   SMLoc OpLoc = SMLoc::getFromPointer(RemainingExpr.data());
Pattern::parseBinop(StringRef Expr, StringRef &RemainingExpr,
   // Parse right operand.
   RemainingExpr = RemainingExpr.ltrim(SpaceChars);
   if (RemainingExpr.empty())
     return ErrorDiagnostic::get(SM, RemainingExpr,
                                 "missing operand in expression");
   // The second operand in a legacy @LINE expression is always a literal.
   AllowedOperand AO =
       IsLegacyLineExpr ? AllowedOperand::LegacyLiteral : AllowedOperand::Any;
-  Expected<std::unique_ptr<ExpressionAST>> RightOpResult =
-      parseNumericOperand(RemainingExpr, AO, /*MaybeInvalidConstraint=*/false,
-                          LineNumber, Context, SM);
+  bool MatchTimeKnownRightOp;
+  Expected<std::unique_ptr<ExpressionAST>> RightOpResult = parseNumericOperand(
+      RemainingExpr, AO, /*MaybeInvalidConstraint=*/false, AllowSameUse,
+      MatchTimeKnownRightOp, LineNumber, Context, SM);
   if (!RightOpResult)
     return RightOpResult;
 
   Expr = Expr.drop_back(RemainingExpr.size());
+  MatchTimeKnown = MatchTimeKnown && MatchTimeKnownRightOp;
   return std::make_unique<BinaryOperation>(Expr, EvalBinop, std::move(LeftOp),
                                            std::move(*RightOpResult));
 }
 
 Expected<std::unique_ptr<ExpressionAST>>
-Pattern::parseCallExpr(StringRef &Expr, StringRef FuncName,
-                       Optional<size_t> LineNumber,
+Pattern::parseCallExpr(StringRef &Expr, StringRef FuncName, bool AllowSameUse,
+                       bool &MatchTimeKnown, Optional<size_t> LineNumber,
                        FileCheckPatternContext *Context, const SourceMgr &SM) {
   Expr = Expr.ltrim(SpaceChars);
   assert(Expr.startswith("("));
 
   auto OptFunc = StringSwitch<Optional<binop_eval_t>>(FuncName)
                      .Case("add", operator+)
                      .Case("div", operator/)
                      .Case("max", max)
Pattern::parseCallExpr(StringRef &Expr, StringRef FuncName, bool AllowSameUse,
   SmallVector<std::unique_ptr<ExpressionAST>, 4> Args;
   while (!Expr.empty() && !Expr.startswith(")")) {
     if (Expr.startswith(","))
       return ErrorDiagnostic::get(SM, Expr, "missing argument");
 
     // Parse the argument, which is an arbitary expression.
     StringRef OuterBinOpExpr = Expr;
     Expected<std::unique_ptr<ExpressionAST>> Arg = parseNumericOperand(
-        Expr, AllowedOperand::Any, /*MaybeInvalidConstraint=*/false, LineNumber,
-        Context, SM);
+        Expr, AllowedOperand::Any, /*MaybeInvalidConstraint=*/false,
+        AllowSameUse, MatchTimeKnown, LineNumber, Context, SM);
     while (Arg && !Expr.empty()) {
       Expr = Expr.ltrim(SpaceChars);
       // Have we reached an argument terminator?
       if (Expr.startswith(",") || Expr.startswith(")"))
         break;
 
       // Arg = Arg <op> <expr>
-      Arg = parseBinop(OuterBinOpExpr, Expr, std::move(*Arg), false, LineNumber,
-                       Context, SM);
+      Arg = parseBinop(OuterBinOpExpr, Expr, std::move(*Arg), false,
+                       AllowSameUse, MatchTimeKnown, LineNumber, Context, SM);
     }
 
     // Prefer an expression error over a generic invalid argument message.
     if (!Arg)
       return Arg.takeError();
     Args.push_back(std::move(*Arg));
 
     // Have we parsed all available arguments?
Pattern::parseCallExpr(StringRef &Expr, StringRef FuncName, bool AllowSameUse,
 
   // TODO: Support more than binop_eval_t.
   return ErrorDiagnostic::get(SM, FuncName,
                               Twine("function '") + FuncName +
                                   Twine("' takes 2 arguments but ") +
                                   Twine(NumArgs) + " given");
 }
 
-Expected<std::unique_ptr<Expression>> Pattern::parseNumericSubstitutionBlock(
-    StringRef Expr, Optional<NumericVariable *> &DefinedNumericVariable,
-    bool IsLegacyLineExpr, Optional<size_t> LineNumber,
+Expected<Expression *> Pattern::parseNumericSubstitutionBlock(
+    StringRef Expr, NumericVariable *&DefinedNumericVariable,
+    bool IsLegacyLineExpr, bool AllowSameUse, Optional<size_t> LineNumber,
     FileCheckPatternContext *Context, const SourceMgr &SM) {
   std::unique_ptr<ExpressionAST> ExpressionASTPointer = nullptr;
   StringRef DefExpr = StringRef();
-  DefinedNumericVariable = None;
+  DefinedNumericVariable = nullptr;
   ExpressionFormat ExplicitFormat = ExpressionFormat();
   unsigned Precision = 0;
 
   // Parse format specifier (NOTE: ',' is also an argument seperator).
   size_t FormatSpecEnd = Expr.find(',');
   size_t FunctionStart = Expr.find('(');
   if (FormatSpecEnd != StringRef::npos && FormatSpecEnd < FunctionStart) {
     StringRef FormatExpr = Expr.take_front(FormatSpecEnd);
Expected<Expression *> Pattern::parseNumericSubstitutionBlock(
   // Parse matching constraint.
   Expr = Expr.ltrim(SpaceChars);
   bool HasParsedValidConstraint = false;
   if (Expr.consume_front("=="))
     HasParsedValidConstraint = true;
 
   // Parse the expression itself.
   Expr = Expr.ltrim(SpaceChars);
+  bool MatchTimeKnown = false;
   if (Expr.empty()) {
+    if (DefEnd != StringRef::npos)
+      MatchTimeKnown = true;
     if (HasParsedValidConstraint)
       return ErrorDiagnostic::get(
           SM, Expr, "empty numeric expression should not have a constraint");
   } else {
     Expr = Expr.rtrim(SpaceChars);
     StringRef OuterBinOpExpr = Expr;
     // The first operand in a legacy @LINE expression is always the @LINE
     // pseudo variable.
     AllowedOperand AO =
         IsLegacyLineExpr ? AllowedOperand::LineVar : AllowedOperand::Any;
-    Expected<std::unique_ptr<ExpressionAST>> ParseResult = parseNumericOperand(
-        Expr, AO, !HasParsedValidConstraint, LineNumber, Context, SM);
+    Expected<std::unique_ptr<ExpressionAST>> ParseResult =
+        parseNumericOperand(Expr, AO, !HasParsedValidConstraint, AllowSameUse,
+                            MatchTimeKnown, LineNumber, Context, SM);
     while (ParseResult && !Expr.empty()) {
       ParseResult = parseBinop(OuterBinOpExpr, Expr, std::move(*ParseResult),
-                               IsLegacyLineExpr, LineNumber, Context, SM);
+                               IsLegacyLineExpr, AllowSameUse, MatchTimeKnown,
+                               LineNumber, Context, SM);
       // Legacy @LINE expressions only allow 2 operands.
       if (ParseResult && IsLegacyLineExpr && !Expr.empty())
         return ErrorDiagnostic::get(
             SM, Expr,
             "unexpected characters at end of expression '" + Expr + "'");
     }
     if (!ParseResult)
       return ParseResult.takeError();
Expected<ExpressionFormat> ImplicitFormat =
         ExpressionASTPointer->getImplicitFormat(SM);
     if (!ImplicitFormat)
       return ImplicitFormat.takeError();
     Format = *ImplicitFormat;
   }
   if (!Format)
     Format = ExpressionFormat(ExpressionFormat::Kind::Unsigned, Precision);
 
-  std::unique_ptr<Expression> ExpressionPointer =
-      std::make_unique<Expression>(std::move(ExpressionASTPointer), Format);
-
   // Parse the numeric variable definition.
   if (DefEnd != StringRef::npos) {
     DefExpr = DefExpr.ltrim(SpaceChars);
     Expected<NumericVariable *> ParseResult = parseNumericVariableDefinition(
-        DefExpr, Context, LineNumber, ExpressionPointer->getFormat(), SM);
+        DefExpr, Context, LineNumber, Format, SM);
 
     if (!ParseResult)
       return ParseResult.takeError();
     DefinedNumericVariable = *ParseResult;
   }
 
-  return std::move(ExpressionPointer);
+  Expression *ExpressionPointer =
+      Context->makeExpression(std::move(ExpressionASTPointer), Format,
+                              MatchTimeKnown, DefinedNumericVariable);
+
+  return ExpressionPointer;
 }
 
 bool Pattern::parsePattern(StringRef PatternStr, StringRef Prefix,
                            SourceMgr &SM, const FileCheckRequest &Req) {
   bool MatchFullLinesHere = Req.MatchFullLines && CheckTy != Check::CheckNot;
   IgnoreCase = Req.IgnoreCase;
 
   PatternLoc = SMLoc::getFromPointer(PatternStr.data());
if (PatternStr.startswith("[[")) {
       }
       // 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);
 
       bool IsDefinition = false;
       bool SubstNeeded = false;
+      bool CaptureNeeded = false;
       // Whether the substitution block is a legacy use of @LINE with string
       // substitution block syntax.
       bool IsLegacyLineExpr = false;
       StringRef DefName;
       StringRef SubstStr;
       StringRef MatchRegexp;
       std::string WildcardRegexp;
       size_t SubstInsertIdx = RegExStr.size();
if (PatternStr.startswith("[[")) {
             parseVariable(MatchStr, SM);
         if (!ParseVarResult) {
           logAllUnhandledErrors(ParseVarResult.takeError(), errs());
           return true;
         }
         StringRef Name = ParseVarResult->Name;
         bool IsPseudo = ParseVarResult->IsPseudo;
 
-        IsDefinition = (VarEndIdx != StringRef::npos);
+        CaptureNeeded = IsDefinition = (VarEndIdx != StringRef::npos);
         SubstNeeded = !IsDefinition;
         if (IsDefinition) {
           if ((IsPseudo || !MatchStr.consume_front(":"))) {
             SM.PrintMessage(SMLoc::getFromPointer(Name.data()),
                             SourceMgr::DK_Error,
                             "invalid name in string variable definition");
             return true;
           }
if (PatternStr.startswith("[[")) {
               return true;
             }
             SubstStr = Name;
           }
         }
       }
 
       // Parse numeric substitution block.
-      std::unique_ptr<Expression> ExpressionPointer;
-      Optional<NumericVariable *> DefinedNumericVariable;
+      Expression *ExpressionPointer;
+      NumericVariable *DefinedNumericVariable = nullptr;
       if (IsNumBlock) {
-        Expected<std::unique_ptr<Expression>> ParseResult =
-            parseNumericSubstitutionBlock(MatchStr, DefinedNumericVariable,
-                                          IsLegacyLineExpr, LineNumber, Context,
-                                          SM);
+        Expected<Expression *> ParseResult = parseNumericSubstitutionBlock(
+            MatchStr, DefinedNumericVariable, IsLegacyLineExpr,
+            CheckTy != Check::CheckNot, LineNumber, Context, SM);
         if (!ParseResult) {
           logAllUnhandledErrors(ParseResult.takeError(), errs());
           return true;
         }
-        ExpressionPointer = std::move(*ParseResult);
-        SubstNeeded = ExpressionPointer->getAST() != nullptr;
+        ExpressionPointer = *ParseResult;
+        SubstNeeded = ExpressionPointer->isMatchTimeKnown();
         if (DefinedNumericVariable) {
           IsDefinition = true;
-          DefName = (*DefinedNumericVariable)->getName();
+          DefName = DefinedNumericVariable->getName();
         }
+        CaptureNeeded = IsDefinition || !ExpressionPointer->isMatchTimeKnown();
         if (SubstNeeded)
           SubstStr = MatchStr;
         else {
           ExpressionFormat Format = ExpressionPointer->getFormat();
           WildcardRegexp = cantFail(Format.getWildcardRegex());
           MatchRegexp = WildcardRegexp;
         }
       }
 
-      // Handle variable definition: [[<def>:(...)]] and [[#(...)<def>:(...)]].
-      if (IsDefinition) {
+      // Handle variable definition and expression needing verifying.
+      if (CaptureNeeded) {
         RegExStr += '(';
         ++SubstInsertIdx;
 
         if (IsNumBlock) {
-          NumericVariableMatch NumericVariableDefinition = {
-              *DefinedNumericVariable, CurParen};
-          NumericVariableDefs[DefName] = NumericVariableDefinition;
+          NumericExpressionMatch CapturedExpression = {
+              ExpressionPointer, DefinedNumericVariable, CurParen};
+          CapturedExpressions.push_back(CapturedExpression);
+          // TODO: reword
           // This store is done here rather than in match() to allow
           // parseNumericVariableUse() to get the pointer to the class instance
           // of the right variable definition corresponding to a given numeric
           // variable use.
-          Context->GlobalNumericVariableTable[DefName] =
-              *DefinedNumericVariable;
+          Context->GlobalNumericVariableTable[DefName] = {
+              DefinedNumericVariable, LineNumber};
+          Context->NumericVariableDefinitionTable[DefName] =
+              ExpressionPointer->isMatchTimeKnown();
         } else {
           VariableDefs[DefName] = CurParen;
           // Mark string variable as defined to detect collisions between
           // string and numeric variables in parseNumericVariableUse() and
           // defineCmdlineVariables() when the latter is created later than the
           // former. We cannot reuse GlobalVariableTable for this by populating
           // it with an empty string since we would then lose the ability to
           // detect the use of an undefined variable in match().
           Context->DefinedVariableTable[DefName] = true;
         }
 
         ++CurParen;
       }
 
       if (!MatchRegexp.empty() && AddRegExToRegEx(MatchRegexp, CurParen, SM))
         return true;
 
-      if (IsDefinition)
+      if (CaptureNeeded)
         RegExStr += ')';
 
       // Handle substitutions: [[foo]] and [[#<foo expr>]].
       if (SubstNeeded) {
         // Handle substitution of string variables that were defined earlier on
         // the same line by emitting a backreference. Expressions do not
         // support substituting a numeric variable defined on the same line.
         if (!IsNumBlock && VariableDefs.find(SubstStr) != VariableDefs.end()) {
           unsigned CaptureParenGroup = VariableDefs[SubstStr];
           if (CaptureParenGroup < 1 || CaptureParenGroup > 9) {
             SM.PrintMessage(SMLoc::getFromPointer(SubstStr.data()),
                             SourceMgr::DK_Error,
                             "Can't back-reference more than 9 variables");
             return true;
           }
           AddBackrefToRegEx(CaptureParenGroup);
         } else {
           // Handle substitution of string variables ([[<var>]]) defined in
           // previous CHECK patterns, and substitution of expressions.
           Substitution *Substitution =
               IsNumBlock
                   ? Context->makeNumericSubstitution(
-                        SubstStr, std::move(ExpressionPointer), SubstInsertIdx)
+                        SubstStr, ExpressionPointer, SubstInsertIdx)
                   : Context->makeStringSubstitution(SubstStr, SubstInsertIdx);
           Substitutions.push_back(Substitution);
         }
       }
     }
 
     // Handle fixed string matches.
     // Find the end, which is the start of the next regex.
Pattern::MatchResult Pattern::match(StringRef Buffer,
 
   // 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;
     if (LineNumber)
-      Context->LineVariable->setValue(ExpressionValue(*LineNumber));
+      Context->LineVariable->setValue(ExpressionValue(*LineNumber),
+                                      /*Tentative=*/false);
 
     size_t InsertOffset = 0;
     // Substitute all string variables and expressions whose values are only
     // now known. Use of string variables defined on the same line are handled
-    // by back-references.
+    // by back-references. For expressions using variable with empty expression
+    // defined on the same line, RegExStr is filled with a suitable wildcard
+    // pattern and the constraint is then verified against the matched value.
+    //
+    // Known issue: Due to the constraints for expressions using variable
+    // variable defined in earlier line not being expressed at the regular
+    // expression level, the wrong values might be matched, leading to a
+    // constraint check failure. An example of this is what happens when
+    // checking the line "1 3 4" against the directive
+    // "CHECK: [[#N:]] [[#N+1]]" which gets substituted by
+    // "[[:digit:]]+ [[:digit:]]+". This would match 1 3 which then fails the
+    // constraint checks.
+    //
+    // One possible solution would be to augment the regular expression engine
+    // to be able to return all matches for a given pattern. FileCheck could
+    // then test all possibility and fail the check only if none of them
+    // satisfy all expressions. This would work both for expression using a
+    // numeric variable defined on the same line as well as expressions with a
+    // comparison rather than equality constraint.
     Error Errs = Error::success();
     for (const auto &Substitution : Substitutions) {
       // Substitute and check for failure (e.g. use of undefined variable).
       Expected<std::string> Value = Substitution->getResult();
       if (!Value) {
         // Convert to an ErrorDiagnostic to get location information. This is
         // done here rather than printMatch/printNoMatch since now we know which
         // substitution block caused the overflow.
if (!Substitutions.empty()) {
     }
     if (Errs)
       return std::move(Errs);
 
     // Match the newly constructed regex.
     RegExToMatch = TmpStr;
   }
 
+  bool AllExpressionsSatisfied;
   SmallVector<StringRef, 4> MatchInfo;
+  Match TheMatch;
   unsigned int Flags = Regex::Newline;
   if (IgnoreCase)
     Flags |= Regex::IgnoreCase;
+  do {
+    AllExpressionsSatisfied = true;
     if (!Regex(RegExToMatch, Flags).match(Buffer, &MatchInfo))
       return make_error<NotFoundError>();
 
     // Successful regex match.
     assert(!MatchInfo.empty() && "Didn't get any match");
+    // 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
+    // case of CHECK-EMPTY but not CHECK-NEXT.
+    size_t MatchStartSkip = CheckTy == Check::CheckEmpty;
     StringRef FullMatch = MatchInfo[0];
+    TheMatch.Pos = FullMatch.data() - Buffer.data() + MatchStartSkip;
+    TheMatch.Len = FullMatch.size() - MatchStartSkip;
 
-  // If this defines any string variables, remember their values.
+    // If this defines any string variables, remember their values. This is
+    // safe to do even if this iteration fails to verify all expressions
+    // because use of string variable defined on the same lined is matched by
+    // using back-reference. Only variables defined in earlier lines are
+    // matched by their value.
     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
-  // case of CHECK-EMPTY but not CHECK-NEXT.
-  size_t MatchStartSkip = CheckTy == Check::CheckEmpty;
-  Match TheMatch;
-  TheMatch.Pos = FullMatch.data() - Buffer.data() + MatchStartSkip;
-  TheMatch.Len = FullMatch.size() - MatchStartSkip;
+    // Clear value tentatively set in previous iteration.
+    for (const auto &CapturedExpression : CapturedExpressions) {
+      NumericVariable *DefinedNumericVariable =
+          CapturedExpression.DefinedNumericVariable;
+      if (DefinedNumericVariable != nullptr)
+        DefinedNumericVariable->clearTentativeValue();
+    }
 
-  // If this defines any numeric variables, remember their values.
-  for (const auto &NumericVariableDef : NumericVariableDefs) {
-    const NumericVariableMatch &NumericVariableMatch =
-        NumericVariableDef.getValue();
-    unsigned CaptureParenGroup = NumericVariableMatch.CaptureParenGroup;
+    // Check matched values satisfy their corresponding expression and store
+    // them in the numeric variables being defined if any.
+    for (const auto &CapturedExpression : CapturedExpressions) {
+      unsigned CaptureParenGroup = CapturedExpression.CaptureParenGroup;
       assert(CaptureParenGroup < MatchInfo.size() && "Internal paren error");
+      Expression *Expr = CapturedExpression.Expr;
       NumericVariable *DefinedNumericVariable =
-        NumericVariableMatch.DefinedNumericVariable;
+          CapturedExpression.DefinedNumericVariable;
 
       StringRef MatchedValue = MatchInfo[CaptureParenGroup];
-    ExpressionFormat Format = DefinedNumericVariable->getImplicitFormat();
+      ExpressionFormat Format = Expr->getFormat();
       Expected<ExpressionValue> Value =
           Format.valueFromStringRepr(MatchedValue, SM);
+
       if (!Value)
         return MatchResult(TheMatch, Value.takeError());
-    DefinedNumericVariable->setValue(*Value, MatchedValue);
+
+      // Now verify the constraint of the expression.
+      if (Expr->verifyConstraint(*Value)) {
+        AllExpressionsSatisfied = false;
+        // Try matching again from the line following the one matched. There
+        // might be other possible matches in the current line but we have no
+        // way to ask for them to the regular expression engine. However this
+        // hazard can be alleviated if the user write a CHECK pattern that uses
+        // expression for all numeric values that the line to match contains.
+        Buffer = Buffer.substr(Buffer.find_first_of('\n')).substr(1);
+        break;
+      }
+
+      // If this defines a numeric variables, mark the verified value as
+      // tentative and store it.
+      if (DefinedNumericVariable != nullptr) {
+        DefinedNumericVariable->setValue(*Value, /*Tentative=*/true,
+                                         MatchedValue);
+      }
+    }
+  } while (!AllExpressionsSatisfied && !Buffer.empty());
+
+  // All constraints satisfied, make variable definitions definitive.
+  for (const auto &CapturedExpression : CapturedExpressions) {
+    NumericVariable *DefinedNumericVariable =
+        CapturedExpression.DefinedNumericVariable;
+    if (DefinedNumericVariable != nullptr)
+      DefinedNumericVariable->commitValue();
   }
 
   return MatchResult(TheMatch, Error::success());
 }
 
 unsigned Pattern::computeMatchDistance(StringRef Buffer) const {
   // Just compute the number of matching characters. For regular expressions, we
   // just compare against the regex itself and hope for the best.
unsigned Pattern::computeMatchDistance(StringRef Buffer) const {
   BufferPrefix = BufferPrefix.split('\n').first;
   return BufferPrefix.edit_distance(ExampleString);
 }
 
 void Pattern::printSubstitutions(const SourceMgr &SM, StringRef Buffer,
                                  SMRange Range,
                                  FileCheckDiag::MatchType MatchTy,
                                  std::vector<FileCheckDiag> *Diags) const {
-  // Print what we know about substitutions.
+  // Print what we know about substitutions. This covers both string and
+  // numeric substitutions as long as they only use variables whose value is
+  // known at match time.
   if (!Substitutions.empty()) {
     for (const auto &Substitution : Substitutions) {
       SmallString<256> Msg;
       raw_svector_ostream OS(Msg);
 
       Expected<std::string> MatchedValue = Substitution->getResult();
       // Substitution failures are handled in printNoMatch().
       if (!MatchedValue) {
         consumeError(MatchedValue.takeError());
         continue;
       }
 
+      // Substitution succeeded and expression satisfied its constrained.
       OS << "with \"";
       OS.write_escaped(Substitution->getFromString()) << "\" equal to \"";
       OS.write_escaped(*MatchedValue) << "\"";
 
       // We report only the start of the match/search range to suggest we are
       // reporting the substitutions as set at the start of the match/search.
       // Indicating a non-zero-length range might instead seem to imply that the
       // substitution matches or was captured from exactly that range.
       if (Diags)
         Diags->emplace_back(SM, CheckTy, getLoc(), MatchTy,
                             SMRange(Range.Start, Range.Start), OS.str());
       else
         SM.PrintMessage(Range.Start, SourceMgr::DK_Note, OS.str());
     }
   }
 }
 
 void Pattern::printVariableDefs(const SourceMgr &SM,
                                 FileCheckDiag::MatchType MatchTy,
                                 std::vector<FileCheckDiag> *Diags) const {
-  if (VariableDefs.empty() && NumericVariableDefs.empty())
+  if (VariableDefs.empty() && CapturedExpressions.empty())
     return;
   // Build list of variable captures.
   struct VarCapture {
     StringRef Name;
     SMRange Range;
   };
   SmallVector<VarCapture, 2> VarCaptures;
   for (const auto &VariableDef : VariableDefs) {
     VarCapture VC;
     VC.Name = VariableDef.first;
     StringRef Value = Context->GlobalVariableTable[VC.Name];
     SMLoc Start = SMLoc::getFromPointer(Value.data());
     SMLoc End = SMLoc::getFromPointer(Value.data() + Value.size());
     VC.Range = SMRange(Start, End);
     VarCaptures.push_back(VC);
   }
-  for (const auto &VariableDef : NumericVariableDefs) {
+  for (const auto &CapturedExpression : CapturedExpressions) {
     VarCapture VC;
-    VC.Name = VariableDef.getKey();
-    Optional<StringRef> StrValue =
-        VariableDef.getValue().DefinedNumericVariable->getStringValue();
+    NumericVariable *DefinedNumericVariable =
+        CapturedExpression.DefinedNumericVariable;
+    if (DefinedNumericVariable == nullptr)
+      continue;
+    VC.Name = DefinedNumericVariable->getName();
+    Optional<StringRef> StrValue = DefinedNumericVariable->getStringValue();
     if (!StrValue)
       continue;
     SMLoc Start = SMLoc::getFromPointer(StrValue->data());
     SMLoc End = SMLoc::getFromPointer(StrValue->data() + StrValue->size());
     VC.Range = SMRange(Start, End);
     VarCaptures.push_back(VC);
   }
   // Sort variable captures by the order in which they matched the input.

 FileCheckPatternContext::getPatternVarValue(StringRef VarName) {
   auto VarIter = GlobalVariableTable.find(VarName);
   if (VarIter == GlobalVariableTable.end())
     return make_error<UndefVarError>(VarName);
 
   return VarIter->second;
 }
 
-template <class... Types>
-NumericVariable *FileCheckPatternContext::makeNumericVariable(Types... args) {
-  NumericVariables.push_back(std::make_unique<NumericVariable>(args...));
+NumericVariable *
+FileCheckPatternContext::makeNumericVariable(StringRef Name,
+                                             ExpressionFormat ImplicitFormat) {
+  NumericVariables.push_back(
+      std::make_unique<NumericVariable>(Name, ImplicitFormat));
   return NumericVariables.back().get();
 }
 
+Expression *FileCheckPatternContext::makeExpression(
+    std::unique_ptr<ExpressionAST> AST, ExpressionFormat Format,
+    bool MatchTimeKnown, NumericVariable *DefinedNumericVariable) {
+  Expressions.push_back(std::make_unique<Expression>(
+      std::move(AST), Format, MatchTimeKnown, DefinedNumericVariable));
+  return Expressions.back().get();
+}
+
 Substitution *
 FileCheckPatternContext::makeStringSubstitution(StringRef VarName,
                                                 size_t InsertIdx) {
   Substitutions.push_back(
       std::make_unique<StringSubstitution>(this, VarName, InsertIdx));
   return Substitutions.back().get();
 }
 
 Substitution *FileCheckPatternContext::makeNumericSubstitution(
-    StringRef ExpressionStr, std::unique_ptr<Expression> Expression,
-    size_t InsertIdx) {
+    StringRef ExpressionStr, Expression *Expression, size_t InsertIdx) {
   Substitutions.push_back(std::make_unique<NumericSubstitution>(
-      this, ExpressionStr, std::move(Expression), InsertIdx));
+      this, ExpressionStr, Expression, InsertIdx));
   return Substitutions.back().get();
 }
 
 size_t Pattern::FindRegexVarEnd(StringRef Str, SourceMgr &SM) {
   // Offset keeps track of the current offset within the input Str
   size_t Offset = 0;
   // [...] Nesting depth
   size_t BracketDepth = 0;
FindFirstMatchingPrefix(const FileCheckRequest &Req, Regex &PrefixRE,
   return {StringRef(), StringRef()};
 }
 
 void FileCheckPatternContext::createLineVariable() {
   assert(!LineVariable && "@LINE pseudo numeric variable already created");
   StringRef LineName = "@LINE";
   LineVariable = makeNumericVariable(
       LineName, ExpressionFormat(ExpressionFormat::Kind::Unsigned));
-  GlobalNumericVariableTable[LineName] = LineVariable;
+  GlobalNumericVariableTable[LineName] = {LineVariable, None};
+  NumericVariableDefinitionTable[LineName] = true;
 }
 
 FileCheck::FileCheck(FileCheckRequest Req)
     : Req(Req), PatternContext(std::make_unique<FileCheckPatternContext>()),
       CheckStrings(std::make_unique<std::vector<FileCheckString>>()) {}
 
 FileCheck::~FileCheck() = default;
 
if (CmdlineDef.empty()) {
       continue;
     }
 
     // Numeric variable definition.
     if (CmdlineDef[0] == '#') {
       // Now parse the definition both to check that the syntax is correct and
       // to create the necessary class instance.
       StringRef CmdlineDefExpr = CmdlineDef.substr(1);
-      Optional<NumericVariable *> DefinedNumericVariable;
-      Expected<std::unique_ptr<Expression>> ExpressionResult =
+      NumericVariable *DefinedNumericVariable;
+      Expected<Expression *> ExpressionResult =
           Pattern::parseNumericSubstitutionBlock(
-              CmdlineDefExpr, DefinedNumericVariable, false, None, this, SM);
+              CmdlineDefExpr, DefinedNumericVariable,
+              /*IsLegacyLineExpr=*/false, /*AllowSameUse=*/false, None, this,
+              SM);
       if (!ExpressionResult) {
         Errs = joinErrors(std::move(Errs), ExpressionResult.takeError());
         continue;
       }
-      std::unique_ptr<Expression> Expression = std::move(*ExpressionResult);
+      Expression *Expr = *ExpressionResult;
       // Now evaluate the expression whose value this variable should be set
       // to, since the expression of a command-line variable definition should
       // only use variables defined earlier on the command-line. If not, this
       // is an error and we report it.
-      Expected<ExpressionValue> Value = Expression->getAST()->eval();
+      Expected<ExpressionValue> Value = Expr->eval(/*SetTentative=*/false);
       if (!Value) {
         Errs = joinErrors(std::move(Errs), Value.takeError());
         continue;
       }
 
-      assert(DefinedNumericVariable && "No variable defined");
-      (*DefinedNumericVariable)->setValue(*Value);
+      assert(DefinedNumericVariable != nullptr && "No variable defined");
+      DefinedNumericVariable->setValue(*Value, /*Tentative=*/false);
 
       // Record this variable definition.
-      GlobalNumericVariableTable[(*DefinedNumericVariable)->getName()] =
-          *DefinedNumericVariable;
+      StringRef DefName = DefinedNumericVariable->getName();
+      GlobalNumericVariableTable[DefName] = {DefinedNumericVariable, None};
+      NumericVariableDefinitionTable[DefName] = true;
     } else {
       // String variable definition.
       std::pair<StringRef, StringRef> CmdlineNameVal = CmdlineDef.split('=');
       StringRef CmdlineName = CmdlineNameVal.first;
       StringRef OrigCmdlineName = CmdlineName;
       Expected<Pattern::VariableProperties> ParseVarResult =
           Pattern::parseVariable(CmdlineName, SM);
       if (!ParseVarResult) {
if (Var.first()[0] != '$')
       LocalPatternVars.push_back(Var.first());
 
   // 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 &VarLineNum : GlobalNumericVariableTable)
+    if (VarLineNum.first()[0] != '$') {
+      VarLineNum.getValue().first->clearValue();
+      LocalNumericVars.push_back(VarLineNum.first());
     }
 
   for (const auto &Var : LocalPatternVars)
     GlobalVariableTable.erase(Var);
   for (const auto &Var : LocalNumericVars)
     GlobalNumericVariableTable.erase(Var);
 }
 

llvm/lib/FileCheck/FileCheckImpl.h

public:
   }
 
   /// Print name of variable associated with this error.
   void log(raw_ostream &OS) const override {
     OS << "undefined variable: " << VarName;
   }
 };
 
+class NumericVariable;
+
 /// Class representing an expression and its matching format.
 class Expression {
 private:
   /// Pointer to AST of the expression.
   std::unique_ptr<ExpressionAST> AST;
 
   /// Format to use (e.g. hex upper case letters) when matching the value.
   ExpressionFormat Format;
 
+  /// Whether the value of this expression can be known at match time
+  /// (i.e. when substituting it in the regular expression). If false, the
+  /// value is known after matching has happened.
+  bool MatchTimeKnown;
+
+  /// Numeric variable defined by this expression, if any.
+  NumericVariable *DefinedNumericVariable;
+
 public:
-  /// Generic constructor for an expression represented by the given \p AST and
-  /// whose matching format is \p Format.
-  Expression(std::unique_ptr<ExpressionAST> AST, ExpressionFormat Format)
-      : AST(std::move(AST)), Format(Format) {}
-
-  /// \returns pointer to AST of the expression. Pointer is guaranteed to be
-  /// valid as long as this object is.
-  ExpressionAST *getAST() const { return AST.get(); }
+  /// Generic constructor for an expression represented by the given \p AST,
+  /// whose matching format is \p Format and which is known at match time if
+  /// \p MatchTimeKnown is true.
+  Expression(std::unique_ptr<ExpressionAST> AST, ExpressionFormat Format,
+             bool MatchTimeKnown, NumericVariable *DefinedNumericVariable)
+      : AST(std::move(AST)), Format(Format), MatchTimeKnown(MatchTimeKnown),
+        DefinedNumericVariable(DefinedNumericVariable) {}
 
   ExpressionFormat getFormat() const { return Format; }
+
+  bool isMatchTimeKnown() const { return MatchTimeKnown; }
+
+  /// Evaluates and \returns the value of this assumed non-null expression or
+  /// an error if evaluation fails. It should only be invoked on expression
+  /// with a non null AST.
+  Expected<ExpressionValue> eval(bool SetTentative) const;
+
+  /// Verifies that the matched value in \p MatchedValue satisfies the
+  /// constraint expressed by this expression. \returns true if constraint is
+  /// not satisfied.
+  bool verifyConstraint(ExpressionValue MatchedValue) const;
 };
 
 /// Class representing a numeric variable and its associated current value.
 class NumericVariable {
 private:
   /// Name of the numeric variable.
   StringRef Name;
 
   /// Format to use for expressions using this variable without an explicit
   /// format.
   ExpressionFormat ImplicitFormat;
 
   /// Value of numeric variable, if defined, or None otherwise.
   Optional<ExpressionValue> Value;
 
+  /// Tentative value of numeric variable when the constraints of the
+  /// expression where it is defined have not been verified yet.
+  Optional<ExpressionValue> TentativeValue;
+
   /// The input buffer's string from which Value was parsed, or None.  See
   /// comments on getStringValue for a discussion of the None case.
   Optional<StringRef> StrValue;
 
-  /// Line number where this variable is defined, or None if defined before
-  /// input is parsed. Used to determine whether a variable is defined on the
-  /// same line as a given use.
-  Optional<size_t> DefLineNumber;
+  /// The input buffer's string from which TentativeValue was parsed, or None.
+  Optional<StringRef> StrTentativeValue;
 
 public:
-  /// Constructor for a variable \p Name with implicit format \p ImplicitFormat
-  /// defined at line \p DefLineNumber or defined before input is parsed if
-  /// \p DefLineNumber is None.
-  explicit NumericVariable(StringRef Name, ExpressionFormat ImplicitFormat,
-                           Optional<size_t> DefLineNumber = None)
-      : Name(Name), ImplicitFormat(ImplicitFormat),
-        DefLineNumber(DefLineNumber) {}
+  /// Constructor for a variable \p Name with implicit format
+  /// \p ImplicitFormat.
+  explicit NumericVariable(StringRef Name, ExpressionFormat ImplicitFormat)
+      : Name(Name), ImplicitFormat(ImplicitFormat) {}
 
   /// \returns name of this numeric variable.
   StringRef getName() const { return Name; }
 
   /// \returns implicit format of this numeric variable.
   ExpressionFormat getImplicitFormat() const { return ImplicitFormat; }
 
-  /// \returns this variable's value.
-  Optional<ExpressionValue> getValue() const { return Value; }
+  /// \returns this variable's tentative value if there is one, otherwise its
+  /// value.
+  Optional<ExpressionValue> getValue() const {
+    if (TentativeValue)
+      return TentativeValue;
+    return Value;
+  }
 
-  /// \returns the input buffer's string from which this variable's value was
-  /// parsed, or None if the value is not yet defined or was not parsed from the
-  /// input buffer.  For example, the value of @LINE is not parsed from the
-  /// input buffer, and some numeric variables are parsed from the command
-  /// line instead.
-  Optional<StringRef> getStringValue() const { return StrValue; }
+  /// \returns the input buffer's string from which this variable's value
+  /// (tentative if any) was parsed, or None if the value is not yet defined or
+  /// was not parsed from the input buffer.  For example, the value of @LINE is
+  /// not parsed from the input buffer, and some numeric variables are parsed
+  /// from the command line instead.
+  Optional<StringRef> getStringValue() const {
+    if (StrTentativeValue)
+      return StrTentativeValue;
+    return StrValue;
+  }
 
   /// Sets value of this numeric variable to \p NewValue, and sets the input
-  /// buffer string from which it was parsed to \p NewStrValue.  See comments on
-  /// getStringValue for a discussion of when the latter can be None.
-  void setValue(ExpressionValue NewValue,
+  /// buffer string from which it was parsed to \p NewStrValue. If \p Tentative
+  /// is set, it is the tentative value and corresponding input string which
+  /// are set. See comments on getStringValue for a discussion of when the
+  /// latter can be None.
+  void setValue(ExpressionValue NewValue, bool Tentative,
                 Optional<StringRef> NewStrValue = None) {
+    if (Tentative) {
+      TentativeValue = NewValue;
+      StrTentativeValue = NewStrValue;
+    } else {
       Value = NewValue;
       StrValue = NewStrValue;
     }
+  }
+
+  /// Marks value as definitive (i.e. not tentative).
+  void commitValue() {
+    assert(TentativeValue && "No value to commit");
+    Value = TentativeValue;
+    StrValue = StrTentativeValue;
+    clearTentativeValue();
+  }
 
   /// Clears value of this numeric variable, regardless of whether it is
   /// currently defined or not.
   void clearValue() {
     Value = None;
     StrValue = None;
   }
 
-  /// \returns the line number where this variable is defined, if any, or None
-  /// if defined before input is parsed.
-  Optional<size_t> getDefLineNumber() const { return DefLineNumber; }
+  /// Clears tentative value of this numeric variable and its corresponding
+  /// input string, regardless of whether it is currently defined or not.
+  void clearTentativeValue() {
+    TentativeValue = None;
+    StrTentativeValue = None;
+  }
 };
 
 /// Class representing the use of a numeric variable in the AST of an
 /// expression.
 class NumericVariableUse : public ExpressionAST {
 private:
   /// Pointer to the class instance for the variable this use is about.
   NumericVariable *Variable;
public:
   /// when defined, or an error if the variable is undefined.
   Expected<std::string> getResult() const override;
 };
 
 class NumericSubstitution : public Substitution {
 private:
   /// Pointer to the class representing the expression whose value is to be
   /// substituted.
-  std::unique_ptr<Expression> ExpressionPointer;
+  Expression *ExpressionPointer;
 
 public:
   NumericSubstitution(FileCheckPatternContext *Context, StringRef ExpressionStr,
-                      std::unique_ptr<Expression> ExpressionPointer,
-                      size_t InsertIdx)
+                      Expression *ExpressionPointer, size_t InsertIdx)
       : Substitution(Context, ExpressionStr, InsertIdx),
-        ExpressionPointer(std::move(ExpressionPointer)) {}
+        ExpressionPointer(ExpressionPointer) {}
 
   /// \returns a string containing the result of evaluating the expression in
   /// this substitution, or an error if evaluation failed.
   Expected<std::string> getResult() const override;
 };
 
 //===----------------------------------------------------------------------===//
 // Pattern handling code.
private:
   /// Back-references are used for uses after any the other definition.
   StringMap<StringRef> GlobalVariableTable;
 
   /// 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 numeric variables defined in previous patterns. When
-  /// matching a pattern all definitions for that pattern are recorded in the
-  /// NumericVariableDefs table in the Pattern instance of that pattern.
-  StringMap<NumericVariable *> GlobalNumericVariableTable;
+  /// Holds the pointers to classes instances representing all the numeric
+  /// variables defined in patterns parsed so far and the line number where
+  /// they were last defined.
+  StringMap<std::pair<NumericVariable *, Optional<size_t>>>
+      GlobalNumericVariableTable;
+
+  /// Holds whether the value of the last definition of a given numeric
+  /// variable is known at match time.
+  StringMap<bool> NumericVariableDefinitionTable;
 
   /// Pointer to the class instance representing the @LINE pseudo variable for
   /// easily updating its value.
   NumericVariable *LineVariable = nullptr;
 
   /// 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<NumericVariable>> NumericVariables;
public:
   /// sign), i.e. removes them from GlobalVariableTable and from
   /// GlobalNumericVariableTable and also clears the value of numeric
   /// variables.
   void clearLocalVars();
 
 private:
   /// Makes a new numeric variable and registers it for destruction when the
   /// context is destroyed.
-  template <class... Types> NumericVariable *makeNumericVariable(Types... args);
+  NumericVariable *makeNumericVariable(StringRef Name,
+                                       ExpressionFormat ImplicitFormat);
 
+  /// Makes a new expression and registers it for destruction when the context
+  /// is destroyed.
+  Expression *makeExpression(std::unique_ptr<ExpressionAST> AST,
+                             ExpressionFormat Format, bool MatchTimeKnown,
+                             NumericVariable *DefinedNumericVariable);
   /// Makes a new string substitution and registers it for destruction when the
   /// context is destroyed.
   Substitution *makeStringSubstitution(StringRef VarName, size_t InsertIdx);
 
   /// Makes a new numeric substitution and registers it for destruction when
   /// the context is destroyed.
   Substitution *makeNumericSubstitution(StringRef ExpressionStr,
-                                        std::unique_ptr<Expression> Expression,
+                                        Expression *Expression,
                                         size_t InsertIdx);
 };
 
 /// Class to represent an error holding a diagnostic with location information
 /// used when printing it.
 class ErrorDiagnostic : public ErrorInfo<ErrorDiagnostic> {
 private:
   SMDiagnostic Diagnostic;
class Pattern {
   /// the value captured for QUUX on the earlier line where it was defined, and
   /// VariableDefs will map "bar" to the third parenthesis group which captures
   /// the second definition of "bar".
   ///
   /// Note: uses std::map rather than StringMap to be able to get the key when
   /// iterating over values.
   std::map<StringRef, unsigned> VariableDefs;
 
-  /// Structure representing the definition of a numeric variable in a pattern.
-  /// It holds the pointer to the class instance holding the value and matching
-  /// format of the numeric variable whose value is being defined and the
-  /// number of the parenthesis group in RegExStr to capture that value.
-  struct NumericVariableMatch {
+  /// Structure representing an expression whose value is verified after
+  /// matching (either a variable definition with an empty expression or an
+  /// expression using directly or indirectly such a variable). It holds the
+  /// pointer to the class instance holding the expression to verify, the
+  /// pointer to the class instance holding the value and matching format of
+  /// the numeric variable whose value is being defined if any, and the number
+  /// of the parenthesis group in RegExStr to capture that value.
+  struct NumericExpressionMatch {
+    /// Pointer to class instance representing the expression to verify.
+    Expression *Expr;
+
     /// Pointer to class instance holding the value and matching format of the
-    /// numeric variable being defined.
+    /// numeric variable being defined, if any.
     NumericVariable *DefinedNumericVariable;
 
-    /// Number of the parenthesis group in RegExStr that captures the value of
-    /// this numeric variable definition.
+    /// Number of the parenthesis group in the regex that captures the value of
+    /// this expression.
     unsigned CaptureParenGroup;
   };
 
-  /// Holds the number of the parenthesis group in RegExStr and pointer to the
-  /// corresponding NumericVariable class instance of all numeric variable
-  /// definitions. Used to set the matched value of all those variables.
-  StringMap<NumericVariableMatch> NumericVariableDefs;
+  /// Holds for expression that need to be verified the information needed to
+  /// do so,
+  SmallVector<NumericExpressionMatch, 4> CapturedExpressions;
 
   /// Pointer to a class instance holding the global state shared by all
   /// patterns:
   /// - separate tables with the values of live string and numeric variables
   ///   respectively at the start of any given CHECK line;
   /// - table holding whether a string variable has been defined at any given
   ///   point during the parsing phase.
   FileCheckPatternContext *Context;
public:
   /// or before input is parsed if \p LineNumber is None. Parameter
   /// \p IsLegacyLineExpr indicates whether \p Expr should be a legacy @LINE
   /// expression and \p Context points to the class instance holding the live
   /// string and numeric variables. \returns a pointer to the class instance
   /// representing the expression whose value must be substitued, or an error
   /// holding a diagnostic against \p SM if parsing fails. If substitution was
   /// successful, sets \p DefinedNumericVariable to point to the class
   /// representing the numeric variable defined in this numeric substitution
-  /// block, or None if this block does not define any variable.
-  static Expected<std::unique_ptr<Expression>> parseNumericSubstitutionBlock(
-      StringRef Expr, Optional<NumericVariable *> &DefinedNumericVariable,
-      bool IsLegacyLineExpr, Optional<size_t> LineNumber,
+  /// block, or null if this block does not define any variable.
+  static Expected<Expression *> parseNumericSubstitutionBlock(
+      StringRef Expr, NumericVariable *&DefinedNumericVariable,
+      bool IsLegacyLineExpr, bool AllowSameUse, Optional<size_t> LineNumber,
       FileCheckPatternContext *Context, const SourceMgr &SM);
   /// Parses the pattern in \p PatternStr and initializes this Pattern 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.
   /// \returns true in case of an error, false otherwise.
public:
   /// The GlobalVariableTable StringMap in the FileCheckPatternContext class
   /// instance provides the current values of FileCheck string variables and is
   /// updated if this match defines new values. Likewise, the
   /// GlobalNumericVariableTable StringMap in the same class provides the
   /// current values of FileCheck numeric variables and is updated if this
   /// match defines new numeric values.
   MatchResult match(StringRef Buffer, const SourceMgr &SM) const;
   /// Prints the value of successful substitutions.
+  ///
+  /// Note: Expressions directly or indirectly using variables defined on the
+  /// same line are not shown because their value is not known at match time.
   void printSubstitutions(const SourceMgr &SM, StringRef Buffer,
                           SMRange MatchRange, FileCheckDiag::MatchType MatchTy,
                           std::vector<FileCheckDiag> *Diags) const;
   void printFuzzyMatch(const SourceMgr &SM, StringRef Buffer,
                        std::vector<FileCheckDiag> *Diags) const;
 
   bool hasVariable() const {
     return !(Substitutions.empty() && VariableDefs.empty());
private:
   static Expected<NumericVariable *> parseNumericVariableDefinition(
       StringRef &Expr, FileCheckPatternContext *Context,
       Optional<size_t> LineNumber, ExpressionFormat ImplicitFormat,
       const SourceMgr &SM);
   /// Parses \p Name as a (pseudo if \p IsPseudo is true) numeric variable use
   /// at line \p LineNumber, or before input is parsed if \p LineNumber is
   /// None. Parameter \p Context points to the class instance holding the live
   /// string and numeric variables. \returns the pointer to the class instance
-  /// representing that variable if successful, or an error holding a
-  /// diagnostic against \p SM otherwise.
-  static Expected<std::unique_ptr<NumericVariableUse>> parseNumericVariableUse(
-      StringRef Name, bool IsPseudo, Optional<size_t> LineNumber,
-      FileCheckPatternContext *Context, const SourceMgr &SM);
+  /// representing that variable if successful and whether the variable's value
+  /// is known at match time in \p MatchTimeKnown, or an error holding a
+  /// diagnostic against \p SM otherwise, for instance if the use is for a
+  /// variable defined on the same line and \p AllowSameUse is false.
+  static Expected<std::unique_ptr<NumericVariableUse>>
+  parseNumericVariableUse(StringRef Name, bool IsPseudo, bool AllowSameUse,
+                          bool &MatchTimeKnown, Optional<size_t> LineNumber,
+                          FileCheckPatternContext *Context,
+                          const SourceMgr &SM);
   enum class AllowedOperand { LineVar, LegacyLiteral, Any };
   /// Parses \p Expr for use of a numeric operand at line \p LineNumber, or
   /// before input is parsed if \p LineNumber is None. Accepts literal values,
   /// numeric variables and function calls, depending on the value of \p AO.
-  /// \p MaybeInvalidConstraint indicates whether the text being parsed could
-  /// be an invalid constraint. \p Context points to the class instance holding
-  /// the live string and numeric variables. \returns the class representing
-  /// that operand in the AST of the expression or an error holding a
-  /// diagnostic against \p SM otherwise. If \p Expr starts with a "(" this
-  /// function will attempt to parse a parenthesized expression.
+  /// \p AllowSameUse indicates whether to accept a variable defined earlier
+  /// on the same line and \p MaybeInvalidConstraint indicates whether the text
+  /// being parsed could be an invalid constraint. \p Context points to the
+  /// class instance holding the live string and numeric variables. If \p Expr
+  /// starts with a "(" this function will attempt to parse a parenthesized
+  /// expression. \returns the class representing that operand in the AST of
+  /// the expression or an error holding a diagnostic against \p SM otherwise.
+  /// Also sets \p MatchTimeKnown to whether the operand's value is known at
+  /// match time.
   static Expected<std::unique_ptr<ExpressionAST>>
-  parseNumericOperand(StringRef &Expr, AllowedOperand AO, bool ConstraintParsed,
-                      Optional<size_t> LineNumber,
+  parseNumericOperand(StringRef &Expr, AllowedOperand AO,
+                      bool MaybeInvalidConstraint, bool AllowSameUse,
+                      bool &MatchTimeKnown, Optional<size_t> LineNumber,
                       FileCheckPatternContext *Context, const SourceMgr &SM);
   /// Parses and updates \p RemainingExpr for a binary operation at line
   /// \p LineNumber, or before input is parsed if \p LineNumber is None. The
-  /// left operand of this binary operation is given in \p LeftOp and \p Expr
-  /// holds the string for the full expression, including the left operand.
-  /// Parameter \p IsLegacyLineExpr indicates whether we are parsing a legacy
-  /// @LINE expression. Parameter \p Context points to the class instance
+  /// left operand of this binary operation is given in \p LeftOp and
+  /// \p MatchTimeKnown holds whether the left operand's value is known at
+  /// match time. \p Expr holds the string for the full expression, including
+  /// the left operand. Parameter \p IsLegacyLineExpr indicates whether we
+  /// are parsing a legacy @LINE expression and parameter \p AllowSameUse
+  /// indicates whether the use of a variable defined earlier on the same line
+  /// is a valid operand. Parameter \p Context points to the class instance
   /// holding the live string and numeric variables. \returns the class
   /// representing the binary operation in the AST of the expression, or an
-  /// error holding a diagnostic against \p SM otherwise.
+  /// error holding a diagnostic against \p SM otherwise. Also update
+  /// \p MatchTimeKnown according to whether the right operand is also known
+  /// at match time.
   static Expected<std::unique_ptr<ExpressionAST>>
   parseBinop(StringRef Expr, StringRef &RemainingExpr,
              std::unique_ptr<ExpressionAST> LeftOp, bool IsLegacyLineExpr,
+             bool AllowSameUse, bool &MatchTimeKnown,
              Optional<size_t> LineNumber, FileCheckPatternContext *Context,
              const SourceMgr &SM);
 
   /// Parses a parenthesized expression inside \p Expr at line \p LineNumber, or
   /// before input is parsed if \p LineNumber is None. \p Expr must start with
   /// a '('. Accepts both literal values and numeric variables. Parameter \p
-  /// Context points to the class instance holding the live string and numeric
-  /// variables. \returns the class representing that operand in the AST of the
+  /// MatchTimeKnown is set to true if the expression is known at match time.
+  /// Parameter \p AllowSameUse indicates whether the expression allows use of
+  /// variable defined earlier on the same line. Parameter \p Context points
+  /// to the class instance holding the live string and numeric variables.
+  /// \returns the class representing that operand in the AST of the
   /// expression or an error holding a diagnostic against \p SM otherwise.
   static Expected<std::unique_ptr<ExpressionAST>>
-  parseParenExpr(StringRef &Expr, Optional<size_t> LineNumber,
-                 FileCheckPatternContext *Context, const SourceMgr &SM);
+  parseParenExpr(StringRef &Expr, bool AllowSameUse, bool &MatchTimeKnown,
+                 Optional<size_t> LineNumber, FileCheckPatternContext *Context,
+                 const SourceMgr &SM);
 
   /// Parses \p Expr for an argument list belonging to a call to function \p
   /// FuncName at line \p LineNumber, or before input is parsed if \p LineNumber
-  /// is None. Parameter \p FuncLoc is the source location used for diagnostics.
-  /// Parameter \p Context points to the class instance holding the live string
-  /// and numeric variables. \returns the class representing that call in the
-  /// AST of the expression or an error holding a diagnostic against \p SM
+  /// is None. Parameter \p FuncName is the name of the function. Parameter \p
+  /// MatchTimeKnown is set to true if the expression is known at match time.
+  /// Parameter \p AllowSameUse indicate whether parameters of the function are
+  /// allowed to be variable defined earlier on the same line. Parameter
+  /// \p Context points to the class instance holding the live string and
+  /// numeric variables. \returns the class representing that call in the AST
+  /// of the expression or an error holding a diagnostic against \p SM
   /// otherwise.
   static Expected<std::unique_ptr<ExpressionAST>>
-  parseCallExpr(StringRef &Expr, StringRef FuncName,
-                Optional<size_t> LineNumber, FileCheckPatternContext *Context,
-                const SourceMgr &SM);
+  parseCallExpr(StringRef &Expr, StringRef FuncName, bool AllowSameUse,
+                bool &MatchTimeKnown, Optional<size_t> LineNumber,
+                FileCheckPatternContext *Context, const SourceMgr &SM);
 };
 
 //===----------------------------------------------------------------------===//
 // Check Strings.
 //===----------------------------------------------------------------------===//
 
 /// A check that we found in the input file.
 struct FileCheckString {

llvm/test/FileCheck/numeric-expressions/numeric-expressions.txt

 RUN:   | FileCheck --check-prefix INVALID-FMT-SPEC-MSG2 --strict-whitespace %s
 
 DEF INVALID FMT
 INVVAR1=a
 INVVAR2=11
 ERR-LABEL: DEF INVALID FMT
 INVALID-FMT-SPEC1-NEXT: INVVAR1=[[#%c,INVVAR1:]]
 INVALID-FMT-SPEC2-NEXT: INVVAR2=[[#%hhd,INVVAR2:]]
-INVALID-FMT-SPEC-MSG1: numeric-expression.txt:[[#@LINE-2]]:37: error: invalid format specifier in expression
+INVALID-FMT-SPEC-MSG1: numeric-expressions.txt:[[#@LINE-2]]:37: error: invalid format specifier in expression
 INVALID-FMT-SPEC-MSG1-NEXT: {{I}}NVALID-FMT-SPEC1-NEXT: INVVAR1={{\[\[#%c,INVVAR1:\]\]}}
 INVALID-FMT-SPEC-MSG1-NEXT:    {{^}}                                    ^{{$}}
-INVALID-FMT-SPEC-MSG2: numeric-expression.txt:[[#@LINE-4]]:37: error: invalid format specifier in expression
+INVALID-FMT-SPEC-MSG2: numeric-expressions.txt:[[#@LINE-4]]:37: error: invalid format specifier in expression
 INVALID-FMT-SPEC-MSG2-NEXT: {{I}}NVALID-FMT-SPEC2-NEXT: INVVAR2={{\[\[#%hhd,INVVAR2:\]\]}}
 INVALID-FMT-SPEC-MSG2-NEXT:    {{^}}                                    ^{{$}}
 
 ; Numeric variable definition of hex value with 0x prefix.
 DEF ALT FORM  // CHECK-LABEL: DEF ALT FORM
 0xf  // CHECK-NEXT: {{^}}[[#%#x,PREFIXED_LHEX:]]
 0xE  // CHECK-NEXT: {{^}}[[#%#X,PREFIXED_UHEX:]]
 
 ; Invalid numeric variable definition of non-hex value with 0x prefix.
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck --check-prefixes INVALID-ALT-FORM,INVALID-ALT-FORM1 --input-file %s %s 2>&1 \
 RUN:   | FileCheck --check-prefix INVALID-ALT-FORM-MSG1 --strict-whitespace %s
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck --check-prefixes INVALID-ALT-FORM,INVALID-ALT-FORM2 --input-file %s %s 2>&1 \
 RUN:   | FileCheck --check-prefix INVALID-ALT-FORM-MSG2 --strict-whitespace %s
 DEF INVALID ALT FORM
 PREFIXED_DEC=0x3
 INVALID-ALT-FORM-LABEL: DEF INVALID ALT FORM
 INVALID-ALT-FORM1-NEXT: PREFIXED_DEC=[[#%#u,PREFIXED_UNSI:]]
 INVALID-ALT-FORM2-NEXT: PREFIXED_DEC=[[#%#d,PREFIXED_SIGN:]]
-INVALID-ALT-FORM-MSG1: numeric-expression.txt:[[#@LINE-2]]:42: error: alternate form only supported for hex values
+INVALID-ALT-FORM-MSG1: numeric-expressions.txt:[[#@LINE-2]]:42: error: alternate form only supported for hex values
 INVALID-ALT-FORM-MSG1-NEXT: {{I}}NVALID-ALT-FORM1-NEXT: PREFIXED_DEC={{\[\[#%#u,PREFIXED_UNSI:\]\]}}
 INVALID-ALT-FORM-MSG1-NEXT:    {{^}}                                         ^{{$}}
-INVALID-ALT-FORM-MSG2: numeric-expression.txt:[[#@LINE-4]]:42: error: alternate form only supported for hex values
+INVALID-ALT-FORM-MSG2: numeric-expressions.txt:[[#@LINE-4]]:42: error: alternate form only supported for hex values
 INVALID-ALT-FORM-MSG2-NEXT: {{I}}NVALID-ALT-FORM2-NEXT: PREFIXED_DEC={{\[\[#%#d,PREFIXED_SIGN:\]\]}}
 INVALID-ALT-FORM-MSG2-NEXT:    {{^}}                                         ^{{$}}
 
 ; Numeric variable definition of hex value with missing 0x prefix.
 RUN: FileCheck --check-prefix INVALID-HEX-PREFIX-DEF --input-file %s %s
 
 FAIL DEF ALT FORM  // INVALID-HEX-PREFIX-DEF-LABEL: FAIL DEF ALT FORM
 INVALID_PREFIXED_LHEX: xf   // INVALID-HEX-PREFIX-DEF-NOT: {{^}}INVALID_PREFIXED_LHEX: [[#%#x,INVALID_PREFIXED_LHEX:]]

 RUN:   | FileCheck --check-prefix NUMEXPR-CONSTRAINT-NOMATCH-MSG --strict-whitespace %s
 
 USE DEF FMT EXPL NO MATCH
 UNSI=11
 UNSI: 12
 NUMEXPR-CONSTRAINT-NOMATCH-LABEL: USE DEF FMT EXPL NO MATCH
 NUMEXPR-CONSTRAINT-NOMATCH-NEXT: UNSI=[[#UNSI:]]
 NUMEXPR-CONSTRAINT-NOMATCH-NEXT: UNSI: [[#==UNSI]]
-NUMEXPR-CONSTRAINT-NOMATCH-MSG: numeric-expression.txt:[[#@LINE-1]]:34: error: {{N}}UMEXPR-CONSTRAINT-NOMATCH-NEXT: expected string not found in input
+NUMEXPR-CONSTRAINT-NOMATCH-MSG: numeric-expressions.txt:[[#@LINE-1]]:34: error: {{N}}UMEXPR-CONSTRAINT-NOMATCH-NEXT: expected string not found in input
 NUMEXPR-CONSTRAINT-NOMATCH-MSG-NEXT:  {{N}}UMEXPR-CONSTRAINT-NOMATCH-NEXT: UNSI: {{\[\[#==UNSI\]\]}}
 NUMEXPR-CONSTRAINT-NOMATCH-MSG-NEXT: {{^}}                                 ^{{$}}
 
 ; Empty numeric expression with matching constraint.
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck --check-prefix EMPTY-NUMEXPR-CONSTRAINT --input-file %s %s 2>&1 \
 RUN:   | FileCheck --check-prefix EMPTY-NUMEXPR-CONSTRAINT-MSG --strict-whitespace %s
 
 EMPTY NUMEXPR USE WITH CONSTRAINT
 18
 EMPTY-NUMEXPR-CONSTRAINT-LABEL: EMPTY NUMEXPR USE WITH CONSTRAINT
 EMPTY-NUMEXPR-CONSTRAINT-NEXT: [[# ==]]
-EMPTY-NUMEXPR-CONSTRAINT-MSG: numeric-expression.txt:[[#@LINE-1]]:38: error: empty numeric expression should not have a constraint
+EMPTY-NUMEXPR-CONSTRAINT-MSG: numeric-expressions.txt:[[#@LINE-1]]:38: error: empty numeric expression should not have a constraint
 EMPTY-NUMEXPR-CONSTRAINT-MSG-NEXT: {{E}}MPTY-NUMEXPR-CONSTRAINT-NEXT: {{\[\[# ==\]\]}}
 EMPTY-NUMEXPR-CONSTRAINT-MSG-NEXT:     {{^}}                                     ^{{$}}
 
 ; Definition from empty numeric expression with matching constraint.
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck --check-prefix EMPTY-NUMDEF-CONSTRAINT --input-file %s %s 2>&1 \
 RUN:   | FileCheck --check-prefix EMPTY-NUMDEF-CONSTRAINT-MSG %s
 
 EMPTY NUMEXPR DEF WITH CONSTRAINT
 18
 EMPTY-NUMDEF-CONSTRAINT-LABEL: EMPTY NUMEXPR CONSTRAINT
 EMPTY-NUMDEF-CONSTRAINT-NEXT: [[#VARDEF: ==]]
-EMPTY-NUMDEF-CONSTRAINT-MSG: numeric-expression.txt:[[#@LINE-1]]:44: error: empty numeric expression should not have a constraint
+EMPTY-NUMDEF-CONSTRAINT-MSG: numeric-expressions.txt:[[#@LINE-1]]:44: error: empty numeric expression should not have a constraint
 EMPTY-NUMDEF-CONSTRAINT-MSG-NEXT: {{E}}MPTY-NUMDEF-CONSTRAINT-NEXT: {{\[\[#VARDEF: ==\]\]}}
 EMPTY-NUMDEF-CONSTRAINT-MSG-NEXT:     {{^}}                                           ^{{$}}
 
 ; Numeric expressions with matching format overriding the implicit format of
 ; variables defined on other lines.
 USE CONV FMT IMPL MATCH  // CHECK-LABEL: USE CONV FMT IMPL MATCH
 b   // CHECK-NEXT: {{^}}[[# %x, UNSI]]
 B   // CHECK-NEXT: {{^}}[[# %X, UNSI]]

 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck --check-prefixes CHECK,FMT-CONFLICT2 --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix FMT-CONFLICT2-MSG %s
 
 VAR USE IMPL FMT CONFLICT
 23
 FMT-CONFLICT1-LABEL: VAR USE IMPL FMT CONFLICT
 FMT-CONFLICT1-NEXT: [[#UNSI + LHEX]]
-FMT-CONFLICT1-MSG: numeric-expression.txt:[[#@LINE-1]]:24: error: implicit format conflict between 'UNSI' (%u) and 'LHEX' (%x), need an explicit format specifier
+FMT-CONFLICT1-MSG: numeric-expressions.txt:[[#@LINE-1]]:24: error: implicit format conflict between 'UNSI' (%u) and 'LHEX' (%x), need an explicit format specifier
 FMT-CONFLICT1-MSG-NEXT: {{F}}MT-CONFLICT1-NEXT: {{\[\[#UNSI \+ LHEX\]\]}}
 FMT-CONFLICT1-MSG-NEXT: {{^                       \^$}}
 
 VAR USE IMPL FMT CONFLICT COMPLEX
 34
 FMT-CONFLICT2-LABEL: VAR USE IMPL FMT CONFLICT
 FMT-CONFLICT2-NEXT: [[#UNSI + UNSIa + LHEX]]
-FMT-CONFLICT2-MSG: numeric-expression.txt:[[#@LINE-1]]:24: error: implicit format conflict between 'UNSI + UNSIa' (%u) and 'LHEX' (%x), need an explicit format specifier
+FMT-CONFLICT2-MSG: numeric-expressions.txt:[[#@LINE-1]]:24: error: implicit format conflict between 'UNSI + UNSIa' (%u) and 'LHEX' (%x), need an explicit format specifier
 FMT-CONFLICT2-MSG-NEXT: {{F}}MT-CONFLICT2-NEXT: {{\[\[#UNSI \+ UNSIa \+ LHEX\]\]}}
 FMT-CONFLICT2-MSG-NEXT: {{^                       \^$}}
 
 ; Explicitly specified format can override conflicting implicit formats.
 VAR USE IMPL OVERRIDE FMT CONFLICT  // CHECK-LABEL: VAR USE IMPL OVERRIDE FMT CONFLICT
 23  // CHECK-NEXT: {{^}}[[# %u, UNSI + LHEX]]
 
 ; Numeric expressions using more than one variable defined on other lines.

 RUN: not FileCheck -D#NUMVAR=10 --check-prefix PAREN-OP \
 RUN:               --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix PAREN-OP-MSG %s
 
 PAREN EXPRESSIONS // PAREN-OP-LABEL: PAREN EXPRESSIONS
 11  // PAREN-OP-NEXT: [[#(NUMVAR+2)-1]]
 11  // PAREN-OP-NEXT: [[#NUMVAR+(2-1)]]
 11  // PAREN-OP-NEXT: [[#NUMVAR+(2-1]]
-PAREN-OP-MSG: numeric-expression.txt:[[#@LINE-1]]:36: error: missing ')' at end of nested expression
+PAREN-OP-MSG: numeric-expressions.txt:[[#@LINE-1]]:36: error: missing ')' at end of nested expression
 PAREN-OP-MSG-NEXT: {{P}}AREN-OP-NEXT: {{\[\[#NUMVAR\+\(2\-1]\]}}
 PAREN-OP-MSG-NEXT: {{^}}                                   ^{{$}}
 
 ; Numeric expression using undefined variables.
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck --check-prefix UNDEF-USE --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix UNDEF-USE-MSG %s
 
 UNDEF VAR USE
 UNDEFVAR: 11
 UNDEF-USE-LABEL: UNDEF VAR USE
 UNDEF-USE-NEXT: UNDEFVAR: [[#UNDEFVAR1+UNDEFVAR2]]
-UNDEF-USE-MSG:      numeric-expression.txt:[[#@LINE-1]]:30: error: undefined variable: UNDEFVAR1
+UNDEF-USE-MSG:      numeric-expressions.txt:[[#@LINE-1]]:30: error: undefined variable: UNDEFVAR1
 UNDEF-USE-MSG-NEXT:      {{U}}NDEF-USE-NEXT: {{U}}NDEFVAR: {{\[\[#UNDEFVAR1\+UNDEFVAR2\]\]}}
 UNDEF-USE-MSG-NEXT:             {{^}}                             ^{{$}}
-UNDEF-USE-MSG-NEXT:      numeric-expression.txt:[[#@LINE-4]]:40: error: undefined variable: UNDEFVAR2
+UNDEF-USE-MSG-NEXT:      numeric-expressions.txt:[[#@LINE-4]]:40: error: undefined variable: UNDEFVAR2
 UNDEF-USE-MSG-NEXT:      {{U}}NDEF-USE-NEXT: {{U}}NDEFVAR: {{\[\[#UNDEFVAR1\+UNDEFVAR2\]\]}}
 UNDEF-USE-MSG-NEXT:              {{^}}                                       ^{{$}}
 
 ; Numeric expression in negative directive using undefined variables.
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck --check-prefix UNDEF-USE2 --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix UNDEF-USE-MSG2 %s
 
 CHECK NOT UNDEF VAR USE
 END MARKER
 UNDEF-USE2-LABEL: CHECK NOT UNDEF VAR USE
 UNDEF-USE2-NOT: UNDEFVAR: [[#UNDEFVAR1+UNDEFVAR2]]
 UNDEF-USE2: END MARKER
-UNDEF-USE-MSG2:      numeric-expression.txt:[[#@LINE-2]]:30: error: undefined variable: UNDEFVAR1
+UNDEF-USE-MSG2:      numeric-expressions.txt:[[#@LINE-2]]:30: error: undefined variable: UNDEFVAR1
 UNDEF-USE-MSG2-NEXT:      {{U}}NDEF-USE2-NOT: {{U}}NDEFVAR: {{\[\[#UNDEFVAR1\+UNDEFVAR2\]\]}}
 UNDEF-USE-MSG2-NEXT:             {{^}}                             ^{{$}}
-UNDEF-USE-MSG2-NEXT:      numeric-expression.txt:[[#@LINE-5]]:40: error: undefined variable: UNDEFVAR2
+UNDEF-USE-MSG2-NEXT:      numeric-expressions.txt:[[#@LINE-5]]:40: error: undefined variable: UNDEFVAR2
 UNDEF-USE-MSG2-NEXT:      {{U}}NDEF-USE2-NOT: {{U}}NDEFVAR: {{\[\[#UNDEFVAR1\+UNDEFVAR2\]\]}}
 UNDEF-USE-MSG2-NEXT:              {{^}}                                       ^{{$}}
 
 ; Numeric expression with unsupported operator.
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck -D#NUMVAR=10 --check-prefix INVAL-OP \
 RUN:               --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix INVAL-OP-MSG %s
 
 INVALID OPERATOR
 NUMVAR*2: 22
 INVAL-OP-LABEL: INVALID OPERATOR
 INVAL-OP-NEXT: NUMVAR*2: [[#NUMVAR*2]]
-INVAL-OP-MSG: numeric-expression.txt:[[#@LINE-1]]:35: error: unsupported operation '*'
+INVAL-OP-MSG: numeric-expressions.txt:[[#@LINE-1]]:35: error: unsupported operation '*'
 INVAL-OP-MSG-NEXT: {{I}}NVAL-OP-NEXT: NUMVAR*2: {{\[\[#NUMVAR\*2\]\]}}
 INVAL-OP-MSG-NEXT:     {{^}}                                  ^{{$}}
 
 ; Name conflict between Numeric variable definition and string variable
 ; definition whether from the command-line or input text.
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck --check-prefixes CONFLICT,CONFLICT1,CONFLICT2 \
 RUN:               --input-file %s %s 2>&1 \

 redef1 42
 foobar
 redef2 42
 CONFLICT-LABEL: STRVAR NUMVAR CONFLICT
 CONFLICT1-NEXT: redef1 [[#NUMVAR:]]
 CONFLICT2: [[NUMVAR:foo.*]]
 CONFLICT3: [[STRVAR:foo.*]]
 CONFLICT4: redef2 [[#STRVAR:]]
-INPUT-STR-CONFLICT: numeric-expression.txt:[[#@LINE-3]]:14: error: numeric variable with name 'NUMVAR' already exists
+INPUT-STR-CONFLICT: numeric-expressions.txt:[[#@LINE-3]]:14: error: numeric variable with name 'NUMVAR' already exists
 INPUT-STR-CONFLICT-NEXT: {{C}}ONFLICT2: {{\[\[NUMVAR:foo\.\*\]\]}}
 INPUT-STR-CONFLICT-NEXT:    {{^}}             ^{{$}}
 CLI-STR-CONFLICT: Global defines:2:19: error: numeric variable with name 'NUMVAR' already exists
 CLI-STR-CONFLICT-NEXT:      Global define #2: NUMVAR=foobar
 CLI-STR-CONFLICT-NEXT: {{^}}                  ^{{$}}
-INPUT-NUM-CONFLICT: numeric-expression.txt:[[#@LINE-7]]:22: error: string variable with name 'STRVAR' already exists
+INPUT-NUM-CONFLICT: numeric-expressions.txt:[[#@LINE-7]]:22: error: string variable with name 'STRVAR' already exists
  INPUT-NUM-CONFLICT-NEXT: CONFLICT4: redef2 {{\[\[#STRVAR:\]\]}}
 INPUT-NUM-CONFLICT-NEXT: {{^}}                     ^{{$}}
 CLI-NUM-CONFLICT: Global defines:2:45: error: string variable with name 'STRVAR' already exists
  CLI-NUM-CONFLICT-NEXT: Global define #2: #STRVAR=42 (parsed as: {{\[\[#STRVAR:42\]\]}})
 CLI-NUM-CONFLICT-NEXT: {{^}}                                            ^{{$}}
 
 ; Numeric variable definition with too big value.
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck --check-prefix BIGVAL --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix BIGVAL-MSG %s
 
 BIG VALUE
 NUMVAR: 10000000000000000000000
 BIGVAL-LABEL: BIG VALUE
 BIGVAL-NEXT: NUMVAR: [[#NUMVAR:]]
-BIGVAL-MSG: numeric-expression.txt:[[#@LINE-3]]:9: error: unable to represent numeric value
+BIGVAL-MSG: numeric-expressions.txt:[[#@LINE-3]]:9: error: unable to represent numeric value
  BIGVAL-MSG-NEXT: {{N}}UMVAR: 10000000000000000000000
 BIGVAL-MSG-NEXT: {{^}}        ^{{$}}
 
 ; Verify that when a variable is set to an expression the expression is still
 ; checked.
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck --check-prefix DEF-EXPR-FAIL --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix DEF-EXPR-FAIL-MSG %s
 
 DEF EXPR WRONG MATCH
 20
 43
 DEF-EXPR-FAIL-LABEL: DEF EXPR WRONG MATCH
 DEF-EXPR-FAIL-NEXT: [[# VAR20:]]
 DEF-EXPR-FAIL-NEXT: [[# VAR42: VAR20+22]]
-DEF-EXPR-FAIL-MSG: numeric-expression.txt:[[#@LINE-1]]:21: error: {{D}}EF-EXPR-FAIL-NEXT: is not on the line after the previous match
+DEF-EXPR-FAIL-MSG: numeric-expressions.txt:[[#@LINE-1]]:21: error: {{D}}EF-EXPR-FAIL-NEXT: is not on the line after the previous match
 DEF-EXPR-FAIL-MSG-NEXT: {{D}}EF-EXPR-FAIL-NEXT: {{\[\[# VAR42: VAR20\+22\]\]}}
 DEF-EXPR-FAIL-MSG-NEXT:   {{^}}                    ^{{$}}
 
-; Verify that using a numeric variable defined on the same line (whether from
-; input or from an expression) is rejected.
-RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck --check-prefix SAME-LINE-USE1 --input-file %s %s 2>&1 \
-RUN:   | FileCheck --strict-whitespace --check-prefix SAME-LINE-USE-MSG1 %s
-RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck --check-prefix SAME-LINE-USE2 --input-file %s %s 2>&1 \
-RUN:   | FileCheck --strict-whitespace --check-prefix SAME-LINE-USE-MSG2 %s
-
-SAME LINE USE
-3
-4 5
-SAME-LINE-USE1-LABEL: SAME LINE USE
-SAME-LINE-USE1-NEXT: [[#]]
-SAME-LINE-USE1-NEXT: [[#UNSI:]] [[#UNSI+1]]
-SAME-LINE-USE-MSG1: numeric-expression.txt:[[#@LINE-1]]:36: error: numeric variable 'UNSI' defined earlier in the same CHECK directive
-SAME-LINE-USE-MSG1-NEXT: {{S}}AME-LINE-USE1-NEXT: {{\[\[#UNSI:\]\] \[\[#UNSI\+1\]\]}}
-SAME-LINE-USE-MSG1-NEXT:        {{^}}                                   ^{{$}}
-
-SAME-LINE-USE2-LABEL: SAME LINE USE
-SAME-LINE-USE2-NEXT: [[#UNSI:]]
-SAME-LINE-USE2-NEXT: [[#UNSI2:UNSI+1]] [[#UNSI2+1]]
-SAME-LINE-USE-MSG2: numeric-expression.txt:[[#@LINE-1]]:43: error: numeric variable 'UNSI2' defined earlier in the same CHECK directive
-SAME-LINE-USE-MSG2-NEXT: {{S}}AME-LINE-USE2-NEXT: {{\[\[#UNSI2:UNSI\+1\]\] \[\[#UNSI2\+1\]\]}}
-SAME-LINE-USE-MSG2-NEXT:        {{^}}                                          ^{{$}}
-
 ; Invalid change of format in variable redefinition.
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck --check-prefix REDEF-NEW-FMT --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix REDEF-NEW-FMT-MSG %s
 
 VAR REDEF FMT CHANGE
 22
 DC
 REDEF-NEW-FMT-LABEL: VAR REDEF FMT CHANGE
 REDEF-NEW-FMT-NEXT: [[#UNSI:]]
 REDEF-NEW-FMT-NEXT: [[#%X,UNSI:]]
-REDEF-NEW-FMT-MSG: numeric-expression.txt:[[#@LINE-1]]:31: error: format different from previous variable definition
+REDEF-NEW-FMT-MSG: numeric-expressions.txt:[[#@LINE-1]]:31: error: format different from previous variable definition
 REDEF-NEW-FMT-MSG-NEXT: {{R}}EDEF-NEW-FMT-NEXT: {{\[\[#%X,UNSI:\]\]}}
 REDEF-NEW-FMT-MSG-NEXT:    {{^}}                              ^{{$}}
 
 ; Numeric expression with overflow.
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck --check-prefix OVERFLOW --input-file %s %s 2>&1 \
 RUN:   | FileCheck --check-prefix OVERFLOW-MSG --strict-whitespace %s
 
 OVERFLOW
 BIGVAR=10000000000000000
 OVERFLOW-LABEL: OVERFLOW
 OVERFLOW-NEXT: BIGVAR: [[#BIGVAR:0x8000000000000000+0x8000000000000000]]
-OVERFLOW-MSG: numeric-expression.txt:[[#@LINE-1]]:27: error: unable to substitute variable or numeric expression
+OVERFLOW-MSG: numeric-expressions.txt:[[#@LINE-1]]:27: error: unable to substitute variable or numeric expression
 OVERFLOW-MSG-NEXT: {{O}}VERFLOW-NEXT: BIGVAR: {{\[\[#BIGVAR:0x8000000000000000\+0x8000000000000000\]\]}}
 OVERFLOW-MSG-NEXT:    {{^}}                          ^{{$}}
 
 ; Numeric expression with underflow.
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck --check-prefix UNDERFLOW --input-file %s %s 2>&1 \
 RUN:   | FileCheck --check-prefix UNDERFLOW-MSG --strict-whitespace %s
 
 UNDERFLOW
 TINYVAR=-10000000000000000
 UNDERFLOW-LABEL: UNDERFLOW
 UNDERFLOW-NEXT: TINYVAR: [[#%d,TINYVAR:-0x8000000000000000-0x8000000000000000]]
-UNDERFLOW-MSG: numeric-expression.txt:[[#@LINE-1]]:29: error: unable to substitute variable or numeric expression
+UNDERFLOW-MSG: numeric-expressions.txt:[[#@LINE-1]]:29: error: unable to substitute variable or numeric expression
 UNDERFLOW-MSG-NEXT: {{U}}NDERFLOW-NEXT: TINYVAR: {{\[\[#%d,TINYVAR:-0x8000000000000000-0x8000000000000000\]\]}}
 UNDERFLOW-MSG-NEXT:    {{^}}                            ^{{$}}
 
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck -D#NUMVAR=10 --check-prefix CALL-MISSING-CLOSING-BRACKET --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix CALL-MISSING-CLOSING-BRACKET-MSG %s
 
 CALL MISSING CLOSING BRACKET
 30
 CALL-MISSING-CLOSING-BRACKET-LABEL: CALL MISSING CLOSING BRACKET
 CALL-MISSING-CLOSING-BRACKET-NEXT: [[#add(NUMVAR,3]]
-CALL-MISSING-CLOSING-BRACKET-MSG: numeric-expression.txt:[[#@LINE-1]]:51: error: missing ')' at end of call expression
+CALL-MISSING-CLOSING-BRACKET-MSG: numeric-expressions.txt:[[#@LINE-1]]:51: error: missing ')' at end of call expression
 CALL-MISSING-CLOSING-BRACKET-MSG-NEXT: {{C}}ALL-MISSING-CLOSING-BRACKET-NEXT: {{\[\[#add\(NUMVAR,3\]\]}}
 CALL-MISSING-CLOSING-BRACKET-MSG-NEXT:      {{^}}                                                  ^{{$}}
 
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck -D#NUMVAR=10 --check-prefix CALL-MISSING-ARGUMENT --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix CALL-MISSING-ARGUMENT-MSG %s
 
 CALL MISSING ARGUMENT
 30
 CALL-MISSING-ARGUMENT-LABEL: CALL MISSING ARGUMENT
 CALL-MISSING-ARGUMENT-NEXT: [[#add(NUMVAR,)]]
-CALL-MISSING-ARGUMENT-MSG: numeric-expression.txt:[[#@LINE-1]]:43: error: missing argument
+CALL-MISSING-ARGUMENT-MSG: numeric-expressions.txt:[[#@LINE-1]]:43: error: missing argument
 CALL-MISSING-ARGUMENT-MSG-NEXT: {{C}}ALL-MISSING-ARGUMENT-NEXT: {{\[\[#add\(NUMVAR,\)\]\]}}
 CALL-MISSING-ARGUMENT-MSG-NEXT:      {{^}}                                          ^{{$}}
 
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck -D#NUMVAR=10 --check-prefix CALL-WRONG-ARGUMENT-COUNT --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix CALL-WRONG-ARGUMENT-COUNT-MSG %s
 
 CALL WRONG ARGUMENT COUNT
 30
 CALL-WRONG-ARGUMENT-COUNT-LABEL: CALL WRONG ARGUMENT COUNT
 CALL-WRONG-ARGUMENT-COUNT-NEXT: [[#add(NUMVAR)]]
-CALL-WRONG-ARGUMENT-COUNT-MSG: numeric-expression.txt:[[#@LINE-1]]:36: error: function 'add' takes 2 arguments but 1 given
+CALL-WRONG-ARGUMENT-COUNT-MSG: numeric-expressions.txt:[[#@LINE-1]]:36: error: function 'add' takes 2 arguments but 1 given
 CALL-WRONG-ARGUMENT-COUNT-MSG-NEXT: {{C}}ALL-WRONG-ARGUMENT-COUNT-NEXT: {{\[\[#add\(NUMVAR\)\]\]}}
 CALL-WRONG-ARGUMENT-COUNT-MSG-NEXT:    {{^}}                                   ^{{$}}
 
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck -D#NUMVAR=10 --check-prefix CALL-UNDEFINED-FUNCTION --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix CALL-UNDEFINED-FUNCTION-MSG %s
 
 CALL UNDEFINED FUNCTION
 30
 CALL-UNDEFINED-FUNCTION-LABEL: CALL UNDEFINED FUNCTION
 CALL-UNDEFINED-FUNCTION-NEXT: [[#bogus_function(NUMVAR)]]
-CALL-UNDEFINED-FUNCTION-MSG: numeric-expression.txt:[[#@LINE-1]]:34: error: call to undefined function 'bogus_function'
+CALL-UNDEFINED-FUNCTION-MSG: numeric-expressions.txt:[[#@LINE-1]]:34: error: call to undefined function 'bogus_function'
 CALL-UNDEFINED-FUNCTION-MSG-NEXT: {{C}}ALL-UNDEFINED-FUNCTION-NEXT: {{\[\[#bogus_function\(NUMVAR\)\]\]}}
 CALL-UNDEFINED-FUNCTION-MSG-NEXT:    {{^}}                                 ^{{$}}

llvm/test/FileCheck/numeric-expressions/same-line-var-use.txt

+RUN: FileCheck --check-prefixes=CHECK,LABELS --input-file %s %s
+
+; Verify that a CHECK directive using a variable defined for the first time on
+; the same line matches valid input with no ambiguity.
+FIRST DEF SIMPLE CASE  // LABELS-LABEL: FIRST DEF SIMPLE CASE
+13 14  // CHECK-NEXT: [[#UNSI:]] [[#UNSI+1]]
+
+; Verify that incorrect values for uses of variable defined for the first time
+; on the same line are rejected.
+RUN: %ProtectFileCheckOutput \
+RUN: not FileCheck --check-prefixes=LABELS,SAME-LINE-FAIL --input-file %s %s 2>&1 \
+RUN:   | FileCheck --strict-whitespace --check-prefixes=SAME-LINE-FAIL-MSG %s
+
+FIRST DEF FAIL
+4 6
+LABELS-LABEL: FIRST DEF FAIL
+SAME-LINE-FAIL-NEXT: [[#UNSI:]] [[#UNSI+1]]
+SAME-LINE-FAIL-MSG: same-line-var-use.txt:[[#@LINE-1]]:22: error: {{S}}AME-LINE-FAIL-NEXT: expected string not found in input
+SAME-LINE-FAIL-MSG-NEXT: {{S}}AME-LINE-FAIL-NEXT: {{\[\[#UNSI:\]\] \[\[#UNSI\+1\]\]}}
+SAME-LINE-FAIL-MSG-NEXT:   {{^}}                     ^{{$}}
+
+; Using a variable defined for the first time on the same line can lead to
+; match failure for input that satisfy the constraint.
+RUN: %ProtectFileCheckOutput \
+RUN: not FileCheck --check-prefixes=LABELS,SAME-LINE-FALSE-NEG --input-file %s %s 2>&1 \
+RUN:   | FileCheck --strict-whitespace --check-prefixes=SAME-LINE-FALSE-NEG-MSG %s
+
+SAME LINE FALSE NEGATIVE
+13 15 16
+LABELS-LABEL: SAME LINE FALSE NEGATIVE
+SAME-LINE-FALSE-NEG-NEXT: [[#UNSI:]] [[#UNSI+1]]
+SAME-LINE-FALSE-NEG-MSG: same-line-var-use.txt:[[#@LINE-1]]:27: error: {{S}}AME-LINE-FALSE-NEG-NEXT: expected string not found in input
+SAME-LINE-FALSE-NEG-MSG-NEXT: {{S}}AME-LINE-FALSE-NEG-NEXT: {{\[\[#UNSI:\]\] \[\[#UNSI\+1\]\]}}
+SAME-LINE-FALSE-NEG-MSG-NEXT:   {{^}}                          ^{{$}}
+
+; Verify that CHECK-NOT are not allowed to use a variable defined from an
+; empty expression on the same line.
+RUN: %ProtectFileCheckOutput \
+RUN: not FileCheck --check-prefixes=LABELS,SAME-LINE-NOT-KO --input-file %s %s 2>&1 \
+RUN:   | FileCheck --strict-whitespace --check-prefix SAME-LINE-NOT-KO-MSG %s
+SAME LINE NOT FORBIDDEN
+2 4
+LABELS-LABEL: SAME LINE NOT FORBIDDEN
+SAME-LINE-NOT-KO-NOT: [[#UNSI:]] [[#UNSI+1]]
+SAME-LINE-NOT-KO-MSG: same-line-var-use.txt:[[#@LINE-1]]:37: error: unknown variable value at match time
+SAME-LINE-NOT-KO-MSG-NEXT: {{S}}AME-LINE-NOT-KO-NOT: {{\[\[#UNSI:\]\] \[\[#UNSI\+1\]\]}}
+SAME-LINE-NOT-KO-MSG-NEXT:   {{^}}                                    ^{{$}}
+
+; Verify that a CHECK directive using a variable defined on the same line also
+; already defined on a previous line matches valid input with no ambiguity.
+ALREADY DEF SIMPLE CASE  // CHECK-LABEL: ALREADY DEF SIMPLE CASE
+13        // CHECK-NEXT: [[#UNSI:]]
+14 15     // CHECK-NEXT: [[#UNSI:]] [[#UNSI+1]]
+14 15 16  // CHECK-NEXT: [[#UNSI]] [[#UNSI:]] [[#UNSI+1]]
+
+; Verify that a CHECK directive using a variable defined for the first time on
+; the same line from ; an expression that is known at match time matches valid
+; input even with ambiguity.
+FIRST DEF FROM EXPR  // CHECK-LABEL: FIRST DEF FROM EXPR
+13        // CHECK-NEXT: [[#UNSI1:]]
+14 15     // CHECK-NEXT: [[#UNSI2:UNSI1+1]] [[#UNSI2+1]]
+14 16 17  // CHECK-NEXT: [[#UNSI3:UNSI1+3]] [[#UNSI3+1]]
+
+; Verify that incorrect values for uses of variable defined for the first time
+; on the same line from an expression are rejected.
+RUN: %ProtectFileCheckOutput \
+RUN: not FileCheck --check-prefixes=LABELS,FROM-EXPR-FAIL --input-file %s %s 2>&1 \
+RUN:   | FileCheck --strict-whitespace --check-prefix FROM-EXPR-FAIL-MSG %s
+
+FROM EXPR FAIL
+3
+4 6
+LABELS-LABEL: FROM EXPR FAIL
+FROM-EXPR-FAIL-NEXT: [[#UNSI1:]]
+FROM-EXPR-FAIL-NEXT: [[#UNSI2:UNSI1+1]] [[#UNSI2+1]]
+FROM-EXPR-FAIL-MSG: same-line-var-use.txt:[[#@LINE-1]]:22: error: {{F}}ROM-EXPR-FAIL-NEXT: expected string not found in input
+FROM-EXPR-FAIL-MSG-NEXT: {{F}}ROM-EXPR-FAIL-NEXT: {{\[\[#UNSI2:UNSI1\+1\]\] \[\[#UNSI2\+1\]\]}}
+FROM-EXPR-FAIL-MSG-NEXT:   {{^}}                     ^{{$}}
+