[FileCheck] Annotate input dump (4/7)

[jdenny]

Summary

This patch implements input annotations for diagnostics that report
unexpected matches for CHECK-NOT. Like wrong-line matches for
CHECK-NEXT, CHECK-SAME, and CHECK-EMPTY, these annotations mark match
ranges using red !~~ to indicate bad matches that are errors.

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)
           - CHECK-NOT found (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 check3 < input3 |& sed -n '/^<<<</,$p'
<<<<<<
       1: abc foobar def
not:2         !~~~~~     error: no match expected
>>>>>>

$ cat check3
CHECK:     abc
CHECK-NOT: foobar
CHECK:     def

$ cat input3
abc foobar def

[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]

These get to be pretty mechanical after a while, don't they? I was wondering how hard it would be for someone else, next time somebody wants to add a new directive kind, but it seems like not really a big deal and that's a good thing.
Again a comment needs fixing but otherwise LGTM.
I'll try to get to the rest tomorrow.

llvm/include/llvm/Support/FileCheck.h

150

Comments should be proper sentences.

[jdenny]

Thanks, Paul!

[jdenny]

Adjust comment, as suggested by probinson.

llvm/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.
   ///
   /// We iterate these types, so they must have contiguous values in
-  /// [0, MatchTypeCount).
+  /// [0, MatchTypeCount).  Moreover, keep match types together if they use the
+  /// same mark in annotated input dumps or else printing of the annotation key
+  /// will malfunction.
   enum MatchType {
     // TODO: More members will appear with later patches in this series.
+    MatchFinalButExcluded, //< the final match for an excluded pattern
+    MatchTypeFirst = MatchFinalButExcluded,
     MatchFinalButIllegal,  //< the final but illegal match for an expected pattern
-    MatchTypeFirst = MatchFinalButIllegal,
     MatchNoneButExpected,  //< no match for an expected pattern
     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,
size_t Check(const SourceMgr &SM, StringRef Buffer, bool IsLabelScanMode,
                size_t &MatchLen, StringMap<StringRef> &VariableTable,
                FileCheckRequest &Req, std::list<FileCheckDiag> *Diags) const;
 
   bool CheckNext(const SourceMgr &SM, StringRef Buffer) const;
   bool CheckSame(const SourceMgr &SM, StringRef Buffer) const;
   bool CheckNot(const SourceMgr &SM, StringRef Buffer,
                 const std::vector<const FileCheckPattern *> &NotStrings,
                 StringMap<StringRef> &VariableTable,
-                const FileCheckRequest &Req) const;
+                const FileCheckRequest &Req,
+                std::list<FileCheckDiag> *Diags) const;
   size_t CheckDag(const SourceMgr &SM, StringRef Buffer,
                   std::vector<const FileCheckPattern *> &NotStrings,
                   StringMap<StringRef> &VariableTable,
                   const FileCheckRequest &Req,
                   std::list<FileCheckDiag> *Diags) const;
 };
 
 /// FileCheck class takes the request and exposes various methods that

llvm/lib/Support/FileCheck.cpp

bool llvm::FileCheck::ReadCheckFile(SourceMgr &SM, StringRef Buffer,
 
   return false;
 }
 
 static void PrintMatch(bool ExpectedMatch, const SourceMgr &SM,
                        StringRef Prefix, SMLoc Loc, const FileCheckPattern &Pat,
                        StringRef Buffer, StringMap<StringRef> &VariableTable,
                        size_t MatchPos, size_t MatchLen,
-                       const FileCheckRequest &Req) {
+                       const FileCheckRequest &Req,
+                       std::list<FileCheckDiag> *Diags) {
   if (ExpectedMatch) {
     if (!Req.Verbose)
       return;
     if (!Req.VerboseVerbose && Pat.getCheckTy() == Check::CheckEOF)
       return;
   }
-  SMLoc MatchStart = SMLoc::getFromPointer(Buffer.data() + MatchPos);
-  SMLoc MatchEnd = SMLoc::getFromPointer(Buffer.data() + MatchPos + MatchLen);
-  SMRange MatchRange(MatchStart, MatchEnd);
+  SMRange MatchRange = ProcessMatchResult(
+      ExpectedMatch ? FileCheckDiag::MatchTypeCount
+                    : FileCheckDiag::MatchFinalButExcluded,
+      SM, Loc, Pat.getCheckTy(), Buffer, MatchPos, MatchLen, Diags);
   SM.PrintMessage(
       Loc, ExpectedMatch ? SourceMgr::DK_Remark : SourceMgr::DK_Error,
       CheckTypeName(Prefix, Pat.getCheckTy()) + ": " +
           (ExpectedMatch ? "expected" : "excluded") +
           " string found in input");
-  SM.PrintMessage(MatchStart, SourceMgr::DK_Note, "found here", {MatchRange});
+  SM.PrintMessage(MatchRange.Start, SourceMgr::DK_Note, "found here",
+                  {MatchRange});
   Pat.PrintVariableUses(SM, Buffer, VariableTable, MatchRange);
 }
 
 static void PrintMatch(bool ExpectedMatch, const SourceMgr &SM,
                        const FileCheckString &CheckStr, StringRef Buffer,
                        StringMap<StringRef> &VariableTable, size_t MatchPos,
-                       size_t MatchLen, FileCheckRequest &Req) {
+                       size_t MatchLen, FileCheckRequest &Req,
+                       std::list<FileCheckDiag> *Diags) {
   PrintMatch(ExpectedMatch, SM, CheckStr.Prefix, CheckStr.Loc, CheckStr.Pat,
-             Buffer, VariableTable, MatchPos, MatchLen, Req);
+             Buffer, VariableTable, MatchPos, MatchLen, Req, Diags);
 }
 
 static void PrintNoMatch(bool ExpectedMatch, const SourceMgr &SM,
                          StringRef Prefix, SMLoc Loc,
                          const FileCheckPattern &Pat, StringRef Buffer,
                          StringMap<StringRef> &VariableTable,
                          bool VerboseVerbose,
                          std::list<FileCheckDiag> *Diags) {
size_t FileCheckString::Check(const SourceMgr &SM, StringRef Buffer,
   // Match itself from the last position after matching CHECK-DAG.
   StringRef MatchBuffer = Buffer.substr(LastPos);
   size_t MatchPos = Pat.Match(MatchBuffer, MatchLen, VariableTable);
   if (MatchPos == StringRef::npos) {
     PrintNoMatch(true, SM, *this, MatchBuffer, VariableTable,
                  Req.VerboseVerbose, Diags);
     return StringRef::npos;
   }
-  PrintMatch(true, SM, *this, MatchBuffer, VariableTable, MatchPos, MatchLen, Req);
+  PrintMatch(true, SM, *this, MatchBuffer, VariableTable, MatchPos, MatchLen,
+             Req, Diags);
 
   // 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 (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))
+    if (CheckNot(SM, SkippedRegion, NotStrings, VariableTable, Req, Diags))
       return StringRef::npos;
   }
 
   return LastPos + MatchPos;
 }
 
 /// Verify there is a single line in the given buffer.
 bool FileCheckString::CheckNext(const SourceMgr &SM, StringRef Buffer) const {
SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Note,
                     "previous match ended here");
     return true;
   }
 
   return false;
 }
 
 /// Verify there's no "not strings" in the given buffer.
-bool FileCheckString::CheckNot(const SourceMgr &SM, StringRef Buffer,
-                           const std::vector<const FileCheckPattern *> &NotStrings,
-                           StringMap<StringRef> &VariableTable,
-                           const FileCheckRequest &Req) const {
+bool FileCheckString::CheckNot(
+    const SourceMgr &SM, StringRef Buffer,
+    StringMap<StringRef> &VariableTable, const FileCheckRequest &Req,
+    std::list<FileCheckDiag> *Diags) const {
   for (const FileCheckPattern *Pat : NotStrings) {
     assert((Pat->getCheckTy() == Check::CheckNot) && "Expect CHECK-NOT!");
 
     size_t MatchLen = 0;
     size_t Pos = Pat->Match(Buffer, MatchLen, VariableTable);
 
     if (Pos == StringRef::npos) {
       PrintNoMatch(false, SM, Prefix, Pat->getLoc(), *Pat, Buffer,
                    VariableTable, Req.VerboseVerbose, nullptr);
       continue;
     }
 
     PrintMatch(false, SM, Prefix, Pat->getLoc(), *Pat, Buffer, VariableTable,
-               Pos, MatchLen, Req);
+               Pos, MatchLen, Req, Diags);
 
     return true;
   }
 
   return false;
 }
 
 /// Match "dag strings" and their mixed "not strings".
for (auto MI = MatchRanges.begin(), ME = MatchRanges.end(); true; ++MI) {
         PrintNoMatch(true, SM, Prefix, Pat.getLoc(), Pat, MatchBuffer,
                      VariableTable, Req.VerboseVerbose, Diags);
         return StringRef::npos;
       }
       // Re-calc it as the offset relative to the start of the original string.
       MatchPos += MatchPosBuf;
       if (Req.VerboseVerbose)
         PrintMatch(true, SM, Prefix, Pat.getLoc(), Pat, Buffer, VariableTable,
-                   MatchPos, MatchLen, Req);
+                   MatchPos, MatchLen, Req, Diags);
       MatchRange M{MatchPos, MatchPos + MatchLen};
       if (Req.AllowDeprecatedDagOverlap) {
         // We don't need to track all matches in this mode, so we just maintain
         // one match range that encompasses the current CHECK-DAG group's
         // matches.
         if (MatchRanges.empty())
           MatchRanges.insert(MatchRanges.end(), M);
         else {
for (auto MI = MatchRanges.begin(), ME = MatchRanges.end(); true; ++MI) {
         SM.PrintMessage(OldStart, SourceMgr::DK_Note,
                         "match discarded, overlaps earlier DAG match here",
                         {OldRange});
       }
       MatchPos = MI->End;
     }
     if (!Req.VerboseVerbose)
       PrintMatch(true, SM, Prefix, Pat.getLoc(), Pat, Buffer, VariableTable,
-                 MatchPos, MatchLen, Req);
+                 MatchPos, MatchLen, Req, Diags);
 
     // Handle the end of a CHECK-DAG group.
     if (std::next(PatItr) == PatEnd ||
         std::next(PatItr)->getCheckTy() == Check::CheckNot) {
       if (!NotStrings.empty()) {
         // If there are CHECK-NOTs between two CHECK-DAGs or from CHECK to
         // CHECK-DAG, verify that there are no 'not' strings occurred in that
         // region.
         StringRef SkippedRegion =
             Buffer.slice(StartPos, MatchRanges.begin()->Pos);
-        if (CheckNot(SM, SkippedRegion, NotStrings, VariableTable, Req))
+        if (CheckNot(SM, SkippedRegion, NotStrings, VariableTable, Req, Diags))
           return StringRef::npos;
         // Clear "not strings".
         NotStrings.clear();
       }
       // All subsequent CHECK-DAGs and CHECK-NOTs should be matched from the
       // end of this CHECK-DAG group's match range.
       StartPos = MatchRanges.rbegin()->End;
       // Don't waste time checking for (impossible) overlaps before that.

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

 ; EMP2-NEXT:            1: hello
 ; EMP2-NEXT:            2: world
 ; EMP2-NEXT:            3:
 ; EMP2-NEXT:   empty:2     !
 ; EMP2-NEXT:   >>>>>>
 ; EMP2-NOT:    {{.}}
 
 ;--------------------------------------------------
+; CHECK-NOT
+;--------------------------------------------------
+
+; No match (success) and illegal match.
+
+; RUN: echo 'hello' > %t.in
+; RUN: echo 'world' >> %t.in
+; RUN: echo 'again' >> %t.in
+
+; RUN: echo 'CHECK-NOT: goodbye' > %t.chk
+; RUN: echo 'CHECK-NOT: world' >> %t.chk
+
+; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk 2>&1 \
+; RUN: | FileCheck -match-full-lines %s -check-prefix=NOT
+; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -v 2>&1 \
+; RUN: | FileCheck -match-full-lines %s -check-prefixes=NOT,NOT-V
+; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -vv 2>&1 \
+; RUN: | FileCheck -match-full-lines %s -check-prefixes=NOT,NOT-V,NOT-VV
+
+; NOT:         <<<<<<
+; NOT-NEXT:           1: hello
+; NOT-NEXT:           2: world
+; NOT-NEXT:    not:2     !~~~~
+; NOT-NEXT:           3: again
+; NOT-NEXT:    >>>>>>
+; NOT-NOT:     {{.}}
+
+; Again, but with a CHECK instead of EOF as search range end.
+
+; RUN: echo 'CHECK: ain' >> %t.chk
+
+; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk 2>&1 \
+; RUN: | FileCheck -match-full-lines %s -check-prefix=NOT2
+; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -v 2>&1 \
+; RUN: | FileCheck -match-full-lines %s -check-prefixes=NOT2,NOT2-V
+; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -vv 2>&1 \
+; RUN: | FileCheck -match-full-lines %s -check-prefixes=NOT2,NOT2-V,NOT2-VV
+
+; NOT2:         <<<<<<
+; NOT2-NEXT:             1: hello
+; NOT2-NEXT:             2: world
+; NOT2-NEXT:    not:2       !~~~~
+; NOT2-NEXT:             3: again
+; NOT2-NEXT:    >>>>>>
+; NOT2-NOT:     {{.}}
+
+;--------------------------------------------------
 ; CHECK-DAG
 ;--------------------------------------------------
 
 ; Good match, discarded match plus good match, and no match.
 
 ; RUN: echo 'abc' > %t.in
 ; RUN: echo 'def' >> %t.in
 ; RUN: echo 'abc' >> %t.in

llvm/utils/FileCheck/FileCheck.cpp

static void DumpCommandLine(int argc, char **argv) {
   errs() << "FileCheck command line: ";
   for (int I = 0; I < argc; I++)
     errs() << " " << argv[I];
   errs() << "\n";
 }
 
 struct MatchTypeStyle {
   char Mark;
+  bool HasTildes;
   raw_ostream::Colors Color;
   const char *What;
-  MatchTypeStyle(char Mark, raw_ostream::Colors Color, const char *What)
-      : Mark(Mark), Color(Color), What(What) {}
+  MatchTypeStyle(char Mark, bool HasTildes, raw_ostream::Colors Color,
+                 const char *What)
+      : Mark(Mark), HasTildes(HasTildes), Color(Color), What(What) {}
 };
 
 static MatchTypeStyle GetMatchTypeStyle(unsigned MatchTy) {
   switch (MatchTy) {
+  case FileCheckDiag::MatchFinalButExcluded:
+    return MatchTypeStyle('!', true, raw_ostream::RED,
+                          "the final match for an excluded pattern (e.g., "
+                          "CHECK-NOT)");
   case FileCheckDiag::MatchFinalButIllegal:
-    return MatchTypeStyle('!', raw_ostream::RED,
+    return MatchTypeStyle('!', true, 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,
+    return MatchTypeStyle('X', true, raw_ostream::RED,
                           "the search range for an unmatched expected "
                           "pattern (e.g., CHECK)");
   case FileCheckDiag::MatchFuzzy:
-    return MatchTypeStyle('?', raw_ostream::MAGENTA,
+    return MatchTypeStyle('?', false, raw_ostream::MAGENTA,
                           "a fuzzy match start for an otherwise unmatched "
                           "pattern");
   case FileCheckDiag::MatchTypeCount:
     llvm_unreachable_internal("unexpected match type");
   }
   llvm_unreachable_internal("unexpected match type");
 }
 
static void DumpInputAnnotationExplanation(raw_ostream &OS,
   if (WithColor(OS).colorsEnabled()) {
     OS << "  - color  ";
     WithColor(OS, raw_ostream::RED, true) << "error";
     OS << ", ";
     WithColor(OS, raw_ostream::MAGENTA, true) << "fuzzy";
     OS << '\n';
   }
 
+  OS << "\nDetailed description of currently enabled markers:\n\n";
+
+  for (unsigned StyleIdx = FileCheckDiag::MatchTypeFirst;
+       StyleIdx < FileCheckDiag::MatchTypeCount; ++StyleIdx) {
+    MatchTypeStyle Style = GetMatchTypeStyle(StyleIdx);
+    if (StyleIdx == FileCheckDiag::MatchTypeFirst ||
+        Style.Mark != GetMatchTypeStyle(StyleIdx - 1).Mark ||
+        Style.HasTildes != GetMatchTypeStyle(StyleIdx - 1).HasTildes ||
+        (WithColor(OS).colorsEnabled() &&
+         Style.Color != GetMatchTypeStyle(StyleIdx - 1).Color)) {
+      OS << "  - ";
+      WithColor(OS, Style.Color, true)
+          << Style.Mark << (Style.HasTildes ? "~~" : "  ");
+      OS << "    marks ";
+      if (StyleIdx + 1 != FileCheckDiag::MatchTypeCount &&
+          Style.Mark == GetMatchTypeStyle(StyleIdx + 1).Mark &&
+          Style.HasTildes == GetMatchTypeStyle(StyleIdx + 1).HasTildes &&
+          (!WithColor(OS).colorsEnabled() ||
+           Style.Color == GetMatchTypeStyle(StyleIdx + 1).Color))
+        OS << "either:\n"
+           << "           - ";
+    } else
+      OS << "           - ";
+    OS << Style.What << "\n";
+  }
+
   // Files.
   OS << "\nInput file: ";
   if (InputFilename == "-")
     OS << "<stdin>";
   else
     OS << InputFilename;
   OS << "\nCheck file: " << CheckFilename << "\n";
 }
for (auto DiagItr = DiagList.begin(), DiagEnd = DiagList.end();
     A.InputLine = DiagItr->InputStartLine;
     A.InputStartCol = DiagItr->InputStartCol;
     if (DiagItr->InputStartLine == DiagItr->InputEndLine) {
       // Sometimes ranges are empty in order to indicate a specific point, but
       // that would mean nothing would be marked, so adjust the range to
       // include the following character.
       A.InputEndCol =
           std::max(DiagItr->InputStartCol + 1, DiagItr->InputEndCol);
+      assert((MatchTyStyle.HasTildes ||
+              A.InputStartCol + 1 == A.InputEndCol) &&
+             "expected input range to have only one character for marker "
+             "style without tildes");
     } else {
+      assert(MatchTyStyle.HasTildes &&
+             "expected input range to have only one character for marker "
+             "style without tildes");
       assert(DiagItr->InputStartLine < DiagItr->InputEndLine &&
              "expected input range not to be inverted");
       A.InputEndCol = UINT_MAX;
       for (unsigned L = DiagItr->InputStartLine + 1, E = DiagItr->InputEndLine;
            L <= E; ++L) {
         // If a range ends before the first column on a line, then it has no
         // characters on that line, so there's nothing to render.
         if (DiagItr->InputEndCol == 1 && L == E)