Sema: Consolidate diagnostics for decls that cannot be unavailable.

Author: tshortli

lib/Sema/TypeCheckAttr.cpp

@@ -5097,23 +5097,10 @@ void AttributeChecker::checkAvailableAttrs(ArrayRef<AvailableAttr *> attrs) {
   if (availabilityConstraint->isUnavailable()) {
     auto attr = availabilityConstraint->getAttr();
     if (auto diag = TypeChecker::diagnosticIfDeclCannotBeUnavailable(D)) {
-      diagnose(attr.getParsedAttr()->getLocation(), diag.value());
+      diagnoseAndRemoveAttr(const_cast<AvailableAttr *>(attr.getParsedAttr()),
+                            diag.value());
       return;
     }
-
-    if (auto *PD = dyn_cast<ProtocolDecl>(D->getDeclContext())) {
-      if (auto *VD = dyn_cast<ValueDecl>(D)) {
-        if (VD->isProtocolRequirement() && !PD->isObjC()) {
-          diagnoseAndRemoveAttr(
-              const_cast<AvailableAttr *>(attr.getParsedAttr()),
-              diag::unavailable_method_non_objc_protocol)
-              .warnInSwiftInterface(D->getDeclContext());
-          // Be lenient in interfaces to accomodate @_spi_available, which has
-          // been accepted historically.
-          return;
-        }
-      }
-    }
   }
 
   // If the decl is potentially unavailable relative to its parent and it's
@@ -5484,6 +5471,21 @@ TypeChecker::diagnosticIfDeclCannotBeUnavailable(const Decl *D) {
       return Diagnostic(diag::availability_decl_no_unavailable, D);
   }
 
+  auto DC = D->getDeclContext();
+  if (auto *PD = dyn_cast<ProtocolDecl>(DC)) {
+    if (auto *VD = dyn_cast<ValueDecl>(D)) {
+      if (VD->isProtocolRequirement() && !PD->isObjC()) {
+        auto diag = Diagnostic(diag::unavailable_method_non_objc_protocol);
+
+        // Be lenient in interfaces to accomodate @_spi_available, which has
+        // been accepted historically.
+        if (DC->isInSwiftinterface())
+          diag.setBehaviorLimit(DiagnosticBehavior::Warning);
+        return diag;
+      }
+    }
+  }
+
   if (auto *VD = dyn_cast<VarDecl>(D)) {
     if (!VD->hasStorageOrWrapsStorage())
       return std::nullopt;

test/Sema/availability_script_mode.swift

@@ -11,10 +11,10 @@ struct Available50 {}
 struct Available51 {}
 
 @available(macOS, unavailable)
-struct UnavailableOnMacOS {}
+struct UnavailableOnMacOS {} // expected-note {{'UnavailableOnMacOS' has been explicitly marked unavailable here}}
 
 @available(*, unavailable)
-struct UnavailableUnconditionally {}
+struct UnavailableUnconditionally {} // expected-note {{'UnavailableUnconditionally' has been explicitly marked unavailable here}}
 
 var alwaysAvailableVar: AlwaysAvailable = .init() // Ok
 
@@ -28,7 +28,7 @@ var availableOn50Var: Available50 = .init() // Ok
 var potentiallyUnavailableVar: Available51 = .init()
 
 @available(macOS, unavailable) // expected-error {{global variable cannot be marked unavailable with '@available' in script mode}}
-var unavailableOnMacOSVar: UnavailableOnMacOS = .init()
+var unavailableOnMacOSVar: UnavailableOnMacOS = .init() // expected-error {{'UnavailableOnMacOS' is unavailable in macOS}}
 
 @available(*, unavailable) // expected-error {{global variable cannot be marked unavailable with '@available' in script mode}}
-var unconditionallyUnavailableVar: UnavailableUnconditionally = .init()
+var unconditionallyUnavailableVar: UnavailableUnconditionally = .init() // expected-error {{'UnavailableUnconditionally' is unavailable}}

test/Sema/availability_stored_unavailable.swift

@@ -3,10 +3,10 @@
 // REQUIRES: OS=macosx
 
 @available(macOS, unavailable)
-struct UnavailableMacOSStruct {}
+struct UnavailableMacOSStruct {} // expected-note 2 {{'UnavailableMacOSStruct' has been explicitly marked unavailable here}}
 
 @available(*, unavailable)
-public struct UniversallyUnavailableStruct {}
+public struct UniversallyUnavailableStruct {} // expected-note {{'UniversallyUnavailableStruct' has been explicitly marked unavailable here}}
 
 // Ok, initialization of globals is lazy and boxed.
 @available(macOS, unavailable)
@@ -61,15 +61,15 @@ struct GoodUniversallyUnavailableStruct {
 struct BadStruct {
   // expected-error@+1 {{stored properties cannot be marked unavailable with '@available'}}
   @available(macOS, unavailable)
-  var unavailableMacOS: UnavailableMacOSStruct = .init()
+  var unavailableMacOS: UnavailableMacOSStruct = .init() // expected-error {{'UnavailableMacOSStruct' is unavailable in macOS}}
 
   // expected-error@+1 {{stored properties cannot be marked unavailable with '@available'}}
   @available(macOS, unavailable)
-  lazy var lazyUnavailableMacOS: UnavailableMacOSStruct = .init()
+  lazy var lazyUnavailableMacOS: UnavailableMacOSStruct = .init() // expected-error {{'UnavailableMacOSStruct' is unavailable in macOS}}
 
   // expected-error@+1 {{stored properties cannot be marked unavailable with '@available'}}
   @available(*, unavailable)
-  var universallyUnavailable: UniversallyUnavailableStruct = .init()
+  var universallyUnavailable: UniversallyUnavailableStruct = .init() // expected-error {{'UniversallyUnavailableStruct' is unavailable}}
 }
 
 enum GoodAvailableEnum {