[CS] Record opened types early in getTypeOfMemberReference

Requirement opening relies on being able to query the opened type to
allow requirement fix coalescing to work. Record the opened type before
we open requirements to ensure we don't duplicate requirement fixes on
the base type with requirement fixes for the member.

Author: hamishknight

lib/Sema/TypeOfReference.cpp

@@ -1646,17 +1646,30 @@ DeclReferenceType ConstraintSystem::getTypeOfMemberReference(
   DeclContext *innerDC = value->getInnermostDeclContext();
   DeclContext *outerDC = value->getDeclContext();
 
+  auto genericSig = innerDC->getGenericSignatureOfContext();
+
   // Open the type of the generic function or member of a generic type.
   Type openedType;
+  ArrayRef<OpenedType> replacements;
   SmallVector<OpenedType, 4> localReplacements;
-  auto &replacements = replacementsPtr ? *replacementsPtr : 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.
-  auto genericSig = innerDC->getGenericSignatureOfContext();
-  if (genericSig) {
-    openGenericParameters(outerDC, genericSig, replacements, locator,
-                          preparedOverload);
+    // 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);
+    replacements = _replacements;
   }
 
   Type thrownErrorType;
@@ -1867,9 +1880,6 @@ DeclReferenceType ConstraintSystem::getTypeOfMemberReference(
         isDynamicLookup, replacements);
   }
 
-  // If we opened up any type variables, record the replacements.
-  recordOpenedTypes(locator, replacements, preparedOverload);
-
   return { origOpenedType, openedType, origType, type, thrownErrorType };
 }
 

test/decl/nested/type_in_type.swift

@@ -427,3 +427,17 @@ extension OuterGeneric.MidNonGeneric {
 
   }
 }
+
+protocol P {}
+
+struct A<T> {}
+extension A where T: P { // expected-note {{where 'T' = 'T'}}
+  struct B<U> {
+    init(_ u: U) {}
+  }
+}
+extension A {
+  func bar() {
+    B(0) // expected-error {{referencing generic struct 'B' on 'A' requires that 'T' conform to 'P'}}
+  }
+}