Eliminate use of the opaque type's generic environment from type matching.

Introduce a new primitive operation on opaque type archetypes that
canonicalizes a type within the environment of the opaque type
archetype without building the environment itself. Use it when matching
opaque archetype types in the solver.

Author: DougGregor

include/swift/AST/Types.h

@@ -5587,7 +5587,11 @@ class OpaqueTypeArchetypeType final : public ArchetypeType,
 
   /// Get a generic environment that has this opaque archetype bound within it.
   GenericEnvironment *getGenericEnvironment() const;
-  
+
+  /// Compute the canonical interface type within the environment of this
+  /// opaque type archetype.
+  CanType getCanonicalInterfaceType(Type interfaceType);
+
   static bool classof(const TypeBase *T) {
     return T->getKind() == TypeKind::OpaqueTypeArchetype;
   }

lib/AST/Type.cpp

@@ -3304,6 +3304,63 @@ SequenceArchetypeType::SequenceArchetypeType(
   assert(cast<GenericTypeParamType>(InterfaceType.getPointer())->isTypeSequence());
 }
 
+namespace {
+
+/// Substitute the outer generic parameters from a substitution map, ignoring
+/// innter generic parameters with a given depth.
+struct SubstituteOuterFromSubstitutionMap {
+  SubstitutionMap subs;
+  unsigned depth;
+
+  /// Whether this is a type parameter that should not be substituted.
+  bool isUnsubstitutedTypeParameter(Type type) const {
+    if (!type->isTypeParameter())
+      return false;
+
+    if (auto depMemTy = type->getAs<DependentMemberType>())
+      return isUnsubstitutedTypeParameter(depMemTy->getBase());
+
+    if (auto genericParam = type->getAs<GenericTypeParamType>())
+      return genericParam->getDepth() >= depth;
+
+    return false;
+  }
+
+  Type operator()(SubstitutableType *type) const {
+    if (isUnsubstitutedTypeParameter(type))
+      return Type(type);
+
+    return QuerySubstitutionMap{subs}(type);
+  }
+
+  ProtocolConformanceRef operator()(CanType dependentType,
+                                    Type conformingReplacementType,
+                                    ProtocolDecl *conformedProtocol) const {
+    if (isUnsubstitutedTypeParameter(dependentType))
+      return ProtocolConformanceRef(conformedProtocol);
+
+    return LookUpConformanceInSubstitutionMap(subs)(
+        dependentType, conformingReplacementType, conformedProtocol);
+  }
+};
+
+}
+
+CanType OpaqueTypeArchetypeType::getCanonicalInterfaceType(Type interfaceType) {
+  // Compute the canonical type within the generic signature of the opaque
+  // type declaration.
+  auto sig = getDecl()->getOpaqueInterfaceGenericSignature();
+  CanType canonicalType = interfaceType->getCanonicalType(sig);
+  if (!interfaceType->hasTypeParameter())
+    return canonicalType;
+
+  // Substitute outer generic parameters only.
+  unsigned opaqueDepth =
+    getDecl()->getOpaqueGenericParams().front()->getDepth();
+  SubstituteOuterFromSubstitutionMap replacer{Substitutions, opaqueDepth};
+  return canonicalType.subst(replacer, replacer)->getCanonicalType();
+}
+
 GenericEnvironment *OpaqueTypeArchetypeType::getGenericEnvironment() const {
   if (Environment)
     return Environment;

lib/Sema/CSSimplify.cpp

@@ -2851,12 +2851,10 @@ ConstraintSystem::matchDeepEqualityTypes(Type type1, Type type2,
     auto arch2 = type2->castTo<ArchetypeType>();
     auto opaque1 = cast<OpaqueTypeArchetypeType>(arch1->getRoot());
     auto opaque2 = cast<OpaqueTypeArchetypeType>(arch2->getRoot());
-    assert(arch1->getInterfaceType()->getCanonicalType(
-                      opaque1->getGenericEnvironment()->getGenericSignature())
-        == arch2->getInterfaceType()->getCanonicalType(
-                      opaque2->getGenericEnvironment()->getGenericSignature()));
     assert(opaque1->getDecl() == opaque2->getDecl());
-    
+    assert(opaque1->getCanonicalInterfaceType(arch1->getInterfaceType())->isEqual(
+               opaque2->getCanonicalInterfaceType(arch2->getInterfaceType())));
+
     auto args1 = opaque1->getSubstitutions().getReplacementTypes();
     auto args2 = opaque2->getSubstitutions().getReplacementTypes();
 
@@ -5896,13 +5894,11 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
       auto rootOpaque1 = dyn_cast<OpaqueTypeArchetypeType>(nested1->getRoot());
       auto rootOpaque2 = dyn_cast<OpaqueTypeArchetypeType>(nested2->getRoot());
       if (rootOpaque1 && rootOpaque2) {
-        auto interfaceTy1 = nested1->getInterfaceType()
-          ->getCanonicalType(rootOpaque1->getGenericEnvironment()
-                                        ->getGenericSignature());
-        auto interfaceTy2 = nested2->getInterfaceType()
-          ->getCanonicalType(rootOpaque2->getGenericEnvironment()
-                                        ->getGenericSignature());
-        if (interfaceTy1 == interfaceTy2
+        auto interfaceTy1 = rootOpaque1->getCanonicalInterfaceType(
+            nested1->getInterfaceType());
+        auto interfaceTy2 = rootOpaque2->getCanonicalInterfaceType(
+            nested2->getInterfaceType());
+        if (interfaceTy1->isEqual(interfaceTy2)
             && rootOpaque1->getDecl() == rootOpaque2->getDecl()) {
           conversionsOrFixes.push_back(ConversionRestrictionKind::DeepEquality);
           break;