[Sema] Requesify inheritsSuperclassInitializers

This commit introduces a request for computing
whether a class inherits both designated and
convenience initializers from its superclass.

The shared logic of finding initializers which the
subclass hasn't overriden has been factored out
into `collectNonOveriddenSuperclassInits`.

Author: hamishknight

include/swift/AST/Decl.h

@@ -527,13 +527,10 @@ class alignas(1 << DeclAlignInBits) Decl {
     NumRequirementsInSignature : 16
   );
 
-  SWIFT_INLINE_BITFIELD(ClassDecl, NominalTypeDecl, 2+1+2+1+7+1+1+1+1+1+1,
+  SWIFT_INLINE_BITFIELD(ClassDecl, NominalTypeDecl, 2+2+1+7+1+1+1+1+1+1,
     /// The stage of the inheritance circularity check for this class.
     Circularity : 2,
 
-    /// Whether this class inherits its superclass's convenience initializers.
-    InheritsSuperclassInits : 1,
-
     /// \see ClassDecl::ForeignKind
     RawForeignKind : 2,
 
@@ -3970,15 +3967,6 @@ class ClassDecl final : public NominalTypeDecl {
   /// from its superclass.
   bool inheritsSuperclassInitializers();
 
-  /// Marks that this class inherits convenience initializers from its
-  /// superclass.
-  ///
-  /// This is computed as part of adding implicit initializers.
-  void setInheritsSuperclassInitializers() {
-    assert(addedImplicitInitializers());
-    Bits.ClassDecl.InheritsSuperclassInits = true;
-  }
-
   /// Walks the class hierarchy starting from this class, checking various
   /// conditions.
   AncestryOptions checkAncestry() const;

include/swift/AST/TypeCheckRequests.h

@@ -1627,6 +1627,25 @@ class SynthesizeDefaultInitRequest
   bool isCached() const { return true; }
 };
 
+/// Checks whether this declaration inherits its superclass' designated and
+/// convenience initializers.
+class InheritsSuperclassInitializersRequest
+    : public SimpleRequest<InheritsSuperclassInitializersRequest,
+                           bool(ClassDecl *), CacheKind::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  llvm::Expected<bool> evaluate(Evaluator &evaluator, ClassDecl *decl) const;
+
+public:
+  // Caching.
+  bool isCached() const { return true; }
+};
+
 // Allow AnyValue to compare two Type values, even though Type doesn't
 // support ==.
 template<>

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -177,3 +177,5 @@ SWIFT_REQUEST(TypeChecker, HasDefaultInitRequest,
               bool(NominalTypeDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, SynthesizeDefaultInitRequest,
               ConstructorDecl *(NominalTypeDecl *), Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, InheritsSuperclassInitializersRequest,
+              bool(ClassDecl *), Cached, NoLocationInfo)

lib/AST/Decl.cpp

@@ -3885,7 +3885,6 @@ ClassDecl::ClassDecl(SourceLoc ClassLoc, Identifier Name, SourceLoc NameLoc,
     ClassLoc(ClassLoc) {
   Bits.ClassDecl.Circularity
     = static_cast<unsigned>(CircularityCheck::Unchecked);
-  Bits.ClassDecl.InheritsSuperclassInits = 0;
   Bits.ClassDecl.RawForeignKind = 0;
   Bits.ClassDecl.HasMissingDesignatedInitializers = 0;
   Bits.ClassDecl.ComputedHasMissingDesignatedInitializers = 0;
@@ -4001,31 +4000,16 @@ bool ClassDecl::isIncompatibleWithWeakReferences() const {
 }
 
 bool ClassDecl::inheritsSuperclassInitializers() {
-  // Check whether we already have a cached answer.
-  if (addedImplicitInitializers())
-    return Bits.ClassDecl.InheritsSuperclassInits;
-
   // If there's no superclass, there's nothing to inherit.
-  ClassDecl *superclassDecl;
-  if (!(superclassDecl = getSuperclassDecl())) {
-    setAddedImplicitInitializers();
-    return false;
-  }
-
-  // If the superclass has known-missing designated initializers, inheriting
-  // is unsafe.
-  if (superclassDecl->hasMissingDesignatedInitializers())
+  if (!getSuperclass())
     return false;
 
-  // Otherwise, do all the work of resolving constructors, which will also
-  // calculate the right answer.
-  if (auto *resolver = getASTContext().getLazyResolver())
-    resolver->resolveImplicitConstructors(this);
-
-  return Bits.ClassDecl.InheritsSuperclassInits;
+  auto &ctx = getASTContext();
+  auto *mutableThis = const_cast<ClassDecl *>(this);
+  return evaluateOrDefault(
+      ctx.evaluator, InheritsSuperclassInitializersRequest{mutableThis}, false);
 }
 
-
 AncestryOptions ClassDecl::checkAncestry() const {
   return AncestryOptions(evaluateOrDefault(getASTContext().evaluator,
                            ClassAncestryFlagsRequest{const_cast<ClassDecl *>(this)},

lib/Sema/CodeSynthesis.cpp

@@ -864,6 +864,48 @@ static bool hasUserDefinedDesignatedInit(Evaluator &eval,
                            false);
 }
 
+static bool canInheritDesignatedInits(Evaluator &eval, ClassDecl *decl) {
+  // We can only inherit designated initializers if the user hasn't defined
+  // a designated init of their own, and all the stored properties have initial
+  // values.
+  return !hasUserDefinedDesignatedInit(eval, decl) &&
+         areAllStoredPropertiesDefaultInitializable(eval, decl);
+}
+
+static void collectNonOveriddenSuperclassInits(
+    ClassDecl *subclass, SmallVectorImpl<ConstructorDecl *> &results) {
+  auto superclassTy = subclass->getSuperclass();
+  assert(superclassTy);
+
+  // Record all of the initializers the subclass has overriden, excluding stub
+  // overrides, which we don't want to consider as viable delegates for
+  // convenience inits.
+  llvm::SmallPtrSet<ConstructorDecl *, 4> overriddenInits;
+  for (auto member : subclass->getMembers())
+    if (auto ctor = dyn_cast<ConstructorDecl>(member))
+      if (!ctor->hasStubImplementation())
+        if (auto overridden = ctor->getOverriddenDecl())
+          overriddenInits.insert(overridden);
+
+  auto superclassCtors = TypeChecker::lookupConstructors(
+      subclass, superclassTy, NameLookupFlags::IgnoreAccessControl);
+
+  for (auto memberResult : superclassCtors) {
+    auto superclassCtor = cast<ConstructorDecl>(memberResult.getValueDecl());
+
+    // Skip invalid superclass initializers.
+    if (superclassCtor->isInvalid())
+      continue;
+
+    // Skip unavailable superclass initializers.
+    if (AvailableAttr::isUnavailable(superclassCtor))
+      continue;
+
+    if (!overriddenInits.count(superclassCtor))
+      results.push_back(superclassCtor);
+  }
+}
+
 /// For a class with a superclass, automatically define overrides
 /// for all of the superclass's designated initializers.
 static void addImplicitInheritedConstructorsToClass(ClassDecl *decl) {
@@ -944,25 +986,11 @@ static void addImplicitInheritedConstructorsToClass(ClassDecl *decl) {
 
   bool canInheritInitializers = defaultInitable && !foundDesignatedInit;
 
-  bool canInheritConvenienceInitalizers =
-      !superclassDecl->hasMissingDesignatedInitializers();
   SmallVector<ConstructorDecl *, 4> requiredConvenienceInitializers;
-  for (auto memberResult : ctors) {
-    auto member = memberResult.getValueDecl();
-
-    // Skip unavailable superclass initializers.
-    if (AvailableAttr::isUnavailable(member))
-      continue;
-
-    // Skip invalid superclass initializers.
-    auto superclassCtor = dyn_cast<ConstructorDecl>(member);
-    if (superclassCtor->isInvalid())
-      continue;
-
-    // If we have an override for this constructor, it's okay.
-    if (overriddenInits.count(superclassCtor) > 0)
-      continue;
+  SmallVector<ConstructorDecl *, 4> nonOverridenSuperclassCtors;
+  collectNonOveriddenSuperclassInits(decl, nonOverridenSuperclassCtors);
 
+  for (auto *superclassCtor : nonOverridenSuperclassCtors) {
     // We only care about required or designated initializers.
     if (!superclassCtor->isDesignatedInit()) {
       if (superclassCtor->isRequired()) {
@@ -973,10 +1001,6 @@ static void addImplicitInheritedConstructorsToClass(ClassDecl *decl) {
       continue;
     }
 
-    // Otherwise, it may no longer be safe to inherit convenience
-    // initializers.
-    canInheritConvenienceInitalizers &= canInheritInitializers;
-
     // Everything after this is only relevant for Swift classes being defined.
     if (decl->hasClangNode())
       continue;
@@ -1028,12 +1052,38 @@ static void addImplicitInheritedConstructorsToClass(ClassDecl *decl) {
     }
   }
 
-  if (canInheritConvenienceInitalizers) {
-    decl->setInheritsSuperclassInitializers();
-  } else {
+  if (!decl->inheritsSuperclassInitializers())
     for (ConstructorDecl *requiredCtor : requiredConvenienceInitializers)
       diagnoseMissingRequiredInitializer(decl, requiredCtor, ctx);
-  }
+}
+
+llvm::Expected<bool>
+InheritsSuperclassInitializersRequest::evaluate(Evaluator &eval,
+                                                ClassDecl *decl) const {
+  auto superclass = decl->getSuperclass();
+  assert(superclass);
+
+  // If the superclass has known-missing designated initializers, inheriting
+  // is unsafe.
+  auto *superclassDecl = superclass->getClassOrBoundGenericClass();
+  if (superclassDecl->hasMissingDesignatedInitializers())
+    return false;
+
+  // If we're allowed to inherit designated initializers, then we can inherit
+  // convenience inits too.
+  if (canInheritDesignatedInits(eval, decl))
+    return true;
+
+  // Otherwise we need to check whether the user has overriden all of the
+  // superclass' designed inits.
+  SmallVector<ConstructorDecl *, 4> nonOverridenSuperclassCtors;
+  collectNonOveriddenSuperclassInits(decl, nonOverridenSuperclassCtors);
+
+  auto allDesignatedInitsOverriden =
+      llvm::none_of(nonOverridenSuperclassCtors, [](ConstructorDecl *ctor) {
+        return ctor->isDesignatedInit();
+      });
+  return allDesignatedInitsOverriden;
 }
 
 static bool shouldAttemptInitializerSynthesis(const NominalTypeDecl *decl) {

lib/Serialization/Deserialization.cpp

@@ -3409,8 +3409,8 @@ class swift::DeclDeserializer {
       theClass->setImplicit();
     theClass->setIsObjC(isObjC);
     theClass->setSuperclass(MF.getType(superclassID));
-    if (inheritsSuperclassInitializers)
-      theClass->setInheritsSuperclassInitializers();
+    ctx.evaluator.cacheOutput(InheritsSuperclassInitializersRequest{theClass},
+                              std::move(inheritsSuperclassInitializers));
 
     handleInherited(theClass,
                     rawInheritedAndDependencyIDs.slice(0, numInheritedTypes));

test/decl/class/circular_inheritance.swift

@@ -6,7 +6,7 @@
 // RUN: %FileCheck -check-prefix CHECK-DOT %s  < %t.dot
 
 // Check that we produced superclass type requests.
-// RUN: %{python} %utils/process-stats-dir.py --evaluate 'SuperclassTypeRequest == 17' %t/stats-dir
+// RUN: %{python} %utils/process-stats-dir.py --evaluate 'SuperclassTypeRequest == 18' %t/stats-dir
 
 class Left // expected-error {{circular reference}}
     : Right.Hand { // expected-note {{through reference here}}
@@ -72,3 +72,12 @@ func crash() {
   Circle()
   // expected-error@-1 {{'Circle' cannot be constructed because it has no accessible initializers}}
 }
+
+// FIXME: We shouldn't emit the redundant "circular reference" diagnostics here.
+class WithDesignatedInit : WithDesignatedInit {
+  // expected-error@-1 {{'WithDesignatedInit' inherits from itself}}
+  // expected-error@-2 {{circular reference}}
+  // expected-note@-3 {{through reference here}}
+
+  init(x: Int) {} // expected-error {{circular reference}}
+}