[Constraint System] Kill the ArchetypeOpener; bind type variables instead. NFC

The ArchetypeOpener was used only to replace dependent types with
archetypes (or concrete types) within the opening context. We can do
the same simply by letting the constraint system create type variables
and then binding those type variables to the appropriate
archetypes/concrete types in that context.

Eliminate the two DependentTypeOpener entry points that were only used
by the ArchetypeOpener.

Author: DougGregor

lib/Sema/CSRanking.cpp

@@ -226,25 +226,6 @@ static Comparison compareWitnessAndRequirement(TypeChecker &tc, DeclContext *dc,
   return proto1? Comparison::Worse : Comparison::Better;
 }
 
-namespace {
-  /// Dependent type opener that maps from a dependent type to its corresponding
-  /// archetype in the given context.
-  class ArchetypeOpener : public constraints::DependentTypeOpener {
-    DeclContext *DC;
-
-  public:
-    explicit ArchetypeOpener(DeclContext *dc) : DC(dc) { }
-
-    virtual Type mapGenericTypeParamType(GenericTypeParamType *param) {
-      return ArchetypeBuilder::mapTypeIntoContext(DC, param);
-    }
-
-    virtual Type mapDependentMemberType(DependentMemberType *memberType) {
-      return ArchetypeBuilder::mapTypeIntoContext(DC, memberType);
-    }
-  };
-}
-
 namespace {
   /// Describes the relationship between the context types for two declarations.
   enum class SelfTypeRelationship {
@@ -596,10 +577,16 @@ static bool isDeclAsSpecializedAs(TypeChecker &tc, DeclContext *dc,
 
   // Get the type of a reference to the first declaration, swapping in
   // archetypes for the dependent types.
-  ArchetypeOpener opener(decl1->getInnermostDeclContext());
-  Type openedType1 = cs.openType(type1, locator,
-                                 decl1->getInnermostDeclContext(),
-                                 &opener);
+  llvm::DenseMap<CanType, TypeVariableType *> replacements;
+  auto dc1 = decl1->getInnermostDeclContext();
+  Type openedType1 = cs.openType(type1, locator, replacements, dc1);
+  for (const auto &replacement : replacements) {
+    if (auto mapped = ArchetypeBuilder::mapTypeIntoContext(dc1,
+                                                           replacement.first)) {
+      cs.addConstraint(ConstraintKind::Bind, replacement.second, mapped,
+                       locator);
+    }
+  }
 
   // Extract the self types from the declarations, if they have them.
   Type selfTy1;

lib/Sema/ConstraintSystem.cpp

@@ -570,13 +570,6 @@ namespace {
 
       // Replace a generic type parameter with its corresponding type variable.
       if (auto genericParam = type->getAs<GenericTypeParamType>()) {
-        if (opener) {
-          // If we have a mapping for this type parameter, there's nothing else to do.
-          if (Type replacement = opener->mapGenericTypeParamType(genericParam)){
-            return replacement;
-          }
-        }
-
         auto known = replacements.find(genericParam->getCanonicalType());
 
         if (known == replacements.end())
@@ -588,14 +581,6 @@ namespace {
       // Replace a dependent member with a fresh type variable and make it a
       // member of its base type.
       if (auto dependentMember = type->getAs<DependentMemberType>()) {
-        if (opener) {
-          // If we have a mapping for this type parameter, there's nothing else to do.
-          if (Type replacement
-                = opener->mapDependentMemberType(dependentMember)) {
-            return replacement;
-          }
-        }
-
         // Check whether we've already dealt with this dependent member.
         auto known = replacements.find(dependentMember->getCanonicalType());
         if (known != replacements.end())
@@ -940,10 +925,6 @@ void ConstraintSystem::openGeneric(
 
   // Create the type variables for the generic parameters.
   for (auto gp : params) {
-    // If we have a mapping for this type parameter, there's nothing else to do.
-    if (opener && opener->mapGenericTypeParamType(gp))
-      continue;
-
     ArchetypeType *archetype = ArchetypeBuilder::mapTypeIntoContext(dc, gp)
                                  ->castTo<ArchetypeType>();
     auto typeVar = createTypeVariable(getConstraintLocator(

lib/Sema/ConstraintSystem.h

@@ -979,18 +979,6 @@ class DependentTypeOpener {
 public:
   virtual ~DependentTypeOpener() { }
 
-  /// Directly map a generic type parameter to a type, or return null if
-  /// the type parameter should be opened.
-  virtual Type mapGenericTypeParamType(GenericTypeParamType *param) {
-    return Type();
-  }
-
-  /// Directly map a dependent member type to a type, or return null if
-  /// the dependent member type should be opened.
-  virtual Type mapDependentMemberType(DependentMemberType *memberType) {
-    return Type();
-  }
-
   /// Invoked when a generic type parameter is opened to a type variable.
   ///
   /// \param param The generic type parameter.