[FileCheck] Annotate input dump (3/7)

[jdenny]

Summary

This patch implements input annotations for diagnostics that report
wrong-line matches for the directives CHECK-NEXT, CHECK-SAME, and
CHECK-EMPTY. Instead of the usual ^~~, which is used by later
patches for good matches, these annotations use !~~ to mark the bad
match ranges so that this category of errors is visually distinct.
Because such matches are errors, these annotates are red when colors
are enabled.

For example:

$ FileCheck -dump-input=help
The following description was requested by -dump-input=help to
explain the input annotations printed by -dump-input=always and
-dump-input=fail:

  - L:     labels line number L of the input file
  - T:L    labels the only match result for a pattern of type T from line L of
           the check file
  - T:L'N  labels the Nth match result for a pattern of type T from line L of
           the check file
  - !~~    marks bad match, such as:
           - CHECK-NEXT on same line as previous match (error)
  - X~~    marks search range when no match is found, such as:
           - CHECK-NEXT not found (error)
  - ?      marks fuzzy match when no match is found
  - colors error, fuzzy match

If you are not seeing color above or in input dumps, try: -color

$ FileCheck -v -dump-input=always check2 < input2 |& sed -n '/^<<<</,$p'
<<<<<<
        1: foo bar
next:2         !~~ error: match on wrong line
>>>>>>

$ cat check2
CHECK: foo
CHECK-NEXT: bar

$ cat input2
foo bar

[jdenny]

Rebased onto updated patches earlier in series.

[jdenny]

Update for changes earlier in patch series.

[jdenny]

Propagate changes started earlier in patch series.

[jdenny]

Continue changes started earlier in patch series.

[probinson]

Comment issue, otherwise LGTM.

llvm/include/llvm/Support/FileCheck.h

148

Comments should be proper sentences.

[jdenny]

Adjust comment, as suggested by probinson.

llvm/include/llvm/Support/FileCheck.h

struct FileCheckDiag {
   ///
   /// There might be more than one of these for the same directive.  For
   /// example, there might be a fuzzy match after a fail.
   ///
   /// We iterate these types, so they must have contiguous values in
   /// [0, MatchTypeCount).
   enum MatchType {
     // TODO: More members will appear with later patches in this series.
+    MatchFinalButIllegal,  //< the final but illegal match for an expected pattern
+    MatchTypeFirst = MatchFinalButIllegal,
     MatchNoneButExpected,  //< no match for an expected pattern
-    MatchTypeFirst = MatchNoneButExpected,
     MatchFuzzy,            //< a fuzzy match (because no perfect match)
     MatchTypeCount,
   } MatchTy;
   /// The match range if MatchTy is not MatchNoneButExpected, or the search
   /// range otherwise.
   unsigned InputStartLine, InputStartCol, InputEndLine, InputEndCol;
   FileCheckDiag(const SourceMgr &SM, const Check::FileCheckType &CheckTy,
                 SMLoc CheckLoc, MatchType MatchTy, SMRange InputRange);

llvm/lib/Support/FileCheck.cpp

size_t FileCheckString::Check(const SourceMgr &SM, StringRef Buffer,
 
   // Similar to the above, in "label-scan mode" we can't yet handle CHECK-NEXT
   // or CHECK-NOT
   if (!IsLabelScanMode) {
     StringRef SkippedRegion = Buffer.substr(LastPos, MatchPos);
 
     // If this check is a "CHECK-NEXT", verify that the previous match was on
     // the previous line (i.e. that there is one newline between them).
-    if (CheckNext(SM, SkippedRegion))
+    if (CheckNext(SM, SkippedRegion)) {
+      ProcessMatchResult(FileCheckDiag::MatchFinalButIllegal, SM, Loc,
+                         Pat.getCheckTy(), MatchBuffer, MatchPos, MatchLen,
+                         Diags);
       return StringRef::npos;
+    }
 
     // If this check is a "CHECK-SAME", verify that the previous match was on
     // the same line (i.e. that there is no newline between them).
-    if (CheckSame(SM, SkippedRegion))
+    if (CheckSame(SM, SkippedRegion)) {
+      ProcessMatchResult(FileCheckDiag::MatchFinalButIllegal, SM, Loc,
+                         Pat.getCheckTy(), MatchBuffer, MatchPos, MatchLen,
+                         Diags);
       return StringRef::npos;
+    }
 
     // If this match had "not strings", verify that they don't exist in the
     // skipped region.
     if (CheckNot(SM, SkippedRegion, NotStrings, VariableTable, Req))
       return StringRef::npos;
   }
 
   return LastPos + MatchPos;

llvm/test/FileCheck/dump-input-annotations.txt

 ; CHK-NEXT:   check:2'0     X~~~~
 ; CHK-NEXT:              3: whirled
 ; CHK-NEXT:   check:2'0     ~~~~~~~
 ; CHK-NEXT:   check:2'1     ?
 ; CHK-NEXT:   >>>>>>
 ; CHK-NOT:    {{.}}
 
 ;--------------------------------------------------
-; CHECK-NEXT (also: EOF search-range)
+; CHECK-NEXT (also: EOF search-range, illegal match)
 ;--------------------------------------------------
 
 ; Good match and no match.
 
 ; RUN: echo 'hello' > %t.in
 ; RUN: echo 'again' >> %t.in
 
 ; RUN: echo 'CHECK: hello' > %t.chk

 ; NXT:        <<<<<<
 ; NXT-NEXT:           1: hello
 ; NXT-NEXT:           2: again
 ; NXT-NEXT:           3:
 ; NXT-NEXT:   next:3     X
 ; NXT-NEXT:   >>>>>>
 ; NXT-NOT:    {{.}}
 
+; Illegal match.
+
+; RUN: echo 'yonder' >> %t.in
+; RUN: echo 'world' >> %t.in
+
+; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk 2>&1 \
+; RUN: | FileCheck -match-full-lines %s -check-prefix=NXT2
+
+; NXT2:      <<<<<<
+; NXT2-NEXT:         1: hello
+; NXT2-NEXT:         2: again
+; NXT2-NEXT:         3: yonder
+; NXT2-NEXT:         4: world
+; NXT2-NEXT: next:3     !~~~~
+; NXT2-NEXT: >>>>>>
+; NXT2-NOT:  {{.}}
+
 ;--------------------------------------------------
-; CHECK-SAME (also: single-char search range)
+; CHECK-SAME (also: single-char search range, illegal match)
 ;--------------------------------------------------
 
 ; Good match and no match.
 
 ; RUN: echo 'hello world!' > %t.in
 
 ; RUN: echo 'CHECK: hello' > %t.chk
 ; RUN: echo 'CHECK-SAME: world' >> %t.chk
 ; RUN: echo 'CHECK-SAME: again' >> %t.chk
 
 ; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk 2>&1 \
 ; RUN: | FileCheck -match-full-lines %s -check-prefix=SAM
 ; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -v 2>&1 \
 ; RUN: | FileCheck -match-full-lines %s -check-prefixes=SAM,SAM-V
 ; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -vv 2>&1 \
 ; RUN: | FileCheck -match-full-lines %s -check-prefixes=SAM,SAM-V,SAM-VV
 
 ; SAM:        <<<<<<
 ; SAM-NEXT:           1: hello world!
 ; SAM-NEXT:   same:3                X
 ; SAM-NEXT:   >>>>>>
 ; SAM-NOT:    {{.}}
 
+; Illegal match.
+
+; RUN: echo 'again' >> %t.in
+
+; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -v 2>&1 \
+; RUN: | FileCheck -match-full-lines %s -check-prefixes=SAM2
+
+; SAM2:      <<<<<<
+; SAM2-NEXT:          1: hello world!
+; SAM2-NEXT:          2: again
+; SAM2-NEXT: same:3      !~~~~
+; SAM2-NEXT: >>>>>>
+; SAM2-NOT:  {{.}}
+
 ;--------------------------------------------------
-; CHECK-EMPTY (also: search range ends at label)
+; CHECK-EMPTY (also: search range ends at label, illegal match)
 ;--------------------------------------------------
 
 ; Good match and no match.
 ;
 ; CHECK-EMPTY always seems to match an empty line at EOF (illegally when it's
 ; not the next line) unless either (1) the last line is non-empty and has no
 ; newline or (2) there's a CHECK-LABEL to end the search range before EOF.  We
 ; choose scenario 2 to check the case of no match.

 ; EMP-NEXT:            2:
 ; EMP-NEXT:            3: world
 ; EMP-NEXT:   empty:3     X~~~~
 ; EMP-NEXT:            4: label
 ; EMP-NEXT:   empty:3     ~~~~~
 ; EMP-NEXT:   >>>>>>
 ; EMP-NOT:    {{.}}
 
+; Illegal match.
+
+; RUN: echo 'hello' > %t.in
+; RUN: echo 'world' >> %t.in
+
+; RUN: echo 'CHECK: hello' > %t.chk
+; RUN: echo 'CHECK-EMPTY:' >> %t.chk
+
+; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk 2>&1 \
+; RUN: | FileCheck -match-full-lines %s -check-prefix=EMP2
+; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -v 2>&1 \
+; RUN: | FileCheck -match-full-lines %s -check-prefixes=EMP2,EMP2-V
+; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -vv 2>&1 \
+; RUN: | FileCheck -match-full-lines %s -check-prefixes=EMP2,EMP2-V,EMP2-VV
+
+; EMP2:        <<<<<<
+; EMP2-NEXT:            1: hello
+; EMP2-NEXT:            2: world
+; EMP2-NEXT:            3:
+; EMP2-NEXT:   empty:2     !
+; EMP2-NEXT:   >>>>>>
+; EMP2-NOT:    {{.}}
+
 ;--------------------------------------------------
 ; CHECK-DAG
 ;--------------------------------------------------
 
 ; Good match, discarded match plus good match, and no match.
 
 ; RUN: echo 'abc' > %t.in
 ; RUN: echo 'def' >> %t.in

llvm/utils/FileCheck/FileCheck.cpp

struct MatchTypeStyle {
   raw_ostream::Colors Color;
   const char *What;
   MatchTypeStyle(char Mark, raw_ostream::Colors Color, const char *What)
       : Mark(Mark), Color(Color), What(What) {}
 };
 
 static MatchTypeStyle GetMatchTypeStyle(unsigned MatchTy) {
   switch (MatchTy) {
+  case FileCheckDiag::MatchFinalButIllegal:
+    return MatchTypeStyle('!', raw_ostream::RED,
+                          "the final but illegal match for an expected "
+                          "pattern (e.g., CHECK-NEXT)");
   case FileCheckDiag::MatchNoneButExpected:
     return MatchTypeStyle('X', raw_ostream::RED,
                           "the search range for an unmatched expected "
                           "pattern (e.g., CHECK)");
   case FileCheckDiag::MatchFuzzy:
     return MatchTypeStyle('?', raw_ostream::MAGENTA,
                           "a fuzzy match start for an otherwise unmatched "
                           "pattern");
static void DumpInputAnnotationExplanation(raw_ostream &OS,
   OS << "  - ";
   WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "T:L'N";
   OS << "  labels the Nth match result for a pattern of type T from line "
      << "L of\n"
      << "           the check file\n";
 
   // Markers on annotation lines.
   OS << "  - ";
+  WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "!~~";
+  OS << "    marks bad match\n"
+     << "  - ";
   WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "X~~";
   OS << "    marks search range when no match is found\n"
      << "  - ";
   WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "?";
   OS << "      marks fuzzy match when no match is found\n";
 
   // Colors.
   if (WithColor(OS).colorsEnabled()) {