[FileCheck] Added --enable-var-scope option to enable scope for regex variables.

[tra]

Summary

This implements Hal's idea suggested in D30725.

If `--enable-var-scope` is in effect, variables with names that
start with $ are considered to be global. All others variables are
local. All local variables get undefined at the beginning of each
CHECK-LABEL block. Global variables are not affected by CHECK-LABEL.
This makes it easier to ensure that individual tests are not affected
by variables set in preceding tests.

The feature is not enabled by default as there are few hundred tests that depend on variables remaining set across CHECK-LABEL.
Once tests are cleaned up we can flip the flag to be enabled by default.

[jlebar]

docs/CommandGuide/FileCheck.rst

357 ↗

(On Diff #91051)

Nit, "blocks" aren't really a concept in FileCheck. Maybe we should just say "If `--enable-var-scope` is in effect, all local variables (i.e. variables that don't start with "$") are cleared when a CHECK-LABEL is encountered."

454 ↗

(On Diff #91051)

Same comment as above about "block".

utils/FileCheck/FileCheck.cpp

80 ↗

(On Diff #91051)

Same here about "block"

1285 ↗

(On Diff #91051)

No need for braces on this one.

[tra]

Removed unneeded {}

[tra]

docs/CommandGuide/FileCheck.rst

357 ↗

(On Diff #91051)

I've used the block because CHECK-LABEL documentation says (lines 353-355):

...the presence of ``CHECK-LABEL`` divides
the input stream into separate blocks, each of which is processed independently,
preventing a ``CHECK:`` directive in one block matching a line in another block.

I did start with a sentence along the lines of the one you've suggested, but decided to stick with blocks as it seems to be a better fit for something with 'scope'.

[jlebar]

Heh, that's what I get for not reading the existing docs. sgtm.

[hfinkel]

LGTM too.

llvm/trunk/docs/CommandGuide/FileCheck.rst

.. option:: --implicit-check-not check-pattern
   checks. The option allows writing stricter tests without stuffing them with
   ``CHECK-NOT``\ s.
 
   For example, "``--implicit-check-not warning:``" can be useful when testing
   diagnostic messages from tools that don't have an option similar to ``clang
   -verify``. With this option FileCheck will verify that input does not contain
   warnings not covered by any ``CHECK:`` patterns.
 
+.. option:: --enable-var-scope
+
+  Enables scope for regex variables.
+
+  Variables with names that start with ``$`` are considered global and
+  remain set throughout the file.
+
+  All other variables get undefined after each encountered ``CHECK-LABEL``.
+
 .. option:: -version
 
  Show the version number of this program.
 
 EXIT STATUS
 -----------
 
 If :program:`FileCheck` verifies that the file matches the expected contents,

 In order to produce better error messages in these cases, the "``CHECK-LABEL:``"
 directive can be used. It is treated identically to a normal ``CHECK``
 directive except that FileCheck makes an additional assumption that a line
 matched by the directive cannot also be matched by any other check present in
 ``match-filename``; this is intended to be used for lines containing labels or
 other unique identifiers. Conceptually, the presence of ``CHECK-LABEL`` divides
 the input stream into separate blocks, each of which is processed independently,
 preventing a ``CHECK:`` directive in one block matching a line in another block.
+If ``--enable-var-scope`` is in effect, all local variables are cleared at the
+beginning of the block.
+
 For example,
 
 .. code-block:: llvm
 
   define %struct.C* @C_ctor_base(%struct.C* %this, i32 %x) {
   entry:
   ; CHECK-LABEL: C_ctor_base:
   ; CHECK: mov [[SAVETHIS:r[0-9]+]], r0

 
 .. code-block:: llvm
 
     ; CHECK: op [[REG:r[0-9]+]], [[REG]]
 
 Can be useful if you want the operands of ``op`` to be the same register,
 and don't care exactly which register it is.
 
+If ``--enable-var-scope`` is in effect, variables with names that
+start with ``$`` are considered to be global. All others variables are
+local.  All local variables get undefined at the beginning of each
+CHECK-LABEL block. Global variables are not affected by CHECK-LABEL.
+This makes it easier to ensure that individual tests are not affected
+by variables set in preceding tests.
+
 FileCheck Expressions
 ~~~~~~~~~~~~~~~~~~~~~
 
 Sometimes there's a need to verify output which refers line numbers of the
 match file, e.g. when testing compiler diagnostics.  This introduces a certain
 fragility of the match file structure, as "``CHECK:``" lines contain absolute
 line numbers in the same file, which have to be updated whenever line numbers
 change due to text addition or deletion.

llvm/trunk/test/FileCheck/line-count.txt

 ; RUN: FileCheck  -input-file %s %s
-2
-3 aaa
-4 bbb
-5 ccc
-6 CHECK: [[@LINE-3]] {{a}}aa
-7 CHECK: [[@LINE-3]] {{b}}bb
-8 CHECK: [[@LINE-3]] {{c}}cc
-9 foobar
-10 CHECK: [[@LINE-1]] {{foo}}bar
-11
-12 arst CHECK: [[@LINE]] {{a}}rst
-13
+; RUN: not FileCheck -check-prefix BAD -input-file %s %s
+3
+4 aaa
+5 bbb
+6 ccc
+7 CHECK: [[@LINE-3]] {{a}}aa
+8 CHECK: [[@LINE-3]] {{b}}bb
+9 CHECK: [[@LINE-3]] {{c}}cc
+10 foobar
+11 CHECK: [[@LINE-1]] {{foo}}bar
+12
+13 arst CHECK: [[@LINE]] {{a}}rst
 14
-
+15 BAD: [[@LINE:cant-have-regex]]

llvm/trunk/test/FileCheck/regex-scope.txt

+// RUN: FileCheck -check-prefix CHECK -input-file %s %s
+// RUN: FileCheck -check-prefixes CHECK,GLOBAL -input-file %s %s
+// RUN: FileCheck -check-prefixes CHECK,LOCAL -input-file %s %s
+// RUN: FileCheck -check-prefixes CHECK,GLOBAL --enable-var-scope -input-file %s %s
+// RUN: not FileCheck -check-prefixes CHECK,LOCAL --enable-var-scope -input-file %s %s
+
+local
+global
+; CHECK: [[LOCAL:loc.*]]
+; CHECK: [[$GLOBAL:glo.*]]
+
+local2
+global2
+; CHECK: [[LOCAL]]2
+; CHECK: [[$GLOBAL]]2
+
+barrier:
+; CHECK-LABEL: barrier
+
+local3
+global3
+; LOCAL: [[LOCAL]]3
+; GLOBAL: [[$GLOBAL]]3

llvm/trunk/utils/FileCheck/FileCheck.cpp

cl::desc("Allow the input file to be empty. This is useful when making\n"
              "checks that some error message does not occur, for example."));
 
 static cl::opt<bool> MatchFullLines(
     "match-full-lines", cl::init(false),
     cl::desc("Require all positive matches to cover an entire input line.\n"
              "Allows leading and trailing whitespace if --strict-whitespace\n"
              "is not also passed."));
 
+static cl::opt<bool> EnableVarScope(
+    "enable-var-scope", cl::init(false),
+    cl::desc("Enables scope for regex variables. Variables with names that\n"
+             "do not start with '$' will be reset at the beginning of\n"
+             "each CHECK-LABEL block."));
+
 typedef cl::list<std::string>::const_iterator prefix_iterator;
 
 //===----------------------------------------------------------------------===//
 // Pattern Handling Code.
 //===----------------------------------------------------------------------===//
 
 namespace Check {
 enum CheckType {
if (PatternStr.startswith("[[")) {
         return true;
       }
 
       // Verify that the name/expression is well formed. FileCheck currently
       // supports @LINE, @LINE+number, @LINE-number expressions. The check here
       // is relaxed, more strict check is performed in \c EvaluateExpression.
       bool IsExpression = false;
       for (unsigned i = 0, e = Name.size(); i != e; ++i) {
-        if (i == 0 && Name[i] == '@') {
+        if (i == 0) {
+          if (Name[i] == '$')  // Global vars start with '$'
+            continue;
+          if (Name[i] == '@') {
             if (NameEnd != StringRef::npos) {
               SM.PrintMessage(SMLoc::getFromPointer(Name.data()),
                               SourceMgr::DK_Error,
                               "invalid name in named regex definition");
               return true;
             }
             IsExpression = true;
             continue;
           }
+        }
         if (Name[i] != '_' && !isalnum(Name[i]) &&
             (!IsExpression || (Name[i] != '+' && Name[i] != '-'))) {
           SM.PrintMessage(SMLoc::getFromPointer(Name.data() + i),
                           SourceMgr::DK_Error, "invalid name in named regex");
           return true;
         }
       }
 

 
 static void DumpCommandLine(int argc, char **argv) {
   errs() << "FileCheck command line: ";
   for (int I = 0; I < argc; I++)
     errs() << " " << argv[I];
   errs() << "\n";
 }
 
+// Remove local variables from \p VariableTable. Global variables
+// (start with '$') are preserved.
+static void ClearLocalVars(StringMap<StringRef> &VariableTable) {
+  SmallVector<StringRef, 16> LocalVars;
+  for (const auto &Var : VariableTable)
+    if (Var.first()[0] != '$')
+      LocalVars.push_back(Var.first());
+
+  for (const auto &Var : LocalVars)
+    VariableTable.erase(Var);
+}
+
 /// Check the input to FileCheck provided in the \p Buffer against the \p
 /// CheckStrings read from the check file.
 ///
 /// Returns false if the input fails to satisfy the checks.
 bool CheckInput(SourceMgr &SM, StringRef Buffer,
                 ArrayRef<CheckString> CheckStrings) {
   bool ChecksFailed = false;
 
if (j == e) {
         // Immediately bail of CHECK-LABEL fails, nothing else we can do.
         return false;
 
       CheckRegion = Buffer.substr(0, MatchLabelPos + MatchLabelLen);
       Buffer = Buffer.substr(MatchLabelPos + MatchLabelLen);
       ++j;
     }
 
+    if (EnableVarScope)
+      ClearLocalVars(VariableTable);
+
     for (; i != j; ++i) {
       const CheckString &CheckStr = CheckStrings[i];
 
       // Check each string within the scanned region, including a second check
       // of any final CHECK-LABEL (to verify CHECK-NOT and CHECK-DAG)
       size_t MatchLen = 0;
       size_t MatchPos =
           CheckStr.Check(SM, CheckRegion, false, MatchLen, VariableTable);