Merge pull request #72628 from xedin/opaque-return-diag-improvements-6.0

[6.0][CSDiagnostics] Add a few tailored diagnostics for opaque return type requirements mismatches

Author: xedin

include/swift/AST/DiagnosticsSema.def

@@ -2687,6 +2687,12 @@ ERROR(type_does_not_conform_anyobject_decl_owner,none,
 ERROR(type_does_not_conform_in_opaque_return,none,
       "return type of %kind0 requires that %1 %select{conform to %2|be a class type}3",
       (const ValueDecl *, Type, Type, bool))
+ERROR(type_is_not_equal_in_opaque_return,none,
+      "return type of %kind0 requires the types %1 and %2 be equivalent",
+      (const ValueDecl *, Type, Type))
+ERROR(types_not_inherited_in_opaque_return,none,
+      "return type of %kind0 requires that %1 inherit from %2",
+      (const ValueDecl *, Type, Type))
 ERROR(types_not_equal_decl,none,
       "%kind0 requires the types %1 and %2 be equivalent",
       (const ValueDecl *, Type, Type))

lib/Sema/CSDiagnostics.cpp

@@ -455,8 +455,28 @@ bool RequirementFailure::diagnoseAsError() {
 
   if (auto *OTD = dyn_cast<OpaqueTypeDecl>(AffectedDecl)) {
     auto *namingDecl = OTD->getNamingDecl();
-    emitDiagnostic(diag::type_does_not_conform_in_opaque_return,
-                   namingDecl, lhs, rhs, rhs->isAnyObject());
+
+    auto &req = getRequirement();
+    switch (req.getKind()) {
+    case RequirementKind::Conformance:
+    case RequirementKind::Layout:
+      emitDiagnostic(diag::type_does_not_conform_in_opaque_return, namingDecl,
+                     lhs, rhs, rhs->isAnyObject());
+      break;
+
+    case RequirementKind::Superclass:
+      emitDiagnostic(diag::types_not_inherited_in_opaque_return, namingDecl,
+                    lhs, rhs);
+      break;
+
+    case RequirementKind::SameType:
+      emitDiagnostic(diag::type_is_not_equal_in_opaque_return, namingDecl, lhs,
+                     rhs);
+      break;
+
+    case RequirementKind::SameShape:
+      return false;
+    }
 
     if (auto *repr = namingDecl->getOpaqueResultTypeRepr()) {
       emitDiagnosticAt(repr->getLoc(), diag::opaque_return_type_declared_here)

test/type/opaque.swift

@@ -590,3 +590,31 @@ func f62787_1(x: Bool) -> Optional<some Collection<Int>> {
   } 
   return nil // expected-error{{underlying type for opaque result type 'Optional<some Collection<Int>>' could not be inferred from return expression}}
 }
+
+// rdar://124482122 - Make sure that constraints are respected by opaque types
+protocol P3<A> {
+  associatedtype A: P1
+}
+
+do {
+  struct G<A: P1>: P3 {}
+
+  struct S: P1 {}
+
+  class A {}
+
+  func test1() -> some P3<Int> { // expected-note {{opaque return type declared here}}
+    return G<S>()
+    // expected-error@-1 {{return type of local function 'test1()' requires the types 'S' and 'Int' be equivalent}}
+  }
+
+  func test2() -> some P3<G<S>> { // expected-note {{opaque return type declared here}}
+    return G<S>()
+    // expected-error@-1 {{return type of local function 'test2()' requires the types 'S' and 'G<S>' be equivalent}}
+  }
+
+  func test3() -> some P1 & A { // expected-note {{opaque return type declared here}}
+    S()
+    // expected-error@-1 {{return type of local function 'test3()' requires that 'S' inherit from 'A'}}
+  }
+}

test/type/parameterized_protocol.swift

@@ -158,7 +158,7 @@ struct OpaqueTypes<E> {
   func returnSequenceOfIntBad() -> some Sequence<Int> {
     // expected-note@-1 {{opaque return type declared here}}
     return ConcreteSequence<E>()
-    // expected-error@-1 {{return type of instance method 'returnSequenceOfIntBad()' requires that 'E' conform to 'Int'}}
+    // expected-error@-1 {{return type of instance method 'returnSequenceOfIntBad()' requires the types 'E' and 'Int' be equivalent}}
   }
 
   // Invalid