[ConstraintSolver] Penalize conversions from String to UnsafePointer

There are possible situations when we find solutions with String
and String -> UnsafePointer conversions at the same time for
expressions with default string literals. In order to disambiguite
such situations let's prefer solutions without String -> UnsafePointer
conversions if possible.

Author: xedin

lib/Sema/CSRanking.cpp

@@ -83,6 +83,10 @@ void ConstraintSystem::increaseScore(ScoreKind kind, unsigned value) {
     case SK_KeyPathSubscript:
       log << "key path subscript";
       break;
+
+    case SK_StringToPointerConversion:
+      log << "string-to-pointer conversion";
+      break;
     }
     log << ")\n";
   }

lib/Sema/CSSimplify.cpp

@@ -4397,6 +4397,8 @@ ConstraintSystem::simplifyRestrictedConstraintImpl(
     // If we haven't resolved the element type, generate constraints.
     if (baseType2->isTypeVariableOrMember()) {
       if (flags.contains(TMF_GenerateConstraints)) {
+        increaseScore(SK_StringToPointerConversion);
+
         auto int8Con = Constraint::create(*this, ConstraintKind::Bind,
                                        baseType2, TC.getInt8Type(DC),
                                        getConstraintLocator(locator));
@@ -4418,6 +4420,8 @@ ConstraintSystem::simplifyRestrictedConstraintImpl(
     if (!isStringCompatiblePointerBaseType(TC, DC, baseType2)) {
       return SolutionKind::Error;
     }
+
+    increaseScore(SK_StringToPointerConversion);
     return SolutionKind::Solved;
   }
 

lib/Sema/ConstraintSystem.h

@@ -416,8 +416,10 @@ enum ScoreKind {
   SK_EmptyExistentialConversion,
   /// A key path application subscript.
   SK_KeyPathSubscript,
-  
-  SK_LastScoreKind = SK_KeyPathSubscript,
+  // A conversion from a string to a pointer.
+  SK_StringToPointerConversion,
+
+  SK_LastScoreKind = SK_StringToPointerConversion,
 };
 
 /// The number of score kinds.

test/Constraints/overload.swift

@@ -222,3 +222,4 @@ func curry<F, S, T, R>(_ f: @escaping (F, S, T) -> R) -> (F) -> (S) -> (T) -> R
 // Ensure that we consider these unambiguous
 let _ = curry(+)(1)
 let _ = [0].reduce(0, +)
+let _ = curry(+)("string vs. pointer")

validation-test/Sema/rdar32204609.swift

@@ -8,4 +8,4 @@
 let x: Int! = nil
 let y: Int! = 1
 
-print(x == y)
+print(x == y)