[FileCheck]] Canonicalize caret location testing

[thopre]

Summary

Testing of caret location in diagnostic message is currently made with
CHECK directive with the following general format:
CHECK: {{^ \^$}}

James Henderson suggested the following would be more readable:
CHECK: {{^}} ^{{$}}

and when whole lines can be matched (as is the case for command-line
testing where error messages do not include path):
CHECK: ^
using the option --match-full-lines.

This commit implements these 2 changes on all existing caret position
tests. It also aligns the caret to the character it is trying to match
in the above line.

[jhenderson]

llvm/test/FileCheck/check-not-diaginfo.txt

8 ↗

(On Diff #210561)

In this context, where exactly is the caret actually pointing at? Can spaces be added to one or more lines to get the caret to nicely line up?

llvm/test/FileCheck/numeric-defines-diagnostics.txt

9 ↗

(On Diff #210561)

Up to you whether you do this, as you may not like it, but I recently realised that you could add leading spaces before the NUMERRCLIFMT: tag to make it line up nicely, whilst still honouring --match-full-lines. Something like:

NUMERRCLIFMT-NEXT:Global define #1: #10VALUE=10 (parsed as: {{\[\[#10
    NUMERRCLIFMT-NEXT:                                             ^

llvm/test/FileCheck/numeric-expression.txt

109 ↗

(On Diff #210561)

Similar to elsewhere, can you add/remove spaces on one line to make the caret line up with where it should? Same goes with other tests here.

[thopre]

Address review comment

[thopre]

I've reintroduced the {{$}} in end of lines because it is clear the intent was to test the whole lines in existing tests.

llvm/test/FileCheck/numeric-defines-diagnostics.txt

9 ↗

(On Diff #210561)

It help show the intent but makes it more difficult to check that the test is correct since the reader has to trust the test writer that the number of space at the beginning of the line equates the number of escape and syntax characters. All in all it's a gain for a loss IMHO so I'm happy to follow your suggestion.

[probinson]

Readability is to some extent in the eye of the reader, so I've restrained myself to one suggestion. Otherwise this review is up to James.

llvm/test/FileCheck/check-not-diaginfo.txt

6 ↗

(On Diff #210587)

Would this all be easier to read if you added --match-full-lines and then lined up the colons on each directive so the "full line" would start in the same place on each line?
Also then you would not need the leading {{^}} which should help clarify.

[thopre]

In D64923#1591865, @probinson wrote:

Readability is to some extent in the eye of the reader, so I've restrained myself to one suggestion. Otherwise this review is up to James.

While I do not like having different alignment for different lines to make the caret match, I do think it makes it obvious the test writer is trying to align the caret to where it should point to. So less readability (but as soon as you have regexes readability is pretty much out of the window) but clear(er) intent. I don't mind either way, except for the patch series to go forward :-)

llvm/test/FileCheck/check-not-diaginfo.txt

6 ↗

(On Diff #210587)

Unfortunately that is not possible because of the error line above which matches a line that would contain the path to the file and this would not be portable accross system, which is why I restricted this changes to the defines tests which refer to stdin.

It would be nice to have a way to turn that feature on/off for a subset of the directives.

[jhenderson]

LGTM.

[jhenderson]

This is a big improvement to my eyes :)

llvm/trunk/test/FileCheck/check-not-diaginfo.txt

-; RUN: not FileCheck -input-file %s %s 2>&1 | FileCheck -check-prefix DIAG %s
+; RUN: not FileCheck --input-file %s %s 2>&1 \
+; RUN:   | FileCheck --strict-whitespace --check-prefix DIAG %s
 
 CHECK-NOT: test
 
-DIAG:         error: CHECK-NOT: excluded string found in input
-DIAG-NEXT:    CHECK-NOT: test
-DIAG-NEXT: {{^           \^}}
-DIAG-NEXT:    note: found here
-DIAG-NEXT:    CHECK-NOT: test
-DIAG-NEXT: {{^           \^}}
+DIAG:           error: CHECK-NOT: excluded string found in input
+DIAG-NEXT:      CHECK-NOT: test
+DIAG-NEXT: {{^}}           ^{{$}}
+DIAG-NEXT:      note: found here
+DIAG-NEXT:      CHECK-NOT: test
+DIAG-NEXT: {{^}}           ^~~~{{$}}

llvm/trunk/test/FileCheck/numeric-defines-diagnostics.txt

 ; Test incorrect syntax for -D# option is correctly diagnosed.
 
 ; Invalid variable name: starts with a digit.
 RUN: not FileCheck -D#10VALUE=10 --input-file %s %s 2>&1 \
-RUN:   | FileCheck %s --strict-whitespace --check-prefix NUMERRCLIFMT
+RUN:   | FileCheck %s --strict-whitespace --match-full-lines --check-prefix NUMERRCLIFMT
 
-NUMERRCLIFMT: Global defines:1:46: error: invalid variable name
-NUMERRCLIFMT-NEXT: Global define #1: #10VALUE=10 (parsed as: {{\[\[#10VALUE:10\]\]}})
-NUMERRCLIFMT-NEXT: {{^                                             \^$}}
+NUMERRCLIFMT:Global defines:1:46: error: invalid variable name
+NUMERRCLIFMT-NEXT:Global define #1: #10VALUE=10 (parsed as: {{\[\[#10VALUE:10\]\]}})
+    NUMERRCLIFMT-NEXT:                                             ^
 
 ; Invalid definition of pseudo variable.
 RUN: not FileCheck -D#@VALUE=10 --input-file %s %s 2>&1 \
-RUN:   | FileCheck %s --strict-whitespace --check-prefix NUMERRCLIPSEUDO
+RUN:   | FileCheck %s --strict-whitespace --match-full-lines --check-prefix NUMERRCLIPSEUDO
 
-NUMERRCLIPSEUDO: Global defines:1:45: error: definition of pseudo numeric variable unsupported
-NUMERRCLIPSEUDO-NEXT: Global define #1: #@VALUE=10 (parsed as: {{\[\[#@VALUE:10\]\]}})
-NUMERRCLIPSEUDO-NEXT: {{^                                            \^$}}
+NUMERRCLIPSEUDO:Global defines:1:45: error: definition of pseudo numeric variable unsupported
+NUMERRCLIPSEUDO-NEXT:Global define #1: #@VALUE=10 (parsed as: {{\[\[#@VALUE:10\]\]}})
+    NUMERRCLIPSEUDO-NEXT:                                            ^
 
 ; Invalid definition of an expression.
 RUN: not FileCheck -D#VALUE+2=10 --input-file %s %s 2>&1 \
-RUN:   | FileCheck %s --strict-whitespace --check-prefix NUMERRCLITRAIL
+RUN:   | FileCheck %s --strict-whitespace --match-full-lines --check-prefix NUMERRCLITRAIL
 
-NUMERRCLITRAIL: Global defines:1:51: error: unexpected characters after numeric variable name
-NUMERRCLITRAIL-NEXT: Global define #1: #VALUE+2=10 (parsed as: {{\[\[#VALUE\+2:10\]\]}})
-NUMERRCLITRAIL-NEXT: {{^                                                  \^$}}
+NUMERRCLITRAIL:Global defines:1:51: error: unexpected characters after numeric variable name
+NUMERRCLITRAIL-NEXT:Global define #1: #VALUE+2=10 (parsed as: {{\[\[#VALUE\+2:10\]\]}})
+     NUMERRCLITRAIL-NEXT:                                                  ^

llvm/trunk/test/FileCheck/numeric-expression.txt

 RUN: not FileCheck --check-prefix UNDEF-USE --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix UNDEF-USE-MSG %s
 
 UNDEF VAR USE
 UNDEFVAR: 11
 UNDEF-USE-LABEL: UNDEF VAR USE
 UNDEF-USE-NEXT: UNDEFVAR: [[#UNDEFVAR1+UNDEFVAR2]]
 UNDEF-USE-MSG: numeric-expression.txt:[[#@LINE-1]]:17: error: {{U}}NDEF-USE-NEXT: expected string not found in input
-UNDEF-USE-MSG-NEXT: {{U}}NDEF-USE-NEXT: UNDEFVAR: {{\[\[#UNDEFVAR1\+UNDEFVAR2\]\]}}
-UNDEF-USE-MSG-NEXT: {{^                \^$}}
-UNDEF-USE-MSG-NEXT: numeric-expression.txt:[[#@LINE-6]]:1: note: scanning from here
-UNDEF-USE-MSG-NEXT: UNDEFVAR: 11
-UNDEF-USE-MSG-NEXT: {{^\^$}}
-UNDEF-USE-MSG-NEXT: numeric-expression.txt:[[#@LINE-9]]:1: note: uses undefined variable(s): "UNDEFVAR1" "UNDEFVAR2"
-UNDEF-USE-MSG-NEXT: UNDEFVAR: 11
-UNDEF-USE-MSG-NEXT: {{^\^$}}
+UNDEF-USE-MSG-NEXT:      {{U}}NDEF-USE-NEXT: UNDEFVAR: {{\[\[#UNDEFVAR1\+UNDEFVAR2\]\]}}
+UNDEF-USE-MSG-NEXT:     {{^}}                ^{{$}}
+UNDEF-USE-MSG-NEXT:      numeric-expression.txt:[[#@LINE-6]]:1: note: scanning from here
+UNDEF-USE-MSG-NEXT:      UNDEFVAR: 11
+UNDEF-USE-MSG-NEXT: {{^}}^{{$}}
+UNDEF-USE-MSG-NEXT:      numeric-expression.txt:[[#@LINE-9]]:1: note: uses undefined variable(s): "UNDEFVAR1" "UNDEFVAR2"
+UNDEF-USE-MSG-NEXT:      UNDEFVAR: 11
+UNDEF-USE-MSG-NEXT: {{^}}^{{$}}
 
 ; Numeric expression with unsupported operator.
 RUN: not FileCheck -D#NUMVAR=10 --check-prefix INVAL-OP --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix INVAL-OP-MSG %s
 
 INVALID OPERATOR
 NUMVAR*2: 22
 INVAL-OP-LABEL: INVALID OPERATOR
 INVAL-OP-NEXT: NUMVAR*2: [[#NUMVAR*2]]
 INVAL-OP-MSG: numeric-expression.txt:[[#@LINE-1]]:35: error: unsupported operation '*'
 INVAL-OP-MSG-NEXT: {{I}}NVAL-OP-NEXT: NUMVAR*2: {{\[\[#NUMVAR\*2\]\]}}
-INVAL-OP-MSG-NEXT: {{^                                  \^$}}
+INVAL-OP-MSG-NEXT:     {{^}}                                  ^{{$}}
 
 ; Name conflict between Numeric variable definition and string variable
 ; definition whether from the command-line or input text.
 RUN: not FileCheck --check-prefixes CONFLICT,CONFLICT1,CONFLICT2 --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix INPUT-STR-CONFLICT %s
 RUN: not FileCheck -D#NUMVAR=42 --check-prefixes CONFLICT,CONFLICT2 --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix INPUT-STR-CONFLICT %s
 RUN: not FileCheck -D#NUMVAR=42 -DNUMVAR=foobar --check-prefix CONFLICT --input-file %s %s 2>&1 \

 redef2 42
 CONFLICT-LABEL: STRVAR NUMVAR CONFLICT
 CONFLICT1-NEXT: redef1 [[#NUMVAR:]]
 CONFLICT2: [[NUMVAR:foo.*]]
 CONFLICT3: [[STRVAR:foo.*]]
 CONFLICT4: redef2 [[#STRVAR:]]
 INPUT-STR-CONFLICT: numeric-expression.txt:[[#@LINE-3]]:14: error: numeric variable with name 'NUMVAR' already exists
 INPUT-STR-CONFLICT-NEXT: {{C}}ONFLICT2: {{\[\[NUMVAR:foo\.\*\]\]}}
-INPUT-STR-CONFLICT-NEXT: {{^             \^$}}
+INPUT-STR-CONFLICT-NEXT:    {{^}}             ^{{$}}
 CLI-STR-CONFLICT: Global defines:2:19: error: numeric variable with name 'NUMVAR' already exists
-CLI-STR-CONFLICT-NEXT: Global define #2: NUMVAR=foobar
-CLI-STR-CONFLICT-NEXT: {{^                  \^$}}
+CLI-STR-CONFLICT-NEXT:      Global define #2: NUMVAR=foobar
+CLI-STR-CONFLICT-NEXT: {{^}}                  ^{{$}}
 INPUT-NUM-CONFLICT: numeric-expression.txt:[[#@LINE-7]]:22: error: string variable with name 'STRVAR' already exists
  INPUT-NUM-CONFLICT-NEXT: CONFLICT4: redef2 {{\[\[#STRVAR:\]\]}}
-INPUT-NUM-CONFLICT-NEXT: {{^                     \^$}}
+INPUT-NUM-CONFLICT-NEXT: {{^}}                     ^{{$}}
 CLI-NUM-CONFLICT: Global defines:2:45: error: string variable with name 'STRVAR' already exists
  CLI-NUM-CONFLICT-NEXT: Global define #2: #STRVAR=42 (parsed as: {{\[\[#STRVAR:42\]\]}})
-CLI-NUM-CONFLICT-NEXT: {{^                                            \^$}}
+CLI-NUM-CONFLICT-NEXT: {{^}}                                            ^{{$}}
 
 ; Numeric variable definition with too big value.
 RUN: not FileCheck --check-prefix BIGVAL --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix BIGVAL-MSG %s
 
 BIG VALUE
 NUMVAR: 10000000000000000000000
 BIGVAL-LABEL: BIG VALUE
 BIGVAL-NEXT: NUMVAR: [[#NUMVAR:]]
 BIGVAL-MSG: numeric-expression.txt:[[#@LINE-3]]:9: error: Unable to represent numeric value
  BIGVAL-MSG-NEXT: {{N}}UMVAR: 10000000000000000000000
-BIGVAL-MSG-NEXT: {{^        \^$}}
+BIGVAL-MSG-NEXT: {{^}}        ^{{$}}
 
 ; Verify that when a variable is set to an expression the expression is still
 ; checked.
 RUN: not FileCheck --check-prefix DEF-EXPR-FAIL --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix DEF-EXPR-FAIL-MSG %s
 
 DEF EXPR WRONG MATCH
 20
 43
 DEF-EXPR-FAIL-LABEL: DEF EXPR WRONG MATCH
 DEF-EXPR-FAIL-NEXT: [[# VAR20:]]
 DEF-EXPR-FAIL-NEXT: [[# VAR42: VAR20+22]]
 DEF-EXPR-FAIL-MSG: numeric-expression.txt:[[#@LINE-1]]:21: error: {{D}}EF-EXPR-FAIL-NEXT: is not on the line after the previous match
 DEF-EXPR-FAIL-MSG-NEXT: {{D}}EF-EXPR-FAIL-NEXT: {{\[\[# VAR42: VAR20\+22\]\]}}
-DEF-EXPR-FAIL-MSG-NEXT: {{^                    \^$}}
+DEF-EXPR-FAIL-MSG-NEXT:   {{^}}                    ^{{$}}

llvm/trunk/test/FileCheck/string-defines-diagnostics.txt

 ; Missing variable name.
 RUN: not FileCheck -D= --input-file %s %s 2>&1 \
 RUN:   | FileCheck %s --check-prefix ERRCLIVAR2
 
 ERRCLIVAR2: Missing variable name in command-line definition '-D='
 
 ; Invalid variable name: starts with a digit.
 RUN: not FileCheck -D10VALUE=10 --input-file %s %s 2>&1 \
-RUN:   | FileCheck %s --strict-whitespace --check-prefix ERRCLIFMT
+RUN:   | FileCheck %s --strict-whitespace --match-full-lines --check-prefix ERRCLIFMT
 
-ERRCLIFMT: Global defines:1:19: error: invalid variable name
-ERRCLIFMT-NEXT: Global define #1: 10VALUE=10
-ERRCLIFMT-NEXT: {{^                  \^$}}
+ERRCLIFMT:Global defines:1:19: error: invalid variable name
+ERRCLIFMT-NEXT:Global define #1: 10VALUE=10
+ERRCLIFMT-NEXT:                  ^
 
 ; Invalid definition of pseudo variable.
 RUN: not FileCheck -D@VALUE=10 --input-file %s %s 2>&1 \
-RUN:   | FileCheck %s --strict-whitespace --check-prefix ERRCLIPSEUDO
+RUN:   | FileCheck %s --strict-whitespace --match-full-lines --check-prefix ERRCLIPSEUDO
 
-ERRCLIPSEUDO: Global defines:1:19: error: invalid name in string variable definition '@VALUE'
-ERRCLIPSEUDO-NEXT: Global define #1: @VALUE=10
-ERRCLIPSEUDO-NEXT: {{^                  \^$}}
+ERRCLIPSEUDO:Global defines:1:19: error: invalid name in string variable definition '@VALUE'
+ERRCLIPSEUDO-NEXT:Global define #1: @VALUE=10
+ERRCLIPSEUDO-NEXT:                  ^
 
 ; Invalid definition of an expression.
 RUN: not FileCheck -D'VALUE + 2=10' --input-file %s %s 2>&1 \
 RUN:   | FileCheck %s --strict-whitespace --check-prefix ERRCLITRAIL
 
-ERRCLITRAIL: Global defines:1:19: error: invalid name in string variable definition 'VALUE + 2'
-ERRCLITRAIL-NEXT: Global define #1: VALUE + 2=10
-ERRCLITRAIL-NEXT: {{^                  \^$}}
+ERRCLITRAIL:Global defines:1:19: error: invalid name in string variable definition 'VALUE + 2'
+ERRCLITRAIL-NEXT:Global define #1: VALUE + 2=10
+ERRCLITRAIL-NEXT:                  ^

llvm/trunk/test/FileCheck/verbose.txt

 ; RUN: FileCheck -input-file %s %s 2>&1 | FileCheck -check-prefix QUIET --allow-empty %s
 ; RUN: FileCheck -v -input-file %s %s 2>&1 | FileCheck --strict-whitespace -check-prefix V %s
 ; RUN: FileCheck -vv -input-file %s %s 2>&1 | FileCheck --strict-whitespace -check-prefixes V,VV %s
 
 foo
 bar
 CHECK: foo
 CHECK-NOT: raboof
 CHECK-NEXT: bar
 
 V:      verbose.txt:[[@LINE-4]]:8: remark: {{C}}HECK: expected string found in input
-V-NEXT: {{C}}HECK: foo{{$}}
-V-NEXT:  {{^       \^$}}
+V-NEXT:  {{C}}HECK: foo{{$}}
+V-NEXT: {{^}}       ^{{$}}
 V-NEXT: verbose.txt:[[@LINE-9]]:1: note: found here
 V-NEXT: {{^}}foo{{$}}
 V-NEXT: {{^}}^~~{{$}}
 
 V-NEXT: verbose.txt:[[@LINE-9]]:13: remark: {{C}}HECK-NEXT: expected string found in input
-V-NEXT: {{C}}HECK-NEXT: bar{{$}}
-V-NEXT:  {{^            \^$}}
+V-NEXT:  {{C}}HECK-NEXT: bar{{$}}
+V-NEXT: {{^}}            ^{{$}}
 V-NEXT: verbose.txt:[[@LINE-15]]:1: note: found here
 V-NEXT: {{^}}bar{{$}}
 V-NEXT: {{^}}^~~{{$}}
 
 VV-NEXT: verbose.txt:[[@LINE-17]]:12: remark: {{C}}HECK-NOT: excluded string not found in input
-VV-NEXT: {{C}}HECK-NOT: raboof{{$}}
-VV-NEXT:  {{^           \^$}}
+VV-NEXT:  {{C}}HECK-NOT: raboof{{$}}
+VV-NEXT: {{^}}           ^{{$}}
 VV-NEXT: verbose.txt:[[@LINE-22]]:1: note: scanning from here
 VV-NEXT: {{^}}bar{{$}}
 VV-NEXT: {{^}}^{{$}}
 
 NUMVAR=42
 NUMVAR - 1:41
 CHECK: NUMVAR=[[#NUMVAR:]]
 CHECK-NOT: [[#NUMVAR + 1]]
 CHECK-NEXT: NUMVAR - 1:[[#NUMVAR - 1]]
 
 V:      verbose.txt:[[#@LINE-4]]:8: remark: {{C}}HECK: expected string found in input
 V-NEXT: {{C}}HECK: {{NUMVAR=[[][[]#NUMVAR:[]][]]$}}
-V-NEXT: {{^       \^$}}
+V-NEXT:  {{^}}       ^{{$}}
 V-NEXT: verbose.txt:[[#@LINE-9]]:1: note: found here
 V-NEXT: {{^}}NUMVAR=42{{$}}
 V-NEXT: {{^}}^~~~~~~~~{{$}}
 
 V-NEXT: verbose.txt:[[#@LINE-9]]:13: remark: {{C}}HECK-NEXT: expected string found in input
 V-NEXT: {{C}}HECK-NEXT: {{NUMVAR - 1:[[][[]#NUMVAR - 1[]][]]$}}
-V-NEXT: {{^            \^$}}
+V-NEXT:  {{^}}            ^{{$}}
 V-NEXT: verbose.txt:[[#@LINE-15]]:1: note: found here
 V-NEXT: {{^}}NUMVAR - 1:41{{$}}
 V-NEXT: {{^}}^~~~~~~~~~~~~{{$}}
 V-NEXT: verbose.txt:[[#@LINE-18]]:1: note: with "NUMVAR - 1" equal to "41"
 V-NEXT: {{^}}NUMVAR - 1:41{{$}}
 V-NEXT: {{^}}^~~~~~~~~~~~~{{$}}
 
 VV-NEXT: verbose.txt:[[#@LINE-20]]:12: remark: {{C}}HECK-NOT: excluded string not found in input
 VV-NEXT: {{C}}HECK-NOT: {{[[][[]#NUMVAR [+] 1[]][]]$}}
-VV-NEXT:  {{^           \^$}}
+VV-NEXT:   {{^}}           ^{{$}}
 VV-NEXT: verbose.txt:[[#@LINE-25]]:1: note: scanning from here
 VV-NEXT: {{^}}NUMVAR - 1:41{{$}}
 VV-NEXT: {{^}}^{{$}}
 
 before empty
 
 after empty
 CHECK: before empty
 CHECK-EMPTY:
 CHECK-NEXT: after empty
 
 V:      verbose.txt:[[@LINE-4]]:8: remark: {{C}}HECK: expected string found in input
-V-NEXT: {{C}}HECK: before empty{{$}}
-V-NEXT:  {{^       \^$}}
+V-NEXT:  {{C}}HECK: before empty{{$}}
+V-NEXT: {{^}}       ^{{$}}
 V-NEXT: verbose.txt:[[@LINE-10]]:1: note: found here
 V-NEXT: {{^}}before empty{{$}}
 V-NEXT: {{^}}^~~~~~~~~~~~{{$}}
 
 V-NEXT:  verbose.txt:[[@LINE-10]]:13: remark: {{C}}HECK-EMPTY: expected string found in input
-V-NEXT:  {{C}}HECK-EMPTY:{{$}}
-V-NEXT:   {{^            \^$}}
+V-NEXT:   {{C}}HECK-EMPTY:{{$}}
+V-NEXT:  {{^}}            ^{{$}}
 V-NEXT:  verbose.txt:[[@LINE-16]]:1: note: found here
 V-EMPTY:
 V-NEXT:  {{^}}^{{$}}
 
 V-NEXT: verbose.txt:[[@LINE-16]]:13: remark: {{C}}HECK-NEXT: expected string found in input
-V-NEXT: {{C}}HECK-NEXT: after empty{{$}}
-V-NEXT:  {{^            \^$}}
+V-NEXT:  {{C}}HECK-NEXT: after empty{{$}}
+V-NEXT: {{^}}            ^{{$}}
 V-NEXT: verbose.txt:[[@LINE-22]]:1: note: found here
 V-NEXT: {{^}}after empty{{$}}
 V-NEXT: {{^}}^~~~~~~~~~~{{$}}
 
 abcdef
 abcdef
 CHECK-DAG: abcdef
 CHECK-DAG: def
 
 V-NEXT: verbose.txt:[[@LINE-3]]:12: remark: {{C}}HECK-DAG: expected string found in input
-V-NEXT: {{C}}HECK-DAG: abcdef
-V-NEXT:  {{^           \^$}}
+V-NEXT:  {{C}}HECK-DAG: abcdef
+V-NEXT: {{^}}           ^{{$}}
 V-NEXT: verbose.txt:[[@LINE-8]]:1: note: found here
 V-NEXT: {{^}}abcdef{{$}}
 V-NEXT: {{^}}^~~~~~{{$}}
 
 VV-NEXT: verbose.txt:[[@LINE-9]]:12: remark: {{C}}HECK-DAG: expected string found in input
-VV-NEXT: {{C}}HECK-DAG: def
-VV-NEXT:  {{^           \^$}}
+VV-NEXT:  {{C}}HECK-DAG: def
+VV-NEXT: {{^}}           ^{{$}}
 VV-NEXT: verbose.txt:[[@LINE-15]]:4: note: found here
-VV-NEXT: {{^abcdef$}}
-VV-NEXT: {{^   \^~~$}}
+VV-NEXT:   {{^abcdef$}}
+VV-NEXT: {{^}}   ^~~
 VV-NEXT: verbose.txt:[[@LINE-18]]:1: note: match discarded, overlaps earlier DAG match here
 VV-NEXT: {{^}}abcdef{{$}}
 VV-NEXT: {{^}}^~~~~~{{$}}
 
 V-NEXT: verbose.txt:[[@LINE-19]]:12: remark: {{C}}HECK-DAG: expected string found in input
-V-NEXT: {{C}}HECK-DAG: def
-V-NEXT:  {{^           \^$}}
+V-NEXT:  {{C}}HECK-DAG: def
+V-NEXT: {{^}}           ^{{$}}
 V-NEXT: verbose.txt:[[@LINE-24]]:4: note: found here
-V-NEXT: {{^abcdef$}}
-V-NEXT: {{^   \^~~$}}
+V-NEXT:   {{^abcdef$}}
+V-NEXT: {{^}}   ^~~
 
 xyz
 CHECK: xyz
 CHECK-NOT: {{z}}yx
 
 V:      verbose.txt:[[@LINE-3]]:8: remark: {{C}}HECK: expected string found in input
-V-NEXT: {{C}}HECK: xyz{{$}}
-V-NEXT:  {{^       \^$}}
+V-NEXT:  {{C}}HECK: xyz{{$}}
+V-NEXT: {{^}}       ^{{$}}
 V-NEXT: verbose.txt:[[@LINE-7]]:1: note: found here
 V-NEXT: {{^}}xyz{{$}}
 V-NEXT: {{^}}^~~{{$}}
 
 VV-NEXT: verbose.txt:[[@LINE-9]]:19: remark: implicit EOF: expected string found in input
 VV-NEXT: {{C}}HECK-NOT: {{[{][{]z[}][}]yx$}}
-VV-NEXT:   {{^                  \^$}}
+VV-NEXT:          {{^}}                  ^{{$}}
 VV-NEXT: verbose.txt:[[@LINE+13]]:1: note: found here
 VV-NOT:  {{.}}
-VV:      {{^\^$}}
+VV:      {{^}}^
 
 VV-NEXT: verbose.txt:[[@LINE-16]]:12: remark: {{C}}HECK-NOT: excluded string not found in input
 VV-NEXT: {{C}}HECK-NOT: {{[{][{]z[}][}]yx$}}
-VV-NEXT:  {{^           \^$}}
+VV-NEXT:   {{^}}           ^{{$}}
 VV-NEXT: verbose.txt:[[@LINE-20]]:1: note: scanning from here
 VV-NEXT: {{^C}}HECK: xyz{{$}}
-VV-NEXT: {{^\^$}}
+VV-NEXT: {{^}}^{{$}}
 
 QUIET-NOT: {{.}}
 V-NOT: {{.}}