[-Wunsafe-buffer-usage] Make raw (ungrouped) warnings a bit more verbose.

[NoQ]

Summary

So far we didn't pay enough attention to them given that we spent a lot of time on grouped warnings, but D146669 will cause them to be displayed more often. Make them nicer and more understandable.

[NoQ]

clang/include/clang/Basic/DiagnosticSemaKinds.td

11786

The first mode doesn't show up in any tests and it's probably dead code at this point.

[malavikasamak]

clang/include/clang/Basic/DiagnosticSemaKinds.td

11786

What do you think of specifying the variable name in these warnings? It could be helpful when there are more than one DREs in a statement.

[NoQ]

clang/include/clang/Basic/DiagnosticSemaKinds.td

11786

These warnings are emitted only when we *cannot* identify the variable; either because it's not there at all, or we don't know how to find it. If we could figure out the variable, we'd be emitting warn_unsafe_buffer_variable instead. IIRC, in all of the provided test cases the operand isn't a DRE.

That said, I totally agree that it's a great idea to try a few other things to point out the specific subexpression, even if we don't connect the warning gadget to a variable. Say, we can try to blame MemberExprs or CallExprs the same way we blame DREs, and include their name in the warning. I'll try a few things real quick and see how bad it gets.

Note that these are also the things for which we may eventually start providing constructive solutions. Say, an unsafe operation on CallExpr can be a reason to autofix the callee to return a std::span. So hopefully these warnings will eventually be replaced by better warnings in more and more cases.

[ziqingluo-90]

LGTM, Thanks!

[NoQ]

clang/include/clang/Basic/DiagnosticSemaKinds.td

11786

Wait nvm, the whole point of this patch is to warn when variable discovery is manually turned off! I'm an idiot, this absolutely deserves more effort.

[NoQ]

Rebase.

Make warnings a bit more verbose than before. This plays nicely with our attempts to categorize unemitted fixits via -mllvm -debug-only=SafeBuffers, but this time it doesn't make sense to make the extra information debug-only; it makes perfect sense as part of the warning.

TODO: Some new code paths aren't covered by tests yet (captured variables, static member variables).

[NoQ]

clang/test/SemaCXX/warn-unsafe-buffer-usage.cpp

231

I don't think this FIXME was correct. The code we're warning about isn't expanded from a template.

[NoQ]

Rebase. Add remaining tests.

I think this is ready to land now.

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_loongarch_builtin_requires_la64 : Error<
   "this builtin requires target: loongarch64">;
 
 // Unsafe buffer usage diagnostics.
 def warn_unsafe_buffer_variable : Warning<
   "%0 is an %select{unsafe pointer used for buffer access|unsafe buffer that "
   "does not perform bounds checks}1">,
   InGroup<UnsafeBufferUsage>, DefaultIgnore;
 def warn_unsafe_buffer_operation : Warning<
-  "%select{unsafe pointer operation|unsafe pointer arithmetic|"
-  "unsafe buffer access|function introduces unsafe buffer manipulation}0">,
-  InGroup<UnsafeBufferUsage>, DefaultIgnore;
+  "%select{"
+    "unsafe operation on raw pointer in expression|"
+    "unsafe arithmetic on raw pointer|"
+    "unsafe buffer access through raw pointer|"
+    "function call introduces unsafe buffer manipulation"
+  "}0">, InGroup<UnsafeBufferUsage>, DefaultIgnore;
 def note_unsafe_buffer_operation : Note<
-  "used%select{| in pointer arithmetic| in buffer access}0 here">;
+  "used %select{"
+    "|"
+    "in pointer arithmetic|"
+    "in buffer access"
+  "}0 here">;
 def note_unsafe_buffer_variable_fixit : Note<
   "change type of '%0' to '%select{std::span|std::array|std::span::iterator}1' to preserve bounds information">;
 def note_safe_buffer_usage_suggestions_disabled : Note<
   "pass -fsafe-buffer-usage-suggestions to receive code hardening suggestions">;
 def err_loongarch_builtin_requires_la32 : Error<
   "this builtin requires target: loongarch32">;
 
 def err_builtin_pass_in_regs_non_class : Error<

clang/test/SemaCXX/unsafe-buffer-usage-diag-type.cpp

 
 namespace structField {
 struct Struct1 {
   int * ptr;      // FIXME: per-declaration warning aggregated at the struct definition?
 };
 
 void testRefersPtrStructFieldDecl(int i) {
   Struct1 s1;
-  s1.ptr + i;     // expected-warning{{unsafe pointer arithmetic}}
-  s1.ptr[i];      // expected-warning{{unsafe buffer access}}
+  s1.ptr + i;     // expected-warning{{unsafe arithmetic on raw pointer}}
+  s1.ptr[i];      // expected-warning{{unsafe buffer access through raw pointer}}
 }
 
 struct Struct2 {
   int array[10];  // FIXME: per-declaration warning aggregated at the struct definition?
 };
 
 void testRefersArrayStructFieldDecl(int i) {
   Struct2 s2;
-  s2.array[i/2];  // expected-warning{{unsafe buffer access}}
+  s2.array[i/2];  // expected-warning{{unsafe buffer access through raw pointer}}
 }
 }
 
 namespace structFieldFromMethod {
 struct Struct1 {
   int * ptr;      // FIXME: per-declaration warning aggregated at the struct definition
 
   void testRefersPtrStructFieldDecl(int i) {
-    ptr + i;     // expected-warning{{unsafe pointer arithmetic}}
-    ptr[i];      // expected-warning{{unsafe buffer access}}
+    ptr + i;     // expected-warning{{unsafe arithmetic on raw pointer}}
+    ptr[i];      // expected-warning{{unsafe buffer access through raw pointer}}
   }
 };
 
 struct Struct2 {
   int array[10];  // FIXME: per-declaration warning aggregated at the struct definition
 
   void testRefersArrayStructFieldDecl(int i) {
     Struct2 s2;
-    s2.array[i/2];  // expected-warning{{unsafe buffer access}}
+    s2.array[i/2];  // expected-warning{{unsafe buffer access through raw pointer}}
   }
 };
 }
 
 namespace staticStructField {
 struct Struct1 {
   static int * ptr;      // expected-warning{{'ptr' is an unsafe pointer used for buffer access}}
 };

 void testRefersArrayStructFieldDecl(int i) {
   Struct2::array[i/2];     // expected-note{{used in buffer access here}}
 }
 }
 
 int * return_ptr();
 
 void testNoDeclRef(int i) {
-  return_ptr() + i;   // expected-warning{{unsafe pointer arithmetic}}
-  return_ptr()[i];    // expected-warning{{unsafe buffer access}}
+  return_ptr() + i;   // expected-warning{{unsafe arithmetic on raw pointer}}
+  return_ptr()[i];    // expected-warning{{unsafe buffer access through raw pointer}}
 }

clang/test/SemaCXX/warn-unsafe-buffer-usage-function-attr.cpp

 void overloading(char c[]);
 
 void overloading(int* x, int size);
 
 [[clang::unsafe_buffer_usage]]
 void deprecatedFunction4(int z);
 
 void caller(int z, int* x, int size, char c[]) {
-    deprecatedFunction3(); // expected-warning{{function introduces unsafe buffer manipulation}}
-    deprecatedFunction4(z); // expected-warning{{function introduces unsafe buffer manipulation}}
+    deprecatedFunction3(); // expected-warning{{function call introduces unsafe buffer manipulation}}
+    deprecatedFunction4(z); // expected-warning{{function call introduces unsafe buffer manipulation}}
     someFunction();
 
-    overloading(x); // expected-warning{{function introduces unsafe buffer manipulation}}
+    overloading(x); // expected-warning{{function call introduces unsafe buffer manipulation}}
     overloading(x, size);
     overloading(c);
 }
 
 [[clang::unsafe_buffer_usage]]
 void overloading(char c[]);
 
 // Test variadics
 [[clang::unsafe_buffer_usage]]
 void testVariadics(int *ptr, ...);
 
 template<typename T, typename... Args>
 [[clang::unsafe_buffer_usage]]
 T adder(T first, Args... args);
 
 template <typename T>
 void foo(T t) {}
 
 template<>
 [[clang::unsafe_buffer_usage]]
 void foo<int *>(int *t) {}
 
 void caller1(int *p, int *q) {
-    testVariadics(p, q);  // expected-warning{{function introduces unsafe buffer manipulation}}
-    adder(p, q);  // expected-warning{{function introduces unsafe buffer manipulation}}
+    testVariadics(p, q);  // expected-warning{{function call introduces unsafe buffer manipulation}}
+    adder(p, q);  // expected-warning{{function call introduces unsafe buffer manipulation}}
     
     int x;
     foo(x);
-    foo(&x);  // expected-warning{{function introduces unsafe buffer manipulation}}
+    foo(&x);  // expected-warning{{function call introduces unsafe buffer manipulation}}
 }
 
 // Test virtual functions
 class BaseClass {
 public:
     [[clang::unsafe_buffer_usage]]
     virtual void func() {}
     
     virtual void func1() {}
 };
 
 class DerivedClass : public BaseClass {
 public:
     void func() {}
     
     [[clang::unsafe_buffer_usage]]
     void func1() {}
 };
 
 void testInheritance() {
     DerivedClass DC;
     DC.func();
-    DC.func1();  // expected-warning{{function introduces unsafe buffer manipulation}}
+    DC.func1();  // expected-warning{{function call introduces unsafe buffer manipulation}}
     
     BaseClass *BC;
-    BC->func();  // expected-warning{{function introduces unsafe buffer manipulation}}
+    BC->func();  // expected-warning{{function call introduces unsafe buffer manipulation}}
     BC->func1();
     
     BC = &DC;
-    BC->func();  // expected-warning{{function introduces unsafe buffer manipulation}}
+    BC->func();  // expected-warning{{function call introduces unsafe buffer manipulation}}
     BC->func1();
 }

clang/test/SemaCXX/warn-unsafe-buffer-usage-suggestions-flag.cpp

 // RUN:        -fno-safe-buffer-usage-suggestions \
 // RUN:        -Xclang -fsafe-buffer-usage-suggestions \
 // RUN:        -Xclang -verify=ON %s
 
 [[clang::unsafe_buffer_usage]] void bar(int *);
 
 void foo(int *x) { // \
   // ON-warning{{'x' is an unsafe pointer used for buffer access}}
-  // FIXME: Better "OFF" warning?
   x[5] = 10; // \
   // ON-note    {{used in buffer access here}} \
-  // OFF-warning{{unsafe buffer access}} \
+  // OFF-warning{{unsafe buffer access through raw pointer}} \
   // OFF-note   {{pass -fsafe-buffer-usage-suggestions to receive code hardening suggestions}}
 
   x += 5;  // \
   // ON-note    {{used in pointer arithmetic here}} \
-  // OFF-warning{{unsafe pointer arithmetic}} \
+  // OFF-warning{{unsafe arithmetic on raw pointer}} \
   // OFF-note   {{pass -fsafe-buffer-usage-suggestions to receive code hardening suggestions}}
 
   bar(x);  // \
-  // ON-warning{{function introduces unsafe buffer manipulation}} \
-  // OFF-warning{{function introduces unsafe buffer manipulation}} \
+  // ON-warning {{function call introduces unsafe buffer manipulation}} \
+  // OFF-warning{{function call introduces unsafe buffer manipulation}} \
   // OFF-note   {{pass -fsafe-buffer-usage-suggestions to receive code hardening suggestions}}
 }

clang/test/SemaCXX/warn-unsafe-buffer-usage.cpp

 void * voidPtrCall(void);
 char * charPtrCall(void);
 
 void testArraySubscripts(int *p, int **pp) {
 // expected-warning@-1{{'p' is an unsafe pointer used for buffer access}}
 // expected-warning@-2{{'pp' is an unsafe pointer used for buffer access}}
   foo(p[1],             // expected-note{{used in buffer access here}}
       pp[1][1],         // expected-note{{used in buffer access here}}
-                        // expected-warning@-1{{unsafe buffer access}}
+                        // expected-warning@-1{{unsafe buffer access through raw pointer}}
       1[1[pp]],         // expected-note{{used in buffer access here}}
-                        // expected-warning@-1{{unsafe buffer access}}
+                        // expected-warning@-1{{unsafe buffer access through raw pointer}}
       1[pp][1]          // expected-note{{used in buffer access here}}
-                        // expected-warning@-1{{unsafe buffer access}}
+                        // expected-warning@-1{{unsafe buffer access through raw pointer}}
       );
 
   if (p[3]) {           // expected-note{{used in buffer access here}}
     void * q = p;
 
-    foo(((int*)q)[10]); // expected-warning{{unsafe buffer access}}
+    foo(((int*)q)[10]); // expected-warning{{unsafe buffer access through raw pointer}}
   }
 
-  foo(((int*)voidPtrCall())[3], // expected-warning{{unsafe buffer access}}
-      3[(int*)voidPtrCall()],   // expected-warning{{unsafe buffer access}}
-      charPtrCall()[3],         // expected-warning{{unsafe buffer access}}
-      3[charPtrCall()]          // expected-warning{{unsafe buffer access}}
+  foo(((int*)voidPtrCall())[3], // expected-warning{{unsafe buffer access through raw pointer}}
+      3[(int*)voidPtrCall()],   // expected-warning{{unsafe buffer access through raw pointer}}
+      charPtrCall()[3],         // expected-warning{{unsafe buffer access through raw pointer}}
+      3[charPtrCall()]          // expected-warning{{unsafe buffer access through raw pointer}}
       );
 
     int a[10];          // expected-warning{{'a' is an unsafe buffer that does not perform bounds checks}}
     int b[10][10];      // expected-warning{{'b' is an unsafe buffer that does not perform bounds checks}}
 
   foo(a[1], 1[a],   // expected-note2{{used in buffer access here}}
-      b[3][4],      // expected-warning{{unsafe buffer access}}
+      b[3][4],      // expected-warning{{unsafe buffer access through raw pointer}}
                     // expected-note@-1{{used in buffer access here}}
-      4[b][3],      // expected-warning{{unsafe buffer access}}
+      4[b][3],      // expected-warning{{unsafe buffer access through raw pointer}}
                     // expected-note@-1{{used in buffer access here}}
-      4[3[b]]);     // expected-warning{{unsafe buffer access}}
+      4[3[b]]);     // expected-warning{{unsafe buffer access through raw pointer}}
                     // expected-note@-1{{used in buffer access here}}
 
   // Not to warn when index is zero
   foo(p[0], pp[0][0], 0[0[pp]], 0[pp][0],
       ((int*)voidPtrCall())[0],
       0[(int*)voidPtrCall()],
       charPtrCall()[0],
       0[charPtrCall()]
auto ap2 = p;   // expected-warning{{'ap2' is an unsafe pointer used for buffer access}} \
            expected-note{{change type of 'ap2' to 'std::span' to preserve bounds information}}
 
   foo(ap2[1]);    // expected-note{{used in buffer access here}}
 
   auto ap3 = pp;  // expected-warning{{'ap3' is an unsafe pointer used for buffer access}} \
          expected-note{{change type of 'ap3' to 'std::span' to preserve bounds information}}
 
   foo(ap3[1][1]); // expected-note{{used in buffer access here}}
-                  // expected-warning@-1{{unsafe buffer access}}
+                  // expected-warning@-1{{unsafe buffer access through raw pointer}}
 
   auto ap4 = *pp; // expected-warning{{'ap4' is an unsafe pointer used for buffer access}} \
            expected-note{{change type of 'ap4' to 'std::span' to preserve bounds information}}
 
   foo(ap4[1]);    // expected-note{{used in buffer access here}}
 }
 
 //TODO: do not warn for unevaluated context
 void testUnevaluatedContext(int * p) {// expected-warning{{'p' is an unsafe pointer used for buffer access}}
   foo(sizeof(p[1]),             // expected-note{{used in buffer access here}}
       sizeof(decltype(p[1])));  // expected-note{{used in buffer access here}}
 }
 
 void testQualifiedParameters(const int * p, const int * const q, const int a[10], const int b[10][10]) {
   // expected-warning@-1{{'p' is an unsafe pointer used for buffer access}}
   // expected-warning@-2{{'q' is an unsafe pointer used for buffer access}}
   // expected-warning@-3{{'a' is an unsafe pointer used for buffer access}}
   // expected-warning@-4{{'b' is an unsafe pointer used for buffer access}}
 
   foo(p[1], 1[p], p[-1],    // expected-note3{{used in buffer access here}}
       q[1], 1[q], q[-1],    // expected-note3{{used in buffer access here}}
       a[1],                 // expected-note{{used in buffer access here}}     `a` is of pointer type
       b[1][2]               // expected-note{{used in buffer access here}}     `b[1]` is of array type
-                            // expected-warning@-1{{unsafe buffer access}}
+                            // expected-warning@-1{{unsafe buffer access through raw pointer}}
       );
 }
 
 struct T {
   int a[10];
   int * b;
   struct {
     int a[10];
     int * b;
   } c;
 };
 
 typedef struct T T_t;
 
 T_t funRetT();
 T_t * funRetTStar();
 
 void testStructMembers(struct T * sp, struct T s, T_t * sp2, T_t s2) {
-  foo(sp->a[1],     // expected-warning{{unsafe buffer access}}
-      sp->b[1],     // expected-warning{{unsafe buffer access}}
-      sp->c.a[1],   // expected-warning{{unsafe buffer access}}
-      sp->c.b[1],   // expected-warning{{unsafe buffer access}}
-      s.a[1],       // expected-warning{{unsafe buffer access}}
-      s.b[1],       // expected-warning{{unsafe buffer access}}
-      s.c.a[1],     // expected-warning{{unsafe buffer access}}
-      s.c.b[1],     // expected-warning{{unsafe buffer access}}
-      sp2->a[1],    // expected-warning{{unsafe buffer access}}
-      sp2->b[1],    // expected-warning{{unsafe buffer access}}
-      sp2->c.a[1],  // expected-warning{{unsafe buffer access}}
-      sp2->c.b[1],  // expected-warning{{unsafe buffer access}}
-      s2.a[1],      // expected-warning{{unsafe buffer access}}
-      s2.b[1],      // expected-warning{{unsafe buffer access}}
-      s2.c.a[1],           // expected-warning{{unsafe buffer access}}
-      s2.c.b[1],           // expected-warning{{unsafe buffer access}}
-      funRetT().a[1],      // expected-warning{{unsafe buffer access}}
-      funRetT().b[1],      // expected-warning{{unsafe buffer access}}
-      funRetTStar()->a[1], // expected-warning{{unsafe buffer access}}
-      funRetTStar()->b[1]  // expected-warning{{unsafe buffer access}}
+  foo(sp->a[1],     // expected-warning{{unsafe buffer access through raw pointer}}
+      sp->b[1],     // expected-warning{{unsafe buffer access through raw pointer}}
+      sp->c.a[1],   // expected-warning{{unsafe buffer access through raw pointer}}
+      sp->c.b[1],   // expected-warning{{unsafe buffer access through raw pointer}}
+      s.a[1],       // expected-warning{{unsafe buffer access through raw pointer}}
+      s.b[1],       // expected-warning{{unsafe buffer access through raw pointer}}
+      s.c.a[1],     // expected-warning{{unsafe buffer access through raw pointer}}
+      s.c.b[1],     // expected-warning{{unsafe buffer access through raw pointer}}
+      sp2->a[1],    // expected-warning{{unsafe buffer access through raw pointer}}
+      sp2->b[1],    // expected-warning{{unsafe buffer access through raw pointer}}
+      sp2->c.a[1],  // expected-warning{{unsafe buffer access through raw pointer}}
+      sp2->c.b[1],  // expected-warning{{unsafe buffer access through raw pointer}}
+      s2.a[1],      // expected-warning{{unsafe buffer access through raw pointer}}
+      s2.b[1],      // expected-warning{{unsafe buffer access through raw pointer}}
+      s2.c.a[1],           // expected-warning{{unsafe buffer access through raw pointer}}
+      s2.c.b[1],           // expected-warning{{unsafe buffer access through raw pointer}}
+      funRetT().a[1],      // expected-warning{{unsafe buffer access through raw pointer}}
+      funRetT().b[1],      // expected-warning{{unsafe buffer access through raw pointer}}
+      funRetTStar()->a[1], // expected-warning{{unsafe buffer access through raw pointer}}
+      funRetTStar()->b[1]  // expected-warning{{unsafe buffer access through raw pointer}}
       );
 }
 
 int garray[10];     // expected-warning{{'garray' is an unsafe buffer that does not perform bounds checks}}
 int * gp = garray;  // expected-warning{{'gp' is an unsafe pointer used for buffer access}}
-int gvar = gp[1];   // FIXME: file scope unsafe buffer access is not warned
+int gvar = gp[1];   // FIXME: file scope unsafe buffer access through raw pointer is not warned
 
 // FIXME: Add test for lambda capture with initializer. E. g. auto Lam = [new_p = p]() {...
 void testLambdaCaptureAndGlobal(int * p) {
   // expected-warning@-1{{'p' is an unsafe pointer used for buffer access}}
   int a[10];              // expected-warning{{'a' is an unsafe buffer that does not perform bounds checks}}
 
   auto Lam = [p, a]() {
     return p[1]           // expected-note{{used in buffer access here}}
       + a[1] + garray[1]  // expected-note2{{used in buffer access here}}
       + gp[1];            // expected-note{{used in buffer access here}}
   };
 }
 
 typedef T_t * T_ptr_t;
 
 void testTypedefs(T_ptr_t p) {
   // expected-warning@-1{{'p' is an unsafe pointer used for buffer access}}
   foo(p[1],       // expected-note{{used in buffer access here}}
       p[1].a[1],  // expected-note{{used in buffer access here}}
-                  // expected-warning@-1{{unsafe buffer access}}
+                  // expected-warning@-1{{unsafe buffer access through raw pointer}}
       p[1].b[1]   // expected-note{{used in buffer access here}}
-                  // expected-warning@-1{{unsafe buffer access}}
+                  // expected-warning@-1{{unsafe buffer access through raw pointer}}
       );
 }
 
 template<typename T, int N> T f(T t, T * pt, T a[N], T (&b)[N]) {
   // expected-warning@-1{{'t' is an unsafe pointer used for buffer access}}
   // expected-warning@-2{{'pt' is an unsafe pointer used for buffer access}}
   // expected-warning@-3{{'a' is an unsafe pointer used for buffer access}}
   // expected-warning@-4{{'b' is an unsafe buffer that does not perform bounds checks}}

 template<typename T>
 void testPointerArithmetic(int * p, const int **q, T * x) {
 // expected-warning@-1{{'p' is an unsafe pointer used for buffer access}}
 // expected-warning@-2{{'x' is an unsafe pointer used for buffer access}}
   int a[10];
   auto y = &a[0]; // expected-warning{{'y' is an unsafe pointer used for buffer access}}
 
   foo(p + 1, 1 + p, p - 1,      // expected-note3{{used in pointer arithmetic here}}
-      *q + 1, 1 + *q, *q - 1,   // expected-warning3{{unsafe pointer arithmetic}}
+      *q + 1, 1 + *q, *q - 1,   // expected-warning3{{unsafe arithmetic on raw pointer}}
       x + 1, 1 + x, x - 1,      // expected-note3{{used in pointer arithmetic here}}
       y + 1, 1 + y, y - 1,      // expected-note3{{used in pointer arithmetic here}}
-      getPtr() + 1, 1 + getPtr(), getPtr() - 1 // expected-warning3{{unsafe pointer arithmetic}}
+      getPtr() + 1, 1 + getPtr(), getPtr() - 1 // expected-warning3{{unsafe arithmetic on raw pointer}}
       );
 
   p += 1;  p -= 1;  // expected-note2{{used in pointer arithmetic here}}
-  *q += 1; *q -= 1; // expected-warning2{{unsafe pointer arithmetic}}
+  *q += 1; *q -= 1; // expected-warning2{{unsafe arithmetic on raw pointer}}
   y += 1; y -= 1;   // expected-note2{{used in pointer arithmetic here}}
   x += 1; x -= 1;   // expected-note2{{used in pointer arithmetic here}}
 }
 
 void testTemplate(int * p) {
   int *a[10];
-  foo(f(p, &p, a, a)[1]); // expected-warning{{unsafe buffer access}}
+  foo(f(p, &p, a, a)[1]); // expected-warning{{unsafe buffer access through raw pointer}}
                           // expected-note@-1{{in instantiation of function template specialization 'f<int *, 10>' requested here}}
 
   const int **q = const_cast<const int **>(&p);
 
   testPointerArithmetic(p, q, p); //expected-note{{in instantiation of}}
 }
 
 void testPointerToMember() {
   struct S_t {
     int x;
     int * y;
   } S;
 
   int S_t::* p = &S_t::x;
   int * S_t::* q = &S_t::y;
 
   foo(S.*p,
-      (S.*q)[1]);  // expected-warning{{unsafe buffer access}}
+      (S.*q)[1]);  // expected-warning{{unsafe buffer access through raw pointer}}
 }
 
 // test that nested callable definitions are scanned only once
 void testNestedCallableDefinition(int * p) {
   class A {
     void inner(int * p) {
       // expected-warning@-1{{'p' is an unsafe pointer used for buffer access}}
       p++; // expected-note{{used in pointer arithmetic here}}

 
 int testArrayAccesses(int n) {
     // auto deduced array type
     int cArr[2][3] = {{1, 2, 3}, {4, 5, 6}};
     // expected-warning@-1{{'cArr' is an unsafe buffer that does not perform bounds checks}}
     int d = cArr[0][0];
     foo(cArr[0][0]);
     foo(cArr[1][2]);        // expected-note{{used in buffer access here}}
-                            // expected-warning@-1{{unsafe buffer access}}
+                            // expected-warning@-1{{unsafe buffer access through raw pointer}}
     auto cPtr = cArr[1][2]; // expected-note{{used in buffer access here}}
-                            // expected-warning@-1{{unsafe buffer access}}
+                            // expected-warning@-1{{unsafe buffer access through raw pointer}}
     foo(cPtr);
 
     // Typdefs
     typedef int A[3];
     const A tArr = {4, 5, 6};
     // expected-warning@-1{{'tArr' is an unsafe buffer that does not perform bounds checks}}
     foo(tArr[0], tArr[1]);  // expected-note{{used in buffer access here}}
-    return cArr[0][1];      // expected-warning{{unsafe buffer access}}
+    return cArr[0][1];      // expected-warning{{unsafe buffer access through raw pointer}}
 }
 
 void testArrayPtrArithmetic(int x[]) { // expected-warning{{'x' is an unsafe pointer used for buffer access}}
   foo (x + 3); // expected-note{{used in pointer arithmetic here}}
 
   int y[3] = {0, 1, 2}; // expected-warning{{'y' is an unsafe buffer that does not perform bounds checks}}
   foo(y + 4); // expected-note{{used in pointer arithmetic here}}
 }