Fix missing diagnostics about the lack of initializers in cross-module inheritance scenarios

lib/Sema/CodeSynthesis.cpp

@@ -826,6 +826,7 @@ createDesignatedInitOverride(ClassDecl *classDecl,
 static void diagnoseMissingRequiredInitializer(
               ClassDecl *classDecl,
               ConstructorDecl *superInitializer,
+              bool downgradeToWarning,
               ASTContext &ctx) {
   // Find the location at which we should insert the new initializer.
   SourceLoc insertionLoc;
@@ -906,6 +907,7 @@ static void diagnoseMissingRequiredInitializer(
   ctx.Diags.diagnose(insertionLoc, diag::required_initializer_missing,
                      superInitializer->getName(),
                      superInitializer->getDeclContext()->getDeclaredInterfaceType())
+    .warnUntilSwiftVersionIf(downgradeToWarning, 6)
     .fixItInsert(insertionLoc, initializerText);
 
   ctx.Diags.diagnose(findNonImplicitRequiredInit(superInitializer),
@@ -1172,10 +1174,11 @@ static void addImplicitInheritedConstructorsToClass(ClassDecl *decl) {
   bool defaultInitable =
       areAllStoredPropertiesDefaultInitializable(ctx.evaluator, decl);
 
-  // We can't define these overrides if we have any uninitialized
-  // stored properties.
-  if (!defaultInitable && !foundDesignatedInit)
-    return;
+  // In cases where we can't define any overrides, we used to suppress
+  // diagnostics about missing required initializers. Now we emit diagnostics,
+  // but downgrade them to warnings prior to Swift 6.
+  bool downgradeRequiredInitsToWarning =
+      !defaultInitable && !foundDesignatedInit;
 
   SmallVector<ConstructorDecl *, 4> nonOverriddenSuperclassCtors;
   collectNonOveriddenSuperclassInits(decl, nonOverriddenSuperclassCtors);
@@ -1187,8 +1190,10 @@ static void addImplicitInheritedConstructorsToClass(ClassDecl *decl) {
       if (superclassCtor->isRequired()) {
         assert(superclassCtor->isInheritable() &&
                "factory initializers cannot be 'required'");
-        if (!decl->inheritsSuperclassInitializers())
-          diagnoseMissingRequiredInitializer(decl, superclassCtor, ctx);
+        if (!decl->inheritsSuperclassInitializers()) {
+          diagnoseMissingRequiredInitializer(
+              decl, superclassCtor, downgradeRequiredInitsToWarning, ctx);
+        }
       }
       continue;
     }
@@ -1204,12 +1209,18 @@ static void addImplicitInheritedConstructorsToClass(ClassDecl *decl) {
 
     // Diagnose a missing override of a required initializer.
     if (superclassCtor->isRequired() && !inheritDesignatedInits) {
-      diagnoseMissingRequiredInitializer(decl, superclassCtor, ctx);
+      diagnoseMissingRequiredInitializer(
+          decl, superclassCtor, downgradeRequiredInitsToWarning, ctx);
       continue;
     }
 
     // A designated or required initializer has not been overridden.
 
+    // We can't define any overrides if we have any uninitialized
+    // stored properties.
+    if (!defaultInitable && !foundDesignatedInit)
+      continue;
+
     bool alreadyDeclared = false;
 
     auto results = decl->lookupDirect(DeclBaseName::createConstructor());

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -1372,11 +1372,14 @@ static std::string getFixItStringForDecodable(ClassDecl *CD,
 }
 
 /// Diagnose a class that does not have any initializers.
-static void diagnoseClassWithoutInitializers(ClassDecl *classDecl) {
+static void diagnoseClassWithoutInitializers(
+    ClassDecl *classDecl, bool downgradeToWarning
+) {
   ASTContext &C = classDecl->getASTContext();
   C.Diags.diagnose(classDecl, diag::class_without_init,
                    classDecl->isExplicitActor(),
-                   classDecl->getDeclaredType());
+                   classDecl->getDeclaredType())
+      .warnUntilSwiftVersionIf(downgradeToWarning, 6);
 
   // HACK: We've got a special case to look out for and diagnose specifically to
   // improve the experience of seeing this, and mitigate some confusion.
@@ -1546,19 +1549,31 @@ static void maybeDiagnoseClassWithoutInitializers(ClassDecl *classDecl) {
       classDecl->inheritsSuperclassInitializers())
     return;
 
+  bool downgradeToWarning = false;
   auto *superclassDecl = classDecl->getSuperclassDecl();
   if (superclassDecl &&
       superclassDecl->getModuleContext() != classDecl->getModuleContext() &&
-      superclassDecl->hasMissingDesignatedInitializers())
-    return;
+      superclassDecl->hasMissingDesignatedInitializers()) {
+    // Objective-C classes might have missing designated initializers because
+    // they couldn't be imported. For historical reasons, we allow the
+    // Swift-defined subclasses to have no
+    if (superclassDecl->hasClangNode() && superclassDecl->isObjC())
+      return;
+
+    // Historically, Swift-defined classes with missing designated
+    // initializers could be subclassed from other modules without defining
+    // any initializers. Downgrade the error to a warning prior to Swift 6
+    // to smooth the transition.
+    downgradeToWarning = true;
+  }
 
   for (auto member : classDecl->lookupDirect(DeclBaseName::createConstructor())) {
     auto ctor = dyn_cast<ConstructorDecl>(member);
     if (ctor && ctor->isDesignatedInit())
       return;
   }
 
-  diagnoseClassWithoutInitializers(classDecl);
+  diagnoseClassWithoutInitializers(classDecl, downgradeToWarning);
 }
 
 /// Determines if a given TypeLoc is module qualified by checking if it's

test/decl/class/inheritance_across_modules.swift

@@ -0,0 +1,31 @@
+// RUN: rm -rf %t
+// RUN: split-file %s %t
+
+// RUN: %target-swift-frontend -emit-module-path %t/MyModule.swiftmodule %t/Inputs/MyModule.swift
+
+// RUN: %target-swift-frontend -typecheck -verify -I %t %t/test.swift
+
+//--- Inputs/MyModule.swift
+open class MySuperclassA {
+  required public init() { }
+  internal init(boop: Bool) {}
+}
+
+open class MySuperclassB {
+}
+
+//--- test.swift
+import MyModule
+
+class MySubclassA: MySuperclassA {
+  // expected-warning{{'required' initializer 'init()' must be provided by subclass of 'MySuperclassA'; this is an error in Swift 6}}
+  // expected-warning@-2{{class 'MySubclassA' has no initializers; this is an error in Swift 6}}
+  var hi: String
+  // expected-note@-1{{stored property 'hi' without initial value prevents synthesized initializers}}
+}
+
+class MySubclassB: MySuperclassB {
+  // expected-warning@-1{{class 'MySubclassB' has no initializers; this is an error in Swift 6}}
+  var hi: String
+  // expected-note@-1{{stored property 'hi' without initial value prevents synthesized initializers}}
+}