Properly substitute outer generic parameters in an opaque type environment.

When forming the generic signature of a generic environment for opaque
types, substitute for the outer generic parameters based on the provided
substitution map. We weren't able to do this before because the
substitution cannot be performed when there are interface types or
type variables involved. However, the lazy construction of this
generic signature and use of other queries on opaque type archetypes
ensures that we don't form new generic signatures until we have
concrete types to work with.

This enables same-type constraints amongst different opaque result types
and their associated types.

Author: DougGregor

lib/AST/GenericEnvironment.cpp

@@ -81,36 +81,9 @@ GenericSignature GenericEnvironment::getGenericSignature() const {
   // map.
   SmallVector<Requirement, 2> newRequirements;
 
-  // TODO: The proper thing to do to build the environment in which the opaque
-  // type's archetype exists would be to take the generic signature of the
-  // decl, feed it into a GenericSignatureBuilder, then add same-type
-  // constraints into the builder to bind the outer generic parameters
-  // to their substituted types provided by \c Substitutions. However,
-  // this is problematic for interface types. In a situation like this:
-  //
-  // __opaque_type Foo<t_0_0: P>: Q // internal signature <t_0_0: P, t_1_0: Q>
-  //
-  // func bar<t_0_0, t_0_1, t_0_2: P>() -> Foo<t_0_2>
-  //
-  // we'd want to feed the GSB constraints to form:
-  //
-  // <t_0_0: P, t_1_0: Q where t_0_0 == t_0_2>
-  //
-  // even though t_0_2 isn't *in* the generic signature being built; it
-  // represents a type
-  // bound elsewhere from some other generic context. If we knew the generic
-  // environment `t_0_2` came from, then maybe we could map it into that context,
-  // but currently we have no way to know that with certainty.
-  //
-  // Because opaque types are currently limited so that they only have immediate
-  // protocol constraints, and therefore don't interact with the outer generic
-  // parameters at all, we can get away without adding these constraints for now.
-  // Adding where clauses would break this hack.
-  auto opaqueDecl = getOpaqueTypeDecl();
-
-#if DO_IT_CORRECTLY
   // Same-type-constrain the arguments in the outer signature to their
   // replacements in the substitution map.
+  auto opaqueDecl = getOpaqueTypeDecl();
   auto subs = getOpaqueSubstitutions();
   if (auto outerSig = opaqueDecl->getGenericSignature()) {
     for (auto outerParam : outerSig.getGenericParams()) {
@@ -119,27 +92,7 @@ GenericSignature GenericEnvironment::getGenericSignature() const {
           Requirement(RequirementKind::SameType, Type(outerParam), boundType));
     }
   }
-#else
-  // Assert that there are no same type constraints on the opaque type or its
-  // associated types.
-  //
-  // This should not be possible until we add where clause support, with the
-  // exception of generic base class constraints (handled below).
-  (void)newRequirements;
-# ifndef NDEBUG
-  for (auto req : opaqueDecl
-                    ->getOpaqueInterfaceGenericSignature().getRequirements()) {
-    auto reqBase = req.getFirstType()->getRootGenericParam();
-    if (reqBase->getDepth() ==
-            opaqueDecl->getOpaqueGenericParams().front()->getDepth()) {
-      assert(req.getKind() != RequirementKind::SameType
-             && "supporting where clauses on opaque types requires correctly "
-                "setting up the generic environment for "
-                "OpaqueTypeArchetypeTypes; see comment above");
-    }
-  }
-# endif
-#endif
+
   auto signature = buildGenericSignature(
         opaqueDecl->getASTContext(),
         opaqueDecl->getOpaqueInterfaceGenericSignature(),

test/type/opaque_return_named.swift

@@ -107,7 +107,8 @@ protocol DefaultInitializable {
 extension String: DefaultInitializable { }
 extension Int: DefaultInitializable { }
 
-struct Generic<T: P1 & Equatable & DefaultInitializable> {
+struct Generic<T: P1 & Equatable & DefaultInitializable>
+    where T.A: DefaultInitializable {
   var value: T
 
   func f() -> <U: Q1, V: P1 where U: Equatable, V: Equatable> (U, V) {
@@ -131,6 +132,18 @@ struct Generic<T: P1 & Equatable & DefaultInitializable> {
       print("here")
     }
   }
+
+  // FIXME: expected-warning@+2{{redundant same-type constraint 'C.Element' == 'T.A'}}
+  // FIXME: expected-note@+1{{previous same-type constraint 'C.Element' == 'T.A' written here}}
+  func sameTypeParams() -> <C: Collection where C.Element == T.A> C {
+    [ T.A(), T.A() ]
+  }
+
+  // FIXME: expected-warning@+2{{redundant same-type constraint 'C.Element' == 'T.A'}}
+  // FIXME: expected-note@+1{{previous same-type constraint 'C.Element' == 'T.A' written here}}
+  func sameTypeParamsBad() -> <C: Collection where C.Element == T.A> C {
+    [ T() ] // expected-error{{cannot convert value of type 'T' to expected element type 'T.A'}}
+  }
 }
 
 func testGeneric(i: Int, gs: Generic<String>, gi: Generic<Int>) {