[CS] Use different locators for nested 'wrappedValue' lookups

With the new way of caching overloads in the
constraint system, we no longer allow different
overloads to be resolved for the same locator in
the same scope.

Adjust the property wrapper logic
so that it appends Member locator elements for
nested lookups.

Author: hamishknight

lib/Sema/TypeCheckConstraints.cpp

@@ -2603,26 +2603,25 @@ bool TypeChecker::typeCheckBinding(Pattern *&pattern, Expr *&initializer,
       if (cs) {
         Type valueType = LValueType::get(initType);
         auto dc = wrappedVar->getInnermostDeclContext();
-        auto emptyLocator = cs->getConstraintLocator(nullptr);
+        auto *loc = cs->getConstraintLocator(initializer);
 
         for (unsigned i : indices(wrappedVar->getAttachedPropertyWrappers())) {
           auto wrapperInfo = wrappedVar->getAttachedPropertyWrapperTypeInfo(i);
           if (!wrapperInfo)
             break;
 
-          Type memberType =
-              cs->createTypeVariable(emptyLocator, TVO_CanBindToLValue);
+          loc = cs->getConstraintLocator(loc, ConstraintLocator::Member);
+          Type memberType = cs->createTypeVariable(loc, TVO_CanBindToLValue);
           cs->addValueMemberConstraint(
               valueType, wrapperInfo.valueVar->getFullName(),
-              memberType, dc, FunctionRefKind::Unapplied, { }, emptyLocator);
+              memberType, dc, FunctionRefKind::Unapplied, { }, loc);
           valueType = memberType;
         }
 
         // Set up an equality constraint to drop the lvalue-ness of the value
         // type we produced.
-        Type propertyType = cs->createTypeVariable(emptyLocator, 0);
-        cs->addConstraint(ConstraintKind::Equal, propertyType, valueType,
-                          emptyLocator);
+        Type propertyType = cs->createTypeVariable(loc, 0);
+        cs->addConstraint(ConstraintKind::Equal, propertyType, valueType, loc);
         return propertyType;
       }
 

test/decl/var/property_wrappers.swift

@@ -216,7 +216,11 @@ struct BadCombinations {
 }
 
 struct MultipleWrappers {
-  @Wrapper(stored: 17)
+  // FIXME: The diagnostics here aren't great. The problem is that we're
+  // attempting to splice a 'wrappedValue:' argument into the call to Wrapper's
+  // init, but it doesn't have a matching init. We're then attempting to access
+  // the nested 'wrappedValue', but Wrapper's 'wrappedValue' is Int.
+  @Wrapper(stored: 17) // expected-error{{value of type 'Int' has no member 'wrappedValue'}}
   @WrapperWithInitialValue // expected-error{{extra argument 'wrappedValue' in call}}
   var x: Int = 17