mirror of
https://github.com/apple/swift.git
synced 2025-12-21 12:14:44 +01:00
5d5872bb83
Instead of binding collection types directly let's try to bind using temporary type variables substituted for element types, that's going to ensure that subtype relationship is always preserved. Resolves: rdar://problem/35541153
544 lines
22 KiB
Swift
544 lines
22 KiB
Swift
// RUN: %target-typecheck-verify-swift
|
|
|
|
infix operator +++
|
|
|
|
protocol ConcatToAnything {
|
|
static func +++ <T>(lhs: Self, other: T)
|
|
}
|
|
|
|
func min<T : Comparable>(_ x: T, y: T) -> T {
|
|
if y < x { return y }
|
|
return x
|
|
}
|
|
|
|
func weirdConcat<T : ConcatToAnything, U>(_ t: T, u: U) {
|
|
t +++ u
|
|
t +++ 1
|
|
u +++ t // expected-error{{argument type 'U' does not conform to expected type 'ConcatToAnything'}}
|
|
}
|
|
|
|
// Make sure that the protocol operators don't get in the way.
|
|
var b1, b2 : Bool
|
|
_ = b1 != b2
|
|
|
|
extension UnicodeScalar {
|
|
func isAlpha2() -> Bool {
|
|
return (self >= "A" && self <= "Z") || (self >= "a" && self <= "z")
|
|
}
|
|
}
|
|
|
|
protocol P {
|
|
static func foo(_ arg: Self) -> Self
|
|
}
|
|
struct S : P {
|
|
static func foo(_ arg: S) -> S {
|
|
return arg
|
|
}
|
|
}
|
|
|
|
func foo<T : P>(_ arg: T) -> T {
|
|
return T.foo(arg)
|
|
}
|
|
|
|
// Associated types and metatypes
|
|
protocol SomeProtocol {
|
|
associatedtype SomeAssociated
|
|
}
|
|
|
|
func generic_metatypes<T : SomeProtocol>(_ x: T)
|
|
-> (T.Type, T.SomeAssociated.Type)
|
|
{
|
|
return (type(of: x), type(of: x).SomeAssociated.self)
|
|
}
|
|
|
|
// Inferring a variable's type from a call to a generic.
|
|
struct Pair<T, U> { } // expected-note 4 {{'T' declared as parameter to type 'Pair'}} expected-note {{'U' declared as parameter to type 'Pair'}}
|
|
|
|
func pair<T, U>(_ x: T, _ y: U) -> Pair<T, U> { }
|
|
|
|
var i : Int, f : Float
|
|
var p = pair(i, f)
|
|
|
|
// Conformance constraints on static variables.
|
|
func f1<S1 : Sequence>(_ s1: S1) {}
|
|
var x : Array<Int> = [1]
|
|
f1(x)
|
|
|
|
// Inheritance involving generics and non-generics.
|
|
class X {
|
|
func f() {}
|
|
}
|
|
|
|
class Foo<T> : X {
|
|
func g() { }
|
|
}
|
|
|
|
class Y<U> : Foo<Int> {
|
|
}
|
|
|
|
func genericAndNongenericBases(_ x: Foo<Int>, y: Y<()>) {
|
|
x.f()
|
|
y.f()
|
|
y.g()
|
|
}
|
|
|
|
func genericAndNongenericBasesTypeParameter<T : Y<()>>(_ t: T) {
|
|
t.f()
|
|
t.g()
|
|
}
|
|
|
|
protocol P1 {}
|
|
protocol P2 {}
|
|
|
|
func foo<T : P1>(_ t: T) -> P2 {
|
|
return t // expected-error{{return expression of type 'T' does not conform to 'P2'}}
|
|
}
|
|
|
|
func foo2(_ p1: P1) -> P2 {
|
|
return p1 // expected-error{{return expression of type 'P1' does not conform to 'P2'}}
|
|
}
|
|
|
|
// <rdar://problem/14005696>
|
|
protocol BinaryMethodWorkaround {
|
|
associatedtype MySelf
|
|
}
|
|
|
|
protocol Squigglable : BinaryMethodWorkaround {
|
|
}
|
|
|
|
infix operator ~~~
|
|
|
|
func ~~~ <T : Squigglable>(lhs: T, rhs: T) -> Bool where T.MySelf == T {
|
|
return true
|
|
}
|
|
|
|
extension UInt8 : Squigglable {
|
|
typealias MySelf = UInt8
|
|
}
|
|
|
|
var rdar14005696 : UInt8
|
|
_ = rdar14005696 ~~~ 5
|
|
|
|
// <rdar://problem/15168483>
|
|
public struct SomeIterator<C: Collection, Indices: Sequence>
|
|
: IteratorProtocol, Sequence
|
|
where C.Index == Indices.Iterator.Element {
|
|
var seq : C
|
|
var indices : Indices.Iterator
|
|
|
|
public typealias Element = C.Iterator.Element
|
|
|
|
public mutating func next() -> Element? {
|
|
fatalError()
|
|
}
|
|
|
|
public init(elements: C, indices: Indices) {
|
|
fatalError()
|
|
}
|
|
}
|
|
func f1<T>(seq: Array<T>) {
|
|
let x = (seq.indices).lazy.reversed()
|
|
SomeIterator(elements: seq, indices: x) // expected-warning{{unused}}
|
|
SomeIterator(elements: seq, indices: seq.indices.reversed()) // expected-warning{{unused}}
|
|
}
|
|
|
|
|
|
// <rdar://problem/16078944>
|
|
func count16078944<T>(_ x: Range<T>) -> Int { return 0 }
|
|
|
|
func test16078944 <T: Comparable>(lhs: T, args: T) -> Int {
|
|
return count16078944(lhs..<args) // don't crash
|
|
}
|
|
|
|
|
|
// <rdar://problem/22409190> QoI: Passing unsigned integer to ManagedBuffer elements.destroy()
|
|
class r22409190ManagedBuffer<Value, Element> {
|
|
final var value: Value { get {} set {}}
|
|
func withUnsafeMutablePointerToElements<R>(
|
|
_ body: (UnsafeMutablePointer<Element>) -> R) -> R {
|
|
}
|
|
}
|
|
class MyArrayBuffer<Element>: r22409190ManagedBuffer<UInt, Element> {
|
|
deinit {
|
|
self.withUnsafeMutablePointerToElements { elems -> Void in
|
|
elems.deinitialize(count: self.value) // expected-error {{cannot convert value of type 'UInt' to expected argument type 'Int'}}
|
|
}
|
|
}
|
|
}
|
|
|
|
// <rdar://problem/22459135> error: 'print' is unavailable: Please wrap your tuple argument in parentheses: 'print((...))'
|
|
func r22459135() {
|
|
func h<S : Sequence>(_ sequence: S) -> S.Iterator.Element
|
|
where S.Iterator.Element : FixedWidthInteger {
|
|
return 0
|
|
}
|
|
|
|
func g(_ x: Any) {}
|
|
func f(_ x: Int) {
|
|
g(h([3]))
|
|
}
|
|
|
|
func f2<TargetType: AnyObject>(_ target: TargetType, handler: @escaping (TargetType) -> ()) {
|
|
let _: (AnyObject) -> () = { internalTarget in
|
|
handler(internalTarget as! TargetType)
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// <rdar://problem/19710848> QoI: Friendlier error message for "[] as Set"
|
|
// <rdar://problem/22326930> QoI: "argument for generic parameter 'Element' could not be inferred" lacks context
|
|
_ = [] as Set // expected-error {{generic parameter 'Element' could not be inferred in cast to 'Set<_>}} expected-note {{explicitly specify the generic arguments to fix this issue}} {{14-14=<<#Element: Hashable#>>}}
|
|
|
|
|
|
//<rdar://problem/22509125> QoI: Error when unable to infer generic archetype lacks greatness
|
|
func r22509125<T>(_ a : T?) { // expected-note {{in call to function 'r22509125'}}
|
|
r22509125(nil) // expected-error {{generic parameter 'T' could not be inferred}}
|
|
}
|
|
|
|
|
|
// <rdar://problem/24267414> QoI: error: cannot convert value of type 'Int' to specified type 'Int'
|
|
struct R24267414<T> { // expected-note {{'T' declared as parameter to type 'R24267414'}}
|
|
static func foo() -> Int {}
|
|
}
|
|
var _ : Int = R24267414.foo() // expected-error {{generic parameter 'T' could not be inferred}} expected-note {{explicitly specify the generic arguments to fix this issue}} {{24-24=<Any>}}
|
|
|
|
|
|
// https://bugs.swift.org/browse/SR-599
|
|
func SR599<T: FixedWidthInteger>() -> T.Type { return T.self } // expected-note {{in call to function 'SR599()'}}
|
|
_ = SR599() // expected-error {{generic parameter 'T' could not be inferred}}
|
|
|
|
|
|
|
|
|
|
// <rdar://problem/19215114> QoI: Poor diagnostic when we are unable to infer type
|
|
protocol Q19215114 {}
|
|
protocol P19215114 {}
|
|
|
|
// expected-note @+1 {{in call to function 'body9215114'}}
|
|
func body9215114<T: P19215114, U: Q19215114>(_ t: T) -> (_ u: U) -> () {}
|
|
|
|
func test9215114<T: P19215114, U: Q19215114>(_ t: T) -> (U) -> () {
|
|
//Should complain about not being able to infer type of U.
|
|
let f = body9215114(t) // expected-error {{generic parameter 'T' could not be inferred}}
|
|
return f
|
|
}
|
|
|
|
// <rdar://problem/21718970> QoI: [uninferred generic param] cannot invoke 'foo' with an argument list of type '(Int)'
|
|
class Whatever<A: Numeric, B: Numeric> { // expected-note 2 {{'A' declared as parameter to type 'Whatever'}}
|
|
static func foo(a: B) {}
|
|
|
|
static func bar() {}
|
|
|
|
}
|
|
Whatever.foo(a: 23) // expected-error {{generic parameter 'A' could not be inferred}} expected-note {{explicitly specify the generic arguments to fix this issue}} {{9-9=<<#A: Numeric#>, <#B: Numeric#>>}}
|
|
|
|
// <rdar://problem/21718955> Swift useless error: cannot invoke 'foo' with no arguments
|
|
Whatever.bar() // expected-error {{generic parameter 'A' could not be inferred}} expected-note {{explicitly specify the generic arguments to fix this issue}} {{9-9=<<#A: Numeric#>, <#B: Numeric#>>}}
|
|
|
|
// <rdar://problem/27515965> Type checker doesn't enforce same-type constraint if associated type is Any
|
|
protocol P27515965 {
|
|
associatedtype R
|
|
func f() -> R
|
|
}
|
|
|
|
struct S27515965 : P27515965 {
|
|
func f() -> Any { return self }
|
|
}
|
|
|
|
struct V27515965 {
|
|
init<T : P27515965>(_ tp: T) where T.R == Float {}
|
|
// expected-note@-1 {{candidate requires that the types 'Any' and 'Float' be equivalent (requirement specified as 'T.R' == 'Float' [with T = S27515965])}}
|
|
}
|
|
|
|
func test(x: S27515965) -> V27515965 {
|
|
return V27515965(x)
|
|
// expected-error@-1 {{cannot invoke initializer for type 'init(_:)' with an argument list of type '(S27515965)'}}
|
|
}
|
|
|
|
protocol BaseProto {}
|
|
protocol SubProto: BaseProto {}
|
|
@objc protocol NSCopyish {
|
|
func copy() -> Any
|
|
}
|
|
|
|
struct FullyGeneric<Foo> {} // expected-note 11 {{'Foo' declared as parameter to type 'FullyGeneric'}} expected-note 1 {{generic type 'FullyGeneric' declared here}}
|
|
|
|
struct AnyClassBound<Foo: AnyObject> {} // expected-note {{'Foo' declared as parameter to type 'AnyClassBound'}} expected-note {{generic type 'AnyClassBound' declared here}}
|
|
struct AnyClassBound2<Foo> where Foo: AnyObject {} // expected-note {{'Foo' declared as parameter to type 'AnyClassBound2'}}
|
|
|
|
struct ProtoBound<Foo: SubProto> {} // expected-note {{'Foo' declared as parameter to type 'ProtoBound'}} expected-note {{generic type 'ProtoBound' declared here}}
|
|
struct ProtoBound2<Foo> where Foo: SubProto {} // expected-note {{'Foo' declared as parameter to type 'ProtoBound2'}}
|
|
|
|
struct ObjCProtoBound<Foo: NSCopyish> {} // expected-note {{'Foo' declared as parameter to type 'ObjCProtoBound'}} expected-note {{generic type 'ObjCProtoBound' declared here}}
|
|
struct ObjCProtoBound2<Foo> where Foo: NSCopyish {} // expected-note {{'Foo' declared as parameter to type 'ObjCProtoBound2'}}
|
|
|
|
struct ClassBound<Foo: X> {} // expected-note {{generic type 'ClassBound' declared here}}
|
|
struct ClassBound2<Foo> where Foo: X {} // expected-note {{generic type 'ClassBound2' declared here}}
|
|
|
|
struct ProtosBound<Foo> where Foo: SubProto & NSCopyish {} // expected-note {{'Foo' declared as parameter to type 'ProtosBound'}} expected-note {{generic type 'ProtosBound' declared here}}
|
|
struct ProtosBound2<Foo: SubProto & NSCopyish> {} // expected-note {{'Foo' declared as parameter to type 'ProtosBound2'}}
|
|
struct ProtosBound3<Foo: SubProto> where Foo: NSCopyish {} // expected-note {{'Foo' declared as parameter to type 'ProtosBound3'}}
|
|
|
|
struct AnyClassAndProtoBound<Foo> where Foo: AnyObject, Foo: SubProto {} // expected-note {{'Foo' declared as parameter to type 'AnyClassAndProtoBound'}}
|
|
struct AnyClassAndProtoBound2<Foo> where Foo: SubProto, Foo: AnyObject {} // expected-note {{'Foo' declared as parameter to type 'AnyClassAndProtoBound2'}}
|
|
|
|
struct ClassAndProtoBound<Foo> where Foo: X, Foo: SubProto {} // expected-note {{'Foo' declared as parameter to type 'ClassAndProtoBound'}}
|
|
|
|
struct ClassAndProtosBound<Foo> where Foo: X, Foo: SubProto, Foo: NSCopyish {} // expected-note {{'Foo' declared as parameter to type 'ClassAndProtosBound'}}
|
|
struct ClassAndProtosBound2<Foo> where Foo: X, Foo: SubProto & NSCopyish {} // expected-note {{'Foo' declared as parameter to type 'ClassAndProtosBound2'}}
|
|
|
|
extension Pair {
|
|
init(first: T) {}
|
|
init(second: U) {}
|
|
|
|
var first: T { fatalError() }
|
|
var second: U { fatalError() }
|
|
}
|
|
|
|
func testFixIts() {
|
|
_ = FullyGeneric() // expected-error {{generic parameter 'Foo' could not be inferred}} expected-note {{explicitly specify the generic arguments to fix this issue}} {{19-19=<Any>}}
|
|
_ = FullyGeneric<Any>()
|
|
|
|
_ = AnyClassBound() // expected-error {{generic parameter 'Foo' could not be inferred}} expected-note {{explicitly specify the generic arguments to fix this issue}} {{20-20=<AnyObject>}}
|
|
_ = AnyClassBound<Any>() // expected-error {{'Any' is not convertible to 'AnyObject'}}
|
|
_ = AnyClassBound<AnyObject>()
|
|
|
|
_ = AnyClassBound2() // expected-error {{generic parameter 'Foo' could not be inferred}} expected-note {{explicitly specify the generic arguments to fix this issue}} {{21-21=<AnyObject>}}
|
|
_ = AnyClassBound2<Any>() // expected-error {{'Any' is not convertible to 'AnyObject'}}
|
|
_ = AnyClassBound2<AnyObject>()
|
|
|
|
_ = ProtoBound() // expected-error {{generic parameter 'Foo' could not be inferred}} expected-note {{explicitly specify the generic arguments to fix this issue}} {{17-17=<<#Foo: SubProto#>>}}
|
|
_ = ProtoBound<Any>() // expected-error {{type 'Any' does not conform to protocol 'SubProto'}}
|
|
|
|
_ = ProtoBound2() // expected-error {{generic parameter 'Foo' could not be inferred}} expected-note {{explicitly specify the generic arguments to fix this issue}} {{18-18=<<#Foo: SubProto#>>}}
|
|
_ = ProtoBound2<Any>() // expected-error {{type 'Any' does not conform to protocol 'SubProto'}}
|
|
|
|
_ = ObjCProtoBound() // expected-error {{generic parameter 'Foo' could not be inferred}} expected-note {{explicitly specify the generic arguments to fix this issue}} {{21-21=<NSCopyish>}}
|
|
_ = ObjCProtoBound<AnyObject>() // expected-error {{type 'AnyObject' does not conform to protocol 'NSCopyish'}}
|
|
_ = ObjCProtoBound<NSCopyish>()
|
|
|
|
_ = ObjCProtoBound2() // expected-error {{generic parameter 'Foo' could not be inferred}} expected-note {{explicitly specify the generic arguments to fix this issue}} {{22-22=<NSCopyish>}}
|
|
_ = ObjCProtoBound2<AnyObject>() // expected-error {{type 'AnyObject' does not conform to protocol 'NSCopyish'}}
|
|
_ = ObjCProtoBound2<NSCopyish>()
|
|
|
|
_ = ProtosBound() // expected-error {{generic parameter 'Foo' could not be inferred}} expected-note {{explicitly specify the generic arguments to fix this issue}} {{18-18=<<#Foo: NSCopyish & SubProto#>>}}
|
|
_ = ProtosBound2() // expected-error {{generic parameter 'Foo' could not be inferred}} expected-note {{explicitly specify the generic arguments to fix this issue}} {{19-19=<<#Foo: NSCopyish & SubProto#>>}}
|
|
_ = ProtosBound3() // expected-error {{generic parameter 'Foo' could not be inferred}} expected-note {{explicitly specify the generic arguments to fix this issue}} {{19-19=<<#Foo: NSCopyish & SubProto#>>}}
|
|
|
|
_ = AnyClassAndProtoBound() // expected-error {{generic parameter 'Foo' could not be inferred}} expected-note {{explicitly specify the generic arguments to fix this issue}} {{28-28=<<#Foo: SubProto & AnyObject#>>}}
|
|
_ = AnyClassAndProtoBound2() // expected-error {{generic parameter 'Foo' could not be inferred}} expected-note {{explicitly specify the generic arguments to fix this issue}} {{29-29=<<#Foo: SubProto & AnyObject#>>}}
|
|
|
|
_ = ClassAndProtoBound() // expected-error {{generic parameter 'Foo' could not be inferred}} expected-note {{explicitly specify the generic arguments to fix this issue}} {{25-25=<<#Foo: X & SubProto#>>}}
|
|
|
|
_ = ClassAndProtosBound() // expected-error {{generic parameter 'Foo' could not be inferred}} expected-note {{explicitly specify the generic arguments to fix this issue}} {{26-26=<<#Foo: X & NSCopyish & SubProto#>>}}
|
|
_ = ClassAndProtosBound2() // expected-error {{generic parameter 'Foo' could not be inferred}} expected-note {{explicitly specify the generic arguments to fix this issue}} {{27-27=<<#Foo: X & NSCopyish & SubProto#>>}}
|
|
|
|
_ = Pair() // expected-error {{generic parameter 'T' could not be inferred}} expected-note {{explicitly specify the generic arguments to fix this issue}} {{11-11=<Any, Any>}}
|
|
_ = Pair(first: S()) // expected-error {{generic parameter 'U' could not be inferred}} expected-note {{explicitly specify the generic arguments to fix this issue}} {{11-11=<S, Any>}}
|
|
_ = Pair(second: S()) // expected-error {{generic parameter 'T' could not be inferred}} expected-note {{explicitly specify the generic arguments to fix this issue}} {{11-11=<Any, S>}}
|
|
}
|
|
|
|
func testFixItClassBound() {
|
|
// We infer a single class bound for simple cases in expressions...
|
|
let x = ClassBound()
|
|
let x1: String = x // expected-error {{cannot convert value of type 'ClassBound<X>' to specified type 'String'}}
|
|
|
|
let y = ClassBound2()
|
|
let y1: String = y // expected-error {{cannot convert value of type 'ClassBound2<X>' to specified type 'String'}}
|
|
|
|
// ...but not in types.
|
|
let z1: ClassBound // expected-error {{reference to generic type 'ClassBound' requires arguments in <...>}} {{21-21=<X>}}
|
|
let z2: ClassBound2 // expected-error {{reference to generic type 'ClassBound2' requires arguments in <...>}} {{22-22=<X>}}
|
|
}
|
|
|
|
func testFixItCasting(x: Any) {
|
|
_ = x as! FullyGeneric // expected-error {{generic parameter 'Foo' could not be inferred in cast to 'FullyGeneric<_>'}} expected-note {{explicitly specify the generic arguments to fix this issue}} {{25-25=<Any>}}
|
|
}
|
|
|
|
func testFixItContextualKnowledge() {
|
|
// FIXME: These could propagate backwards.
|
|
let _: Int = Pair().first // expected-error {{generic parameter 'T' could not be inferred}} expected-note {{explicitly specify the generic arguments to fix this issue}} {{20-20=<Any, Any>}}
|
|
let _: Int = Pair().second // expected-error {{generic parameter 'T' could not be inferred}} expected-note {{explicitly specify the generic arguments to fix this issue}} {{20-20=<Any, Any>}}
|
|
}
|
|
|
|
func testFixItTypePosition() {
|
|
let _: FullyGeneric // expected-error {{reference to generic type 'FullyGeneric' requires arguments in <...>}} {{22-22=<Any>}}
|
|
let _: ProtoBound // expected-error {{reference to generic type 'ProtoBound' requires arguments in <...>}} {{20-20=<<#Foo: SubProto#>>}}
|
|
let _: ObjCProtoBound // expected-error {{reference to generic type 'ObjCProtoBound' requires arguments in <...>}} {{24-24=<NSCopyish>}}
|
|
let _: AnyClassBound // expected-error {{reference to generic type 'AnyClassBound' requires arguments in <...>}} {{23-23=<AnyObject>}}
|
|
let _: ProtosBound // expected-error {{reference to generic type 'ProtosBound' requires arguments in <...>}} {{21-21=<<#Foo: NSCopyish & SubProto#>>}}
|
|
}
|
|
|
|
func testFixItNested() {
|
|
_ = Array<FullyGeneric>() // expected-error {{generic parameter 'Foo' could not be inferred}}
|
|
// expected-note@-1 {{explicitly specify the generic arguments to fix this issue}} {{25-25=<Any>}}
|
|
_ = [FullyGeneric]() // expected-error {{generic parameter 'Foo' could not be inferred}} expected-note {{explicitly specify the generic arguments to fix this issue}} {{20-20=<Any>}}
|
|
|
|
_ = FullyGeneric<FullyGeneric>() // expected-error {{generic parameter 'Foo' could not be inferred}}
|
|
|
|
_ = Pair< // expected-error {{generic parameter 'Foo' could not be inferred}}
|
|
FullyGeneric,
|
|
// expected-note@-1 {{explicitly specify the generic arguments to fix this issue}} {{17-17=<Any>}}
|
|
FullyGeneric // FIXME: We could diagnose both of these, but we don't.
|
|
>()
|
|
_ = Pair< // expected-error {{generic parameter 'Foo' could not be inferred}}
|
|
FullyGeneric<Any>,
|
|
FullyGeneric
|
|
>()
|
|
_ = Pair< // expected-error {{generic parameter 'Foo' could not be inferred}}
|
|
FullyGeneric,
|
|
// expected-note@-1 {{explicitly specify the generic arguments to fix this issue}} {{17-17=<Any>}}
|
|
FullyGeneric<Any>
|
|
>()
|
|
|
|
_ = pair( // expected-error {{generic parameter 'Foo' could not be inferred}} {{none}}
|
|
FullyGeneric(), // expected-note {{explicitly specify the generic arguments to fix this issue}}
|
|
FullyGeneric()
|
|
)
|
|
_ = pair( // expected-error {{generic parameter 'Foo' could not be inferred}} {{none}}
|
|
FullyGeneric<Any>(),
|
|
FullyGeneric() // expected-note {{explicitly specify the generic arguments to fix this issue}}
|
|
)
|
|
_ = pair( // expected-error {{generic parameter 'Foo' could not be inferred}} {{none}}
|
|
FullyGeneric(), // expected-note {{explicitly specify the generic arguments to fix this issue}}
|
|
FullyGeneric<Any>()
|
|
)
|
|
}
|
|
|
|
// rdar://problem/26845038
|
|
func occursCheck26845038(a: [Int]) {
|
|
_ = Array(a)[0]
|
|
}
|
|
|
|
// rdar://problem/29633747
|
|
extension Array where Element: Hashable {
|
|
public func trimmed(_ elements: [Element]) -> SubSequence {
|
|
return []
|
|
}
|
|
}
|
|
|
|
func rdar29633747(characters: String) {
|
|
let _ = Array(characters).trimmed(["("])
|
|
}
|
|
|
|
// Null pointer dereference in noteArchetypeSource()
|
|
class GenericClass<A> {}
|
|
// expected-note@-1 {{'A' declared as parameter to type 'GenericClass'}}
|
|
|
|
func genericFunc<T>(t: T) {
|
|
_ = [T: GenericClass] // expected-error {{generic parameter 'A' could not be inferred}}
|
|
// expected-note@-1 {{explicitly specify the generic arguments to fix this issue}}
|
|
// expected-error@-2 3 {{type 'T' does not conform to protocol 'Hashable'}}
|
|
}
|
|
|
|
struct SR_3525<T> {}
|
|
func sr3525_arg_int(_: inout SR_3525<Int>) {}
|
|
func sr3525_arg_gen<T>(_: inout SR_3525<T>) {}
|
|
func sr3525_1(t: SR_3525<Int>) {
|
|
let _ = sr3525_arg_int(&t) // expected-error {{cannot pass immutable value as inout argument: 't' is a 'let' constant}}
|
|
}
|
|
func sr3525_2(t: SR_3525<Int>) {
|
|
let _ = sr3525_arg_gen(&t) // expected-error {{cannot pass immutable value as inout argument: 't' is a 'let' constant}}
|
|
}
|
|
func sr3525_3<T>(t: SR_3525<T>) {
|
|
let _ = sr3525_arg_gen(&t) // expected-error {{cannot pass immutable value as inout argument: 't' is a 'let' constant}}
|
|
}
|
|
|
|
class testStdlibType {
|
|
let _: Array // expected-error {{reference to generic type 'Array' requires arguments in <...>}} {{15-15=<Any>}}
|
|
}
|
|
|
|
// rdar://problem/32697033
|
|
protocol P3 {
|
|
associatedtype InnerAssoc
|
|
}
|
|
|
|
protocol P4 {
|
|
associatedtype OuterAssoc: P3
|
|
}
|
|
|
|
struct S3 : P3 {
|
|
typealias InnerAssoc = S4
|
|
}
|
|
|
|
struct S4: P4 {
|
|
typealias OuterAssoc = S3
|
|
}
|
|
|
|
public struct S5 {
|
|
func f<Model: P4, MO> (models: [Model])
|
|
where Model.OuterAssoc == MO, MO.InnerAssoc == Model {
|
|
}
|
|
|
|
func g<MO, Model: P4> (models: [Model])
|
|
where Model.OuterAssoc == MO, MO.InnerAssoc == Model {
|
|
}
|
|
|
|
func f(arr: [S4]) {
|
|
f(models: arr)
|
|
g(models: arr)
|
|
}
|
|
}
|
|
|
|
// rdar://problem/24329052 - QoI: call argument archetypes not lining up leads to ambiguity errors
|
|
|
|
struct S_24329052<T> { // expected-note {{generic parameter 'T' of generic struct 'S_24329052' declared here}}
|
|
var foo: (T) -> Void
|
|
// expected-note@+1 {{generic parameter 'T' of instance method 'bar(_:)' declared here}}
|
|
func bar<T>(_ v: T) { foo(v) }
|
|
// expected-error@-1 {{cannot convert value of type 'T' (generic parameter of instance method 'bar(_:)') to expected argument type 'T' (generic parameter of generic struct 'S_24329052')}}
|
|
}
|
|
|
|
extension Sequence {
|
|
var rdar24329052: (Element) -> Void { fatalError() }
|
|
// expected-note@+1 {{generic parameter 'Element' of instance method 'foo24329052(_:)' declared here}}
|
|
func foo24329052<Element>(_ v: Element) { rdar24329052(v) }
|
|
// expected-error@-1 {{cannot convert value of type 'Element' (generic parameter of instance method 'foo24329052(_:)') to expected argument type 'Self.Element' (associated type of protocol 'Sequence')}}
|
|
}
|
|
|
|
func rdar27700622<E: Comparable>(_ input: [E]) -> [E] {
|
|
let pivot = input.first!
|
|
let lhs = input.dropFirst().filter { $0 <= pivot }
|
|
let rhs = input.dropFirst().filter { $0 > pivot }
|
|
|
|
return rdar27700622(lhs) + [pivot] + rdar27700622(rhs) // Ok
|
|
}
|
|
|
|
// rdar://problem/22898292 - Type inference failure with constrained subclass
|
|
protocol P_22898292 {}
|
|
|
|
do {
|
|
func construct_generic<T: P_22898292>(_ construct: () -> T) -> T { return construct() }
|
|
|
|
class A {}
|
|
class B : A, P_22898292 {}
|
|
|
|
func foo() -> B { return B() }
|
|
func bar(_ value: A) {}
|
|
func baz<T: A>(_ value: T) {}
|
|
|
|
func rdar_22898292_1() {
|
|
let x = construct_generic { foo() } // returns A
|
|
bar(x) // Ok
|
|
bar(construct_generic { foo() }) // Ok
|
|
}
|
|
|
|
func rdar22898292_2<T: B>(_ d: T) {
|
|
_ = { baz($0) }(construct_generic { d }) // Ok
|
|
}
|
|
}
|
|
|
|
// rdar://problem/35541153 - Generic parameter inference bug
|
|
|
|
func rdar35541153() {
|
|
func foo<U: Equatable, V: Equatable, C: Collection>(_ c: C) where C.Element == (U, V) {}
|
|
func bar<K: Equatable, V, C: Collection>(_ c: C, _ k: K, _ v: V) where C.Element == (K, V) {}
|
|
|
|
let x: [(a: Int, b: Int)] = []
|
|
let y: [(k: String, v: Int)] = []
|
|
|
|
foo(x) // Ok
|
|
bar(y, "ultimate question", 42) // Ok
|
|
}
|