Merge pull request #27123 from hborla/missing-conformance-diag

[ConstraintSystem] Allow fixing missing conformance failures for `Void` and uninhabited types.

Author: hborla

lib/Sema/CSSimplify.cpp

@@ -3901,11 +3901,6 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
       return recordFix(fix) ? SolutionKind::Error : SolutionKind::Solved;
     }
 
-    // Let's not try to fix missing conformance for Void
-    // or Never because that doesn't really make sense.
-    if (type->isVoid() || type->isUninhabited())
-      return SolutionKind::Error;
-
     if (path.back().is<LocatorPathElt::AnyRequirement>()) {
       // If this is a requirement associated with `Self` which is bound
       // to `Any`, let's consider this "too incorrect" to continue.

test/Constraints/rdar44770297.swift

@@ -4,8 +4,8 @@ protocol P {
   associatedtype A
 }
 
-func foo<T: P>(_: () throws -> T) -> T.A? { // expected-note {{in call to function 'foo'}}
+func foo<T: P>(_: () throws -> T) -> T.A? { // expected-note {{where 'T' = 'Never'}}
   fatalError()
 }
 
-let _ = foo() {fatalError()} & nil // expected-error {{generic parameter 'T' could not be inferred}}
+let _ = foo() {fatalError()} & nil // expected-error {{global function 'foo' requires that 'Never' conform to 'P'}}

test/type/opaque.swift

@@ -172,8 +172,11 @@ func recursion(x: Int) -> some P {
   return recursion(x: x - 1)
 }
 
-// FIXME: We need to emit a better diagnostic than the failure to convert Never to opaque.
-func noReturnStmts() -> some P { fatalError() } // expected-error{{cannot convert return expression of type 'Never' to return type 'some P'}} expected-error{{no return statements}}
+func noReturnStmts() -> some P {} // expected-error {{function declares an opaque return type, but has no return statements in its body from which to infer an underlying type}}
+
+func returnUninhabited() -> some P { // expected-note {{opaque return type declared here}}
+    fatalError() // expected-error{{return type of global function 'returnUninhabited()' requires that 'Never' conform to 'P'}}
+}
 
 func mismatchedReturnTypes(_ x: Bool, _ y: Int, _ z: String) -> some P { // expected-error{{do not have matching underlying types}}
   if x {

validation-test/Sema/type_checker_crashers_fixed/rdar50869732.swift

@@ -10,7 +10,7 @@ struct Generic<T> {
 
 @_functionBuilder
 struct Builder {
-  static func buildBlock<C0, C1>(_ c0: C0, _ c1: C1)
+  static func buildBlock<C0, C1>(_ c0: C0, _ c1: C1) // expected-note {{where 'C0' = 'Empty'}} expected-note {{where 'C1' = 'Test<Empty>'}}
            -> Generic<(C0, C1)> where C0 : P, C1 : P {
     return Generic((c0, c1))
   }
@@ -24,11 +24,13 @@ struct Empty {
   init() {}
 }
 
-struct Test<T> where T : P {
+struct Test<T> where T : P { // expected-note {{where 'T' = 'Empty'}}
   init(@Builder _: () -> T) {}
 }
 
 let x = G {
+  // expected-error@-1 {{static method 'buildBlock' requires that 'Empty' conform to 'P'}}
+  // expected-error@-2 {{static method 'buildBlock' requires that 'Test<Empty>' conform to 'P'}}
   Empty()
-  Test { <#code#> } // expected-error {{editor placeholder in source file}}
+  Test { Empty() } // expected-error {{generic struct 'Test' requires that 'Empty' conform to 'P'}}
 }

validation-test/compiler_crashers_2_fixed/0196-rdar48937223.swift

@@ -2,10 +2,10 @@
 
 protocol P {}
 
-func fn<T, U: P>(_ arg1: T, arg2: (T) -> U) {}
+func fn<T, U: P>(_ arg1: T, arg2: (T) -> U) {} // expected-note {{where 'U' = '()'}}
 
 func test(str: String) {
-  fn(str) { arg in
+  fn(str) { arg in // expected-error {{global function 'fn(_:arg2:)' requires that '()' conform to 'P'}}
     <#FOO#> // expected-error {{editor placeholder in source file}}
   }
 }