[CSOptimizer] Allow matching candidates with optional types against generic paameter types

For example passing `Int?` to `T` should be considered a match
if `T` doesn't have any requirements that block it.

Author: xedin

lib/Sema/CSOptimizer.cpp

@@ -926,7 +926,10 @@ static void determineBestChoicesInContext(
         paramType = paramType->lookThroughAllOptionalTypes(paramOptionals);
 
         if (!candidateOptionals.empty() || !paramOptionals.empty()) {
-          if (paramOptionals.size() >= candidateOptionals.size()) {
+          // Can match i.e. Int? to Int or T to Int?
+          if ((paramOptionals.empty() &&
+               paramType->is<GenericTypeParamType>()) ||
+              paramOptionals.size() >= candidateOptionals.size()) {
             auto score = scoreCandidateMatch(genericSig, choice, candidateType,
                                              paramType, options);
             // Injection lowers the score slightly to comply with
@@ -1031,6 +1034,11 @@ static void determineBestChoicesInContext(
           }
         }
 
+        // If there are no requirements associated with the generic
+        // parameter or dependent member type it could match any type.
+        if (requirements.empty())
+          return 0.7;
+
         // If some of the requirements cannot be satisfied, because
         // they reference other generic parameters, for example:
         // `<T, U, where T.Element == U.Element>`, let's perform a

test/Constraints/nil-coalescing-favoring.swift

@@ -28,3 +28,17 @@ do {
     let _: Super = x
   }
 }
+
+// Reduced from vapor project. Favoring _only_ an overload of `??` and takes `T?` as a second parameter would result in an invalid solution.
+extension Array where Element == UInt8 {
+  init?(decodingBase32 str: String) {
+    guard let decoded = str.utf8.withContiguousStorageIfAvailable({ Array(decodingBase32: $0) }) ?? Array(decodingBase32: Array(str.utf8)) else { // Ok
+      return nil
+    }
+    self = decoded
+  }
+
+  init?<C>(decodingBase32 bytes: C) where C: RandomAccessCollection, C.Element == UInt8, C.Index == Int {
+    fatalError()
+  }
+}

test/SILOptimizer/infinite_recursion.swift

@@ -282,7 +282,7 @@ public class U {
 }
 
 func == (l: S?, r: S?) -> Bool {
-  if l == nil && r == nil { return true } // expected-warning {{function call causes an infinite recursion}}
+  if l == nil && r == nil { return true }
   guard let l = l, let r = r else { return false }
   return l === r
 }

validation-test/Sema/type_checker_perf/fast/nil_coalescing_dictionary_values.swift.gyb

@@ -5,6 +5,6 @@ let x: Int?
 
 let _ = [
 %for i in range(0, N):
-  "%{i}" : x ?? 0,
+  "${i}" : x ?? 0,
 %end
 ]