[Sema] Allow inference of binding to differing lvalue-ness type var…

lib/Sema/CSApply.cpp

@@ -2696,7 +2696,7 @@ namespace {
       // then we're in an ambiguity tolerant mode used for diagnostic
       // generation.  Just leave this as an unresolved member reference.
       Type resultTy = simplifyType(cs.getType(expr));
-      if (resultTy->getRValueType()->is<UnresolvedType>()) {
+      if (resultTy->hasUnresolvedType()) {
         cs.setType(expr, resultTy);
         return expr;
       }

lib/Sema/CSBindings.cpp

@@ -715,8 +715,7 @@ ConstraintSystem::getPotentialBindingForRelationalConstraint(
 
   // Make sure we aren't trying to equate type variables with different
   // lvalue-binding rules.
-  if (auto otherTypeVar =
-          type->lookThroughAllOptionalTypes()->getAs<TypeVariableType>()) {
+  if (auto otherTypeVar = type->getAs<TypeVariableType>()) {
     if (typeVar->getImpl().canBindToLValue() !=
         otherTypeVar->getImpl().canBindToLValue())
       return None;

lib/Sema/CSSimplify.cpp

@@ -6590,6 +6590,14 @@ performMemberLookup(ConstraintKind constraintKind, DeclNameRef memberName,
       baseObjTy->is<AnyMetatypeType>() &&
       constraintKind == ConstraintKind::UnresolvedValueMember) {
     if (auto objectType = instanceTy->getOptionalObjectType()) {
+      // If we don't have a wrapped type yet, we can't look through the optional
+      // type.
+      if (objectType->getAs<TypeVariableType>()) {
+        MemberLookupResult result;
+        result.OverallResult = MemberLookupResult::Unsolved;
+        return result;
+      }
+
       if (objectType->mayHaveMembers()) {
         LookupResult &optionalLookup = lookupMember(objectType, memberName);
         for (auto result : optionalLookup)

test/Constraints/patterns.swift

@@ -296,8 +296,7 @@ switch staticMembers {
   // expected-note@-2 {{coalesce using '??' to provide a default when the optional value contains 'nil'}}
 
   case .prop: break
-  // TODO: repeated error message
-  case .optProp: break // expected-error* {{not unwrapped}}
+  case .optProp: break
 
   case .method: break // expected-error{{member 'method' expects argument of type 'Int'}}
   case .method(0): break
@@ -311,9 +310,6 @@ switch staticMembers {
 
   case .optMethod: break // expected-error{{member 'optMethod' expects argument of type 'Int'}}
   case .optMethod(0): break
-  // expected-error@-1 {{value of optional type 'StaticMembers?' must be unwrapped to a value of type 'StaticMembers'}}
-  // expected-note@-2 {{coalesce}}
-  // expected-note@-3 {{force-unwrap}}
 }
 
 _ = 0

test/expr/delayed-ident/enum.swift

@@ -25,3 +25,13 @@ e2a = .Second(5)
 var e2b: E2 = .Second(5)
 e2b = .First
 var e2c: E2 = .First // expected-error{{generic parameter 'T' could not be inferred}}
+
+// SR-13357
+struct SR13357 {}
+extension Optional where Wrapped == SR13357 {
+    static var sr13357: Self { .none }
+}
+
+func f_sr13357<T>(_: T?) { }
+
+f_sr13357(.sr13357)

test/expr/delayed-ident/static_var.swift

@@ -52,3 +52,17 @@ var _: HasClosure = .factoryOpt(3)
 // expected-note@-3 {{force-unwrap}}
 // FIXME: we should accept this
 var _: HasClosure = .factoryOpt!(4) // expected-error {{cannot infer contextual base in reference to member 'factoryOpt'}}
+
+infix operator =%: ComparisonPrecedence
+
+extension Optional {
+    static func =%(lhs: Self, rhs: Self) -> Bool { return true }
+}
+
+struct ImplicitMembers {
+    static var optional: ImplicitMembers? = ImplicitMembers()
+}
+
+func implicit(_ i: inout ImplicitMembers) {
+    if i =% .optional {}
+}