self.swift

// RUN: %target-typecheck-verify-swift -swift-version 5

structS0<T>{
func foo(_ other:Self){}
}

classC0<T>{
func foo(_ other:Self){} // expected-error{{covariant 'Self' or 'Self?' can only appear as the type of a property, subscript or method result; did you mean 'C0'?}}
}

enumE0<T>{
func foo(_ other:Self){}
}

// rdar://problem/21745221
structX{
typealiasT=Int
}

extensionX{
structInner{
}
}

extensionX.Inner{
func foo(_ other:Self){}
}

// https://github.com/apple/swift/issues/43310
classMario{
func getFriend()->Self{returnself} // expected-note{{overridden declaration is here}}
func getEnemy()->Mario{returnself}
}
classSuperMario:Mario{
overridefunc getFriend()->SuperMario{ // expected-error{{cannot override a Self return type with a non-Self return type}}
returnSuperMario()
}
overridefunc getEnemy()->Self{returnself}
}
finalclassFinalMario:Mario{
overridefunc getFriend()->FinalMario{
returnFinalMario()
}
}

// These references to Self are now possible (SE-0068)

classA<T>{
typealias_Self=Self
 // expected-error@-1 {{covariant 'Self' or 'Self?' can only appear as the type of a property, subscript or method result; did you mean 'A'?}}
letb:Int
requiredinit(a:Int){
print("\(Self.self).\(#function)")
Self.y()
 b = a
}
staticfunc z(n:Self?=nil){
 // expected-error@-1 {{covariant 'Self' or 'Self?' can only appear as the type of a property, subscript or method result; did you mean 'A'?}}
print("\(Self.self).\(#function)")
}
classfunc y(){
print("\(Self.self).\(#function)")
Self.z()
}
func x()->A?{
print("\(Self.self).\(#function)")
Self.y()
Self.z()
let _:Self=Self.init(a:66)
returnSelf.init(a:77)as?Selfas?A
 // expected-warning@-1 {{conditional cast from 'Self' to 'Self' always succeeds}}
 // expected-warning@-2 {{conditional downcast from 'Self?' to 'A<T>' is equivalent to an implicit conversion to an optional 'A<T>'}}
}
func copy()->Self{
letcopy=Self.init(a:11)
return copy
}

 subscript (i:Int)->Self{ // expected-error {{mutable subscript cannot have covariant 'Self' type}}
get{
returnSelf.init(a: i)
}
set(newValue){
}
}
}

classB:A<Int>{
leta:Int
requiredconvenienceinit(a:Int){
print("\(Self.self).\(#function)")
self.init()
}
init(){
print("\(Self.self).\(#function)")
Self.y()
Self.z()
 a =99
 super.init(a:88)
}
overrideclassfunc y(){
print("override \(Self.self).\(#function)")
}
}

classC{
requiredinit(){
}

func f(){
func g(_:Self){}
letx:Self=selfas!Self
g(x)
typealias_Self=Self
}
func g(){
 _ =Self.init()as?Self
 // expected-warning@-1 {{conditional cast from 'Self' to 'Self' always succeeds}}
}
func h(j:()->Self)->()->Self{
 // expected-error@-1 {{covariant 'Self' or 'Self?' can only appear at the top level of method result type}}
return{returnself}
}
func i()->(Self,Self){}
 // expected-error@-1 {{covariant 'Self' or 'Self?' can only appear at the top level of method result type}}

func j()->Self.Type{}
 // expected-error@-1 {{covariant 'Self' or 'Self?' can only appear at the top level of method result type}}

letp0:Self? // expected-error {{stored property cannot have covariant 'Self' type}}
varp1:Self? // expected-error {{stored property cannot have covariant 'Self' type}}

staticfunc staticFunc()->Self{}
letstored:Self=Self.staticFunc() // expected-error {{stored property cannot have covariant 'Self' type}}
 // expected-error@-1 {{covariant 'Self' type cannot be referenced from a stored property initializer}}

varprop:Self{ // expected-error {{mutable property cannot have covariant 'Self' type}}
get{
returnself
}
set(newValue){
}
}
 subscript (i:Int)->Self{ // expected-error {{mutable subscript cannot have covariant 'Self' type}}
get{
returnself
}
set(newValue){
}
}
}

extensionC{
staticvarrdar57188331=Self.staticFunc() // expected-error {{covariant 'Self' type cannot be referenced from a stored property initializer}} expected-error {{stored property cannot have covariant 'Self' type}}
staticvarrdar57188331Var=""
staticletrdar57188331Ref=UnsafeRawPointer(&Self.rdar57188331Var) // expected-error {{covariant 'Self' type cannot be referenced from a stored property initializer}}
}


structS1{
typealias_SELF=Self
letj=99.1
 subscript (i:Int)->Self{
get{
returnself
}
set(newValue){
}
}
varfoo:Self{
get{
returnself// as! Self
}
set(newValue){
}
}
func x(y:()->Self, z:Self){
}
}

structS2{
letx=99
structS3<T>{
letx=99
staticfunc x(){
Self.y()
}
func f(){
func g(_:Self){}
}
staticfunc y(){
print("HERE")
}
func foo(a:[Self])->Self?{
Self.x()
returnselfas?Self
 // expected-warning@-1 {{conditional cast from 'S2.S3<T>' to 'S2.S3<T>' always succeeds}}
}
}
func copy()->Self{
letcopy=Self.init()
return copy
}

varcopied:Self{
letcopy=Self.init()
return copy
}
}

extensionS2{
staticfunc x(){
Self.y()
}
staticfunc y(){
print("HERE")
}
func f(){
func g(_:Self){}
}
func foo(a:[Self])->Self?{
Self.x()
returnSelf.init()as?Self
 // expected-warning@-1 {{conditional cast from 'S2' to 'S2' always succeeds}}
}
 subscript (i:Int)->Self{
get{
returnSelf.init()
}
set(newValue){
}
}
}

enumE{
staticfunc f(){
func g(_:Self){}
print("f()")
}
case e
func h(h:Self)->Self{
Self.f()
return.e
}
}

classSelfStoredPropertyInit{
staticfunc myValue()->Int{return123}

varvalue=Self.myValue() // expected-error {{covariant 'Self' type cannot be referenced from a stored property initializer}}
}

// rdar://problem/55273931 - erroneously rejecting 'Self' in lazy initializer
classFoo{
staticvarvalue:Int=17

 lazy vardoubledValue:Int={
Self.value *2
}()
}

// https://github.com/apple/swift/issues/54090 (duplicate diagnostics)

structBox<T>{
letboxed:T
}

classBoxer{
 lazy vars=Box<Self>(boxed:selfas!Self)
 // expected-error@-1 {{stored property cannot have covariant 'Self' type}}
 // expected-error@-2 {{mutable property cannot have covariant 'Self' type}}
 // FIXME: [DiagQoI] We can do better than this.

vart=Box<Self>(boxed:Self())
 // expected-error@-1 {{stored property cannot have covariant 'Self' type}}
 // expected-error@-2 {{covariant 'Self' type cannot be referenced from a stored property initializer}}

requiredinit(){}
}

// https://github.com/apple/swift/issues/54568
// A type named 'Self' should be found first
structOuterType{
struct`Self`{
letstring:String
}

varfoo:`Self`?{
letoptional:String?="foo"
return optional.map{`Self`(string: $0)}
}
}

// rdar://69804933 - CSApply assigns wrong type to MemberRefExpr for property with
// DynamicSelfType
classHasDynamicSelfProperty{
varme:Self{
returnself
}
}

// SILGen doesn't care about the MemberRefExpr's type, so it's hard to come up with an
// example that actually fails. Here, the rogue 'Self' type was diagnosed as being invalid
// in a stored property initializer.
classUsesDynamicSelfProperty{
varc=HasDynamicSelfProperty().me
}

// Test that dynamic 'Self' gets substituted with the object type of the
// associated 'self' parameter in 'super'-based invocations.
do{
classA{
requiredinit(){}

func method()->Self{self}
varproperty:Self{self}
 subscript()->Self{self}

classfunc method()->Self{self.init()}
classvarproperty:Self{self.init()}
class subscript()->Self{self.init()}
}

classB:A{
overridefunc method()->Self{ super.method()}
overridevarproperty:Self{ super.property }
override subscript()->Self{ super[]}

overrideclassfunc method()->Self{
 // Constructors must always have dynamic 'Self' replaced with the base
 // object type.
 // FIXME: Statically dispatches to the superclass init, but constructs an
 // object of the 'Self' type.
let _:Self= super.init() // expected-error {{cannot convert value of type 'A' to specified type 'Self'}}
return super.method()
}
overrideclassvarproperty:Self{ super.property }
overrideclass subscript()->Self{ super[]}
}

classC:B{}

classD:C{
func testWithStaticSelf(){
let _:Self= super.method() // expected-error {{cannot convert value of type 'D' to specified type 'Self'}}
let _:Self= super.property // expected-error {{cannot convert value of type 'D' to specified type 'Self'}}
let _:Self= super[] // expected-error {{cannot convert value of type 'D' to specified type 'Self'}}
let _:()->Self= super.method // expected-error {{cannot convert value of type '() -> D' to specified type '() -> Self'}}
}

staticfunc testWithStaticSelfStatic(){
 // Constructors must always have dynamic 'Self' replaced with the base
 // object type.
 // FIXME: Statically dispatches to the superclass init, but constructs an
 // object of the 'Self' type.
let _:Self= super.init() // expected-error {{cannot convert value of type 'C' to specified type 'Self'}}
let _:Self= super.method() // expected-error {{cannot convert value of type 'D' to specified type 'Self'}}
let _:Self= super.property // expected-error {{cannot convert value of type 'D' to specified type 'Self'}}
let _:Self= super[] // expected-error {{cannot convert value of type 'D' to specified type 'Self'}}
let _:()->Self= super.method
 // expected-error@-1 {{cannot reference 'super' instance method with metatype base as function value}}
 // expected-error@-2 {{cannot convert value of type '(C) -> () -> D' to specified type '() -> Self'}}
}
}
}

// https://github.com/apple/swift/issues/57081

structGeneric<T>{
func foo()->Self<Int>{}
 // expected-error@-1 {{cannot specialize 'Self'}}
 // expected-note@-2 {{did you mean to explicitly reference 'Generic' instead?}}{{17-21=Generic}}
}

structNonGeneric{
func foo()->Self<Int>{}
 // expected-error@-1 {{cannot specialize 'Self'}}
}

protocolP{
func foo()->Self<Int>
 // expected-error@-1 {{cannot specialize non-generic type 'Self'}}
}