[ConstraintSystem] Let optional chaining infer a type from sub-expression even with contextual mismatch

Just like in case of `try?` it makes it easier to distinguish between
missing optional unwrap and contextual type mismatch.

Author: xedin

lib/Sema/CSDiagnostics.cpp

@@ -1958,12 +1958,12 @@ bool ContextualFailure::diagnoseAsError() {
     if (diagnoseYieldByReferenceMismatch())
       return true;
 
-    if (auto *OTE = dyn_cast<OptionalTryExpr>(anchor)) {
-      auto tryType = fromType->getOptionalObjectType();
-      if (tryType->isEqual(toType)) {
+    if (isa<OptionalTryExpr>(anchor) || isa<OptionalEvaluationExpr>(anchor)) {
+      auto objectType = fromType->getOptionalObjectType();
+      if (objectType->isEqual(toType)) {
         auto &cs = getConstraintSystem();
-        MissingOptionalUnwrapFailure failure(cs, getType(OTE), toType,
-                                             cs.getConstraintLocator(OTE));
+        MissingOptionalUnwrapFailure failure(cs, getType(anchor), toType,
+                                             cs.getConstraintLocator(anchor));
         if (failure.diagnoseAsError())
           return true;
       }

lib/Sema/CSSimplify.cpp

@@ -2596,6 +2596,15 @@ repairViaOptionalUnwrap(ConstraintSystem &cs, Type fromType, Type toType,
   if (!anchor)
     return false;
 
+  bool possibleContextualMismatch = false;
+  // If this is a conversion to a non-optional contextual type e.g.
+  // `let _: Bool = try? foo()` and `foo()` produces `Int`
+  // we should diagnose it as type mismatch instead of missing unwrap.
+  if (auto last = locator.last()) {
+    possibleContextualMismatch = last->is<LocatorPathElt::ContextualType>() &&
+                                 !toType->getOptionalObjectType();
+  }
+
   // `OptionalEvaluationExpr` doesn't add a new level of
   // optionality but it could be hiding concrete types
   // behind itself which we can use to better understand
@@ -2612,7 +2621,12 @@ repairViaOptionalUnwrap(ConstraintSystem &cs, Type fromType, Type toType,
     // other type e.g. contextual type or a parameter type,
     // let's use `Bind` to match object types because
     // object type of the optinal chain is a type variable.
-    if (matchKind >= ConstraintKind::Conversion)
+    //
+    // One exception is contextual conversion - in such cases
+    // let's give optional chain a chance to infer its inner type
+    // first, that makes it much easier to diagnose contextual
+    // mismatch vs. missing optional unwrap.
+    if (!possibleContextualMismatch && matchKind >= ConstraintKind::Conversion)
       matchKind = ConstraintKind::Bind;
   }
 
@@ -2644,13 +2658,12 @@ repairViaOptionalUnwrap(ConstraintSystem &cs, Type fromType, Type toType,
       // language mode, so we can safely try to bind its
       // object type to contextual type without risk of
       // causing more optionality mismatches down the road.
-      auto last = locator.last();
+      //
       // For contextual conversions let's give `try?` a chance to
       // infer inner type which, if incorrect, should result in
       // contextual conversion failure instead of optional unwrap.
-      matchKind = last && last->is<LocatorPathElt::ContextualType>()
-                      ? ConstraintKind::Conversion
-                      : ConstraintKind::Bind;
+      matchKind = possibleContextualMismatch ? ConstraintKind::Conversion
+                                             : ConstraintKind::Bind;
     }
   }