[clang][Diagnostics] Show line numbers when printing code snippets

[tbaeder]

Summary

Just putting this here because it's a pretty simple patch as it turns out.

Done:

1. Increase -fcaret-diagnostics-max-lines default to 16.
2. Add -fdiagnostics-show-line-numbers to disable the margin with the line numbers on the left
3. Actually show the line numbers in all diagnostics.
4. Fix up tests.

Sample output:

./array.cpp:98:1: error: static assertion failed due to requirement 'func()'
  98 | static_assert(
     | ^
  99 |     // I wonder if this works.
 100 |     // Also, what if it doesn't?
 101 |     func());
     |     ~~~~~~
1 error generated.

[tbaeder]

clang/lib/Frontend/TextDiagnostic.cpp

1138

Wrote this just to get things going but I hope there's something better than this...?

[aaron.ballman]

GCC emits line numbers by default these days, so it seems reasonable for Clang to do so as well. Having a way to disable the feature is important though as some folks have scripts that scrap diagnostic results and changing the format may break those scripts in challenging ways. GCC supports -fno-diagnostics-show-line-numbers and we should do the same. GCC also supports -fdiagnostics-minimum-margin-width=width which we might want to consider supporting up front as well.

As for -fcaret-diagnostics-max-lines, I think I agree that the current default of 1 makes this functionality a bit less than useful, but perhaps we want to change that default value now? Alternatively, do we want to tie this option to the number of max lines? e.g., if the max lines is one, then we disable line numbers by default, but if the max lines is > 1, we enable line numbers by default?

[cjdb]

I have no opinion on this addition. If folks find it useful in GCC, happy to see it added.

clang/lib/Frontend/TextDiagnostic.cpp

1136

I'd prefer this to be an assert rather than returning a value. We should never be able to return from here.

[tbaeder]

Wow, in FixIt/fixits-function-call, this output:

./array.cpp:123:3: error: no matching function for call to 'f1'
  f1(a + 1);
  ^~
./array.cpp:114:6: note: candidate function not viable: no known conversion from 'intTy2 *' (aka 'int *') to 'intTy &' (aka 'int &') for 1st argument; dereference the argument with *
void f1(intTy &a);
     ^
fix-it:"./array.cpp":{123:6-123:6}:"*("
fix-it:"./array.cpp":{123:11-123:11}:")"

now (with increased snippet line limit) prints:

./array.cpp:123:3: error: no matching function for call to 'f1'
  123 |   f1(a + 1);
      |   ^~
./array.cpp:114:6: note: candidate function not viable: no known conversion from 'intTy2 *' (aka 'int *') to 'intTy &' (aka 'int &') for 1st argument; dereference the argument with *
  114 | void f1(intTy &a);
      |      ^
  116 | void f2(intTy2 *a) {
  117 | // CHECK: error: no matching function for call to 'f1
  118 | // CHECK: dereference the argument with *
  119 | // CHECK: void f1(intTy &a);
  120 | // CHECK: fix-it{{.*}}*(
  121 | // CHECK-NEXT: fix-it{{.*}})
  122 | // CHECK: void f1(double *a);
  123 |   f1(a + 1);
      |      ~~~~~
      |      *(   )
fix-it:"./array.cpp":{123:6-123:6}:"*("
fix-it:"./array.cpp":{123:11-123:11}:")"

Is this actually what we want? It somehow makes sense but also doesn't. It's weird that the test ensures the parseable fixits but the output doesn't show the fixit at all (in the first case).

[tbaeder]

Since basically nobody has seen multiple snippet lines being printed, we probably need to fix up a bunch of diagnostics afterwards to be more useful, e.g.

./array.cpp:111:5: error: no matching function for call to 'func'
  111 |     func(1, 2, 3, 4), "hah, reason!");
      |     ^~~~
./array.cpp:96:16: note: candidate function not viable: requires 7 arguments, but 4 were provided
   96 | consteval bool func(int why,
      |                ^    ~~~~~~~~
   97 |                     int would_my,
      |                     ~~~~~~~~~~~~~
   98 |                     int compiler_complain,
      |                     ~~~~~~~~~~~~~~~~~~~~~~
   99 |                     int about_the_arguments,
      |                     ~~~~~~~~~~~~~~~~~~~~~~~~
  100 |                     int but_not_show_them_to_me,
      |                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  101 |                     int if_the_declaration_covers_multiple_lines,
      |                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  102 |                     int big_question_mark) {
      |                     ~~~~~~~~~~~~~~~~~~~~~
1 error generated.

has annoyed me in the past (using one argument per line is common in some coding styles).

[tbaeder]

Ping

[tbaeder]

Fix all existing tests

[tbaeder]

CCing @njames93 since I have no idea how to properly fix the clang-tidy test failures.

[PiotrZSL]

In D147875#4283135, @tbaeder wrote:

CCing @njames93 since I have no idea how to properly fix the clang-tidy test failures.

I look into some of those tests, there are 1 way to fix them. Tried to -fno-diagnostics-show-line-numbers but clang-tidy got history of ignoring those diagnostic flags, I thing there are some issues open for it.

In those tests you got thing like this:

// CHECK-MESSAGES-NEXT: ^~~
// CHECK-MESSAGES-NEXT: {{^ *}}LU{{$}}

this could be changed into something like this:

// CHECK-MESSAGES-NEXT: ^~~
// CHECK-MESSAGES-NEXT: {{^ *\| *}}LU{{$}}

Simply this matching beginning of a line. by using ^ *\| * we match: beginning of line, any number of white spaces, character | any number of white spaces.

[PiotrZSL]

clang-tools-extra/test/clang-tidy/checkers/cert/uppercase-literal-suffix-integer.cpp

34

In theory you should escape this character (|) by using \, otherwise it could be interpreted as an regexp or. Still looks like this test file passes, so 7 to go.

[tbaeder]

clang-tools-extra/test/clang-tidy/checkers/cert/uppercase-literal-suffix-integer.cpp

34

Yeah I noticed the missing backslash but the test passed.

For the other tests, I've just removed the {{^ *}} before the uppercase suffix. It seems pointless to check that the line contains nothing else(?). I can revert that of course, but it seemed like the easier fix.

[PiotrZSL]

Clang-tidy related changes looks fine.

[aaron.ballman]

This should definitely have explicit documentation added to https://github.com/llvm/llvm-project/blob/main/clang/docs/UsersManual.rst?plain=1#L156 and a release note.

Adding clang-vendors because of the potential that this is a breaking change for some folks doing diagnostic scraping; perhaps we should also mention this under potentially breaking changes in the release notes?

clang/include/clang/Driver/Options.td

2548

I'm hopeful that defaulting this to true (which matches the GCC behavior) is reasonable, but I'm a bit worried about how downstreams will react to this. Specifically, I'm wondering about things like clang-cl integration in MSVC or clang use in Xcode, where diagnostics are being displayed other than on the command line.

clang/test/FixIt/fixit-function-call.cpp

1

Just to double-check, parseable diagnostic output still works even if line numbers are shown, yes?

[kwk]

@tbaeder I have a small suggestion.

clang/lib/Frontend/TextDiagnostic.cpp

1121–1138

This function screamed at me to be generalized so I gave it a try: https://gist.github.com/kwk/7e408065ea291e49fea4a83cf90a9cdf

[jrtc27]

clang/lib/Frontend/TextDiagnostic.cpp

1121–1138

I don't think I want floating point arithmetic in my compiler... Something like:

unsigned L, M;
for (L = 1U, M = 10U; N >= M && M != ~0U; ++L)
    M = (M > ((~0U) / 10U)) ? (~0U) : (M * 10U);

return (L);

is the generalised form (without all the redundant parentheses I added during debugging).

[tbaeder]

clang/test/FixIt/fixit-function-call.cpp

1

Yes, at leat we don't prepend the line numbers to the parseable fixits:

   21 | // CHECK-NEXT: fix-it{{.*}})
   22 | // CHECK: void f1(double *a);
   23 |   f1(a + 1);
      |      ~~~~~
      |      *(   )
fix-it:"../clang/test/FixIt/fixit-function-call.cpp":{23:6-23:6}:"*("
fix-it:"../clang/test/FixIt/fixit-function-call.cpp":{23:11-23:11}:")"

[tbaeder]

Add docs and a release note.

[aaron.ballman]

clang/lib/Frontend/TextDiagnostic.cpp

1121–1138

Cleaned up a bit:

constexpr unsigned getNumDisplayWidth(unsigned N) {
  unsigned L = 1U, M = 10U;
  constexpr unsigned Upper = ~0U / 10U;
  for (; N >= M && M != ~0U; ++L)
    M = M > Upper ? ~0U : M * 10U;
  return L;
}

https://godbolt.org/z/szTYsEM4v

clang/test/FixIt/fixit-function-call.cpp

1

Excellent, thank you!

[efriedma]

clang/lib/Frontend/TextDiagnostic.cpp

1121–1138

Slightly less efficient, but easier to read:

unsigned getNumDisplayWidth(unsigned N) {
  unsigned Width = 1;
  for (; N >= 10; ++Width)
    N /= 10;
  return Width;
}

[aaronpuchert]

clang/include/clang/Driver/Options.td

2548

I don't like line number margins that much, but I think it should be Ok. What I've seen of compiler output parsers, they mainly concentrate on the <file>:<line>[:<column>]: <kind>: <message> lines and ignore code snippets. After all, once they have the source location, they can just look at the file.

clang/lib/Frontend/TextDiagnostic.cpp

1121–1138

I'd suggest to replace ~0U by std::numeric_limits<unsigned>::max(). And if we're looking at <limits>, why not ask it directly how far we need to go?

static unsigned getNumDisplayWidth(unsigned N) {
  unsigned L = 1u, M = 10u;
  constexpr unsigned Max = std::numeric_limits<unsigned>::digits10 + 1;
  for (; M <= N && L != Max; ++L)
    M *= 10u;
  return L;
}

This will let the overflow happen, but that should be fine for unsigned arithmetic. Without overflow:

static unsigned getNumDisplayWidth(unsigned N) {
  unsigned L = 1u, M = 10u;
  while (M <= N && L++ != std::numeric_limits<unsigned>::digits10)
    M *= 10u;
  return L;
}

The trick is that the increment is done even if the comparison fails and we exit the loop.

[aaronpuchert]

clang/lib/Frontend/TextDiagnostic.cpp

1121–1138

Though pre-increment also does it if we change the right-hand side:

while (M <= N && ++L != std::numeric_limits<unsigned>::digits10 + 1)
  M *= 10u;

[tbaeder]

Ping

[aaron.ballman]

clang/lib/Frontend/TextDiagnostic.cpp

1121–1138

+1 to the final suggestion that's fully generalized.

[aaron.ballman]

LGTM!

[hans]

clang/docs/UsersManual.rst

578

I think this is still a cc1-only option. Should it be made available as a driver option now?

[tbaeder]

clang/docs/UsersManual.rst

578

No strong opinion from my side, but would certainly make sense to me.

[dyung]

clang/docs/ReleaseNotes.rst

290

Is this correct? I notice that all of the tests you update used the form of the option "-fcaret-diagnostics-max-lines n" rather than "-fcaret-diagnostics-max-lines=n". When I tried to update some private tests to use "-fcaret-diagnostics-max-lines=n", the compiler did not accept it, but when I changed it to use "-fcaret-diagnostics-max-lines n" it worked. I think we either need to update the option to accept both forms or to correct the documentation.

[tbaeder]

clang/docs/ReleaseNotes.rst

290

Yes, you're right, that should be changed.

[tbaeder]

@hans @dyung I've opened https://reviews.llvm.org/D152090 which should fix both of your concerns.

[hans]

I noticed that at least for some cases of -Wformat, the line numbers on the left seem to be off: https://github.com/llvm/llvm-project/issues/63524

[jrtc27]

In D147875#4448545, @hans wrote:

I noticed that at least for some cases of -Wformat, the line numbers on the left seem to be off: https://github.com/llvm/llvm-project/issues/63524

That's because DisplayLineNo refers to the line of the diagnostic, not the first source line, and then counts up. What's the reason for DisplayLineNo in the first place? Given the printed line comes from LineNo, surely we should be using LineNo instead?

clang-tools-extra/test/clang-tidy/checkers/cert/uppercase-literal-suffix-integer.cpp

void integer_suffix() {
   static_assert(v4 == 1, "");
 
   // Long
 
   static constexpr auto v5 = 1l;
   // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'l', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v5 = 1l;
   // CHECK-MESSAGES-NEXT: ^~
-  // CHECK-MESSAGES-NEXT: {{^ *}}L{{$}}
+  // CHECK-MESSAGES-NEXT: {{^ *| *}}L{{$}}
   // CHECK-FIXES: static constexpr auto v5 = 1L;
   static_assert(is_same<decltype(v5), const long>::value, "");
   static_assert(v5 == 1, "");
 
   static constexpr auto v6 = 1L; // OK.
   static_assert(is_same<decltype(v6), const long>::value, "");
   static_assert(v6 == 1, "");
 
   // Long Long
 
   static constexpr auto v7 = 1ll;
   // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'll', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v7 = 1ll;
   // CHECK-MESSAGES-NEXT: ^~~
-  // CHECK-MESSAGES-NEXT: {{^ *}}LL{{$}}
+  // CHECK-MESSAGES-NEXT: {{^ *| *}}LL{{$}}
   // CHECK-FIXES: static constexpr auto v7 = 1LL;
   static_assert(is_same<decltype(v7), const long long>::value, "");
   static_assert(v7 == 1, "");
 
   static constexpr auto v8 = 1LL; // OK.
   static_assert(is_same<decltype(v8), const long long>::value, "");
   static_assert(v8 == 1, "");
 
void integer_suffix() {
   static_assert(v12 == 1, "");
 
   // Long Unsigned
 
   static constexpr auto v13 = 1lu;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'lu', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v13 = 1lu;
   // CHECK-MESSAGES-NEXT: ^~~
-  // CHECK-MESSAGES-NEXT: {{^ *}}LU{{$}}
+  // CHECK-MESSAGES-NEXT: {{^ *| *}}LU{{$}}
   // CHECK-FIXES: static constexpr auto v13 = 1LU;
   static_assert(is_same<decltype(v13), const unsigned long>::value, "");
   static_assert(v13 == 1, "");
 
   static constexpr auto v14 = 1Lu;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'Lu', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v14 = 1Lu;
   // CHECK-MESSAGES-NEXT: ^~~
-  // CHECK-MESSAGES-NEXT: {{^ *}}LU{{$}}
+  // CHECK-MESSAGES-NEXT: {{^ *| *}}LU{{$}}
   // CHECK-FIXES: static constexpr auto v14 = 1LU;
   static_assert(is_same<decltype(v14), const unsigned long>::value, "");
   static_assert(v14 == 1, "");
 
   static constexpr auto v15 = 1lU;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'lU', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v15 = 1lU;
   // CHECK-MESSAGES-NEXT: ^~~
-  // CHECK-MESSAGES-NEXT: {{^ *}}LU{{$}}
+  // CHECK-MESSAGES-NEXT: {{^ *| *}}LU{{$}}
   // CHECK-FIXES: static constexpr auto v15 = 1LU;
   static_assert(is_same<decltype(v15), const unsigned long>::value, "");
   static_assert(v15 == 1, "");
 
   static constexpr auto v16 = 1LU; // OK.
   static_assert(is_same<decltype(v16), const unsigned long>::value, "");
   static_assert(v16 == 1, "");
 
void integer_suffix() {
   static_assert(v20 == 1, "");
 
   // Long Long Unsigned
 
   static constexpr auto v21 = 1llu;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'llu', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v21 = 1llu;
   // CHECK-MESSAGES-NEXT: ^~~~
-  // CHECK-MESSAGES-NEXT: {{^ *}}LLU{{$}}
+  // CHECK-MESSAGES-NEXT: {{^ *| *}}LLU{{$}}
   // CHECK-FIXES: static constexpr auto v21 = 1LLU;
   static_assert(is_same<decltype(v21), const unsigned long long>::value, "");
   static_assert(v21 == 1, "");
 
   static constexpr auto v22 = 1LLu;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'LLu', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v22 = 1LLu;
   // CHECK-MESSAGES-NEXT: ^~~~
-  // CHECK-MESSAGES-NEXT: {{^ *}}LLU{{$}}
+  // CHECK-MESSAGES-NEXT: {{^ *| *}}LLU{{$}}
   // CHECK-FIXES: static constexpr auto v22 = 1LLU;
   static_assert(is_same<decltype(v22), const unsigned long long>::value, "");
   static_assert(v22 == 1, "");
 
   static constexpr auto v23 = 1llU;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'llU', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v23 = 1llU;
   // CHECK-MESSAGES-NEXT: ^~~~
-  // CHECK-MESSAGES-NEXT: {{^ *}}LLU{{$}}
+  // CHECK-MESSAGES-NEXT: {{^ *| *}}LLU{{$}}
   // CHECK-FIXES: static constexpr auto v23 = 1LLU;
   static_assert(is_same<decltype(v23), const unsigned long long>::value, "");
   static_assert(v23 == 1, "");
 
   static constexpr auto v24 = 1LLU; // OK.
   static_assert(is_same<decltype(v24), const unsigned long long>::value, "");
   static_assert(v24 == 1, "");
 }

clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-float16.cpp

 // RUN: %check_clang_tidy %s readability-uppercase-literal-suffix %t -- -- -target aarch64-linux-gnu -I %clang_tidy_headers
 
 #include "integral_constant.h"
 
 void float16_normal_literals() {
   // _Float16
 
   static constexpr auto v14 = 1.f16;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'f16', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v14 = 1.f16;
   // CHECK-MESSAGES-NEXT: ^ ~
-  // CHECK-MESSAGES-NEXT: {{^ *}}F16{{$}}
+  // CHECK-MESSAGES-NEXT: F16{{$}}
   // CHECK-FIXES: static constexpr auto v14 = 1.F16;
   static_assert(is_same<decltype(v14), const _Float16>::value, "");
   static_assert(v14 == 1.F16, "");
 
   static constexpr auto v15 = 1.e0f16;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'f16', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v15 = 1.e0f16;
   // CHECK-MESSAGES-NEXT: ^ ~
-  // CHECK-MESSAGES-NEXT: {{^ *}}F16{{$}}
+  // CHECK-MESSAGES-NEXT: F16{{$}}
   // CHECK-FIXES: static constexpr auto v15 = 1.e0F16;
   static_assert(is_same<decltype(v15), const _Float16>::value, "");
   static_assert(v15 == 1.F16, "");
 
   static constexpr auto v16 = 1.F16; // OK.
   static_assert(is_same<decltype(v16), const _Float16>::value, "");
   static_assert(v16 == 1.F16, "");
 
   static constexpr auto v17 = 1.e0F16; // OK.
   static_assert(is_same<decltype(v17), const _Float16>::value, "");
   static_assert(v17 == 1.F16, "");
 }
 
 void float16_hexadecimal_literals() {
 // _Float16
 
   static constexpr auto v13 = 0xfp0f16;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'f16', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v13 = 0xfp0f16;
   // CHECK-MESSAGES-NEXT: ^    ~
-  // CHECK-MESSAGES-NEXT: {{^ *}}F16{{$}}
+  // CHECK-MESSAGES-NEXT: F16{{$}}
   // CHECK-FIXES: static constexpr auto v13 = 0xfp0F16;
   static_assert(is_same<decltype(v13), const _Float16>::value, "");
   static_assert(v13 == 0xfp0F16, "");
 
   static constexpr auto v14 = 0xfp0F16; // OK.
   static_assert(is_same<decltype(v14), const _Float16>::value, "");
   static_assert(v14 == 0xfp0F16, "");
 
 }

clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-floating-point-opencl-half.cpp

 // RUN: %check_clang_tidy -std=cl2.0 %s readability-uppercase-literal-suffix %t -- -- -target x86_64-pc-linux-gnu -I %S -x cl
 // RUN: grep -Ev "// *[A-Z-]+:" %s > %t.cpp
 // RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -fix -- -target x86_64-pc-linux-gnu -I %S -std=cl2.0 -x cl
 // RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -warnings-as-errors='-*,readability-uppercase-literal-suffix' -- -target x86_64-pc-linux-gnu -I %S -std=cl2.0 -x cl
 
 #pragma OPENCL EXTENSION cl_khr_fp16 : enable
 
 void floating_point_half_suffix() {
   static half v0 = 0x0p0; // no literal
 
   // half
 
   static half v2 = 1.h;
   // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: floating point literal has suffix 'h', which is not uppercase
   // CHECK-MESSAGES-NEXT: static half v2 = 1.h;
   // CHECK-MESSAGES-NEXT: ^ ~
-  // CHECK-MESSAGES-NEXT: {{^ *}}H{{$}}
+  // CHECK-MESSAGES-NEXT: H{{$}}
   // CHECK-HIXES: static half v2 = 1.H;
 
   static half v3 = 1.e0h;
   // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: floating point literal has suffix 'h', which is not uppercase
   // CHECK-MESSAGES-NEXT: static half v3 = 1.e0h;
   // CHECK-MESSAGES-NEXT: ^ ~
-  // CHECK-MESSAGES-NEXT: {{^ *}}H{{$}}
+  // CHECK-MESSAGES-NEXT: H{{$}}
   // CHECK-HIXES: static half v3 = 1.e0H;
 
   static half v4 = 1.H; // OK.
 
   static half v5 = 1.e0H; // OK.
 }

clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-floating-point.cpp

void floating_point_suffix() {
   static_assert(v1 == 1., "");
 
   // Float
 
   static constexpr auto v2 = 1.f;
   // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v2 = 1.f;
   // CHECK-MESSAGES-NEXT: ^ ~
-  // CHECK-MESSAGES-NEXT: {{^ *}}F{{$}}
+  // CHECK-MESSAGES-NEXT: F{{$}}
   // CHECK-FIXES: static constexpr auto v2 = 1.F;
   static_assert(is_same<decltype(v2), const float>::value, "");
   static_assert(v2 == 1.0F, "");
 
   static constexpr auto v3 = 1.e0f;
   // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v3 = 1.e0f;
   // CHECK-MESSAGES-NEXT: ^ ~
-  // CHECK-MESSAGES-NEXT: {{^ *}}F{{$}}
+  // CHECK-MESSAGES-NEXT: F{{$}}
   // CHECK-FIXES: static constexpr auto v3 = 1.e0F;
   static_assert(is_same<decltype(v3), const float>::value, "");
   static_assert(v3 == 1.0F, "");
 
   static constexpr auto v4 = 1.F; // OK.
   static_assert(is_same<decltype(v4), const float>::value, "");
   static_assert(v4 == 1.0F, "");
 
   static constexpr auto v5 = 1.e0F; // OK.
   static_assert(is_same<decltype(v5), const float>::value, "");
   static_assert(v5 == 1.0F, "");
 
   // Long double
 
   static constexpr auto v6 = 1.l;
   // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'l', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v6 = 1.l;
   // CHECK-MESSAGES-NEXT: ^ ~
-  // CHECK-MESSAGES-NEXT: {{^ *}}L{{$}}
+  // CHECK-MESSAGES-NEXT: L{{$}}
   // CHECK-FIXES: static constexpr auto v6 = 1.L;
   static_assert(is_same<decltype(v6), const long double>::value, "");
   static_assert(v6 == 1., "");
 
   static constexpr auto v7 = 1.e0l;
   // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'l', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v7 = 1.e0l;
   // CHECK-MESSAGES-NEXT: ^ ~
-  // CHECK-MESSAGES-NEXT: {{^ *}}L{{$}}
+  // CHECK-MESSAGES-NEXT: L{{$}}
   // CHECK-FIXES: static constexpr auto v7 = 1.e0L;
   static_assert(is_same<decltype(v7), const long double>::value, "");
   static_assert(v7 == 1., "");
 
   static constexpr auto v8 = 1.L; // OK.
   static_assert(is_same<decltype(v8), const long double>::value, "");
   static_assert(v8 == 1., "");
 
   static constexpr auto v9 = 1.e0L; // OK.
   static_assert(is_same<decltype(v9), const long double>::value, "");
   static_assert(v9 == 1., "");
 
   // __float128
 
   static constexpr auto v10 = 1.q;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'q', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v10 = 1.q;
   // CHECK-MESSAGES-NEXT: ^ ~
-  // CHECK-MESSAGES-NEXT: {{^ *}}Q{{$}}
+  // CHECK-MESSAGES-NEXT: Q{{$}}
   // CHECK-FIXES: static constexpr auto v10 = 1.Q;
   static_assert(is_same<decltype(v10), const __float128>::value, "");
   static_assert(v10 == 1., "");
 
   static constexpr auto v11 = 1.e0q;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'q', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v11 = 1.e0q;
   // CHECK-MESSAGES-NEXT: ^ ~
-  // CHECK-MESSAGES-NEXT: {{^ *}}Q{{$}}
+  // CHECK-MESSAGES-NEXT: Q{{$}}
   // CHECK-FIXES: static constexpr auto v11 = 1.e0Q;
   static_assert(is_same<decltype(v11), const __float128>::value, "");
   static_assert(v11 == 1., "");
 
   static constexpr auto v12 = 1.Q; // OK.
   static_assert(is_same<decltype(v12), const __float128>::value, "");
   static_assert(v12 == 1., "");
 
   static constexpr auto v13 = 1.e0Q; // OK.
   static_assert(is_same<decltype(v13), const __float128>::value, "");
   static_assert(v13 == 1., "");
 }
 
 void floating_point_complex_suffix() {
   // _Complex, I
 
   static constexpr auto v14 = 1.i;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'i', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v14 = 1.i;
   // CHECK-MESSAGES-NEXT: ^ ~
-  // CHECK-MESSAGES-NEXT: {{^ *}}I{{$}}
+  // CHECK-MESSAGES-NEXT: I{{$}}
   // CHECK-FIXES: static constexpr auto v14 = 1.I;
   static_assert(is_same<decltype(v14), const _Complex double>::value, "");
   static_assert(v14 == 1.I, "");
 
   static constexpr auto v15 = 1.e0i;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'i', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v15 = 1.e0i;
   // CHECK-MESSAGES-NEXT: ^ ~
-  // CHECK-MESSAGES-NEXT: {{^ *}}I{{$}}
+  // CHECK-MESSAGES-NEXT: I{{$}}
   // CHECK-FIXES: static constexpr auto v15 = 1.e0I;
   static_assert(is_same<decltype(v15), const _Complex double>::value, "");
   static_assert(v15 == 1.I, "");
 
   static constexpr auto v16 = 1.I; // OK.
   static_assert(is_same<decltype(v16), const _Complex double>::value, "");
   static_assert(v16 == 1.I, "");
 
   static constexpr auto v17 = 1.e0I; // OK.
   static_assert(is_same<decltype(v17), const _Complex double>::value, "");
   static_assert(v17 == 1.I, "");
 
   // _Complex, J
 
   static constexpr auto v18 = 1.j;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'j', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v18 = 1.j;
   // CHECK-MESSAGES-NEXT: ^ ~
-  // CHECK-MESSAGES-NEXT: {{^ *}}J{{$}}
+  // CHECK-MESSAGES-NEXT: J{{$}}
   // CHECK-FIXES: static constexpr auto v18 = 1.J;
   static_assert(is_same<decltype(v18), const _Complex double>::value, "");
   static_assert(v18 == 1.J, "");
 
   static constexpr auto v19 = 1.e0j;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'j', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v19 = 1.e0j;
   // CHECK-MESSAGES-NEXT: ^ ~
-  // CHECK-MESSAGES-NEXT: {{^ *}}J{{$}}
+  // CHECK-MESSAGES-NEXT: J{{$}}
   // CHECK-FIXES: static constexpr auto v19 = 1.e0J;
   static_assert(is_same<decltype(v19), const _Complex double>::value, "");
   static_assert(v19 == 1.J, "");
 
   static constexpr auto v20 = 1.J; // OK.
   static_assert(is_same<decltype(v20), const _Complex double>::value, "");
   static_assert(v20 == 1.J, "");
 
   static constexpr auto v21 = 1.e0J; // OK.
   static_assert(is_same<decltype(v21), const _Complex double>::value, "");
   static_assert(v21 == 1.J, "");
 }
 
 void macros() {
 #define PASSTHROUGH(X) X
   static constexpr auto m0 = PASSTHROUGH(1.f);
   // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: floating point literal has suffix 'f', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto m0 = PASSTHROUGH(1.f);
   // CHECK-MESSAGES-NEXT: ^ ~
-  // CHECK-MESSAGES-NEXT: {{^ *}}F{{$}}
+  // CHECK-MESSAGES-NEXT: F{{$}}
   // CHECK-FIXES: static constexpr auto m0 = PASSTHROUGH(1.F);
   static_assert(is_same<decltype(m0), const float>::value, "");
   static_assert(m0 == 1.0F, "");
 }

clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-hexadecimal-floating-point.cpp

void floating_point_suffix() {
   static_assert(v0 == 0, "");
 
   // Float
 
   static constexpr auto v1 = 0xfp0f;
   // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v1 = 0xfp0f;
   // CHECK-MESSAGES-NEXT: ^    ~
-  // CHECK-MESSAGES-NEXT: {{^ *}}F{{$}}
+  // CHECK-MESSAGES-NEXT: F{{$}}
   // CHECK-FIXES: static constexpr auto v1 = 0xfp0F;
   static_assert(is_same<decltype(v1), const float>::value, "");
   static_assert(v1 == 15, "");
 
   static constexpr auto v2 = 0xfp0F; // OK
   static_assert(is_same<decltype(v2), const float>::value, "");
   static_assert(v2 == 15, "");
 
   static constexpr auto v3 = 0xfP0f;
   // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v3 = 0xfP0f;
   // CHECK-MESSAGES-NEXT: ^    ~
-  // CHECK-MESSAGES-NEXT: {{^ *}}F{{$}}
+  // CHECK-MESSAGES-NEXT: F{{$}}
   // CHECK-FIXES: static constexpr auto v3 = 0xfP0F;
   static_assert(is_same<decltype(v3), const float>::value, "");
   static_assert(v3 == 15, "");
 
   static constexpr auto v4 = 0xfP0F; // OK
   static_assert(is_same<decltype(v4), const float>::value, "");
   static_assert(v4 == 15, "");
 
   static constexpr auto v5 = 0xFP0f;
   // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v5 = 0xFP0f;
   // CHECK-MESSAGES-NEXT: ^    ~
-  // CHECK-MESSAGES-NEXT: {{^ *}}F{{$}}
+  // CHECK-MESSAGES-NEXT: F{{$}}
   // CHECK-FIXES: static constexpr auto v5 = 0xFP0F;
   static_assert(is_same<decltype(v5), const float>::value, "");
   static_assert(v5 == 15, "");
 
   static constexpr auto v6 = 0xFP0F; // OK
   static_assert(is_same<decltype(v6), const float>::value, "");
   static_assert(v6 == 15, "");
 
   static constexpr auto v7 = 0xFp0f;
   // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v7 = 0xFp0f;
   // CHECK-MESSAGES-NEXT: ^    ~
-  // CHECK-MESSAGES-NEXT: {{^ *}}F{{$}}
+  // CHECK-MESSAGES-NEXT: F{{$}}
   // CHECK-FIXES: static constexpr auto v7 = 0xFp0F;
   static_assert(is_same<decltype(v7), const float>::value, "");
   static_assert(v7 == 15, "");
 
   static constexpr auto v8 = 0xFp0F; // OK
   static_assert(is_same<decltype(v8), const float>::value, "");
   static_assert(v8 == 15, "");
 
   // long double
 
   static constexpr auto v9 = 0xfp0l;
   // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'l', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v9 = 0xfp0l;
   // CHECK-MESSAGES-NEXT: ^    ~
-  // CHECK-MESSAGES-NEXT: {{^ *}}L{{$}}
+  // CHECK-MESSAGES-NEXT: L{{$}}
   // CHECK-FIXES: static constexpr auto v9 = 0xfp0L;
   static_assert(is_same<decltype(v9), const long double>::value, "");
   static_assert(v9 == 0xfp0, "");
 
   static constexpr auto v10 = 0xfp0L; // OK.
   static_assert(is_same<decltype(v10), const long double>::value, "");
   static_assert(v10 == 0xfp0, "");
 
   // __float128
 
   static constexpr auto v11 = 0xfp0q;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'q', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v11 = 0xfp0q;
   // CHECK-MESSAGES-NEXT: ^    ~
-  // CHECK-MESSAGES-NEXT: {{^ *}}Q{{$}}
+  // CHECK-MESSAGES-NEXT: Q{{$}}
   // CHECK-FIXES: static constexpr auto v11 = 0xfp0Q;
   static_assert(is_same<decltype(v11), const __float128>::value, "");
   static_assert(v11 == 0xfp0, "");
 
   static constexpr auto v12 = 0xfp0Q; // OK.
   static_assert(is_same<decltype(v12), const __float128>::value, "");
   static_assert(v12 == 0xfp0, "");
 }
 
 void floating_point_complex_suffix() {
   // _Complex, I
 
   static constexpr auto v14 = 0xfp0i;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'i', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v14 = 0xfp0i;
   // CHECK-MESSAGES-NEXT: ^    ~
-  // CHECK-MESSAGES-NEXT: {{^ *}}I{{$}}
+  // CHECK-MESSAGES-NEXT: I{{$}}
   // CHECK-FIXES: static constexpr auto v14 = 0xfp0I;
   static_assert(is_same<decltype(v14), const _Complex double>::value, "");
   static_assert(v14 == 0xfp0I, "");
 
   static constexpr auto v16 = 0xfp0I; // OK.
   static_assert(is_same<decltype(v16), const _Complex double>::value, "");
   static_assert(v16 == 0xfp0I, "");
 
   // _Complex, J
 
   static constexpr auto v18 = 0xfp0j;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'j', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v18 = 0xfp0j;
   // CHECK-MESSAGES-NEXT: ^    ~
-  // CHECK-MESSAGES-NEXT: {{^ *}}J{{$}}
+  // CHECK-MESSAGES-NEXT: J{{$}}
   // CHECK-FIXES: static constexpr auto v18 = 0xfp0J;
   static_assert(is_same<decltype(v18), const _Complex double>::value, "");
   static_assert(v18 == 0xfp0J, "");
 
   static constexpr auto v20 = 0xfp0J; // OK.
   static_assert(is_same<decltype(v20), const _Complex double>::value, "");
   static_assert(v20 == 0xfp0J, "");
 }
 
 void macros() {
 #define PASSTHROUGH(X) X
   static constexpr auto m0 = PASSTHROUGH(0x0p0f);
   // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: floating point literal has suffix 'f', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto m0 = PASSTHROUGH(0x0p0f);
   // CHECK-MESSAGES-NEXT: ^ ~
-  // CHECK-MESSAGES-NEXT: {{^ *}}F{{$}}
+  // CHECK-MESSAGES-NEXT: F{{$}}
   // CHECK-FIXES: static constexpr auto m0 = PASSTHROUGH(0x0p0F);
   static_assert(is_same<decltype(m0), const float>::value, "");
   static_assert(m0 == 0x0p0F, "");
 }

clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-integer-custom-list.cpp

void integer_suffix() {
   static_assert(v4 == 1, "");
 
   // Long
 
   static constexpr auto v5 = 1l;
   // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'l', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v5 = 1l;
   // CHECK-MESSAGES-NEXT: ^~
-  // CHECK-MESSAGES-NEXT: {{^ *}}L{{$}}
+  // CHECK-MESSAGES-NEXT: L{{$}}
   // CHECK-FIXES: static constexpr auto v5 = 1L;
   static_assert(is_same<decltype(v5), const long>::value, "");
   static_assert(v5 == 1, "");
 
   static constexpr auto v6 = 1L; // OK.
   static_assert(is_same<decltype(v6), const long>::value, "");
   static_assert(v6 == 1, "");
 
   // Long Long
 
   static constexpr auto v7 = 1ll; // OK.
   static_assert(is_same<decltype(v7), const long long>::value, "");
   static_assert(v7 == 1, "");
 
   static constexpr auto v8 = 1LL; // OK.
   static_assert(is_same<decltype(v8), const long long>::value, "");
   static_assert(v8 == 1, "");
 
   // Unsigned Long
 
   static constexpr auto v9 = 1ul;
   // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'ul', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v9 = 1ul;
   // CHECK-MESSAGES-NEXT: ^~~
-  // CHECK-MESSAGES-NEXT: {{^ *}}uL{{$}}
+  // CHECK-MESSAGES-NEXT: uL{{$}}
   // CHECK-FIXES: static constexpr auto v9 = 1uL;
   static_assert(is_same<decltype(v9), const unsigned long>::value, "");
   static_assert(v9 == 1, "");
 
   static constexpr auto v10 = 1uL; // OK.
   static_assert(is_same<decltype(v10), const unsigned long>::value, "");
   static_assert(v10 == 1, "");
 
   static constexpr auto v11 = 1Ul;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'Ul', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v11 = 1Ul;
   // CHECK-MESSAGES-NEXT: ^~~
-  // CHECK-MESSAGES-NEXT: {{^ *}}uL{{$}}
+  // CHECK-MESSAGES-NEXT: uL{{$}}
   // CHECK-FIXES: static constexpr auto v11 = 1uL;
   static_assert(is_same<decltype(v11), const unsigned long>::value, "");
   static_assert(v11 == 1, "");
 
   static constexpr auto v12 = 1UL; // OK.
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'UL', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v12 = 1UL;
   // CHECK-MESSAGES-NEXT: ^~~
-  // CHECK-MESSAGES-NEXT: {{^ *}}uL{{$}}
+  // CHECK-MESSAGES-NEXT: uL{{$}}
   // CHECK-FIXES: static constexpr auto v12 = 1uL;
   static_assert(is_same<decltype(v12), const unsigned long>::value, "");
   static_assert(v12 == 1, "");
 
   // Long Unsigned
 
   static constexpr auto v13 = 1lu; // OK.
   static_assert(is_same<decltype(v13), const unsigned long>::value, "");

clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-integer-ms.cpp

void integer_suffix() {
   static_assert(v2 == 1, "");
 
   // i32
 
   static constexpr auto v3 = 1i32;
   // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'i32', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v3 = 1i32;
   // CHECK-MESSAGES-NEXT: ^~
-  // CHECK-MESSAGES-NEXT: {{^ *}}I32{{$}}
+  // CHECK-MESSAGES-NEXT: I32{{$}}
   // CHECK-FIXES: static constexpr auto v3 = 1I32;
   static_assert(is_same<decltype(v3), const int>::value, "");
   static_assert(v3 == 1I32, "");
 
   static constexpr auto v4 = 1I32; // OK.
   static_assert(is_same<decltype(v4), const int>::value, "");
   static_assert(v4 == 1I32, "");
 
   // i64
 
   static constexpr auto v5 = 1i64;
   // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'i64', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v5 = 1i64;
   // CHECK-MESSAGES-NEXT: ^~
-  // CHECK-MESSAGES-NEXT: {{^ *}}I64{{$}}
+  // CHECK-MESSAGES-NEXT: I64{{$}}
   // CHECK-FIXES: static constexpr auto v5 = 1I64;
   static_assert(is_same<decltype(v5), const long int>::value, "");
   static_assert(v5 == 1I64, "");
 
   static constexpr auto v6 = 1I64; // OK.
   static_assert(is_same<decltype(v6), const long int>::value, "");
   static_assert(v6 == 1I64, "");
 
   // i16
 
   static constexpr auto v7 = 1i16;
   // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'i16', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v7 = 1i16;
   // CHECK-MESSAGES-NEXT: ^~
-  // CHECK-MESSAGES-NEXT: {{^ *}}I16{{$}}
+  // CHECK-MESSAGES-NEXT: I16{{$}}
   // CHECK-FIXES: static constexpr auto v7 = 1I16;
   static_assert(is_same<decltype(v7), const short>::value, "");
   static_assert(v7 == 1I16, "");
 
   static constexpr auto v8 = 1I16; // OK.
   static_assert(is_same<decltype(v8), const short>::value, "");
   static_assert(v8 == 1I16, "");
 
   // i8
 
   static constexpr auto v9 = 1i8;
   // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'i8', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v9 = 1i8;
   // CHECK-MESSAGES-NEXT: ^~
-  // CHECK-MESSAGES-NEXT: {{^ *}}I8{{$}}
+  // CHECK-MESSAGES-NEXT: I8{{$}}
   // CHECK-FIXES: static constexpr auto v9 = 1I8;
   static_assert(is_same<decltype(v9), const char>::value, "");
   static_assert(v9 == 1I8, "");
 
   static constexpr auto v10 = 1I8; // OK.
   static_assert(is_same<decltype(v10), const char>::value, "");
   static_assert(v10 == 1I8, "");
 }

clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-integer.cpp

void integer_suffix() {
   static_assert(v2 == 1, "");
 
   // Unsigned
 
   static constexpr auto v3 = 1u;
   // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'u', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v3 = 1u;
   // CHECK-MESSAGES-NEXT: ^~
-  // CHECK-MESSAGES-NEXT: {{^ *}}U{{$}}
+  // CHECK-MESSAGES-NEXT: U{{$}}
   // CHECK-FIXES: static constexpr auto v3 = 1U;
   static_assert(is_same<decltype(v3), const unsigned int>::value, "");
   static_assert(v3 == 1, "");
 
   static constexpr auto v4 = 1U; // OK.
   static_assert(is_same<decltype(v4), const unsigned int>::value, "");
   static_assert(v4 == 1, "");
 
   // Long
 
   static constexpr auto v5 = 1l;
   // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'l', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v5 = 1l;
   // CHECK-MESSAGES-NEXT: ^~
-  // CHECK-MESSAGES-NEXT: {{^ *}}L{{$}}
+  // CHECK-MESSAGES-NEXT: L{{$}}
   // CHECK-FIXES: static constexpr auto v5 = 1L;
   static_assert(is_same<decltype(v5), const long>::value, "");
   static_assert(v5 == 1, "");
 
   static constexpr auto v6 = 1L; // OK.
   static_assert(is_same<decltype(v6), const long>::value, "");
   static_assert(v6 == 1, "");
 
   // Long Long
 
   static constexpr auto v7 = 1ll;
   // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'll', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v7 = 1ll;
   // CHECK-MESSAGES-NEXT: ^~~
-  // CHECK-MESSAGES-NEXT: {{^ *}}LL{{$}}
+  // CHECK-MESSAGES-NEXT: LL{{$}}
   // CHECK-FIXES: static constexpr auto v7 = 1LL;
   static_assert(is_same<decltype(v7), const long long>::value, "");
   static_assert(v7 == 1, "");
 
   static constexpr auto v8 = 1LL; // OK.
   static_assert(is_same<decltype(v8), const long long>::value, "");
   static_assert(v8 == 1, "");
 
   // Unsigned Long
 
   static constexpr auto v9 = 1ul;
   // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'ul', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v9 = 1ul;
   // CHECK-MESSAGES-NEXT: ^~~
-  // CHECK-MESSAGES-NEXT: {{^ *}}UL{{$}}
+  // CHECK-MESSAGES-NEXT: UL{{$}}
   // CHECK-FIXES: static constexpr auto v9 = 1UL;
   static_assert(is_same<decltype(v9), const unsigned long>::value, "");
   static_assert(v9 == 1, "");
 
   static constexpr auto v10 = 1uL;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'uL', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v10 = 1uL;
   // CHECK-MESSAGES-NEXT: ^~~
-  // CHECK-MESSAGES-NEXT: {{^ *}}UL{{$}}
+  // CHECK-MESSAGES-NEXT: UL{{$}}
   // CHECK-FIXES: static constexpr auto v10 = 1UL;
   static_assert(is_same<decltype(v10), const unsigned long>::value, "");
   static_assert(v10 == 1, "");
 
   static constexpr auto v11 = 1Ul;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'Ul', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v11 = 1Ul;
   // CHECK-MESSAGES-NEXT: ^~~
-  // CHECK-MESSAGES-NEXT: {{^ *}}UL{{$}}
+  // CHECK-MESSAGES-NEXT: UL{{$}}
   // CHECK-FIXES: static constexpr auto v11 = 1UL;
   static_assert(is_same<decltype(v11), const unsigned long>::value, "");
   static_assert(v11 == 1, "");
 
   static constexpr auto v12 = 1UL; // OK.
   static_assert(is_same<decltype(v12), const unsigned long>::value, "");
   static_assert(v12 == 1, "");
 
   // Long Unsigned
 
   static constexpr auto v13 = 1lu;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'lu', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v13 = 1lu;
   // CHECK-MESSAGES-NEXT: ^~~
-  // CHECK-MESSAGES-NEXT: {{^ *}}LU{{$}}
+  // CHECK-MESSAGES-NEXT: LU{{$}}
   // CHECK-FIXES: static constexpr auto v13 = 1LU;
   static_assert(is_same<decltype(v13), const unsigned long>::value, "");
   static_assert(v13 == 1, "");
 
   static constexpr auto v14 = 1Lu;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'Lu', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v14 = 1Lu;
   // CHECK-MESSAGES-NEXT: ^~~
-  // CHECK-MESSAGES-NEXT: {{^ *}}LU{{$}}
+  // CHECK-MESSAGES-NEXT: LU{{$}}
   // CHECK-FIXES: static constexpr auto v14 = 1LU;
   static_assert(is_same<decltype(v14), const unsigned long>::value, "");
   static_assert(v14 == 1, "");
 
   static constexpr auto v15 = 1lU;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'lU', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v15 = 1lU;
   // CHECK-MESSAGES-NEXT: ^~~
-  // CHECK-MESSAGES-NEXT: {{^ *}}LU{{$}}
+  // CHECK-MESSAGES-NEXT: LU{{$}}
   // CHECK-FIXES: static constexpr auto v15 = 1LU;
   static_assert(is_same<decltype(v15), const unsigned long>::value, "");
   static_assert(v15 == 1, "");
 
   static constexpr auto v16 = 1LU; // OK.
   static_assert(is_same<decltype(v16), const unsigned long>::value, "");
   static_assert(v16 == 1, "");
 
   // Unsigned Long Long
 
   static constexpr auto v17 = 1ull;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'ull', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v17 = 1ull;
   // CHECK-MESSAGES-NEXT: ^~~~
-  // CHECK-MESSAGES-NEXT: {{^ *}}ULL{{$}}
+  // CHECK-MESSAGES-NEXT: ULL{{$}}
   // CHECK-FIXES: static constexpr auto v17 = 1ULL;
   static_assert(is_same<decltype(v17), const unsigned long long>::value, "");
   static_assert(v17 == 1, "");
 
   static constexpr auto v18 = 1uLL;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'uLL', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v18 = 1uLL;
   // CHECK-MESSAGES-NEXT: ^~~~
-  // CHECK-MESSAGES-NEXT: {{^ *}}ULL{{$}}
+  // CHECK-MESSAGES-NEXT: ULL{{$}}
   // CHECK-FIXES: static constexpr auto v18 = 1ULL;
   static_assert(is_same<decltype(v18), const unsigned long long>::value, "");
   static_assert(v18 == 1, "");
 
   static constexpr auto v19 = 1Ull;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'Ull', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v19 = 1Ull;
   // CHECK-MESSAGES-NEXT: ^~~~
-  // CHECK-MESSAGES-NEXT: {{^ *}}ULL{{$}}
+  // CHECK-MESSAGES-NEXT: ULL{{$}}
   // CHECK-FIXES: static constexpr auto v19 = 1ULL;
   static_assert(is_same<decltype(v19), const unsigned long long>::value, "");
   static_assert(v19 == 1, "");
 
   static constexpr auto v20 = 1ULL; // OK.
   static_assert(is_same<decltype(v20), const unsigned long long>::value, "");
   static_assert(v20 == 1, "");
 
   // Long Long Unsigned
 
   static constexpr auto v21 = 1llu;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'llu', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v21 = 1llu;
   // CHECK-MESSAGES-NEXT: ^~~~
-  // CHECK-MESSAGES-NEXT: {{^ *}}LLU{{$}}
+  // CHECK-MESSAGES-NEXT: LLU{{$}}
   // CHECK-FIXES: static constexpr auto v21 = 1LLU;
   static_assert(is_same<decltype(v21), const unsigned long long>::value, "");
   static_assert(v21 == 1, "");
 
   static constexpr auto v22 = 1LLu;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'LLu', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v22 = 1LLu;
   // CHECK-MESSAGES-NEXT: ^~~~
-  // CHECK-MESSAGES-NEXT: {{^ *}}LLU{{$}}
+  // CHECK-MESSAGES-NEXT: LLU{{$}}
   // CHECK-FIXES: static constexpr auto v22 = 1LLU;
   static_assert(is_same<decltype(v22), const unsigned long long>::value, "");
   static_assert(v22 == 1, "");
 
   static constexpr auto v23 = 1llU;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'llU', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v23 = 1llU;
   // CHECK-MESSAGES-NEXT: ^~~~
-  // CHECK-MESSAGES-NEXT: {{^ *}}LLU{{$}}
+  // CHECK-MESSAGES-NEXT: LLU{{$}}
   // CHECK-FIXES: static constexpr auto v23 = 1LLU;
   static_assert(is_same<decltype(v23), const unsigned long long>::value, "");
   static_assert(v23 == 1, "");
 
   static constexpr auto v24 = 1LLU; // OK.
   static_assert(is_same<decltype(v24), const unsigned long long>::value, "");
   static_assert(v24 == 1, "");
 }
 
 void integer_complex_suffix() {
   // _Complex, I
 
   static constexpr auto v25 = 1i;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'i', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v25 = 1i;
   // CHECK-MESSAGES-NEXT: ^~
-  // CHECK-MESSAGES-NEXT: {{^ *}}I{{$}}
+  // CHECK-MESSAGES-NEXT: I{{$}}
   // CHECK-FIXES: static constexpr auto v25 = 1I;
   static_assert(is_same<decltype(v25), const _Complex int>::value, "");
   static_assert(v25 == 1I, "");
 
   static constexpr auto v26 = 1I; // OK.
   static_assert(is_same<decltype(v26), const _Complex int>::value, "");
   static_assert(v26 == 1I, "");
 
   // _Complex, J
 
   static constexpr auto v27 = 1j;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'j', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto v27 = 1j;
   // CHECK-MESSAGES-NEXT: ^~
-  // CHECK-MESSAGES-NEXT: {{^ *}}J{{$}}
+  // CHECK-MESSAGES-NEXT: J{{$}}
   // CHECK-FIXES: static constexpr auto v27 = 1J;
   static_assert(is_same<decltype(v27), const _Complex int>::value, "");
   static_assert(v27 == 1J, "");
 
   static constexpr auto v28 = 1J; // OK.
   static_assert(is_same<decltype(v28), const _Complex int>::value, "");
   static_assert(v28 == 1J, "");
 }
 
 void macros() {
 #define PASSTHROUGH(X) X
   static constexpr auto m0 = PASSTHROUGH(1u);
   // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: integer literal has suffix 'u', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto m0 = PASSTHROUGH(1u);
   // CHECK-MESSAGES-NEXT: ^~
-  // CHECK-MESSAGES-NEXT: {{^ *}}U{{$}}
+  // CHECK-MESSAGES-NEXT: U{{$}}
   // CHECK-FIXES: static constexpr auto m0 = PASSTHROUGH(1U);
   static_assert(is_same<decltype(m0), const unsigned int>::value, "");
   static_assert(m0 == 1, "");
 
   // This location is inside a macro, no warning on that by default.
 #define MACRO 1u
   int foo = MACRO;
 }

clang/docs/ReleaseNotes.rst

- Clang now diagnoses shadowing of lambda's template parameter by a capture.
   (`#61105: <https://github.com/llvm/llvm-project/issues/61105>`_).
 - Address a false positive in ``-Wpacked`` when applied to a non-pod type using
   Clang ABI >= 15.
   (`#62353: <https://github.com/llvm/llvm-project/issues/62353>`_,
   fallout from the non-POD packing ABI fix in LLVM 15).
 - Clang constexpr evaluator now prints subobject's name instead of its type in notes
   when a constexpr variable has uninitialized subobjects after its constructor call.
   (`#58601 <https://github.com/llvm/llvm-project/issues/58601>`_)
+- Clang will now show a margin with line numbers to the left of each line
+  of code it prints for diagnostics. This can be disabled using
+  ``-fno-diagnostics-show-line-numbers``. At the same time, the maximum
+  number of code lines it prints has been increased from 1 to 16. This
+  can be controlled using ``-fcaret-diagnostics-max-lines=``.
 
 Bug Fixes in This Version
 -------------------------
 
 - Fix segfault while running clang-rename on a non existing file.
   (`#36471 <https://github.com/llvm/llvm-project/issues/36471>`_)
 - Fix crash when diagnosing incorrect usage of ``_Nullable`` involving alias
   templates.

clang/docs/UsersManual.rst

::
        t.cc:4:5: note: candidate function not viable: no known conversion for 1st argument;
          vector<
            map<
              [...],
              map<
                [float != double],
                [...]>>>
 
+
+.. option:: -fcaret-diagnostics-max-lines:
+
+   Controls how many lines of code clang prints for diagnostics. By default,
+   clang prints a maximum of 16 lines of code.
+
+
+.. option:: -fdiagnostics-show-line-numbers:
+
+   Controls whether clang will print a margin containing the line number on
+   the left of each line of code it prints for diagnostics.
+
+   Default:
+
+    ::
+
+      test.cpp:5:1: error: 'main' must return 'int'
+          5 | void main() {}
+            | ^~~~
+            | int
+
+
+   With :option:`-fno-diagnostics-show-line-numbers`:
+
+    ::
+
+      test.cpp:5:1: error: 'main' must return 'int'
+      void main() {}
+      ^~~~
+      int
+
+
+
 .. _cl_diag_warning_groups:
 
 Individual Warning Groups
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 TODO: Generate this from tblgen. Define one anchor per warning group.
 
 .. option:: -Wextra-tokens

clang/include/clang/Basic/DiagnosticOptions.h

public:
   // Default values.
   enum {
     DefaultTabStop = 8,
     MaxTabStop = 100,
     DefaultMacroBacktraceLimit = 6,
     DefaultTemplateBacktraceLimit = 10,
     DefaultConstexprBacktraceLimit = 10,
     DefaultSpellCheckingLimit = 50,
-    DefaultSnippetLineLimit = 1,
+    DefaultSnippetLineLimit = 16,
+    DefaultShowLineNumbers = 1,
   };
 
   // Define simple diagnostic options (with no accessors).
 #define DIAGOPT(Name, Bits, Default) unsigned Name : Bits;
 #define ENUM_DIAGOPT(Name, Type, Bits, Default)
 #include "clang/Basic/DiagnosticOptions.def"
 
 protected:

clang/include/clang/Basic/DiagnosticOptions.def

 /// Limit depth of instantiation backtrace.
 VALUE_DIAGOPT(TemplateBacktraceLimit, 32, DefaultTemplateBacktraceLimit)
 /// Limit depth of constexpr backtrace.
 VALUE_DIAGOPT(ConstexprBacktraceLimit, 32, DefaultConstexprBacktraceLimit)
 /// Limit number of times to perform spell checking.
 VALUE_DIAGOPT(SpellCheckingLimit, 32, DefaultSpellCheckingLimit)
 /// Limit number of lines shown in a snippet.
 VALUE_DIAGOPT(SnippetLineLimit, 32, DefaultSnippetLineLimit)
+/// Show line number column on the left of snippets.
+VALUE_DIAGOPT(ShowLineNumbers, 1, DefaultShowLineNumbers)
 
 VALUE_DIAGOPT(TabStop, 32, DefaultTabStop) /// The distance between tab stops.
 /// Column limit for formatting message diagnostics, or 0 if unused.
 VALUE_DIAGOPT(MessageLength, 32, 0)
 
 #undef DIAGOPT
 #undef ENUM_DIAGOPT
 #undef VALUE_DIAGOPT
 #undef SEMANTIC_DIAGOPT
 #undef SEMANTIC_ENUM_DIAGOPT
 #undef SEMANTIC_VALUE_DIAGOPT

clang/include/clang/Driver/Options.td

 def fno_omit_frame_pointer : Flag<["-"], "fno-omit-frame-pointer">, Group<f_Group>;
 defm operator_names : BoolFOption<"operator-names",
   LangOpts<"CXXOperatorNames">, Default<cplusplus.KeyPath>,
   NegFlag<SetFalse, [CC1Option], "Do not treat C++ operator name keywords as synonyms for operators">,
   PosFlag<SetTrue>>;
 def fdiagnostics_absolute_paths : Flag<["-"], "fdiagnostics-absolute-paths">, Group<f_Group>,
   Flags<[CC1Option, CoreOption]>, HelpText<"Print absolute paths in diagnostics">,
   MarshallingInfoFlag<DiagnosticOpts<"AbsolutePath">>;
+defm diagnostics_show_line_numbers : BoolFOption<"diagnostics-show-line-numbers",
+  DiagnosticOpts<"ShowLineNumbers">, DefaultTrue,
+  NegFlag<SetFalse, [CC1Option], "Show line numbers in diagnostic code snippest">,
+  PosFlag<SetTrue>>;
 def fno_stack_protector : Flag<["-"], "fno-stack-protector">, Group<f_Group>,
   HelpText<"Disable the use of stack protectors">;
 def fno_strict_aliasing : Flag<["-"], "fno-strict-aliasing">, Group<f_Group>,
   Flags<[NoXarchOption, CoreOption]>;
 def fstruct_path_tbaa : Flag<["-"], "fstruct-path-tbaa">, Group<f_Group>;
 def fno_struct_path_tbaa : Flag<["-"], "fno-struct-path-tbaa">, Group<f_Group>;
 def fno_strict_enums : Flag<["-"], "fno-strict-enums">, Group<f_Group>;
 def fno_strict_overflow : Flag<["-"], "fno-strict-overflow">, Group<f_Group>;

clang/include/clang/Frontend/TextDiagnostic.h

 
 private:
   void emitFilename(StringRef Filename, const SourceManager &SM);
 
   void emitSnippetAndCaret(FullSourceLoc Loc, DiagnosticsEngine::Level Level,
                            SmallVectorImpl<CharSourceRange> &Ranges,
                            ArrayRef<FixItHint> Hints);
 
-  void emitSnippet(StringRef SourceLine);
+  void emitSnippet(StringRef SourceLine, unsigned MaxLineNoDisplayWidth,
+                   unsigned LineNo);
 
   void emitParseableFixits(ArrayRef<FixItHint> Hints, const SourceManager &SM);
 };
 
 } // end namespace clang
 
 #endif

clang/lib/Driver/ToolChains/Clang.cpp

if (D.getDiags().getDiagnosticOptions().ShowColors)
     CmdArgs.push_back("-fcolor-diagnostics");
 
   if (Args.hasArg(options::OPT_fansi_escape_codes))
     CmdArgs.push_back("-fansi-escape-codes");
 
   Args.addOptOutFlag(CmdArgs, options::OPT_fshow_source_location,
                      options::OPT_fno_show_source_location);
 
+  Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_show_line_numbers,
+                     options::OPT_fno_diagnostics_show_line_numbers);
+
   if (Args.hasArg(options::OPT_fdiagnostics_absolute_paths))
     CmdArgs.push_back("-fdiagnostics-absolute-paths");
 
   if (!Args.hasFlag(options::OPT_fshow_column, options::OPT_fno_show_column,
                     ColumnDefault))
     CmdArgs.push_back("-fno-show-column");
 
   Args.addOptOutFlag(CmdArgs, options::OPT_fspell_checking,

clang/lib/Frontend/TextDiagnostic.cpp

while (SourceStart>0 || SourceEnd<SourceLine.size()) {
     if (!ExpandedRegion)
       break;
   }
 
   CaretStart = map.byteToColumn(SourceStart);
   CaretEnd = map.byteToColumn(SourceEnd) + CaretColumnsOutsideSource;
 
   // [CaretStart, CaretEnd) is the slice we want. Update the various
-  // output lines to show only this slice, with two-space padding
-  // before the lines so that it looks nicer.
-
+  // output lines to show only this slice.
   assert(CaretStart!=(unsigned)-1 && CaretEnd!=(unsigned)-1 &&
          SourceStart!=(unsigned)-1 && SourceEnd!=(unsigned)-1);
   assert(SourceStart <= SourceEnd);
   assert(CaretStart <= CaretEnd);
 
   unsigned BackColumnsRemoved
     = map.byteToColumn(SourceLine.size())-map.byteToColumn(SourceEnd);
   unsigned FrontColumnsRemoved = CaretStart;
for (const auto &H : Hints) {
     }
   }
 
   expandTabs(FixItInsertionLine, DiagOpts->TabStop);
 
   return FixItInsertionLine;
 }
 
+static unsigned getNumDisplayWidth(unsigned N) {
+  unsigned L = 1u, M = 10u;
+  while (M <= N && ++L != std::numeric_limits<unsigned>::digits10 + 1)
+    M *= 10u;
+
+  return L;
+}
+
 /// Emit a code snippet and caret line.
 ///
 /// This routine emits a single line's code snippet and caret line..
 ///
 /// \param Loc The location for the caret.
 /// \param Ranges The underlined ranges for this code snippet.
 /// \param Hints The FixIt hints active for this diagnostic.
 void TextDiagnostic::emitSnippetAndCaret(
     FullSourceLoc Loc, DiagnosticsEngine::Level Level,
     SmallVectorImpl<CharSourceRange> &Ranges, ArrayRef<FixItHint> Hints) {
   assert(Loc.isValid() && "must have a valid source location here");
   assert(Loc.isFileID() && "must have a file location here");
 
   // If caret diagnostics are enabled and we have location, we want to
   // emit the caret.  However, we only do this if the location moved
   // from the last diagnostic, if the last diagnostic was a note that
   // was part of a different warning or error diagnostic, or if the
   // diagnostic has ranges.  We don't want to emit the same caret
void TextDiagnostic::emitSnippetAndCaret(
   // Find the set of lines to include.
   const unsigned MaxLines = DiagOpts->SnippetLineLimit;
   std::pair<unsigned, unsigned> Lines = {CaretLineNo, CaretLineNo};
   for (const auto &I : Ranges) {
     if (auto OptionalRange = findLinesForRange(I, FID, SM))
       Lines = maybeAddRange(Lines, *OptionalRange, MaxLines);
   }
 
-  for (unsigned LineNo = Lines.first; LineNo != Lines.second + 1; ++LineNo) {
+  // Our line numbers look like:
+  // " [number] | "
+  // Where [number] is MaxLineNoDisplayWidth columns
+  // and the full thing is therefore MaxLineNoDisplayWidth + 4 columns.
+  unsigned DisplayLineNo = Loc.getPresumedLoc().getLine();
+  unsigned MaxLineNoDisplayWidth =
+      DiagOpts->ShowLineNumbers
+          ? std::max(4u, getNumDisplayWidth(DisplayLineNo + MaxLines))
+          : 0;
+  auto indentForLineNumbers = [&] {
+    if (MaxLineNoDisplayWidth > 0) {
+      OS << ' ';
+      for (unsigned I = 0; I != MaxLineNoDisplayWidth; ++I)
+        OS << ' ';
+      OS << " | ";
+    }
+  };
+
+  for (unsigned LineNo = Lines.first; LineNo != Lines.second + 1;
+       ++LineNo, ++DisplayLineNo) {
     const char *BufStart = BufData.data();
     const char *BufEnd = BufStart + BufData.size();
 
     // Rewind from the current position to the start of the line.
     const char *LineStart =
         BufStart +
         SM.getDecomposedLoc(SM.translateLineCol(FID, LineNo, 1)).second;
     if (LineStart == BufEnd)
if (DiagOpts->ShowSourceRanges) {
       CaretLine = ' ' + CaretLine;
     }
 
     // Finally, remove any blank spaces from the end of CaretLine.
     while (!CaretLine.empty() && CaretLine[CaretLine.size() - 1] == ' ')
       CaretLine.erase(CaretLine.end() - 1);
 
     // Emit what we have computed.
-    emitSnippet(SourceLine);
+    emitSnippet(SourceLine, MaxLineNoDisplayWidth, DisplayLineNo);
 
     if (!CaretLine.empty()) {
+      indentForLineNumbers();
       if (DiagOpts->ShowColors)
         OS.changeColor(caretColor, true);
       OS << CaretLine << '\n';
       if (DiagOpts->ShowColors)
         OS.resetColor();
     }
 
     if (!FixItInsertionLine.empty()) {
+      indentForLineNumbers();
       if (DiagOpts->ShowColors)
         // Print fixit line in color
         OS.changeColor(fixitColor, false);
       if (DiagOpts->ShowSourceRanges)
         OS << ' ';
       OS << FixItInsertionLine << '\n';
       if (DiagOpts->ShowColors)
         OS.resetColor();
     }
   }
 
   // Print out any parseable fixit information requested by the options.
   emitParseableFixits(Hints, SM);
 }
 
-void TextDiagnostic::emitSnippet(StringRef line) {
+void TextDiagnostic::emitSnippet(StringRef line, unsigned MaxLineNoDisplayWidth,
+                                 unsigned LineNo) {
   if (line.empty())
     return;
 
   size_t i = 0;
 
   std::string to_print;
   bool print_reversed = false;
 
+  // Emit line number.
+  if (MaxLineNoDisplayWidth > 0) {
+    unsigned LineNoDisplayWidth = getNumDisplayWidth(LineNo);
+    OS << ' ';
+    for (unsigned I = LineNoDisplayWidth; I < MaxLineNoDisplayWidth; ++I)
+      OS << ' ';
+    OS << LineNo;
+    OS << " | ";
+  }
+
   while (i<line.size()) {
     std::pair<SmallString<16>,bool> res
         = printableTextForNextCharacter(line, &i, DiagOpts->TabStop);
     bool was_printable = res.second;
 
     if (DiagOpts->ShowColors && was_printable == print_reversed) {
       if (print_reversed)
         OS.reverseColor();

clang/test/Analysis/Checkers/WebKit/uncounted-lambda-captures.cpp

 // RUN: %clang_analyze_cc1 -analyzer-checker=webkit.UncountedLambdaCapturesChecker %s 2>&1 | FileCheck %s --strict-whitespace
 #include "mock-types.h"
 
 void raw_ptr() {
   RefCountable* ref_countable = nullptr;
   auto foo1 = [ref_countable](){};
   // CHECK: warning: Captured raw-pointer 'ref_countable' to uncounted type is unsafe [webkit.UncountedLambdaCapturesChecker]
-  // CHECK-NEXT:{{^}}  auto foo1 = [ref_countable](){};
-  // CHECK-NEXT:{{^}}               ^
+  // CHECK-NEXT:{{^   6 | }}  auto foo1 = [ref_countable](){};
+  // CHECK-NEXT:{{^     | }}               ^
   auto foo2 = [&ref_countable](){};
   // CHECK: warning: Captured raw-pointer 'ref_countable' to uncounted type is unsafe [webkit.UncountedLambdaCapturesChecker]
   auto foo3 = [&](){ ref_countable = nullptr; };
   // CHECK: warning: Implicitly captured raw-pointer 'ref_countable' to uncounted type is unsafe [webkit.UncountedLambdaCapturesChecker]
-  // CHECK-NEXT:{{^}}  auto foo3 = [&](){ ref_countable = nullptr; };
-  // CHECK-NEXT:{{^}}                     ^
+  // CHECK-NEXT:{{^  12 | }}  auto foo3 = [&](){ ref_countable = nullptr; };
+  // CHECK-NEXT:{{^     | }}                     ^
   auto foo4 = [=](){ (void) ref_countable; };
   // CHECK: warning: Implicitly captured raw-pointer 'ref_countable' to uncounted type is unsafe [webkit.UncountedLambdaCapturesChecker]
 }
 
 void references() {
   RefCountable automatic;
   RefCountable& ref_countable_ref = automatic;
 

clang/test/FixIt/fixit-function-call.cpp

-// RUN: not %clang_cc1 -fdiagnostics-parseable-fixits -x c++ %s 2> %t
+// RUN: not %clang_cc1 -fdiagnostics-parseable-fixits -fno-diagnostics-show-line-numbers -fcaret-diagnostics-max-lines 1 -x c++ %s 2> %t
 // RUN: FileCheck %s < %t
 // PR5941
 // END.
 
 /* Test fixits for * and & mismatch in function arguments.
  * Since fixits are on the notes, they cannot be applied automatically. */
 
 typedef int intTy;

clang/test/FixIt/fixit-newline-style.c

-// RUN: %clang_cc1 -pedantic -Wunused-label -x c %s 2>&1 | FileCheck %s -strict-whitespace
+// RUN: %clang_cc1 -pedantic -Wunused-label -fno-diagnostics-show-line-numbers -x c %s 2>&1 | FileCheck %s -strict-whitespace
 
 // This file intentionally uses a CRLF newline style
 // <rdar://problem/12639047>
 // CHECK: warning: unused label 'ddd'
 // CHECK-NEXT: {{^  ddd:}}
 // CHECK-NEXT: {{^  \^~~~$}}
 void f(void) {
   ddd:
   ;
 }

clang/test/FixIt/fixit-unicode-with-utf8-output.c

 // This test is an additional set of checks for the fixit-unicode.c test for
 // systems capable of outputting Unicode characters to the standard output in
 // the UTF-8 encoding.
-// RUN: not %clang_cc1 -fsyntax-only %S/fixit-unicode.c 2>&1 | FileCheck -strict-whitespace %s
+// RUN: not %clang_cc1 -fsyntax-only -fno-diagnostics-show-line-numbers %S/fixit-unicode.c 2>&1 | FileCheck -strict-whitespace %s
 // REQUIRES: utf8-capable-terminal
 
 // CHECK: warning: format specifies type 'int' but the argument has type 'long'
 // CHECK: {{^  printf\("∆: %d", 1L\);}}
 // CHECK: {{^             ~~   \^~}}
 
 // CHECK: error: use of undeclared identifier 'กsss'; did you mean 'กssss'?
 // CHECK: {{^          \^}}

clang/test/FixIt/fixit-unicode.c

 // This file contains code and checks, that should work on any platform.
 // There's a set of additional checks for systems with proper support of UTF-8
 // on the standard output in fixit-unicode-with-utf8-output.c.
 
-// RUN: not %clang_cc1 -fsyntax-only %s 2>&1 | FileCheck -strict-whitespace %s
-// RUN: not %clang_cc1 -fsyntax-only -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck -check-prefix=CHECK-MACHINE %s
+// RUN: not %clang_cc1 -fsyntax-only -fno-diagnostics-show-line-numbers %s 2>&1 | FileCheck -strict-whitespace %s
+// RUN: not %clang_cc1 -fsyntax-only -fno-diagnostics-show-line-numbers -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck -check-prefix=CHECK-MACHINE %s
 
 struct Foo {
   int bar;
 };
 
 // PR13312
 void test1() {
   struct Foo foo;

clang/test/Frontend/source-col-map.c

-// RUN: not %clang_cc1 -fsyntax-only -fmessage-length=75 -o /dev/null -x c < %s 2>&1 | FileCheck %s -strict-whitespace
+// RUN: not %clang_cc1 -fsyntax-only -fno-diagnostics-show-line-numbers -fmessage-length=75 -o /dev/null -x c < %s 2>&1 | FileCheck %s -strict-whitespace
 // REQUIRES: utf8-capable-terminal
 
 // Test case for the text diagnostics source column conversion crash.
 
 // This test case tries to check the error diagnostic message printer, which is
 // responsible to create the code snippet shorter than the message-length (in
 // number of columns.)
 //

clang/test/Lexer/header.cpp

 // RUN: %clang_cc1 -fsyntax-only -Wno-header-guard %s
-// RUN: %clang_cc1 -fsyntax-only -Wheader-guard %s 2>&1 | FileCheck %s
+// RUN: %clang_cc1 -fsyntax-only -Wheader-guard -fno-diagnostics-show-line-numbers %s 2>&1 | FileCheck %s
 
 #include "Inputs/good-header-guard.h"
 #include "Inputs/no-define.h"
 #include "Inputs/different-define.h"
 #include "Inputs/out-of-order-define.h"
 #include "Inputs/tokens-between-ifndef-and-define.h"
 #include "Inputs/unlikely-to-be-header-guard.h"
 

clang/test/Lexer/string-literal-errors.cpp

-// RUN: not %clang_cc1 -fsyntax-only %s 2>&1 | FileCheck -strict-whitespace %s
+// RUN: not %clang_cc1 -fsyntax-only -fno-diagnostics-show-line-numbers %s 2>&1 | FileCheck -strict-whitespace %s
 
 void foo() {
   (void)"\q \u123z \x \U \U123 \U12345 \u123 \xyzzy \777 \U"
   // CHECK: {{^  \(void\)"\\q \\u123z \\x \\U \\U123 \\U12345 \\u123 \\xyzzy \\777 \\U"$}}
   //
   //              (void)"\q \u123z \x \U \U123 \U12345 \u123 \xyzzy \777 \U"
   // CHECK: {{^         \^~$}}
   // CHECK: {{^            \^~~~~$}}

clang/test/Misc/caret-diags-macros.c

-// RUN: %clang_cc1 -fsyntax-only %s 2>&1 | FileCheck %s -strict-whitespace
+// RUN: %clang_cc1 -fsyntax-only -fno-diagnostics-show-line-numbers %s 2>&1 | FileCheck %s -strict-whitespace
 
 #define M1(x) x
 #define M2 1;
 void foo(void) {
   M1(
     M2);
   // CHECK: {{.*}}:7:{{[0-9]+}}: warning: expression result unused
   // CHECK: {{.*}}:4:{{[0-9]+}}: note: expanded from macro 'M2'

clang/test/Misc/caret-diags-multiline.cpp

-// RUN: not %clang_cc1 -std=c++11 -fcaret-diagnostics-max-lines 5 -Wsometimes-uninitialized %s 2>&1 | FileCheck %s --strict-whitespace
+// RUN: not %clang_cc1 -std=c++11 -fno-diagnostics-show-line-numbers -fcaret-diagnostics-max-lines 5 -Wsometimes-uninitialized %s 2>&1 | FileCheck %s --strict-whitespace
 
 void line(int);
 
 // Check we expand the range as much as possible within the limit.
 
 // CHECK:      warning: variable 'a' is used uninitialized whenever 'if' condition is true
 // CHECK-NEXT: {{^}}  if (cond) {
 // CHECK-NEXT: {{^}}      ^~~~{{$}}

clang/test/Misc/diag-macro-backtrace.c

-// RUN: not %clang -fsyntax-only -fmacro-backtrace-limit=0 %s 2>&1 | FileCheck %s
+// RUN: not %clang -fsyntax-only -fno-diagnostics-show-line-numbers -fmacro-backtrace-limit=0 %s 2>&1 | FileCheck %s
 
 #define FOO 1+"hi" 
 #define BAR FOO
 #define BAZ BAR
 #define QUZ BAZ
 #define TAZ QUZ
 #define ABA TAZ
 #define BAB ABA

clang/test/Misc/message-length.c

void a_very_long_line(int *ip, float *FloatPointer) {
 
 
   int array0[] = { [3] 3, 5, 7, 4, 2, 7, 6, 3, 4, 5, 6, 7, 8, 9, 12, 345, 14, 345, 789, 234, 678, 345, 123, 765, 234 };
 }
 
 #pragma STDC CX_LIMITED_RANGE    // some long comment text and a brace, eh {}
 
 // CHECK: FILE:23:78
-// CHECK: {{^  ...// some long comment text and a brace, eh {}}}
+// CHECK: {{^   23 |  ...// some long comment text and a brace, eh {}}}
 
 struct A { int x; };
 void h(struct A *a) {
   // CHECK-DOT: member
   // CHECK-DOT: reference
   // CHECK-DOT: type
   (void)a
           .
           x;
 }

clang/test/Misc/tabstop.c

-// RUN: %clang_cc1 -ftabstop 3 -fsyntax-only -Wno-error=int-conversion %s 2>&1 | FileCheck -check-prefix=CHECK-3 -strict-whitespace %s
-// RUN: %clang_cc1 -ftabstop 4 -fsyntax-only -Wno-error=int-conversion %s 2>&1 | FileCheck -check-prefix=CHECK-4 -strict-whitespace %s
-// RUN: %clang_cc1 -ftabstop 5 -fsyntax-only -Wno-error=int-conversion %s 2>&1 | FileCheck -check-prefix=CHECK-5 -strict-whitespace %s
+// RUN: %clang_cc1 -ftabstop 3 -fsyntax-only -Wno-error=int-conversion -fno-diagnostics-show-line-numbers %s 2>&1 | FileCheck -check-prefix=CHECK-3 -strict-whitespace %s
+// RUN: %clang_cc1 -ftabstop 4 -fsyntax-only -Wno-error=int-conversion -fno-diagnostics-show-line-numbers %s 2>&1 | FileCheck -check-prefix=CHECK-4 -strict-whitespace %s
+// RUN: %clang_cc1 -ftabstop 5 -fsyntax-only -Wno-error=int-conversion -fno-diagnostics-show-line-numbers %s 2>&1 | FileCheck -check-prefix=CHECK-5 -strict-whitespace %s
 
 // tab
   void* a = 1;
 
 // tab tab
     void* b = 1;
 
 // 3x space tab

clang/test/Misc/unnecessary-elipses.cpp

-// RUN: %clang_cc1 -fsyntax-only -fmessage-length=80 %s 2>&1 | FileCheck -strict-whitespace %s
+// RUN: %clang_cc1 -fsyntax-only -fmessage-length=80 -fno-diagnostics-show-line-numbers %s 2>&1 | FileCheck -strict-whitespace %s
 
 int main() {
     "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
 // CHECK: {{^    "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";}}
 
         "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
 // CHECK: {{^  ..."xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";}}
 
 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"        ;
 // CHECK: {{^"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"...}}
 
         "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"        ;
 // CHECK: {{^  ..."xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"...}}
 }

clang/test/Misc/unprintable.c

-// RUN: not %clang_cc1 %s -fmessage-length=40 2>&1 | FileCheck -strict-whitespace %s
+// RUN: not %clang_cc1 %s -fmessage-length=40 -fno-diagnostics-show-line-numbers 2>&1 | FileCheck -strict-whitespace %s
 
 int main() {
     int i;
     if((i==/*￾*/1));
 
 // CHECK: {{^    if\(\(i==/\*<U\+FFFE>\*/1\)\);}}
 
 // CHECK: {{^        ~\^~~~~~~~~~~~~~~}}

clang/test/Misc/wrong-encoding.c

-// RUN: %clang_cc1 -fsyntax-only -Wno-unused-value %s 2>&1 | FileCheck %s
+// RUN: %clang_cc1 -fsyntax-only -Wno-unused-value -fno-diagnostics-show-line-numbers %s 2>&1 | FileCheck %s
 // REQUIRES: asserts
 
 void foo(void) {
 
   "§Ã"; // ø
 // CHECK: {{^  "<A7><C3>"; // <F8>}}
 // CHECK: {{^   \^~~~~~~}}
 

clang/test/Parser/brackets.c

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 // RUN: cp %s %t
 // RUN: not %clang_cc1 -fixit %t -x c -DFIXIT
 // RUN: %clang_cc1 -fsyntax-only %t -x c -DFIXIT
-// RUN: not %clang_cc1 -fsyntax-only -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s -strict-whitespace
+// RUN: not %clang_cc1 -fsyntax-only -fdiagnostics-parseable-fixits -fno-diagnostics-show-line-numbers %s 2>&1 | FileCheck %s -strict-whitespace
 
 void test1(void) {
   int a[] = {0,1,1,2,3};
   int []b = {0,1,4,9,16};
   // expected-error@-1{{brackets are not allowed here; to declare an array, place the brackets after the identifier}}
   // CHECK: {{^}}  int []b = {0,1,4,9,16};
   // CHECK: {{^}}      ~~ ^
   // CHECK: {{^}}         []

clang/test/Parser/brackets.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 // RUN: cp %s %t
 // RUN: not %clang_cc1 -fixit %t -x c++ -DFIXIT
 // RUN: %clang_cc1 -fsyntax-only %t -x c++ -DFIXIT
-// RUN: not %clang_cc1 -fsyntax-only -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s -strict-whitespace
+// RUN: not %clang_cc1 -fsyntax-only -fdiagnostics-parseable-fixits -fno-diagnostics-show-line-numbers %s 2>&1 | FileCheck %s -strict-whitespace
 
 void test1() {
   int a[] = {0,1,1,2,3};
   int []b = {0,1,4,9,16};
   // expected-error@-1{{brackets are not allowed here; to declare an array, place the brackets after the name}}
   // CHECK: {{^}}  int []b = {0,1,4,9,16};
   // CHECK: {{^}}      ~~ ^
   // CHECK: {{^}}         []

clang/test/Preprocessor/ucn-pp-identifier.c

 #else
 #error "Line splicing failed to produce UCNs"
 #endif
 
 
 #define capital_u_\U00FC
 // expected-warning@-1 {{incomplete universal character name}} expected-note@-1 {{did you mean to use '\u'?}} expected-warning@-1 {{whitespace}}
 // CHECK: note: did you mean to use '\u'?
-// CHECK-NEXT:   #define capital_u_\U00FC
-// CHECK-NEXT: {{^                   \^}}
-// CHECK-NEXT: {{^                   u}}
+// CHECK-NEXT: {{^  112 | #define capital_u_\U00FC}}
+// CHECK-NEXT: {{^      |                    \^}}
+// CHECK-NEXT: {{^      |                    u}}
 
 #define \u{}           // expected-warning {{empty delimited universal character name; treating as '\' 'u' '{' '}'}} expected-error {{macro name must be an identifier}}
 #define \u1{123}       // expected-warning {{incomplete universal character name; treating as '\' followed by identifier}} expected-error {{macro name must be an identifier}}
 #define \u{123456789}  // expected-error {{hex escape sequence out of range}} expected-error {{macro name must be an identifier}}
 #define \u{            // expected-warning {{incomplete delimited universal character name; treating as '\' 'u' '{' identifier}} expected-error {{macro name must be an identifier}}
 #define \u{fgh}        // expected-warning {{incomplete delimited universal character name; treating as '\' 'u' '{' identifier}} expected-error {{macro name must be an identifier}}
 #define \N{
 // expected-warning@-1 {{incomplete delimited universal character name; treating as '\' 'N' '{' identifier}}

clang/test/Sema/caret-diags-complex-init.cpp

-// RUN: not %clang_cc1 -std=c++11 -fsyntax-only -fcaret-diagnostics-max-lines 5 %s 2>&1 | FileCheck %s -strict-whitespace
+// RUN: not %clang_cc1 -std=c++11 -fsyntax-only -fno-diagnostics-show-line-numbers -fcaret-diagnostics-max-lines 5 %s 2>&1 | FileCheck %s -strict-whitespace
 
 
 //CHECK: {{.*}}: error: excess elements in scalar initializer
 //CHECK-NEXT: {{^}}_Complex double gz1 = {1, 2, 3};
 //CHECK-NEXT: {{^}}                             ^{{$}}
 _Complex double gz1 = {1, 2, 3}; 
 
 //CHECK: {{.*}}: error: excess elements in scalar initializer

clang/test/SemaCXX/struct-class-redecl.cpp

-// RUN: %clang_cc1 -fsyntax-only -Wmismatched-tags -verify %s
-// RUN: not %clang_cc1 -fsyntax-only -Wmismatched-tags %s 2>&1 | FileCheck %s
+// RUN: %clang_cc1 -fsyntax-only -Wmismatched-tags -fno-diagnostics-show-line-numbers -verify %s
+// RUN: not %clang_cc1 -fsyntax-only -Wmismatched-tags -fno-diagnostics-show-line-numbers %s 2>&1 | FileCheck %s
 class X; // expected-note 2{{here}}
 typedef struct X * X_t; // expected-warning{{previously declared}}
 union X { int x; float y; }; // expected-error{{use of 'X' with tag type that does not match previous declaration}}
 
 template<typename T> struct Y; // expected-note{{did you mean class here?}}
 template<class U> class Y { }; // expected-warning{{previously declared}}
 
 template <typename>