[Sema] Report non-constructor unavailable overrides as warnings

Report unavailable overrides as a warning to avoid breaking sources.

Author: xymus

include/swift/AST/DiagnosticsSema.def

@@ -2455,10 +2455,16 @@ NOTE(suggest_removing_override, none,
 ERROR(override_less_available,none,
       "overriding %0 must be as available as declaration it overrides",
       (DeclBaseName))
+WARNING(override_less_available_warn,none,
+        "overriding %0 must be as available as declaration it overrides",
+        (DeclBaseName))
 
 ERROR(override_accessor_less_available,none,
       "overriding %0 for %1 must be as available as declaration it overrides",
       (DescriptiveDeclKind, DeclBaseName))
+WARNING(override_accessor_less_available_warn,none,
+        "overriding %0 for %1 must be as available as declaration it overrides",
+        (DescriptiveDeclKind, DeclBaseName))
 
 ERROR(override_let_property,none,
       "cannot override immutable 'let' property %0 with the getter of a 'var'",

lib/Sema/TypeCheckDeclOverride.cpp

@@ -1690,23 +1690,34 @@ static bool diagnoseOverrideForAvailability(ValueDecl *override,
   auto &ctx = override->getASTContext();
   auto &diags = ctx.Diags;
   if (auto *accessor = dyn_cast<AccessorDecl>(override)) {
-    diags.diagnose(override, diag::override_accessor_less_available,
+    bool downgradeToWarning = override->getAttrs().isUnavailable(ctx);
+    diags.diagnose(override,
+                   downgradeToWarning?
+                     diag::override_accessor_less_available_warn :
+                     diag::override_accessor_less_available,
                    accessor->getDescriptiveKind(),
                    accessor->getStorage()->getBaseName());
     diags.diagnose(base, diag::overridden_here);
     return true;
   }
 
-  // Don't report constructors that are marked unavailable as being less
-  // available than their introduction. This was previously allowed and
-  // can be used to forbid the direct use of a constructor in a subclass.
-  // Note that even when marked unavailable the constructor could be called
-  // by other inherited constructors.
-  if (isa<ConstructorDecl>(override) &&
-      override->getAttrs().isUnavailable(ctx))
-    return false;
+  bool downgradeToWarning = false;
+  if (override->getAttrs().isUnavailable(ctx)) {
+    // Don't report constructors that are marked unavailable as being less
+    // available than their introduction. This was previously allowed and
+    // can be used to forbid the direct use of a constructor in a subclass.
+    // Note that even when marked unavailable the constructor could be called
+    // by other inherited constructors.
+    if (isa<ConstructorDecl>(override))
+      return false;
+
+    // Report as a warning other unavailable overrides.
+    downgradeToWarning = true;
+  }
 
-  diags.diagnose(override, diag::override_less_available,
+  diags.diagnose(override,
+                 downgradeToWarning? diag::override_less_available_warn :
+                                     diag::override_less_available,
                  override->getBaseName());
   diags.diagnose(base, diag::overridden_here);
 

test/Sema/availability_versions.swift

@@ -845,25 +845,25 @@ class SubWithUnavailableMembers : SuperWithAlwaysAvailableMembers {
   required init() {}
 
   @available(OSX, unavailable)
-  override func shouldAlwaysBeAvailableMethod() { // expected-error {{overriding 'shouldAlwaysBeAvailableMethod' must be as available as declaration it overrides}}
+  override func shouldAlwaysBeAvailableMethod() { // expected-warning {{overriding 'shouldAlwaysBeAvailableMethod' must be as available as declaration it overrides}}
   }
 
   @available(OSX, unavailable)
-  override var shouldAlwaysBeAvailableProperty: Int { // expected-error {{overriding 'shouldAlwaysBeAvailableProperty' must be as available as declaration it overrides}}
+  override var shouldAlwaysBeAvailableProperty: Int { // expected-warning {{overriding 'shouldAlwaysBeAvailableProperty' must be as available as declaration it overrides}}
     get { return 10 }
     set(newVal) {}
   }
 
   override var setterShouldAlwaysBeAvailableProperty: Int {
     get { return 9 }
     @available(OSX, unavailable)
-    set(newVal) {} // expected-error {{overriding setter for 'setterShouldAlwaysBeAvailableProperty' must be as available as declaration it overrides}}
+    set(newVal) {} // expected-warning {{overriding setter for 'setterShouldAlwaysBeAvailableProperty' must be as available as declaration it overrides}}
     // This is a terrible diagnostic. rdar://problem/20427938
   }
 
   override var getterShouldAlwaysBeAvailableProperty: Int {
     @available(OSX, unavailable)
-    get { return 9 } // expected-error {{overriding getter for 'getterShouldAlwaysBeAvailableProperty' must be as available as declaration it overrides}}
+    get { return 9 } // expected-warning {{overriding getter for 'getterShouldAlwaysBeAvailableProperty' must be as available as declaration it overrides}}
     set(newVal) {}
   }
 }