Sema: Diagnose invalid initializers on resilient types

Value type initializers must initialize stored properties directly
if they do not delegate to another initializer via self.init().

Since direct stored property access is not permitted for resilient
value types from outside their resilience domain, this means that
such initializers are prohibited in two cases:

- If the initializer is defined in an extension from outside the
  value type's resilience domain

- If the initializer is public and @_inlineable, since it might get
  inlined outside the value type's resilience domain

Right now, such initializers cannot *assign* to self either;
I filed <https://bugs.swift.org/browse/SR-3686> to track the issue.

Author: slavapestov

include/swift/AST/DiagnosticsSema.def

@@ -3356,10 +3356,19 @@ ERROR(resilience_decl_unavailable,
       "cannot be referenced from " FRAGILE_FUNC_KIND "3",
       (DescriptiveDeclKind, DeclName, Accessibility, unsigned))
 
+#undef FRAGILE_FUNC_KIND
+
 NOTE(resilience_decl_declared_here,
      none, "%0 %1 is not '@_versioned' or public", (DescriptiveDeclKind, DeclName))
 
-#undef FRAGILE_FUNC_KIND
+ERROR(designated_init_in_extension_resilient,none,
+      "initializer declared in an extension of "
+      "non-'@_fixed_layout' type %0 must delegate to another initializer", (Type))
+
+ERROR(designated_init_inlineable_resilient,none,
+      "initializer of non-'@_fixed_layout' type %0 is "
+      "'%select{@_transparent|@inline(__always)|@_inlineable|%error}1' and must "
+      "delegate to another initializer", (Type, unsigned))
 
 //------------------------------------------------------------------------------
 // @_specialize diagnostics

lib/Sema/CSApply.cpp

@@ -210,6 +210,11 @@ static bool shouldAccessStorageDirectly(Expr *base, VarDecl *member,
        member->getDeclContext()->getDeclaredInterfaceType()))
     return false;
 
+  // If the storage is resilient, we cannot access it directly at all.
+  if (!member->hasFixedLayout(DC->getParentModule(),
+                              DC->getResilienceExpansion()))
+    return false;
+
   return true;
 }
 
@@ -222,12 +227,6 @@ getImplicitMemberReferenceAccessSemantics(Expr *base, VarDecl *member,
   // accessors.  However, in the init and destructor methods for the type
   // immediately containing the property, accesses are done direct.
   if (shouldAccessStorageDirectly(base, member, DC)) {
-    // The storage better not be resilient.
-    assert(member->hasFixedLayout(DC->getParentModule(),
-                                  DC->getResilienceExpansion()) &&
-           "Designated initializers and destructors of resilient types "
-           "cannot be @_transparent or defined in extensions");
-
     // Access this directly instead of going through (e.g.) observing or
     // trivial accessors.
     return AccessSemantics::DirectToStorage;

lib/Sema/ResilienceDiagnostics.cpp

@@ -99,3 +99,33 @@ bool TypeChecker::diagnoseInlineableDeclRef(SourceLoc loc,
 
   return false;
 }
+
+void TypeChecker::diagnoseResilientValueConstructor(ConstructorDecl *ctor) {
+  auto nominalDecl = ctor->getDeclContext()
+    ->getAsNominalTypeOrNominalTypeExtensionContext();
+
+  bool isDelegating =
+      (ctor->getDelegatingOrChainedInitKind(&Diags) ==
+       ConstructorDecl::BodyInitKind::Delegating);
+
+  if (!isDelegating &&
+      !nominalDecl->hasFixedLayout(ctor->getParentModule(),
+                                   ctor->getResilienceExpansion())) {
+    if (ctor->getResilienceExpansion() == ResilienceExpansion::Minimal) {
+      // An @_inlineable designated initializer defined in a resilient type
+      // cannot initialize stored properties directly, and must chain to
+      // another initializer.
+      diagnose(ctor->getLoc(),
+               diag::designated_init_inlineable_resilient,
+               ctor->getDeclContext()->getDeclaredInterfaceType(),
+               getFragileFunctionKind(ctor));
+    } else {
+      // A designated initializer defined on an extension of a resilient
+      // type from a different resilience domain cannot initialize stored
+      // properties directly, and must chain to another initializer.
+      diagnose(ctor->getLoc(),
+               diag::designated_init_in_extension_resilient,
+               ctor->getDeclContext()->getDeclaredInterfaceType());
+    }
+  }
+}

lib/Sema/TypeCheckDecl.cpp

@@ -6416,6 +6416,13 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     } else if (auto extType = CD->getDeclContext()->getDeclaredInterfaceType()) {
       // A designated initializer 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 (extType->getClassOrBoundGenericClass() &&
           isa<ExtensionDecl>(CD->getDeclContext())) {
         TC.diagnose(CD->getLoc(), diag::designated_init_in_extension, extType)

lib/Sema/TypeCheckStmt.cpp

@@ -1489,7 +1489,12 @@ bool TypeChecker::typeCheckConstructorBodyUntil(ConstructorDecl *ctor,
   // Determine whether we need to introduce a super.init call.
   auto nominalDecl = ctor->getDeclContext()
     ->getAsNominalTypeOrNominalTypeExtensionContext();
-  ClassDecl *ClassD = dyn_cast_or_null<ClassDecl>(nominalDecl);
+
+  // Error case.
+  if (nominalDecl == nullptr)
+    return HadError;
+
+  ClassDecl *ClassD = dyn_cast<ClassDecl>(nominalDecl);
   bool wantSuperInitCall = false;
   if (ClassD) {
     bool isDelegating = false;
@@ -1521,18 +1526,22 @@ bool TypeChecker::typeCheckConstructorBodyUntil(ConstructorDecl *ctor,
     }
 
     // A class designated initializer must never be delegating.
-    if (ctor->isDesignatedInit() && ClassD && isDelegating) {
+    if (ctor->isDesignatedInit() && isDelegating) {
       diagnose(ctor->getLoc(),
                diag::delegating_designated_init,
                ctor->getDeclContext()->getDeclaredInterfaceType())
         .fixItInsert(ctor->getLoc(), "convenience ");
       diagnose(initExpr->getLoc(), diag::delegation_here);
       ctor->setInitKind(CtorInitializerKind::Convenience);
     }
+  } else {
+    diagnoseResilientValueConstructor(ctor);
   }
 
   // If we want a super.init call...
   if (wantSuperInitCall) {
+    assert(ClassD != nullptr);
+
     // Find a default initializer in the superclass.
     if (Expr *SuperInitCall = constructCallToSuperInit(ctor, ClassD)) {
       // If the initializer we found is a designated initializer, we're okay.

lib/Sema/TypeChecker.h

@@ -1943,6 +1943,8 @@ class TypeChecker final : public LazyResolver {
   bool diagnoseInlineableDeclRef(SourceLoc loc, const ValueDecl *D,
                                  const DeclContext *DC);
 
+  void diagnoseResilientValueConstructor(ConstructorDecl *ctor);
+
   /// \name Availability checking
   ///
   /// Routines that perform API availability checking and type checking of

test/decl/init/resilience.swift

@@ -0,0 +1,67 @@
+// RUN: rm -rf %t && mkdir %t
+// RUN: %target-swift-frontend -emit-module -enable-resilience -emit-module-path=%t/resilient_struct.swiftmodule -module-name=resilient_struct %S/../../Inputs/resilient_struct.swift
+// RUN: %target-swift-frontend -typecheck -verify -enable-resilience -I %t %s
+
+import resilient_struct
+
+// Point is @_fixed_layout -- this is OK
+extension Point {
+  init(xx: Int, yy: Int) {
+    self.x = xx
+    self.y = yy
+  }
+}
+
+// Size is not @_fixed_layout, so we cannot define a new designated initializer
+extension Size {
+  init(ww: Int, hh: Int) {
+  // expected-error@-1 {{initializer declared in an extension of non-'@_fixed_layout' type 'Size' must delegate to another initializer}}
+    self.w = ww
+    self.h = hh
+  }
+
+  // This is OK
+  init(www: Int, hhh: Int) {
+    self.init(w: www, h: hhh)
+  }
+
+  // FIXME: This should be allowed, but Sema doesn't distinguish this
+  // case from memberwise initialization, and DI explodes the value type
+  init(other: Size) {
+  // expected-error@-1 {{initializer declared in an extension of non-'@_fixed_layout' type 'Size' must delegate to another initializer}}
+    self = other
+  }
+}
+
+// Animal is not @_fixed_layout, so we cannot define an @_inlineable
+// designated initializer
+public struct Animal {
+  public let name: String
+
+  @_inlineable public init(name: String) {
+  // expected-error@-1 {{initializer of non-'@_fixed_layout' type 'Animal' is '@_inlineable' and must delegate to another initializer}}
+    self.name = name
+  }
+
+  @inline(__always) public init(dog: String) {
+  // expected-error@-1 {{initializer of non-'@_fixed_layout' type 'Animal' is '@inline(__always)' and must delegate to another initializer}}
+    self.name = dog
+  }
+
+  @_transparent public init(cat: String) {
+  // expected-error@-1 {{initializer of non-'@_fixed_layout' type 'Animal' is '@_transparent' and must delegate to another initializer}}
+    self.name = cat
+  }
+
+  // This is OK
+  @_inlineable public init(cow: String) {
+    self.init(name: cow)
+  }
+
+  // FIXME: This should be allowed, but Sema doesn't distinguish this
+  // case from memberwise initialization, and DI explodes the value type
+  @_inlineable public init(other: Animal) {
+  // expected-error@-1 {{initializer of non-'@_fixed_layout' type 'Animal' is '@_inlineable' and must delegate to another initializer}}
+    self = other
+  }
+}