Merge pull request #76403 from tshortli/availability-attr-diags

Sema: Reject unavailable associated types and observing accessors

Author: tshortli

include/swift/AST/DiagnosticsSema.def

@@ -6757,12 +6757,13 @@ WARNING(availability_query_useless_enclosing_scope, none,
 NOTE(availability_query_useless_enclosing_scope_here, none,
      "enclosing scope here", ())
 
-ERROR(availability_deinit_no_potential, none,
-      "deinitializer cannot be marked potentially unavailable with "
-      "'@available'", ())
+ERROR(availability_decl_no_potential, none,
+      "%kindonly0 cannot be marked potentially unavailable with '@available'",
+      (const Decl *))
 
-ERROR(availability_deinit_no_unavailable, none,
-      "deinitializer cannot be marked unavailable with '@available'", ())
+ERROR(availability_decl_no_unavailable, none,
+      "%kindonly0 cannot be marked unavailable with '@available'",
+      (const Decl *))
 
 ERROR(availability_global_script_no_potential,
       none, "global variable cannot be marked potentially "

lib/IDE/SyntaxModel.cpp

@@ -358,21 +358,6 @@ class ModelASTWalker : public ASTWalker {
   /// is considered as one, e.g. object literal expression.
   uint8_t AvoidPassingSyntaxToken = 0;
 
-  class InactiveClauseRAII {
-    const bool wasInInactiveClause;
-    bool &isInInactiveClause;
-
-  public:
-    InactiveClauseRAII(bool &isInInactiveClauseArg, bool enteringInactiveClause)
-        : wasInInactiveClause(isInInactiveClauseArg),
-          isInInactiveClause(isInInactiveClauseArg) {
-      isInInactiveClause |= enteringInactiveClause;
-    }
-    ~InactiveClauseRAII() { isInInactiveClause = wasInInactiveClause; }
-  };
-  friend class InactiveClauseRAII;
-  bool inInactiveClause = false;
-
 public:
   SyntaxModelWalker &Walker;
   ArrayRef<SyntaxNode> TokenNodes;

lib/Sema/TypeCheckAttr.cpp

@@ -2220,7 +2220,7 @@ void AttributeChecker::visitAvailableAttr(AvailableAttr *attr) {
     }
   }
 
-  std::optional<Diag<>> MaybeNotAllowed =
+  std::optional<Diagnostic> MaybeNotAllowed =
       TypeChecker::diagnosticIfDeclCannotBePotentiallyUnavailable(D);
   if (MaybeNotAllowed.has_value()) {
     AvailabilityContext DeploymentRange
@@ -4924,13 +4924,19 @@ Type TypeChecker::checkReferenceOwnershipAttr(VarDecl *var, Type type,
   return ReferenceStorageType::get(type, ownershipKind, var->getASTContext());
 }
 
-std::optional<Diag<>>
+std::optional<Diagnostic>
 TypeChecker::diagnosticIfDeclCannotBePotentiallyUnavailable(const Decl *D) {
   auto *DC = D->getDeclContext();
 
   // A destructor is always called if declared.
   if (auto *DD = dyn_cast<DestructorDecl>(D))
-    return diag::availability_deinit_no_potential;
+    return Diagnostic(diag::availability_decl_no_potential, D);
+
+  // Observing accessors are always called implicitly.
+  if (auto *AD = dyn_cast<AccessorDecl>(D)) {
+    if (AD->isObservingAccessor())
+      return Diagnostic(diag::availability_decl_no_potential, D);
+  }
 
   if (auto *VD = dyn_cast<VarDecl>(D)) {
     if (!VD->hasStorageOrWrapsStorage())
@@ -4964,7 +4970,7 @@ TypeChecker::diagnosticIfDeclCannotBePotentiallyUnavailable(const Decl *D) {
   return std::nullopt;
 }
 
-std::optional<Diag<>>
+std::optional<Diagnostic>
 TypeChecker::diagnosticIfDeclCannotBeUnavailable(const Decl *D) {
   auto parentIsUnavailable = [](const Decl *D) -> bool {
     if (auto *parent =
@@ -4979,7 +4985,18 @@ TypeChecker::diagnosticIfDeclCannotBeUnavailable(const Decl *D) {
     if (parentIsUnavailable(D))
       return std::nullopt;
 
-    return diag::availability_deinit_no_unavailable;
+    return Diagnostic(diag::availability_decl_no_unavailable, D);
+  }
+
+  // The conformance checker does not know what to do with unavailable
+  // associated types.
+  if (auto *AT = dyn_cast<AssociatedTypeDecl>(D))
+    return Diagnostic(diag::availability_decl_no_unavailable, D);
+
+  // Observing accessors are always called implicitly.
+  if (auto *AD = dyn_cast<AccessorDecl>(D)) {
+    if (AD->isObservingAccessor())
+      return Diagnostic(diag::availability_decl_no_unavailable, D);
   }
 
   if (auto *VD = dyn_cast<VarDecl>(D)) {

lib/Sema/TypeChecker.h

@@ -1020,13 +1020,13 @@ TypeRefinementContext *getOrBuildTypeRefinementContext(SourceFile *SF);
 /// Returns a diagnostic indicating why the declaration cannot be annotated
 /// with an @available() attribute indicating it is potentially unavailable
 /// or None if this is allowed.
-std::optional<Diag<>>
+std::optional<Diagnostic>
 diagnosticIfDeclCannotBePotentiallyUnavailable(const Decl *D);
 
 /// Returns a diagnostic indicating why the declaration cannot be annotated
 /// with an @available() attribute indicating it is unavailable or None if this
 /// is allowed.
-std::optional<Diag<>> diagnosticIfDeclCannotBeUnavailable(const Decl *D);
+std::optional<Diagnostic> diagnosticIfDeclCannotBeUnavailable(const Decl *D);
 
 /// Same as \c checkDeclarationAvailability but doesn't give a reason for
 /// unavailability.

test/Sema/availability_accessors.swift

@@ -98,7 +98,6 @@ struct SubscriptHelper {
     @available(*, unavailable)
     set { } // expected-note {{setter for 'subscript(unavailableGetterAndSetter:)' has been explicitly marked unavailable here}}
   }
-
 }
 
 @discardableResult func takesInOut<T>(_ t: inout T) -> T {
@@ -553,3 +552,22 @@ struct TestPatternBindingInitExprs {
   var unavailableGetterAndSetter_0 = global.unavailableGetterAndSetter[0] // expected-error {{getter for 'unavailableGetterAndSetter' is unavailable}}
   var unavailableGetterAndSetter_0_b = global.unavailableGetterAndSetter[0].b // expected-error {{getter for 'unavailableGetterAndSetter' is unavailable}}
 }
+
+struct BadAccessorAvailability<T> {
+  var alwaysUnavailableObservers: T  {
+    @available(*, unavailable) // expected-error {{willSet observer for property cannot be marked unavailable with '@available'}}
+    willSet { }
+
+    @available(*, unavailable) // expected-error {{didSet observer for property cannot be marked unavailable with '@available'}}
+    didSet { }
+  }
+
+  var observersUnavailableBeforeSwift99: T  {
+    @available(swift, introduced: 99) // expected-error {{willSet observer for property cannot be marked unavailable with '@available'}}
+    willSet { }
+
+    @available(swift, introduced: 99) // expected-error {{didSet observer for property cannot be marked unavailable with '@available'}}
+    didSet { }
+  }
+
+}

test/Sema/availability_versions.swift

@@ -1801,3 +1801,21 @@ class StoredPropertiesWithAvailabilityInClosures {
     return 0
   }()
 }
+
+struct PropertyObservers {
+  var hasPotentiallyUnavailableObservers: Int {
+    @available(macOS 51, *) // expected-error {{willSet observer for property cannot be marked potentially unavailable with '@available'}}
+    willSet { }
+
+    @available(macOS 51, *) // expected-error {{didSet observer for property cannot be marked potentially unavailable with '@available'}}
+    didSet { }
+  }
+
+  var hasObsoletedObservers: Int {
+    @available(macOS, obsoleted: 10.9) // expected-error {{willSet observer for property cannot be marked unavailable with '@available'}}
+    willSet { }
+
+    @available(macOS, obsoleted: 10.9) // expected-error {{didSet observer for property cannot be marked unavailable with '@available'}}
+    didSet { }
+  }
+}

test/attr/attr_availability_unavailability.swift renamed to test/attr/attr_availability_unavailable_query.swift

@@ -84,3 +84,11 @@ extension ModelP2 {
   // expected-error@-1{{'B' is only available in macOS 14 or newer}}
   // expected-note@-2{{add @available attribute to enclosing instance method}}
 }
+
+protocol P3 {
+  @available(macOS, obsoleted: 12) // expected-error{{associated type cannot be marked unavailable with '@available'}}
+  associatedtype A1
+
+  @available(macOS, obsoleted: 99) // FIXME: this should probably be diagnosed
+  associatedtype A2
+}

test/decl/protocol/associated_type_availability.swift

@@ -91,3 +91,11 @@ struct SelfT: Unavail { // expected-error {{type 'SelfT' does not conform to pro
   // expected-error@-1 {{unavailable instance method 'req()' was used to satisfy a requirement of protocol 'Unavail': write it yourself}}
   typealias T = SelfT
 }
+
+protocol UnavailableAssoc {
+  @available(*, unavailable) // expected-error {{associated type cannot be marked unavailable with '@available'}}
+  associatedtype A1
+
+  @available(swift, introduced: 99) // expected-error {{associated type cannot be marked unavailable with '@available'}}
+  associatedtype A2
+}