FileCheck Enhancement - prefixes-regular expressions

[eklepilkina]

Summary

This patch adds opportunity to use regular expressions as prefix for writing one check string for several real prefixes.
Also there is wildcard prefix, if some statements should be checked regardless prefix.

[alexfh]

IIUC, there was no consensus about usefulness of this change.

docs/CommandGuide/FileCheck.rst

.. option:: --implicit-check-not check-pattern
   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:: -version
 
  Show the version number of this program.
 
+.. option:: --regex-prefixes
+
+ Enable option of using regular expressions as prefix in check strings.
+
 EXIT STATUS
 -----------
 
 If :program:`FileCheck` verifies that the file matches the expected contents,
 it exits with 0.  Otherwise, if not, or if an error occurs, it will exit with a
 non-zero value.
 
 TUTORIAL
.. code-block:: llvm
 
    ; X64: pinsrd_1:
    ; X64:    pinsrd $1, %edi, %xmm0
    }
 
 In this case, we're testing that we get the expected code generation with
 both 32-bit and 64-bit code generation.
 
+The FileCheck -regex-prefixes option
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The FileCheck :option:`-regex-prefixes` option allows use regular expressions 
+as prefixes for check strings. If you use different prefixes, checks for some 
+prefixes can be repeated, then if names of these prefixes will match same 
+regular expression, you can use regular expression without prefix.
+For example:
+
+.. code-block:: llvm
+
+    //{{ARC[0-9]*}}:
+
+It’s equal to
+
+.. code-block:: llvm
+
+    //ARC:
+    //ARC1:
+    //ARC23:
+
+and etc.
+
+Wildcard for prefixes
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+In FileCheck you can set your own prefixes for checking. If you use different 
+prefixes, but there are some checks, which should match with all prefixes, you 
+can used wildcard prefix {{*}}.
+
+For example
+
+.. code-block:: llvm
+
+    //{{*}}-SAME: {{[a-z]+}}
+
+It’s equal to
+
+.. code-block:: llvm
+
+    // A-WORD: {{[a-z]+}}
+    // B-WORD: {{[a-z]+}}
+
+and etc
+
+It will find match for this regex if you run FileCheck with any prefix.
+
+It’s necessary to use :option:`-regex-prefixes` option if you would like to have 
+this feature enable.
+
 The "CHECK-NEXT:" directive
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Sometimes you want to match lines and would like to verify that matches
 happen on exactly consecutive lines with no other lines in between them.  In
 this case, you can use "``CHECK:``" and "``CHECK-NEXT:``" directives to specify
 this.  If you specified a custom check prefix, just use "``<PREFIX>-NEXT:``".
 For example, something like this works as you'd expect:

test/FileCheck/check-regexp-prefix.txt

+// RUN: FileCheck -check-prefix=A -regex-prefixes -input-file %s %s
+// RUN: FileCheck -check-prefix=b -regex-prefixes -input-file %s %s
+
+for B check
+first
+next-line
+
+// {{[A-Z]+}}: first
+// {{[a-z0-9]+}}: for {{B}}
+
+
+// {{[A-C0-9]+}}-NEXT: {{next-line}}
+
+same for both
+// {{[A-Za-z0-9]+}}: same
+// {{[A-Za-z0-9]+}}-SAME: both

test/FileCheck/check-wildcard-prefix.txt

+// RUN: FileCheck -check-prefix=A -regex-prefixes -input-file %s %s
+// RUN: not FileCheck -check-prefix=B -regex-prefixes -input-file %s %s
+
+for B check
+first
+next-line
+// A: first
+// B: for B
+// {{*}}-NEXT: {{next-line}}
+
+same for both
+// {{*}}: same
+// {{*}}-SAME: both
 No newline at end of file

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>
+RegexPrefixesOn ("regex-prefixes",
+                 cl::desc("Use checks with prefixes which can be described as regular expressions."));
+
 typedef cl::list<std::string>::const_iterator prefix_iterator;
 
 //===----------------------------------------------------------------------===//
 // Pattern Handling Code.
 //===----------------------------------------------------------------------===//
 
 namespace Check {
   enum CheckType {
static StringRef FindFirstCandidateMatch(StringRef &Buffer,
   Check::CheckType FirstTy = Check::CheckNone;
 
   CheckTy = Check::CheckNone;
   CheckLoc = StringRef::npos;
 
   for (StringRef Prefix : CheckPrefixes) {
     size_t PrefixLoc = Buffer.find(Prefix);
 
+    if (RegexPrefixesOn) {
+      SmallVector<StringRef, 4> Matches;
+      // Try ti find prefixes defined as regexes.
+      Regex PrefixesWithRegexes(StringRef("\\{\\{(.+)\\}\\}(-.+)?:.+$"));
+      StringRef BufferCopy = Buffer;
+      size_t DiffInLoc = 0;
+      
+      while (PrefixesWithRegexes.match(BufferCopy, &Matches) &&
+             (DiffInLoc < PrefixLoc || PrefixLoc == StringRef::npos)) {
+        // Get regex part
+        StringRef RegexPart = Matches[1];
+        if (RegexPart.find("}}") != StringRef::npos) {
+          RegexPart = RegexPart.substr(0, RegexPart.find("}}"));
+        }
+
+        size_t RegexPrefixLoc = Matches[1].data() - BufferCopy.data();
+        DiffInLoc += RegexPrefixLoc;
+        // Check if current prefix matches with found.
+        if (Regex(RegexPart).match(Prefix)) {
+          if (DiffInLoc < PrefixLoc) {
+            PrefixLoc = DiffInLoc;
+            Prefix = StringRef(RegexPart.str() + "}}");
+          }
+        }
+
+        if (BufferCopy.find("\n", RegexPrefixLoc) != StringRef::npos) {
+          DiffInLoc += BufferCopy.find("\n", RegexPrefixLoc) - RegexPrefixLoc;
+          BufferCopy =
+              BufferCopy.drop_front(BufferCopy.find("\n", RegexPrefixLoc));
+        } else {
+          BufferCopy = BufferCopy.drop_front(RegexPrefixLoc);
+        }
+      }
+    }
+
     if (PrefixLoc == StringRef::npos)
       continue;
 
     // Track where we are searching for invalid prefixes that look almost right.
     // We need to only advance to the first partial match on the next attempt
     // since a partial match could be a substring of a later, valid prefix.
     // Need to skip to the end of the word, otherwise we could end up
     // matching a prefix in a substring later.
static bool ValidateCheckPrefixes() {
   return true;
 }
 
 // I don't think there's a way to specify an initial value for cl::list,
 // so if nothing was specified, add the default
 static void AddCheckPrefixIfNeeded() {
   if (CheckPrefixes.empty())
     CheckPrefixes.push_back("CHECK");
+  // Prefix wild-card which will be always matched.
+  if (RegexPrefixesOn)
+    if (std::find(CheckPrefixes.begin(), CheckPrefixes.end(), "{{*}}") ==
+        CheckPrefixes.end())
+      CheckPrefixes.push_back("{{*}}");
 }
 
 static void DumpCommandLine(int argc, char **argv) {
   errs() << "FileCheck command line: ";
   for (int I = 0; I < argc; I++)
     errs() << " " << argv[I];
   errs() << "\n";
 }