[CSOptimizer] Infer argument candidates from calls to Double and CGFloat constructors

Helps situations like `1 + {Double, CGFloat}(...)` by inferring
a type for the second operand of `+` based on a type being constructed.

Currently limited to Double and CGFloat only since we need to
support implicit `Double<->CGFloat` conversion.

Helps situations like `1 + CGFloat(...)` by inferring a type for
the second operand of `+` based on a type being constructed.
Currently limited to known integer, floating-point and CGFloat types
since we know how they are structured.

Author: xedin

include/swift/Sema/ConstraintSystem.h

@@ -497,6 +497,10 @@ class TypeVariableType::Implementation {
   /// literal (represented by `ArrayExpr` and `DictionaryExpr` in AST).
   bool isCollectionLiteralType() const;
 
+  /// Determine whether this type variable represents a result type of a
+  /// function call.
+  bool isFunctionResult() const;
+
   /// Retrieve the representative of the equivalence class to which this
   /// type variable belongs.
   ///

lib/Sema/CSOptimizer.cpp

@@ -250,6 +250,23 @@ static Constraint *determineBestChoicesInContext(
                 {literal.second.getDefaultType(), /*fromLiteral=*/true});
           }
         }
+
+        // Helps situations like `1 + {Double, CGFloat}(...)` by inferring
+        // a type for the second operand of `+` based on a type being constructed.
+        //
+        // Currently limited to Double and CGFloat only since we need to 
+        // support implicit `Double<->CGFloat` conversion.
+        if (typeVar->getImpl().isFunctionResult() &&
+            isOperatorDisjunction(disjunction)) {
+          auto resultLoc = typeVar->getImpl().getLocator();
+          if (auto *call = getAsExpr<CallExpr>(resultLoc->getAnchor())) {
+            if (auto *typeExpr = dyn_cast<TypeExpr>(call->getFn())) {
+              auto instanceTy = cs.getType(typeExpr)->getMetatypeInstanceType();
+              if (instanceTy->isDouble() || instanceTy->isCGFloat())
+                types.push_back({instanceTy, /*fromLiteral=*/false});
+            }
+          }
+        }
       } else {
         types.push_back({argType, /*fromLiteral=*/false});
       }

lib/Sema/TypeCheckConstraints.cpp

@@ -204,6 +204,10 @@ bool TypeVariableType::Implementation::isCollectionLiteralType() const {
                      locator->directlyAt<DictionaryExpr>());
 }
 
+bool TypeVariableType::Implementation::isFunctionResult() const {
+  return locator && locator->isLastElement<LocatorPathElt::FunctionResult>();
+}
+
 void *operator new(size_t bytes, ConstraintSystem& cs,
                    size_t alignment) {
   return cs.getAllocator().Allocate(bytes, alignment);

test/Constraints/implicit_double_cgfloat_conversion.swift

@@ -342,3 +342,22 @@ func test_init_validation() {
     }
   }
 }
+
+do {
+  struct G<T> {
+    init(_: T) {}
+  }
+
+  func round(_: Double) -> Double {}
+  func round<T: FloatingPoint>(_: T) -> T {}
+
+  func test_cgfloat_over_double(withColors colors: Int, size: CGSize) -> G<CGFloat> {
+    let g = G(1.0 / CGFloat(colors))
+    return g // Ok
+  }
+
+  func test_no_ambiguity(width: Int, height: Int) -> CGFloat {
+    let v = round(CGFloat(width / height) * 10) / 10.0
+    return v // Ok
+  }
+}