annotation.swift

// RUN: %target-swift-ide-test -annotate -source-filename %s | %FileCheck %s

// CHECK: import struct <iMod>Swift</iMod>.<iStruct@>Int</iStruct>
importstruct Swift.Int
// CHECK: import func <iMod>Swift</iMod>.print_new
importfunc Swift.print_new

// CHECK: struct <Struct>S</Struct> {
// CHECK-NEXT: var <Var>x</Var>: <iStruct@>Int</iStruct> = 0
// CHECK-NEXT: var <Var>y</Var>: <iMod>Swift</iMod>.<iStruct@>Int</iStruct> = 0
// CHECK-NEXT: }
structS{
varx:Int=0
vary:Swift.Int=0
}

// CHECK: typealias <TypeAlias>TypealiasForS</TypeAlias> = <Struct@[[@LINE-5]]:8>S</Struct>
typealiasTypealiasForS=S

func test6(p:S){
 // CHECK: <Param@[[@LINE-1]]:12>p</Param>.<Var@[[@LINE-8]]:7>x</Var> <iFunc@>+</iFunc> 0
 p.x +0
}

// CHECK: struct <Struct>PropagatedTypesInPatterns</Struct> {
// CHECK-NEXT: var <Var>a</Var>, <Var>b</Var>: <iStruct@>Int</iStruct>
// CHECK-NEXT: var <Var>c</Var>: <iStruct@>Int</iStruct>, <Var>d</Var>, <Var>e</Var>: <iStruct@>Double</iStruct>
// CHECK-NEXT: var <Var>f</Var>, <Var>g</Var>, <Var>h</Var>: <iStruct@>Int</iStruct>, <Var>i</Var>: <iStruct@>Float</iStruct>, <Var>j</Var>, <Var>k</Var>, <Var>l</Var>, <Var>m</Var>: <iStruct@>Double</iStruct>
// CHECK-NEXT: var (<Var>x</Var>, <Var>y</Var>): (<iStruct@>Int</iStruct>, <iStruct@>Float</iStruct>)
// CHECK-NEXT: }
structPropagatedTypesInPatterns{
vara,b:Int
varc:Int,d,e:Double
varf,g,h:Int,i:Float,j,k,l,m:Double
var(x, y):(Int,Float)
}

// CHECK: class <Class>MyCls</Class> {
// CHECK: var <Var>www</Var> : <iStruct@>Int</iStruct>
// CHECK: func <Func>foo</Func>(_ <Param>x</Param> : <iStruct@>Int</iStruct>) {}
// CHECK: }
classMyCls{
varwww:Int=0
func foo(_ x :Int){}
}

// CHECK: func <Func>foo</Func>(<Param>n</Param> : <iStruct@>Float</iStruct>) -> <iStruct@>Int</iStruct> {
// CHECK: var <Var>q</Var> = <Ctor@[[@LINE-6]]:7-Class@[[@LINE-6]]:7>MyCls</Ctor>()
// CHECK: var <Var>ee</Var> = "yoo";
// CHECK: return 100009
// CHECK: }
func foo(n :Float)->Int{
varq=MyCls()
varee="yoo";
return100009
}

// CHECK-LABEL: protocol <Protocol>Prot</Protocol> {
// CHECK-NEXT: associatedtype <AssociatedType>Blarg</AssociatedType>
// CHECK-NEXT: func <Func>protMeth</Func>(_ <Param>x</Param>: <iStruct@>Int</iStruct>)
// CHECK-NEXT: var <Var>protocolProperty1</Var>: <iStruct@>Int</iStruct> { get }
// CHECK-NEXT: var <Var>protocolProperty2</Var>: <iStruct@>Int</iStruct> { get set }
// CHECK-NEXT: }
protocolProt{
associatedtypeBlarg
func protMeth(_ x:Int)
varprotocolProperty1:Int{get}
varprotocolProperty2:Int{getset}
}
// CHECK: protocol <Protocol>Prot2</Protocol> {}
protocolProt2{}

// CHECK: class <Class>SubCls</Class> : <Class@[[@LINE-31]]:7>MyCls</Class>, <Protocol@[[@LINE-9]]:10>Prot</Protocol> {
// CHECK: typealias <TypeAlias>Blarg</TypeAlias> = <Protocol@[[@LINE-3]]:10>Prot2</Protocol>
// CHECK: func <Func>protMeth</Func>(_ <Param>x</Param>: <iStruct@>Int</iStruct>) {}
// CHECK: }
classSubCls:MyCls,Prot{
typealiasBlarg=Prot2
func protMeth(_ x:Int){}
varprotocolProperty1=0
varprotocolProperty2=0
}

// CHECK: func <Func>genFn</Func><<GenericTypeParam>T</GenericTypeParam> : <Protocol@64:10>Prot</Protocol>>(_ <Param>p</Param> : <GenericTypeParam@85:12>T</GenericTypeParam>) -> <iStruct@>Int</iStruct> where <GenericTypeParam@85:12>T</GenericTypeParam>.<AssociatedType@65:18>Blarg</AssociatedType> : <Protocol@71:10>Prot2</Protocol> {}{{$}}
func genFn<T :Prot>(_ p :T)->Intwhere T.Blarg :Prot2{}

func test(_ x:Int){
 // CHECK: <Func@[[@LINE-3]]:6>genFn</Func>(<Class@[[@LINE-11]]:7>SubCls</Class>())
genFn(SubCls())
 // CHECK: "This is string \(<Func@[[@LINE-5]]:6>genFn</Func>({(<Param>a</Param>:<iStruct@>Int</iStruct>) in <Class@[[@LINE-13]]:7>SubCls</Class>()}(<Param@[[@LINE-3]]:13>x</Param>))) interpolation"
"This is string \(genFn({(a:Int)inSubCls()}(x))) interpolation"
}

// CHECK: func <Func>bar</Func>(<Param>x</Param>: <iStruct@>Int</iStruct>) -> (<iStruct@>Int</iStruct>, <iStruct@>Float</iStruct>) {
func bar(x:Int)->(Int,Float){
 // CHECK: <Ctor@[[@LINE-84]]:8-TypeAlias@[[@LINE-78]]:11>TypealiasForS</Ctor>()
 _ =TypealiasForS()
}

classC2{
typealiasWW=Int
varp=0

func meth(_ x:Int){}
}

func test2(x:C2){
 // CHECK: <Param@[[@LINE-1]]:12>x</Param>.<Func@[[@LINE-4]]:8>meth</Func>(0)
 x.meth(0)
}

// CHECK: class <Class>GenCls</Class><<GenericTypeParam>T</GenericTypeParam>> {
classGenCls<T>{
 // CHECK: <Constructor>init</Constructor>() {}
init(){}

 // CHECK: <Subscript>subscript</Subscript> (<Param>i</Param> : <iStruct@>Int</iStruct>, <Param>j</Param> : <iStruct@>Int</iStruct>) -> <iStruct@>Int</iStruct> {
 subscript (i :Int, j :Int)->Int{
get{
 // CHECK: return <Param@[[@LINE-2]]:14>i</Param> <iFunc@>+</iFunc> <Param@[[@LINE-2]]:23>j</Param>
return i + j
}
 // CHECK: set(<Param>v</Param>) {
set(v){
 // CHECK: <Param@[[@LINE-1]]:9>v</Param> <iFunc@>+</iFunc> <Param@[[@LINE-7]]:14>i</Param> <iFunc@>-</iFunc> <Param@[[@LINE-7]]:23>j</Param>
 v + i - j
}
}
}

func test2(){
 // CHECK: <Ctor@[[@LINE-17]]:3-Class@[[@LINE-19]]:7>GenCls</Ctor><<iStruct@>Int</iStruct>>()
GenCls<Int>()
}

func test3(name:Int, x:Int){
 // CHECK: <Param@[[@LINE-1]]:23>x</Param> = 0
 name =0; x =0
}

classC4{
classIn{
classfunc goo(){}
classfunc foo(){
 // CHECK: <Class@[[@LINE-3]]:9>In</Class>.<Func@[[@LINE-2]]:16>goo</Func>()
In.goo()
 // CHECK: <Class@[[@LINE-6]]:7>C4</Class>.<Class@[[@LINE-5]]:9>In</Class>.<Func@[[@LINE-4]]:16>goo</Func>()
C4.In.goo()
 // CHECK: <Class@[[@LINE-8]]:7>C4</Class>.<Ctor@[[@LINE-7]]:9-Class@[[@LINE-7]]:9>In</Ctor>()
C4.In()
}
}
}

classGenC<T1,T2>{
classfunc foo(){}
}
func test4(){
 // CHECK: <Class@[[@LINE-4]]:7>GenC</Class><<iStruct@>Int</iStruct>, <TypeAlias@[[@LINE-141]]:11>TypealiasForS</TypeAlias>>.<Func@[[@LINE-3]]:14>foo</Func>()
GenC<Int,TypealiasForS>.foo()
}

classC5{}
protocolP5{}
// CHECK: extension <Class@[[@LINE-2]]:7>C5</Class> : <Protocol@[[@LINE-1]]:10>P5</Protocol> {}
extensionC5:P5{}

extensionArray:P5{}
// CHECK: extension <iStruct@>Array</iStruct> : <Protocol{{.*}}>P5</Protocol> {}
extensionOptional:P5{}
// CHECK: extension <iEnum@>Optional</iEnum> : <Protocol{{.*}}>P5</Protocol> {}

classC6{
func meth(){
 // CHECK: <Func@[[@LINE+5]]:8>meth2</Func>()
meth2()
 // CHECK: <Param@[[@LINE-3]]:8>self</Param>.<Func@[[@LINE+3]]:8>meth2</Func>()
self.meth2();
}
func meth2(){}
}

func test5(){
varx:Int
 // CHECK: for <Var>i</Var> in 1<iFunc@>..<</iFunc>100 {
foriin1..<100{
 // CHECK: <Var@[[@LINE-3]]:7>x</Var> = <Var@[[@LINE-1]]:7>i</Var>
 x = i
}
}

classC7{
varc7ivar:Int
func meth(_ p:Undeclared){
 // CHECK: <Var@[[@LINE-2]]:7>c7ivar</Var> = 0
 c7ivar =0
}
}

classC8{
init(_ x:Int){
 // CHECK: <Param@[[@LINE-1]]:3>self</Param>.<Ctor@[[@LINE-1]]:3>init</Ctor>(1)
self.init(1)
}
}

classSubC8:C8{
init(x:Int){
 // CHECK: super.<Ctor@[[@LINE-8]]:3>init</Ctor>(2)
 super.init(2)
}
}

classObservers{
func doit(){}

varp1:Int{
 // CHECK: willSet(<Param>newValue</Param>) { <Func@[[@LINE-3]]:8>doit</Func>() }
 willSet(newValue){doit()}
 // CHECK: didSet { <Func@[[@LINE-5]]:8>doit</Func>() }
 didSet {doit()}
}
}

classC9{}
// CHECK: func <Func>test6</Func>(_ <Param>o</Param>: <iTypeAlias@>AnyObject</iTypeAlias>) {
func test6(_ o:AnyObject){
 // CHECK: let <Var>x</Var> = <Param@[[@LINE-1]]:14>o</Param> as! <Class@[[@LINE-3]]:7>C9</Class>
letx= o as!C9
}

// CHECK: enum <Enum>myCoolEnum</Enum> {
enummyCoolEnum{
 // CHECK: case <EnumElement>water</EnumElement>
case water
 // CHECK-NEXT: case
case
}

// rdar://19614869, do not crash
classE{
 lazy varu:T{
return1
}
}

classC10{
init(int:Int, andThis:Float){}
func meth(_ x:Int, withFloat:Float){}
}

// CHECK: var <Var>c10</Var> = <Ctor@[[@LINE-4]]:3-Class@[[@LINE-5]]:7>C10</Ctor>(<Ctor@[[@LINE-4]]:3#int>int</Ctor>: 0, <Ctor@[[@LINE-4]]:3#andThis>andThis</Ctor>: 0)
varc10=C10(int:0, andThis:0)
// CHECK: <Var@[[@LINE-1]]:5>c10</Var>.<Func@[[@LINE-5]]:8>meth</Func>(0, <Func@[[@LINE-5]]:8#withFloat>withFloat</Func>: 0)
c10.meth(0, withFloat:0)

func test7(int x:Int, andThis y:Float){}
// CHECK: <Func@[[@LINE-1]]:6>test7</Func>(<Func@[[@LINE-1]]:6#int>int</Func>: 0, <Func@[[@LINE-1]]:6#andThis>andThis</Func>: 0)
test7(int:0, andThis:0)

func test8<T :Prot2>(_ x:T){}
// CHECK: func <Func>test8</Func><<GenericTypeParam>T</GenericTypeParam> : <Protocol@71:10>Prot2</Protocol>>(_ <Param>x</Param>: <GenericTypeParam@261:12>T</GenericTypeParam>) {}{{$}}

classC11{
 // CHECK: var <Var>a</Var>: <iStruct@>Int</iStruct> = { var <Var>tmp</Var> = 0; return <Var@[[@LINE+1]]:22>tmp</Var> }()
vara:Int={vartmp=0; return tmp }()
 // CHECK: lazy var <Var>b</Var>: <iStruct@>Int</iStruct> = { var <Var>tmp</Var> = 0; return <Var@[[@LINE+1]]:27>tmp</Var> }()
 lazy varb:Int={vartmp=0; return tmp }()
 // CHECK: var <Var>c</Var>: <iStruct@>Int</iStruct> { get { {var <Var>tmp</Var> = 0; return <Var@[[@LINE+1]]:27>tmp</Var>}() } }
varc:Int{get{{vartmp=0; return tmp}()}}
}

// CHECK: var <Var>g1</Var> = { (<Param>x</Param>: <iStruct@>Int</iStruct>) -> <iStruct@>Int</iStruct> in return 0 }
varg1={(x:Int)->Intinreturn0}

classC12{
classInn{}
typealiasAliasInn=Inn
}
typealiasAliasC12=C12

// CHECK: extension <Class@[[@LINE-6]]:7>C12</Class>.<Class@[[@LINE-5]]:9>Inn</Class> {}
extensionC12.Inn{}
// CHECK: extension <TypeAlias@[[@LINE-4]]:11>AliasC12</TypeAlias>.<TypeAlias@[[@LINE-6]]:13>AliasInn</TypeAlias> {}
extensionAliasC12.AliasInn{}

typealiasAliasPH=C12
func testPH(_ x:Int){}
func testPH(_ x:AliasPH){}
// CHECK: <Func@[[@LINE-1]]:6>testPH</Func>(<#T##x: AliasPH##AliasPH##C12#>)
testPH(<#T##x: AliasPH##AliasPH##C12#>)

classNumberTooLarge{}
// CHECK: guard case let <Var>error</Var> as <Class@[[@LINE-1]]:7>NumberTooLarge</Class> = <Ctor@[[@LINE-1]]:7-Class@[[@LINE-1]]:7>NumberTooLarge</Ctor>() else {}
guard case let error as NumberTooLarge=NumberTooLarge()else{}

// CHECK: <Func>testMod</Func>(_ <Param>x</Param>: <iMod>Swift</iMod>.<iStruct@>String</iStruct>) {
func testMod(_ x:Swift.String){
// CHECK: let <Var>x</Var> = <iMod>Swift</iMod>
letx= Swift
}

func+(a:C12, b:C12){}
func test9(a:C12, b:C12){
 // CHECK: <Param@[[@LINE-1]]:12>a</Param><Func@[[@LINE-2]]:6>+</Func><Param@[[@LINE-1]]:20>b</Param>
 a+b
}

func test10(a:[Int], i:Int){
 // CHECK: <Param@[[@LINE-1]]:13>a</Param><iSubscript@>[</iSubscript><Param@[[@LINE-1]]:23>i</Param><iSubscript@>]</iSubscript>
a[i]
}

classCWS{
 subscript (i :Int, j :Int)->Int{return0}
}
func test11(a:CWS, i:Int){
 // CHECK: <Param@[[@LINE-1]]:13>a</Param><Subscript@[[@LINE-3]]:3>[</Subscript><Param@[[@LINE-1]]:21>i</Param>,<Param@[[@LINE-1]]:21>i</Param><Subscript@[[@LINE-3]]:3>]</Subscript>
a[i,i]
}

// CHECK: func <Func>test_defer</Func>() {
func test_defer(){
defer{
 // CHECK: <Func@[[@LINE-2]]:6>test_defer</Func>()
test_defer()
}
}

func test_arg_tuple1(_:Int, _:Int){}
func test_arg_tuple2(p1:Int, _:Int){}
func test_arg_tuple3(_:Int, p2:Int){}
func test_arg_tuple4(p1:Int, p2:Int){}
// CHECK: <Func@[[@LINE-4]]:6>test_arg_tuple1</Func>(0,0)
test_arg_tuple1(0,0)
// CHECK: <Func@[[@LINE-5]]:6>test_arg_tuple2</Func>(<Func@[[@LINE-5]]:6#p1>p1</Func>:0,0)
test_arg_tuple2(p1:0,0)
// CHECK: <Func@[[@LINE-6]]:6>test_arg_tuple3</Func>(0,<Func@[[@LINE-6]]:6#p2>p2</Func>:0)
test_arg_tuple3(0,p2:0)
// CHECK: <Func@[[@LINE-7]]:6>test_arg_tuple4</Func>(<Func@[[@LINE-7]]:6#p1>p1</Func>:0,<Func@[[@LINE-7]]:6#p2>p2</Func>:0)
test_arg_tuple4(p1:0,p2:0)


@dynamicMemberLookup
structLens<T>{
varobj:T
init(_ obj:T){
self.obj = obj
}
 subscript<U>(dynamicMember member:WritableKeyPath<T,U>)->Lens<U>{
get{returnLens<U>(obj[keyPath: member])}
set{obj[keyPath: member]= newValue.obj }
}
}
structPoint{
varx:Int
vary:Int
}
structRectangle{
vartopLeft:Point
varbottomRight:Point
}
func testDynamicMemberLookup(r:Lens<Rectangle>){
 _ = r.topLeft
 // CHECK: _ = <Param@[[@LINE-2]]:30>r</Param>.<Var@[[@LINE-5]]:7>topLeft</Var>
 _ = r.bottomRight.y
 // CHECK: _ = <Param@[[@LINE-4]]:30>r</Param>.<Var@[[@LINE-6]]:7>bottomRight</Var>.<Var@[[@LINE-10]]:7>y</Var>
}
func keyPathTester<V>(keyPath:KeyPath<Lens<Rectangle>,V>){}
func testKeyPath(){
keyPathTester(keyPath: \.topLeft)
 // CHECK: <Func@[[@LINE-3]]:6>keyPathTester</Func>(<Func@[[@LINE-3]]:6#keyPath>keyPath</Func>: \.<Var@[[@LINE-12]]:7>topLeft</Var>)
}