Reapply: Collapse the three optional-to-optional restriction kinds.

This reapply's Doug's change d79ba78,
which had previously been applied on top of
1efafbc, the latter of which resulted
in a source compatibility break.

Author: rudkx

lib/Sema/CSApply.cpp

@@ -5545,8 +5545,6 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
       return result;
     }
 
-    case ConversionRestrictionKind::OptionalToImplicitlyUnwrappedOptional:
-    case ConversionRestrictionKind::ImplicitlyUnwrappedOptionalToOptional:
     case ConversionRestrictionKind::OptionalToOptional:
       return coerceOptionalToOptional(expr, toType, locator, typeFromPattern);
 

lib/Sema/CSSimplify.cpp

@@ -2009,13 +2009,13 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
                      decl1 == TC.Context.getImplicitlyUnwrappedOptionalDecl()) {
             assert(boundGenericType1->getGenericArgs().size() == 1);
             conversionsOrFixes.push_back(
-                       ConversionRestrictionKind::ImplicitlyUnwrappedOptionalToOptional);
+                       ConversionRestrictionKind::OptionalToOptional);
           } else if (optionalKind2 == OTK_ImplicitlyUnwrappedOptional &&
                      kind >= ConstraintKind::Conversion &&
                      decl1 == TC.Context.getOptionalDecl()) {
             assert(boundGenericType1->getGenericArgs().size() == 1);
             conversionsOrFixes.push_back(
-                       ConversionRestrictionKind::OptionalToImplicitlyUnwrappedOptional);
+                       ConversionRestrictionKind::OptionalToOptional);
           }
         }
 
@@ -3818,8 +3818,6 @@ ConstraintSystem::simplifyRestrictedConstraintImpl(
   //   T $< U ===> T! $< U?
   // also:
   //   T <c U ===> T? <c U!
-  case ConversionRestrictionKind::OptionalToImplicitlyUnwrappedOptional:
-  case ConversionRestrictionKind::ImplicitlyUnwrappedOptionalToOptional:
   case ConversionRestrictionKind::OptionalToOptional: {
     addContextualScore();
     assert(matchKind >= ConstraintKind::Subtype);

lib/Sema/CSSolver.cpp

@@ -2223,11 +2223,7 @@ static bool shortCircuitDisjunctionAt(Constraint *constraint,
   if (auto restriction = constraint->getRestriction()) {
     // Non-optional conversions are better than optional-to-optional
     // conversions.
-    if (*restriction == ConversionRestrictionKind::OptionalToOptional ||
-        *restriction
-          == ConversionRestrictionKind::ImplicitlyUnwrappedOptionalToOptional ||
-        *restriction
-          == ConversionRestrictionKind::OptionalToImplicitlyUnwrappedOptional)
+    if (*restriction == ConversionRestrictionKind::OptionalToOptional)
       return true;
 
     // Array-to-pointer conversions are better than inout-to-pointer conversions.

lib/Sema/Constraint.cpp

@@ -365,10 +365,6 @@ StringRef swift::constraints::getName(ConversionRestrictionKind kind) {
     return "[value-to-optional]";
   case ConversionRestrictionKind::OptionalToOptional:
     return "[optional-to-optional]";
-  case ConversionRestrictionKind::ImplicitlyUnwrappedOptionalToOptional:
-    return "[unchecked-optional-to-optional]";
-  case ConversionRestrictionKind::OptionalToImplicitlyUnwrappedOptional:
-    return "[optional-to-unchecked-optional]";
   case ConversionRestrictionKind::ClassMetatypeToAnyObject:
     return "[class-metatype-to-object]";
   case ConversionRestrictionKind::ExistentialMetatypeToAnyObject:

lib/Sema/Constraint.h

@@ -188,10 +188,6 @@ enum class ConversionRestrictionKind {
   ValueToOptional,
   /// T? -> U? optional to optional conversion (or unchecked to unchecked).
   OptionalToOptional,
-  /// T! -> U? unchecked-optional to optional conversion
-  ImplicitlyUnwrappedOptionalToOptional,
-  /// T? -> U! optional to implicitly unwrapped optional conversion
-  OptionalToImplicitlyUnwrappedOptional,
   /// Implicit forces of implicitly unwrapped optionals to their presumed values
   ForceUnchecked,
   /// Implicit upcast conversion of array types.