prevent serialization of allocating inits for actors

A public designated initializer of a class would have its allocating
entry-point serialized in the module, meaning with `-O` that entry-point
can get inlined into programs linking against that module. Once that
entry-point is inlined, the program will _require_ that it remain non-delegating,
because it will depend on the 2nd entry-point (for actual initializing) to be in the
library.

As a result of this change, public initializers of an actor should be resilient in a library, whether their underlying implementation is delegating or not.

Author: kavon

lib/SIL/IR/SILDeclRef.cpp

@@ -669,13 +669,14 @@ IsSerialized_t SILDeclRef::isSerialized() const {
     return IsSerialized;
 
   // The allocating entry point for designated initializers are serialized
-  // if the class is @usableFromInline or public.
+  // if the class is @usableFromInline or public. Actors are excluded because
+  // whether the init is designated is not clearly reflected in the source code.
   if (kind == SILDeclRef::Kind::Allocator) {
     auto *ctor = cast<ConstructorDecl>(d);
-    if (ctor->isDesignatedInit() &&
-        ctor->getDeclContext()->getSelfClassDecl()) {
-      if (!ctor->hasClangNode())
-        return IsSerialized;
+    if (auto classDecl = ctor->getDeclContext()->getSelfClassDecl()) {
+      if (!classDecl->isAnyActor() && ctor->isDesignatedInit())
+        if (!ctor->hasClangNode())
+          return IsSerialized;
     }
   }
 

lib/Sema/TypeCheckDecl.cpp

@@ -421,8 +421,37 @@ InitKindRequest::evaluate(Evaluator &evaluator, ConstructorDecl *decl) const {
 
     // if there is no `convenience` keyword...
 
-    // actors infer whether they are `convenience` from their body kind.
-    if (auto classDecl = dyn_cast<ClassDecl>(nominal)) {
+    if (auto classDcl = dyn_cast<ClassDecl>(nominal)) {
+      // 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::cfclass_designated_init_in_extension,
+                         nominal->getName());
+          return CtorInitializerKind::Designated;
+        } else {
+          auto diag = diags.diagnose(decl->getLoc(),
+                         diag::designated_init_in_extension,
+                         nominal->getName());
+
+          if (!classDcl->isAnyActor())
+              diag.fixItInsert(decl->getLoc(), "convenience ");
+              
+          return CtorInitializerKind::Convenience;
+        }
+      }
+
+      // actors infer whether they are `convenience` from their body kind.
       if (classDecl->isAnyActor()) {
         auto kind = decl->getDelegatingOrChainedInitKind();
         switch (kind.initKind) {
@@ -435,32 +464,8 @@ InitKindRequest::evaluate(Evaluator &evaluator, ConstructorDecl *decl) const {
             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 ");
-        return CtorInitializerKind::Convenience;
-      }
-    }
+    } // end of ClassDecl context
   } // end of Nominal context
 
   // initializers in protocol extensions must be convenience inits

test/SILGen/inlinable_attribute.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-emit-silgen -module-name inlinable_attribute -emit-verbose-sil -warnings-as-errors %s | %FileCheck %s
+// RUN: %target-swift-emit-silgen -module-name inlinable_attribute -emit-verbose-sil -warnings-as-errors -disable-availability-checking %s | %FileCheck %s
 
 // CHECK-LABEL: sil [serialized] [ossa] @$s19inlinable_attribute15fragileFunctionyyF : $@convention(thin) () -> ()
 @inlinable public func fragileFunction() {
@@ -37,6 +37,32 @@ public class MyCls {
   }
 }
 
+public actor MyAct {
+  // CHECK-LABEL: sil [serialized] [ossa] @$s19inlinable_attribute5MyActCfD : $@convention(method) (@owned MyAct) -> ()
+  @inlinable deinit {}
+
+  /// whether delegating or not, the initializers for an actor are not serialized unless marked inlinable.
+
+  // CHECK-LABEL: sil [exact_self_class] [ossa] @$s19inlinable_attribute5MyActC14designatedInitACyt_tcfC : $@convention(method) (@thick MyAct.Type) -> @owned MyAct
+  // CHECK-LABEL: sil [ossa] @$s19inlinable_attribute5MyActC14designatedInitACyt_tcfc : $@convention(method) (@owned MyAct) -> @owned MyAct
+  public init(designatedInit: ()) {}
+
+  // CHECK-LABEL: sil [ossa] @$s19inlinable_attribute5MyActC15convenienceInitACyt_tcfC : $@convention(method) (@thick MyAct.Type) -> @owned MyAct
+  public init(convenienceInit: ()) {
+    self.init(designatedInit: ())
+  }
+
+
+  // CHECK-LABEL: sil [serialized] [exact_self_class] [ossa] @$s19inlinable_attribute5MyActC0A14DesignatedInitACyt_tcfC : $@convention(method) (@thick MyAct.Type) -> @owned MyAct
+  // CHECK-LABEL: sil [serialized] [ossa] @$s19inlinable_attribute5MyActC0A14DesignatedInitACyt_tcfc : $@convention(method) (@owned MyAct) -> @owned MyAct
+  @inlinable public init(inlinableDesignatedInit: ()) {}
+
+  // CHECK-LABEL: sil [serialized] [ossa] @$s19inlinable_attribute5MyActC0A15ConvenienceInitACyt_tcfC : $@convention(method) (@thick MyAct.Type) -> @owned MyAct
+  @inlinable public init(inlinableConvenienceInit: ()) {
+    self.init(designatedInit: ())
+  }
+}
+
 // Make sure enum case constructors for public and versioned enums are
 // [serialized].
 @usableFromInline enum MyEnum {