Sema: Diagnose use of the @_backDeploy attribute on non-final and @objc decls.

Author: tshortli

include/swift/AST/DiagnosticsSema.def

@@ -3161,6 +3161,10 @@ ERROR(final_not_allowed_here,none,
       "'final' may only be applied to classes, properties, methods, and "
       "subscripts", ())
 
+ERROR(attr_incompatible_with_non_final,none,
+      "'%0' cannot be applied to a non-final %1",
+      (DeclAttribute, DescriptiveDeclKind))
+
 ERROR(final_not_on_accessors,none,
       "'final' cannot be applied to accessors, it must be put on the "
       "%select{var|let|subscript}0", (unsigned))
@@ -6291,7 +6295,8 @@ ERROR(cannot_convert_default_value_type_to_argument_type, none,
 //------------------------------------------------------------------------------
 
 ERROR(attr_incompatible_with_back_deploy,none,
-      "'%0' cannot be applied to back deployed declarations", (DeclAttribute))
+      "'%0' cannot be applied to a back deployed %1",
+      (DeclAttribute, DescriptiveDeclKind))
 
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

lib/SILGen/SILGenApply.cpp

@@ -1030,10 +1030,8 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
   }
 
   void processClassMethod(DeclRefExpr *e, AbstractFunctionDecl *afd) {
-    // FIXME(backDeploy): Investigate support for back deployed class method
-    // calls
     assert(!afd->isBackDeployed() &&
-           "back deployed method calls are unsupported");
+           "cannot back deploy dynamically dispatched methods");
 
     ArgumentSource selfArgSource(selfApply->getBase());
     setSelfParam(std::move(selfArgSource));

lib/Sema/TypeCheckAttr.cpp

@@ -80,7 +80,7 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
             attr,
             isError ? diag::attr_not_on_decl_with_invalid_access_level
                     : diag::attr_has_no_effect_on_decl_with_access_level,
-            attr, VD->getFormalAccess());
+            attr, access.accessLevelForDiagnostics());
         return true;
       }
     }
@@ -3508,28 +3508,46 @@ void AttributeChecker::checkBackDeployAttrs(ArrayRef<BackDeployAttr *> Attrs) {
   // ABI version of the declaration when it is available.
   if (auto *AEICA = D->getAttrs().getAttribute<AlwaysEmitIntoClientAttr>()) {
     diagnoseAndRemoveAttr(AEICA, diag::attr_incompatible_with_back_deploy,
-                          AEICA);
+                          AEICA, D->getDescriptiveKind());
   }
 
   if (auto *IA = D->getAttrs().getAttribute<InlinableAttr>()) {
-    diagnoseAndRemoveAttr(IA, diag::attr_incompatible_with_back_deploy, IA);
+    diagnoseAndRemoveAttr(IA, diag::attr_incompatible_with_back_deploy, IA,
+                          D->getDescriptiveKind());
   }
 
   if (auto *TA = D->getAttrs().getAttribute<TransparentAttr>()) {
-    diagnoseAndRemoveAttr(TA, diag::attr_incompatible_with_back_deploy, TA);
+    diagnoseAndRemoveAttr(TA, diag::attr_incompatible_with_back_deploy, TA,
+                          D->getDescriptiveKind());
   }
 
+  // @objc conflicts with back deployment since it implies dynamic dispatch.
+  if (auto *OA = D->getAttrs().getAttribute<ObjCAttr>()) {
+    diagnose(OA->getLocation(), diag::attr_incompatible_with_back_deploy, OA,
+             D->getDescriptiveKind());
+  }
+
+  // Only functions, methods, computed properties, and subscripts are
+  // back-deployable, so D should be ValueDecl.
+  auto *VD = cast<ValueDecl>(D);
   std::map<PlatformKind, SourceLoc> seenPlatforms;
 
   for (auto *Attr : Attrs) {
     // Back deployment only makes sense for public declarations.
     if (diagnoseAndRemoveAttrIfDeclIsNonPublic(Attr, /*isError=*/true))
       continue;
 
-    if (auto *VD = dyn_cast<VarDecl>(D)) {
+    // Back deployment isn't compatible with dynamic dispatch.
+    if (VD->isPotentiallyOverridable() && !VD->isFinal()) {
+      diagnose(Attr->getLocation(), diag::attr_incompatible_with_non_final,
+               Attr, D->getDescriptiveKind());
+      continue;
+    }
+
+    if (auto *VarD = dyn_cast<VarDecl>(D)) {
       // There must be a function body to back deploy so for vars we require
       // that they be computed in order to allow back deployment.
-      if (VD->hasStorageOrWrapsStorage()) {
+      if (VarD->hasStorageOrWrapsStorage()) {
         diagnoseAndRemoveAttr(Attr, diag::attr_not_on_stored_properties, Attr);
         continue;
       }
@@ -3556,9 +3574,6 @@ void AttributeChecker::checkBackDeployAttrs(ArrayRef<BackDeployAttr *> Attrs) {
     // fallback could never be executed at runtime.
     auto IntroVer = D->getIntroducedOSVersion(Platform);
     if (Attr->Version <= IntroVer.getValue()) {
-      // Only functions, methods, computed properties, and subscripts are
-      // back-deployable.
-      auto *VD = cast<ValueDecl>(D);
       diagnose(AtLoc, diag::attr_has_no_effect_decl_not_available_before, Attr,
                VD->getName(), prettyPlatformString(Platform), Attr->Version);
       continue;

test/attr/attr_backDeploy.swift

@@ -24,16 +24,76 @@ public struct TopLevelStruct {
   public var backDeployedComputedProperty: Int { 98 }
 }
 
+// OK: final function decls in a non-final class
 public class TopLevelClass {
   @available(macOS 11.0, *)
   @_backDeploy(macOS 12.0)
   final public func backDeployedFinalMethod() {}
 
+  @available(macOS 11.0, *)
+  @_backDeploy(macOS 12.0)
+  final public var backDeployedFinalComputedProperty: Int { 98 }
+
+  @available(macOS 11.0, *)
+  @_backDeploy(macOS 12.0)
+  public static func backDeployedStaticMethod() {}
+
+  @available(macOS 11.0, *)
+  @_backDeploy(macOS 12.0)
+  public final class func backDeployedClassMethod() {}
+}
+
+// OK: function decls in a final class
+final public class FinalTopLevelClass {
+  @available(macOS 11.0, *)
+  @_backDeploy(macOS 12.0)
+  public func backDeployedMethod() {}
+
   @available(macOS 11.0, *)
   @_backDeploy(macOS 12.0)
   public var backDeployedComputedProperty: Int { 98 }
 }
 
+// OK: final function decls on an actor
+@available(macOS 11.0, *)
+public actor TopLevelActor {
+  @available(macOS 11.0, *)
+  @_backDeploy(macOS 12.0)
+  final public func finalActorMethod() {}
+
+  // OK: actor methods are effectively final
+  @available(macOS 11.0, *)
+  @_backDeploy(macOS 12.0)
+  public func actorMethod() {}
+}
+
+// OK: function decls in extension on public types
+extension TopLevelStruct {
+  @available(macOS 11.0, *)
+  @_backDeploy(macOS 12.0)
+  public func backDeployedExtensionMethod() {}
+}
+
+extension TopLevelClass {
+  @available(macOS 11.0, *)
+  @_backDeploy(macOS 12.0)
+  final public func backDeployedExtensionMethod() {}
+}
+
+extension FinalTopLevelClass {
+  @available(macOS 11.0, *)
+  @_backDeploy(macOS 12.0)
+  public func backDeployedExtensionMethod() {}
+}
+
+public protocol TopLevelProtocol {}
+
+extension TopLevelProtocol {
+  @available(macOS 11.0, *)
+  @_backDeploy(macOS 12.0)
+  public func backDeployedExtensionMethod() {}
+}
+
 // MARK: - Unsupported declaration types
 
 @_backDeploy(macOS 12.0) // expected-error {{'@_backDeploy' attribute cannot be applied to this declaration}}
@@ -60,6 +120,13 @@ public var cannotBackDeployTopLevelVar = 79
 @_backDeploy(macOS 12.0) // expected-error {{'@_backDeploy' attribute cannot be applied to this declaration}}
 extension TopLevelStruct {}
 
+@_backDeploy(macOS 12.0) // expected-error {{'@_backDeploy' attribute cannot be applied to this declaration}}
+protocol CannotBackDeployProtocol {}
+
+@available(macOS 11.0, *)
+@_backDeploy(macOS 12.0) // expected-error {{'@_backDeploy' attribute cannot be applied to this declaration}}
+public actor CannotBackDeployActor {}
+
 // MARK: - Incompatible declarations
 
 @_backDeploy(macOS 12.0) // expected-error {{'@_backDeploy' may not be used on fileprivate declarations}}
@@ -71,11 +138,22 @@ private func privateFunc() {}
 @_backDeploy(macOS 12.0) // expected-error {{'@_backDeploy' may not be used on internal declarations}}
 internal func internalFunc() {}
 
-// FIXME(backDeploy): back deployed methods must be final
+private struct PrivateTopLevelStruct {
+  @_backDeploy(macOS 12.0) // expected-error {{'@_backDeploy' may not be used on private declarations}}
+  public func effectivelyPrivateFunc() {}
+}
+
 public class TopLevelClass2 {
+  @_backDeploy(macOS 12.0) // expected-error {{'@_backDeploy' cannot be applied to a non-final instance method}}
+  public func nonFinalMethod() {}
+
   @available(macOS 11.0, *)
   @_backDeploy(macOS 12.0)
-  public func backDeployedNonFinalMethod() {}
+  @objc // expected-error {{'@objc' cannot be applied to a back deployed instance method}}
+  final public func objcMethod() {}
+
+  @_backDeploy(macOS 12.0) // expected-error {{'@_backDeploy' cannot be applied to a non-final class method}}
+  public class func nonFinalClassMethod() {}
 }
 
 @_backDeploy(macOS 12.0) // expected-error {{'@_backDeploy' requires that 'missingAllAvailabilityFunc()' have explicit availability for macOS}}
@@ -104,17 +182,17 @@ public func duplicatePlatformsFunc2() {}
 
 @available(macOS 11.0, *)
 @_backDeploy(macOS 12.0)
-@_alwaysEmitIntoClient // expected-error {{'@_alwaysEmitIntoClient' cannot be applied to back deployed declarations}}
+@_alwaysEmitIntoClient // expected-error {{'@_alwaysEmitIntoClient' cannot be applied to a back deployed global function}}
 public func alwaysEmitIntoClientFunc() {}
 
 @available(macOS 11.0, *)
 @_backDeploy(macOS 12.0)
-@inlinable // expected-error {{'@inlinable' cannot be applied to back deployed declarations}}
+@inlinable // expected-error {{'@inlinable' cannot be applied to a back deployed global function}}
 public func inlinableFunc() {}
 
 @available(macOS 11.0, *)
 @_backDeploy(macOS 12.0)
-@_transparent // expected-error {{'@_transparent' cannot be applied to back deployed declarations}}
+@_transparent // expected-error {{'@_transparent' cannot be applied to a back deployed global function}}
 public func transparentFunc() {}
 
 // MARK: - Attribute parsing