attr_override.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(){}

classMixedKeywordsAndAttributes{ // 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(){}
}

classDuplicateOverrideBase{
func f1(){}
classfunc cf1(){}
classfunc cf2(){}
classfunc cf3(){}
classfunc cf4(){}
}
classDuplicateOverrideDerived:DuplicateOverrideBase{
overrideoverridefunc f1(){} // expected-error {{duplicate modifier}} expected-note {{modifier already specified here}}
overrideoverrideclassfunc cf1(){} // expected-error {{duplicate modifier}} expected-note {{modifier already specified here}}
overrideclassoverridefunc cf2(){} // expected-error {{duplicate modifier}} expected-note {{modifier already specified here}}
classoverrideoverridefunc cf3(){} // expected-error {{duplicate modifier}} expected-note {{modifier already specified here}}
overrideclassoverridefunc cf4(){} // expected-error {{duplicate modifier}} expected-note {{modifier already specified here}}
}

classA{
func f0(){}
func f1(){} // expected-note{{overridden declaration is here}}

varv1:Int{return5}
varv2:Int{return5} // expected-note{{overridden declaration is here}}
varv4:String{return"hello"}// expected-note{{attempt to override property here}}
varv5:A{returnself}
varv6:A{returnself}
varv7:A{ // expected-note{{attempt to override property here}}
get{returnself}
set{}
}
varv8:Int=0 // expected-note {{attempt to override property here}}
varv9:Int{return5} // expected-note{{attempt to override property here}}
varv10:Int{return5} // 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{returnself}
}

 subscript (i:Int16)->A{ // expected-note{{attempt to override subscript here}} expected-note{{potential overridden subscript 'subscript(_:)' here}}
get{returnself}
set{}
}

func overriddenInExtension(){} // expected-note {{overri}}
}

classB:A{
overridefunc f0(){}
func f1(){} // expected-error{{overriding declaration requires an 'override' keyword}}{{3-3=override }}
overridefunc f2(){} // expected-error{{method does not override any method from its superclass}}

overridevarv1:Int{return5}
varv2:Int{return5} // expected-error{{overriding declaration requires an 'override' keyword}}
overridevarv3:Int{return5} // expected-error{{property does not override any property from its superclass}}
overridevarv4:Int{return5} // expected-error{{property 'v4' with type 'Int' cannot override a property with type 'String'}}

 // Covariance
overridevarv5:B{returnself}
overridevarv6:B{
get{returnself}
set{}
}

overridevarv7:B{ // expected-error{{cannot override mutable property 'v7' of type 'A' with covariant type 'B'}}
get{returnself}
set{}
}

 // Stored properties
overridevarv8:Int{return5} // expected-error {{cannot override mutable property with read-only property 'v8'}}
overridevarv9:Int // expected-error{{cannot override with a stored property 'v9'}}
 lazy overridevarv10: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{returnself}
}

override subscript (i:Int16)->B{ // expected-error{{cannot override mutable subscript of type '(Int16) -> B' with covariant type '(Int16) -> A'}}
get{returnself}
set{}
}

overrideinit(){}
overridedeinit{} // expected-error{{'override' modifier cannot be applied to this declaration}} {{3-12=}}
overridetypealiasInner=Int // expected-error{{'override' modifier cannot be applied to this declaration}} {{3-12=}}
}

extensionB{
overridefunc overriddenInExtension(){} // expected-error{{overri}}
}

structS{
overridefunc f(){} // expected-error{{'override' can only be specified on class members}} {{3-12=}}
}
extensionS{
overridefunc ef(){} // expected-error{{'override' can only be specified on class members}} {{3-12=}}
}

enumE{
overridefunc f(){} // expected-error{{'override' can only be specified on class members}} {{3-12=}}
}

protocolP{
overridefunc f() // expected-error{{method does not override any method from its parent protocol}}
}

overridefunc f(){} // expected-error{{'override' can only be specified on class members}} {{1-10=}}

// Invalid 'override' on declarations inside closures.
varrdar16654075a={
override func foo(){} // expected-error{{'override' can only be specified on class members}} {{3-12=}}
}
varrdar16654075b={
classA{
overridefunc foo(){} // expected-error{{method does not override any method from its superclass}}
}
}
varrdar16654075c={()->()in
 override func foo(){} // expected-error {{'override' can only be specified on class members}} {{3-12=}}
()
}
varrdar16654075d={()->()in
classA{
overridefunc foo(){} // expected-error {{method does not override any method from its superclass}}
}
A().foo()
}
varrdar16654075e={()->()in
classA{
func foo(){}
}
classB:A{
overridefunc foo(){}
}
A().foo()
}

classC{
init(string:String){} // expected-note{{overridden declaration is here}}
requiredinit(double:Double){} // expected-note 3{{overridden required initializer is here}}

convenienceinit(){self.init(string:"hello")} // expected-note{{attempt to override convenience initializer here}}
}

classD1:C{
overrideinit(string:String){ super.init(string: string)}
requiredinit(double:Double){}
convenienceinit(){self.init(string:"hello")}
}

classD2: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.
requiredoverrideinit(double:Double){} // expected-warning{{'override' is implied when overriding a required initializer}} {{12-21=}}
overrideconvenienceinit(){self.init(string:"hello")} // expected-error{{initializer does not override a designated initializer from its superclass}}
}

classD3:C{
overrideinit(string:String){ super.init(string: string)}
overrideinit(double:Double){} // expected-error{{use the 'required' modifier to override a required initializer}}{{3-11=required}}
}

classD4:C{
 // "required override" only when we're overriding a non-required
 // designated initializer with a required initializer.
requiredoverrideinit(string:String){ super.init(string: string)}
requiredinit(double:Double){}
}

classD5:C{
 // "required override" only when we're overriding a non-required
 // designated initializer with a required initializer.
requiredconvenienceoverrideinit(string:String){self.init(double:5.0)}
requiredinit(double:Double){}
}

classD6:C{
init(double:Double){} // expected-error{{'required' modifier must be present on all overrides of a required initializer}} {{3-3=required }}
}

// rdar://problem/18232867
classC_empty_tuple{
init(){}
}

classD_empty_tuple:C_empty_tuple{
overrideinit(foo:()){} // expected-error{{initializer does not override a designated initializer from its superclass}}
}

classC_with_let{
letx=42 // expected-note {{attempt to override property here}}
}

classD_with_let:C_with_let{
overridevarx:Int{get{return4}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
classC21311590{
overrideinit(){} // expected-error {{initializer does not override a designated initializer from its superclass}}
}
classB21311590:C21311590{}
_ =C21311590()
_ =B21311590()


classMismatchOptionalBase{
func param(_:Int?){}
func paramIUO(_:Int!){}
func result()->Int{return0}

func fixSeveralTypes(a:Int?, b:Int!)->Int{return0}

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}}

varprop:Int=0 // expected-note {{attempt to override property here}}
varoptProp:Int? // expected-note {{attempt to override property here}}

vargetProp:Int{return0} // expected-note {{attempt to override property here}}
vargetOptProp:Int?{returnnil}

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{return0}
set{}
}

 subscript(get a:Int?)->Void{
return()
}
 subscript(get b:Void)->Int{
return0
}

 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()
}
}

protocolP1{}
protocolP2{}

classMismatchOptional:MismatchOptionalBase{
overridefunc param(_:Int){} // expected-error {{cannot override instance method parameter of type 'Int?' with non-optional type 'Int'}} {{29-29=?}}
overridefunc paramIUO(_:Int){} // expected-error {{cannot override instance method parameter of type 'Int?' with non-optional type 'Int'}} {{32-32=?}}
overridefunc result()->Int?{returnnil} // expected-error {{cannot override instance method result type 'Int' with optional type 'Int?'}} {{32-33=}}

overridefunc fixSeveralTypes(a:Int, b:Int)->Int!{returnnil}
 // 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=}}

overridefunc 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=)?}}
overridefunc tupleParam(x:(Int,Int)){} // expected-error {{cannot override instance method parameter of type '(Int, Int)?' with non-optional type '(Int, Int)'}} {{41-41=?}}
overridefunc 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=)?}}

overridefunc 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=?}}

overridefunc ambiguousOverride(a:Int?, b:Int?){} // expected-error {{declaration 'ambiguousOverride(a:b:)' cannot override more than one superclass declaration}} {{none}}
overridefunc ambiguousOverride(a:Int, b:Int){} // expected-error {{method does not override any method from its superclass}} {{none}}

overridevarprop:Int?{ // expected-error {{property 'prop' with type 'Int?' cannot override a property with type 'Int'}} {{none}}
get{returnnil}
set{}
}
overridevaroptProp:Int{ // expected-error {{cannot override mutable property 'optProp' of type 'Int?' with covariant type 'Int'}} {{none}}
get{return0}
set{}
}
overridevargetProp:Int?{returnnil} // expected-error {{property 'getProp' with type 'Int?' cannot override a property with type 'Int'}} {{none}}
overridevargetOptProp:Int{return0} // okay

overrideinit(param:Int){} // expected-error {{cannot override initializer parameter of type 'Int?' with non-optional type 'Int'}}
overrideinit?(){} // 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{returnnil}
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=}}
returnnil
}

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()
}
}

classMismatchOptional2:MismatchOptionalBase{
overridefunc result()->Int!{returnnil} // 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}}
}

classMismatchOptional3:MismatchOptionalBase{
overridefunc result()->Optional<Int>{returnnil} // 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
classGenericBase<T>{
func doStuff<U>(t:T, u:U){}
init<U>(t:T, u:U){}
}

classConcreteSub:GenericBase<Int>{
overridefunc doStuff<U>(t:Int, u:U){}
overrideinit<U>(t:Int, u:U){}
}

classConcreteBase{
init<U>(t:Int, u:U){}
func doStuff<U>(t:Int, u:U){}

}

classGenericSub<T>:ConcreteBase{
overrideinit<U>(t:Int, u:U){}
overridefunc doStuff<U>(t:Int, u:U){}
}

// Issue with generic parameter index
classMoreGenericSub1<T, TT>:GenericBase<T>{
overridefunc doStuff<U>(t:T, u:U){}
}

classMoreGenericSub2<TT, T>:GenericBase<T>{
overridefunc doStuff<U>(t:T, u:U){}
}

// Issue with insufficient canonicalization when
// comparing types
protocolSI{}
protocolCI{}

protocolSequence{
associatedtypeI:SI // expected-note{{declared here}}
}

protocolCollection:Sequence{
associatedtypeI:CI // expected-warning{{redeclaration of associated type 'I'}}
}

classIndex<F, T>{
func map(_ f:F)->T{}
}

classCollectionIndex<C :Collection>:Index<C,C.I>{
overridefunc map(_ f:C)->C.I{}
}