[FileCheck] Annotate input dump (1/7)
Extend FileCheck to dump its input annotated with FileCheck's
diagnostics: errors, good matches if -v, and additional information if
-vv. The goal is to make it easier to visualize FileCheck's matching
behavior when debugging.
Each patch in this series implements input annotations for a
particular category of FileCheck diagnostics. While the first few
patches alone are somewhat useful, the annotations become much more
useful as later patches implement annotations for -v and -vv
diagnostics, which show the matching behavior leading up to the error.
This first patch implements boilerplate plus input annotations for
error diagnostics reporting that no matches were found for a
directive. These annotations mark the search ranges of the failed
directives. Instead of using the usual `^~~`, which is used by later
patches for good matches, these annotations use `X~~` so that this
category of errors is visually distinct.
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 match result for a pattern of type T from line L of
the check file
- X~~ marks search range when no match is found
- colors error
If you are not seeing color above or in input dumps, try: -color
$ FileCheck -v -dump-input=always check1 < input1 |& sed -n '/^Input file/,$p'
Input file: <stdin>
Check file: check1
-dump-input=help describes the format of the following dump.
Full input was:
<<<<<<
1: ; abc def
2: ; ghI jkl
next:3 X~~~~~~~~ error: no match found
>>>>>>
$ cat check1
CHECK: abc
CHECK-SAME: def
CHECK-NEXT: ghi
CHECK-SAME: jkl
$ cat input1
; abc def
; ghI jkl
```
Some additional details related to the boilerplate:
* Enabling: The annotated input dump is enabled by `-dump-input`,
which can also be set via the `FILECHECK_OPTS` environment variable.
Accepted values are `help`, `always`, `fail`, or `never`. As shown
above, `help` describes the format of the dump. `always` is helpful
when you want to investigate a successful FileCheck run, perhaps for
an unexpected pass. `-dump-input-on-failure` and
`FILECHECK_DUMP_INPUT_ON_FAILURE` remain as a deprecated alias for
`-dump-input=fail`.
* Diagnostics: The usual diagnostics are not suppressed in this mode
and are printed first. For brevity in the example above, I've
omitted them using a sed command. Sometimes they're perfectly
sufficient, and then they make debugging quicker than if you were
forced to hunt through a dump of long input looking for the error.
If you think they'll get in the way sometimes, keep in mind that
it's pretty easy to grep for the start of the input dump, which is
`<<<`.
* Colored Annotations: The annotated input is colored if colors are
enabled (enabling colors can be forced using -color). For example,
errors are red. However, as in the above example, colors are not
vital to reading the annotations.
I don't know how to test color in the output, so any hints here would
be appreciated.
Reviewed By: george.karpenkov, zturner, probinson
Differential Revision: https://reviews.llvm.org/D52999
llvm-svn: 349418
2018-12-18 08:01:39 +08:00
|
|
|
;--------------------------------------------------
|
[FileCheck] Annotate input dump (2/7)
This patch implements input annotations for diagnostics that suggest
fuzzy matches for directives for which no matches were found. Instead
of using the usual `^~~`, which is used by later patches for good
matches, these annotations use `?` so that fuzzy matches are visually
distinct. No tildes are included as these diagnostics (independently
of this patch) currently identify only the start of the match.
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
- X~~ marks search range when no match is found
- ? 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 check1 < input1 |& sed -n '/^<<<</,$p'
<<<<<<
1: ; abc def
2: ; ghI jkl
next:3'0 X~~~~~~~~ error: no match found
next:3'1 ? possible intended match
>>>>>>
$ cat check1
CHECK: abc
CHECK-SAME: def
CHECK-NEXT: ghi
CHECK-SAME: jkl
$ cat input1
; abc def
; ghI jkl
```
This patch introduces the concept of multiple "match results" per
directive. In the above example, the first match result for the
CHECK-NEXT directive is the failed match, for which the annotation
shows the search range. The second match result is the fuzzy match.
Later patches will introduce other cases of multiple match results per
directive.
When colors are enabled, `?` is colored magenta. That is, it doesn't
indicate the actual error, which a red `X~~` marker indicates, but its
color suggests it's closely related.
Reviewed By: george.karpenkov, probinson
Differential Revision: https://reviews.llvm.org/D53893
llvm-svn: 349419
2018-12-18 08:02:04 +08:00
|
|
|
; Use -strict-whitespace to check marker and note alignment here.
|
[FileCheck] Annotate input dump (1/7)
Extend FileCheck to dump its input annotated with FileCheck's
diagnostics: errors, good matches if -v, and additional information if
-vv. The goal is to make it easier to visualize FileCheck's matching
behavior when debugging.
Each patch in this series implements input annotations for a
particular category of FileCheck diagnostics. While the first few
patches alone are somewhat useful, the annotations become much more
useful as later patches implement annotations for -v and -vv
diagnostics, which show the matching behavior leading up to the error.
This first patch implements boilerplate plus input annotations for
error diagnostics reporting that no matches were found for a
directive. These annotations mark the search ranges of the failed
directives. Instead of using the usual `^~~`, which is used by later
patches for good matches, these annotations use `X~~` so that this
category of errors is visually distinct.
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 match result for a pattern of type T from line L of
the check file
- X~~ marks search range when no match is found
- colors error
If you are not seeing color above or in input dumps, try: -color
$ FileCheck -v -dump-input=always check1 < input1 |& sed -n '/^Input file/,$p'
Input file: <stdin>
Check file: check1
-dump-input=help describes the format of the following dump.
Full input was:
<<<<<<
1: ; abc def
2: ; ghI jkl
next:3 X~~~~~~~~ error: no match found
>>>>>>
$ cat check1
CHECK: abc
CHECK-SAME: def
CHECK-NEXT: ghi
CHECK-SAME: jkl
$ cat input1
; abc def
; ghI jkl
```
Some additional details related to the boilerplate:
* Enabling: The annotated input dump is enabled by `-dump-input`,
which can also be set via the `FILECHECK_OPTS` environment variable.
Accepted values are `help`, `always`, `fail`, or `never`. As shown
above, `help` describes the format of the dump. `always` is helpful
when you want to investigate a successful FileCheck run, perhaps for
an unexpected pass. `-dump-input-on-failure` and
`FILECHECK_DUMP_INPUT_ON_FAILURE` remain as a deprecated alias for
`-dump-input=fail`.
* Diagnostics: The usual diagnostics are not suppressed in this mode
and are printed first. For brevity in the example above, I've
omitted them using a sed command. Sometimes they're perfectly
sufficient, and then they make debugging quicker than if you were
forced to hunt through a dump of long input looking for the error.
If you think they'll get in the way sometimes, keep in mind that
it's pretty easy to grep for the start of the input dump, which is
`<<<`.
* Colored Annotations: The annotated input is colored if colors are
enabled (enabling colors can be forced using -color). For example,
errors are red. However, as in the above example, colors are not
vital to reading the annotations.
I don't know how to test color in the output, so any hints here would
be appreciated.
Reviewed By: george.karpenkov, zturner, probinson
Differential Revision: https://reviews.llvm.org/D52999
llvm-svn: 349418
2018-12-18 08:01:39 +08:00
|
|
|
; (Also check multiline marker where start/end columns vary across lines.)
|
|
|
|
|
;
|
|
|
|
|
; In the remaining checks, don't use -strict-whitespace and thus check just the
|
|
|
|
|
; presence, order, and lengths of markers. That way, if we ever change padding
|
|
|
|
|
; within line labels, we don't have to adjust so many tests.
|
|
|
|
|
;--------------------------------------------------
|
|
|
|
|
|
|
|
|
|
; RUN: echo 'hello world' > %t.in
|
|
|
|
|
; RUN: echo 'goodbye' >> %t.in
|
|
|
|
|
; RUN: echo 'world' >> %t.in
|
[FileCheck] Annotate input dump (2/7)
This patch implements input annotations for diagnostics that suggest
fuzzy matches for directives for which no matches were found. Instead
of using the usual `^~~`, which is used by later patches for good
matches, these annotations use `?` so that fuzzy matches are visually
distinct. No tildes are included as these diagnostics (independently
of this patch) currently identify only the start of the match.
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
- X~~ marks search range when no match is found
- ? 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 check1 < input1 |& sed -n '/^<<<</,$p'
<<<<<<
1: ; abc def
2: ; ghI jkl
next:3'0 X~~~~~~~~ error: no match found
next:3'1 ? possible intended match
>>>>>>
$ cat check1
CHECK: abc
CHECK-SAME: def
CHECK-NEXT: ghi
CHECK-SAME: jkl
$ cat input1
; abc def
; ghI jkl
```
This patch introduces the concept of multiple "match results" per
directive. In the above example, the first match result for the
CHECK-NEXT directive is the failed match, for which the annotation
shows the search range. The second match result is the fuzzy match.
Later patches will introduce other cases of multiple match results per
directive.
When colors are enabled, `?` is colored magenta. That is, it doesn't
indicate the actual error, which a red `X~~` marker indicates, but its
color suggests it's closely related.
Reviewed By: george.karpenkov, probinson
Differential Revision: https://reviews.llvm.org/D53893
llvm-svn: 349419
2018-12-18 08:02:04 +08:00
|
|
|
; RUN: echo 'unicorn' >> %t.in
|
[FileCheck] Annotate input dump (1/7)
Extend FileCheck to dump its input annotated with FileCheck's
diagnostics: errors, good matches if -v, and additional information if
-vv. The goal is to make it easier to visualize FileCheck's matching
behavior when debugging.
Each patch in this series implements input annotations for a
particular category of FileCheck diagnostics. While the first few
patches alone are somewhat useful, the annotations become much more
useful as later patches implement annotations for -v and -vv
diagnostics, which show the matching behavior leading up to the error.
This first patch implements boilerplate plus input annotations for
error diagnostics reporting that no matches were found for a
directive. These annotations mark the search ranges of the failed
directives. Instead of using the usual `^~~`, which is used by later
patches for good matches, these annotations use `X~~` so that this
category of errors is visually distinct.
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 match result for a pattern of type T from line L of
the check file
- X~~ marks search range when no match is found
- colors error
If you are not seeing color above or in input dumps, try: -color
$ FileCheck -v -dump-input=always check1 < input1 |& sed -n '/^Input file/,$p'
Input file: <stdin>
Check file: check1
-dump-input=help describes the format of the following dump.
Full input was:
<<<<<<
1: ; abc def
2: ; ghI jkl
next:3 X~~~~~~~~ error: no match found
>>>>>>
$ cat check1
CHECK: abc
CHECK-SAME: def
CHECK-NEXT: ghi
CHECK-SAME: jkl
$ cat input1
; abc def
; ghI jkl
```
Some additional details related to the boilerplate:
* Enabling: The annotated input dump is enabled by `-dump-input`,
which can also be set via the `FILECHECK_OPTS` environment variable.
Accepted values are `help`, `always`, `fail`, or `never`. As shown
above, `help` describes the format of the dump. `always` is helpful
when you want to investigate a successful FileCheck run, perhaps for
an unexpected pass. `-dump-input-on-failure` and
`FILECHECK_DUMP_INPUT_ON_FAILURE` remain as a deprecated alias for
`-dump-input=fail`.
* Diagnostics: The usual diagnostics are not suppressed in this mode
and are printed first. For brevity in the example above, I've
omitted them using a sed command. Sometimes they're perfectly
sufficient, and then they make debugging quicker than if you were
forced to hunt through a dump of long input looking for the error.
If you think they'll get in the way sometimes, keep in mind that
it's pretty easy to grep for the start of the input dump, which is
`<<<`.
* Colored Annotations: The annotated input is colored if colors are
enabled (enabling colors can be forced using -color). For example,
errors are red. However, as in the above example, colors are not
vital to reading the annotations.
I don't know how to test color in the output, so any hints here would
be appreciated.
Reviewed By: george.karpenkov, zturner, probinson
Differential Revision: https://reviews.llvm.org/D52999
llvm-svn: 349418
2018-12-18 08:01:39 +08:00
|
|
|
|
|
|
|
|
; RUN: echo 'CHECK: hello' > %t.chk
|
|
|
|
|
; RUN: echo 'CHECK: universe' >> %t.chk
|
|
|
|
|
|
|
|
|
|
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -v 2>&1 \
|
|
|
|
|
; RUN: | FileCheck -strict-whitespace -match-full-lines -check-prefix=ALIGN %s
|
|
|
|
|
|
|
|
|
|
; ALIGN:Full input was:
|
|
|
|
|
; ALIGN-NEXT:<<<<<<
|
[FileCheck] Annotate input dump (2/7)
This patch implements input annotations for diagnostics that suggest
fuzzy matches for directives for which no matches were found. Instead
of using the usual `^~~`, which is used by later patches for good
matches, these annotations use `?` so that fuzzy matches are visually
distinct. No tildes are included as these diagnostics (independently
of this patch) currently identify only the start of the match.
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
- X~~ marks search range when no match is found
- ? 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 check1 < input1 |& sed -n '/^<<<</,$p'
<<<<<<
1: ; abc def
2: ; ghI jkl
next:3'0 X~~~~~~~~ error: no match found
next:3'1 ? possible intended match
>>>>>>
$ cat check1
CHECK: abc
CHECK-SAME: def
CHECK-NEXT: ghi
CHECK-SAME: jkl
$ cat input1
; abc def
; ghI jkl
```
This patch introduces the concept of multiple "match results" per
directive. In the above example, the first match result for the
CHECK-NEXT directive is the failed match, for which the annotation
shows the search range. The second match result is the fuzzy match.
Later patches will introduce other cases of multiple match results per
directive.
When colors are enabled, `?` is colored magenta. That is, it doesn't
indicate the actual error, which a red `X~~` marker indicates, but its
color suggests it's closely related.
Reviewed By: george.karpenkov, probinson
Differential Revision: https://reviews.llvm.org/D53893
llvm-svn: 349419
2018-12-18 08:02:04 +08:00
|
|
|
; ALIGN-NEXT: 1: hello world
|
|
|
|
|
; ALIGN-NEXT:check:2'0 X~~~~
|
|
|
|
|
; ALIGN-NEXT: 2: goodbye
|
|
|
|
|
; ALIGN-NEXT:check:2'0 ~~~~~~~
|
|
|
|
|
; ALIGN-NEXT: 3: world
|
|
|
|
|
; ALIGN-NEXT:check:2'0 ~~~~~
|
|
|
|
|
; ALIGN-NEXT: 4: unicorn
|
|
|
|
|
; ALIGN-NEXT:check:2'0 ~~~~~~~ error: no match found
|
|
|
|
|
; ALIGN-NEXT:check:2'1 ? possible intended match
|
[FileCheck] Annotate input dump (1/7)
Extend FileCheck to dump its input annotated with FileCheck's
diagnostics: errors, good matches if -v, and additional information if
-vv. The goal is to make it easier to visualize FileCheck's matching
behavior when debugging.
Each patch in this series implements input annotations for a
particular category of FileCheck diagnostics. While the first few
patches alone are somewhat useful, the annotations become much more
useful as later patches implement annotations for -v and -vv
diagnostics, which show the matching behavior leading up to the error.
This first patch implements boilerplate plus input annotations for
error diagnostics reporting that no matches were found for a
directive. These annotations mark the search ranges of the failed
directives. Instead of using the usual `^~~`, which is used by later
patches for good matches, these annotations use `X~~` so that this
category of errors is visually distinct.
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 match result for a pattern of type T from line L of
the check file
- X~~ marks search range when no match is found
- colors error
If you are not seeing color above or in input dumps, try: -color
$ FileCheck -v -dump-input=always check1 < input1 |& sed -n '/^Input file/,$p'
Input file: <stdin>
Check file: check1
-dump-input=help describes the format of the following dump.
Full input was:
<<<<<<
1: ; abc def
2: ; ghI jkl
next:3 X~~~~~~~~ error: no match found
>>>>>>
$ cat check1
CHECK: abc
CHECK-SAME: def
CHECK-NEXT: ghi
CHECK-SAME: jkl
$ cat input1
; abc def
; ghI jkl
```
Some additional details related to the boilerplate:
* Enabling: The annotated input dump is enabled by `-dump-input`,
which can also be set via the `FILECHECK_OPTS` environment variable.
Accepted values are `help`, `always`, `fail`, or `never`. As shown
above, `help` describes the format of the dump. `always` is helpful
when you want to investigate a successful FileCheck run, perhaps for
an unexpected pass. `-dump-input-on-failure` and
`FILECHECK_DUMP_INPUT_ON_FAILURE` remain as a deprecated alias for
`-dump-input=fail`.
* Diagnostics: The usual diagnostics are not suppressed in this mode
and are printed first. For brevity in the example above, I've
omitted them using a sed command. Sometimes they're perfectly
sufficient, and then they make debugging quicker than if you were
forced to hunt through a dump of long input looking for the error.
If you think they'll get in the way sometimes, keep in mind that
it's pretty easy to grep for the start of the input dump, which is
`<<<`.
* Colored Annotations: The annotated input is colored if colors are
enabled (enabling colors can be forced using -color). For example,
errors are red. However, as in the above example, colors are not
vital to reading the annotations.
I don't know how to test color in the output, so any hints here would
be appreciated.
Reviewed By: george.karpenkov, zturner, probinson
Differential Revision: https://reviews.llvm.org/D52999
llvm-svn: 349418
2018-12-18 08:01:39 +08:00
|
|
|
; ALIGN-NEXT:>>>>>>
|
|
|
|
|
; ALIGN-NOT:{{.}}
|
|
|
|
|
|
|
|
|
|
;--------------------------------------------------
|
[FileCheck] Annotate input dump (2/7)
This patch implements input annotations for diagnostics that suggest
fuzzy matches for directives for which no matches were found. Instead
of using the usual `^~~`, which is used by later patches for good
matches, these annotations use `?` so that fuzzy matches are visually
distinct. No tildes are included as these diagnostics (independently
of this patch) currently identify only the start of the match.
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
- X~~ marks search range when no match is found
- ? 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 check1 < input1 |& sed -n '/^<<<</,$p'
<<<<<<
1: ; abc def
2: ; ghI jkl
next:3'0 X~~~~~~~~ error: no match found
next:3'1 ? possible intended match
>>>>>>
$ cat check1
CHECK: abc
CHECK-SAME: def
CHECK-NEXT: ghi
CHECK-SAME: jkl
$ cat input1
; abc def
; ghI jkl
```
This patch introduces the concept of multiple "match results" per
directive. In the above example, the first match result for the
CHECK-NEXT directive is the failed match, for which the annotation
shows the search range. The second match result is the fuzzy match.
Later patches will introduce other cases of multiple match results per
directive.
When colors are enabled, `?` is colored magenta. That is, it doesn't
indicate the actual error, which a red `X~~` marker indicates, but its
color suggests it's closely related.
Reviewed By: george.karpenkov, probinson
Differential Revision: https://reviews.llvm.org/D53893
llvm-svn: 349419
2018-12-18 08:02:04 +08:00
|
|
|
; CHECK (also: multi-line search range, fuzzy match)
|
[FileCheck] Annotate input dump (1/7)
Extend FileCheck to dump its input annotated with FileCheck's
diagnostics: errors, good matches if -v, and additional information if
-vv. The goal is to make it easier to visualize FileCheck's matching
behavior when debugging.
Each patch in this series implements input annotations for a
particular category of FileCheck diagnostics. While the first few
patches alone are somewhat useful, the annotations become much more
useful as later patches implement annotations for -v and -vv
diagnostics, which show the matching behavior leading up to the error.
This first patch implements boilerplate plus input annotations for
error diagnostics reporting that no matches were found for a
directive. These annotations mark the search ranges of the failed
directives. Instead of using the usual `^~~`, which is used by later
patches for good matches, these annotations use `X~~` so that this
category of errors is visually distinct.
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 match result for a pattern of type T from line L of
the check file
- X~~ marks search range when no match is found
- colors error
If you are not seeing color above or in input dumps, try: -color
$ FileCheck -v -dump-input=always check1 < input1 |& sed -n '/^Input file/,$p'
Input file: <stdin>
Check file: check1
-dump-input=help describes the format of the following dump.
Full input was:
<<<<<<
1: ; abc def
2: ; ghI jkl
next:3 X~~~~~~~~ error: no match found
>>>>>>
$ cat check1
CHECK: abc
CHECK-SAME: def
CHECK-NEXT: ghi
CHECK-SAME: jkl
$ cat input1
; abc def
; ghI jkl
```
Some additional details related to the boilerplate:
* Enabling: The annotated input dump is enabled by `-dump-input`,
which can also be set via the `FILECHECK_OPTS` environment variable.
Accepted values are `help`, `always`, `fail`, or `never`. As shown
above, `help` describes the format of the dump. `always` is helpful
when you want to investigate a successful FileCheck run, perhaps for
an unexpected pass. `-dump-input-on-failure` and
`FILECHECK_DUMP_INPUT_ON_FAILURE` remain as a deprecated alias for
`-dump-input=fail`.
* Diagnostics: The usual diagnostics are not suppressed in this mode
and are printed first. For brevity in the example above, I've
omitted them using a sed command. Sometimes they're perfectly
sufficient, and then they make debugging quicker than if you were
forced to hunt through a dump of long input looking for the error.
If you think they'll get in the way sometimes, keep in mind that
it's pretty easy to grep for the start of the input dump, which is
`<<<`.
* Colored Annotations: The annotated input is colored if colors are
enabled (enabling colors can be forced using -color). For example,
errors are red. However, as in the above example, colors are not
vital to reading the annotations.
I don't know how to test color in the output, so any hints here would
be appreciated.
Reviewed By: george.karpenkov, zturner, probinson
Differential Revision: https://reviews.llvm.org/D52999
llvm-svn: 349418
2018-12-18 08:01:39 +08:00
|
|
|
;--------------------------------------------------
|
|
|
|
|
|
|
|
|
|
; Good match and no match.
|
|
|
|
|
|
|
|
|
|
; RUN: echo 'hello' > %t.in
|
|
|
|
|
; RUN: echo 'again' >> %t.in
|
|
|
|
|
; RUN: echo 'whirled' >> %t.in
|
|
|
|
|
|
|
|
|
|
; RUN: echo 'CHECK: hello' > %t.chk
|
|
|
|
|
; RUN: echo 'CHECK: 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=CHK
|
|
|
|
|
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -v 2>&1 \
|
|
|
|
|
; RUN: | FileCheck -match-full-lines %s -check-prefixes=CHK,CHK-V
|
|
|
|
|
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -vv 2>&1 \
|
|
|
|
|
; RUN: | FileCheck -match-full-lines %s -check-prefixes=CHK,CHK-V
|
|
|
|
|
|
|
|
|
|
; CHK: <<<<<<
|
[FileCheck] Annotate input dump (2/7)
This patch implements input annotations for diagnostics that suggest
fuzzy matches for directives for which no matches were found. Instead
of using the usual `^~~`, which is used by later patches for good
matches, these annotations use `?` so that fuzzy matches are visually
distinct. No tildes are included as these diagnostics (independently
of this patch) currently identify only the start of the match.
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
- X~~ marks search range when no match is found
- ? 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 check1 < input1 |& sed -n '/^<<<</,$p'
<<<<<<
1: ; abc def
2: ; ghI jkl
next:3'0 X~~~~~~~~ error: no match found
next:3'1 ? possible intended match
>>>>>>
$ cat check1
CHECK: abc
CHECK-SAME: def
CHECK-NEXT: ghi
CHECK-SAME: jkl
$ cat input1
; abc def
; ghI jkl
```
This patch introduces the concept of multiple "match results" per
directive. In the above example, the first match result for the
CHECK-NEXT directive is the failed match, for which the annotation
shows the search range. The second match result is the fuzzy match.
Later patches will introduce other cases of multiple match results per
directive.
When colors are enabled, `?` is colored magenta. That is, it doesn't
indicate the actual error, which a red `X~~` marker indicates, but its
color suggests it's closely related.
Reviewed By: george.karpenkov, probinson
Differential Revision: https://reviews.llvm.org/D53893
llvm-svn: 349419
2018-12-18 08:02:04 +08:00
|
|
|
; CHK-NEXT: 1: hello
|
|
|
|
|
; CHK-NEXT: 2: again
|
|
|
|
|
; CHK-NEXT: check:2'0 X~~~~
|
|
|
|
|
; CHK-NEXT: 3: whirled
|
|
|
|
|
; CHK-NEXT: check:2'0 ~~~~~~~ error: no match found
|
|
|
|
|
; CHK-NEXT: check:2'1 ? possible intended match
|
[FileCheck] Annotate input dump (1/7)
Extend FileCheck to dump its input annotated with FileCheck's
diagnostics: errors, good matches if -v, and additional information if
-vv. The goal is to make it easier to visualize FileCheck's matching
behavior when debugging.
Each patch in this series implements input annotations for a
particular category of FileCheck diagnostics. While the first few
patches alone are somewhat useful, the annotations become much more
useful as later patches implement annotations for -v and -vv
diagnostics, which show the matching behavior leading up to the error.
This first patch implements boilerplate plus input annotations for
error diagnostics reporting that no matches were found for a
directive. These annotations mark the search ranges of the failed
directives. Instead of using the usual `^~~`, which is used by later
patches for good matches, these annotations use `X~~` so that this
category of errors is visually distinct.
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 match result for a pattern of type T from line L of
the check file
- X~~ marks search range when no match is found
- colors error
If you are not seeing color above or in input dumps, try: -color
$ FileCheck -v -dump-input=always check1 < input1 |& sed -n '/^Input file/,$p'
Input file: <stdin>
Check file: check1
-dump-input=help describes the format of the following dump.
Full input was:
<<<<<<
1: ; abc def
2: ; ghI jkl
next:3 X~~~~~~~~ error: no match found
>>>>>>
$ cat check1
CHECK: abc
CHECK-SAME: def
CHECK-NEXT: ghi
CHECK-SAME: jkl
$ cat input1
; abc def
; ghI jkl
```
Some additional details related to the boilerplate:
* Enabling: The annotated input dump is enabled by `-dump-input`,
which can also be set via the `FILECHECK_OPTS` environment variable.
Accepted values are `help`, `always`, `fail`, or `never`. As shown
above, `help` describes the format of the dump. `always` is helpful
when you want to investigate a successful FileCheck run, perhaps for
an unexpected pass. `-dump-input-on-failure` and
`FILECHECK_DUMP_INPUT_ON_FAILURE` remain as a deprecated alias for
`-dump-input=fail`.
* Diagnostics: The usual diagnostics are not suppressed in this mode
and are printed first. For brevity in the example above, I've
omitted them using a sed command. Sometimes they're perfectly
sufficient, and then they make debugging quicker than if you were
forced to hunt through a dump of long input looking for the error.
If you think they'll get in the way sometimes, keep in mind that
it's pretty easy to grep for the start of the input dump, which is
`<<<`.
* Colored Annotations: The annotated input is colored if colors are
enabled (enabling colors can be forced using -color). For example,
errors are red. However, as in the above example, colors are not
vital to reading the annotations.
I don't know how to test color in the output, so any hints here would
be appreciated.
Reviewed By: george.karpenkov, zturner, probinson
Differential Revision: https://reviews.llvm.org/D52999
llvm-svn: 349418
2018-12-18 08:01:39 +08:00
|
|
|
; CHK-NEXT: >>>>>>
|
|
|
|
|
; CHK-NOT: {{.}}
|
|
|
|
|
|
|
|
|
|
;--------------------------------------------------
|
|
|
|
|
; CHECK-COUNT-<num>
|
|
|
|
|
;--------------------------------------------------
|
|
|
|
|
|
|
|
|
|
; Good match and no match.
|
|
|
|
|
|
|
|
|
|
; RUN: echo 'pete' > %t.in
|
|
|
|
|
; RUN: echo 'repete' >> %t.in
|
|
|
|
|
; RUN: echo 'repeat' >> %t.in
|
|
|
|
|
|
|
|
|
|
; RUN: echo 'CHECK-COUNT-3: pete' > %t.chk
|
|
|
|
|
|
|
|
|
|
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk 2>&1 \
|
|
|
|
|
; RUN: | FileCheck -match-full-lines %s -check-prefix=CNT
|
|
|
|
|
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -v 2>&1 \
|
|
|
|
|
; RUN: | FileCheck -match-full-lines %s -check-prefixes=CNT,CNT-V
|
|
|
|
|
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -vv 2>&1 \
|
|
|
|
|
; RUN: | FileCheck -match-full-lines %s -check-prefixes=CNT,CNT-V
|
|
|
|
|
|
|
|
|
|
; CNT: <<<<<<
|
|
|
|
|
; 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)
|
|
|
|
|
;--------------------------------------------------
|
|
|
|
|
|
|
|
|
|
; Good match and no match.
|
|
|
|
|
|
|
|
|
|
; RUN: echo 'hello' > %t.in
|
|
|
|
|
; RUN: echo 'again' >> %t.in
|
|
|
|
|
|
|
|
|
|
; RUN: echo 'CHECK: hello' > %t.chk
|
|
|
|
|
; RUN: echo 'CHECK-NEXT: again' >> %t.chk
|
|
|
|
|
; RUN: echo 'CHECK-NEXT: 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=NXT
|
|
|
|
|
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -v 2>&1 \
|
|
|
|
|
; RUN: | FileCheck -match-full-lines %s -check-prefixes=NXT,NXT-V
|
|
|
|
|
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -vv 2>&1 \
|
|
|
|
|
; RUN: | FileCheck -match-full-lines %s -check-prefixes=NXT,NXT-V,NXT-VV
|
|
|
|
|
|
|
|
|
|
; 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: {{.}}
|
|
|
|
|
|
|
|
|
|
;--------------------------------------------------
|
|
|
|
|
; CHECK-SAME (also: single-char search range)
|
|
|
|
|
;--------------------------------------------------
|
|
|
|
|
|
|
|
|
|
; 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: {{.}}
|
|
|
|
|
|
|
|
|
|
;--------------------------------------------------
|
|
|
|
|
; CHECK-EMPTY (also: search range ends at label)
|
|
|
|
|
;--------------------------------------------------
|
|
|
|
|
|
|
|
|
|
; 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.
|
|
|
|
|
|
|
|
|
|
; RUN: echo 'hello' > %t.in
|
|
|
|
|
; RUN: echo '' >> %t.in
|
|
|
|
|
; RUN: echo 'world' >> %t.in
|
|
|
|
|
; RUN: echo 'label' >> %t.in
|
|
|
|
|
|
|
|
|
|
; RUN: echo 'CHECK: hello' > %t.chk
|
|
|
|
|
; RUN: echo 'CHECK-EMPTY:' >> %t.chk
|
|
|
|
|
; RUN: echo 'CHECK-EMPTY:' >> %t.chk
|
|
|
|
|
; RUN: echo 'CHECK-LABEL: label' >> %t.chk
|
|
|
|
|
|
|
|
|
|
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk 2>&1 \
|
|
|
|
|
; RUN: | FileCheck -match-full-lines %s -check-prefix=EMP
|
|
|
|
|
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -v 2>&1 \
|
|
|
|
|
; RUN: | FileCheck -match-full-lines %s -check-prefixes=EMP,EMP-V
|
|
|
|
|
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -vv 2>&1 \
|
|
|
|
|
; RUN: | FileCheck -match-full-lines %s -check-prefixes=EMP,EMP-V,EMP-VV
|
|
|
|
|
|
|
|
|
|
; EMP: <<<<<<
|
|
|
|
|
; EMP-NEXT: 1: hello
|
|
|
|
|
; 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: {{.}}
|
|
|
|
|
|
|
|
|
|
;--------------------------------------------------
|
|
|
|
|
; 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
|
|
|
|
|
|
|
|
|
|
; RUN: echo 'CHECK-DAG: def' > %t.chk
|
|
|
|
|
; RUN: echo 'CHECK-DAG: abc' >> %t.chk
|
|
|
|
|
; RUN: echo 'CHECK-DAG: abc' >> %t.chk
|
|
|
|
|
; RUN: echo 'CHECK-DAG: def' >> %t.chk
|
|
|
|
|
|
|
|
|
|
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk 2>&1 \
|
|
|
|
|
; RUN: | FileCheck -match-full-lines %s -check-prefixes=DAG
|
|
|
|
|
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -v 2>&1 \
|
|
|
|
|
; RUN: | FileCheck -match-full-lines %s -check-prefixes=DAG
|
|
|
|
|
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -vv 2>&1 \
|
|
|
|
|
; RUN: | FileCheck -match-full-lines %s -check-prefixes=DAG
|
|
|
|
|
|
|
|
|
|
; DAG: <<<<<<
|
|
|
|
|
; DAG-NEXT: 1: abc
|
|
|
|
|
; DAG-NEXT: 2: def
|
|
|
|
|
; DAG-NEXT: 3: abc
|
|
|
|
|
; DAG-NEXT: dag:4 X~~ error: no match found
|
|
|
|
|
; DAG-NEXT: >>>>>>
|
|
|
|
|
; DAG-NOT: {{.}}
|
|
|
|
|
|
|
|
|
|
;--------------------------------------------------
|
|
|
|
|
; CHECK-LABEL
|
|
|
|
|
;--------------------------------------------------
|
|
|
|
|
|
|
|
|
|
; Good match and no match.
|
|
|
|
|
|
|
|
|
|
; RUN: echo 'lab0' > %t.in
|
|
|
|
|
; RUN: echo 'foo' >> %t.in
|
|
|
|
|
; RUN: echo 'lab1' >> %t.in
|
|
|
|
|
; RUN: echo 'bar' >> %t.in
|
|
|
|
|
|
|
|
|
|
; RUN: echo 'CHECK-LABEL: lab0' > %t.chk
|
|
|
|
|
; RUN: echo 'CHECK: foo' >> %t.chk
|
|
|
|
|
; RUN: echo 'CHECK-LABEL: lab2' >> %t.chk
|
|
|
|
|
|
|
|
|
|
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk 2>&1 \
|
|
|
|
|
; RUN: | FileCheck -match-full-lines %s -check-prefixes=LAB
|
|
|
|
|
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -v 2>&1 \
|
|
|
|
|
; RUN: | FileCheck -match-full-lines %s -check-prefixes=LAB,LAB-V
|
|
|
|
|
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -vv 2>&1 \
|
|
|
|
|
; RUN: | FileCheck -match-full-lines %s -check-prefixes=LAB,LAB-V,LAB-VV
|
|
|
|
|
|
|
|
|
|
; LAB: <<<<<<
|
[FileCheck] Annotate input dump (2/7)
This patch implements input annotations for diagnostics that suggest
fuzzy matches for directives for which no matches were found. Instead
of using the usual `^~~`, which is used by later patches for good
matches, these annotations use `?` so that fuzzy matches are visually
distinct. No tildes are included as these diagnostics (independently
of this patch) currently identify only the start of the match.
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
- X~~ marks search range when no match is found
- ? 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 check1 < input1 |& sed -n '/^<<<</,$p'
<<<<<<
1: ; abc def
2: ; ghI jkl
next:3'0 X~~~~~~~~ error: no match found
next:3'1 ? possible intended match
>>>>>>
$ cat check1
CHECK: abc
CHECK-SAME: def
CHECK-NEXT: ghi
CHECK-SAME: jkl
$ cat input1
; abc def
; ghI jkl
```
This patch introduces the concept of multiple "match results" per
directive. In the above example, the first match result for the
CHECK-NEXT directive is the failed match, for which the annotation
shows the search range. The second match result is the fuzzy match.
Later patches will introduce other cases of multiple match results per
directive.
When colors are enabled, `?` is colored magenta. That is, it doesn't
indicate the actual error, which a red `X~~` marker indicates, but its
color suggests it's closely related.
Reviewed By: george.karpenkov, probinson
Differential Revision: https://reviews.llvm.org/D53893
llvm-svn: 349419
2018-12-18 08:02:04 +08:00
|
|
|
; LAB-NEXT: 1: lab0
|
|
|
|
|
; LAB-NEXT: 2: foo
|
|
|
|
|
; LAB-NEXT: label:3'0 X~~
|
|
|
|
|
; LAB-NEXT: 3: lab1
|
|
|
|
|
; LAB-NEXT: label:3'0 ~~~~
|
|
|
|
|
; LAB-NEXT: label:3'1 ? possible intended match
|
|
|
|
|
; LAB-NEXT: 4: bar
|
|
|
|
|
; LAB-NEXT: label:3'0 ~~~ error: no match found
|
[FileCheck] Annotate input dump (1/7)
Extend FileCheck to dump its input annotated with FileCheck's
diagnostics: errors, good matches if -v, and additional information if
-vv. The goal is to make it easier to visualize FileCheck's matching
behavior when debugging.
Each patch in this series implements input annotations for a
particular category of FileCheck diagnostics. While the first few
patches alone are somewhat useful, the annotations become much more
useful as later patches implement annotations for -v and -vv
diagnostics, which show the matching behavior leading up to the error.
This first patch implements boilerplate plus input annotations for
error diagnostics reporting that no matches were found for a
directive. These annotations mark the search ranges of the failed
directives. Instead of using the usual `^~~`, which is used by later
patches for good matches, these annotations use `X~~` so that this
category of errors is visually distinct.
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 match result for a pattern of type T from line L of
the check file
- X~~ marks search range when no match is found
- colors error
If you are not seeing color above or in input dumps, try: -color
$ FileCheck -v -dump-input=always check1 < input1 |& sed -n '/^Input file/,$p'
Input file: <stdin>
Check file: check1
-dump-input=help describes the format of the following dump.
Full input was:
<<<<<<
1: ; abc def
2: ; ghI jkl
next:3 X~~~~~~~~ error: no match found
>>>>>>
$ cat check1
CHECK: abc
CHECK-SAME: def
CHECK-NEXT: ghi
CHECK-SAME: jkl
$ cat input1
; abc def
; ghI jkl
```
Some additional details related to the boilerplate:
* Enabling: The annotated input dump is enabled by `-dump-input`,
which can also be set via the `FILECHECK_OPTS` environment variable.
Accepted values are `help`, `always`, `fail`, or `never`. As shown
above, `help` describes the format of the dump. `always` is helpful
when you want to investigate a successful FileCheck run, perhaps for
an unexpected pass. `-dump-input-on-failure` and
`FILECHECK_DUMP_INPUT_ON_FAILURE` remain as a deprecated alias for
`-dump-input=fail`.
* Diagnostics: The usual diagnostics are not suppressed in this mode
and are printed first. For brevity in the example above, I've
omitted them using a sed command. Sometimes they're perfectly
sufficient, and then they make debugging quicker than if you were
forced to hunt through a dump of long input looking for the error.
If you think they'll get in the way sometimes, keep in mind that
it's pretty easy to grep for the start of the input dump, which is
`<<<`.
* Colored Annotations: The annotated input is colored if colors are
enabled (enabling colors can be forced using -color). For example,
errors are red. However, as in the above example, colors are not
vital to reading the annotations.
I don't know how to test color in the output, so any hints here would
be appreciated.
Reviewed By: george.karpenkov, zturner, probinson
Differential Revision: https://reviews.llvm.org/D52999
llvm-svn: 349418
2018-12-18 08:01:39 +08:00
|
|
|
; LAB-NEXT: >>>>>>
|
|
|
|
|
; LAB-NOT: {{.}}
|
|
|
|
|
|
|
|
|
|
|