prevent extensions from having designated inits for actors

When I began removing `convenience` from actor inits, I thought it would
be ok for an actor's extensions to be non-delegating. But that's wrong,
because the actor could be in a resilient module and still have its
properties change between stored and computed, meaning that there isn't
a practical way to allow this, unless if the extension and the actor
are in the same file.

For now, just re-ban this behavior before anybody notices :)

Author: kavon

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/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
+  }
+}