Sema: Remove replacementsPtr parameter from getTypeOfMemberReference()

Author: slavapestov

include/swift/Sema/ConstraintSystem.h

@@ -4462,8 +4462,7 @@ class ConstraintSystem {
   /// \returns the opened type and the thrown error type.
   std::pair<Type, Type> getTypeOfMemberReferenceImpl(
       OverloadChoice choice, DeclContext *useDC, ConstraintLocator *locator,
-      SmallVectorImpl<OpenedType> *replacements = nullptr,
-      PreparedOverloadBuilder *preparedOverload = nullptr);
+      PreparedOverloadBuilder *preparedOverload);
 
   /// Retrieve the type of a reference to the given value declaration,
   /// as a member with a base of the given type.
@@ -4475,8 +4474,7 @@ class ConstraintSystem {
   /// \returns a description of the type of this declaration reference.
   DeclReferenceType getTypeOfMemberReference(
       OverloadChoice choice, DeclContext *useDC, ConstraintLocator *locator,
-      SmallVectorImpl<OpenedType> *replacements = nullptr,
-      PreparedOverloadBuilder *preparedOverload = nullptr);
+      PreparedOverloadBuilder *preparedOverload);
 
   /// Retrieve a list of generic parameter types solver has "opened" (replaced
   /// with a type variable) at the given location.

lib/Sema/TypeCheckProtocol.cpp

@@ -1168,21 +1168,21 @@ swift::matchWitness(WitnessChecker::RequirementEnvironmentCache &reqEnvCache,
     Type selfTy = proto->getSelfInterfaceType().subst(reqSubMap);
 
     // Open up the type of the requirement.
-    SmallVector<OpenedType, 4> reqReplacements;
-
     reqLocator =
         cs->getConstraintLocator(req, ConstraintLocator::ProtocolRequirement);
     OverloadChoice reqChoice(selfTy, req, FunctionRefInfo::doubleBaseNameApply());
     auto reqTypeInfo =
-        cs->getTypeOfMemberReference(reqChoice, dc, reqLocator, &reqReplacements);
+        cs->getTypeOfMemberReference(reqChoice, dc, reqLocator,
+                                     /*preparedOverload=*/nullptr);
+
     reqType = reqTypeInfo.adjustedReferenceType;
     reqType = reqType->getRValueType();
 
     Type reqThrownError = reqTypeInfo.thrownErrorTypeOnAccess;
 
     // For any type parameters we replaced in the witness, map them
     // to the corresponding archetypes in the witness's context.
-    for (const auto &replacement : reqReplacements) {
+    for (const auto &replacement : cs->getOpenedTypes(reqLocator)) {
       auto replacedInReq = Type(replacement.first).subst(reqSubMap);
 
       // If substitution failed, skip the requirement. This only occurs in
@@ -1210,7 +1210,6 @@ swift::matchWitness(WitnessChecker::RequirementEnvironmentCache &reqEnvCache,
       openWitnessTypeInfo =
           cs->getTypeOfMemberReference(witnessChoice, dc,
                                        witnessLocator,
-                                       /*replacements=*/nullptr,
                                        /*preparedOverload=*/nullptr);
     } else {
       OverloadChoice witnessChoice(Type(), witness, FunctionRefInfo::doubleBaseNameApply());

lib/Sema/TypeOfReference.cpp

@@ -1858,7 +1858,7 @@ static FunctionType *applyOptionality(ValueDecl *value, FunctionType *fnTy) {
 std::pair<Type, Type>
 ConstraintSystem::getTypeOfMemberReferenceImpl(
     OverloadChoice choice, DeclContext *useDC,
-    ConstraintLocator *locator, SmallVectorImpl<OpenedType> *replacementsPtr,
+    ConstraintLocator *locator,
     PreparedOverloadBuilder *preparedOverload) {
   ASSERT(!!preparedOverload == PreparingOverload);
 
@@ -1888,28 +1888,23 @@ ConstraintSystem::getTypeOfMemberReferenceImpl(
   auto genericSig = innerDC->getGenericSignatureOfContext();
 
   // Open the type of the generic function or member of a generic type.
-  ArrayRef<OpenedType> replacements;
-  SmallVector<OpenedType, 4> localReplacements;
-  {
-    auto &_replacements = replacementsPtr ? *replacementsPtr : localReplacements;
-
-    // If we have a generic signature, open the parameters. We delay opening
-    // requirements to allow contextual types to affect the situation.
-    if (genericSig) {
-      openGenericParameters(outerDC, genericSig, _replacements, locator,
-                            preparedOverload);
-    }
+  SmallVector<OpenedType, 4> replacements;
 
-    // If we opened up any type variables, record the replacements. We do this
-    // up-front to allow requirement fix coalescing logic to work correctly with
-    // requirements imposed on base type (since that relies on being able to
-    // find the recorded opened type). We then make the array immutable for the
-    // following logic to ensure they don't attempt to add any additional opened
-    // types.
-    recordOpenedTypes(locator, _replacements, preparedOverload);
-    replacements = _replacements;
+  // If we have a generic signature, open the parameters. We delay opening
+  // requirements to allow contextual types to affect the situation.
+  if (genericSig) {
+    openGenericParameters(outerDC, genericSig, replacements, locator,
+                          preparedOverload);
   }
 
+  // If we opened up any type variables, record the replacements. We do this
+  // up-front to allow requirement fix coalescing logic to work correctly with
+  // requirements imposed on base type (since that relies on being able to
+  // find the recorded opened type). We then make the array immutable for the
+  // following logic to ensure they don't attempt to add any additional opened
+  // types.
+  recordOpenedTypes(locator, replacements, preparedOverload);
+
   // Check to see if the self parameter is applied, in which case we'll want to
   // strip it off later.
   auto hasAppliedSelf = doesMemberRefApplyCurriedSelf(baseRValueTy, value);
@@ -2039,7 +2034,6 @@ ConstraintSystem::getTypeOfMemberReferenceImpl(
 
 DeclReferenceType ConstraintSystem::getTypeOfMemberReference(
     OverloadChoice choice, DeclContext *useDC, ConstraintLocator *locator,
-    SmallVectorImpl<OpenedType> *replacementsPtr,
     PreparedOverloadBuilder *preparedOverload) {
   ASSERT(!!preparedOverload == PreparingOverload);
 
@@ -2056,8 +2050,7 @@ DeclReferenceType ConstraintSystem::getTypeOfMemberReference(
 
   Type openedType, thrownErrorType;
   std::tie(openedType, thrownErrorType)
-      = getTypeOfMemberReferenceImpl(choice, useDC, locator, replacementsPtr,
-                                     preparedOverload);
+      = getTypeOfMemberReferenceImpl(choice, useDC, locator, preparedOverload);
 
   if (isa<TypeDecl>(value)) {
     auto type = openedType->castTo<FunctionType>()->getResult();
@@ -2852,11 +2845,9 @@ ConstraintSystem::prepareOverloadImpl(ConstraintLocator *locator,
       return getTypeOfReference(choice, locator, useDC, preparedOverload);
     }
 
-    return getTypeOfMemberReference(
-        choice, useDC, locator, /*replacements=*/nullptr, preparedOverload);
+    return getTypeOfMemberReference(choice, useDC, locator, preparedOverload);
   } else {
-    return getTypeOfReference(
-        choice, locator, useDC, preparedOverload);
+    return getTypeOfReference(choice, locator, useDC, preparedOverload);
   }
 }