[TypeChecker] handle UnresolvedTypes in setContextualType

We used to handle these in an equivalent way in `generateConstraints`, but,
when most of the `generateConstraints` logic got moved to `setContextualType`,
the `UnresolvedType` logic was simply removed.

Author: Benjamin Driscoll

include/swift/Sema/ConstraintSystem.h

@@ -3017,8 +3017,9 @@ class ConstraintSystem {
   /// and creating type variables for placeholders).
   ///
   /// May only be called once per AST node.
-  void setContextualType(ASTNode node, TypeLoc T,
-                         ContextualTypePurpose purpose);
+  void setContextualType(ASTNode node, TypeLoc T, ContextualTypePurpose purpose,
+                         FreeTypeVariableBinding allowFreeTypeVariables =
+                             FreeTypeVariableBinding::Disallow);
 
   Optional<ContextualTypeInfo> getContextualTypeInfo(ASTNode node) const {
     auto known = contextualTypes.find(node);

lib/Sema/CSGen.cpp

@@ -3810,51 +3810,8 @@ bool ConstraintSystem::generateConstraints(
         convertType = contextType;
 
       // Determine whether we know more about the contextual type.
-      ContextualTypePurpose ctp = target.getExprContextualTypePurpose();
-      // auto *convertTypeLocator =
-      //    getConstraintLocator(expr, LocatorPathElt::ContextualType(ctp));
-
-      // FIXME [OPAQUE SUPPORT]: most of this got moved to `setContextualType`,
-      // but `UnresolvedTypes` aren't handled there, so they are broken now!!!
-
-      // auto getLocator = [&](Type ty) -> ConstraintLocator * {
-      //  // If we have a placeholder originating from a PlaceholderTypeRepr,
-      //  // tack that on to the locator.
-      //  if (auto *placeholderTy = ty->getAs<PlaceholderType>())
-      //    if (auto *placeholderRepr = placeholderTy->getOriginator()
-      //                                    .dyn_cast<PlaceholderTypeRepr *>())
-      //      return getConstraintLocator(
-      //          convertTypeLocator,
-      //          LocatorPathElt::PlaceholderType(placeholderRepr));
-      //  return convertTypeLocator;
-      //};
-
-      // Substitute type variables in for placeholder types (and unresolved
-      // types, if allowed).
-      // if (allowFreeTypeVariables == FreeTypeVariableBinding::UnresolvedType)
-      // {
-      //  convertType = convertType.transform([&](Type type) -> Type {
-      //    if (type->is<UnresolvedType>() || type->is<PlaceholderType>()) {
-      //      return createTypeVariable(getLocator(type),
-      //                                TVO_CanBindToNoEscape |
-      //                                    TVO_PrefersSubtypeBinding |
-      //                                    TVO_CanBindToHole);
-      //    }
-      //    return type;
-      //  });
-      //} else {
-      //  convertType = convertType.transform([&](Type type) -> Type {
-      //    if (type->is<PlaceholderType>()) {
-      //      return createTypeVariable(getLocator(type),
-      //                                TVO_CanBindToNoEscape |
-      //                                    TVO_PrefersSubtypeBinding |
-      //                                    TVO_CanBindToHole);
-      //    }
-      //    return type;
-      //  });
-      //}
-
-      addContextualConversionConstraint(expr, convertType, ctp);
+      addContextualConversionConstraint(expr, convertType,
+                                        target.getExprContextualTypePurpose());
     }
 
     // For an initialization target, generate constraints for the pattern.

lib/Sema/ConstraintSystem.cpp

@@ -5699,29 +5699,42 @@ Type ConstraintSystem::getVarType(const VarDecl *var) {
   });
 }
 
-void ConstraintSystem::setContextualType(ASTNode node, TypeLoc T,
-                                         ContextualTypePurpose purpose) {
+void ConstraintSystem::setContextualType(
+    ASTNode node, TypeLoc T, ContextualTypePurpose purpose,
+    FreeTypeVariableBinding allowFreeTypeVariables) {
   assert(bool(node) && "Expected non-null expression!");
   assert(contextualTypes.count(node) == 0 &&
          "Already set this contextual type");
 
   auto contextualType = T.getType();
+  bool transformUnresolved =
+      allowFreeTypeVariables == FreeTypeVariableBinding::UnresolvedType;
+
   if (contextualType) {
     contextualType = contextualType.transform([&](Type type) -> Type {
       // TODO [OPAQUE SUPPORT]: perhaps we could provide better locators here?
       auto *locator =
           getConstraintLocator(node, LocatorPathElt::ContextualType(purpose));
 
-      if (type->is<OpaqueTypeArchetypeType>()) {
+      if (type->is<OpaqueTypeArchetypeType>())
         return openOpaqueType(type, locator);
-      }
 
-      if (type->is<PlaceholderType>()) {
+      if (auto *placeholderType = type->getAs<PlaceholderType>()) {
+        if (auto *placeholderRepr = placeholderType->getOriginator()
+                                        .dyn_cast<PlaceholderTypeRepr *>())
+          locator = getConstraintLocator(
+              locator, LocatorPathElt::PlaceholderType(placeholderRepr));
+
         return createTypeVariable(locator, TVO_CanBindToNoEscape |
                                                TVO_PrefersSubtypeBinding |
                                                TVO_CanBindToHole);
       }
 
+      if (transformUnresolved && type->is<UnresolvedType>())
+        return createTypeVariable(locator, TVO_CanBindToNoEscape |
+                                               TVO_PrefersSubtypeBinding |
+                                               TVO_CanBindToHole);
+
       return type;
     });
   }

lib/Sema/TypeCheckCodeCompletion.cpp

@@ -407,6 +407,9 @@ getTypeOfExpressionWithoutApplying(Expr *&expr, DeclContext *dc,
     expr->setType(Type());
   SolutionApplicationTarget target(
       expr, dc, CTP_Unused, Type(), /*isDiscarded=*/false);
+  cs.setContextualType(expr, target.getExprContextualTypeLoc(),
+                       target.getExprContextualTypePurpose(),
+                       allowFreeTypeVariables);
   auto viable = cs.solve(target, allowFreeTypeVariables);
   if (!viable) {
     recoverOriginalType();

lib/Sema/TypeCheckConstraints.cpp

@@ -382,24 +382,23 @@ TypeChecker::typeCheckExpression(
                                 target.getExprContextualType(),
                                 target.getExprContextualTypePurpose());
 
+  // If the client can handle unresolved type variables, leave them in the
+  // system.
+  auto allowFreeTypeVariables = FreeTypeVariableBinding::Disallow;
+
   // Tell the constraint system what the contextual type is. This is used in
   // constraint generation, informs diagnostics, and is a hint for various
   // performance optimizations.
-  cs.setContextualType(
-      expr,
-      target.getExprContextualTypeLoc(),
-      target.getExprContextualTypePurpose());
+  cs.setContextualType(expr, target.getExprContextualTypeLoc(),
+                       target.getExprContextualTypePurpose(),
+                       allowFreeTypeVariables);
 
   // Try to shrink the system by reducing disjunction domains. This
   // goes through every sub-expression and generate its own sub-system, to
   // try to reduce the domains of those subexpressions.
   cs.shrink(expr);
   target.setExpr(expr);
 
-  // If the client can handle unresolved type variables, leave them in the
-  // system.
-  auto allowFreeTypeVariables = FreeTypeVariableBinding::Disallow;
-
   // Attempt to solve the constraint system.
   auto viable = cs.solve(target, allowFreeTypeVariables);
   if (!viable) {