[Constraint system] Give SolutionApplicationTarget purpose.

A contextual type purpose, that is, so it captures more about what the
entity is that is being solved.

Author: DougGregor

lib/Sema/ConstraintSystem.h

@@ -1149,8 +1149,11 @@ class SolutionApplicationTarget {
     struct {
       Expr *expression;
 
+      /// The purpose of the contextual type.
+      ContextualTypePurpose contextualPurpose;
+
       /// The type to which the expression should be converted.
-      Type convertType;
+      TypeLoc convertType;
 
       /// Whether the expression result will be discarded at the end.
       bool isDiscarded;
@@ -1163,9 +1166,18 @@ class SolutionApplicationTarget {
   };
 
 public:
-  SolutionApplicationTarget(Expr *expr, Type convertType, bool isDiscarded) {
+  SolutionApplicationTarget(Expr *expr,
+                            ContextualTypePurpose contextualPurpose,
+                            Type convertType, bool isDiscarded)
+      : SolutionApplicationTarget(expr, contextualPurpose,
+                                  TypeLoc::withoutLoc(convertType),
+                                  isDiscarded) { }
+
+  SolutionApplicationTarget(Expr *expr, ContextualTypePurpose contextualPurpose,
+                            TypeLoc convertType, bool isDiscarded) {
     kind = Kind::expression;
     expression.expression = expr;
+    expression.contextualPurpose = contextualPurpose;
     expression.convertType = convertType;
     expression.isDiscarded = isDiscarded;
   }
@@ -1189,16 +1201,31 @@ class SolutionApplicationTarget {
     }
   }
 
+  ContextualTypePurpose getExprContextualTypePurpose() const {
+    assert(kind == Kind::expression);
+    return expression.contextualPurpose;
+  }
+
   Type getExprConversionType() const {
+    assert(kind == Kind::expression);
+    return expression.convertType.getType();
+  }
+
+  TypeLoc getExprConversionTypeLoc() const {
     assert(kind == Kind::expression);
     return expression.convertType;
   }
 
   void setExprConversionType(Type type) {
+    assert(kind == Kind::expression);
+    expression.convertType = TypeLoc::withoutLoc(type);
+  }
+
+  void setExprConversionTypeLoc(TypeLoc type) {
     assert(kind == Kind::expression);
     expression.convertType = type;
   }
-  
+
   bool isDiscardedExpr() const {
     assert(kind == Kind::expression);
     return expression.isDiscarded;

lib/Sema/TypeCheckConstraints.cpp

@@ -2183,7 +2183,7 @@ Type TypeChecker::typeCheckExpression(Expr *&expr, DeclContext *dc,
 
   // Attempt to solve the constraint system.
   SolutionApplicationTarget target(
-      expr, convertTo,
+      expr, convertTypePurpose, convertTo,
       options.contains(TypeCheckExprFlags::IsDiscarded));
   auto viable = cs.solve(target, listener, allowFreeTypeVariables);
   if (!viable)
@@ -2283,7 +2283,8 @@ getTypeOfExpressionWithoutApplying(Expr *&expr, DeclContext *dc,
   // re-check.
   if (needClearType)
     expr->setType(Type());
-  SolutionApplicationTarget target(expr, Type(), /*isDiscarded=*/false);
+  SolutionApplicationTarget target(
+      expr, CTP_Unused, Type(), /*isDiscarded=*/false);
   auto viable = cs.solve(target, listener, allowFreeTypeVariables);
   if (!viable) {
     recoverOriginalType();
@@ -2363,7 +2364,8 @@ void TypeChecker::getPossibleTypesOfExpressionWithoutApplying(
   if (originalType && originalType->hasError())
     expr->setType(Type());
 
-  SolutionApplicationTarget target(expr, Type(), /*isDiscarded=*/false);
+  SolutionApplicationTarget target(
+      expr, CTP_Unused, Type(), /*isDiscarded=*/false);
   if (auto viable = cs.solve(target, listener, allowFreeTypeVariables)) {
     expr = target.getAsExpr();
     for (auto &solution : *viable) {