fixup: support different span struct field orderings

Do not demand that the pointer should be the first field and the integer
type the second field.

Author: a-nogikh

clang/include/clang/Basic/AttrDocs.td

@@ -5256,9 +5256,9 @@ like a system memory allocation function and returns a span-like structure,
 where the returned memory range does not alias storage from any other object
 accessible to the caller.
 
-In this context, a span-like structure is assumed to have a pointer to the
-allocated memory as its first field and any integer type containing the size
-of the actually allocated memory as the second field.
+In this context, a span-like structure is assumed to have two fields, one of
+which is a pointer to the allocated memory and another one is an integer type
+containing the size of the actually allocated memory.
   }];
 }
 

clang/lib/Sema/SemaDeclAttr.cpp

@@ -1840,8 +1840,8 @@ static void handleRestrictAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
 }
 
 static bool isSpanLikeType(const QualType &Ty) {
-  // Check that the type is a plain record with the first field being a pointer
-  // type and the second field being an integer. This matches the common
+  // Check that the type is a plain record with one field being a pointer
+  // type and the other field being an integer. This matches the common
   // implementation of std::span or sized_allocation_t in P0901R11.
   // Note that there may also be numerous cases of pointer+integer structures
   // not actually exhibiting a span-like semantics, so sometimes
@@ -1855,10 +1855,13 @@ static bool isSpanLikeType(const QualType &Ty) {
   auto FieldsBegin = Def->field_begin();
   if (std::distance(FieldsBegin, Def->field_end()) != 2)
     return false;
-  const FieldDecl *FirstField = *FieldsBegin;
-  const FieldDecl *SecondField = *std::next(FieldsBegin);
-  return FirstField->getType()->isAnyPointerType() &&
-         SecondField->getType()->isIntegerType();
+  const QualType FirstFieldType = FieldsBegin->getType();
+  const QualType SecondFieldType = std::next(FieldsBegin)->getType();
+  // Verify two possible orderings.
+  return (FirstFieldType->isAnyPointerType() &&
+          SecondFieldType->isIntegerType()) ||
+         (FirstFieldType->isIntegerType() &&
+          SecondFieldType->isAnyPointerType());
 }
 
 static void handleMallocSpanAttr(Sema &S, Decl *D, const ParsedAttr &AL) {

clang/test/Sema/attr-malloc_span.c

@@ -6,26 +6,26 @@
 typedef struct {
   void *ptr;
   size_t n;
-} sized_ptr;
-sized_ptr  returns_sized_ptr  (void) __attribute((malloc_span)); // no-warning
+} span;
+span  returns_span  (void) __attribute((malloc_span)); // no-warning
 
-// The first struct field must be pointer and the second must be an integer.
-// Check the possible ways to violate it.
+// Try out a different field ordering.
 typedef struct {
   size_t n;
   void *ptr;
-} invalid_span1;
-invalid_span1  returns_non_std_span1  (void) __attribute((malloc_span)); // expected-warning {{attribute only applies to return values that are span-like structures}}
+} span2;
+span2  returns_span2  (void) __attribute((malloc_span)); // no-warning
 
+// Ensure that a warning is produced on malloc_span precondition violation.
 typedef struct {
   void *ptr;
   void *ptr2;
-} invalid_span2;
-invalid_span2  returns_non_std_span2  (void) __attribute((malloc_span)); // expected-warning {{attribute only applies to return values that are span-like structures}}
+} invalid_span1;
+invalid_span1  returns_non_std_span1  (void) __attribute((malloc_span)); // expected-warning {{attribute only applies to return values that are span-like structures}}
 
 typedef struct {
   void *ptr;
   size_t n;
   size_t n2;
-} invalid_span3;
-invalid_span3  returns_non_std_span3  (void) __attribute((malloc_span)); // expected-warning {{attribute only applies to return values that are span-like structures}}
+} invalid_span2;
+invalid_span2  returns_non_std_span2  (void) __attribute((malloc_span)); // expected-warning {{attribute only applies to return values that are span-like structures}}