[ConstraintSystem] Allow attempting generic unary operators in presence of Double<->CGFloat conversion

Not all of the unary operators have `CGFloat` overloads,
so in order to preserve previous behavior (and overall
best solution) with implicit Double<->CGFloat conversion
we need to allow  attempting generic operators for such cases.

```swift
let _: CGFloat = -.pi / 2
```

`-` doesn't have `CGFloat` overload (which might be an oversight),
so in order to preserve type-checking behavior solver can't be
allowed to pick `-(Double) -> Double` based on overload of `/`,
the best possible solution would be with `/` as `(CGFloat, CGFloat) -> CGFloat`
and `-` on a `FloatingPoint` protocol.

Author: xedin

include/swift/Sema/ConstraintSystem.h

@@ -5349,11 +5349,12 @@ class DisjunctionChoice {
 
   bool isBeginningOfPartition() const { return IsBeginningOfPartition; }
 
-  // FIXME: Both of the accessors below are required to support
+  // FIXME: All three of the accessors below are required to support
   //        performance optimization hacks in constraint solver.
 
   bool isGenericOperator() const;
   bool isSymmetricOperator() const;
+  bool isUnaryOperator() const;
 
   void print(llvm::raw_ostream &Out, SourceManager *SM) const {
     Out << "disjunction choice ";

lib/Sema/CSSolver.cpp

@@ -2167,6 +2167,15 @@ bool DisjunctionChoice::isSymmetricOperator() const {
   return firstType->isEqual(secondType);
 }
 
+bool DisjunctionChoice::isUnaryOperator() const {
+  auto *decl = getOperatorDecl(Choice);
+  if (!decl)
+    return false;
+
+  auto func = cast<FuncDecl>(decl);
+  return func->getParameters()->size() == 1;
+}
+
 void DisjunctionChoice::propagateConversionInfo(ConstraintSystem &cs) const {
   assert(ExplicitConversion);
 

lib/Sema/CSStep.cpp

@@ -696,8 +696,18 @@ bool DisjunctionStep::shouldSkip(const DisjunctionChoice &choice) const {
   //        already have a solution involving non-generic operators,
   //        but continue looking for a better non-generic operator
   //        solution.
-  if (shouldSkipGenericOperators() && choice.isGenericOperator()) {
-    return skip("generic");
+  if (BestNonGenericScore && choice.isGenericOperator()) {
+    auto &score = BestNonGenericScore->Data;
+
+    // Not all of the unary operators have `CGFloat` overloads,
+    // so in order to preserve previous behavior (and overall
+    // best solution) with implicit Double<->CGFloat conversion
+    // we need to allow  attempting generic operators for such cases.
+    if (score[SK_ImplicitValueConversion] > 0 && choice.isUnaryOperator())
+      return false;
+
+    if (shouldSkipGenericOperators())
+      return skip("generic");
   }
 
   return false;