[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

167 ↗

(On Diff #177383)

Comments should be proper sentences.

[jdenny]

Adjust comment, as suggested by probinson.

llvm/trunk/include/llvm/Support/FileCheck.h

struct FileCheckDiag {
   /// Where is the FileCheck directive for this diagnostic?
   unsigned CheckLine, CheckCol;
   /// What kind of match result does this diagnostic describe?
   ///
   /// There might be more than one of these for the same directive.  For
   /// example, there might be a fuzzy match after a fail.
   enum MatchType {
     // TODO: More members will appear with later patches in this series.
+    /// Indicates the final match for an expected pattern, but the match is on
+    /// the wrong line.
+    MatchFinalButWrongLine,
     /// Indicates no match for an expected pattern.
     MatchNoneButExpected,
     /// Indicates a possible intended match because there's no perfect match.
     MatchFuzzy,
     MatchTypeCount,
   } MatchTy;
   /// The match range if MatchTy is not MatchNoneButExpected, or the search
   /// range otherwise.

llvm/trunk/lib/Support/FileCheck.cpp

for (int i = 1; i <= Pat.getCount(); i++) {
     LastMatchEnd += MatchPos + CurrentMatchLen;
   }
   // Full match len counts from first match pos.
   MatchLen = LastMatchEnd - FirstMatchPos;
 
   // 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, FirstMatchPos - LastPos);
+    size_t MatchPos = FirstMatchPos - LastPos;
+    StringRef MatchBuffer = Buffer.substr(LastPos);
+    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::MatchFinalButWrongLine, 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::MatchFinalButWrongLine, 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 FirstMatchPos;

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

 ; CNT-NEXT:            1: pete
 ; CNT-NEXT:            2: repete
 ; CNT-NEXT:            3: repeat
 ; CNT-NEXT:   count:1     X~~~~~ error: no match found
 ; CNT-NEXT:   >>>>>>
 ; CNT-NOT:    {{.}}
 
 ;--------------------------------------------------
-; CHECK-NEXT (also: EOF search-range)
+; CHECK-NEXT (also: EOF search-range, wrong-line 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 error: no match found
 ; NXT-NEXT:   >>>>>>
 ; NXT-NOT:    {{.}}
 
+; Wrong-line 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     !~~~~ error: match on wrong line
+; NXT2-NEXT: >>>>>>
+; NXT2-NOT:  {{.}}
+
 ;--------------------------------------------------
-; CHECK-SAME (also: single-char search range)
+; CHECK-SAME (also: single-char search range, wrong-line 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 error: no match found
 ; SAM-NEXT:   >>>>>>
 ; SAM-NOT:    {{.}}
 
+; Wrong-line 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      !~~~~ error: match on wrong line
+; SAM2-NEXT: >>>>>>
+; SAM2-NOT:  {{.}}
+
 ;--------------------------------------------------
-; CHECK-EMPTY (also: search range ends at label)
+; CHECK-EMPTY (also: search range ends at label, wrong-line 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     ~~~~~ error: no match found
 ; EMP-NEXT:   >>>>>>
 ; EMP-NOT:    {{.}}
 
+; Wrong-line 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     !     error: match on wrong line
+; 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/trunk/utils/FileCheck/FileCheck.cpp

struct MarkerStyle {
   std::string Note;
   MarkerStyle() {}
   MarkerStyle(char Lead, raw_ostream::Colors Color, const std::string &Note)
       : Lead(Lead), Color(Color), Note(Note) {}
 };
 
 static MarkerStyle GetMarker(FileCheckDiag::MatchType MatchTy) {
   switch (MatchTy) {
+  case FileCheckDiag::MatchFinalButWrongLine:
+    return MarkerStyle('!', raw_ostream::RED, "error: match on wrong line");
   case FileCheckDiag::MatchNoneButExpected:
     return MarkerStyle('X', raw_ostream::RED, "error: no match found");
   case FileCheckDiag::MatchFuzzy:
     return MarkerStyle('?', raw_ostream::MAGENTA, "possible intended match");
   case FileCheckDiag::MatchTypeCount:
     llvm_unreachable_internal("unexpected match type");
   }
   llvm_unreachable_internal("unexpected match type");
static void DumpInputAnnotationHelp(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, such as:\n"
+     << "           - CHECK-NEXT on same line as previous match (error)\n"
+     << "  - ";
   WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "X~~";
-  OS << "    marks search range when no match is found\n"
+  OS << "    marks search range when no match is found, such as:\n"
+     << "           - CHECK-NEXT not found (error)\n"
      << "  - ";
   WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "?";
   OS << "      marks fuzzy match when no match is found\n";
 
   // Colors.
   OS << "  - colors ";
   WithColor(OS, raw_ostream::RED, true) << "error";
   OS << ", ";