Now that enough yaks are cleanly shaven, completely reimplement how

we process contextual constraints when producing diagnostic.  Formerly,
we would aggressively drop contextual type information on the floor under
the idea that it would reduce constraints on the system and make it more
likely to be solvable.  However, this also has the downside of introducing
ambiguity into the system, and some expr nodes (notably closures) cannot
usually be solved without that contextual information.

In the new model, expr diagnostics are expected to handle the fact that
contextual information may be present, and bail out without diagnosing an
error if that is the case.  This gets us more information into closures,
allowing more specific return type information, e.g. in the case in
test/expr/closure/closures.swift.

This approach also produces more correct diagnostics in a bunch of other
cases as well, e.g.:

-  var c = [:]  // expected-error {{type '[_ : _]' does not conform to protocol 'DictionaryLiteralConvertible'}} 
+  var c = [:]  // expected-error {{expression type '[_ : _]' is ambiguous without more context}}

and the examples in test/stmt/foreach.swift, test/expr/cast/as_coerce.swift,
test/expr/cast/array_iteration.swift, etc.

That said, this another two steps forward, one back thing.  Because we
don't handle propagating sametype constraints from results of calls to their
arguments, we regress a couple of (admittedly weird) cases.  This is now 
tracked by:
<rdar://problem/22333090> QoI: Propagate contextual information in a call to operands

There is also the one-off narrow case tracked by:
<rdar://problem/22333281> QoI: improve diagnostic when contextual type of closure disagrees with arguments



Swift SVN r31319

Author: lattner

lib/Sema/CSDiag.cpp

@@ -50,7 +50,8 @@ useDoubleList([1.0,2,3])
 useDoubleList([1.0,2.0,3.0])
 
 useIntDict(["Niners" => 31, "Ravens" => 34])
-useIntDict(["Niners" => 31, "Ravens" => 34.0]) // expected-error{{cannot convert value of type '(String, Double)' to expected element type '(String, Int)'}}
+// FIXME: rdar://22333090 improve diagnostic.
+useIntDict(["Niners" => 31, "Ravens" => 34.0]) // expected-error{{binary operator '=>' cannot be applied to operands of type 'String' and 'Double'}}
 useDoubleDict(["Niners" => 31, "Ravens" => 34.0])
 useDoubleDict(["Niners" => 31.0, "Ravens" => 34])
 useDoubleDict(["Niners" => 31.0, "Ravens" => 34.0])

test/Constraints/array_literal.swift

@@ -269,7 +269,6 @@ func rdar20029786(ns: NSString?) {
 // <rdar://problem/19813772> QoI: Using as! instead of as in this case produces really bad diagnostic
 func rdar19813772(nsma: NSMutableArray) {
   var a1 = nsma as! Array // expected-error{{argument for generic parameter 'Element' could not be inferred}}
-  // expected-warning @-1 {{cast from 'NSMutableArray' to unrelated type 'Array<_>' always fails}}
   var a2 = nsma as! Array<AnyObject> // expected-warning{{forced cast from 'NSMutableArray' to 'Array<AnyObject>' always succeeds; did you mean to use 'as'?}} {{17-20=as}}
   var a3 = nsma as Array<AnyObject>
 }

test/Constraints/bridging.swift

@@ -169,7 +169,7 @@ var ir2 = ((&i)) // expected-error{{type 'inout Int' of variable is not material
 func takeArrayRef(inout x:Array<String>) { }
 
 // FIXME rdar://22308291 Poor diagnostic.
-takeArrayRef(["asdf", "1234"]) // expected-error{{type 'inout Array<String>' does not conform to protocol 'ArrayLiteralConvertible'}}
+takeArrayRef(["asdf", "1234"]) // expected-error{{cannot convert value of type '[String]' to expected argument type 'inout Array<String>'}}
 
 // <rdar://problem/19835413> Reference to value from array changed
 func rdar19835413() {

test/Constraints/lvalues.swift

@@ -88,8 +88,8 @@ let _: () -> Any = {  // expected-error {{function signature '() -> Int' is not
   return 0
 }
 
-let _: () -> Int = { // expected-error {{cannot convert value of type '() -> String' to specified type '() -> Int'}}
-  () -> String in
+let _: () -> Int = { 
+  () -> String in  // expected-error {{declared closure result 'String' is incompatible with contextual type 'Int'}}
   return ""
 }
 

test/Constraints/protocols.swift

@@ -88,7 +88,10 @@ func testReturnTuple(x: Int, y: Float) {
 
   var _ : (Int, Float) = returnTuple(x)
   var _ : (Float, Float) = returnTuple(y)
-  var _ : (Int, Float) = returnTuple(y) // expected-error{{cannot convert value of type '(Float, _)' to specified type '(Int, Float)'}}
+
+  // FIXME rdar://22333090: Improve diagnostic
+  var _ : (Int, Float) = returnTuple(y) // expected-error{{cannot invoke 'returnTuple' with an argument list of type '(Float)'}}
+  // expected-note @-1 {{expected an argument list of type '(T)'}}
 }
 
 

test/Generics/deduction.swift

@@ -95,7 +95,7 @@ func constPointerArguments(p: UnsafeMutablePointer<Int>,
   takesConstPointer(ff) // expected-error{{cannot convert value of type '[Float]' to expected argument type 'UnsafePointer<Int>'}}
   takesConstPointer([0, 1, 2])
   // FIXME: improve QoI: rdar://22308330
-  takesConstPointer([0.0, 1.0, 2.0]) // expected-error{{type 'UnsafePointer<Int>' does not conform to protocol 'ArrayLiteralConvertible'}}
+  takesConstPointer([0.0, 1.0, 2.0]) // expected-error{{cannot convert value of type '[Double]' to expected argument type 'UnsafePointer<Int>'}}
 
   // We don't allow these conversions outside of function arguments.
   var x: UnsafePointer<Int> = &i // expected-error{{cannot convert value of type 'inout Int' to specified type 'UnsafePointer<Int>'}}

test/Parse/pointer_conversion.swift

@@ -95,8 +95,11 @@ func identity<T>(t: T) -> T { return t }
 func defaultArgTuplesNotMaterializable(x: Int, y: Int = 0) {}
 
 defaultArgTuplesNotMaterializable(identity(5))
+
+// FIXME: 22333090 - Improve diagnostic
 defaultArgTuplesNotMaterializable(identity((5, y: 10)))
-// expected-error@-1 {{cannot convert value of type '(Int, y: Int)' to expected argument type 'Int'}}
+// expected-error@-1 {{cannot invoke 'identity' with an argument list of type '(Int, y: Int)'}}
+// expected-note@-2 {{expected an argument list of type '(T)'}}
 
 
 // rdar://problem/21799331

test/decl/func/default-values.swift

@@ -16,7 +16,7 @@ for view in rootView.subviews as! [View] {
   doFoo()
 }
 
-for view:View in rootView.subviews { // expected-error{{'Array<AnyObject>!' is not convertible to 'View'}}
+for view:View in rootView.subviews { // expected-error{{'AnyObject' is not convertible to 'View'}}
   doFoo()
 }
 

test/expr/cast/array_iteration.swift

@@ -81,10 +81,10 @@ c3 as C4 // expected-error {{'C3' is not convertible to 'C4'; did you mean to us
 1 as Double as Float // expected-error{{cannot convert value of type 'Double' to type 'Float' in coercion}}
 1 as Int as String // expected-error{{cannot convert value of type 'Int' to type 'String' in coercion}}
 Double(1) as Double as String // expected-error{{cannot convert value of type 'Double' to type 'String' in coercion}}
-["awd"] as [Int] // expected-error{{'[Int]' is not convertible to 'Int'}}
+["awd"] as [Int] // expected-error{{cannot convert value of type '[String]' to type '[Int]' in coercion}}
 ([1, 2, 1.0], 1) as ([String], Int) // expected-error{{cannot convert value of type '([Double], Int)' (aka '(Array<Double>, Int)') to type '([String], Int)' (aka '(Array<String>, Int)') in coercion}}
 // FIXME: below diagnostic should say [[Int]], not [Array<Int>]
-[[1]] as [[String]] // expected-error{{'[[String]]' is not convertible to '[String]'}}
+[[1]] as [[String]] // expected-error{{cannot convert value of type '[Array<Int>]' to type '[[String]]' in coercion}}
 (1, 1.0) as (Int, Int) // expected-error{{cannot convert value of type '(Int, Double)' to type '(Int, Int)' in coercion}}
 (1.0, 1, "asd") as (String, Int, Float) // expected-error{{cannot convert value of type '(Double, Int, String)' to type '(String, Int, Float)' in coercion}}
 (1, 1.0, "a", [1, 23]) as (Int, Double, String, [String]) // expected-error{{cannot convert value of type '(Int, Double, String, [Int])' (aka '(Int, Double, String, Array<Int>)') to type '(Int, Double, String, [String])' (aka '(Int, Double, String, Array<String>)') in coercion}}

test/expr/cast/as_coerce.swift

@@ -26,7 +26,7 @@ func variadic() {
   f(1, 2)
   f(1, 3)
 
-  let D = { (Ss ...) in 1 } // expected-error{{'...' cannot be applied to a subpattern which is not explicitly typed}}, expected-error{{unable to infer closure type in the current context}}
+  let D = { (Ss ...) in 1 } // expected-error{{'...' cannot be applied to a subpattern which is not explicitly typed}}, expected-error{{unable to infer closure return type in current context}}
 }
 
 // Closures with attributes in the parameter list.

test/expr/closure/basic.swift

@@ -13,9 +13,9 @@ var closure2 : (Int,Int) -> Int = { 4 } // FIXME: expected-error{{tuple types '(
 var closure3a : ()->()->(Int,Int) = {{ (4, 2) }} // multi-level closing.
 var closure3b : (Int,Int)->(Int)->(Int,Int) = {{ (4, 2) }} // expected-error{{tuple types '(Int, Int)' and '()' have a different number of elements (2 vs. 0)}}
 var closure4 : (Int,Int) -> Int = { $0 + $1 }
-var closure5 : (Double) -> Int =
-   { // expected-error {{cannot convert value of type '(Double) -> Double' to specified type '(Double) -> Int'}}
-       $0 + 1.0 }
+var closure5 : (Double) -> Int = {
+       $0 + 1.0  // expected-error {{cannot convert value of type 'Double' to closure result type 'Int'}}
+}
 
 var closure6 = $0  // expected-error {{anonymous closure argument not contained in a closure}}
 

test/expr/closure/closures.swift

@@ -2,8 +2,8 @@
 
 func simple_default_args() {
   let _ : (Int) -> Int = {(x : Int = 1) in x+1} // expected-error{{default argument is only permitted for a non-curried function parameter}} {{36-39=}}
-  let _ : () -> Int = {(x : Int = 1) in x+1} // expected-error{{cannot convert value of type '(Int) -> Int' to specified type '() -> Int'}} expected-error {{default argument is only permitted for a non-curried function parameter}} {{33-36=}}
-  let _ : () -> Int = {(x : Int) in x+1} // expected-error{{cannot convert value of type '(Int) -> Int' to specified type '() -> Int'}}
+  let _ : () -> Int = {(x : Int = 1) in x+1} // expected-error{{cannot convert value of type 'Int -> Int' to specified type '() -> Int'}} expected-error {{default argument is only permitted for a non-curried function parameter}} {{33-36=}}
+  let _ : () -> Int = {(x : Int) in x+1} // expected-error{{cannot convert value of type 'Int -> Int' to specified type '() -> Int'}}
 }
 
 func func_default_args() {

test/expr/closure/default_args.swift

@@ -47,8 +47,13 @@ func basictest() {
   x8 = x8 + 1
   x8 + 1
   0 + x8
-  1.0 + x8 // expected-error{{binary operator '+' cannot be applied to operands of type 'Double' and 'Int8'}} expected-note {{overloads for '+' exist with these partially matching parameter lists:}}
-  var x9 : Int16 = x8 + 1 // expected-error{{cannot convert value of type 'Int8' to specified type 'Int16'}}
+  1.0 + x8 // expected-error{{binary operator '+' cannot be applied to operands of type 'Double' and 'Int8'}}
+  // expected-note @-1 {{overloads for '+' exist with these partially matching parameter lists:}}
+
+
+  // FIXME rdar://22333090 - Improve diagnostic.
+  var x9 : Int16 = x8 + 1 // expected-error{{binary operator '+' cannot be applied to operands of type 'Int8' and 'Int'}}
+  // expected-note @-1 {{overloads for '+' exist with these partially matching parameter lists:}}
 
   // Various tuple types.
   var tuple1 : ()
@@ -139,8 +144,8 @@ acceptsInt(unknown_var) // expected-error {{use of unresolved identifier 'unknow
 // and support the '=' operator.
 
 
-// FIXME: Bogus error
-var test1a: (Int) -> (Int) -> Int = { { $0 } } // expected-error{{type of expression is ambiguous without more context}}
+// FIXME rdar://22333281: Poor error message.
+var test1a: (Int) -> (Int) -> Int = { { $0 } } // expected-error{{tuple pattern cannot match values of the non-tuple type 'Int'}}
 var test1b = { 42 }
 var test1c = { { 42 } }
 var test1d = { { { 42 } } }
@@ -629,13 +634,13 @@ func unusedExpressionResults() {
 func arrayLiterals() { 
   var a = [1,2,3]
   var b : [Int] = []
-  var c = []  // expected-error {{type '[_]' does not conform to protocol 'ArrayLiteralConvertible'}}
+  var c = []  // expected-error {{expression type '[_]' is ambiguous without more context}}
 }
 
 func dictionaryLiterals() {
   var a = [1 : "foo",2 : "bar",3 : "baz"]
   var b : Dictionary<Int, String> = [:]
-  var c = [:]  // expected-error {{type '[_ : _]' does not conform to protocol 'DictionaryLiteralConvertible'}} 
+  var c = [:]  // expected-error {{expression type '[_ : _]' is ambiguous without more context}}
 }
 
 func invalidDictionaryLiteral() {

test/expr/expressions.swift

@@ -1,5 +1,4 @@
 // RUN: %target-swift-frontend -parse -verify %s
-
 enum MSV : ErrorType {
   case Foo, Bar, Baz
 
@@ -159,7 +158,7 @@ func ==(a: Thirteen, b: Thirteen) -> Bool { return true }
 
 func thirteen_helper(fn: (Thirteen) -> ()) {}
 func thirteen() {
-  thirteen_helper { (a) in // expected-error {{invalid conversion from throwing function of type '(_) throws -> ()' to non-throwing function type '(Thirteen) -> ()'}}
+  thirteen_helper { (a) in // expected-error {{invalid conversion from throwing function of type '_ throws -> ()' to non-throwing function type '(Thirteen) -> ()'}}
     do {
       try thrower()
     } catch a {

test/stmt/errors.swift

@@ -60,7 +60,7 @@ func patterns(gir: GoodRange<Int>, gtr: GoodTupleGeneratorType) {
   var sumf : Float
   for i : Int in gir { sum = sum + i }
   for i in gir { sum = sum + i }
-  for f : Float in gir { sum = sum + f } // expected-error{{'GoodRange<Int>' is not convertible to 'Float'}}
+  for f : Float in gir { sum = sum + f } // expected-error{{'Int' is not convertible to 'Float'}}
 
   for (i, f) : (Int, Float) in gtr { sum = sum + i }
 
@@ -72,7 +72,7 @@ func patterns(gir: GoodRange<Int>, gtr: GoodTupleGeneratorType) {
 
   for (i, _) : (Int, Float) in gtr { sum = sum + i }
 
-  for (i, _) : (Int, Int) in gtr { sum = sum + i } // expected-error{{'GoodTupleGeneratorType' is not convertible to '(Int, Int)'}}
+  for (i, _) : (Int, Int) in gtr { sum = sum + i } // expected-error{{'Element' (aka '(Int, Float)') is not convertible to '(Int, Int)'}}
 
   for (i, f) in gtr {}
 }