Parse/Sema: Fix diagnostics for missing wildcards in @available.

The previous algorithm failed to correctly handle the cases where some grouped
`@available` attributes could be marked invalid prior to type checking
attributes.

Author: tshortli

include/swift/AST/Attr.h

@@ -165,14 +165,20 @@ class DeclAttribute : public AttributeBase {
       /// Whether this attribute was spelled `@_spi_available`.
       IsSPI : 1,
 
-      /// Whether this attribute belongs to a chain of adjacent `@available` attributes that were generated from a single attribute written in source using short form syntax e.g. (`@available(macOS 15, iOS 18, *)`).
+      /// Whether this attribute belongs to a chain of adjacent `@available`
+      /// attributes that were generated from a single attribute written in
+      /// source using short form syntax, e.g.
+      ///
+      ///     @available(macOS 15, iOS 18, *)
+      ///
       IsGroupMember : 1,
 
       /// Whether this attribute is the final one in its group.
       IsGroupTerminator : 1,
 
-      /// Whether this attribute's specification was followed by `, *` in source.
-      IsAdjacentToWildcard : 1
+      /// Whether any members of the group were written as a wildcard
+      /// specification (`*`) in source.
+      IsGroupedWithWildcard : 1
     );
 
     SWIFT_INLINE_BITFIELD(ClangImporterSynthesizedTypeAttr, DeclAttribute, 1,
@@ -848,12 +854,13 @@ class AvailableAttr : public DeclAttribute {
   }
   void setIsGroupTerminator() { Bits.AvailableAttr.IsGroupTerminator = true; }
 
-  /// Whether this attribute's specification was followed by `, *` in source.
-  bool isAdjacentToWildcard() const {
-    return Bits.AvailableAttr.IsAdjacentToWildcard;
+  /// Whether any members of the group were written as a wildcard specification
+  /// (`*`) in source.
+  bool isGroupedWithWildcard() const {
+    return Bits.AvailableAttr.IsGroupedWithWildcard;
   }
-  void setIsAdjacentToWildcard() {
-    Bits.AvailableAttr.IsAdjacentToWildcard = true;
+  void setIsGroupedWithWildcard() {
+    Bits.AvailableAttr.IsGroupedWithWildcard = true;
   }
 
   /// Returns the kind of availability the attribute specifies.

lib/AST/Attr.cpp

@@ -2146,7 +2146,7 @@ AvailableAttr::AvailableAttr(
   Bits.AvailableAttr.IsSPI = IsSPI;
   Bits.AvailableAttr.IsGroupMember = false;
   Bits.AvailableAttr.IsGroupTerminator = false;
-  Bits.AvailableAttr.IsAdjacentToWildcard = false;
+  Bits.AvailableAttr.IsGroupedWithWildcard = false;
 }
 
 AvailableAttr *AvailableAttr::createUniversallyUnavailable(ASTContext &C,

lib/Parse/ParseDecl.cpp

@@ -790,13 +790,13 @@ bool Parser::parseAvailability(
     // we will synthesize
     //   @available(_PackageDescription, introduced: 4.2)
 
+    bool groupContainsWildcard = llvm::any_of(
+        Specs, [](AvailabilitySpec *Spec) { return Spec->isWildcard(); });
+
     AvailableAttr *PrevAttr = nullptr;
     for (auto *Spec : Specs) {
-      if (Spec->isWildcard()) {
-        if (PrevAttr)
-          PrevAttr->setIsAdjacentToWildcard();
+      if (Spec->isWildcard())
         continue;
-      }
 
       std::optional<AvailabilityDomain> Domain = Spec->getDomain();
       if (!Domain)
@@ -817,6 +817,8 @@ bool Parser::parseAvailability(
       addAttribute(Attr);
 
       Attr->setIsGroupMember();
+      if (groupContainsWildcard)
+        Attr->setIsGroupedWithWildcard();
       if (!PrevAttr)
         Attr->setIsGroupTerminator();
 

lib/Sema/TypeCheckAttr.cpp

@@ -4936,24 +4936,29 @@ void AttributeChecker::checkOriginalDefinedInAttrs(
 /// Find each of the `AvailableAttr`s that represents the first attribute in a
 /// group of attributes what were parsed from a short-form available attribute,
 /// e.g. `@available(macOS , iOS, *)`.
-static llvm::SmallSet<const AvailableAttr *, 8>
-getAvailableAttrGroups(ArrayRef<AvailableAttr *> attrs) {
-  llvm::SmallSet<const AvailableAttr *, 8> heads;
+static llvm::SmallVector<const AvailableAttr *, 4>
+getAvailableAttrGroups(ArrayRef<const AvailableAttr *> attrs) {
+  llvm::SmallSet<const AvailableAttr *, 8> seen;
 
-  // Find each attribute that belongs to a group.
+  // Collect the of the grouped attributes that are reachable starting from any
+  // other attribute.
   for (auto attr : attrs) {
-    if (attr->isGroupMember())
-      heads.insert(attr);
+    auto next = attr;
+    while ((next = next->getNextGroupedAvailableAttr())) {
+      if (!seen.insert(next).second)
+        break;
+    }
   }
 
-  // Remove the interior attributes of each group, leaving only the head.
+  // The grouped attributes that are _not_ reachable from any other attribute
+  // are the results.
+  llvm::SmallVector<const AvailableAttr *, 4> results;
   for (auto attr : attrs) {
-    if (auto next = attr->getNextGroupedAvailableAttr()) {
-      heads.erase(next);
-    }
+    if (attr->isGroupMember() && !seen.contains(attr))
+      results.push_back(attr);
   }
 
-  return heads;
+  return results;
 }
 
 void AttributeChecker::checkAvailableAttrs(ArrayRef<AvailableAttr *> attrs) {
@@ -4982,7 +4987,7 @@ void AttributeChecker::checkAvailableAttrs(ArrayRef<AvailableAttr *> attrs) {
       groupAttrCount++;
       auto loc = groupedAttr->getLocation();
       groupEndLoc = groupedAttr->getEndLoc();
-      if (groupedAttr->isAdjacentToWildcard())
+      if (groupedAttr->isGroupedWithWildcard())
         foundWildcard = true;
 
       auto attr = D->getSemanticAvailableAttr(groupedAttr);
@@ -4997,8 +5002,8 @@ void AttributeChecker::checkAvailableAttrs(ArrayRef<AvailableAttr *> attrs) {
       if (domain.isPlatform())
         requiresWildcard = true;
 
-      if (groupAttrCount > 1 || groupedAttr->isAdjacentToWildcard() ||
-          !groupedAttr->isGroupTerminator()) {
+      if (groupAttrCount > 1 || !groupedAttr->isGroupTerminator() ||
+          foundWildcard) {
         // Only platform availability is allowed to be written groups with more
         // than one member.
         if (!domain.isPlatform()) {