Enable SE-0328 "Structural opaque result types" by default.

Remove the error that prevented the use of multiple opaque result types,
which was the remaining blocker for SE-0328's structural opaque result
types. Add some type checking tests for this feature, and customize
the diagnostics so they describe *which* opaque result type failed to
match when indeed there is a failure.

Author: DougGregor

Diff for: include/swift/AST/Decl.h

@@ -2746,15 +2746,6 @@ class OpaqueTypeDecl final :
     return getNumOpaqueReturnTypeReprs();
   }
 
-  /// Retrieve the buffer containing the opaque return type
-  /// representations that correspond to the opaque generic parameters.
-  ArrayRef<OpaqueReturnTypeRepr *> getOpaqueReturnTypeReprs() const {
-    return {
-      getTrailingObjects<OpaqueReturnTypeRepr *>(),
-      getNumOpaqueReturnTypeReprs()
-    };
-  }
-
 public:
   static OpaqueTypeDecl *get(
       ValueDecl *NamingDecl, GenericParamList *GenericParams,
@@ -2793,6 +2784,15 @@ class OpaqueTypeDecl final :
     return OpaqueInterfaceGenericSignature.getInnermostGenericParams();
   }
 
+  /// Retrieve the buffer containing the opaque return type
+  /// representations that correspond to the opaque generic parameters.
+  ArrayRef<OpaqueReturnTypeRepr *> getOpaqueReturnTypeReprs() const {
+    return {
+      getTrailingObjects<OpaqueReturnTypeRepr *>(),
+      getNumOpaqueReturnTypeReprs()
+    };
+  }
+
   /// The underlying interface type describing the whole opaque type.
   ///
   /// FIXME: Structured opaque types will generalize this to an

Diff for: include/swift/AST/DiagnosticsSema.def

@@ -1876,9 +1876,6 @@ ERROR(opaque_type_invalid_constraint,none,
       "and/or a base class", ())
 NOTE(opaque_of_optional_rewrite,none,
       "did you mean to write an optional of an 'opaque' type?", ())
-ERROR(more_than_one_opaque_type,none,
-      "%0 contains multiple 'opaque' types, but only one 'opaque' type is "
-      "supported", (TypeRepr*))
 ERROR(inferred_opaque_type,none,
       "property definition has inferred type %0, involving the 'some' "
       "return type of another declaration", (Type))
@@ -4135,8 +4132,8 @@ ERROR(opaque_type_no_underlying_type_candidates,none,
       "function declares an opaque return type, but has no return statements "
       "in its body from which to infer an underlying type", ())
 ERROR(opaque_type_mismatched_underlying_type_candidates,none,
-      "function declares an opaque return type, but the return statements "
-      "in its body do not have matching underlying types", ())
+      "function declares an opaque return type %0, but the return statements "
+      "in its body do not have matching underlying types", (TypeRepr *))
 NOTE(opaque_type_underlying_type_candidate_here,none,
      "return statement has underlying type %0", (Type))
 ERROR(opaque_type_self_referential_underlying_type,none,

Diff for: lib/Sema/MiscDiagnostics.cpp

@@ -2651,12 +2651,36 @@ class OpaqueUnderlyingTypeChecker : public ASTWalker {
                       return canonicalUnderlyingSubs != otherCandidate.second.getCanonical();
                     });
     if (mismatch) {
+      unsigned mismatchIndex = OpaqueDecl->getOpaqueGenericParams().size();
+      for (auto genericParam : OpaqueDecl->getOpaqueGenericParams()) {
+        unsigned index = genericParam->getIndex();
+        Type underlyingType = Candidates[0].second.getReplacementTypes()[index];
+        bool found = false;
+        for (const auto &candidate : Candidates) {
+          Type otherType = candidate.second.getReplacementTypes()[index];
+          if (!underlyingType->isEqual(otherType)) {
+            mismatchIndex = index;
+            found = true;
+            break;
+          }
+        }
+
+        if (found)
+          break;
+      }
+      assert(mismatchIndex < OpaqueDecl->getOpaqueGenericParams().size());
+      TypeRepr *opaqueRepr =
+          OpaqueDecl->getOpaqueReturnTypeReprs()[mismatchIndex];
       Implementation->diagnose(
-          diag::opaque_type_mismatched_underlying_type_candidates);
+          diag::opaque_type_mismatched_underlying_type_candidates,
+          opaqueRepr)
+        .highlight(opaqueRepr->getSourceRange());
+
       for (auto candidate : Candidates) {
-        Ctx.Diags.diagnose(candidate.first->getLoc(),
-                           diag::opaque_type_underlying_type_candidate_here,
-                           candidate.second.getReplacementTypes()[0]);
+        Ctx.Diags.diagnose(
+           candidate.first->getLoc(),
+           diag::opaque_type_underlying_type_candidate_here,
+           candidate.second.getReplacementTypes()[mismatchIndex]);
       }
       return;
     }
@@ -2672,9 +2696,10 @@ class OpaqueUnderlyingTypeChecker : public ASTWalker {
       });
 
       if (isSelfReferencing) {
+        unsigned index = genericParam->getIndex();
         Ctx.Diags.diagnose(Candidates.front().first->getLoc(),
                            diag::opaque_type_self_referential_underlying_type,
-                           underlyingSubs.getReplacementTypes()[0]);
+                           underlyingSubs.getReplacementTypes()[index]);
         return;
       }
     }

Diff for: lib/Sema/TypeCheckGeneric.cpp

@@ -215,13 +215,6 @@ OpaqueResultTypeRequest::evaluate(Evaluator &evaluator,
     underlyingGenericParamType = interfaceSignature.getGenericParams()[0];
   } else {
     opaqueReprs = collectOpaqueReturnTypeReprs(repr);
-    if (opaqueReprs.size() > 1) {
-      ctx.Diags.diagnose(repr->getLoc(), diag::more_than_one_opaque_type, repr);
-      return nullptr;
-    }
-
-    // TODO [OPAQUE SUPPORT]: right now we only allow one structural 'some' type,
-    // but *very* soon we will allow more than one such type.
     SmallVector<GenericTypeParamType *, 2> genericParamTypes;
     SmallVector<Requirement, 2> requirements;
     for (unsigned i = 0; i < opaqueReprs.size(); ++i) {

Diff for: test/type/opaque.swift

@@ -76,7 +76,7 @@ struct Test {
 let zingle = {() -> some P in 1 } // expected-error{{'some' types are only implemented}}
 
 
-func twoOpaqueTypes() -> (some P, some P) { return (1, 2) } // expected-error{{'(some P, some P)' contains multiple 'opaque' types, but only one 'opaque' type is supported}}
+func twoOpaqueTypes() -> (some P, some P) { return (1, 2) }
 func asArrayElem() -> [some P] { return [1] }
 
 // Invalid positions

Diff for: test/type/opaque_return_structural.swift

@@ -12,21 +12,17 @@ class C {}
 class D: P, Q { func paul() {}; func d() {} }
 
 
-// TODO: cases that we should support, but don't yet:
+func asUnwrappedOptionalBase() -> (some P)! { return 1 } // expected-warning{{using '!' is not allowed here; treating this as '?' instead}}
 //
-// WARNING: using '!' is not allowed here; treating this as '?' instead
-// func asUnwrappedOptionalBase() -> (some P)! { return 1 }
+// FIXME: We should be able to support this
+func asHOFRetRet() -> () -> some P { return { 1 } } // expected-error{{cannot convert value of type 'Int' to closure result type 'some P'}}
 //
-// ERROR: generic parameter 'τ_0_0' could not be inferred
-// func asHOFRetRet() -> () -> some P { return { 1 } }
-//
-// ERROR: function declares an opaque return type, but has no return statements in its body from which to infer an underlying type
-// func asHOFRetArg() -> (some P) -> () { return { (x: Int) -> () in } }
+func asHOFRetArg() -> (some P) -> () { return { (x: Int) -> () in } } // expected-error{{'some' cannot appear in parameter position in result type '(some P) -> ()'}}
 //
 // ERROR: 'some' types are only implemented for the declared type of properties and subscripts and the return type of functions
 // let x = { () -> some P in return 1 }
 
-func twoOpaqueTypes() -> (some P, some P) { return (1, 2) } // expected-error{{only one 'opaque' type is supported}}
+func twoOpaqueTypes() -> (some P, some P) { return (1, 2) }
 func asTupleElemBad() -> (P, some Q) { return (1, C()) } // expected-note{{opaque return type declared here}} expected-error{{requires that 'C' conform to 'Q'}}
 
 func asTupleElem() -> (P, some Q) { return (1, 2) }
@@ -96,3 +92,37 @@ typealias Takes<T> = (T) -> Void
 
 // expected-error@+1 {{'some' cannot appear in parameter position in result type 'Takes<some P>' (aka '(some P) -> ()')}}
 func indirectOpaqueParameter() -> Takes<some P> {}
+
+struct X<T, U> { }
+
+struct StructuralMethods {
+  func f1() -> X<(some P)?, [some Q]> {
+    return X<Int?, [String]>()
+  }
+
+  func f2(cond: Bool) -> X<(some P)?, [some Q]> {
+    if cond {
+      return X<Int?, [String]>()
+    } else {
+      return X<Int?, [String]>()
+    }
+  }
+
+  // TODO: Diagnostics here should be more clear about which "some" is the
+  // problem.
+  func f3(cond: Bool) -> X<(some P)?, [some Q]> { // expected-error{{function declares an opaque return type 'some P', but the return statements in its body do not have matching underlying types}}
+    if cond {
+      return X<String?, [String]>() // expected-note{{return statement has underlying type 'String'}}
+    } else {
+      return X<Int?, [String]>() // expected-note{{return statement has underlying type 'Int'}}
+    }
+  }
+
+  func f4(cond: Bool) -> X<(some P)?, [some Q]> { // expected-error{{function declares an opaque return type 'some Q', but the return statements in its body do not have matching underlying types}}
+    if cond {
+      return X<Int?, [String]>() // expected-note{{return statement has underlying type 'String'}}
+    } else {
+      return X<Int?, [Int]>() // expected-note{{return statement has underlying type 'Int'}}
+    }
+  }
+}