[ConstraintSystem] Do not infer 'nil' arguments as optional throwing function types.

I have a follow-up change to correctly classify optional arguments,
and with that fix applied we incorrectly emit rethrow diagnostics for
'nil' arguments passed in places where optional throwing functions are
expected.

This change ensures that we strip the throwing bit off of the nested
function type so that we don't consider 'nil' arguments in these
positions as potentially throwing functions.

(cherry picked from commit 1ed46b4)

Author: rudkx

lib/Sema/CSBindings.cpp

@@ -365,6 +365,7 @@ ConstraintSystem::getPotentialBindings(TypeVariableType *typeVar) {
   auto &tc = getTypeChecker();
   bool hasNonDependentMemberRelationalConstraints = false;
   bool hasDependentMemberRelationalConstraints = false;
+  bool sawNilLiteral = false;
   for (auto constraint : constraints) {
     switch (constraint->getKind()) {
     case ConstraintKind::Bind:
@@ -481,8 +482,10 @@ ConstraintSystem::getPotentialBindings(TypeVariableType *typeVar) {
       // If there is a 'nil' literal constraint, we might need optional
       // supertype bindings.
       if (constraint->getProtocol()->isSpecificProtocol(
-              KnownProtocolKind::ExpressibleByNilLiteral))
+              KnownProtocolKind::ExpressibleByNilLiteral)) {
+        sawNilLiteral = true;
         addOptionalSupertypeBindings = true;
+      }
 
       // If there is a default literal type for this protocol, it's a
       // potential binding.
@@ -721,6 +724,32 @@ ConstraintSystem::getPotentialBindings(TypeVariableType *typeVar) {
       result.Bindings.clear();
   }
 
+  // Revise any optional-of-function-types we may try to nil literals
+  // to be non-throwing so they don't inadvertantly result in rethrows
+  // diagnostics.
+  if (sawNilLiteral) {
+    for (auto &binding : result.Bindings) {
+      auto nested = binding.BindingType->lookThroughAllOptionalTypes();
+      if (!nested)
+        continue;
+
+      if (!nested->is<FunctionType>())
+        continue;
+
+      // Remove throws from the nested function type.
+      binding.BindingType =
+          binding.BindingType.transform([&](Type inner) -> Type {
+            auto *fnTy = dyn_cast<FunctionType>(inner.getPointer());
+            if (!fnTy)
+              return inner;
+
+            auto extInfo = fnTy->getExtInfo().withThrows(false);
+            return FunctionType::get(fnTy->getParams(), fnTy->getResult(),
+                                     extInfo);
+          });
+    }
+  }
+
   return result;
 }
 

lib/Sema/TypeCheckError.cpp

@@ -146,6 +146,9 @@ class AbstractFunction {
       // Look through closure capture lists.
       } else if (auto captureList = dyn_cast<CaptureListExpr>(fn)) {
         fn = captureList->getClosureBody();
+        // Look through optional evaluations.
+      } else if (auto optionalEval = dyn_cast<OptionalEvaluationExpr>(fn)) {
+        fn = optionalEval->getSubExpr()->getValueProvidingExpr();
       } else {
         break;
       }