[Type checker] Eliminate TypeCheckExprFlags::ConvertTypeIsOnlyAHint.

This flag is recoverable from the contextual type purpose; don’t duplicate
the logic.

Author: DougGregor

lib/Sema/ConstraintSystem.h

@@ -789,7 +789,7 @@ using OpenedTypeMap =
 
 /// Describes contextual type information about a particular expression
 /// within a constraint system.
-struct ContextualTypeInfo  {
+struct ContextualTypeInfo {
   TypeLoc typeLoc;
   ContextualTypePurpose purpose;
   bool isOpaqueReturnType = false;

lib/Sema/TypeCheckConstraints.cpp

@@ -2058,6 +2058,40 @@ bool GenericRequirementsCheckListener::diagnoseUnsatisfiedRequirement(
   return false;
 }
 
+/// Whether the contextual type provided for the given purpose is only a
+/// hint, and not a requirement.
+static bool contextualTypeIsOnlyAHint(ContextualTypePurpose ctp,
+                                      TypeCheckExprOptions options) {
+  switch (ctp) {
+  case CTP_Initialization:
+    return !options.contains(
+        TypeCheckExprFlags::ConvertTypeIsOpaqueReturnType);
+  case CTP_ForEachStmt:
+    return true;
+  case CTP_Unused:
+  case CTP_ReturnStmt:
+  case CTP_ReturnSingleExpr:
+  case CTP_YieldByValue:
+  case CTP_YieldByReference:
+  case CTP_ThrowStmt:
+  case CTP_EnumCaseRawValue:
+  case CTP_DefaultParameter:
+  case CTP_AutoclosureDefaultParameter:
+  case CTP_CalleeResult:
+  case CTP_CallArgument:
+  case CTP_ClosureResult:
+  case CTP_ArrayElement:
+  case CTP_DictionaryKey:
+  case CTP_DictionaryValue:
+  case CTP_CoerceOperand:
+  case CTP_AssignSource:
+  case CTP_SubscriptAssignSource:
+  case CTP_Condition:
+  case CTP_CannotFail:
+    return false;
+  }
+}
+
 #pragma mark High-level entry points
 Type TypeChecker::typeCheckExpression(Expr *&expr, DeclContext *dc,
                                       TypeLoc convertType,
@@ -2128,7 +2162,7 @@ Type TypeChecker::typeCheckExpression(Expr *&expr, DeclContext *dc,
 
   // If the convertType is *only* provided for that hint, then null it out so
   // that we don't later treat it as an actual conversion constraint.
-  if (options.contains(TypeCheckExprFlags::ConvertTypeIsOnlyAHint))
+  if (contextualTypeIsOnlyAHint(convertTypePurpose, options))
     convertType = TypeLoc();
 
   // If the client can handle unresolved type variables, leave them in the
@@ -2655,7 +2689,7 @@ bool TypeChecker::typeCheckBinding(Pattern *&pattern, Expr *&initializer,
 
   TypeLoc contextualType;
   auto contextualPurpose = CTP_Unused;
-  TypeCheckExprOptions flags = TypeCheckExprFlags::ConvertTypeIsOnlyAHint;
+  TypeCheckExprOptions flags = None;
 
   // Set the contextual purpose even if the pattern doesn't have a type so
   // if there's an error we can use that information to inform diagnostics.
@@ -2674,7 +2708,6 @@ bool TypeChecker::typeCheckBinding(Pattern *&pattern, Expr *&initializer,
     // opaque type.
     if (auto opaqueType = patternType->getAs<OpaqueTypeArchetypeType>()){
       flags |= TypeCheckExprFlags::ConvertTypeIsOpaqueReturnType;
-      flags -= TypeCheckExprFlags::ConvertTypeIsOnlyAHint;
     }
 
     // Only provide a TypeLoc if it makes sense to allow diagnostics.
@@ -3042,7 +3075,7 @@ bool TypeChecker::typeCheckForEachBinding(DeclContext *dc, ForEachStmt *stmt) {
   // Type-check the for-each loop sequence and element pattern.
   auto resultTy = TypeChecker::typeCheckExpression(
       seq, dc, TypeLoc::withoutLoc(sequenceProto->getDeclaredType()),
-      CTP_ForEachStmt, TypeCheckExprFlags::ConvertTypeIsOnlyAHint, &listener);
+      CTP_ForEachStmt, None, &listener);
   if (!resultTy)
     return true;
   return false;

lib/Sema/TypeChecker.h

@@ -174,12 +174,6 @@ enum class TypeCheckExprFlags {
   /// left in-tact.
   AllowUnresolvedTypeVariables = 0x08,
 
-  /// If set, the 'convertType' specified to typeCheckExpression should not
-  /// produce a conversion constraint, but it should be used to guide the
-  /// solution in terms of performance optimizations of the solver, and in terms
-  /// of guiding diagnostics.
-  ConvertTypeIsOnlyAHint = 0x10,
-
   /// If set, this expression isn't embedded in a larger expression or
   /// statement. This should only be used for syntactic restrictions, and should
   /// not affect type checking itself.
@@ -821,11 +815,9 @@ class TypeChecker final {
   /// to be possible.
   ///
   /// \param convertType The type that the expression is being converted to,
-  /// or null if the expression is standalone.  If the 'ConvertTypeIsOnlyAHint'
-  /// option is specified, then this is only a hint, it doesn't produce a full
-  /// conversion constraint. The location information is only used for
-  /// diagnostics should the conversion fail; it is safe to pass a TypeLoc
-  /// without location information.
+  /// or null if the expression is standalone. The location information is
+  /// only used for diagnostics should the conversion fail; it is safe to pass
+  /// a TypeLoc without location information.
   ///
   /// \param options Options that control how type checking is performed.
   ///