Merge pull request swiftlang#22212 from xedin/rdar-47550715

[TypeChecker] Classify `nil` literal and `.none` as non-contriburing to throws

Author: xedin

lib/Sema/CSBindings.cpp

@@ -389,7 +389,6 @@ 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:
@@ -507,7 +506,6 @@ ConstraintSystem::getPotentialBindings(TypeVariableType *typeVar) {
       // supertype bindings.
       if (constraint->getProtocol()->isSpecificProtocol(
               KnownProtocolKind::ExpressibleByNilLiteral)) {
-        sawNilLiteral = true;
         addOptionalSupertypeBindings = true;
       }
 
@@ -748,32 +746,6 @@ 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

@@ -679,6 +679,16 @@ class ApplyClassifier {
   Classification classifyRethrowsArgument(Expr *arg, Type paramType) {
     arg = arg->getValueProvidingExpr();
 
+    // If this argument is `nil` literal or `.none`,
+    // it doesn't cause the call to throw.
+    if (auto *DSCE = dyn_cast<DotSyntaxCallExpr>(arg)) {
+      if (auto *DE = dyn_cast<DeclRefExpr>(DSCE->getFn())) {
+        auto &ctx = paramType->getASTContext();
+        if (DE->getDecl() == ctx.getOptionalNoneDecl())
+          return Classification();
+      }
+    }
+
     // If the parameter was structurally a tuple, try to look through the
     // various tuple operations.
     if (auto paramTupleType = dyn_cast<TupleType>(paramType.getPointer())) {

test/decl/func/rethrows.swift

@@ -602,4 +602,13 @@ class RethrowingConstructor {
       try throwingFunc()
     }
   }
-}
+}
+
+// default values -vs- throwing function inside optional
+func rdar_47550715() {
+  typealias A<T> = (T) -> Void
+  typealias F = () throws -> Void
+
+  func foo(_: A<F>? = nil) {} // Ok
+  func bar(_: A<F>? = .none) {} // Ok
+}