[ConstraintSystem] Fix situations when contextual base type can't be inferred

It might be either impossible to infer the base because there is
no contextual information e.g. `_ = .foo` or there is something
else wrong in the expression which disconnects member reference
from its context.

Author: xedin

lib/Sema/CSBindings.cpp

@@ -738,6 +738,13 @@ ConstraintSystem::getPotentialBindings(TypeVariableType *typeVar) const {
   if (shouldAttemptFixes() && result.Bindings.empty() &&
       typeVar->getImpl().canBindToHole()) {
     result.IsHole = true;
+    // If the base of the unresolved member reference like `.foo`
+    // couldn't be resolved we'd want to bind it to a hole at the
+    // very last moment possible, just like generic parameters.
+    auto *locator = typeVar->getImpl().getLocator();
+    if (locator->isLastElement<LocatorPathElt::MemberRefBase>())
+      result.PotentiallyIncomplete = true;
+
     result.addPotentialBinding({getASTContext().TheUnresolvedType,
         AllowedBindingKind::Exact, ConstraintKind::Defaultable, nullptr,
         typeVar->getImpl().getLocator()});

lib/Sema/CSGen.cpp

@@ -1507,10 +1507,13 @@ namespace {
 
       auto memberLocator
         = CS.getConstraintLocator(expr, ConstraintLocator::UnresolvedMember);
-      auto baseTy = CS.createTypeVariable(baseLocator, TVO_CanBindToNoEscape);
-      auto memberTy = CS.createTypeVariable(memberLocator,
-                                            TVO_CanBindToLValue |
-                                            TVO_CanBindToNoEscape);
+
+      // Since base type in this case is completely dependent on context it
+      // should be marked as a potential hole.
+      auto baseTy = CS.createTypeVariable(baseLocator, TVO_CanBindToNoEscape |
+                                                           TVO_CanBindToHole);
+      auto memberTy = CS.createTypeVariable(
+          memberLocator, TVO_CanBindToLValue | TVO_CanBindToNoEscape);
 
       // An unresolved member expression '.member' is modeled as a value member
       // constraint

lib/Sema/CSSimplify.cpp

@@ -6059,6 +6059,23 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyMemberConstraint(
   Type baseObjTy = baseTy->getRValueType();
 
   auto locator = getConstraintLocator(locatorB);
+
+  // If this is an unresolved member ref e.g. `.foo` and its contextual base
+  // type has been determined to be a "hole", let's mark the resulting member
+  // type as a potential hole and continue solving.
+  if (shouldAttemptFixes() && kind == ConstraintKind::UnresolvedValueMember &&
+      baseObjTy->getMetatypeInstanceType()->isHole()) {
+    auto *fix =
+        SpecifyBaseTypeForContextualMember::create(*this, member, locator);
+    if (recordFix(fix))
+      return SolutionKind::Error;
+
+    if (auto *typeVar = memberTy->getAs<TypeVariableType>())
+      recordPotentialHole(typeVar);
+
+    return SolutionKind::Solved;
+  }
+
   MemberLookupResult result =
       performMemberLookup(kind, member, baseTy, functionRefKind, locator,
                           /*includeInaccessibleMembers*/ shouldAttemptFixes());
@@ -8449,6 +8466,7 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
   case FixKind::ExpandArrayIntoVarargs:
   case FixKind::UseValueTypeOfRawRepresentative:
   case FixKind::ExplicitlyConstructRawRepresentable:
+  case FixKind::SpecifyBaseTypeForContextualMember:
   case FixKind::CoerceToCheckedCast: {
     return recordFix(fix) ? SolutionKind::Error : SolutionKind::Solved;
   }

test/Constraints/construction.swift

@@ -60,6 +60,7 @@ Optional<Int>(1) // expected-warning{{unused}}
 Optional(1) // expected-warning{{unused}}
 _ = .none as Optional<Int>
 Optional(.none) // expected-error{{generic parameter 'T' could not be inferred}} expected-note {{explicitly specify the generic arguments to fix this issue}} {{9-9=<Any>}}
+// expected-error@-1 {{cannot infer contextual base in reference to member 'none'}}
 
 // Interpolation
 _ = "\(hello), \(world) #\(i)!"

test/Constraints/diagnostics.swift

@@ -498,8 +498,8 @@ enum Color {
   static var svar: Color { return .Red }
 }
 
-// FIXME: This used to be better: "'map' produces '[T]', not the expected contextual result type '(Int, Color)'"
-let _: (Int, Color) = [1,2].map({ ($0, .Unknown("")) }) // expected-error {{expression type '((Int) throws -> _) throws -> Array<_>' is ambiguous without more context}}
+let _: (Int, Color) = [1,2].map({ ($0, .Unknown("")) }) // expected-error {{cannot convert value of type 'Array<(Int, _)>' to specified type '(Int, Color)'}}
+// expected-error@-1 {{cannot infer contextual base in reference to member 'Unknown'}}
 
 let _: [(Int, Color)] = [1,2].map({ ($0, .Unknown("")) })// expected-error {{missing argument label 'description:' in call}}
 

test/Constraints/members.swift

@@ -325,6 +325,7 @@ enum r23942743 {
   case Tomato(cloud: String)
 }
 let _ = .Tomato(cloud: .none)  // expected-error {{reference to member 'Tomato' cannot be resolved without a contextual type}}
+// expected-error@-1 {{cannot infer contextual base in reference to member 'none'}}
 
 
 

test/Sema/diag_ambiguous_overloads.swift

@@ -26,10 +26,10 @@ struct S {
     f({x in x}, 2) // expected-error {{generic parameter 'T' could not be inferred}}
   }
 
-  func g<T>(_ a: T, _ b: Int) -> Void {} // expected-note {{in call to function 'g'}}
+  func g<T>(_ a: T, _ b: Int) -> Void {}
   func g(_ a: String) -> Void {}
   func test2() -> Void {
-    g(.notAThing, 7) // expected-error {{generic parameter 'T' could not be inferred}}
+    g(.notAThing, 7) // expected-error {{cannot infer contextual base in reference to member 'notAThing'}}
   }
 
   func h(_ a: Int, _ b: Int) -> Void {}

test/decl/enum/enumtest.swift

@@ -100,7 +100,8 @@ func test3a(_ a: ZeroOneTwoThree) {
   // Overload resolution can resolve this to the right constructor.
   var h = ZeroOneTwoThree(1)
 
-  var i = 0 > 3 ? .none : .some(3) // expected-error {{reference to member 'none' cannot be resolved without a contextual type}}
+  var i = 0 > 3 ? .none : .some(3) // expected-error {{cannot infer contextual base in reference to member 'none'}}
+  // expected-error@-1 {{cannot infer contextual base in reference to member 'some'}}
 
   test3a;  // expected-error {{unused function}}
   .Zero   // expected-error {{reference to member 'Zero' cannot be resolved without a contextual type}}