Revert "[Constraint solver] Collapse the three optional-to-optional restriction kinds."

This reverts commit d79ba78 so that I
can revert 1efafbc, which caused a
source compatibility regression.

Author: rudkx

lib/Sema/CSApply.cpp

@@ -5545,6 +5545,8 @@ 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

@@ -1209,18 +1209,29 @@ selectOptionalConversionRestriction(Type type1, Type type2,
         kind >= ConstraintKind::Conversion)
       return ConversionRestrictionKind::ForceUnchecked;
 
-    return None;
+    return llvm::None;
   }
 
+  if (optionalKind1 == optionalKind2)
+    return ConversionRestrictionKind::OptionalToOptional;
+
   if (optionalKind1 == OTK_None)
     return ConversionRestrictionKind::ValueToOptional;
 
-  if (optionalKind1 == OTK_Optional &&
-      optionalKind2 == OTK_ImplicitlyUnwrappedOptional &&
-      kind < ConstraintKind::Conversion)
-    return None;
+  if (optionalKind1 == OTK_Optional) {
+    if (kind >= ConstraintKind::Conversion)
+      return ConversionRestrictionKind::OptionalToImplicitlyUnwrappedOptional;
+
+    assert(optionalKind2 == OTK_ImplicitlyUnwrappedOptional &&
+           "Result has unexpected optional kind!");
+
+    return llvm::None;
+  }
+
+  assert(optionalKind1 == OTK_ImplicitlyUnwrappedOptional &&
+         "Source has unexpected optional kind!");
 
-  return ConversionRestrictionKind::OptionalToOptional;
+  return ConversionRestrictionKind::ImplicitlyUnwrappedOptionalToOptional;
 }
 
 
@@ -3807,6 +3818,8 @@ 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,7 +2223,11 @@ static bool shortCircuitDisjunctionAt(Constraint *constraint,
   if (auto restriction = constraint->getRestriction()) {
     // Non-optional conversions are better than optional-to-optional
     // conversions.
-    if (*restriction == ConversionRestrictionKind::OptionalToOptional)
+    if (*restriction == ConversionRestrictionKind::OptionalToOptional ||
+        *restriction
+          == ConversionRestrictionKind::ImplicitlyUnwrappedOptionalToOptional ||
+        *restriction
+          == ConversionRestrictionKind::OptionalToImplicitlyUnwrappedOptional)
       return true;
 
     // Array-to-pointer conversions are better than inout-to-pointer conversions.

lib/Sema/Constraint.cpp

@@ -365,6 +365,10 @@ 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,6 +188,10 @@ 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.