mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
253 lines
9.7 KiB
Swift
253 lines
9.7 KiB
Swift
// RUN: %swift-ide-test -structure -source-filename %s | %FileCheck %s
|
|
|
|
// CHECK: <class>class <name>MyCls</name> : <inherited><elem-typeref>OtherClass</elem-typeref></inherited> {
|
|
// CHECK: <property>var <name>bar</name> : <type>Int</type></property>
|
|
// CHECK: <property>var <name>anotherBar</name> : <type>Int</type> = 42</property>
|
|
// CHECK: <cvar>class var <name>cbar</name> : <type>Int</type> = 0</cvar>
|
|
class MyCls : OtherClass {
|
|
var bar : Int
|
|
var anotherBar : Int = 42
|
|
class var cbar : Int = 0
|
|
|
|
// CHECK: <ifunc>func <name>foo(<param>_ arg1: <type>Int</type></param>, <param><name>name</name>: <type>String</type></param>, <param><name>param</name> par: <type>String</type></param>)</name> {
|
|
// CHECK: <lvar>var <name>abc</name></lvar>
|
|
// CHECK: <if>if <elem-condexpr>1</elem-condexpr> <brace>{
|
|
// CHECK: <call><name>foo</name>(<arg>1</arg>, <arg><name>name</name>:"test"</arg>, <arg><name>param</name>:"test2"</arg>)</call>
|
|
// CHECK: }</brace>
|
|
// CHECK: }</ifunc>
|
|
func foo(_ arg1: Int, name: String, param par: String) {
|
|
var abc
|
|
if 1 {
|
|
foo(1, name:"test", param:"test2")
|
|
}
|
|
}
|
|
|
|
// CHECK: <ifunc><name>init (<param><name>x</name>: <type>Int</type></param>)</name></ifunc>
|
|
init (x: Int)
|
|
|
|
// CHECK: <cfunc>class func <name>cfoo()</name></cfunc>
|
|
class func cfoo()
|
|
|
|
// CHECK: }</class>
|
|
}
|
|
|
|
// CHECK: <struct>struct <name>MyStruc</name> {
|
|
// CHECK: <property>var <name>myVar</name>: <type>Int</type></property>
|
|
// CHECK: <svar>static var <name>sbar</name> : <type>Int</type> = 0</svar>
|
|
// CHECK: <sfunc>static func <name>cfoo()</name></sfunc>
|
|
// CHECK: }</struct>
|
|
struct MyStruc {
|
|
var myVar: Int
|
|
static var sbar : Int = 0
|
|
static func cfoo()
|
|
}
|
|
|
|
// CHECK: <protocol>protocol <name>MyProt</name> {
|
|
// CHECK: <ifunc>func <name>foo()</name></ifunc>
|
|
// CHECK: }</protocol>
|
|
protocol MyProt {
|
|
func foo()
|
|
}
|
|
|
|
// CHECK: <extension>extension <name>MyStruc</name> {
|
|
// CHECK: <ifunc>func <name>foo()</name> {
|
|
// CHECK: }</ifunc>
|
|
// CHECK: }</extension>
|
|
extension MyStruc {
|
|
func foo() {
|
|
}
|
|
}
|
|
|
|
// CHECK: <gvar>var <name>gvar</name> : <type>Int</type> = 0</gvar>
|
|
var gvar : Int = 0
|
|
|
|
// CHECK: <ffunc>func <name>ffoo()</name> {}</ffunc>
|
|
func ffoo() {}
|
|
|
|
// CHECK: <foreach>for <elem-id><lvar><name>i</name></lvar></elem-id> in <elem-expr>0...5</elem-expr> <brace>{}</brace></foreach>
|
|
for i in 0...5 {}
|
|
// CHECK: <foreach>for <elem-id>var (<lvar><name>i</name></lvar>, <lvar><name>j</name></lvar>)</elem-id> in <elem-expr>array</elem-expr> <brace>{}</brace></foreach>
|
|
for var (i, j) in array {}
|
|
|
|
// CHECK: <while>while <elem-condexpr>var <lvar><name>v</name></lvar> = o, <lvar><name>z</name></lvar> = o where v > z</elem-condexpr> <brace>{}</brace></while>
|
|
while var v = o, z = o where v > z {}
|
|
// CHECK: <while>while <elem-condexpr>v == 0</elem-condexpr> <brace>{}</brace></while>
|
|
while v == 0 {}
|
|
// CHECK: <repeat-while>repeat <brace>{}</brace> while <elem-expr>v == 0</elem-expr></repeat-while>
|
|
repeat {} while v == 0
|
|
// CHECK: <if>if <elem-condexpr>var <lvar><name>v</name></lvar> = o, <lvar><name>z</name></lvar> = o where v > z</elem-condexpr> <brace>{}</brace></if>
|
|
if var v = o, z = o where v > z {}
|
|
|
|
// CHECK: <switch>switch <elem-expr>v</elem-expr> {
|
|
// CHECK: <case>case <elem-pattern>1</elem-pattern>: break;</case>
|
|
// CHECK: <case>case <elem-pattern>2</elem-pattern>, <elem-pattern>3</elem-pattern>: break;</case>
|
|
// CHECK: <case>case <elem-pattern><call><name>Foo</name>(<arg>var <lvar><name>x</name></lvar></arg>, <arg>var <lvar><name>y</name></lvar></arg>)</call> where x < y</elem-pattern>: break;</case>
|
|
// CHECK: <case>case <elem-pattern>2 where <call><name>foo</name>()</call></elem-pattern>, <elem-pattern>3 where <call><name>bar</name>()</call></elem-pattern>: break;</case>
|
|
// CHECK: <case><elem-pattern>default</elem-pattern>: break;</case>
|
|
// CHECK: }</switch>
|
|
switch v {
|
|
case 1: break;
|
|
case 2, 3: break;
|
|
case Foo(var x, var y) where x < y: break;
|
|
case 2 where foo(), 3 where bar(): break;
|
|
default: break;
|
|
}
|
|
|
|
// CHECK: <gvar>let <name>myArray</name> = <array>[<elem-expr>1</elem-expr>, <elem-expr>2</elem-expr>, <elem-expr>3</elem-expr>]</array></gvar>
|
|
let myArray = [1, 2, 3]
|
|
// CHECK: <gvar>let <name>myDict</name> = <dictionary>[<elem-expr>1</elem-expr>:<elem-expr>1</elem-expr>, <elem-expr>2</elem-expr>:<elem-expr>2</elem-expr>, <elem-expr>3</elem-expr>:<elem-expr>3</elem-expr>]</dictionary></gvar>
|
|
let myDict = [1:1, 2:2, 3:3]
|
|
// CHECK: <gvar>let <name>myArray2</name> = <array>[<elem-expr>1</elem-expr>]</array></gvar>
|
|
let myArray2 = [1]
|
|
// CHECK: <gvar>let <name>myDict2</name> = <dictionary>[<elem-expr>1</elem-expr>:<elem-expr>1</elem-expr>]</dictionary></gvar>
|
|
let myDict2 = [1:1]
|
|
|
|
// CHECK: <foreach>for <brace>{}</brace></foreach>
|
|
for {}
|
|
|
|
// CHECK: <class>class <name><#MyCls#></name> : <inherited><elem-typeref><#OtherClass#></elem-typeref></inherited> {}
|
|
class <#MyCls#> : <#OtherClass#> {}
|
|
|
|
// CHECK: <ffunc>func <name><#test1#> ()</name> {
|
|
// CHECK: <foreach>for <elem-id><lvar><name><#name#></name></lvar></elem-id> in <elem-expr><#items#></elem-expr> <brace>{}</brace></foreach>
|
|
// CHECK: }</ffunc>
|
|
func <#test1#> () {
|
|
for <#name#> in <#items#> {}
|
|
}
|
|
|
|
// CHECK: <gvar>let <name>myArray</name> = <array>[<elem-expr><#item1#></elem-expr>, <elem-expr><#item2#></elem-expr>]</array></gvar>
|
|
let myArray = [<#item1#>, <#item2#>]
|
|
|
|
// CHECK: <ffunc>func <name>test1()</name> {
|
|
// CHECK: <call><name>dispatch_async</name>(<arg><call><name>dispatch_get_main_queue</name>()</call></arg>, <arg><brace>{}</brace></arg>)</call>
|
|
// CHECK: <call><name>dispatch_async</name>(<arg><call><name>dispatch_get_main_queue</name>()</call></arg>) <arg><brace>{}</brace></arg></call>
|
|
// CHECK: }</ffunc>
|
|
func test1() {
|
|
dispatch_async(dispatch_get_main_queue(), {})
|
|
dispatch_async(dispatch_get_main_queue()) {}
|
|
}
|
|
|
|
// CHECK: <enum>enum <name>SomeEnum</name> {
|
|
// CHECK: <enum-case>case <enum-elem><name>North</name></enum-elem></enum-case>
|
|
// CHECK: <enum-case>case <enum-elem><name>South</name></enum-elem>, <enum-elem><name>East</name></enum-elem></enum-case>
|
|
// CHECK: <enum-case>case <enum-elem><name>QRCode</name>(String)</enum-elem></enum-case>
|
|
// CHECK: <enum-case>case</enum-case>
|
|
// CHECK: }</enum>
|
|
enum SomeEnum {
|
|
case North
|
|
case South, East
|
|
case QRCode(String)
|
|
case
|
|
}
|
|
|
|
// CHECK: <enum>enum <name>Rawness</name> : <inherited><elem-typeref>Int</elem-typeref></inherited> {
|
|
// CHECK: <enum-case>case <enum-elem><name>One</name> = <elem-initexpr>1</elem-initexpr></enum-elem></enum-case>
|
|
// CHECK: <enum-case>case <enum-elem><name>Two</name> = <elem-initexpr>2</elem-initexpr></enum-elem>, <enum-elem><name>Three</name> = <elem-initexpr>3</elem-initexpr></enum-elem></enum-case>
|
|
// CHECK: }</enum>
|
|
enum Rawness : Int {
|
|
case One = 1
|
|
case Two = 2, Three = 3
|
|
}
|
|
|
|
// CHECK: <ffunc>func <name>rethrowFunc(<param>_ f: <type>() throws -> ()</type></param>)</name> rethrows {}</ffunc>
|
|
func rethrowFunc(_ f: () throws -> ()) rethrows {}
|
|
|
|
class NestedPoundIf{
|
|
func foo1() {
|
|
#if os(OSX)
|
|
var a = 1
|
|
#if USE_METAL
|
|
var b = 2
|
|
#if os(iOS)
|
|
var c = 3
|
|
#else
|
|
var c = 3
|
|
#endif
|
|
#else
|
|
var b = 2
|
|
#endif
|
|
#else
|
|
var a = 1
|
|
#endif
|
|
}
|
|
func foo2() {}
|
|
func foo3() {}
|
|
}
|
|
// CHECK: <ifunc>func <name>foo2()</name> {}</ifunc>
|
|
// CHECK: <ifunc>func <name>foo3()</name> {}</ifunc>
|
|
|
|
class A {
|
|
func foo(_ i : Int, animations: () -> ()) {}
|
|
func perform() {foo(5, animations: {})}
|
|
// CHECK: <ifunc>func <name>perform()</name> {<call><name>foo</name>(<arg>5</arg>, <arg><name>animations</name>: <brace>{}</brace></arg>)</call>}</ifunc>
|
|
}
|
|
|
|
// CHECK: <typealias>typealias <name>OtherA</name> = A</typealias>
|
|
typealias OtherA = A
|
|
|
|
class SubscriptTest {
|
|
subscript(index: Int) -> Int {
|
|
return 0
|
|
}
|
|
// CHECK: <subscript><name>subscript(<param>index: <type>Int</type></param>)</name> -> <type>Int</type> {
|
|
// CHECK: return 0
|
|
// CHECK: }</subscript>
|
|
|
|
subscript(string: String) -> Int {
|
|
get {
|
|
return 0
|
|
}
|
|
set(value) {
|
|
print(value)
|
|
}
|
|
}
|
|
// CHECK: <subscript><name>subscript(<param>string: <type>String</type></param>)</name> -> <type>Int</type> {
|
|
// CHECK: get {
|
|
// CHECK: return 0
|
|
// CHECK: }
|
|
// CHECK: set(<param>value</param>) {
|
|
// CHECK: <call><name>print</name>(value)</call>
|
|
// CHECK: }</subscript>
|
|
}
|
|
|
|
class ReturnType {
|
|
func foo() -> Int { return 0 }
|
|
// CHECK: <ifunc>func <name>foo()</name> -> <type>Int</type> {
|
|
// CHECK: return 0
|
|
// CHECK: }</ifunc>
|
|
|
|
func foo2<T>() -> T {}
|
|
// CHECK: <ifunc>func <name>foo2<T>()</name> -> <type>T</type> {}</ifunc>
|
|
|
|
func foo3() -> () -> Int {}
|
|
// CHECK: <ifunc>func <name>foo3()</name> -> <type>() -> Int</type> {}</ifunc>
|
|
}
|
|
|
|
protocol FooProtocol {
|
|
associatedtype Bar
|
|
// CHECK: <associatedtype>associatedtype <name>Bar</name></associatedtype>
|
|
associatedtype Baz: Equatable
|
|
// CHECK: <associatedtype>associatedtype <name>Baz</name>: Equatable</associatedtype>
|
|
}
|
|
|
|
a.b(c: d?.e?.f, g: h)
|
|
// CHECK: <call><name>a.b</name>(<arg><name>c</name>: d?.e?.f</arg>, <arg><name>g</name>: h</arg>)</call>
|
|
|
|
struct Tuples {
|
|
var foo: (Int, String) {
|
|
return (1, "test")
|
|
// CHECK: <tuple>(<elem-expr>1</elem-expr>, <elem-expr>"test"</elem-expr>)</tuple>
|
|
}
|
|
|
|
func foo2() {
|
|
foo3(x: (1, 20))
|
|
// CHECK: <call><name>foo3</name>(<arg><name>x</name>: <tuple>(<elem-expr>1</elem-expr>, <elem-expr>20</elem-expr>)</tuple></arg>)</call>
|
|
let y = (x, foo4(a: 0))
|
|
// CHECK: <lvar>let <name>y</name> = <tuple>(<elem-expr>x</elem-expr>, <elem-expr><call><name>foo4</name>(<arg><name>a</name>: 0</arg>)</call></elem-expr>)</tuple></lvar>
|
|
|
|
let z = (name1: 1, name2: 2)
|
|
// CHECK: <lvar>let <name>z</name> = <tuple>(name1: <elem-expr>1</elem-expr>, name2: <elem-expr>2</elem-expr>)</tuple></lvar>
|
|
}
|
|
}
|
|
|