[ConstraintSystem] Adjust impact of implicit Double <-> CGFloat conversions

- Prefer CGFloat -> Double over the other way around to avoid
  ambiguities;

- Every new conversion impacts the score by factor of number of
  previously applied conversions to make it possible to select
  solutions that require the least such conversions.

- Prefer concrete overloads with Double <-> CGFloat conversion
  over generic ones.

Author: xedin

include/swift/Sema/ConstraintSystem.h

@@ -790,10 +790,6 @@ enum ScoreKind {
   SK_DisfavoredOverload,
   /// A member for an \c UnresolvedMemberExpr found via unwrapped optional base.
   SK_UnresolvedMemberViaOptional,
-  /// An implicit conversion from a value of one type (lhs)
-  /// to another type (rhs) via implicit initialization of
-  /// `rhs` type which an argument of `lhs` value.
-  SK_ImplicitValueConversion,
   /// An implicit force of an implicitly unwrapped optional value.
   SK_ForceUnchecked,
   /// A user-defined conversion.
@@ -814,8 +810,12 @@ enum ScoreKind {
   SK_ValueToPointerConversion,
   /// A closure/function conversion to an autoclosure parameter.
   SK_FunctionToAutoClosureConversion,
+  /// An implicit conversion from a value of one type (lhs)
+  /// to another type (rhs) via implicit initialization of
+  /// `rhs` type which an argument of `lhs` value.
+  SK_ImplicitValueConversion,
 
-  SK_LastScoreKind = SK_FunctionToAutoClosureConversion,
+  SK_LastScoreKind = SK_ImplicitValueConversion,
 };
 
 /// The number of score kinds.

lib/Sema/CSSimplify.cpp

@@ -10527,7 +10527,14 @@ ConstraintSystem::simplifyRestrictedConstraintImpl(
 
   case ConversionRestrictionKind::DoubleToCGFloat:
   case ConversionRestrictionKind::CGFloatToDouble: {
-    increaseScore(SK_ImplicitValueConversion);
+    // Prefer CGFloat -> Double over other way araund.
+    auto defaultImpact =
+        restriction == ConversionRestrictionKind::CGFloatToDouble ? 1 : 2;
+
+    auto numConversions = CurrentScore.Data[SK_ImplicitValueConversion];
+    increaseScore(SK_ImplicitValueConversion,
+                  defaultImpact * (numConversions + 1));
+
     if (worseThanBestSolution())
       return SolutionKind::Error;
 

lib/Sema/CSStep.cpp

@@ -710,7 +710,6 @@ bool DisjunctionStep::shouldStopAt(const DisjunctionChoice &choice) const {
   auto *lastChoice = LastSolvedChoice->first;
   auto delta = LastSolvedChoice->second - getCurrentScore();
   bool hasUnavailableOverloads = delta.Data[SK_Unavailable] > 0;
-  bool hasImplicitConversions = delta.Data[SK_ImplicitValueConversion] > 0;
   bool hasFixes = delta.Data[SK_Fix] > 0;
   bool hasAsyncMismatch = delta.Data[SK_AsyncInSyncMismatch] > 0;
   auto isBeginningOfPartition = choice.isBeginningOfPartition();
@@ -720,9 +719,7 @@ bool DisjunctionStep::shouldStopAt(const DisjunctionChoice &choice) const {
   //   1. selecting unavailable overloads
   //   2. result in fixes being applied to reach a solution
   //   3. selecting an overload that results in an async/sync mismatch
-  //   4. implicit value conversions
   return !hasUnavailableOverloads && !hasFixes && !hasAsyncMismatch &&
-         !hasImplicitConversions &&
          (isBeginningOfPartition ||
           shortCircuitDisjunctionAt(choice, lastChoice));
 }

lib/Sema/CSStep.h

@@ -691,11 +691,10 @@ class DisjunctionStep final : public BindingStep<DisjunctionChoiceProducer> {
     // non-generic score indicates that there were no forced
     // unwrappings of optional(s), no unavailable overload
     // choices present in the solution, no fixes required,
-    // and there are no non-trivial function or value conversions.
+    // and there are no non-trivial function conversions.
     auto &score = BestNonGenericScore->Data;
     return (score[SK_ForceUnchecked] == 0 && score[SK_Unavailable] == 0 &&
-            score[SK_Fix] == 0 && score[SK_FunctionConversion] == 0 &&
-            score[SK_ImplicitValueConversion] == 0);
+            score[SK_Fix] == 0 && score[SK_FunctionConversion] == 0);
   }
 
   /// Attempt to apply given disjunction choice to constraint system.

stdlib/public/Darwin/CoreGraphics/CGFloat.swift.gyb

@@ -470,6 +470,11 @@ extension CGFloat {
     lhs /= rhs
     return lhs
   }
+
+  @_transparent
+  public static prefix func -(x: CGFloat) -> CGFloat {
+    return 0 - x
+  }
 }
 
 //===----------------------------------------------------------------------===//
@@ -596,7 +601,8 @@ public func remquo(_ x: CGFloat, _ y: CGFloat) -> (CGFloat, Int) {
            "use CGFloat(nan: CGFloat.RawSignificand) instead.")
 @_transparent
 public func nan(_ tag: String) -> CGFloat {
-  return CGFloat(nan(tag) as CGFloat.NativeType)
+  let NaN: Float = nan(tag)
+  return CGFloat(CGFloat.NativeType(NaN))
 }
 
 @_transparent

test/Misc/misc_diagnostics.swift

@@ -186,14 +186,14 @@ func test_implicit_cgfloat_conversion() {
   test_to(f) // expected-error {{cannot convert value of type 'Float' to expected argument type 'CGFloat'}}
   test_to(d + d) // Ok (Double -> CGFloat for both arguments)
   test_to(d + cgf) // Ok
-  test_to(d + cgf - d) // expected-error {{ambiguous use of operator '+'}} (Both Double and CGFloat are equaly viable here)
+  test_to(d + cgf - d) // Ok (prefer CGFloat -> Double for `cgf`), it's a better solution than trying to convert `d`s to `CGFloat`
   test_to(d + cgf - cgf) // Ok (only one choice here to conver `d` to CGFloat)
 
   test_from(cgf) // Ok (CGFloat -> Double)
   test_from(f) // expected-error {{cannot convert value of type 'Float' to expected argument type 'Double'}}
   test_from(cgf + cgf) // Ok (CGFloat -> Double for both arguments)
   test_from(d + cgf) // Ok
-  test_from(cgf + d - cgf) // expected-error {{ambiguous use of operator '+'}} (Both Double and CGFloat are equaly viable here)
+  test_from(cgf + d - cgf) // (prefer Double -> CGFloat for `d`), it's a better solution than trying to convert `cgf`s to `Double`
   test_from(cgf + d - d) // Ok (only one choice here to conver `cgf` to Double)
 
   func test_returns_double(_: CGFloat) -> Double {

validation-test/Sema/type_checker_perf/slow/rdar46541800.swift renamed to validation-test/Sema/type_checker_perf/fast/rdar46541800.swift

@@ -16,7 +16,7 @@ class SomeView {
     let displayScale: CGFloat = CGFloat()
     let _ = (descriptionTextViewFrame.height 
              + (-descriptionTextView.lastBaselineOffsetFromBottom - textInset.bottom + descriptionLabelProperties.lastBaselineOffsetFromBottom)
-             + (-descriptionTextView.firstBaselineOffsetFromTop - textInset.top + descriptionTextBaselineOffset).ceilingValue(scale: displayScale) // expected-error {{reasonable time}}
+             + (-descriptionTextView.firstBaselineOffsetFromTop - textInset.top + descriptionTextBaselineOffset).ceilingValue(scale: displayScale)
             )
   }