mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
442 lines
17 KiB
Swift
442 lines
17 KiB
Swift
// RUN: %target-typecheck-verify-swift -swift-version 4
|
|
|
|
@override // expected-error {{'override' can only be specified on class members}} {{1-11=}} expected-error {{'override' is a declaration modifier, not an attribute}} {{1-2=}}
|
|
func virtualAttributeCanNotBeUsedInSource() {}
|
|
|
|
class MixedKeywordsAndAttributes { // expected-note {{in declaration of 'MixedKeywordsAndAttributes'}}
|
|
// expected-error@+1 {{expected declaration}} expected-error@+1 {{consecutive declarations on a line must be separated by ';'}} {{11-11=;}}
|
|
override @inline(never) func f1() {}
|
|
}
|
|
|
|
class DuplicateOverrideBase {
|
|
func f1() {}
|
|
class func cf1() {}
|
|
class func cf2() {}
|
|
class func cf3() {}
|
|
class func cf4() {}
|
|
}
|
|
class DuplicateOverrideDerived : DuplicateOverrideBase {
|
|
override override func f1() {} // expected-error {{duplicate modifier}} expected-note {{modifier already specified here}}
|
|
override override class func cf1() {} // expected-error {{duplicate modifier}} expected-note {{modifier already specified here}}
|
|
override class override func cf2() {} // expected-error {{duplicate modifier}} expected-note {{modifier already specified here}}
|
|
class override override func cf3() {} // expected-error {{duplicate modifier}} expected-note {{modifier already specified here}}
|
|
override class override func cf4() {} // expected-error {{duplicate modifier}} expected-note {{modifier already specified here}}
|
|
}
|
|
|
|
class A {
|
|
func f0() { }
|
|
func f1() { } // expected-note{{overridden declaration is here}}
|
|
|
|
var v1: Int { return 5 }
|
|
var v2: Int { return 5 } // expected-note{{overridden declaration is here}}
|
|
var v4: String { return "hello" }// expected-note{{attempt to override property here}}
|
|
var v5: A { return self }
|
|
var v6: A { return self }
|
|
var v7: A { // expected-note{{attempt to override property here}}
|
|
get { return self }
|
|
set { }
|
|
}
|
|
var v8: Int = 0 // expected-note {{attempt to override property here}}
|
|
var v9: Int { return 5 } // expected-note{{attempt to override property here}}
|
|
var v10: Int { return 5 } // expected-note{{attempt to override property here}}
|
|
|
|
subscript (i: Int) -> String { // expected-note{{potential overridden subscript 'subscript(_:)' here}}
|
|
get {
|
|
return "hello"
|
|
}
|
|
|
|
set {
|
|
}
|
|
}
|
|
|
|
subscript (d: Double) -> String { // expected-note{{overridden declaration is here}} expected-note{{potential overridden subscript 'subscript(_:)' here}}
|
|
get {
|
|
return "hello"
|
|
}
|
|
|
|
set {
|
|
}
|
|
}
|
|
|
|
subscript (i: Int8) -> A { // expected-note{{potential overridden subscript 'subscript(_:)' here}}
|
|
get { return self }
|
|
}
|
|
|
|
subscript (i: Int16) -> A { // expected-note{{attempt to override subscript here}} expected-note{{potential overridden subscript 'subscript(_:)' here}}
|
|
get { return self }
|
|
set { }
|
|
}
|
|
|
|
func overriddenInExtension() {} // expected-note {{overri}}
|
|
}
|
|
|
|
class B : A {
|
|
override func f0() { }
|
|
func f1() { } // expected-error{{overriding declaration requires an 'override' keyword}}{{3-3=override }}
|
|
override func f2() { } // expected-error{{method does not override any method from its superclass}}
|
|
|
|
override var v1: Int { return 5 }
|
|
var v2: Int { return 5 } // expected-error{{overriding declaration requires an 'override' keyword}}
|
|
override var v3: Int { return 5 } // expected-error{{property does not override any property from its superclass}}
|
|
override var v4: Int { return 5 } // expected-error{{property 'v4' with type 'Int' cannot override a property with type 'String'}}
|
|
|
|
// Covariance
|
|
override var v5: B { return self }
|
|
override var v6: B {
|
|
get { return self }
|
|
set { }
|
|
}
|
|
|
|
override var v7: B { // expected-error{{cannot override mutable property 'v7' of type 'A' with covariant type 'B'}}
|
|
get { return self }
|
|
set { }
|
|
}
|
|
|
|
// Stored properties
|
|
override var v8: Int { return 5 } // expected-error {{cannot override mutable property with read-only property 'v8'}}
|
|
override var v9: Int // expected-error{{cannot override with a stored property 'v9'}}
|
|
lazy override var v10: Int = 5 // expected-warning{{cannot override with a stored property 'v10'}}
|
|
|
|
override subscript (i: Int) -> String {
|
|
get {
|
|
return "hello"
|
|
}
|
|
|
|
set {
|
|
}
|
|
}
|
|
|
|
subscript (d: Double) -> String { // expected-error{{overriding declaration requires an 'override' keyword}} {{3-3=override }}
|
|
get {
|
|
return "hello"
|
|
}
|
|
|
|
set {
|
|
}
|
|
}
|
|
|
|
override subscript (f: Float) -> String { // expected-error{{subscript does not override any subscript from its superclass}}
|
|
get {
|
|
return "hello"
|
|
}
|
|
|
|
set {
|
|
}
|
|
}
|
|
|
|
// Covariant
|
|
override subscript (i: Int8) -> B {
|
|
get { return self }
|
|
}
|
|
|
|
override subscript (i: Int16) -> B { // expected-error{{cannot override mutable subscript of type '(Int16) -> B' with covariant type '(Int16) -> A'}}
|
|
get { return self }
|
|
set { }
|
|
}
|
|
|
|
override init() { }
|
|
override deinit { } // expected-error{{'override' modifier cannot be applied to this declaration}} {{3-12=}}
|
|
override typealias Inner = Int // expected-error{{'override' modifier cannot be applied to this declaration}} {{3-12=}}
|
|
}
|
|
|
|
extension B {
|
|
override func overriddenInExtension() {} // expected-error{{overri}}
|
|
}
|
|
|
|
struct S {
|
|
override func f() { } // expected-error{{'override' can only be specified on class members}} {{3-12=}}
|
|
}
|
|
extension S {
|
|
override func ef() {} // expected-error{{'override' can only be specified on class members}} {{3-12=}}
|
|
}
|
|
|
|
enum E {
|
|
override func f() { } // expected-error{{'override' can only be specified on class members}} {{3-12=}}
|
|
}
|
|
|
|
protocol P {
|
|
override func f() // expected-error{{method does not override any method from its parent protocol}}
|
|
}
|
|
|
|
override func f() { } // expected-error{{'override' can only be specified on class members}} {{1-10=}}
|
|
|
|
// Invalid 'override' on declarations inside closures.
|
|
var rdar16654075a = {
|
|
override func foo() {} // expected-error{{'override' can only be specified on class members}} {{3-12=}}
|
|
}
|
|
var rdar16654075b = {
|
|
class A {
|
|
override func foo() {} // expected-error{{method does not override any method from its superclass}}
|
|
}
|
|
}
|
|
var rdar16654075c = { () -> () in
|
|
override func foo() {} // expected-error {{'override' can only be specified on class members}} {{3-12=}}
|
|
()
|
|
}
|
|
var rdar16654075d = { () -> () in
|
|
class A {
|
|
override func foo() {} // expected-error {{method does not override any method from its superclass}}
|
|
}
|
|
A().foo()
|
|
}
|
|
var rdar16654075e = { () -> () in
|
|
class A {
|
|
func foo() {}
|
|
}
|
|
class B : A {
|
|
override func foo() {}
|
|
}
|
|
A().foo()
|
|
}
|
|
|
|
class C {
|
|
init(string: String) { } // expected-note{{overridden declaration is here}}
|
|
required init(double: Double) { } // expected-note 3{{overridden required initializer is here}}
|
|
|
|
convenience init() { self.init(string: "hello") } // expected-note{{attempt to override convenience initializer here}}
|
|
}
|
|
|
|
class D1 : C {
|
|
override init(string: String) { super.init(string: string) }
|
|
required init(double: Double) { }
|
|
convenience init() { self.init(string: "hello") }
|
|
}
|
|
|
|
class D2 : C {
|
|
init(string: String) { super.init(string: string) } // expected-error{{overriding declaration requires an 'override' keyword}}{{3-3=override }}
|
|
|
|
// FIXME: Would like to remove the space after 'override' as well.
|
|
required override init(double: Double) { } // expected-warning{{'override' is implied when overriding a required initializer}} {{12-21=}}
|
|
override convenience init() { self.init(string: "hello") } // expected-error{{initializer does not override a designated initializer from its superclass}}
|
|
}
|
|
|
|
class D3 : C {
|
|
override init(string: String) { super.init(string: string) }
|
|
override init(double: Double) { } // expected-error{{use the 'required' modifier to override a required initializer}}{{3-11=required}}
|
|
}
|
|
|
|
class D4 : C {
|
|
// "required override" only when we're overriding a non-required
|
|
// designated initializer with a required initializer.
|
|
required override init(string: String) { super.init(string: string) }
|
|
required init(double: Double) { }
|
|
}
|
|
|
|
class D5 : C {
|
|
// "required override" only when we're overriding a non-required
|
|
// designated initializer with a required initializer.
|
|
required convenience override init(string: String) { self.init(double: 5.0) }
|
|
required init(double: Double) { }
|
|
}
|
|
|
|
class D6 : C {
|
|
init(double: Double) { } // expected-error{{'required' modifier must be present on all overrides of a required initializer}} {{3-3=required }}
|
|
}
|
|
|
|
// rdar://problem/18232867
|
|
class C_empty_tuple {
|
|
init() { }
|
|
}
|
|
|
|
class D_empty_tuple : C_empty_tuple {
|
|
override init(foo:()) { } // expected-error{{initializer does not override a designated initializer from its superclass}}
|
|
}
|
|
|
|
class C_with_let {
|
|
let x = 42 // expected-note {{attempt to override property here}}
|
|
}
|
|
|
|
class D_with_let : C_with_let {
|
|
override var x : Int { get { return 4 } set {} } // expected-error {{cannot override immutable 'let' property 'x' with the getter of a 'var'}}
|
|
}
|
|
|
|
|
|
// <rdar://problem/21311590> QoI: Inconsistent diagnostics when no constructor is available
|
|
class C21311590 {
|
|
override init() {} // expected-error {{initializer does not override a designated initializer from its superclass}}
|
|
}
|
|
class B21311590 : C21311590 {}
|
|
_ = C21311590()
|
|
_ = B21311590()
|
|
|
|
|
|
class MismatchOptionalBase {
|
|
func param(_: Int?) {}
|
|
func paramIUO(_: Int!) {}
|
|
func result() -> Int { return 0 }
|
|
|
|
func fixSeveralTypes(a: Int?, b: Int!) -> Int { return 0 }
|
|
|
|
func functionParam(x: ((Int) -> Int)?) {}
|
|
func tupleParam(x: (Int, Int)?) {}
|
|
func compositionParam(x: (P1 & P2)?) {}
|
|
|
|
func nameAndTypeMismatch(label: Int?) {}
|
|
|
|
func ambiguousOverride(a: Int, b: Int?) {} // expected-note 2 {{overridden declaration is here}} expected-note {{potential overridden instance method 'ambiguousOverride(a:b:)' here}}
|
|
func ambiguousOverride(a: Int?, b: Int) {} // expected-note 2 {{overridden declaration is here}} expected-note {{potential overridden instance method 'ambiguousOverride(a:b:)' here}}
|
|
|
|
var prop: Int = 0 // expected-note {{attempt to override property here}}
|
|
var optProp: Int? // expected-note {{attempt to override property here}}
|
|
|
|
var getProp: Int { return 0 } // expected-note {{attempt to override property here}}
|
|
var getOptProp: Int? { return nil }
|
|
|
|
init(param: Int?) {}
|
|
init() {} // expected-note {{non-failable initializer 'init()' overridden here}}
|
|
|
|
subscript(a: Int?) -> Void { // expected-note {{attempt to override subscript here}}
|
|
get { return () }
|
|
set {}
|
|
}
|
|
subscript(b: Void) -> Int { // expected-note {{attempt to override subscript here}}
|
|
get { return 0 }
|
|
set {}
|
|
}
|
|
|
|
subscript(get a: Int?) -> Void {
|
|
return ()
|
|
}
|
|
subscript(get b: Void) -> Int {
|
|
return 0
|
|
}
|
|
|
|
subscript(ambiguous a: Int, b: Int?) -> Void { // expected-note {{overridden declaration is here}} expected-note {{potential overridden subscript 'subscript(ambiguous:_:)' here}}
|
|
return ()
|
|
}
|
|
subscript(ambiguous a: Int?, b: Int) -> Void { // expected-note {{overridden declaration is here}} expected-note {{potential overridden subscript 'subscript(ambiguous:_:)' here}}
|
|
return ()
|
|
}
|
|
}
|
|
|
|
protocol P1 {}
|
|
protocol P2 {}
|
|
|
|
class MismatchOptional : MismatchOptionalBase {
|
|
override func param(_: Int) {} // expected-error {{cannot override instance method parameter of type 'Int?' with non-optional type 'Int'}} {{29-29=?}}
|
|
override func paramIUO(_: Int) {} // expected-error {{cannot override instance method parameter of type 'Int?' with non-optional type 'Int'}} {{32-32=?}}
|
|
override func result() -> Int? { return nil } // expected-error {{cannot override instance method result type 'Int' with optional type 'Int?'}} {{32-33=}}
|
|
|
|
override func fixSeveralTypes(a: Int, b: Int) -> Int! { return nil }
|
|
// expected-error@-1 {{cannot override instance method parameter of type 'Int?' with non-optional type 'Int'}} {{39-39=?}}
|
|
// expected-error@-2 {{cannot override instance method parameter of type 'Int?' with non-optional type 'Int'}} {{47-47=?}}
|
|
// expected-error@-3 {{cannot override instance method result type 'Int' with optional type 'Int?'}} {{55-56=}}
|
|
|
|
override func functionParam(x: @escaping (Int) -> Int) {} // expected-error {{cannot override instance method parameter of type '((Int) -> Int)?' with non-optional type '(Int) -> Int'}} {{34-34=(}} {{56-56=)?}}
|
|
override func tupleParam(x: (Int, Int)) {} // expected-error {{cannot override instance method parameter of type '(Int, Int)?' with non-optional type '(Int, Int)'}} {{41-41=?}}
|
|
override func compositionParam(x: P1 & P2) {} // expected-error {{cannot override instance method parameter of type '(any P1 & P2)?' with non-optional type 'any P1 & P2'}} {{37-37=(}} {{44-44=)?}}
|
|
|
|
override func nameAndTypeMismatch(_: Int) {}
|
|
// expected-error@-1 {{argument labels for method 'nameAndTypeMismatch' do not match those of overridden method 'nameAndTypeMismatch(label:)'}} {{37-37=label }}
|
|
// expected-error@-2 {{cannot override instance method parameter of type 'Int?' with non-optional type 'Int'}} {{43-43=?}}
|
|
|
|
override func ambiguousOverride(a: Int?, b: Int?) {} // expected-error {{declaration 'ambiguousOverride(a:b:)' cannot override more than one superclass declaration}} {{none}}
|
|
override func ambiguousOverride(a: Int, b: Int) {} // expected-error {{method does not override any method from its superclass}} {{none}}
|
|
|
|
override var prop: Int? { // expected-error {{property 'prop' with type 'Int?' cannot override a property with type 'Int'}} {{none}}
|
|
get { return nil }
|
|
set {}
|
|
}
|
|
override var optProp: Int { // expected-error {{cannot override mutable property 'optProp' of type 'Int?' with covariant type 'Int'}} {{none}}
|
|
get { return 0 }
|
|
set {}
|
|
}
|
|
override var getProp: Int? { return nil } // expected-error {{property 'getProp' with type 'Int?' cannot override a property with type 'Int'}} {{none}}
|
|
override var getOptProp: Int { return 0 } // okay
|
|
|
|
override init(param: Int) {} // expected-error {{cannot override initializer parameter of type 'Int?' with non-optional type 'Int'}}
|
|
override init?() {} // expected-error {{failable initializer 'init()' cannot override a non-failable initializer}} {{none}}
|
|
|
|
override subscript(a: Int) -> Void { // expected-error {{cannot override mutable subscript of type '(Int) -> Void' with covariant type '(Int?) -> Void'}}
|
|
get { return () }
|
|
set {}
|
|
}
|
|
override subscript(b: Void) -> Int? { // expected-error {{cannot override mutable subscript of type '(Void) -> Int?' with covariant type '(Void) -> Int'}}
|
|
get { return nil }
|
|
set {}
|
|
}
|
|
|
|
override subscript(get a: Int) -> Void { // expected-error {{cannot override subscript index of type 'Int?' with non-optional type 'Int'}} {{32-32=?}}
|
|
return ()
|
|
}
|
|
override subscript(get b: Void) -> Int? { // expected-error {{cannot override subscript element type 'Int' with optional type 'Int?'}} {{41-42=}}
|
|
return nil
|
|
}
|
|
|
|
override subscript(ambiguous a: Int?, b: Int?) -> Void { // expected-error {{declaration 'subscript(ambiguous:_:)' cannot override more than one superclass declaration}}
|
|
return ()
|
|
}
|
|
override subscript(ambiguous a: Int, b: Int) -> Void { // expected-error {{subscript does not override any subscript from its superclass}}
|
|
return ()
|
|
}
|
|
}
|
|
|
|
class MismatchOptional2 : MismatchOptionalBase {
|
|
override func result() -> Int! { return nil } // expected-error {{cannot override instance method result type 'Int' with optional type 'Int?'}} {{32-33=}}
|
|
|
|
// None of these are overrides because we didn't say 'override'. Since they're
|
|
// not exact matches, they shouldn't result in errors.
|
|
func param(_: Int) {}
|
|
func ambiguousOverride(a: Int, b: Int) {}
|
|
|
|
// This is covariant, so we still assume it's meant to override.
|
|
func ambiguousOverride(a: Int?, b: Int?) {} // expected-error {{declaration 'ambiguousOverride(a:b:)' cannot override more than one superclass declaration}}
|
|
}
|
|
|
|
class MismatchOptional3 : MismatchOptionalBase {
|
|
override func result() -> Optional<Int> { return nil } // expected-error {{cannot override instance method result type 'Int' with optional type 'Optional<Int>'}} {{none}}
|
|
}
|
|
|
|
// Make sure we remap the method's innermost generic parameters
|
|
// to the correct depth
|
|
class GenericBase<T> {
|
|
func doStuff<U>(t: T, u: U) {}
|
|
init<U>(t: T, u: U) {}
|
|
}
|
|
|
|
class ConcreteSub : GenericBase<Int> {
|
|
override func doStuff<U>(t: Int, u: U) {}
|
|
override init<U>(t: Int, u: U) {}
|
|
}
|
|
|
|
class ConcreteBase {
|
|
init<U>(t: Int, u: U) {}
|
|
func doStuff<U>(t: Int, u: U) {}
|
|
|
|
}
|
|
|
|
class GenericSub<T> : ConcreteBase {
|
|
override init<U>(t: Int, u: U) {}
|
|
override func doStuff<U>(t: Int, u: U) {}
|
|
}
|
|
|
|
// Issue with generic parameter index
|
|
class MoreGenericSub1<T, TT> : GenericBase<T> {
|
|
override func doStuff<U>(t: T, u: U) {}
|
|
}
|
|
|
|
class MoreGenericSub2<TT, T> : GenericBase<T> {
|
|
override func doStuff<U>(t: T, u: U) {}
|
|
}
|
|
|
|
// Issue with insufficient canonicalization when
|
|
// comparing types
|
|
protocol SI {}
|
|
protocol CI {}
|
|
|
|
protocol Sequence {
|
|
associatedtype I : SI // expected-note{{declared here}}
|
|
}
|
|
|
|
protocol Collection : Sequence {
|
|
associatedtype I : CI // expected-warning{{redeclaration of associated type 'I'}}
|
|
}
|
|
|
|
class Index<F, T> {
|
|
func map(_ f: F) -> T {}
|
|
}
|
|
|
|
class CollectionIndex<C : Collection> : Index<C, C.I> {
|
|
override func map(_ f: C) -> C.I {}
|
|
}
|