mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
cf2e7f6f45
The issue here is that the constraint solver was deciding on FixKind::RelabelCallTuple as the fix for the problem and emitting the diagnostic, even though there were two different fixes possible. CSDiags has the infrastructure to support doing doing the right thing here, but is only being used for ApplyExprs, not SubscriptExprs. The solution is to fix both problems: remove FixKind::RelabelCallTuple, to let CSDiags handle the problem, and enhance CSDiags to treat SubscriptExpr more commonly with ApplyExpr. This improves several cases where the solver was picking one solution randomly and suggesting that as a fix, instead of listing that there are multiple different solutions.
98 lines
2.7 KiB
Swift
98 lines
2.7 KiB
Swift
// RUN: %target-parse-verify-swift
|
|
|
|
// Simple subscript of arrays:
|
|
func simpleSubscript(array: [Float], x: Int) -> Float {
|
|
_ = array[x]
|
|
return array[x]
|
|
}
|
|
|
|
// Subscript of archetype.
|
|
protocol IntToStringSubscript {
|
|
subscript (i : Int) -> String { get }
|
|
}
|
|
|
|
class LameDictionary {
|
|
subscript (i : Int) -> String {
|
|
get {
|
|
return String(i)
|
|
}
|
|
}
|
|
}
|
|
|
|
func archetypeSubscript<T : IntToStringSubscript, U : LameDictionary>(t: T, u: U)
|
|
-> String {
|
|
// Subscript an archetype.
|
|
if false { return t[17] }
|
|
|
|
// Subscript an archetype for which the subscript operator is in a base class.
|
|
return u[17]
|
|
}
|
|
|
|
// Subscript of existential type.
|
|
func existentialSubscript(a: IntToStringSubscript) -> String {
|
|
return a[17]
|
|
}
|
|
|
|
class MyDictionary<Key, Value> {
|
|
subscript (key : Key) -> Value {
|
|
get {}
|
|
}
|
|
}
|
|
|
|
class MyStringToInt<T> : MyDictionary<String, Int> { }
|
|
|
|
// Subscript of generic type.
|
|
func genericSubscript<T>(t: T,
|
|
array: Array<Int>,
|
|
i2i: MyDictionary<Int, Int>,
|
|
t2i: MyDictionary<T, Int>,
|
|
s2i: MyStringToInt<()>) -> Int {
|
|
if true { return array[5] }
|
|
if true { return i2i[5] }
|
|
if true { return t2i[t] }
|
|
return s2i["hello"]
|
|
}
|
|
|
|
|
|
|
|
// <rdar://problem/21364448> QoI: Poor error message for ambiguous subscript call
|
|
extension String {
|
|
func number() -> Int { } // expected-note {{found this candidate}}
|
|
func number() -> Double { } // expected-note {{found this candidate}}
|
|
}
|
|
|
|
let _ = "a".number // expected-error {{ambiguous use of 'number()'}}
|
|
|
|
extension Int {
|
|
subscript(key: String) -> Int { get {} } // expected-note {{found this candidate}}
|
|
subscript(key: String) -> Double { get {} } // expected-note {{found this candidate}}
|
|
}
|
|
|
|
let _ = 1["1"] // expected-error {{ambiguous use of 'subscript'}}
|
|
|
|
|
|
// rdar://17687826 - QoI: error message when reducing to an untyped dictionary isn't helpful
|
|
let squares = [ 1, 2, 3 ].reduce([:]) { (dict, n) in // expected-error {{expression type '[_ : _]' is ambiguous without more context}}
|
|
var dict = dict
|
|
dict[n] = n * n
|
|
return dict
|
|
}
|
|
|
|
// <rdar://problem/23670252> QoI: Misleading error message when assigning a value from [String : AnyObject]
|
|
func r23670252(dictionary: [String : AnyObject], someObject: AnyObject) {
|
|
let color : String?
|
|
color = dictionary["color"] // expected-error {{cannot assign value of type 'AnyObject?' to type 'String?'}}
|
|
_ = color
|
|
}
|
|
|
|
|
|
// SR-718 - Type mismatch reported as extraneous parameter
|
|
struct SR718 {
|
|
subscript(b : Int) -> Int
|
|
{ return 0 }
|
|
subscript(a a : UInt) -> Int { return 0 }
|
|
}
|
|
|
|
SR718()[a: Int()] // expected-error {{cannot convert value of type 'Int' to expected argument type 'UInt'}}
|
|
|