mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
58fa8bf762
The flow was such that we recorded subtype constraints regardless of the subject type's nature. Extract value generics handling out of the devious `else if` chain, and never record any subtype constraints if the subject type is a non-type parameter. While we're here, generalize the diagnostic message for user-written subtype constraints on value generic parameters and emit it consistently, not just if the right-hand side contains a protocol type.
225 lines
8.5 KiB
Swift
225 lines
8.5 KiB
Swift
// RUN: %target-typecheck-verify-swift -disable-availability-checking
|
|
|
|
protocol P {}
|
|
protocol Q {}
|
|
class Class {}
|
|
|
|
func invalid<let N>() { // expected-error {{value generic 'N' must have an explicit value type declared}}
|
|
// expected-error@-1 {{generic parameter 'N' is not used in function signature}}
|
|
let x: String = N // Fine, we bind to a hole.
|
|
}
|
|
func invalid<let N>(_: A<N>) {} // expected-error {{value generic 'N' must have an explicit value type declared}}
|
|
|
|
struct A<let N: Int> {
|
|
var int: Int {
|
|
N // OK
|
|
}
|
|
|
|
var uint: UInt {
|
|
N // expected-error {{cannot convert return expression of type 'Int' to return type 'UInt'}}
|
|
}
|
|
|
|
var goodUInt: UInt {
|
|
UInt(N) // OK
|
|
}
|
|
|
|
var intSelf: Int {
|
|
N.self // OK
|
|
}
|
|
|
|
var n: N { // expected-error {{using value generic 'N' here is not allowed}}
|
|
fatalError()
|
|
}
|
|
|
|
var nType: N.Type { // expected-error {{using value generic 'N' here is not allowed}}
|
|
fatalError()
|
|
}
|
|
|
|
var a: A<N> { // OK
|
|
fatalError()
|
|
}
|
|
}
|
|
|
|
extension A where N == Int {} // expected-error {{cannot constrain value parameter 'N' to be type 'Int'}}
|
|
|
|
extension A where N == 123 {
|
|
func thing() -> Int {
|
|
N // OK (this used to crash the compiler in a concrete case 'where N == 123')
|
|
}
|
|
}
|
|
|
|
func b(with a: A<123>) {} // OK
|
|
func c<let M: Int>(with a: A<M>) {} // OK
|
|
func d<T>(with a: A<T>) {} // expected-error {{cannot pass type 'T' as a value for generic value 'N'}}
|
|
func e(with a: A<Int>) {} // expected-error {{cannot pass type 'Int' as a value for generic value 'N'}}
|
|
|
|
func *<let X: Int, let Y: Int>(l: A<X>, r: A<Y>) -> Int { l.int * r.int }
|
|
|
|
struct Generic<T: ~Copyable & ~Escapable> {}
|
|
struct GenericWithIntParam<T: ~Copyable & ~Escapable, let N: Int> {}
|
|
|
|
extension Generic where T == 123 {} // expected-error {{cannot constrain type parameter 'T' to be integer '123'}}
|
|
extension Generic where T == 123.Type {} // expected-error {{cannot constrain type parameter 'T' to be integer '123'}}
|
|
// expected-error@-1 {{expected '{' in extension}}
|
|
extension Generic where T == 123? {} // expected-error {{cannot constrain type parameter 'T' to be integer '123'}}
|
|
// expected-error@-1 {{expected '{' in extension}}
|
|
|
|
func f(_: Generic<123>) {} // expected-error {{integer unexpectedly used in a type position}}
|
|
func g<let N: Int>(_: Generic<N>) {} // expected-error {{cannot use value type 'N' for generic argument 'T'}}
|
|
func h(_: (Int, 123)) {} // expected-error {{expected type}}
|
|
func i(_: () -> 123) {} // expected-error {{expected type}}
|
|
func j(_: (A<123>) -> ()) {} // OK
|
|
func k(_: some 123) {} // expected-error {{expected parameter type following ':'}}
|
|
func l(_: GenericWithIntParam<123, Int>) {}
|
|
// expected-error@-1 {{cannot pass type 'Int' as a value for generic value 'N'}}
|
|
// expected-error@-2 {{cannot use value type '123' for generic argument 'T'}}
|
|
func m(_: GenericWithIntParam<Int, 123>) {} // OK
|
|
|
|
typealias One = 1 // expected-error {{expected type in type alias declaration}}
|
|
|
|
// Unsupported type in value type parameter definition.
|
|
do {
|
|
struct S1<let N: UInt8> {}
|
|
// expected-error@-1:20 {{'UInt8' is not a supported value type for 'N'}}
|
|
struct S2<let N: Any> {}
|
|
// expected-error@-1:20 {{'Any' is not a supported value type for 'N'}}
|
|
struct S3<let N: AnyObject> {}
|
|
// expected-error@-1:20 {{'AnyObject' is not a supported value type for 'N'}}
|
|
struct S4<let N: Class> {}
|
|
// expected-error@-1:20 {{'Class' is not a supported value type for 'N'}}
|
|
struct S5<let N: P> {}
|
|
// expected-error@-1:20 {{'P' is not a supported value type for 'N'}}
|
|
struct S6<let N: P & Q> {}
|
|
// expected-error@-1:20 {{'P & Q' is not a supported value type for 'N'}}
|
|
struct S7<let N: ~Copyable> {}
|
|
// expected-error@-1:20 {{'~Copyable' is not a supported value type for 'N'}}
|
|
}
|
|
|
|
// Subtype constraint on value type parameter.
|
|
|
|
struct S1<let x: Int> where x: Class, x: P, x: P & Q, x: Int, x: ~Copyable {}
|
|
// expected-error@-1:30 {{cannot use type constraint with generic value parameter 'x'}}
|
|
// expected-error@-2:40 {{cannot use type constraint with generic value parameter 'x'}}
|
|
// expected-error@-3:46 {{cannot use type constraint with generic value parameter 'x'}}
|
|
// expected-error@-4:56 {{cannot use type constraint with generic value parameter 'x'}}
|
|
// expected-error@-5:64 {{cannot use type constraint with generic value parameter 'x'}}
|
|
extension S1 where x: Class, x: P, x: P & Q, x: Int, x: ~Copyable {}
|
|
// expected-error@-1:21 {{cannot use type constraint with generic value parameter 'x'}}
|
|
// expected-error@-2:31 {{cannot use type constraint with generic value parameter 'x'}}
|
|
// expected-error@-3:37 {{cannot use type constraint with generic value parameter 'x'}}
|
|
// expected-error@-4:47 {{cannot use type constraint with generic value parameter 'x'}}
|
|
// expected-error@-5:55 {{cannot use type constraint with generic value parameter 'x'}}
|
|
|
|
struct C<let N: Int, let M: Int> {}
|
|
|
|
extension C where N == 123 { // expected-note {{where 'N' = '0'}}
|
|
// expected-note@-1 {{where 'N' = '0'}}
|
|
// expected-note@-2 {{where 'N' = 'T'}}
|
|
func nIs123() {}
|
|
}
|
|
|
|
extension C where M == 321 { // expected-note {{where 'M' = '0'}}
|
|
// expected-note@-1 {{where 'M' = '0'}}
|
|
// expected-note@-2 {{where 'M' = 'T'}}
|
|
func mIs123() {}
|
|
}
|
|
|
|
extension C where N == M { // expected-note {{where 'N' = '123', 'M' = '0'}}
|
|
// expected-note@-1 {{where 'N' = '0', 'M' = '321'}}
|
|
func nAndMAreBothEqual() {}
|
|
}
|
|
|
|
func testC1(with c: C<0, 0>) {
|
|
c.nIs123() // expected-error {{referencing instance method 'nIs123()' on 'C' requires the types '0' and '123' be equivalent}}
|
|
c.mIs123() // expected-error {{referencing instance method 'mIs123()' on 'C' requires the types '0' and '321' be equivalent}}
|
|
c.nAndMAreBothEqual() // OK
|
|
}
|
|
|
|
func testC2(with c: C<123, 0>) {
|
|
c.nIs123() // OK
|
|
c.mIs123() // expected-error {{referencing instance method 'mIs123()' on 'C' requires the types '0' and '321' be equivalent}}
|
|
c.nAndMAreBothEqual() // expected-error {{referencing instance method 'nAndMAreBothEqual()' on 'C' requires the types '123' and '0' be equivalent}}
|
|
}
|
|
|
|
func testC3(with c: C<0, 321>) {
|
|
c.nIs123() // expected-error {{referencing instance method 'nIs123()' on 'C' requires the types '0' and '123' be equivalent}}
|
|
c.mIs123() // OK
|
|
c.nAndMAreBothEqual() // expected-error {{referencing instance method 'nAndMAreBothEqual()' on 'C' requires the types '0' and '321' be equivalent}}
|
|
}
|
|
|
|
func testC4<let T: Int>(with c: C<T, T>) {
|
|
c.nIs123() // expected-error {{referencing instance method 'nIs123()' on 'C' requires the types 'T' and '123' be equivalent}}
|
|
c.mIs123() // expected-error {{referencing instance method 'mIs123()' on 'C' requires the types 'T' and '321' be equivalent}}
|
|
c.nAndMAreBothEqual() // OK
|
|
}
|
|
|
|
struct D<let N: Int & P> {} // expected-error {{non-protocol, non-class type 'Int' cannot be used within a protocol-constrained type}}
|
|
|
|
struct E<A, let b: Int> { // expected-note {{'b' previously declared here}}
|
|
static var b: Int { // expected-warning {{redeclaration of 'b' is deprecated and will be an error in Swift 5}}
|
|
// expected-note@-1 {{'b' declared here}}
|
|
123
|
|
}
|
|
|
|
let b: String // expected-note {{'b' previously declared here}}
|
|
// expected-note@-1 {{'b' declared here}}
|
|
|
|
func b() {} // expected-error {{invalid redeclaration of 'b()'}}
|
|
// expected-note@-1 {{'b' declared here}}
|
|
|
|
func dumb() -> Int {
|
|
Self.b // OK
|
|
}
|
|
|
|
static func dumb2() -> Int {
|
|
Self.b // OK
|
|
}
|
|
}
|
|
|
|
func testE1() -> Int {
|
|
E<Int, 123>.b // OK
|
|
}
|
|
|
|
func testE2() -> Int {
|
|
E<Int, 123>.A // expected-error {{type 'E<Int, 123>' has no member 'A'}}
|
|
}
|
|
|
|
func testE3<let c: Int>(_: E<Int, c>.Type) -> Int {
|
|
E<Int, c>.b // OK
|
|
}
|
|
|
|
func testShadowing<let a: Int>(_: A<a>) {
|
|
var a: String {
|
|
"123"
|
|
}
|
|
|
|
let x: String = a // OK
|
|
let y: Int = a // expected-error {{cannot convert value of type 'String' to specified type 'Int'}}
|
|
|
|
print(a) // OK
|
|
print(a.self) // OK
|
|
}
|
|
|
|
class F<let n: Int> {}
|
|
class G: F<3> {}
|
|
|
|
func hello() -> Int {
|
|
G.n // OK
|
|
}
|
|
|
|
func testTypeOf() -> Int {
|
|
let x = E<Int, 123>(b: "")
|
|
return type(of: x).b // OK
|
|
}
|
|
|
|
func testTypeOf2<let c: Int>(_: E<Int, c>.Type) -> Int {
|
|
let x = E<Int, c>(b: "")
|
|
return type(of: x).b // OK
|
|
}
|
|
|
|
struct H<let I: Int> { // expected-note {{'I' previously declared here}}
|
|
struct I {} // expected-warning {{redeclaration of 'I' is deprecated and will be an error in Swift 5}}
|
|
}
|
|
|
|
typealias J = E<Int, 123>.b // expected-error {{static property 'b' is not a member type of 'E<Int, 123>'}}
|