Merge pull request #59828 from kavon/inconvenienced-actors-continued

Inconvenienced actors, continued

Author: swift-ci

include/swift/AST/DiagnosticsSema.def

@@ -3569,7 +3569,7 @@ ERROR(designated_init_in_extension,none,
       "designated initializer cannot be declared in an extension of %0; "
       "did you mean this to be a convenience initializer?",
       (DeclName))
-ERROR(cfclass_designated_init_in_extension,none,
+ERROR(designated_init_in_extension_no_convenience_tip,none,
       "designated initializer cannot be declared in an extension of %0",
       (DeclName))
 ERROR(no_convenience_keyword_init,none,

lib/Sema/TypeCheckDecl.cpp

@@ -419,48 +419,60 @@ InitKindRequest::evaluate(Evaluator &evaluator, ConstructorDecl *decl) const {
       return CtorInitializerKind::Convenience;
     }
 
-    // if there is no `convenience` keyword...
+    // if there's no `convenience` attribute...
 
-    // actors infer whether they are `convenience` from their body kind.
-    if (auto classDecl = dyn_cast<ClassDecl>(nominal)) {
-      if (classDecl->isAnyActor()) {
+    if (auto classDcl = dyn_cast<ClassDecl>(nominal)) {
+
+      // actors infer whether they are `convenience` from their body kind.
+      if (classDcl->isAnyActor()) {
         auto kind = decl->getDelegatingOrChainedInitKind();
         switch (kind.initKind) {
           case BodyInitKind::ImplicitChained:
           case BodyInitKind::Chained:
           case BodyInitKind::None:
-            return CtorInitializerKind::Designated;
+            break; // it's designated, we need more checks.
 
           case BodyInitKind::Delegating:
             return CtorInitializerKind::Convenience;
         }
       }
-    }
 
-    // A designated init for a class must be written within the class itself.
-    //
-    // This is because designated initializers of classes get a vtable entry,
-    // and extensions cannot add vtable entries to the extended type.
-    //
-    // If we implement the ability for extensions defined in the same module
-    // (or the same file) to add vtable entries, we can re-evaluate this
-    // restriction.
-    if (isa<ClassDecl>(nominal) && !decl->isSynthesized() &&
-        isa<ExtensionDecl>(decl->getDeclContext()) &&
-        !(decl->getAttrs().hasAttribute<DynamicReplacementAttr>())) {
-      if (cast<ClassDecl>(nominal)->getForeignClassKind() == ClassDecl::ForeignKind::CFType) {
-        diags.diagnose(decl->getLoc(),
-                       diag::cfclass_designated_init_in_extension,
-                       nominal->getName());
-        return CtorInitializerKind::Designated;
-      } else {
-        diags.diagnose(decl->getLoc(),
-                       diag::designated_init_in_extension,
-                       nominal->getName())
-            .fixItInsert(decl->getLoc(), "convenience ");
+      // A designated init for a class must be written within the class itself.
+      //
+      // This is because designated initializers of classes get a vtable entry,
+      // and extensions cannot add vtable entries to the extended type.
+      //
+      // If we implement the ability for extensions defined in the same module
+      // (or the same file) to add vtable entries, we can re-evaluate this
+      // restriction.
+      if (!decl->isSynthesized() &&
+          isa<ExtensionDecl>(decl->getDeclContext()) &&
+          !(decl->getAttrs().hasAttribute<DynamicReplacementAttr>())) {
+
+        if (classDcl->getForeignClassKind() == ClassDecl::ForeignKind::CFType) {
+          diags.diagnose(decl->getLoc(),
+                         diag::designated_init_in_extension_no_convenience_tip,
+                         nominal->getName());
+
+          // despite having reported it as an error, say that it is designated.
+          return CtorInitializerKind::Designated;
+
+        } else if (classDcl->isAnyActor()) {
+          // tailor the diagnostic to not mention `convenience`
+          diags.diagnose(decl->getLoc(),
+                         diag::designated_init_in_extension_no_convenience_tip,
+                         nominal->getName());
+
+        } else {
+          diags.diagnose(decl->getLoc(),
+                             diag::designated_init_in_extension,
+                             nominal->getName())
+                 .fixItInsert(decl->getLoc(), "convenience ");
+        }
+
         return CtorInitializerKind::Convenience;
       }
-    }
+    } // end of Class context
   } // end of Nominal context
 
   // initializers in protocol extensions must be convenience inits

test/Concurrency/Runtime/Inputs/MysteryInit.swift

@@ -1,19 +1,43 @@
+import Foundation
 
 // This input is useful to ensure the delegation status of
 // an actor's initializer does not affect ABI stability
-public actor BigFoot {
 
-  public let name: String
+public protocol NamedEntity: Actor {
+  nonisolated var name: String? { get }
+}
+
+public actor BigFoot: NamedEntity {
+
+  public nonisolated let name: String?
+
+  private init(withName name: String) {
+    self.name = name
+  }
+
+  public init() {
+  #if DELEGATES
+    self.init(withName: "Sasquatch")
+  #else
+    self.name = nil
+  #endif
+  }
+}
+
+
+@objc public actor BigFootObjC: NSObject, NamedEntity {
+
+  public nonisolated let name: String?
 
   private init(withName name: String) {
     self.name = name
   }
 
-  public init?() {
+  @objc public override init() {
   #if DELEGATES
     self.init(withName: "Sasquatch")
   #else
-    return nil
+    self.name = nil
   #endif
   }
 }

test/Concurrency/Runtime/actor_init_abi.swift

@@ -47,23 +47,38 @@
 
 // REQUIRES: executable_test
 // REQUIRES: concurrency
+// REQUIRES: objc_interop
 
 // rdar://76038845
 // REQUIRES: concurrency_runtime
 // UNSUPPORTED: back_deployment_runtime
 
 import MysteryInit
 
-@main
-struct Main {
-  static func main() {
-    switch BigFoot() {
+// NOTE: the number of myth/real checks in this function (in either mode) should
+// match the number of times `test` is called. The -NOT check is there to catch
+// any mistakes in updating the test.
+func test(_ bigFoot: any NamedEntity) {
+  switch bigFoot.name {
     case .none:
       print("bigfoot is myth")
       // CHECK-NO-DELEGATES: bigfoot is myth
+      // CHECK-NO-DELEGATES: bigfoot is myth
+
+      // CHECK-NO-DELEGATES-NOT: bigfoot
     default:
       print("bigfoot is real")
       // CHECK-DELEGATES: bigfoot is real
+      // CHECK-DELEGATES: bigfoot is real
+
+      // CHECK-DELEGATES-NOT: bigfoot
     }
+}
+
+@main
+struct Main {
+  static func main() {
+    test(BigFoot())
+    test(BigFootObjC())
   }
 }

test/decl/class/actor/basic.swift

@@ -46,4 +46,10 @@ extension A2 {
 
   class subscript(i: Int) -> Int { i } // expected-error{{class subscripts are only allowed within classes; use 'static' to declare a static subscript}}
   static subscript(s: String) -> String { s }
+
+  init(delegates: ()) {
+    self.init()
+  }
+
+  init(doesNotDelegate: ()) {} // expected-error {{designated initializer cannot be declared in an extension of 'A2'}}
 }

test/decl/class/actor/initializers.swift

@@ -0,0 +1,36 @@
+// RUN: %target-swift-frontend -swift-version 5 -disable-availability-checking -emit-sil -verify %s
+
+// check the initializer kinds for protocols and their extensions
+
+protocol GoodActor {
+  init()
+  init(with: Int)
+}
+
+extension GoodActor {
+  init() {
+    self.init(with: 0)
+  }
+
+  init(with: Int) {} // expected-error {{'self.init' isn't called on all paths before returning from initializer}}
+}
+
+actor Myself: GoodActor {
+  var x: Int
+
+  init(with val: Int) {
+    self.x = val
+  }
+}
+
+actor SomebodyElse: GoodActor {
+  var x: Int
+
+  init(with val: Int) {
+    self.x = val
+  }
+
+  init() {
+    self.x = 0
+  }
+}