| // RUN: %target-typecheck-verify-swift -parse-as-library -enable-objc-interop |
| |
| class A { |
| func ret_sametype() -> Int { return 0 } |
| func ret_subclass() -> A { return self } |
| func ret_subclass_rev() -> B { return B() } |
| func ret_nonclass_optional() -> Int? { return .none } |
| func ret_nonclass_optional_rev() -> Int { return 0 } |
| func ret_class_optional() -> B? { return .none } |
| func ret_class_optional_rev() -> A { return self } |
| func ret_class_uoptional() -> B! { return B() } |
| func ret_class_uoptional_rev() -> A { return self } |
| func ret_class_optional_uoptional() -> B? { return .none } |
| func ret_class_optional_uoptional_rev() -> A! { return self } |
| |
| func param_sametype(_ x : Int) {} |
| func param_subclass(_ x : B) {} |
| func param_subclass_rev(_ x : A) {} |
| func param_nonclass_optional(_ x : Int) {} |
| func param_nonclass_optional_rev(_ x : Int?) {} |
| func param_class_optional(_ x : B) {} |
| func param_class_optional_rev(_ x : B?) {} |
| func param_class_uoptional(_ x : B) {} |
| func param_class_uoptional_rev(_ x : B!) {} |
| func param_class_optional_uoptional(_ x : B!) {} |
| func param_class_optional_uoptional_rev(_ x : B?) {} |
| } |
| |
| class B : A { |
| override func ret_sametype() -> Int { return 1 } |
| override func ret_subclass() -> B { return self } |
| func ret_subclass_rev() -> A { return self } |
| override func ret_nonclass_optional() -> Int { return 0 } |
| func ret_nonclass_optional_rev() -> Int? { return 0 } |
| override func ret_class_optional() -> B { return self } |
| func ret_class_optional_rev() -> A? { return self } |
| override func ret_class_uoptional() -> B { return self } |
| func ret_class_uoptional_rev() -> A! { return self } |
| override func ret_class_optional_uoptional() -> B! { return self } |
| override func ret_class_optional_uoptional_rev() -> A? { return self } |
| |
| override func param_sametype(_ x : Int) {} |
| override func param_subclass(_ x : A) {} |
| func param_subclass_rev(_ x : B) {} |
| override func param_nonclass_optional(_ x : Int?) {} |
| func param_nonclass_optional_rev(_ x : Int) {} |
| override func param_class_optional(_ x : B?) {} |
| func param_class_optional_rev(_ x : B) {} |
| override func param_class_uoptional(_ x : B!) {} |
| func param_class_uoptional_rev(_ x : B) {} |
| override func param_class_optional_uoptional(_ x : B?) {} |
| override func param_class_optional_uoptional_rev(_ x : B!) {} |
| } |
| |
| class C<T> { |
| func ret_T() -> T {} |
| } |
| |
| class D<T> : C<[T]> { |
| override func ret_T() -> [T] {} |
| } |
| |
| class E { |
| var var_sametype: Int { get { return 0 } set {} } |
| var var_subclass: E { get { return self } set {} } // expected-note{{attempt to override property here}} |
| var var_subclass_rev: F { get { return F() } set {} } // expected-note{{attempt to override property here}} |
| var var_nonclass_optional: Int? { get { return .none } set {} } // expected-note{{attempt to override property here}} |
| var var_nonclass_optional_rev: Int { get { return 0 } set {} } // expected-note{{attempt to override property here}} |
| var var_class_optional: F? { get { return .none } set {} } // expected-note{{attempt to override property here}} |
| var var_class_optional_rev: E { get { return self } set {} } // expected-note{{attempt to override property here}} |
| var var_class_uoptional: F! { get { return F() } set {} } // expected-note{{attempt to override property here}} |
| var var_class_uoptional_rev: E { get { return self } set {} } // expected-note{{attempt to override property here}} |
| var var_class_optional_uoptional: F? { get { return .none } set {} } |
| var var_class_optional_uoptional_rev: E! { get { return self } set {} } |
| |
| var ro_sametype: Int { return 0 } |
| var ro_subclass: E { return self } |
| var ro_subclass_rev: F { return F() } |
| var ro_nonclass_optional: Int? { return 0 } |
| var ro_nonclass_optional_rev: Int { return 0 } // expected-note{{attempt to override property here}} |
| var ro_class_optional: F? { return .none } |
| var ro_class_optional_rev: E { return self } // expected-note{{attempt to override property here}} |
| var ro_class_uoptional: F! { return F() } |
| var ro_class_uoptional_rev: E { return self } // expected-note{{attempt to override property here}} |
| var ro_class_optional_uoptional: F? { return .none } |
| var ro_class_optional_uoptional_rev: E! { return self } |
| } |
| |
| class F : E { |
| override var var_sametype: Int { get { return 0 } set {} } |
| override var var_subclass: F { get { return self } set {} } // expected-error{{cannot override mutable property 'var_subclass' of type 'E' with covariant type 'F'}} |
| override var var_subclass_rev: E { get { return F() } set {} } // expected-error{{property 'var_subclass_rev' with type 'E' cannot override a property with type 'F}} |
| override var var_nonclass_optional: Int { get { return 0 } set {} } // expected-error{{cannot override mutable property 'var_nonclass_optional' of type 'Int?' with covariant type 'Int'}} |
| override var var_nonclass_optional_rev: Int? { get { return 0 } set {} } // expected-error{{property 'var_nonclass_optional_rev' with type 'Int?' cannot override a property with type 'Int'}} |
| override var var_class_optional: F { get { return self } set {} } // expected-error{{cannot override mutable property 'var_class_optional' of type 'F?' with covariant type 'F'}} |
| override var var_class_optional_rev: E? { get { return self } set {} } // expected-error{{property 'var_class_optional_rev' with type 'E?' cannot override a property with type 'E'}} |
| override var var_class_uoptional: F { get { return F() } set {} } // expected-error{{cannot override mutable property 'var_class_uoptional' of type 'F?' with covariant type 'F'}} |
| override var var_class_uoptional_rev: E! { get { return self } set {} } // expected-error{{property 'var_class_uoptional_rev' with type 'E?' cannot override a property with type 'E'}} |
| override var var_class_optional_uoptional: F! { get { return .none } set {} } |
| override var var_class_optional_uoptional_rev: E? { get { return self } set {} } |
| |
| override var ro_sametype: Int { return 0 } |
| override var ro_subclass: E { return self } |
| override var ro_subclass_rev: F { return F() } |
| override var ro_nonclass_optional: Int { return 0 } |
| override var ro_nonclass_optional_rev: Int? { return 0 } // expected-error{{property 'ro_nonclass_optional_rev' with type 'Int?' cannot override a property with type 'Int'}} |
| override var ro_class_optional: F { return self } |
| override var ro_class_optional_rev: E? { return self } // expected-error{{property 'ro_class_optional_rev' with type 'E?' cannot override a property with type 'E'}} |
| override var ro_class_uoptional: F { return F() } |
| override var ro_class_uoptional_rev: E! { return self } // expected-error{{property 'ro_class_uoptional_rev' with type 'E?' cannot override a property with type 'E'}} |
| override var ro_class_optional_uoptional: F! { return .none } |
| override var ro_class_optional_uoptional_rev: E? { return self } |
| } |
| |
| |
| class G { |
| func f1(_: Int, int: Int) { } |
| func f2(_: Int, int: Int) { } |
| func f3(_: Int, int: Int) { } |
| func f4(_: Int, int: Int) { } |
| func f5(_: Int, int: Int) { } |
| func f6(_: Int, int: Int) { } |
| func f7(_: Int, int: Int) { } |
| |
| func g1(_: Int, string: String) { } // expected-note{{potential overridden instance method 'g1(_:string:)' here}} {{28-28=string }} |
| func g1(_: Int, path: String) { } // expected-note{{potential overridden instance method 'g1(_:path:)' here}} {{28-28=path }} |
| |
| func g2(_: Int, string: String) { } // expected-note{{potential overridden instance method 'g2(_:string:)' here}} {{none}} |
| func g2(_: Int, path: String) { } |
| |
| func g3(_: Int, _ another: Int) { } |
| func g3(_: Int, path: String) { } // expected-note{{potential overridden instance method 'g3(_:path:)' here}} {{none}} |
| |
| func g4(_: Int, _ another: Int) { } |
| func g4(_: Int, path: String) { } |
| |
| init(a: Int) {} // expected-note {{potential overridden initializer 'init(a:)' here}} {{none}} |
| init(a: String) {} // expected-note {{potential overridden initializer 'init(a:)' here}} {{17-17=a }} expected-note {{potential overridden initializer 'init(a:)' here}} {{none}} |
| init(b: String) {} // expected-note {{potential overridden initializer 'init(b:)' here}} {{17-17=b }} expected-note {{potential overridden initializer 'init(b:)' here}} {{none}} |
| } |
| |
| class H : G { |
| override func f1(_: Int, _: Int) { } // expected-error{{argument labels for method 'f1' do not match those of overridden method 'f1(_:int:)'}}{{28-28=int }} |
| override func f2(_: Int, value: Int) { } // expected-error{{argument labels for method 'f2(_:value:)' do not match those of overridden method 'f2(_:int:)'}}{{28-28=int }} |
| override func f3(_: Int, value int: Int) { } // expected-error{{argument labels for method 'f3(_:value:)' do not match those of overridden method 'f3(_:int:)'}}{{28-34=}} |
| override func f4(_: Int, _ int: Int) { } // expected-error{{argument labels for method 'f4' do not match those of overridden method 'f4(_:int:)'}}{{28-30=}} |
| override func f5(_: Int, value inValue: Int) { } // expected-error{{argument labels for method 'f5(_:value:)' do not match those of overridden method 'f5(_:int:)'}}{{28-33=int}} |
| override func f6(_: Int, _ inValue: Int) { } // expected-error{{argument labels for method 'f6' do not match those of overridden method 'f6(_:int:)'}}{{28-29=int}} |
| |
| override func f7(_: Int, int value: Int) { } // okay |
| |
| override func g1(_: Int, s: String) { } // expected-error{{declaration 'g1(_:s:)' has different argument labels from any potential overrides}}{{none}} |
| override func g2(_: Int, string: Int) { } // expected-error{{method does not override any method from its superclass}} {{none}} |
| override func g3(_: Int, path: Int) { } // expected-error{{method does not override any method from its superclass}} {{none}} |
| override func g4(_: Int, string: Int) { } // expected-error{{argument labels for method 'g4(_:string:)' do not match those of overridden method 'g4'}} {{28-28=_ }} |
| |
| override init(x: Int) {} // expected-error{{argument labels for initializer 'init(x:)' do not match those of overridden initializer 'init(a:)'}} {{17-17=a }} |
| override init(x: String) {} // expected-error{{declaration 'init(x:)' has different argument labels from any potential overrides}} {{none}} |
| override init(a: Double) {} // expected-error{{initializer does not override a designated initializer from its superclass}} {{none}} |
| override init(b: Double) {} // expected-error{{initializer does not override a designated initializer from its superclass}} {{none}} |
| } |
| |
| @objc class IUOTestBaseClass { |
| @objc func none() {} |
| |
| @objc func oneA(_: AnyObject) {} |
| @objc func oneB(x: AnyObject) {} |
| @objc func oneC(_ x: AnyObject) {} |
| |
| @objc func manyA(_: AnyObject, _: AnyObject) {} |
| @objc func manyB(_ a: AnyObject, b: AnyObject) {} |
| @objc func manyC(var a: AnyObject, // expected-error {{'var' as a parameter attribute is not allowed}} |
| var b: AnyObject) {} // expected-error {{'var' as a parameter attribute is not allowed}} |
| |
| @objc func result() -> AnyObject? { return nil } |
| @objc func both(_ x: AnyObject) -> AnyObject? { return x } |
| |
| @objc init(_: AnyObject) {} |
| @objc init(one: AnyObject) {} |
| @objc init(a: AnyObject, b: AnyObject) {} |
| } |
| |
| class IUOTestSubclass : IUOTestBaseClass { |
| override func oneA(_: AnyObject!) {} // expected-warning {{overriding instance method parameter of type 'AnyObject' with implicitly unwrapped optional type 'AnyObject?'}} |
| // expected-note@-1 {{remove '!' to make the parameter required}} {{34-35=}} |
| // expected-note@-2 {{add parentheses to silence this warning}} {{25-25=(}} {{35-35=)}} |
| override func oneB(x: AnyObject!) {} // expected-warning {{overriding instance method parameter of type 'AnyObject' with implicitly unwrapped optional type 'AnyObject?'}} |
| // expected-note@-1 {{remove '!' to make the parameter required}} {{34-35=}} |
| // expected-note@-2 {{add parentheses to silence this warning}} {{25-25=(}} {{35-35=)}} |
| override func oneC(_ x: AnyObject!) {} // expected-warning {{overriding instance method parameter of type 'AnyObject' with implicitly unwrapped optional type 'AnyObject?'}} |
| // expected-note@-1 {{remove '!' to make the parameter required}} {{36-37=}} |
| // expected-note@-2 {{add parentheses to silence this warning}} {{27-27=(}} {{37-37=)}} |
| |
| override func manyA(_: AnyObject!, _: AnyObject!) {} // expected-warning 2 {{overriding instance method parameter of type 'AnyObject' with implicitly unwrapped optional type 'AnyObject?'}} |
| // expected-note@-1 2 {{remove '!' to make the parameter required}} |
| // expected-note@-2 2 {{add parentheses to silence this warning}} |
| override func manyB(_ a: AnyObject!, b: AnyObject!) {} // expected-warning 2 {{overriding instance method parameter of type 'AnyObject' with implicitly unwrapped optional type 'AnyObject?'}} |
| // expected-note@-1 2 {{remove '!' to make the parameter required}} |
| // expected-note@-2 2 {{add parentheses to silence this warning}} |
| |
| override func result() -> AnyObject! { return nil } // expected-warning {{overriding instance method optional result type 'AnyObject?' with implicitly unwrapped optional type 'AnyObject?'}} |
| // expected-note@-1 {{use '?' to make the result optional}} {{38-39=?}} |
| // expected-note@-2 {{add parentheses to silence this warning}} {{29-29=(}} {{39-39=)}} |
| override func both(_ x: AnyObject!) -> AnyObject! { return x } // expected-warning {{overriding instance method optional result type 'AnyObject?' with implicitly unwrapped optional type 'AnyObject?'}} expected-warning {{overriding instance method parameter of type 'AnyObject' with implicitly unwrapped optional type 'AnyObject?'}} |
| // expected-note@-1 {{use '?' to make the result optional}} {{51-52=?}} expected-note@-1 {{remove '!' to make the parameter required}} {{36-37=}} |
| // expected-note@-2 2 {{add parentheses to silence this warning}} |
| |
| override init(_: AnyObject!) {} // expected-warning {{overriding initializer parameter of type 'AnyObject' with implicitly unwrapped optional type 'AnyObject?'}} |
| // expected-note@-1 {{remove '!' to make the parameter required}} {{29-30=}} |
| // expected-note@-2 {{add parentheses to silence this warning}} {{20-20=(}} {{30-30=)}} |
| override init(one: AnyObject!) {} // expected-warning {{overriding initializer parameter of type 'AnyObject' with implicitly unwrapped optional type 'AnyObject?'}} |
| // expected-note@-1 {{remove '!' to make the parameter required}} {{31-32=}} |
| // expected-note@-2 {{add parentheses to silence this warning}} {{22-22=(}} {{32-32=)}} |
| override init(a: AnyObject!, b: AnyObject!) {} // expected-warning 2 {{overriding initializer parameter of type 'AnyObject' with implicitly unwrapped optional type 'AnyObject?'}} |
| // expected-note@-1 2 {{remove '!' to make the parameter required}} |
| // expected-note@-2 2 {{add parentheses to silence this warning}} |
| } |
| |
| class IUOTestSubclass2 : IUOTestBaseClass { |
| override func oneA(_ x: AnyObject!) {} // expected-warning {{overriding instance method parameter of type 'AnyObject' with implicitly unwrapped optional type 'AnyObject?'}} |
| // expected-note@-1 {{remove '!' to make the parameter required}} {{36-37=}} |
| // expected-note@-2 {{add parentheses to silence this warning}} {{27-27=(}} {{37-37=)}} |
| |
| override func oneB(x: AnyObject!) {} // expected-warning {{overriding instance method parameter of type 'AnyObject' with implicitly unwrapped optional type 'AnyObject?'}} |
| // expected-note@-1 {{remove '!' to make the parameter required}} {{34-35=}} |
| // expected-note@-2 {{add parentheses to silence this warning}} {{25-25=(}} {{35-35=)}} |
| |
| override func oneC(_: AnyObject!) {} // expected-warning {{overriding instance method parameter of type 'AnyObject' with implicitly unwrapped optional type 'AnyObject?'}} |
| // expected-note@-1 {{remove '!' to make the parameter required}} {{34-35=}} |
| // expected-note@-2 {{add parentheses to silence this warning}} {{25-25=(}} {{35-35=)}} |
| |
| } |
| |
| class IUOTestSubclassOkay : IUOTestBaseClass { |
| override func oneA(_: AnyObject?) {} |
| override func oneC(_ x: AnyObject) {} |
| } |
| |
| class GenericBase<T> {} |
| class ConcreteDerived: GenericBase<Int> {} |
| |
| class OverriddenWithConcreteDerived<T> { |
| func foo() -> GenericBase<T> {} // expected-note{{potential overridden instance method 'foo()' here}} |
| } |
| class OverridesWithMismatchedConcreteDerived<T>: |
| OverriddenWithConcreteDerived<T> { |
| override func foo() -> ConcreteDerived {} //expected-error{{does not override}} |
| } |
| class OverridesWithConcreteDerived: |
| OverriddenWithConcreteDerived<Int> { |
| override func foo() -> ConcreteDerived {} |
| } |
| |
| |
| // <rdar://problem/24646184> |
| class Ty {} |
| class SubTy : Ty {} |
| class Base24646184 { |
| init(_: SubTy) { } |
| func foo(_: SubTy) { } |
| |
| init(ok: Ty) { } |
| init(ok: SubTy) { } |
| func foo(ok: Ty) { } |
| func foo(ok: SubTy) { } |
| } |
| class Derived24646184 : Base24646184 { |
| override init(_: Ty) { } // expected-note {{'init(_:)' previously overridden here}} |
| override init(_: SubTy) { } // expected-error {{'init(_:)' has already been overridden}} |
| override func foo(_: Ty) { } // expected-note {{'foo' previously overridden here}} |
| override func foo(_: SubTy) { } // expected-error {{'foo' has already been overridden}} |
| |
| override init(ok: Ty) { } |
| override init(ok: SubTy) { } |
| override func foo(ok: Ty) { } |
| override func foo(ok: SubTy) { } |
| } |
| |
| |
| // Subscripts |
| |
| class SubscriptBase { |
| subscript(a a: Int) -> Int { return a } |
| } |
| |
| class SubscriptDerived : SubscriptBase { |
| override subscript(a: Int) -> Int { return a } |
| // expected-error@-1 {{argument labels for method 'subscript(_:)' do not match those of overridden method 'subscript(a:)'}} |
| } |
| |
| // Generic subscripts |
| |
| class GenericSubscriptBase { |
| var dict: [AnyHashable : Any] = [:] |
| |
| subscript<T : Hashable, U>(t: T) -> U { |
| get { |
| return dict[t] as! U |
| } |
| set { |
| dict[t] = newValue |
| } |
| } |
| } |
| |
| class GenericSubscriptDerived : GenericSubscriptBase { |
| override subscript<K : Hashable, V>(t: K) -> V { |
| get { |
| return super[t] |
| } |
| set { |
| super[t] = newValue |
| } |
| } |
| } |
| |
| |
| // @escaping |
| class CallbackBase { |
| func perform(handler: @escaping () -> Void) {} // expected-note * {{here}} |
| func perform(optHandler: (() -> Void)?) {} // expected-note * {{here}} |
| func perform(nonescapingHandler: () -> Void) {} // expected-note * {{here}} |
| } |
| class CallbackSubA: CallbackBase { |
| override func perform(handler: () -> Void) {} // expected-error {{method does not override any method from its superclass}} |
| // expected-note@-1 {{type does not match superclass instance method with type '(@escaping () -> Void) -> ()'}} |
| override func perform(optHandler: () -> Void) {} // expected-error {{method does not override any method from its superclass}} |
| override func perform(nonescapingHandler: () -> Void) {} |
| } |
| class CallbackSubB : CallbackBase { |
| override func perform(handler: (() -> Void)?) {} |
| override func perform(optHandler: (() -> Void)?) {} |
| override func perform(nonescapingHandler: (() -> Void)?) {} // expected-error {{method does not override any method from its superclass}} |
| } |
| class CallbackSubC : CallbackBase { |
| override func perform(handler: @escaping () -> Void) {} |
| override func perform(optHandler: @escaping () -> Void) {} // expected-error {{cannot override instance method parameter of type '(() -> Void)?' with non-optional type '() -> Void'}} |
| override func perform(nonescapingHandler: @escaping () -> Void) {} // expected-error {{method does not override any method from its superclass}} |
| } |
| |
| // inout, varargs |
| class HasFlagsBase { |
| func modify(x: inout B) {} // expected-note 2{{potential overridden instance method 'modify(x:)' here}} |
| func tweak(x: inout A) {} // expected-note 2{{potential overridden instance method 'tweak(x:)' here}} |
| func collect(x: B...) {} // expected-note 2{{potential overridden instance method 'collect(x:)' here}} |
| } |
| |
| class HasFlagsDerivedGood : HasFlagsBase { |
| override func modify(x: inout B) {} |
| override func tweak(x: inout A) {} |
| override func collect(x: B...) {} |
| } |
| |
| class HasFlagsDerivedBad1 : HasFlagsBase { |
| override func modify(x: inout A) {} // expected-error {{method does not override any method from its superclass}} |
| override func tweak(x: inout B) {} // expected-error {{method does not override any method from its superclass}} |
| override func collect(x: A...) {} // expected-error {{method does not override any method from its superclass}} |
| } |
| |
| class HasFlagsDerivedBad2 : HasFlagsBase { |
| override func modify(x: B) {} // expected-error {{method does not override any method from its superclass}} |
| override func tweak(x: A) {} // expected-error {{method does not override any method from its superclass}} |
| override func collect(x: [B]) {} // expected-error {{method does not override any method from its superclass}} |
| } |
| |
| // Issues with overrides of internal(set) and fileprivate(set) members |
| public class BaseWithInternalSetter { |
| public internal(set) var someValue: Int = 0 |
| } |
| |
| public class DerivedWithInternalSetter: BaseWithInternalSetter { |
| override public internal(set) var someValue: Int { |
| get { return 0 } |
| set { } |
| } |
| } |
| |
| class BaseWithFilePrivateSetter { |
| fileprivate(set) var someValue: Int = 0 |
| } |
| |
| class DerivedWithFilePrivateSetter: BaseWithFilePrivateSetter { |
| override fileprivate(set) var someValue: Int { |
| get { return 0 } |
| set { } |
| } |
| } |
| |
| open class OpenBase { |
| open func instanceMethod() {} |
| open class func classMethod() {} |
| } |
| |
| public class PublicDerived : OpenBase { |
| override public func instanceMethod() {} |
| override public class func classMethod() {} |
| } |
| |
| open class OpenDerived : OpenBase { |
| override open func instanceMethod() {} |
| override open class func classMethod() {} |
| } |
| |
| open class OpenDerivedPublic : OpenBase { |
| override public func instanceMethod() {} // Ok |
| override public class func classMethod() {} // Ok |
| } |
| |
| open class OpenDerivedFinal : OpenBase { |
| override public final func instanceMethod() {} |
| override public class final func classMethod() {} |
| } |
| |
| open class OpenDerivedStatic : OpenBase { |
| override public static func classMethod() {} |
| } |
