[FileCheck] Implement -dump-input-filter

[jdenny]

Summary

This makes the input dump filtering implemented by D82203 more
configurable. D82203 enables filtering out everything but the initial
input lines of error diagnostics (plus some context). This patch
enables including any line with any kind of annotation.

[jdenny]

Rebased.

[mehdi_amini]

llvm/utils/FileCheck/FileCheck.cpp

455

In a tool like FileCheck I rather err on the side of deterministically failing with a report_fatal_error

[jdenny]

llvm/utils/FileCheck/FileCheck.cpp

455

I don't object in principal, but I see no precedent for this in FileCheck.

Are you ok with this landing as is? If FileCheck should generally use report_fatal_error instead of llvm_unreachable, I feel like that should be discussed in a separate review for all occurrences.

[jdenny]

llvm/utils/FileCheck/FileCheck.cpp

455

Given your accept and the tone of your comment, I decided it's safe to land this as is. I'm fine to revert or adjust if you feel this was the wrong decision. And again, I'm open to a larger discussion about making this change throughout FileCheck.

[mehdi_amini]

llvm/utils/FileCheck/FileCheck.cpp

455

LG

I don't think it has bitten anyone, so likely not worth the effort right now.

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

 ; ALL-NEXT:           32: foo8
 ; ALL-NEXT: check:3'0     ~~~~
 ; ALL-NEXT:           33: foo9
 ; ALL-NEXT: check:3'0     ~~~~
 ; ALL-NEXT:           34: end
 ; ALL-NEXT: check:3'0     ~~~
 ; ALL-NEXT: >>>>>>
 
+;      ANNOTATION-FULL: <<<<<<
+; ANNOTATION-FULL-NEXT:            1: start
+; ANNOTATION-FULL-NEXT: check:1       ^~~~~
+; ANNOTATION-FULL-NEXT:            2: foo0
+; ANNOTATION-FULL-NEXT:            3: foo1
+; ANNOTATION-FULL-NEXT:            .
+; ANNOTATION-FULL-NEXT:            .
+; ANNOTATION-FULL-NEXT:            .
+; ANNOTATION-FULL-NEXT:           10: foo8
+; ANNOTATION-FULL-NEXT:           11: foo9
+; ANNOTATION-FULL-NEXT:           12: hello
+; ANNOTATION-FULL-NEXT: check:2       ^~~~~
+; ANNOTATION-FULL-NEXT:           13: foo0
+; ANNOTATION-FULL-NEXT: check:3'0     X~~~ error: no match found
+; ANNOTATION-FULL-NEXT:           14: foo1
+; ANNOTATION-FULL-NEXT: check:3'0     ~~~~
+; ANNOTATION-FULL-NEXT:           15: foo2
+; ANNOTATION-FULL-NEXT: check:3'0     ~~~~
+; ANNOTATION-FULL-NEXT:           16: foo3
+; ANNOTATION-FULL-NEXT: check:3'0     ~~~~
+; ANNOTATION-FULL-NEXT:           17: foo4
+; ANNOTATION-FULL-NEXT: check:3'0     ~~~~
+; ANNOTATION-FULL-NEXT:           18: foo5
+; ANNOTATION-FULL-NEXT: check:3'0     ~~~~
+; ANNOTATION-FULL-NEXT:           19: foo6
+; ANNOTATION-FULL-NEXT: check:3'0     ~~~~
+; ANNOTATION-FULL-NEXT:           20: foo7
+; ANNOTATION-FULL-NEXT: check:3'0     ~~~~
+; ANNOTATION-FULL-NEXT:           21: foo8
+; ANNOTATION-FULL-NEXT: check:3'0     ~~~~
+; ANNOTATION-FULL-NEXT:           22: foo9
+; ANNOTATION-FULL-NEXT: check:3'0     ~~~~
+; ANNOTATION-FULL-NEXT:           23: word
+; ANNOTATION-FULL-NEXT: check:3'0     ~~~~
+; ANNOTATION-FULL-NEXT: check:3'1     ?     possible intended match
+; ANNOTATION-FULL-NEXT:           24: foo0
+; ANNOTATION-FULL-NEXT: check:3'0     ~~~~
+; ANNOTATION-FULL-NEXT:           25: foo1
+; ANNOTATION-FULL-NEXT: check:3'0     ~~~~
+; ANNOTATION-FULL-NEXT:           26: foo2
+; ANNOTATION-FULL-NEXT: check:3'0     ~~~~
+; ANNOTATION-FULL-NEXT:           27: foo3
+; ANNOTATION-FULL-NEXT: check:3'0     ~~~~
+; ANNOTATION-FULL-NEXT:           28: foo4
+; ANNOTATION-FULL-NEXT: check:3'0     ~~~~
+; ANNOTATION-FULL-NEXT:           29: foo5
+; ANNOTATION-FULL-NEXT: check:3'0     ~~~~
+; ANNOTATION-FULL-NEXT:           30: foo6
+; ANNOTATION-FULL-NEXT: check:3'0     ~~~~
+; ANNOTATION-FULL-NEXT:           31: foo7
+; ANNOTATION-FULL-NEXT: check:3'0     ~~~~
+; ANNOTATION-FULL-NEXT:           32: foo8
+; ANNOTATION-FULL-NEXT: check:3'0     ~~~~
+; ANNOTATION-FULL-NEXT:           33: foo9
+; ANNOTATION-FULL-NEXT: check:3'0     ~~~~
+; ANNOTATION-FULL-NEXT:           34: end
+; ANNOTATION-FULL-NEXT: check:3'0     ~~~
+; ANNOTATION-FULL-NEXT: >>>>>>
+
+;      ANNOTATION: <<<<<<
+; ANNOTATION-NEXT:            1: start
+; ANNOTATION-NEXT: check:1       ^~~~~
+; ANNOTATION-NEXT:            2: foo0
+; ANNOTATION-NEXT:            3: foo1
+; ANNOTATION-NEXT:            .
+; ANNOTATION-NEXT:            .
+; ANNOTATION-NEXT:            .
+; ANNOTATION-NEXT:           10: foo8
+; ANNOTATION-NEXT:           11: foo9
+; ANNOTATION-NEXT:           12: hello
+; ANNOTATION-NEXT: check:2       ^~~~~
+; ANNOTATION-NEXT:           13: foo0
+; ANNOTATION-NEXT: check:3'0     X~~~ error: no match found
+; ANNOTATION-NEXT:           14: foo1
+; ANNOTATION-NEXT: check:3'0     ~~~~
+; ANNOTATION-NEXT:           15: foo2
+; ANNOTATION-NEXT: check:3'0     ~~~~
+; ANNOTATION-NEXT:            .
+; ANNOTATION-NEXT:            .
+; ANNOTATION-NEXT:            .
+; ANNOTATION-NEXT:           21: foo8
+; ANNOTATION-NEXT: check:3'0     ~~~~
+; ANNOTATION-NEXT:           22: foo9
+; ANNOTATION-NEXT: check:3'0     ~~~~
+; ANNOTATION-NEXT:           23: word
+; ANNOTATION-NEXT: check:3'0     ~~~~
+; ANNOTATION-NEXT: check:3'1     ?     possible intended match
+; ANNOTATION-NEXT:           24: foo0
+; ANNOTATION-NEXT: check:3'0     ~~~~
+; ANNOTATION-NEXT:           25: foo1
+; ANNOTATION-NEXT: check:3'0     ~~~~
+; ANNOTATION-NEXT:            .
+; ANNOTATION-NEXT:            .
+; ANNOTATION-NEXT:            .
+; ANNOTATION-NEXT: >>>>>>
+
 ;      ERROR: <<<<<<
 ; ERROR-NEXT:            .
 ; ERROR-NEXT:            .
 ; ERROR-NEXT:            .
 ; ERROR-NEXT:           11: foo9
 ; ERROR-NEXT:           12: hello
 ; ERROR-NEXT: check:2       ^~~~~
 ; ERROR-NEXT:           13: foo0

 ; ERROR-NEXT:           25: foo1
 ; ERROR-NEXT: check:3'0     ~~~~
 ; ERROR-NEXT:            .
 ; ERROR-NEXT:            .
 ; ERROR-NEXT:            .
 ; ERROR-NEXT: >>>>>>
 
 ;--------------------------------------------------
-; Check how -dump-input affects filter.
+; Check -dump-input-filter=<bad value>.
 ;--------------------------------------------------
 
-; no -dump-input => include errors.
 ; RUN: %ProtectFileCheckOutput \
 ; RUN: not FileCheck -dump-input-context=2 -vv %t.chk < %t.in 2>&1 \
+; RUN:               -dump-input-filter=foobar \
+; RUN: | FileCheck %s -match-full-lines -check-prefix=BADVAL
+
+BADVAL: {{F|f}}ile{{C|c}}heck{{.*}}: for the --dump-input-filter option: Cannot find option named 'foobar'!
+
+;--------------------------------------------------
+; Check -dump-input-filter explicit values.
+;--------------------------------------------------
+
+; RUN: %ProtectFileCheckOutput \
+; RUN: not FileCheck -dump-input-context=2 -vv %t.chk < %t.in 2>&1 \
+; RUN:               -dump-input-filter=all \
+; RUN: | FileCheck %s -match-full-lines -check-prefixes=ALL
+
+; RUN: %ProtectFileCheckOutput \
+; RUN: not FileCheck -dump-input-context=2 -vv %t.chk < %t.in 2>&1 \
+; RUN:               -dump-input-filter=annotation-full \
+; RUN: | FileCheck %s -match-full-lines -check-prefixes=ANNOTATION-FULL
+
+; RUN: %ProtectFileCheckOutput \
+; RUN: not FileCheck -dump-input-context=2 -vv %t.chk < %t.in 2>&1 \
+; RUN:               -dump-input-filter=annotation \
+; RUN: | FileCheck %s -match-full-lines -check-prefixes=ANNOTATION
+
+; RUN: %ProtectFileCheckOutput \
+; RUN: not FileCheck -dump-input-context=2 -vv %t.chk < %t.in 2>&1 \
+; RUN:               -dump-input-filter=error \
 ; RUN: | FileCheck %s -match-full-lines -check-prefixes=ERROR
 
-; -dump-input=fail => include errors.
+;--------------------------------------------------
+; Check -dump-input-filter defaults.
+;--------------------------------------------------
+
+; no -dump-input => -dump-input-filter=error
+; RUN: %ProtectFileCheckOutput \
+; RUN: not FileCheck -dump-input-context=2 -vv %t.chk < %t.in 2>&1 \
+; RUN: | FileCheck %s -match-full-lines -check-prefixes=ERROR
+
+; -dump-input=fail => -dump-input-filter=error
 ; RUN: %ProtectFileCheckOutput \
 ; RUN: not FileCheck -dump-input-context=2 -vv %t.chk < %t.in 2>&1 \
 ; RUN:               -dump-input=fail \
 ; RUN: | FileCheck %s -match-full-lines -check-prefixes=ERROR
 
-; -dump-input=always => include all.
+; -dump-input=always => -dump-input-filter=all
 ; RUN: %ProtectFileCheckOutput \
 ; RUN: not FileCheck -dump-input-context=2 -vv %t.chk < %t.in 2>&1 \
 ; RUN:               -dump-input=always \
 ; RUN: | FileCheck %s -match-full-lines -check-prefixes=ALL
 
 ;--------------------------------------------------
-; Check that other kinds of errors are included by -dump-input=fail.
+; Check multiple -dump-input-filter options.
+;
+; This might occur when a test author specifies -dump-input-filter on a specific
+; FileCheck call while a test runner specifies -dump-input-filter in
+; FILECHECK_OPTS, but check the behavior generally.
+;
+; The value providing the most information wins.
+;--------------------------------------------------
+
+;- - - - - - - - - - - - - - - - - - - - - - - - -
+; Check duplicate.
+;- - - - - - - - - - - - - - - - - - - - - - - - -
+
+; all, all => all
+; RUN: %ProtectFileCheckOutput \
+; RUN: not FileCheck -dump-input-context=2 -vv %t.chk < %t.in 2>&1 \
+; RUN:               -dump-input-filter=all -dump-input-filter=all \
+; RUN: | FileCheck %s -match-full-lines -check-prefixes=ALL
+
+;- - - - - - - - - - - - - - - - - - - - - - - - -
+; Check precedence.
+;- - - - - - - - - - - - - - - - - - - - - - - - -
+
+; all, annotation-full => all
+; RUN: %ProtectFileCheckOutput \
+; RUN: not FileCheck -dump-input-context=2 -vv %t.chk < %t.in 2>&1 \
+; RUN:               -dump-input-filter=all -dump-input-filter=annotation-full \
+; RUN: | FileCheck %s -match-full-lines -check-prefixes=ALL
+
+; annotation-full, annotation => annotation-full
+; RUN: %ProtectFileCheckOutput \
+; RUN: not FileCheck -dump-input-context=2 -vv %t.chk < %t.in 2>&1 \
+; RUN:               -dump-input-filter=annotation-full \
+; RUN:               -dump-input-filter=annotation \
+; RUN: | FileCheck %s -match-full-lines -check-prefixes=ANNOTATION-FULL
+
+; annotation, error => annotation
+; RUN: %ProtectFileCheckOutput \
+; RUN: not FileCheck -dump-input-context=2 -vv %t.chk < %t.in 2>&1 \
+; RUN:               -dump-input-filter=annotation -dump-input-filter=error \
+; RUN: | FileCheck %s -match-full-lines -check-prefixes=ANNOTATION
+
+;- - - - - - - - - - - - - - - - - - - - - - - - -
+; Check that order doesn't matter.
+;- - - - - - - - - - - - - - - - - - - - - - - - -
+
+; error, annotation => annotation
+; RUN: %ProtectFileCheckOutput \
+; RUN: not FileCheck -dump-input-context=2 -vv %t.chk < %t.in 2>&1 \
+; RUN:               -dump-input-filter=error -dump-input-filter=annotation \
+; RUN: | FileCheck %s -match-full-lines -check-prefixes=ANNOTATION
+
+;- - - - - - - - - - - - - - - - - - - - - - - - -
+; Check that FILECHECK_OPTS isn't handled differently.
+;- - - - - - - - - - - - - - - - - - - - - - - - -
+
+; annotation, error => annotation
+; RUN: %ProtectFileCheckOutput FILECHECK_OPTS=-dump-input-filter=annotation \
+; RUN: not FileCheck -dump-input-context=2 -vv %t.chk < %t.in 2>&1 \
+; RUN:               -dump-input-filter=error \
+; RUN: | FileCheck %s -match-full-lines -check-prefixes=ANNOTATION
+
+; error, annotation => annotation
+; RUN: %ProtectFileCheckOutput FILECHECK_OPTS=-dump-input-filter=error \
+; RUN: not FileCheck -dump-input-context=2 -vv %t.chk < %t.in 2>&1 \
+; RUN:               -dump-input-filter=annotation \
+; RUN: | FileCheck %s -match-full-lines -check-prefixes=ANNOTATION
+
+;--------------------------------------------------
+; Check the case where all input lines are filtered out.
+;--------------------------------------------------
+
+; RUN: echo 'CHECK: hello' > %t.good.chk
+
+; RUN: %ProtectFileCheckOutput \
+; RUN: FileCheck -dump-input=always -dump-input-filter=error -vv %t.good.chk \
+; RUN:           < %t.in 2>&1 \
+; RUN: | FileCheck %s -match-full-lines -check-prefixes=EMPTY
+
+;      EMPTY: <<<<<<
+; EMPTY-NEXT:          .
+; EMPTY-NEXT:          .
+; EMPTY-NEXT:          .
+; EMPTY-NEXT: >>>>>>
+
+;--------------------------------------------------
+; Check that other kinds of errors are included by -dump-input-filter=error.
 ;
 ; "error: no match found" and "possible intended match" are checked above.
 ;--------------------------------------------------
 
 ;- - - - - - - - - - - - - - - - - - - - - - - - -
 ; error: no match expected.
 ;- - - - - - - - - - - - - - - - - - - - - - - - -
 
 ; RUN: echo 'foo'            > %t.not-err.in
 ; RUN: echo 'CHECK-NOT: foo' > %t.not-err.chk
 
 ; RUN: %ProtectFileCheckOutput \
-; RUN: not FileCheck -dump-input-context=0 -dump-input=fail \
+; RUN: not FileCheck -dump-input-context=0 -dump-input-filter=error \
 ; RUN:               %t.not-err.chk < %t.not-err.in 2>&1 \
 ; RUN: | FileCheck %s -match-full-lines -check-prefixes=NOT-ERR
 
 ;      NOT-ERR:        1: foo
 ; NOT-ERR-NEXT: not:1     !~~ error: no match expected
 
 ;- - - - - - - - - - - - - - - - - - - - - - - - -
 ; error: match on wrong line.
 ;- - - - - - - - - - - - - - - - - - - - - - - - -
 
 ; RUN: echo 'foo'             >  %t.next-err.in
 ; RUN: echo 'foo'             >> %t.next-err.in
 ; RUN: echo 'bar'             >> %t.next-err.in
 ; RUN: echo 'CHECK: foo'      >  %t.next-err.chk
 ; RUN: echo 'CHECK-NEXT: bar' >> %t.next-err.chk
 
 ; RUN: %ProtectFileCheckOutput \
-; RUN: not FileCheck -dump-input-context=0 -dump-input=fail \
+; RUN: not FileCheck -dump-input-context=0 -dump-input-filter=error \
 ; RUN:               %t.next-err.chk < %t.next-err.in 2>&1 \
 ; RUN: | FileCheck %s -match-full-lines -check-prefixes=NEXT-ERR
 
 ;      NEXT-ERR:         3: bar
-; NEXT-ERR-NEXT: next:2     !~~ error: match on wrong line
+; NEXT-ERR-NEXT: next:2     !~~ error: match on wrong line
 No newline at end of file

llvm/utils/FileCheck/FileCheck.cpp

cl::desc("Dump input to stderr, adding annotations representing\n"
              "occurrences of this option, the <value> that appears earliest\n"
              "in the list below has precedence.  The default is 'fail'.\n"),
     cl::value_desc("mode"),
     cl::values(clEnumValN(DumpInputHelp, "help", "Explain input dump and quit"),
                clEnumValN(DumpInputAlways, "always", "Always dump input"),
                clEnumValN(DumpInputFail, "fail", "Dump input on failure"),
                clEnumValN(DumpInputNever, "never", "Never dump input")));
 
+// The order of DumpInputFilterValue members affects their precedence, as
+// documented for -dump-input-filter below.
+enum DumpInputFilterValue {
+  DumpInputFilterError,
+  DumpInputFilterAnnotation,
+  DumpInputFilterAnnotationFull,
+  DumpInputFilterAll
+};
+
+static cl::list<DumpInputFilterValue> DumpInputFilters(
+    "dump-input-filter",
+    cl::desc("In the dump requested by -dump-input, print only input lines of\n"
+             "kind <kind> plus any context specified by -dump-input-context.\n"
+             "When there are multiple occurrences of this option, the <kind>\n"
+             "that appears earliest in the list below has precedence.  The\n"
+             "default is 'error' when -dump-input=fail, and it's 'all' when\n"
+             "-dump-input=always.\n"),
+    cl::value_desc("kind"),
+    cl::values(clEnumValN(DumpInputFilterAll, "all", "All input lines"),
+               clEnumValN(DumpInputFilterAnnotationFull, "annotation-full",
+                          "Input lines with annotations"),
+               clEnumValN(DumpInputFilterAnnotation, "annotation",
+                          "Input lines with starting points of annotations"),
+               clEnumValN(DumpInputFilterError, "error",
+                          "Input lines with starting points of error "
+                          "annotations")));
+
 static cl::list<unsigned> DumpInputContexts(
     "dump-input-context", cl::value_desc("N"),
-    cl::desc("In the dump requested by -dump-input=fail, print <N> input\n"
-             "lines before and <N> input lines after the starting line of\n"
-             "any error diagnostic.  When there are multiple occurrences of\n"
+    cl::desc("In the dump requested by -dump-input, print <N> input lines\n"
+             "before and <N> input lines after any lines specified by\n"
+             "-dump-input-filter.  When there are multiple occurrences of\n"
              "this option, the largest specified <N> has precedence.  The\n"
              "default is 5.\n"));
 
 typedef cl::list<std::string>::const_iterator prefix_iterator;
 
 
 
 

 
 struct MarkerStyle {
   /// The starting char (before tildes) for marking the line.
   char Lead;
   /// What color to use for this annotation.
   raw_ostream::Colors Color;
   /// A note to follow the marker, or empty string if none.
   std::string Note;
-  /// Does this marker indicate inclusion by the input filter implied by
-  /// -dump-input=fail?
+  /// Does this marker indicate inclusion by -dump-input-filter=error?
   bool FiltersAsError;
   MarkerStyle() {}
   MarkerStyle(char Lead, raw_ostream::Colors Color,
               const std::string &Note = "", bool FiltersAsError = false)
       : Lead(Lead), Color(Color), Note(Note), FiltersAsError(FiltersAsError) {
     assert((!FiltersAsError || !Note.empty()) &&
            "expected error diagnostic to have note");
   }

 }
 
 static void DumpInputAnnotationHelp(raw_ostream &OS) {
   OS << "The following description was requested by -dump-input=help to\n"
      << "explain the input dump printed by FileCheck.\n"
      << "\n"
      << "Related command-line options:\n"
      << "  - -dump-input=<value> enables or disables the input dump\n"
-     << "  - -dump-input-context=<N> adjusts the context of errors\n"
+     << "  - -dump-input-filter=<kind> filters the input lines\n"
+     << "  - -dump-input-context=<N> adjusts the context of filtered lines\n"
      << "  - -v and -vv add more annotations\n"
      << "  - -color forces colors to be enabled both in the dump and below\n"
      << "  - -help documents the above options in more detail\n"
      << "\n"
      << "Input dump annotation format:\n";
 
   // Labels for input lines.
   OS << "  - ";
OS << "    marks search range when no match is found, such as:\n"
      << "  - ";
   WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "?";
   OS << "      marks fuzzy match when no match is found\n";
 
   // Elided lines.
   OS << "  - ";
   WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "...";
   OS << "    indicates elided input lines and annotations, as specified by\n"
-     << "           -dump-input=fail and -dump-input-context\n";
+     << "           -dump-input-filter and -dump-input-context\n";
 
   // Colors.
   OS << "  - colors ";
   WithColor(OS, raw_ostream::GREEN, true) << "success";
   OS << ", ";
   WithColor(OS, raw_ostream::RED, true) << "error";
   OS << ", ";
   WithColor(OS, raw_ostream::MAGENTA, true) << "fuzzy match";
if (DiagItr->InputStartLine == DiagItr->InputEndLine) {
         B.FoundAndExpectedMatch = A.FoundAndExpectedMatch;
         Annotations.push_back(B);
       }
     }
   }
 }
 
 static unsigned FindInputLineInFilter(
-    bool FilterOnError, unsigned CurInputLine,
+    DumpInputFilterValue DumpInputFilter, unsigned CurInputLine,
     const std::vector<InputAnnotation>::iterator &AnnotationBeg,
     const std::vector<InputAnnotation>::iterator &AnnotationEnd) {
-  if (!FilterOnError)
+  if (DumpInputFilter == DumpInputFilterAll)
     return CurInputLine;
   for (auto AnnotationItr = AnnotationBeg; AnnotationItr != AnnotationEnd;
        ++AnnotationItr) {
+    switch (DumpInputFilter) {
+    case DumpInputFilterAll:
+      llvm_unreachable("unexpected DumpInputFilterAll");
+      break;
+    case DumpInputFilterAnnotationFull:
+      return AnnotationItr->InputLine;
+    case DumpInputFilterAnnotation:
+      if (AnnotationItr->IsFirstLine)
+        return AnnotationItr->InputLine;
+      break;
+    case DumpInputFilterError:
       if (AnnotationItr->IsFirstLine && AnnotationItr->Marker.FiltersAsError)
         return AnnotationItr->InputLine;
+      break;
+    }
   }
   return UINT_MAX;
 }
 
 /// To OS, print a vertical ellipsis (right-justified at LabelWidth) if it would
 /// occupy less lines than ElidedLines, but print ElidedLines otherwise.  Either
 /// way, clear ElidedLines.  Thus, if ElidedLines is empty, do nothing.
 static void DumpEllipsisOrElidedLines(raw_ostream &OS, std::string &ElidedLines,
                                       unsigned LabelWidth) {
   if (ElidedLines.empty())
     return;
   unsigned EllipsisLines = 3;
   if (EllipsisLines < StringRef(ElidedLines).count('\n')) {
     for (unsigned i = 0; i < EllipsisLines; ++i) {
       WithColor(OS, raw_ostream::BLACK, /*Bold=*/true)
           << right_justify(".", LabelWidth);
       OS << '\n';
     }
   } else
     OS << ElidedLines;
   ElidedLines.clear();
 }
 
 static void DumpAnnotatedInput(raw_ostream &OS, const FileCheckRequest &Req,
-                               bool DumpInputFilterOnError,
+                               DumpInputFilterValue DumpInputFilter,
                                unsigned DumpInputContext,
                                StringRef InputFileText,
                                std::vector<InputAnnotation> &Annotations,
                                unsigned LabelWidth) {
   OS << "Input was:\n<<<<<<\n";
 
   // Sort annotations.
   std::sort(Annotations.begin(), Annotations.end(),
static void DumpAnnotatedInput(raw_ostream &OS, const FileCheckRequest &Req,
   auto AnnotationItr = Annotations.begin(), AnnotationEnd = Annotations.end();
   for (unsigned Line = 1;
        InputFilePtr != InputFileEnd || AnnotationItr != AnnotationEnd;
        ++Line) {
     const unsigned char *InputFileLine = InputFilePtr;
 
     // Compute the previous and next line included by the filter.
     if (NextLineInFilter < Line)
-      NextLineInFilter = FindInputLineInFilter(DumpInputFilterOnError, Line,
+      NextLineInFilter = FindInputLineInFilter(DumpInputFilter, Line,
                                                AnnotationItr, AnnotationEnd);
     assert(NextLineInFilter && "expected NextLineInFilter to be computed");
     if (NextLineInFilter == Line)
       PrevLineInFilter = Line;
 
     // Elide this input line and its annotations if it's not within the
     // context specified by -dump-input-context of an input line included by
-    // the dump filter.  However, in case the resulting ellipsis would occupy
+    // -dump-input-filter.  However, in case the resulting ellipsis would occupy
     // more lines than the input lines and annotations it elides, buffer the
     // elided lines and annotations so we can print them instead.
     raw_ostream *LineOS = &OS;
     if ((!PrevLineInFilter || PrevLineInFilter + DumpInputContext < Line) &&
         (NextLineInFilter == UINT_MAX ||
          Line + DumpInputContext < NextLineInFilter))
       LineOS = &ElidedLinesOS;
     else {
int main(int argc, char **argv) {
   // Select -dump-input* values.  The -help documentation specifies the default
   // value and which value to choose if an option is specified multiple times.
   // In the latter case, the general rule of thumb is to choose the value that
   // provides the most information.
   DumpInputValue DumpInput =
       DumpInputs.empty()
           ? DumpInputFail
           : *std::max_element(DumpInputs.begin(), DumpInputs.end());
-  bool DumpInputFilterOnError = DumpInput == DumpInputFail;
+  DumpInputFilterValue DumpInputFilter;
+  if (DumpInputFilters.empty())
+    DumpInputFilter = DumpInput == DumpInputAlways ? DumpInputFilterAll
+                                                   : DumpInputFilterError;
+  else
+    DumpInputFilter =
+        *std::max_element(DumpInputFilters.begin(), DumpInputFilters.end());
   unsigned DumpInputContext = DumpInputContexts.empty()
                                   ? 5
                                   : *std::max_element(DumpInputContexts.begin(),
                                                       DumpInputContexts.end());
 
   if (DumpInput == DumpInputHelp) {
     DumpInputAnnotationHelp(outs());
     return 0;
errs() << "\n"
            << "Check file: " << CheckFilename << "\n"
            << "\n"
            << "-dump-input=help explains the following input dump.\n"
            << "\n";
     std::vector<InputAnnotation> Annotations;
     unsigned LabelWidth;
     BuildInputAnnotations(SM, CheckFileBufferID, ImpPatBufferIDRange, Diags,
                           Annotations, LabelWidth);
-    DumpAnnotatedInput(errs(), Req, DumpInputFilterOnError, DumpInputContext,
+    DumpAnnotatedInput(errs(), Req, DumpInputFilter, DumpInputContext,
                        InputFileText, Annotations, LabelWidth);
   }
 
   return ExitCode;
 }