| // RUN: %target-typecheck-verify-swift -swift-version 4 |
| |
| // See test/Compatibility/tuple_arguments.swift for the Swift 3 behavior. |
| |
| func concrete(_ x: Int) {} |
| func concreteLabeled(x: Int) {} |
| func concreteTwo(_ x: Int, _ y: Int) {} // expected-note 5 {{'concreteTwo' declared here}} |
| func concreteTuple(_ x: (Int, Int)) {} |
| |
| do { |
| concrete(3) |
| concrete((3)) |
| |
| concreteLabeled(x: 3) |
| concreteLabeled(x: (3)) |
| concreteLabeled((x: 3)) // expected-error {{missing argument label 'x:' in call}} |
| |
| concreteTwo(3, 4) |
| concreteTwo((3, 4)) // expected-error {{missing argument for parameter #2 in call}} |
| |
| concreteTuple(3, 4) // expected-error {{global function 'concreteTuple' expects a single parameter of type '(Int, Int)'}} {{17-17=(}} {{21-21=)}} |
| concreteTuple((3, 4)) |
| } |
| |
| do { |
| let a = 3 |
| let b = 4 |
| let c = (3) |
| let d = (a, b) |
| |
| concrete(a) |
| concrete((a)) |
| concrete(c) |
| |
| concreteTwo(a, b) |
| concreteTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| concreteTwo(d) // expected-error {{missing argument for parameter #2 in call}} |
| |
| concreteTuple(a, b) // expected-error {{global function 'concreteTuple' expects a single parameter of type '(Int, Int)'}} {{17-17=(}} {{21-21=)}} |
| concreteTuple((a, b)) |
| concreteTuple(d) |
| } |
| |
| do { |
| var a = 3 // expected-warning {{variable 'a' was never mutated; consider changing to 'let' constant}} |
| var b = 4 // expected-warning {{variable 'b' was never mutated; consider changing to 'let' constant}} |
| var c = (3) // expected-warning {{variable 'c' was never mutated; consider changing to 'let' constant}} |
| var d = (a, b) // expected-warning {{variable 'd' was never mutated; consider changing to 'let' constant}} |
| |
| concrete(a) |
| concrete((a)) |
| concrete(c) |
| |
| concreteTwo(a, b) |
| concreteTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| concreteTwo(d) // expected-error {{missing argument for parameter #2 in call}} |
| |
| concreteTuple(a, b) // expected-error {{global function 'concreteTuple' expects a single parameter of type '(Int, Int)'}} {{17-17=(}} {{21-21=)}} |
| concreteTuple((a, b)) |
| concreteTuple(d) |
| } |
| |
| func generic<T>(_ x: T) {} |
| func genericLabeled<T>(x: T) {} |
| func genericTwo<T, U>(_ x: T, _ y: U) {} // expected-note 5 {{'genericTwo' declared here}} |
| func genericTuple<T, U>(_ x: (T, U)) {} |
| |
| do { |
| generic(3) |
| generic(3, 4) // expected-error {{extra argument in call}} |
| generic((3)) |
| generic((3, 4)) |
| |
| genericLabeled(x: 3) |
| genericLabeled(x: 3, 4) // expected-error {{extra argument in call}} |
| genericLabeled(x: (3)) |
| genericLabeled(x: (3, 4)) |
| |
| genericTwo(3, 4) |
| genericTwo((3, 4)) // expected-error {{missing argument for parameter #2 in call}} |
| |
| genericTuple(3, 4) // expected-error {{global function 'genericTuple' expects a single parameter of type '(T, U)'}} {{16-16=(}} {{20-20=)}} |
| genericTuple((3, 4)) |
| } |
| |
| do { |
| let a = 3 |
| let b = 4 |
| let c = (3) |
| let d = (a, b) |
| |
| generic(a) |
| generic(a, b) // expected-error {{extra argument in call}} |
| generic((a)) |
| generic(c) |
| generic((a, b)) |
| generic(d) |
| |
| genericTwo(a, b) |
| genericTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| genericTwo(d) // expected-error {{missing argument for parameter #2 in call}} |
| |
| genericTuple(a, b) // expected-error {{global function 'genericTuple' expects a single parameter of type '(T, U)'}} {{16-16=(}} {{20-20=)}} |
| genericTuple((a, b)) |
| genericTuple(d) |
| } |
| |
| do { |
| var a = 3 |
| var b = 4 |
| var c = (3) |
| var d = (a, b) |
| |
| generic(a) |
| generic(a, b) // expected-error {{extra argument in call}} |
| generic((a)) |
| generic(c) |
| generic((a, b)) |
| generic(d) |
| |
| genericTwo(a, b) |
| genericTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| genericTwo(d) // expected-error {{missing argument for parameter #2 in call}} |
| |
| genericTuple(a, b) // expected-error {{global function 'genericTuple' expects a single parameter of type '(T, U)'}} {{16-16=(}} {{20-20=)}} |
| genericTuple((a, b)) |
| genericTuple(d) |
| } |
| |
| var function: (Int) -> () |
| var functionTwo: (Int, Int) -> () // expected-note 5 {{'functionTwo' declared here}} |
| var functionTuple: ((Int, Int)) -> () |
| |
| do { |
| function(3) |
| function((3)) |
| |
| functionTwo(3, 4) |
| functionTwo((3, 4)) // expected-error {{missing argument for parameter #2 in call}} |
| |
| functionTuple(3, 4) // expected-error {{var 'functionTuple' expects a single parameter of type '(Int, Int)'}} {{17-17=(}} {{21-21=)}} |
| functionTuple((3, 4)) |
| } |
| |
| do { |
| let a = 3 |
| let b = 4 |
| let c = (3) |
| let d = (a, b) |
| |
| function(a) |
| function((a)) |
| function(c) |
| |
| functionTwo(a, b) |
| functionTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| functionTwo(d) // expected-error {{missing argument for parameter #2 in call}} |
| |
| functionTuple(a, b) // expected-error {{var 'functionTuple' expects a single parameter of type '(Int, Int)'}} {{17-17=(}} {{21-21=)}} |
| functionTuple((a, b)) |
| functionTuple(d) |
| } |
| |
| do { |
| var a = 3 |
| var b = 4 |
| var c = (3) |
| var d = (a, b) |
| |
| function(a) |
| function((a)) |
| function(c) |
| |
| functionTwo(a, b) |
| functionTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| functionTwo(d) // expected-error {{missing argument for parameter #2 in call}} |
| |
| functionTuple(a, b) // expected-error {{var 'functionTuple' expects a single parameter of type '(Int, Int)'}} {{17-17=(}} {{21-21=)}} |
| functionTuple((a, b)) |
| functionTuple(d) |
| } |
| |
| struct Concrete {} |
| |
| extension Concrete { |
| func concrete(_ x: Int) {} |
| func concreteTwo(_ x: Int, _ y: Int) {} // expected-note 5 {{'concreteTwo' declared here}} |
| func concreteTuple(_ x: (Int, Int)) {} |
| } |
| |
| do { |
| let s = Concrete() |
| |
| s.concrete(3) |
| s.concrete((3)) |
| |
| s.concreteTwo(3, 4) |
| s.concreteTwo((3, 4)) // expected-error {{missing argument for parameter #2 in call}} |
| |
| s.concreteTuple(3, 4) // expected-error {{instance method 'concreteTuple' expects a single parameter of type '(Int, Int)'}} {{19-19=(}} {{23-23=)}} |
| s.concreteTuple((3, 4)) |
| } |
| |
| do { |
| let s = Concrete() |
| |
| let a = 3 |
| let b = 4 |
| let c = (3) |
| let d = (a, b) |
| |
| s.concrete(a) |
| s.concrete((a)) |
| s.concrete(c) |
| |
| s.concreteTwo(a, b) |
| s.concreteTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| s.concreteTwo(d) // expected-error {{missing argument for parameter #2 in call}} |
| |
| s.concreteTuple(a, b) // expected-error {{instance method 'concreteTuple' expects a single parameter of type '(Int, Int)'}} {{19-19=(}} {{23-23=)}} |
| s.concreteTuple((a, b)) |
| s.concreteTuple(d) |
| } |
| |
| do { |
| var s = Concrete() |
| |
| var a = 3 |
| var b = 4 |
| var c = (3) |
| var d = (a, b) |
| |
| s.concrete(a) |
| s.concrete((a)) |
| s.concrete(c) |
| |
| s.concreteTwo(a, b) |
| s.concreteTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| s.concreteTwo(d) // expected-error {{missing argument for parameter #2 in call}} |
| |
| s.concreteTuple(a, b) // expected-error {{instance method 'concreteTuple' expects a single parameter of type '(Int, Int)'}} {{19-19=(}} {{23-23=)}} |
| s.concreteTuple((a, b)) |
| s.concreteTuple(d) |
| } |
| |
| extension Concrete { |
| func generic<T>(_ x: T) {} |
| func genericLabeled<T>(x: T) {} |
| func genericTwo<T, U>(_ x: T, _ y: U) {} // expected-note 5 {{'genericTwo' declared here}} |
| func genericTuple<T, U>(_ x: (T, U)) {} |
| } |
| |
| do { |
| let s = Concrete() |
| |
| s.generic(3) |
| s.generic(3, 4) // expected-error {{extra argument in call}} |
| s.generic((3)) |
| s.generic((3, 4)) |
| |
| s.genericLabeled(x: 3) |
| s.genericLabeled(x: 3, 4) // expected-error {{extra argument in call}} |
| s.genericLabeled(x: (3)) |
| s.genericLabeled(x: (3, 4)) |
| |
| s.genericTwo(3, 4) |
| s.genericTwo((3, 4)) // expected-error {{missing argument for parameter #2 in call}} |
| |
| s.genericTuple(3, 4) // expected-error {{instance method 'genericTuple' expects a single parameter of type '(T, U)'}} {{18-18=(}} {{22-22=)}} |
| s.genericTuple((3, 4)) |
| } |
| |
| do { |
| let s = Concrete() |
| |
| let a = 3 |
| let b = 4 |
| let c = (3) |
| let d = (a, b) |
| |
| s.generic(a) |
| s.generic(a, b) // expected-error {{extra argument in call}} |
| s.generic((a)) |
| s.generic((a, b)) |
| s.generic(d) |
| |
| s.genericTwo(a, b) |
| s.genericTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| s.genericTwo(d) // expected-error {{missing argument for parameter #2 in call}} |
| |
| s.genericTuple(a, b) // expected-error {{instance method 'genericTuple' expects a single parameter of type '(T, U)'}} {{18-18=(}} {{22-22=)}} |
| s.genericTuple((a, b)) |
| s.genericTuple(d) |
| } |
| |
| do { |
| var s = Concrete() |
| |
| var a = 3 |
| var b = 4 |
| var c = (3) |
| var d = (a, b) |
| |
| s.generic(a) |
| s.generic(a, b) // expected-error {{extra argument in call}} |
| s.generic((a)) |
| s.generic((a, b)) |
| s.generic(d) |
| |
| s.genericTwo(a, b) |
| s.genericTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| s.genericTwo(d) // expected-error {{missing argument for parameter #2 in call}} |
| |
| s.genericTuple(a, b) // expected-error {{instance method 'genericTuple' expects a single parameter of type '(T, U)'}} {{18-18=(}} {{22-22=)}} |
| s.genericTuple((a, b)) |
| s.genericTuple(d) |
| } |
| |
| extension Concrete { |
| mutating func mutatingConcrete(_ x: Int) {} |
| mutating func mutatingConcreteTwo(_ x: Int, _ y: Int) {} // expected-note 5 {{'mutatingConcreteTwo' declared here}} |
| mutating func mutatingConcreteTuple(_ x: (Int, Int)) {} |
| } |
| |
| do { |
| var s = Concrete() |
| |
| s.mutatingConcrete(3) |
| s.mutatingConcrete((3)) |
| |
| s.mutatingConcreteTwo(3, 4) |
| s.mutatingConcreteTwo((3, 4)) // expected-error {{missing argument for parameter #2 in call}} |
| |
| s.mutatingConcreteTuple(3, 4) // expected-error {{instance method 'mutatingConcreteTuple' expects a single parameter of type '(Int, Int)'}} {{27-27=(}} {{31-31=)}} |
| s.mutatingConcreteTuple((3, 4)) |
| } |
| |
| do { |
| var s = Concrete() |
| |
| let a = 3 |
| let b = 4 |
| let c = (3) |
| let d = (a, b) |
| |
| s.mutatingConcrete(a) |
| s.mutatingConcrete((a)) |
| s.mutatingConcrete(c) |
| |
| s.mutatingConcreteTwo(a, b) |
| s.mutatingConcreteTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| s.mutatingConcreteTwo(d) // expected-error {{missing argument for parameter #2 in call}} |
| |
| s.mutatingConcreteTuple(a, b) // expected-error {{instance method 'mutatingConcreteTuple' expects a single parameter of type '(Int, Int)'}} {{27-27=(}} {{31-31=)}} |
| s.mutatingConcreteTuple((a, b)) |
| s.mutatingConcreteTuple(d) |
| } |
| |
| do { |
| var s = Concrete() |
| |
| var a = 3 |
| var b = 4 |
| var c = (3) |
| var d = (a, b) |
| |
| s.mutatingConcrete(a) |
| s.mutatingConcrete((a)) |
| s.mutatingConcrete(c) |
| |
| s.mutatingConcreteTwo(a, b) |
| s.mutatingConcreteTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| s.mutatingConcreteTwo(d) // expected-error {{missing argument for parameter #2 in call}} |
| |
| s.mutatingConcreteTuple(a, b) // expected-error {{instance method 'mutatingConcreteTuple' expects a single parameter of type '(Int, Int)'}} {{27-27=(}} {{31-31=)}} |
| s.mutatingConcreteTuple((a, b)) |
| s.mutatingConcreteTuple(d) |
| } |
| |
| extension Concrete { |
| mutating func mutatingGeneric<T>(_ x: T) {} |
| mutating func mutatingGenericLabeled<T>(x: T) {} |
| mutating func mutatingGenericTwo<T, U>(_ x: T, _ y: U) {} // expected-note 5 {{'mutatingGenericTwo' declared here}} |
| mutating func mutatingGenericTuple<T, U>(_ x: (T, U)) {} |
| } |
| |
| do { |
| var s = Concrete() |
| |
| s.mutatingGeneric(3) |
| s.mutatingGeneric(3, 4) // expected-error {{extra argument in call}} |
| s.mutatingGeneric((3)) |
| s.mutatingGeneric((3, 4)) |
| |
| s.mutatingGenericLabeled(x: 3) |
| s.mutatingGenericLabeled(x: 3, 4) // expected-error {{extra argument in call}} |
| s.mutatingGenericLabeled(x: (3)) |
| s.mutatingGenericLabeled(x: (3, 4)) |
| |
| s.mutatingGenericTwo(3, 4) |
| s.mutatingGenericTwo((3, 4)) // expected-error {{missing argument for parameter #2 in call}} |
| |
| s.mutatingGenericTuple(3, 4) // expected-error {{instance method 'mutatingGenericTuple' expects a single parameter of type '(T, U)'}} {{26-26=(}} {{30-30=)}} |
| s.mutatingGenericTuple((3, 4)) |
| } |
| |
| do { |
| var s = Concrete() |
| |
| let a = 3 |
| let b = 4 |
| let c = (3) |
| let d = (a, b) |
| |
| s.mutatingGeneric(a) |
| s.mutatingGeneric(a, b) // expected-error {{extra argument in call}} |
| s.mutatingGeneric((a)) |
| s.mutatingGeneric((a, b)) |
| s.mutatingGeneric(d) |
| |
| s.mutatingGenericTwo(a, b) |
| s.mutatingGenericTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| s.mutatingGenericTwo(d) // expected-error {{missing argument for parameter #2 in call}} |
| |
| s.mutatingGenericTuple(a, b) // expected-error {{instance method 'mutatingGenericTuple' expects a single parameter of type '(T, U)'}} {{26-26=(}} {{30-30=)}} |
| s.mutatingGenericTuple((a, b)) |
| s.mutatingGenericTuple(d) |
| } |
| |
| do { |
| var s = Concrete() |
| |
| var a = 3 |
| var b = 4 |
| var c = (3) |
| var d = (a, b) |
| |
| s.mutatingGeneric(a) |
| s.mutatingGeneric(a, b) // expected-error {{extra argument in call}} |
| s.mutatingGeneric((a)) |
| s.mutatingGeneric((a, b)) |
| s.mutatingGeneric(d) |
| |
| s.mutatingGenericTwo(a, b) |
| s.mutatingGenericTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| s.mutatingGenericTwo(d) // expected-error {{missing argument for parameter #2 in call}} |
| |
| s.mutatingGenericTuple(a, b) // expected-error {{instance method 'mutatingGenericTuple' expects a single parameter of type '(T, U)'}} {{26-26=(}} {{30-30=)}} |
| s.mutatingGenericTuple((a, b)) |
| s.mutatingGenericTuple(d) |
| } |
| |
| extension Concrete { |
| var function: (Int) -> () { return concrete } |
| var functionTwo: (Int, Int) -> () { return concreteTwo } |
| var functionTuple: ((Int, Int)) -> () { return concreteTuple } |
| } |
| |
| do { |
| let s = Concrete() |
| |
| s.function(3) |
| s.function((3)) |
| |
| s.functionTwo(3, 4) |
| s.functionTwo((3, 4)) // expected-error {{missing argument for parameter #2 in call}} |
| |
| s.functionTuple(3, 4) // expected-error {{single parameter of type '(Int, Int)' is expected in call}} {{19-19=(}} {{23-23=)}} |
| s.functionTuple((3, 4)) |
| } |
| |
| do { |
| let s = Concrete() |
| |
| let a = 3 |
| let b = 4 |
| let c = (3) |
| let d = (a, b) |
| |
| s.function(a) |
| s.function((a)) |
| s.function(c) |
| |
| s.functionTwo(a, b) |
| s.functionTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| s.functionTwo(d) // expected-error {{missing argument for parameter #2 in call}} |
| |
| |
| s.functionTuple(a, b) // expected-error {{single parameter of type '(Int, Int)' is expected in call}} {{19-19=(}} {{23-23=)}} |
| s.functionTuple((a, b)) |
| s.functionTuple(d) |
| } |
| |
| do { |
| var s = Concrete() |
| |
| var a = 3 |
| var b = 4 |
| var c = (3) |
| var d = (a, b) |
| |
| s.function(a) |
| s.function((a)) |
| s.function(c) |
| |
| s.functionTwo(a, b) |
| s.functionTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| s.functionTwo(d) // expected-error {{missing argument for parameter #2 in call}} |
| |
| s.functionTuple(a, b) // expected-error {{single parameter of type '(Int, Int)' is expected in call}} {{19-19=(}} {{23-23=)}} |
| s.functionTuple((a, b)) |
| s.functionTuple(d) |
| } |
| |
| struct InitTwo { |
| init(_ x: Int, _ y: Int) {} // expected-note 5 {{'init' declared here}} |
| } |
| |
| struct InitTuple { |
| init(_ x: (Int, Int)) {} |
| } |
| |
| struct InitLabeledTuple { |
| init(x: (Int, Int)) {} |
| } |
| |
| do { |
| _ = InitTwo(3, 4) |
| _ = InitTwo((3, 4)) // expected-error {{missing argument for parameter #2 in call}} |
| |
| _ = InitTuple(3, 4) // expected-error {{initializer expects a single parameter of type '(Int, Int)'}} {{17-17=(}} {{21-21=)}} |
| _ = InitTuple((3, 4)) |
| |
| _ = InitLabeledTuple(x: 3, 4) // expected-error {{extra argument in call}} |
| _ = InitLabeledTuple(x: (3, 4)) |
| } |
| |
| do { |
| let a = 3 |
| let b = 4 |
| let c = (a, b) |
| |
| _ = InitTwo(a, b) |
| _ = InitTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| _ = InitTwo(c) // expected-error {{missing argument for parameter #2 in call}} |
| |
| _ = InitTuple(a, b) // expected-error {{initializer expects a single parameter of type '(Int, Int)'}} {{17-17=(}} {{21-21=)}} |
| _ = InitTuple((a, b)) |
| _ = InitTuple(c) |
| } |
| |
| do { |
| var a = 3 // expected-warning {{variable 'a' was never mutated; consider changing to 'let' constant}} |
| var b = 4 // expected-warning {{variable 'b' was never mutated; consider changing to 'let' constant}} |
| var c = (a, b) // expected-warning {{variable 'c' was never mutated; consider changing to 'let' constant}} |
| |
| _ = InitTwo(a, b) |
| _ = InitTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| _ = InitTwo(c) // expected-error {{missing argument for parameter #2 in call}} |
| |
| _ = InitTuple(a, b) // expected-error {{initializer expects a single parameter of type '(Int, Int)'}} {{17-17=(}} {{21-21=)}} |
| _ = InitTuple((a, b)) |
| _ = InitTuple(c) |
| } |
| |
| struct SubscriptTwo { |
| subscript(_ x: Int, _ y: Int) -> Int { get { return 0 } set { } } // expected-note 5 {{'subscript' declared here}} |
| } |
| |
| struct SubscriptTuple { |
| subscript(_ x: (Int, Int)) -> Int { get { return 0 } set { } } |
| } |
| |
| struct SubscriptLabeledTuple { |
| subscript(x x: (Int, Int)) -> Int { get { return 0 } set { } } |
| } |
| |
| do { |
| let s1 = SubscriptTwo() |
| _ = s1[3, 4] |
| _ = s1[(3, 4)] // expected-error {{missing argument for parameter #2 in call}} |
| |
| let s2 = SubscriptTuple() |
| _ = s2[3, 4] // expected-error {{subscript expects a single parameter of type '(Int, Int)'}} {{10-10=(}} {{14-14=)}} |
| _ = s2[(3, 4)] |
| } |
| |
| do { |
| let a = 3 |
| let b = 4 |
| let d = (a, b) |
| |
| let s1 = SubscriptTwo() |
| _ = s1[a, b] |
| _ = s1[(a, b)] // expected-error {{missing argument for parameter #2 in call}} |
| _ = s1[d] // expected-error {{missing argument for parameter #2 in call}} |
| |
| let s2 = SubscriptTuple() |
| _ = s2[a, b] // expected-error {{subscript expects a single parameter of type '(Int, Int)'}} {{10-10=(}} {{14-14=)}} |
| _ = s2[(a, b)] |
| _ = s2[d] |
| |
| let s3 = SubscriptLabeledTuple() |
| _ = s3[x: 3, 4] // expected-error {{extra argument in call}} |
| _ = s3[x: (3, 4)] |
| } |
| |
| do { |
| // TODO: Restore regressed diagnostics rdar://problem/31724211 |
| var a = 3 // e/xpected-warning {{variable 'a' was never mutated; consider changing to 'let' constant}} |
| var b = 4 // e/xpected-warning {{variable 'b' was never mutated; consider changing to 'let' constant}} |
| var d = (a, b) // e/xpected-warning {{variable 'd' was never mutated; consider changing to 'let' constant}} |
| |
| var s1 = SubscriptTwo() |
| _ = s1[a, b] |
| _ = s1[(a, b)] // expected-error {{missing argument for parameter #2 in call}} |
| _ = s1[d] // expected-error {{missing argument for parameter #2 in call}} |
| |
| var s2 = SubscriptTuple() |
| _ = s2[a, b] // expected-error {{subscript expects a single parameter of type '(Int, Int)'}} {{10-10=(}} {{14-14=)}} |
| _ = s2[(a, b)] |
| _ = s2[d] |
| } |
| |
| enum Enum { |
| case two(Int, Int) // expected-note 6 {{'two' declared here}} |
| case tuple((Int, Int)) |
| case labeledTuple(x: (Int, Int)) |
| } |
| |
| do { |
| _ = Enum.two(3, 4) |
| _ = Enum.two((3, 4)) // expected-error {{missing argument for parameter #2 in call}} |
| _ = Enum.two(3 > 4 ? 3 : 4) // expected-error {{missing argument for parameter #2 in call}} |
| |
| _ = Enum.tuple(3, 4) // expected-error {{enum element 'tuple' expects a single parameter of type '(Int, Int)'}} {{18-18=(}} {{22-22=)}} |
| _ = Enum.tuple((3, 4)) |
| |
| _ = Enum.labeledTuple(x: 3, 4) // expected-error {{extra argument in call}} |
| _ = Enum.labeledTuple(x: (3, 4)) |
| } |
| |
| do { |
| let a = 3 |
| let b = 4 |
| let c = (a, b) |
| |
| _ = Enum.two(a, b) |
| _ = Enum.two((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| _ = Enum.two(c) // expected-error {{missing argument for parameter #2 in call}} |
| |
| _ = Enum.tuple(a, b) // expected-error {{enum element 'tuple' expects a single parameter of type '(Int, Int)'}} {{18-18=(}} {{22-22=)}} |
| _ = Enum.tuple((a, b)) |
| _ = Enum.tuple(c) |
| } |
| |
| do { |
| var a = 3 |
| var b = 4 |
| var c = (a, b) |
| |
| _ = Enum.two(a, b) |
| _ = Enum.two((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| _ = Enum.two(c) // expected-error {{missing argument for parameter #2 in call}} |
| |
| _ = Enum.tuple(a, b) // expected-error {{enum element 'tuple' expects a single parameter of type '(Int, Int)'}} {{18-18=(}} {{22-22=)}} |
| _ = Enum.tuple((a, b)) |
| _ = Enum.tuple(c) |
| } |
| |
| struct Generic<T> {} |
| |
| extension Generic { |
| func generic(_ x: T) {} |
| func genericLabeled(x: T) {} |
| func genericTwo(_ x: T, _ y: T) {} // expected-note 3 {{'genericTwo' declared here}} |
| func genericTuple(_ x: (T, T)) {} |
| } |
| |
| do { |
| let s = Generic<Double>() |
| |
| s.generic(3.0) |
| s.generic((3.0)) |
| |
| s.genericLabeled(x: 3.0) |
| s.genericLabeled(x: (3.0)) |
| |
| s.genericTwo(3.0, 4.0) |
| s.genericTwo((3.0, 4.0)) // expected-error {{missing argument for parameter #2 in call}} |
| |
| s.genericTuple(3.0, 4.0) // expected-error {{instance method 'genericTuple' expects a single parameter of type '(Double, Double)'}} {{18-18=(}} {{26-26=)}} |
| s.genericTuple((3.0, 4.0)) |
| |
| let sTwo = Generic<(Double, Double)>() |
| |
| sTwo.generic(3.0, 4.0) // expected-error {{instance method 'generic' expects a single parameter of type '(Double, Double)'}} {{16-16=(}} {{24-24=)}} |
| sTwo.generic((3.0, 4.0)) |
| |
| sTwo.genericLabeled(x: 3.0, 4.0) // expected-error {{extra argument in call}} |
| sTwo.genericLabeled(x: (3.0, 4.0)) |
| } |
| |
| do { |
| let s = Generic<Double>() |
| |
| let a = 3.0 |
| let b = 4.0 |
| let c = (3.0) |
| let d = (a, b) |
| |
| s.generic(a) |
| s.generic((a)) |
| s.generic(c) |
| |
| s.genericTwo(a, b) |
| s.genericTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| |
| s.genericTuple(a, b) // expected-error {{instance method 'genericTuple' expects a single parameter of type '(Double, Double)'}} {{18-18=(}} {{22-22=)}} |
| s.genericTuple((a, b)) |
| |
| let sTwo = Generic<(Double, Double)>() |
| |
| sTwo.generic(a, b) // expected-error {{instance method 'generic' expects a single parameter of type '(Double, Double)'}} {{16-16=(}} {{20-20=)}} |
| sTwo.generic((a, b)) |
| sTwo.generic(d) |
| } |
| |
| do { |
| var s = Generic<Double>() |
| |
| var a = 3.0 |
| var b = 4.0 |
| var c = (3.0) |
| var d = (a, b) |
| |
| s.generic(a) |
| s.generic((a)) |
| s.generic(c) |
| |
| s.genericTwo(a, b) |
| s.genericTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| |
| s.genericTuple(a, b) // expected-error {{instance method 'genericTuple' expects a single parameter of type '(Double, Double)'}} {{18-18=(}} {{22-22=)}} |
| s.genericTuple((a, b)) |
| |
| var sTwo = Generic<(Double, Double)>() |
| |
| sTwo.generic(a, b) // expected-error {{instance method 'generic' expects a single parameter of type '(Double, Double)'}} {{16-16=(}} {{20-20=)}} |
| sTwo.generic((a, b)) |
| sTwo.generic(d) |
| } |
| |
| extension Generic { |
| mutating func mutatingGeneric(_ x: T) {} |
| mutating func mutatingGenericLabeled(x: T) {} |
| mutating func mutatingGenericTwo(_ x: T, _ y: T) {} // expected-note 3 {{'mutatingGenericTwo' declared here}} |
| mutating func mutatingGenericTuple(_ x: (T, T)) {} |
| } |
| |
| do { |
| var s = Generic<Double>() |
| |
| s.mutatingGeneric(3.0) |
| s.mutatingGeneric((3.0)) |
| |
| s.mutatingGenericLabeled(x: 3.0) |
| s.mutatingGenericLabeled(x: (3.0)) |
| |
| s.mutatingGenericTwo(3.0, 4.0) |
| s.mutatingGenericTwo((3.0, 4.0)) // expected-error {{missing argument for parameter #2 in call}} |
| |
| s.mutatingGenericTuple(3.0, 4.0) // expected-error {{instance method 'mutatingGenericTuple' expects a single parameter of type '(Double, Double)'}} {{26-26=(}} {{34-34=)}} |
| s.mutatingGenericTuple((3.0, 4.0)) |
| |
| var sTwo = Generic<(Double, Double)>() |
| |
| sTwo.mutatingGeneric(3.0, 4.0) // expected-error {{instance method 'mutatingGeneric' expects a single parameter of type '(Double, Double)'}} {{24-24=(}} {{32-32=)}} |
| sTwo.mutatingGeneric((3.0, 4.0)) |
| |
| sTwo.mutatingGenericLabeled(x: 3.0, 4.0) // expected-error {{extra argument in call}} |
| sTwo.mutatingGenericLabeled(x: (3.0, 4.0)) |
| } |
| |
| do { |
| var s = Generic<Double>() |
| |
| let a = 3.0 |
| let b = 4.0 |
| let c = (3.0) |
| let d = (a, b) |
| |
| s.mutatingGeneric(a) |
| s.mutatingGeneric((a)) |
| s.mutatingGeneric(c) |
| |
| s.mutatingGenericTwo(a, b) |
| s.mutatingGenericTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| |
| s.mutatingGenericTuple(a, b) // expected-error {{instance method 'mutatingGenericTuple' expects a single parameter of type '(Double, Double)'}} {{26-26=(}} {{30-30=)}} |
| s.mutatingGenericTuple((a, b)) |
| |
| var sTwo = Generic<(Double, Double)>() |
| |
| sTwo.mutatingGeneric(a, b) // expected-error {{instance method 'mutatingGeneric' expects a single parameter of type '(Double, Double)'}} {{24-24=(}} {{28-28=)}} |
| sTwo.mutatingGeneric((a, b)) |
| sTwo.mutatingGeneric(d) |
| } |
| |
| do { |
| var s = Generic<Double>() |
| |
| var a = 3.0 |
| var b = 4.0 |
| var c = (3.0) |
| var d = (a, b) |
| |
| s.mutatingGeneric(a) |
| s.mutatingGeneric((a)) |
| s.mutatingGeneric(c) |
| |
| s.mutatingGenericTwo(a, b) |
| s.mutatingGenericTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| |
| s.mutatingGenericTuple(a, b) // expected-error {{instance method 'mutatingGenericTuple' expects a single parameter of type '(Double, Double)'}} {{26-26=(}} {{30-30=)}} |
| s.mutatingGenericTuple((a, b)) |
| |
| var sTwo = Generic<(Double, Double)>() |
| |
| sTwo.mutatingGeneric(a, b) // expected-error {{instance method 'mutatingGeneric' expects a single parameter of type '(Double, Double)'}} {{24-24=(}} {{28-28=)}} |
| sTwo.mutatingGeneric((a, b)) |
| sTwo.mutatingGeneric(d) |
| } |
| |
| extension Generic { |
| var genericFunction: (T) -> () { return generic } |
| var genericFunctionTwo: (T, T) -> () { return genericTwo } |
| var genericFunctionTuple: ((T, T)) -> () { return genericTuple } |
| } |
| |
| do { |
| let s = Generic<Double>() |
| |
| s.genericFunction(3.0) |
| s.genericFunction((3.0)) |
| |
| s.genericFunctionTwo(3.0, 4.0) |
| s.genericFunctionTwo((3.0, 4.0)) // expected-error {{missing argument for parameter #2 in call}} |
| |
| s.genericFunctionTuple(3.0, 4.0) // expected-error {{single parameter of type '(Double, Double)' is expected in call}} {{26-26=(}} {{34-34=)}} |
| s.genericFunctionTuple((3.0, 4.0)) |
| |
| let sTwo = Generic<(Double, Double)>() |
| |
| sTwo.genericFunction(3.0, 4.0) // expected-error {{single parameter of type '(Double, Double)' is expected in call}} {{24-24=(}} {{32-32=)}} |
| sTwo.genericFunction((3.0, 4.0)) |
| } |
| |
| do { |
| let s = Generic<Double>() |
| |
| let a = 3.0 |
| let b = 4.0 |
| let c = (3.0) |
| let d = (a, b) |
| |
| s.genericFunction(a) |
| s.genericFunction((a)) |
| s.genericFunction(c) |
| |
| s.genericFunctionTwo(a, b) |
| s.genericFunctionTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| |
| s.genericFunctionTuple(a, b) // expected-error {{single parameter of type '(Double, Double)' is expected in call}} {{26-26=(}} {{30-30=)}} |
| s.genericFunctionTuple((a, b)) |
| |
| let sTwo = Generic<(Double, Double)>() |
| |
| sTwo.genericFunction(a, b) // expected-error {{single parameter of type '(Double, Double)' is expected in call}} {{24-24=(}} {{28-28=)}} |
| sTwo.genericFunction((a, b)) |
| sTwo.genericFunction(d) |
| } |
| |
| do { |
| var s = Generic<Double>() |
| |
| var a = 3.0 |
| var b = 4.0 |
| var c = (3.0) |
| var d = (a, b) |
| |
| s.genericFunction(a) |
| s.genericFunction((a)) |
| s.genericFunction(c) |
| |
| s.genericFunctionTwo(a, b) |
| s.genericFunctionTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| |
| s.genericFunctionTuple(a, b) // expected-error {{single parameter of type '(Double, Double)' is expected in call}} {{26-26=(}} {{30-30=)}} |
| s.genericFunctionTuple((a, b)) |
| |
| var sTwo = Generic<(Double, Double)>() |
| |
| sTwo.genericFunction(a, b) // expected-error {{single parameter of type '(Double, Double)' is expected in call}} {{24-24=(}} {{28-28=)}} |
| sTwo.genericFunction((a, b)) |
| sTwo.genericFunction(d) |
| } |
| |
| struct GenericInit<T> { |
| init(_ x: T) {} |
| } |
| |
| struct GenericInitLabeled<T> { |
| init(x: T) {} |
| } |
| |
| struct GenericInitTwo<T> { |
| init(_ x: T, _ y: T) {} // expected-note 10 {{'init' declared here}} |
| } |
| |
| struct GenericInitTuple<T> { |
| init(_ x: (T, T)) {} |
| } |
| |
| struct GenericInitLabeledTuple<T> { |
| init(x: (T, T)) {} |
| } |
| |
| do { |
| _ = GenericInit(3, 4) // expected-error {{extra argument in call}} |
| _ = GenericInit((3, 4)) |
| |
| _ = GenericInitLabeled(x: 3, 4) // expected-error {{extra argument in call}} |
| _ = GenericInitLabeled(x: (3, 4)) |
| |
| _ = GenericInitTwo(3, 4) |
| _ = GenericInitTwo((3, 4)) // expected-error {{missing argument for parameter #2 in call}} |
| |
| _ = GenericInitTuple(3, 4) // expected-error {{initializer expects a single parameter of type '(T, T)'}} {{24-24=(}} {{28-28=)}} |
| _ = GenericInitTuple((3, 4)) |
| |
| _ = GenericInitLabeledTuple(x: 3, 4) // expected-error {{extra argument in call}} |
| _ = GenericInitLabeledTuple(x: (3, 4)) |
| } |
| |
| do { |
| _ = GenericInit<(Int, Int)>(3, 4) // expected-error {{extra argument in call}} |
| _ = GenericInit<(Int, Int)>((3, 4)) |
| |
| _ = GenericInitLabeled<(Int, Int)>(x: 3, 4) // expected-error {{extra argument in call}} |
| _ = GenericInitLabeled<(Int, Int)>(x: (3, 4)) |
| |
| _ = GenericInitTwo<Int>(3, 4) |
| _ = GenericInitTwo<Int>((3, 4)) // expected-error {{missing argument for parameter #2 in call}} |
| |
| _ = GenericInitTuple<Int>(3, 4) // expected-error {{initializer expects a single parameter of type '(T, T)'}} {{29-29=(}} {{33-33=)}} |
| _ = GenericInitTuple<Int>((3, 4)) |
| |
| _ = GenericInitLabeledTuple<Int>(x: 3, 4) // expected-error {{extra argument in call}} |
| _ = GenericInitLabeledTuple<Int>(x: (3, 4)) |
| } |
| |
| do { |
| let a = 3 |
| let b = 4 |
| let c = (a, b) |
| |
| _ = GenericInit(a, b) // expected-error {{extra argument in call}} |
| _ = GenericInit((a, b)) |
| _ = GenericInit(c) |
| |
| _ = GenericInitTwo(a, b) |
| _ = GenericInitTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| _ = GenericInitTwo(c) // expected-error {{missing argument for parameter #2 in call}} |
| |
| _ = GenericInitTuple(a, b) // expected-error {{initializer expects a single parameter of type '(T, T)'}} {{24-24=(}} {{28-28=)}} |
| _ = GenericInitTuple((a, b)) |
| _ = GenericInitTuple(c) |
| } |
| |
| do { |
| let a = 3 |
| let b = 4 |
| let c = (a, b) |
| |
| _ = GenericInit<(Int, Int)>(a, b) // expected-error {{extra argument in call}} |
| _ = GenericInit<(Int, Int)>((a, b)) |
| _ = GenericInit<(Int, Int)>(c) |
| |
| _ = GenericInitTwo<Int>(a, b) |
| _ = GenericInitTwo<Int>((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| _ = GenericInitTwo<Int>(c) // expected-error {{missing argument for parameter #2 in call}} |
| |
| _ = GenericInitTuple<Int>(a, b) // expected-error {{initializer expects a single parameter of type '(T, T)'}} {{29-29=(}} {{33-33=)}} |
| _ = GenericInitTuple<Int>((a, b)) |
| _ = GenericInitTuple<Int>(c) |
| } |
| |
| do { |
| var a = 3 |
| var b = 4 |
| var c = (a, b) |
| |
| _ = GenericInit(a, b) // expected-error {{extra argument in call}} |
| _ = GenericInit((a, b)) |
| _ = GenericInit(c) |
| |
| _ = GenericInitTwo(a, b) |
| _ = GenericInitTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| _ = GenericInitTwo(c) // expected-error {{missing argument for parameter #2 in call}} |
| |
| _ = GenericInitTuple(a, b) // expected-error {{initializer expects a single parameter of type '(T, T)'}} {{24-24=(}} {{28-28=)}} |
| _ = GenericInitTuple((a, b)) |
| _ = GenericInitTuple(c) |
| } |
| |
| do { |
| var a = 3 // expected-warning {{variable 'a' was never mutated; consider changing to 'let' constant}} |
| var b = 4 // expected-warning {{variable 'b' was never mutated; consider changing to 'let' constant}} |
| var c = (a, b) // expected-warning {{variable 'c' was never mutated; consider changing to 'let' constant}} |
| |
| _ = GenericInit<(Int, Int)>(a, b) // expected-error {{extra argument in call}} |
| _ = GenericInit<(Int, Int)>((a, b)) |
| _ = GenericInit<(Int, Int)>(c) |
| |
| _ = GenericInitTwo<Int>(a, b) |
| _ = GenericInitTwo<Int>((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| _ = GenericInitTwo<Int>(c) // expected-error {{missing argument for parameter #2 in call}} |
| |
| _ = GenericInitTuple<Int>(a, b) // expected-error {{initializer expects a single parameter of type '(T, T)'}} {{29-29=(}} {{33-33=)}} |
| _ = GenericInitTuple<Int>((a, b)) |
| _ = GenericInitTuple<Int>(c) |
| } |
| |
| struct GenericSubscript<T> { |
| subscript(_ x: T) -> Int { get { return 0 } set { } } |
| } |
| |
| struct GenericSubscriptLabeled<T> { |
| subscript(x x: T) -> Int { get { return 0 } set { } } |
| } |
| |
| struct GenericSubscriptTwo<T> { |
| subscript(_ x: T, _ y: T) -> Int { get { return 0 } set { } } // expected-note 5 {{'subscript' declared here}} |
| } |
| |
| struct GenericSubscriptLabeledTuple<T> { |
| subscript(x x: (T, T)) -> Int { get { return 0 } set { } } |
| } |
| |
| struct GenericSubscriptTuple<T> { |
| subscript(_ x: (T, T)) -> Int { get { return 0 } set { } } |
| } |
| |
| do { |
| let s1 = GenericSubscript<(Double, Double)>() |
| _ = s1[3.0, 4.0] // expected-error {{extra argument in call}} |
| _ = s1[(3.0, 4.0)] |
| |
| let s1a = GenericSubscriptLabeled<(Double, Double)>() |
| _ = s1a [x: 3.0, 4.0] // expected-error {{extra argument in call}} |
| _ = s1a [x: (3.0, 4.0)] |
| |
| let s2 = GenericSubscriptTwo<Double>() |
| _ = s2[3.0, 4.0] |
| _ = s2[(3.0, 4.0)] // expected-error {{missing argument for parameter #2 in call}} |
| |
| let s3 = GenericSubscriptTuple<Double>() |
| _ = s3[3.0, 4.0] // expected-error {{subscript expects a single parameter of type '(T, T)'}} {{10-10=(}} {{18-18=)}} |
| _ = s3[(3.0, 4.0)] |
| |
| let s3a = GenericSubscriptLabeledTuple<Double>() |
| _ = s3a[x: 3.0, 4.0] // expected-error {{extra argument in call}} |
| _ = s3a[x: (3.0, 4.0)] |
| } |
| |
| do { |
| let a = 3.0 |
| let b = 4.0 |
| let d = (a, b) |
| |
| let s1 = GenericSubscript<(Double, Double)>() |
| _ = s1[a, b] // expected-error {{extra argument in call}} |
| _ = s1[(a, b)] |
| _ = s1[d] |
| |
| let s2 = GenericSubscriptTwo<Double>() |
| _ = s2[a, b] |
| _ = s2[(a, b)] // expected-error {{missing argument for parameter #2 in call}} |
| _ = s2[d] // expected-error {{missing argument for parameter #2 in call}} |
| |
| let s3 = GenericSubscriptTuple<Double>() |
| _ = s3[a, b] // expected-error {{subscript expects a single parameter of type '(T, T)'}} {{10-10=(}} {{14-14=)}} |
| _ = s3[(a, b)] |
| _ = s3[d] |
| } |
| |
| do { |
| // TODO: Restore regressed diagnostics rdar://problem/31724211 |
| var a = 3.0 // e/xpected-warning {{variable 'a' was never mutated; consider changing to 'let' constant}} |
| var b = 4.0 // e/xpected-warning {{variable 'b' was never mutated; consider changing to 'let' constant}} |
| var d = (a, b) // e/xpected-warning {{variable 'd' was never mutated; consider changing to 'let' constant}} |
| |
| var s1 = GenericSubscript<(Double, Double)>() |
| _ = s1[a, b] // expected-error {{extra argument in call}} |
| _ = s1[(a, b)] |
| _ = s1[d] |
| |
| var s2 = GenericSubscriptTwo<Double>() |
| _ = s2[a, b] |
| _ = s2[(a, b)] // expected-error {{missing argument for parameter #2 in call}} |
| _ = s2[d] // expected-error {{missing argument for parameter #2 in call}} |
| |
| var s3 = GenericSubscriptTuple<Double>() |
| _ = s3[a, b] // expected-error {{subscript expects a single parameter of type '(T, T)'}} {{10-10=(}} {{14-14=)}} |
| _ = s3[(a, b)] |
| _ = s3[d] |
| } |
| |
| enum GenericEnum<T> { |
| case one(T) |
| case labeled(x: T) |
| case two(T, T) // expected-note 10 {{'two' declared here}} |
| case tuple((T, T)) |
| } |
| |
| do { |
| _ = GenericEnum.one(3, 4) // expected-error {{extra argument in call}} |
| _ = GenericEnum.one((3, 4)) |
| |
| _ = GenericEnum.labeled(x: 3, 4) // expected-error {{extra argument in call}} |
| _ = GenericEnum.labeled(x: (3, 4)) |
| _ = GenericEnum.labeled(3, 4) // expected-error {{extra argument in call}} |
| _ = GenericEnum.labeled((3, 4)) // expected-error {{missing argument label 'x:' in call}} |
| |
| _ = GenericEnum.two(3, 4) |
| _ = GenericEnum.two((3, 4)) // expected-error {{missing argument for parameter #2 in call}} |
| |
| _ = GenericEnum.tuple(3, 4) // expected-error {{enum element 'tuple' expects a single parameter of type '(T, T)'}} {{25-25=(}} {{29-29=)}} |
| _ = GenericEnum.tuple((3, 4)) |
| } |
| |
| do { |
| _ = GenericEnum<(Int, Int)>.one(3, 4) // expected-error {{enum element 'one' expects a single parameter of type '(Int, Int)'}} {{35-35=(}} {{39-39=)}} |
| _ = GenericEnum<(Int, Int)>.one((3, 4)) |
| |
| _ = GenericEnum<(Int, Int)>.labeled(x: 3, 4) // expected-error {{extra argument in call}} |
| _ = GenericEnum<(Int, Int)>.labeled(x: (3, 4)) |
| _ = GenericEnum<(Int, Int)>.labeled(3, 4) // expected-error {{extra argument in call}} |
| _ = GenericEnum<(Int, Int)>.labeled((3, 4)) // expected-error {{missing argument label 'x:' in call}} |
| |
| _ = GenericEnum<Int>.two(3, 4) |
| _ = GenericEnum<Int>.two((3, 4)) // expected-error {{missing argument for parameter #2 in call}} |
| |
| _ = GenericEnum<Int>.tuple(3, 4) // expected-error {{enum element 'tuple' expects a single parameter of type '(Int, Int)'}} {{30-30=(}} {{34-34=)}} |
| _ = GenericEnum<Int>.tuple((3, 4)) |
| } |
| |
| do { |
| let a = 3 |
| let b = 4 |
| let c = (a, b) |
| |
| _ = GenericEnum.one(a, b) // expected-error {{extra argument in call}} |
| _ = GenericEnum.one((a, b)) |
| _ = GenericEnum.one(c) |
| |
| _ = GenericEnum.two(a, b) |
| _ = GenericEnum.two((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| _ = GenericEnum.two(c) // expected-error {{missing argument for parameter #2 in call}} |
| |
| _ = GenericEnum.tuple(a, b) // expected-error {{enum element 'tuple' expects a single parameter of type '(T, T)'}} {{25-25=(}} {{29-29=)}} |
| _ = GenericEnum.tuple((a, b)) |
| _ = GenericEnum.tuple(c) |
| } |
| |
| do { |
| let a = 3 |
| let b = 4 |
| let c = (a, b) |
| |
| _ = GenericEnum<(Int, Int)>.one(a, b) // expected-error {{enum element 'one' expects a single parameter of type '(Int, Int)'}} {{35-35=(}} {{39-39=)}} |
| _ = GenericEnum<(Int, Int)>.one((a, b)) |
| _ = GenericEnum<(Int, Int)>.one(c) |
| |
| _ = GenericEnum<Int>.two(a, b) |
| _ = GenericEnum<Int>.two((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| _ = GenericEnum<Int>.two(c) // expected-error {{missing argument for parameter #2 in call}} |
| |
| _ = GenericEnum<Int>.tuple(a, b) // expected-error {{enum element 'tuple' expects a single parameter of type '(Int, Int)'}} {{30-30=(}} {{34-34=)}} |
| _ = GenericEnum<Int>.tuple((a, b)) |
| _ = GenericEnum<Int>.tuple(c) |
| } |
| |
| do { |
| var a = 3 |
| var b = 4 |
| var c = (a, b) |
| |
| _ = GenericEnum.one(a, b) // expected-error {{extra argument in call}} |
| _ = GenericEnum.one((a, b)) |
| _ = GenericEnum.one(c) |
| |
| _ = GenericEnum.two(a, b) |
| _ = GenericEnum.two((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| _ = GenericEnum.two(c) // expected-error {{missing argument for parameter #2 in call}} |
| |
| _ = GenericEnum.tuple(a, b) // expected-error {{enum element 'tuple' expects a single parameter of type '(T, T)'}} {{25-25=(}} {{29-29=)}} |
| _ = GenericEnum.tuple((a, b)) |
| _ = GenericEnum.tuple(c) |
| } |
| |
| do { |
| var a = 3 |
| var b = 4 |
| var c = (a, b) |
| |
| _ = GenericEnum<(Int, Int)>.one(a, b) // expected-error {{enum element 'one' expects a single parameter of type '(Int, Int)'}} {{35-35=(}} {{39-39=)}} |
| _ = GenericEnum<(Int, Int)>.one((a, b)) |
| _ = GenericEnum<(Int, Int)>.one(c) |
| |
| _ = GenericEnum<Int>.two(a, b) |
| _ = GenericEnum<Int>.two((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| _ = GenericEnum<Int>.two(c) // expected-error {{missing argument for parameter #2 in call}} |
| |
| _ = GenericEnum<Int>.tuple(a, b) // expected-error {{enum element 'tuple' expects a single parameter of type '(Int, Int)'}} {{30-30=(}} {{34-34=)}} |
| _ = GenericEnum<Int>.tuple((a, b)) |
| _ = GenericEnum<Int>.tuple(c) |
| } |
| |
| protocol Protocol { |
| associatedtype Element |
| } |
| |
| extension Protocol { |
| func requirement(_ x: Element) {} |
| func requirementLabeled(x: Element) {} |
| func requirementTwo(_ x: Element, _ y: Element) {} // expected-note 3 {{'requirementTwo' declared here}} |
| func requirementTuple(_ x: (Element, Element)) {} |
| } |
| |
| struct GenericConforms<T> : Protocol { |
| typealias Element = T |
| } |
| |
| do { |
| let s = GenericConforms<Double>() |
| |
| s.requirement(3.0) |
| s.requirement((3.0)) |
| |
| s.requirementLabeled(x: 3.0) |
| s.requirementLabeled(x: (3.0)) |
| |
| s.requirementTwo(3.0, 4.0) |
| s.requirementTwo((3.0, 4.0)) // expected-error {{missing argument for parameter #2 in call}} |
| |
| s.requirementTuple(3.0, 4.0) // expected-error {{instance method 'requirementTuple' expects a single parameter of type '(Double, Double)'}} {{22-22=(}} {{30-30=)}} |
| s.requirementTuple((3.0, 4.0)) |
| |
| let sTwo = GenericConforms<(Double, Double)>() |
| |
| sTwo.requirement(3.0, 4.0) // expected-error {{instance method 'requirement' expects a single parameter of type '(Double, Double)'}} {{20-20=(}} {{28-28=)}} |
| sTwo.requirement((3.0, 4.0)) |
| |
| sTwo.requirementLabeled(x: 3.0, 4.0) // expected-error {{extra argument in call}} |
| sTwo.requirementLabeled(x: (3.0, 4.0)) |
| } |
| |
| do { |
| let s = GenericConforms<Double>() |
| |
| let a = 3.0 |
| let b = 4.0 |
| let c = (3.0) |
| let d = (a, b) |
| |
| s.requirement(a) |
| s.requirement((a)) |
| s.requirement(c) |
| |
| s.requirementTwo(a, b) |
| s.requirementTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| |
| s.requirementTuple(a, b) // expected-error {{instance method 'requirementTuple' expects a single parameter of type '(Double, Double)'}} {{22-22=(}} {{26-26=)}} |
| s.requirementTuple((a, b)) |
| |
| let sTwo = GenericConforms<(Double, Double)>() |
| |
| sTwo.requirement(a, b) // expected-error {{instance method 'requirement' expects a single parameter of type '(Double, Double)'}} {{20-20=(}} {{24-24=)}} |
| sTwo.requirement((a, b)) |
| sTwo.requirement(d) |
| } |
| |
| do { |
| var s = GenericConforms<Double>() |
| |
| var a = 3.0 |
| var b = 4.0 |
| var c = (3.0) |
| var d = (a, b) |
| |
| s.requirement(a) |
| s.requirement((a)) |
| s.requirement(c) |
| |
| s.requirementTwo(a, b) |
| s.requirementTwo((a, b)) // expected-error {{missing argument for parameter #2 in call}} |
| |
| s.requirementTuple(a, b) // expected-error {{instance method 'requirementTuple' expects a single parameter of type '(Double, Double)'}} {{22-22=(}} {{26-26=)}} |
| s.requirementTuple((a, b)) |
| |
| var sTwo = GenericConforms<(Double, Double)>() |
| |
| sTwo.requirement(a, b) // expected-error {{instance method 'requirement' expects a single parameter of type '(Double, Double)'}} {{20-20=(}} {{24-24=)}} |
| sTwo.requirement((a, b)) |
| sTwo.requirement(d) |
| } |
| |
| extension Protocol { |
| func takesClosure(_ fn: (Element) -> ()) {} |
| func takesClosureTwo(_ fn: (Element, Element) -> ()) {} |
| func takesClosureTuple(_ fn: ((Element, Element)) -> ()) {} |
| } |
| |
| do { |
| let s = GenericConforms<Double>() |
| s.takesClosure({ _ = $0 }) |
| s.takesClosure({ x in }) |
| s.takesClosure({ (x: Double) in }) |
| |
| s.takesClosureTwo({ _ = $0 }) // expected-error {{contextual closure type '(Double, Double) -> ()' expects 2 arguments, but 1 was used in closure body}} |
| s.takesClosureTwo({ x in }) // expected-error {{contextual closure type '(Double, Double) -> ()' expects 2 arguments, but 1 was used in closure body}} |
| s.takesClosureTwo({ (x: (Double, Double)) in }) // expected-error {{contextual closure type '(Double, Double) -> ()' expects 2 arguments, but 1 was used in closure body}} |
| s.takesClosureTwo({ _ = $0; _ = $1 }) |
| s.takesClosureTwo({ (x, y) in }) |
| s.takesClosureTwo({ (x: Double, y:Double) in }) |
| |
| s.takesClosureTuple({ _ = $0 }) |
| s.takesClosureTuple({ x in }) |
| s.takesClosureTuple({ (x: (Double, Double)) in }) |
| s.takesClosureTuple({ _ = $0; _ = $1 }) |
| s.takesClosureTuple({ (x, y) in }) |
| s.takesClosureTuple({ (x: Double, y:Double) in }) |
| |
| let sTwo = GenericConforms<(Double, Double)>() |
| sTwo.takesClosure({ _ = $0 }) |
| sTwo.takesClosure({ x in }) |
| sTwo.takesClosure({ (x: (Double, Double)) in }) |
| sTwo.takesClosure({ _ = $0; _ = $1 }) |
| sTwo.takesClosure({ (x, y) in }) |
| sTwo.takesClosure({ (x: Double, y: Double) in }) |
| } |
| |
| do { |
| let _: ((Int, Int)) -> () = { _ = $0 } |
| let _: ((Int, Int)) -> () = { _ = ($0.0, $0.1) } |
| let _: ((Int, Int)) -> () = { t in _ = (t.0, t.1) } |
| |
| let _: ((Int, Int)) -> () = { _ = ($0, $1) } // expected-error {{closure tuple parameter '(Int, Int)' does not support destructuring}} |
| let _: ((Int, Int)) -> () = { t, u in _ = (t, u) } // expected-error {{closure tuple parameter '(Int, Int)' does not support destructuring}} {{33-37=(arg)}} {{41-41=let (t, u) = arg; }} |
| |
| let _: (Int, Int) -> () = { _ = $0 } // expected-error {{contextual closure type '(Int, Int) -> ()' expects 2 arguments, but 1 was used in closure body}} |
| let _: (Int, Int) -> () = { _ = ($0.0, $0.1) } // expected-error {{contextual closure type '(Int, Int) -> ()' expects 2 arguments, but 1 was used in closure body}} |
| let _: (Int, Int) -> () = { t in _ = (t.0, t.1) } // expected-error {{contextual closure type '(Int, Int) -> ()' expects 2 arguments, but 1 was used in closure body}} |
| |
| let _: (Int, Int) -> () = { _ = ($0, $1) } |
| let _: (Int, Int) -> () = { t, u in _ = (t, u) } |
| } |
| |
| // rdar://problem/28952837 - argument labels ignored when calling function |
| // with single 'Any' parameter |
| func takesAny(_: Any) {} |
| |
| enum HasAnyCase { |
| case any(_: Any) |
| } |
| |
| do { |
| let fn: (Any) -> () = { _ in } |
| |
| fn(123) |
| fn(data: 123) // expected-error {{extraneous argument label 'data:' in call}} |
| |
| takesAny(123) |
| takesAny(data: 123) // expected-error {{extraneous argument label 'data:' in call}} |
| |
| _ = HasAnyCase.any(123) |
| _ = HasAnyCase.any(data: 123) // expected-error {{extraneous argument label 'data:' in call}} |
| } |
| |
| // rdar://problem/29739905 - protocol extension methods on Array had |
| // ParenType sugar stripped off the element type |
| func processArrayOfFunctions(f1: [((Bool, Bool)) -> ()], |
| f2: [(Bool, Bool) -> ()], |
| c: Bool) { |
| let p = (c, c) |
| |
| f1.forEach { block in |
| block(p) |
| block((c, c)) |
| block(c, c) // expected-error {{parameter 'block' expects a single parameter of type '(Bool, Bool)'}} {{11-11=(}} {{15-15=)}} |
| } |
| |
| f2.forEach { block in |
| // expected-note@-1 2{{'block' declared here}} |
| block(p) // expected-error {{missing argument for parameter #2 in call}} |
| block((c, c)) // expected-error {{missing argument for parameter #2 in call}} |
| block(c, c) |
| } |
| |
| f2.forEach { (block: ((Bool, Bool)) -> ()) in |
| // expected-error@-1 {{cannot convert value of type '(((Bool, Bool)) -> ()) -> ()' to expected argument type '((Bool, Bool) -> ()) -> Void}} |
| block(p) |
| block((c, c)) |
| block(c, c) |
| } |
| |
| f2.forEach { (block: (Bool, Bool) -> ()) in |
| // expected-note@-1 2{{'block' declared here}} |
| block(p) // expected-error {{missing argument for parameter #2 in call}} |
| block((c, c)) // expected-error {{missing argument for parameter #2 in call}} |
| block(c, c) |
| } |
| } |
| |
| // expected-error@+1 {{cannot create a single-element tuple with an element label}} |
| func singleElementTupleArgument(completion: ((didAdjust: Bool)) -> Void) { |
| // TODO: Error could be improved. |
| // expected-error@+1 {{cannot convert value of type '(didAdjust: Bool)' to expected argument type 'Bool'}} |
| completion((didAdjust: true)) |
| } |
| |
| |
| // SR-4378 |
| |
| final public class MutableProperty<Value> { |
| public init(_ initialValue: Value) {} |
| } |
| |
| enum DataSourcePage<T> { |
| case notLoaded |
| } |
| |
| let pages1: MutableProperty<(data: DataSourcePage<Int>, totalCount: Int)> = MutableProperty(( |
| data: .notLoaded, |
| totalCount: 0 |
| )) |
| |
| |
| let pages2: MutableProperty<(data: DataSourcePage<Int>, totalCount: Int)> = MutableProperty(( |
| data: DataSourcePage.notLoaded, |
| totalCount: 0 |
| )) |
| |
| |
| let pages3: MutableProperty<(data: DataSourcePage<Int>, totalCount: Int)> = MutableProperty(( |
| data: DataSourcePage<Int>.notLoaded, |
| totalCount: 0 |
| )) |
| |
| // SR-4745 |
| let sr4745 = [1, 2] |
| let _ = sr4745.enumerated().map { (count, element) in "\(count): \(element)" } |
| |
| // SR-4738 |
| |
| let sr4738 = (1, (2, 3)) |
| [sr4738].map { (x, (y, z)) -> Int in x + y + z } // expected-error {{use of undeclared type 'y'}} |
| // expected-error@-1 {{closure tuple parameter does not support destructuring}} {{20-26=arg1}} {{38-38=let (y, z) = arg1; }} |
| |
| // rdar://problem/31892961 |
| let r31892961_1 = [1: 1, 2: 2] |
| r31892961_1.forEach { (k, v) in print(k + v) } |
| |
| let r31892961_2 = [1, 2, 3] |
| let _: [Int] = r31892961_2.enumerated().map { ((index, val)) in |
| // expected-error@-1 {{closure tuple parameter does not support destructuring}} {{48-60=arg0}} {{3-3=\n let (index, val) = arg0\n }} |
| // expected-error@-2 {{use of undeclared type 'index'}} |
| val + 1 |
| } |
| |
| let r31892961_3 = (x: 1, y: 42) |
| _ = [r31892961_3].map { (x: Int, y: Int) in x + y } |
| |
| _ = [r31892961_3].map { (x, y: Int) in x + y } |
| |
| let r31892961_4 = (1, 2) |
| _ = [r31892961_4].map { x, y in x + y } |
| |
| let r31892961_5 = (x: 1, (y: 2, (w: 3, z: 4))) |
| [r31892961_5].map { (x: Int, (y: Int, (w: Int, z: Int))) in x + y } |
| // expected-error@-1 {{closure tuple parameter does not support destructuring}} {{30-56=arg1}} {{61-61=let (y, (w, z)) = arg1; }} |
| |
| let r31892961_6 = (x: 1, (y: 2, z: 4)) |
| [r31892961_6].map { (x: Int, (y: Int, z: Int)) in x + y } |
| // expected-error@-1 {{closure tuple parameter does not support destructuring}} {{30-46=arg1}} {{51-51=let (y, z) = arg1; }} |
| |
| // rdar://problem/32214649 -- these regressed in Swift 4 mode |
| // with SE-0110 because of a problem in associated type inference |
| |
| func r32214649_1<X,Y>(_ a: [X], _ f: (X)->Y) -> [Y] { |
| return a.map(f) |
| } |
| |
| func r32214649_2<X>(_ a: [X], _ f: (X) -> Bool) -> [X] { |
| return a.filter(f) |
| } |
| |
| func r32214649_3<X>(_ a: [X]) -> [X] { |
| return a.filter { _ in return true } |
| } |
| |
| // rdar://problem/32301091 - [SE-0110] causes errors when passing a closure with a single underscore to a block accepting multiple parameters |
| |
| func rdar32301091_1(_ :((Int, Int) -> ())!) {} |
| rdar32301091_1 { _ in } |
| // expected-error@-1 {{contextual closure type '(Int, Int) -> ()' expects 2 arguments, but 1 was used in closure body}} {{19-19=,_ }} |
| |
| func rdar32301091_2(_ :(Int, Int) -> ()) {} |
| rdar32301091_2 { _ in } |
| // expected-error@-1 {{contextual closure type '(Int, Int) -> ()' expects 2 arguments, but 1 was used in closure body}} {{19-19=,_ }} |
| rdar32301091_2 { x in } |
| // expected-error@-1 {{contextual closure type '(Int, Int) -> ()' expects 2 arguments, but 1 was used in closure body}} {{19-19=,<#arg#> }} |
| |
| func rdar32875953() { |
| let myDictionary = ["hi":1] |
| |
| myDictionary.forEach { |
| print("\($0) -> \($1)") |
| } |
| |
| myDictionary.forEach { key, value in |
| print("\(key) -> \(value)") |
| } |
| |
| myDictionary.forEach { (key, value) in |
| print("\(key) -> \(value)") |
| } |
| |
| let array1 = [1] |
| let array2 = [2] |
| |
| _ = zip(array1, array2).map(+) |
| } |
| |
| struct SR_5199 {} |
| extension Sequence where Iterator.Element == (key: String, value: String?) { |
| func f() -> [SR_5199] { |
| return self.map { (key, value) in |
| SR_5199() // Ok |
| } |
| } |
| } |
| |
| func rdar33043106(_ records: [(Int)], _ other: [((Int))]) -> [Int] { |
| let x: [Int] = records.map { _ in |
| let i = 1 |
| return i |
| } |
| let y: [Int] = other.map { _ in |
| let i = 1 |
| return i |
| } |
| |
| return x + y |
| } |
| |
| func itsFalse(_: Int) -> Bool? { |
| return false |
| } |
| |
| func rdar33159366(s: AnySequence<Int>) { |
| _ = s.compactMap(itsFalse) |
| let a = Array(s) |
| _ = a.compactMap(itsFalse) |
| } |
| |
| func sr5429<T>(t: T) { |
| _ = AnySequence([t]).first(where: { (t: T) in true }) |
| } |
| |
| extension Concrete { |
| typealias T = (Int, Int) |
| typealias F = (T) -> () |
| func opt1(_ fn: (((Int, Int)) -> ())?) {} |
| func opt2(_ fn: (((Int, Int)) -> ())??) {} |
| func opt3(_ fn: (((Int, Int)) -> ())???) {} |
| func optAliasT(_ fn: ((T) -> ())?) {} |
| func optAliasF(_ fn: F?) {} |
| } |
| |
| extension Generic { |
| typealias F = (T) -> () |
| func opt1(_ fn: (((Int, Int)) -> ())?) {} |
| func opt2(_ fn: (((Int, Int)) -> ())??) {} |
| func opt3(_ fn: (((Int, Int)) -> ())???) {} |
| func optAliasT(_ fn: ((T) -> ())?) {} |
| func optAliasF(_ fn: F?) {} |
| } |
| |
| func rdar33239714() { |
| Concrete().opt1 { x, y in } |
| Concrete().opt1 { (x, y) in } |
| Concrete().opt2 { x, y in } |
| Concrete().opt2 { (x, y) in } |
| Concrete().opt3 { x, y in } |
| Concrete().opt3 { (x, y) in } |
| Concrete().optAliasT { x, y in } |
| Concrete().optAliasT { (x, y) in } |
| Concrete().optAliasF { x, y in } |
| Concrete().optAliasF { (x, y) in } |
| Generic<(Int, Int)>().opt1 { x, y in } |
| Generic<(Int, Int)>().opt1 { (x, y) in } |
| Generic<(Int, Int)>().opt2 { x, y in } |
| Generic<(Int, Int)>().opt2 { (x, y) in } |
| Generic<(Int, Int)>().opt3 { x, y in } |
| Generic<(Int, Int)>().opt3 { (x, y) in } |
| Generic<(Int, Int)>().optAliasT { x, y in } |
| Generic<(Int, Int)>().optAliasT { (x, y) in } |
| Generic<(Int, Int)>().optAliasF { x, y in } |
| Generic<(Int, Int)>().optAliasF { (x, y) in } |
| } |
| |
| // rdar://problem/35198459 - source-compat-suite failure: Moya (toType->hasUnresolvedType() && "Should have handled this above" |
| do { |
| func foo(_: (() -> Void)?) {} |
| func bar() -> ((()) -> Void)? { return nil } |
| foo(bar()) // expected-error {{cannot convert value of type '((()) -> Void)?' to expected argument type '(() -> Void)?'}} |
| } |
| |
| // https://bugs.swift.org/browse/SR-6509 |
| public extension Optional { |
| public func apply<Result>(_ transform: ((Wrapped) -> Result)?) -> Result? { |
| return self.flatMap { value in |
| transform.map { $0(value) } |
| } |
| } |
| |
| public func apply<Value, Result>(_ value: Value?) -> Result? |
| where Wrapped == (Value) -> Result { |
| return value.apply(self) |
| } |
| } |