Merge pull request swiftlang#28629 from CodaFi/convenience-never-comes-without-cost

[Shepherd] Support classes with missing designated inits

Author: CodaFi

include/swift/AST/Decl.h

@@ -539,7 +539,7 @@ class alignas(1 << DeclAlignInBits) Decl {
     RawForeignKind : 2,
 
     /// \see ClassDecl::getEmittedMembers()
-    HasForcedEmittedMembers : 1,     
+    HasForcedEmittedMembers : 1,
 
     HasMissingDesignatedInitializers : 1,
     ComputedHasMissingDesignatedInitializers : 1,
@@ -3833,6 +3833,25 @@ class ClassDecl final : public NominalTypeDecl {
     return None;
   }
 
+  Optional<bool> getCachedHasMissingDesignatedInitializers() const {
+    if (!Bits.ClassDecl.ComputedHasMissingDesignatedInitializers) {
+      // Force loading all the members, which will add this attribute if any of
+      // members are determined to be missing while loading.
+      auto mutableThis = const_cast<ClassDecl *>(this);
+      (void)mutableThis->lookupDirect(DeclBaseName::createConstructor());
+    }
+
+    if (Bits.ClassDecl.ComputedHasMissingDesignatedInitializers)
+      return Bits.ClassDecl.HasMissingDesignatedInitializers;
+
+    return None;
+  }
+
+  void setHasMissingDesignatedInitializers(bool value) {
+    Bits.ClassDecl.HasMissingDesignatedInitializers = value;
+    Bits.ClassDecl.ComputedHasMissingDesignatedInitializers = true;
+  }
+
   /// Marks that this class inherits convenience initializers from its
   /// superclass.
   void setInheritsSuperclassInitializers(bool value) {
@@ -3843,6 +3862,7 @@ class ClassDecl final : public NominalTypeDecl {
   friend class SuperclassDeclRequest;
   friend class SuperclassTypeRequest;
   friend class EmittedMembersRequest;
+  friend class HasMissingDesignatedInitializersRequest;
   friend class InheritsSuperclassInitializersRequest;
   friend class TypeChecker;
 
@@ -3949,11 +3969,6 @@ class ClassDecl final : public NominalTypeDecl {
   /// initializers that cannot be represented in Swift.
   bool hasMissingDesignatedInitializers() const;
 
-  void setHasMissingDesignatedInitializers(bool newValue = true) {
-    Bits.ClassDecl.ComputedHasMissingDesignatedInitializers = 1;
-    Bits.ClassDecl.HasMissingDesignatedInitializers = newValue;
-  }
-
   /// Returns true if the class has missing members that require vtable entries.
   ///
   /// In this case, the class cannot be subclassed, because we cannot construct
@@ -3992,7 +4007,7 @@ class ClassDecl final : public NominalTypeDecl {
 
   /// Determine whether this class inherits the convenience initializers
   /// from its superclass.
-  bool inheritsSuperclassInitializers();
+  bool inheritsSuperclassInitializers() const;
 
   /// Walks the class hierarchy starting from this class, checking various
   /// conditions.

include/swift/AST/DiagnosticsModuleDiffer.def

@@ -98,6 +98,10 @@ ERROR(objc_name_change,none,"%0 has ObjC name change from %1 to %2", (StringRef,
 
 ERROR(desig_init_added,none,"%0 has been added as a designated initializer to an open class", (StringRef))
 
+ERROR(added_invisible_designated_init,none,"%0 has new designated initializers that are not visible to clients", (StringRef))
+
+ERROR(not_inheriting_convenience_inits,none,"%0 no longer inherits convenience inits from its superclass", (StringRef))
+
 #ifndef DIAG_NO_UNDEF
 # if defined(DIAG)
 #  undef DIAG

include/swift/AST/NameLookupRequests.h

@@ -161,6 +161,29 @@ class SuperclassDeclRequest :
   void cacheResult(ClassDecl *value) const;
 };
 
+/// Requests whether or not this class has designated initializers that are
+/// not public or @usableFromInline.
+class HasMissingDesignatedInitializersRequest :
+    public SimpleRequest<HasMissingDesignatedInitializersRequest,
+                         bool(ClassDecl *),
+                         CacheKind::SeparatelyCached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  llvm::Expected<bool>
+  evaluate(Evaluator &evaluator, ClassDecl *subject) const;
+
+public:
+  // Caching
+  bool isCached() const { return true; }
+  Optional<bool> getCachedResult() const;
+  void cacheResult(bool) const;
+};
+
 /// Request the nominal declaration extended by a given extension declaration.
 class ExtendedNominalRequest :
     public SimpleRequest<ExtendedNominalRequest,

include/swift/AST/NameLookupTypeIDZone.def

@@ -56,6 +56,9 @@ SWIFT_REQUEST(NameLookup, SelfBoundsFromWhereClauseRequest,
               Uncached, NoLocationInfo)
 SWIFT_REQUEST(NameLookup, SuperclassDeclRequest, ClassDecl *(NominalTypeDecl *),
               SeparatelyCached, NoLocationInfo)
+SWIFT_REQUEST(NameLookup, HasMissingDesignatedInitializersRequest,
+              bool(ClassDecl *),
+              SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(NameLookup, TypeDeclsFromWhereClauseRequest,
               DirectlyReferencedTypeDecls(ExtensionDecl *), Uncached,
               NoLocationInfo)

include/swift/IDE/DigesterEnums.def

@@ -132,6 +132,8 @@ KEY_BOOL(HasStorage, hasStorage)
 KEY_BOOL(ReqNewWitnessTableEntry, reqNewWitnessTableEntry)
 KEY_BOOL(IsABIPlaceholder, isABIPlaceholder)
 KEY_BOOL(IsExternal, isExternal)
+KEY_BOOL(HasMissingDesignatedInitializers, hasMissingDesignatedInitializers)
+KEY_BOOL(InheritsConvenienceInitializers, inheritsConvenienceInitializers)
 
 KEY(kind)
 

lib/AST/ASTPrinter.cpp

@@ -990,6 +990,22 @@ void PrintAST::printAttributes(const Decl *D) {
         Printer << " ";
       }
     }
+
+    // If the declaration has designated inits that won't be visible to
+    // clients, or if it inherits superclass convenience initializers,
+    // then print those attributes specially.
+    if (auto CD = dyn_cast<ClassDecl>(D)) {
+      if (Options.PrintImplicitAttrs) {
+        if (CD->inheritsSuperclassInitializers()) {
+          Printer.printAttrName("@_inheritsConvenienceInitializers");
+          Printer << " ";
+        }
+        if (CD->hasMissingDesignatedInitializers()) {
+          Printer.printAttrName("@_hasMissingDesignatedInitializers");
+          Printer << " ";
+        }
+      }
+    }
   }
 
   D->getAttrs().print(Printer, Options, D);

lib/AST/Decl.cpp

@@ -4127,15 +4127,11 @@ GetDestructorRequest::evaluate(Evaluator &evaluator, ClassDecl *CD) const {
   return DD;
 }
 
-
 bool ClassDecl::hasMissingDesignatedInitializers() const {
-  if (!Bits.ClassDecl.ComputedHasMissingDesignatedInitializers) {
-    auto *mutableThis = const_cast<ClassDecl *>(this);
-    mutableThis->Bits.ClassDecl.ComputedHasMissingDesignatedInitializers = 1;
-    (void)mutableThis->lookupDirect(DeclBaseName::createConstructor());
-  }
-
-  return Bits.ClassDecl.HasMissingDesignatedInitializers;
+  return evaluateOrDefault(
+      getASTContext().evaluator,
+      HasMissingDesignatedInitializersRequest{const_cast<ClassDecl *>(this)},
+      false);
 }
 
 bool ClassDecl::hasMissingVTableEntries() const {
@@ -4158,7 +4154,7 @@ bool ClassDecl::isIncompatibleWithWeakReferences() const {
   return false;
 }
 
-bool ClassDecl::inheritsSuperclassInitializers() {
+bool ClassDecl::inheritsSuperclassInitializers() const {
   // If there's no superclass, there's nothing to inherit.
   if (!getSuperclass())
     return false;

lib/AST/NameLookupRequests.cpp

@@ -67,6 +67,47 @@ void SuperclassDeclRequest::cacheResult(ClassDecl *value) const {
     protocolDecl->LazySemanticInfo.SuperclassDecl.setPointerAndInt(value, true);
 }
 
+//----------------------------------------------------------------------------//
+// Missing designated initializers computation
+//----------------------------------------------------------------------------//
+
+Optional<bool> HasMissingDesignatedInitializersRequest::getCachedResult() const {
+  auto classDecl = std::get<0>(getStorage());
+  return classDecl->getCachedHasMissingDesignatedInitializers();
+}
+
+void HasMissingDesignatedInitializersRequest::cacheResult(bool result) const {
+  auto classDecl = std::get<0>(getStorage());
+  classDecl->setHasMissingDesignatedInitializers(result);
+}
+
+llvm::Expected<bool>
+HasMissingDesignatedInitializersRequest::evaluate(Evaluator &evaluator,
+                                           ClassDecl *subject) const {
+  // Short-circuit and check for the attribute here.
+  if (subject->getAttrs().hasAttribute<HasMissingDesignatedInitializersAttr>())
+    return true;
+
+  AccessScope scope =
+    subject->getFormalAccessScope(/*useDC*/nullptr,
+                                  /*treatUsableFromInlineAsPublic*/true);
+  // This flag only makes sense for public types that will be written in the
+  // module.
+  if (!scope.isPublic())
+    return false;
+
+  auto constructors = subject->lookupDirect(DeclBaseName::createConstructor());
+  return llvm::any_of(constructors, [&](ValueDecl *decl) {
+    auto init = cast<ConstructorDecl>(decl);
+    if (!init->isDesignatedInit())
+      return false;
+    AccessScope scope =
+        init->getFormalAccessScope(/*useDC*/nullptr,
+                                   /*treatUsableFromInlineAsPublic*/true);
+    return !scope.isPublic();
+  });
+}
+
 //----------------------------------------------------------------------------//
 // Extended nominal computation.
 //----------------------------------------------------------------------------//

lib/ClangImporter/ImportDecl.cpp

@@ -7695,7 +7695,8 @@ ClangImporter::Implementation::importDeclImpl(const clang::NamedDecl *ClangDecl,
         if (getClangModuleForDecl(theClass) == getClangModuleForDecl(method)) {
           if (auto swiftClass = castIgnoringCompatibilityAlias<ClassDecl>(
                   importDecl(theClass, CurrentVersion))) {
-            swiftClass->setHasMissingDesignatedInitializers();
+            SwiftContext.evaluator.cacheOutput(
+                HasMissingDesignatedInitializersRequest{swiftClass}, true);
           }
         }
       }

lib/Sema/CodeSynthesis.cpp

@@ -1002,13 +1002,18 @@ static void addImplicitInheritedConstructorsToClass(ClassDecl *decl) {
 llvm::Expected<bool>
 InheritsSuperclassInitializersRequest::evaluate(Evaluator &eval,
                                                 ClassDecl *decl) const {
+  // Check if we parsed the @_inheritsConvenienceInitializers attribute.
+  if (decl->getAttrs().hasAttribute<InheritsConvenienceInitializersAttr>())
+    return true;
+
   auto superclass = decl->getSuperclass();
   assert(superclass);
 
   // If the superclass has known-missing designated initializers, inheriting
   // is unsafe.
   auto *superclassDecl = superclass->getClassOrBoundGenericClass();
-  if (superclassDecl->hasMissingDesignatedInitializers())
+  if (superclassDecl->getModuleContext() != decl->getParentModule() &&
+      superclassDecl->hasMissingDesignatedInitializers())
     return false;
 
   // If we're allowed to inherit designated initializers, then we can inherit