* Tweak new diagnostic message

* Rename `attr-counted-by.c` -> `attr-counted-by-vla.c`
* Disallow `__counted_by` on VLA if element type is a struct with a VLA
  (addresses @hnrklssn 's feedback)

Author: delcypher

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -6537,14 +6537,16 @@ def err_counted_by_attr_refer_to_union : Error<
 def note_flexible_array_counted_by_attr_field : Note<
   "field %0 declared here">;
 def err_counted_by_attr_pointee_unknown_size : Error<
-  "'counted_by' cannot be applied a pointer with pointee with unknown size "
-  "because %0 is %select{"
+  "'counted_by' cannot be applied to %select{"
+    "a pointer with pointee|" // pointer
+    "an array with element}0" // array
+  " of unknown size because %1 is %select{"
     "an incomplete type|"  // CountedByInvalidPointeeTypeKind::INCOMPLETE
     "a sizeless type|"     // CountedByInvalidPointeeTypeKind::SIZELESS
     "a function type|"     // CountedByInvalidPointeeTypeKind::FUNCTION
     // CountedByInvalidPointeeTypeKind::FLEXIBLE_ARRAY_MEMBER
     "a struct type with a flexible array member"
-  "}1">;
+  "}2">;
 
 let CategoryName = "ARC Semantic Issue" in {
 

clang/lib/Sema/SemaDeclAttr.cpp

@@ -8626,26 +8626,37 @@ static bool CheckCountedByAttrOnField(
     return true;
   }
 
+  CountedByInvalidPointeeTypeKind InvalidTypeKind =
+      CountedByInvalidPointeeTypeKind::VALID;
+  QualType PointeeTy;
+  int SelectPtrOrArr = 0;
   if (FieldTy->isPointerType()) {
-    CountedByInvalidPointeeTypeKind InvalidTypeKind =
-        CountedByInvalidPointeeTypeKind::VALID;
-    const auto PointeeTy = FieldTy->getPointeeType();
-    if (PointeeTy->isIncompleteType()) {
-      InvalidTypeKind = CountedByInvalidPointeeTypeKind::INCOMPLETE;
-    } else if (PointeeTy->isSizelessType()) {
-      InvalidTypeKind = CountedByInvalidPointeeTypeKind::SIZELESS;
-    } else if (PointeeTy->isFunctionType()) {
-      InvalidTypeKind = CountedByInvalidPointeeTypeKind::FUNCTION;
-    } else if (PointeeTy->isStructureTypeWithFlexibleArrayMember()) {
-      InvalidTypeKind = CountedByInvalidPointeeTypeKind::FLEXIBLE_ARRAY_MEMBER;
-    }
-
-    if (InvalidTypeKind != CountedByInvalidPointeeTypeKind::VALID) {
-      S.Diag(FD->getBeginLoc(), diag::err_counted_by_attr_pointee_unknown_size)
-          << FieldTy->getPointeeType() << (int)InvalidTypeKind
-          << FD->getSourceRange();
-      return true;
-    }
+    PointeeTy = FieldTy->getPointeeType();
+    SelectPtrOrArr = 0;
+  } else {
+    assert(FieldTy->isArrayType());
+    const ArrayType *AT = S.getASTContext().getAsArrayType(FieldTy);
+    PointeeTy = AT->getElementType();
+    SelectPtrOrArr = 1;
+  }
+  // Note: The `Decl::isFlexibleArrayMemberLike` check earlier on means
+  // only `PointeeTy->isStructureTypeWithFlexibleArrayMember()` is reachable
+  // when `FieldTy->isArrayType()`.
+  if (PointeeTy->isIncompleteType()) {
+    InvalidTypeKind = CountedByInvalidPointeeTypeKind::INCOMPLETE;
+  } else if (PointeeTy->isSizelessType()) {
+    InvalidTypeKind = CountedByInvalidPointeeTypeKind::SIZELESS;
+  } else if (PointeeTy->isFunctionType()) {
+    InvalidTypeKind = CountedByInvalidPointeeTypeKind::FUNCTION;
+  } else if (PointeeTy->isStructureTypeWithFlexibleArrayMember()) {
+    InvalidTypeKind = CountedByInvalidPointeeTypeKind::FLEXIBLE_ARRAY_MEMBER;
+  }
+
+  if (InvalidTypeKind != CountedByInvalidPointeeTypeKind::VALID) {
+    S.Diag(FD->getBeginLoc(), diag::err_counted_by_attr_pointee_unknown_size)
+        << SelectPtrOrArr << PointeeTy << (int)InvalidTypeKind
+        << FD->getSourceRange();
+    return true;
   }
 
   // Check the expression

clang/test/Sema/attr-counted-by-late-parsed-struct-ptrs.c

@@ -17,17 +17,24 @@ struct on_member_pointer_complete_ty {
 };
 
 struct on_member_pointer_incomplete_ty {
-  struct size_unknown * buf __counted_by(count); // expected-error{{'counted_by' cannot be applied a pointer with pointee with unknown size because 'struct size_unknown' is an incomplete type}}
+  struct size_unknown * buf __counted_by(count); // expected-error{{'counted_by' cannot be applied to a pointer with pointee of unknown size because 'struct size_unknown' is an incomplete type}}
   int count;
 };
 
+struct on_member_pointer_const_incomplete_ty {
+  // expected-error@+1{{'counted_by' cannot be applied to a pointer with pointee of unknown size because 'const struct size_unknown' is an incomplete type}}
+  const struct size_unknown * buf __counted_by(count);
+  int count;
+};
+
+
 struct on_member_pointer_void_ty {
-  void* buf __counted_by(count); // expected-error{{'counted_by' cannot be applied a pointer with pointee with unknown size because 'void' is an incomplete type}}
+  void* buf __counted_by(count); // expected-error{{'counted_by' cannot be applied to a pointer with pointee of unknown size because 'void' is an incomplete type}}
   int count;
 };
 
 struct on_member_pointer_fn_ty {
-  // expected-error@+1{{'counted_by' cannot be applied a pointer with pointee with unknown size because 'void (void)' is a function type}}
+  // expected-error@+1{{'counted_by' cannot be applied to a pointer with pointee of unknown size because 'void (void)' is a function type}}
   void (*fn_ptr)(void) __counted_by(count);
   int count;
 };
@@ -38,7 +45,7 @@ struct has_unannotated_vla {
 };
 
 struct on_member_pointer_struct_with_vla {
-  // expected-error@+1{{'counted_by' cannot be applied a pointer with pointee with unknown size because 'struct has_unannotated_vla' is a struct type with a flexible array member}}
+  // expected-error@+1{{'counted_by' cannot be applied to a pointer with pointee of unknown size because 'struct has_unannotated_vla' is a struct type with a flexible array member}}
   struct has_unannotated_vla* objects __counted_by(count);
   int count;
 };
@@ -52,7 +59,7 @@ struct has_annotated_vla {
 // require an O(N) walk of `objects` to take into account the length of the VLA
 // in each struct instance.
 struct on_member_pointer_struct_with_annotated_vla {
-  // expected-error@+1{{'counted_by' cannot be applied a pointer with pointee with unknown size because 'struct has_annotated_vla' is a struct type with a flexible array member}}
+  // expected-error@+1{{'counted_by' cannot be applied to a pointer with pointee of unknown size because 'struct has_annotated_vla' is a struct type with a flexible array member}}
   struct has_annotated_vla* objects __counted_by(count);
   int count;
 };
@@ -94,6 +101,13 @@ struct on_member_pointer_incomplete_ty_ty_pos {
   int count;
 };
 
+struct on_member_pointer_const_incomplete_ty_ty_pos {
+  // TODO: Allow this
+  // expected-error@+1{{use of undeclared identifier 'count'}}
+  const struct size_unknown * __counted_by(count) buf;
+  int count;
+};
+
 struct on_member_pointer_void_ty_ty_pos {
   // TODO: This should fail because the attribute is
   // on a pointer with the pointee being an incomplete type.

clang/test/Sema/attr-counted-by-struct-ptrs-sizeless-types.c

@@ -5,7 +5,7 @@
 
 struct on_sizeless_pointee_ty {
     int count;
-    // expected-error@+1{{'counted_by' cannot be applied a pointer with pointee with unknown size because '__SVInt8_t' is a sizeless type}}
+    // expected-error@+1{{'counted_by' cannot be applied to a pointer with pointee of unknown size because '__SVInt8_t' is a sizeless type}}
     __SVInt8_t* member __counted_by(count);
 };
 

clang/test/Sema/attr-counted-by-struct-ptrs.c

@@ -18,17 +18,25 @@ struct on_member_pointer_complete_ty {
 
 struct on_member_pointer_incomplete_ty {
   int count;
-  struct size_unknown * buf __counted_by(count); // expected-error{{'counted_by' cannot be applied a pointer with pointee with unknown size because 'struct size_unknown' is an incomplete type}}
+  // expected-error@+1{{'counted_by' cannot be applied to a pointer with pointee of unknown size because 'struct size_unknown' is an incomplete type}}
+  struct size_unknown * buf __counted_by(count);
+};
+
+struct on_member_pointer_const_incomplete_ty {
+  int count;
+  // expected-error@+1{{'counted_by' cannot be applied to a pointer with pointee of unknown size because 'const struct size_unknown' is an incomplete type}}
+  const struct size_unknown * buf __counted_by(count);
 };
 
 struct on_member_pointer_void_ty {
   int count;
-  void* buf __counted_by(count); // expected-error{{'counted_by' cannot be applied a pointer with pointee with unknown size because 'void' is an incomplete type}}
+  // expected-error@+1{{'counted_by' cannot be applied to a pointer with pointee of unknown size because 'void' is an incomplete type}}
+  void* buf __counted_by(count);
 };
 
 struct on_member_pointer_fn_ty {
   int count;
-  // expected-error@+1{{'counted_by' cannot be applied a pointer with pointee with unknown size because 'void (void)' is a function type}}
+  // expected-error@+1{{'counted_by' cannot be applied to a pointer with pointee of unknown size because 'void (void)' is a function type}}
   void (*fn_ptr)(void) __counted_by(count);
 };
 
@@ -39,7 +47,7 @@ struct has_unannotated_vla {
 
 struct on_member_pointer_struct_with_vla {
   int count;
-  // expected-error@+1{{'counted_by' cannot be applied a pointer with pointee with unknown size because 'struct has_unannotated_vla' is a struct type with a flexible array member}}
+  // expected-error@+1{{'counted_by' cannot be applied to a pointer with pointee of unknown size because 'struct has_unannotated_vla' is a struct type with a flexible array member}}
   struct has_unannotated_vla* objects __counted_by(count);
 };
 
@@ -53,7 +61,7 @@ struct has_annotated_vla {
 // in each struct instance.
 struct on_member_pointer_struct_with_annotated_vla {
   int count;
-  // expected-error@+1{{'counted_by' cannot be applied a pointer with pointee with unknown size because 'struct has_annotated_vla' is a struct type with a flexible array member}}
+  // expected-error@+1{{'counted_by' cannot be applied to a pointer with pointee of unknown size because 'struct has_annotated_vla' is a struct type with a flexible array member}}
   struct has_annotated_vla* objects __counted_by(count);
 };
 
@@ -79,22 +87,30 @@ struct on_pointer_anon_count {
 
 struct on_member_pointer_complete_ty_ty_pos {
   int count;
-  struct size_known *__counted_by(count) buf ;
+  struct size_known *__counted_by(count) buf;
 };
 
 struct on_member_pointer_incomplete_ty_ty_pos {
   int count;
-  struct size_unknown * __counted_by(count) buf; // expected-error{{'counted_by' cannot be applied a pointer with pointee with unknown size because 'struct size_unknown' is an incomplete type}}
+  // expected-error@+1{{'counted_by' cannot be applied to a pointer with pointee of unknown size because 'struct size_unknown' is an incomplete type}}
+  struct size_unknown * __counted_by(count) buf;
+};
+
+struct on_member_pointer_const_incomplete_ty_ty_pos {
+  int count;
+  // expected-error@+1{{'counted_by' cannot be applied to a pointer with pointee of unknown size because 'const struct size_unknown' is an incomplete type}}
+  const struct size_unknown * __counted_by(count) buf;
 };
 
 struct on_member_pointer_void_ty_ty_pos {
   int count;
-  void *__counted_by(count) buf; // expected-error{{'counted_by' cannot be applied a pointer with pointee with unknown size because 'void' is an incomplete type}}
+  // expected-error@+1{{'counted_by' cannot be applied to a pointer with pointee of unknown size because 'void' is an incomplete type}}
+  void *__counted_by(count) buf;
 };
 
 struct on_member_pointer_fn_ty_ty_pos {
   int count;
-  // expected-error@+1{{'counted_by' cannot be applied a pointer with pointee with unknown size because 'void (void)' is a function type}}
+  // expected-error@+1{{'counted_by' cannot be applied to a pointer with pointee of unknown size because 'void (void)' is a function type}}
   void (* __counted_by(count) fn_ptr)(void);
 };
 
@@ -113,7 +129,7 @@ struct on_member_pointer_fn_ptr_ty_ty_pos_inner {
 
 struct on_member_pointer_struct_with_vla_ty_pos {
   int count;
-  // expected-error@+1{{'counted_by' cannot be applied a pointer with pointee with unknown size because 'struct has_unannotated_vla' is a struct type with a flexible array member}}
+  // expected-error@+1{{'counted_by' cannot be applied to a pointer with pointee of unknown size because 'struct has_unannotated_vla' is a struct type with a flexible array member}}
   struct has_unannotated_vla *__counted_by(count) objects;
 };
 
@@ -122,7 +138,7 @@ struct on_member_pointer_struct_with_vla_ty_pos {
 // in each struct instance.
 struct on_member_pointer_struct_with_annotated_vla_ty_pos {
   int count;
-  // expected-error@+1{{'counted_by' cannot be applied a pointer with pointee with unknown size because 'struct has_annotated_vla' is a struct type with a flexible array member}}
+  // expected-error@+1{{counted_by' cannot be applied to a pointer with pointee of unknown size because 'struct has_annotated_vla' is a struct type with a flexible array member}}
   struct has_annotated_vla* __counted_by(count) objects;
 };
 

clang/test/Sema/attr-counted-by-vla-sizeless-types.c

@@ -0,0 +1,11 @@
+// __SVInt8_t is specific to ARM64 so specify that in the target triple
+// RUN: %clang_cc1 -triple arm64-apple-darwin -fsyntax-only -verify %s
+
+#define __counted_by(f)  __attribute__((counted_by(f)))
+
+struct on_sizeless_elt_ty {
+    int count;
+    // expected-error@+2{{'counted_by' only applies to pointers or C99 flexible array members}}
+    // expected-error@+1{{array has sizeless element type '__SVInt8_t'}}
+    __SVInt8_t arr[] __counted_by(count);
+};

clang/test/Sema/attr-counted-by.c renamed to clang/test/Sema/attr-counted-by-vla.c

@@ -95,7 +95,7 @@ struct array_of_ints_count {
 
 struct not_a_fam {
   int count;
-  // expected-error@+1{{'counted_by' cannot be applied a pointer with pointee with unknown size because 'struct bar' is an incomplete type}}
+  // expected-error@+1{{'counted_by' cannot be applied to a pointer with pointee of unknown size because 'struct bar' is an incomplete type}}
   struct bar *non_fam __counted_by(count);
 };
 
@@ -111,3 +111,77 @@ struct annotated_with_anon_struct {
     int array[] __counted_by(crount); // expected-error {{use of undeclared identifier 'crount'}}
   };
 };
+
+//==============================================================================
+// __counted_by on a struct VLA with element type that has unknown size
+//==============================================================================
+
+struct size_unknown; // expected-note 2{{forward declaration of 'struct size_unknown'}}
+struct on_member_arr_incomplete_ty_ty_pos {
+  int count;
+  // expected-error@+2{{'counted_by' only applies to pointers or C99 flexible array members}}
+  // expected-error@+1{{array has incomplete element type 'struct size_unknown'}}
+  struct size_unknown buf[] __counted_by(count);
+};
+
+struct on_member_arr_incomplete_const_ty_ty_pos {
+  int count;
+  // expected-error@+2{{'counted_by' only applies to pointers or C99 flexible array members}}
+  // expected-error@+1{{array has incomplete element type 'const struct size_unknown'}}
+  const struct size_unknown buf[] __counted_by(count);
+};
+
+struct on_member_arr_void_ty_ty_pos {
+  int count;
+  // expected-error@+2{{'counted_by' only applies to pointers or C99 flexible array members}}
+  // expected-error@+1{{array has incomplete element type 'void'}}
+  void buf[] __counted_by(count);
+};
+
+typedef void(fn_ty)(int);
+
+struct on_member_arr_fn_ty {
+  int count;
+  // expected-error@+2{{'counted_by' only applies to pointers or C99 flexible array members}}
+  // expected-error@+1{{'buf' declared as array of functions of type 'fn_ty' (aka 'void (int)')}}
+  fn_ty buf[] __counted_by(count);
+};
+
+
+
+// `buffer_of_structs_with_unnannotated_vla`,
+// `buffer_of_structs_with_annotated_vla`, and
+// `buffer_of_const_structs_with_annotated_vla` are currently prevented because
+// computing the size of `Arr` at runtime would require an O(N) walk of `Arr`
+// elements to take into account the length of the VLA in each struct instance.
+
+struct has_unannotated_VLA {
+  int count;
+  char buffer[];
+};
+
+struct has_annotated_VLA {
+  int count;
+  char buffer[] __counted_by(count);
+};
+
+struct buffer_of_structs_with_unnannotated_vla {
+  int count;
+  // expected-error@+1{{'counted_by' cannot be applied to an array with element of unknown size because 'struct has_unannotated_VLA' is a struct type with a flexible array member}}
+  struct has_unannotated_VLA Arr[] __counted_by(count);
+};
+
+
+struct buffer_of_structs_with_annotated_vla {
+  int count;
+  // expected-error@+1{{'counted_by' cannot be applied to an array with element of unknown size because 'struct has_annotated_VLA' is a struct type with a flexible array member}}
+  struct has_annotated_VLA Arr[] __counted_by(count);
+};
+
+struct buffer_of_const_structs_with_annotated_vla {
+  int count;
+  // Make sure the `const` qualifier is printed when printing the element type.
+  // expected-error@+1{{'counted_by' cannot be applied to an array with element of unknown size because 'const struct has_annotated_VLA' is a struct type with a flexible array member}}
+  const struct has_annotated_VLA Arr[] __counted_by(count);
+};
+