---

yaml
---
r: 346095
b: refs/heads/master
c: 65483f4
h: refs/heads/master
i:
  346093: 2d33ca8
  346091: 058dbc1
  346087: 2e613a5
  346079: 02acfbf

Author: swift-ci

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: cd417213a7faf267ec1f4a94886246fa5b6337e4
+refs/heads/master: 65483f43aeb5a15c6a25c23df90acaed106b45a2
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/lib/Sema/CSBindings.cpp

@@ -389,6 +389,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:
@@ -505,8 +506,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.
@@ -745,6 +748,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;
 }
 

trunk/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;
       }
@@ -710,7 +713,10 @@ class ApplyClassifier {
 
     // If it doesn't have function type, we must have invalid code.
     Type argType = fn.getType();
-    auto argFnType = (argType ? argType->getAs<AnyFunctionType>() : nullptr);
+    if (!argType) return Classification::forInvalidCode();
+
+    auto argFnType =
+        argType->lookThroughAllOptionalTypes()->getAs<AnyFunctionType>();
     if (!argFnType) return Classification::forInvalidCode();
 
     // If it doesn't throw, this argument does not cause the call to throw.

trunk/test/Constraints/sr9102.swift

@@ -0,0 +1,5 @@
+// RUN: %target-typecheck-verify-swift
+
+func test(_ a: [Int], _ f: ((Int) -> Bool)?) {
+  _ = a.filter(f!)
+}