Simplify diagnoseResilientConstructor all the way away.

Now that struct initializers "just" fall into the delegating case when
they're made inlinable, the only interesting case is class
initializers, which can be checked in a more direct way than what we
were doing before.

Author: jrose-apple

lib/Sema/ResilienceDiagnostics.cpp

@@ -19,16 +19,11 @@
 #include "swift/AST/Decl.h"
 #include "swift/AST/Initializer.h"
 #include "swift/AST/DeclContext.h"
-using namespace swift;
 
-enum FragileFunctionKind : unsigned {
-  Transparent,
-  InlineAlways,
-  Inlineable,
-  DefaultArgument
-};
+using namespace swift;
+using FragileFunctionKind = TypeChecker::FragileFunctionKind;
 
-FragileFunctionKind getFragileFunctionKind(const DeclContext *DC) {
+FragileFunctionKind TypeChecker::getFragileFunctionKind(const DeclContext *DC) {
   for (; DC->isLocalContext(); DC = DC->getParent()) {
     if (auto *DAI = dyn_cast<DefaultArgumentInitializer>(DC))
       if (DAI->getResilienceExpansion() == ResilienceExpansion::Minimal)
@@ -69,7 +64,8 @@ void TypeChecker::diagnoseInlineableLocalType(const NominalTypeDecl *NTD) {
   auto expansion = DC->getResilienceExpansion();
   if (expansion == ResilienceExpansion::Minimal) {
     diagnose(NTD, diag::local_type_in_inlineable_function,
-             NTD->getFullName(), getFragileFunctionKind(DC));
+             NTD->getFullName(),
+             static_cast<unsigned>(getFragileFunctionKind(DC)));
   }
 }
 
@@ -117,7 +113,7 @@ bool TypeChecker::diagnoseInlineableDeclRef(SourceLoc loc,
   diagnose(loc, diag::resilience_decl_unavailable,
            D->getDescriptiveKind(), D->getFullName(),
            D->getFormalAccessScope().accessLevelForDiagnostics(),
-           getFragileFunctionKind(DC));
+           static_cast<unsigned>(getFragileFunctionKind(DC)));
 
   bool isDefaultArgument = false;
   while (DC->isLocalContext()) {
@@ -140,32 +136,3 @@ bool TypeChecker::diagnoseInlineableDeclRef(SourceLoc loc,
   return true;
 }
 
-void TypeChecker::diagnoseResilientConstructor(ConstructorDecl *ctor) {
-  auto nominalDecl = ctor->getDeclContext()
-    ->getAsNominalTypeOrNominalTypeExtensionContext();
-
-  // These restrictions only apply to concrete types, and not protocol
-  // extensions.
-  if (isa<ProtocolDecl>(nominalDecl))
-    return;
-
-  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(),
-               isa<ClassDecl>(nominalDecl)
-                 ? diag::class_designated_init_inlineable_resilient
-                 : diag::designated_init_inlineable_resilient,
-               nominalDecl->getDeclaredInterfaceType(),
-               getFragileFunctionKind(ctor));
-    }
-  }
-}

lib/Sema/TypeCheckStmt.cpp

@@ -1551,9 +1551,15 @@ bool TypeChecker::typeCheckConstructorBodyUntil(ConstructorDecl *ctor,
       diagnose(initExpr->getLoc(), diag::delegation_here);
       ctor->setInitKind(CtorInitializerKind::Convenience);
     }
-  }
 
-  diagnoseResilientConstructor(ctor);
+    // An inlinable constructor in a class must always be delegating.
+    if (!isDelegating && !ClassD->hasFixedLayout() &&
+        ctor->getResilienceExpansion() == ResilienceExpansion::Minimal) {
+      diagnose(ctor, diag::class_designated_init_inlineable_resilient,
+               ClassD->getDeclaredInterfaceType(),
+               static_cast<unsigned>(getFragileFunctionKind(ctor)));
+    }
+  }
 
   // If we want a super.init call...
   if (wantSuperInitCall) {

lib/Sema/TypeChecker.h

@@ -2272,7 +2272,19 @@ class TypeChecker final : public LazyResolver {
   bool diagnoseInlineableDeclRef(SourceLoc loc, const ValueDecl *D,
                                  const DeclContext *DC);
 
-  void diagnoseResilientConstructor(ConstructorDecl *ctor);
+  /// Used in diagnostic %selects.
+  enum class FragileFunctionKind : unsigned {
+    Transparent,
+    InlineAlways,
+    Inlineable,
+    DefaultArgument
+  };
+
+  /// Given that \p DC is within a fragile context for some reason, describe
+  /// why.
+  ///
+  /// \see FragileFunctionKind
+  FragileFunctionKind getFragileFunctionKind(const DeclContext *DC);
 
   /// \name Availability checking
   ///

test/decl/init/resilience.swift

@@ -54,11 +54,31 @@ public struct Animal {
 
 public class Widget {
   public let name: String
+  
+  public init(nonInlinableName name: String) {
+    self.name = name
+  }
 
   @_inlineable public init(name: String) {
     // expected-error@-1 {{initializer for class 'Widget' is '@_inlineable' and must delegate to another initializer}}
     self.name = name
   }
+
+  @_inlineable public convenience init(goodName name: String) {
+    // This is OK
+    self.init(nonInlinableName: name)
+  }
+}
+
+public protocol Gadget {
+  init()
+}
+
+extension Gadget {
+  @_inlineable public init(unused: Int) {
+    // This is OK
+    self.init()
+  }
 }
 
 // Protocol extension initializers are OK too