1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
// RUN: not %target-swift-frontend -dump-parse %s | %FileCheck %s
// RUN: not %target-swift-frontend -dump-ast %s | %FileCheck %s -check-prefix=CHECK-AST
// CHECK-LABEL: (func_decl{{.*}}"foo(_:)"
// CHECK-AST-LABEL: (func_decl{{.*}}"foo(_:)"
func foo(_ n: Int) -> Int {
// CHECK: (brace_stmt
// CHECK: (return_stmt
// CHECK: (integer_literal_expr type="<null>" value="42" {{.*}})))
// CHECK-AST: (brace_stmt
// CHECK-AST: (return_stmt
// CHECK-AST: (integer_literal_expr type="{{[^"]+}}" {{.*}} value="42" {{.*}})
return 42
}
// -dump-parse should print an AST even though this code is invalid.
// CHECK-LABEL: (func_decl{{.*}}"bar()"
// CHECK-AST-LABEL: (func_decl{{.*}}"bar()"
func bar() {
// CHECK: (brace_stmt
// CHECK-NEXT: (unresolved_decl_ref_expr type="{{[^"]+}}" name="foo"
// CHECK-NEXT: (unresolved_decl_ref_expr type="{{[^"]+}}" name="foo"
// CHECK-NEXT: (unresolved_decl_ref_expr type="{{[^"]+}}" name="foo"
// CHECK-AST: (brace_stmt
// CHECK-AST-NEXT: (declref_expr type="{{[^"]+}}" {{.*}} decl="main.(file).foo@
// CHECK-AST-NEXT: (declref_expr type="{{[^"]+}}" {{.*}} decl="main.(file).foo@
// CHECK-AST-NEXT: (declref_expr type="{{[^"]+}}" {{.*}} decl="main.(file).foo@
foo foo foo
}
// CHECK-LABEL: (enum_decl{{.*}}trailing_semi "TrailingSemi"
enum TrailingSemi {
// CHECK-LABEL: (enum_case_decl
// CHECK-NOT: (enum_element_decl{{.*}}trailing_semi
// CHECK: (enum_element_decl{{.*}}"A")
// CHECK: (enum_element_decl{{.*}}"B")
case A,B;
// CHECK-LABEL: (subscript_decl{{.*}}trailing_semi
// CHECK-NOT: (func_decl{{.*}}trailing_semi <anonymous @ 0x{{[0-9a-f]+}}> get for="subscript(_:)"
// CHECK: (accessor_decl{{.*}} <anonymous @ 0x{{[0-9a-f]+}}> get for="subscript(_:)"
subscript(x: Int) -> Int {
// CHECK-LABEL: (pattern_binding_decl{{.*}}
// CHECK-NOT: (var_decl{{.*}}trailing_semi "y"
// CHECK: (var_decl{{.*}}"y"
var y = 1;
// CHECK-LABEL: (sequence_expr {{.*}} trailing_semi
y += 1;
// CHECK-LABEL: (return_stmt{{.*}}trailing_semi
return y;
};
};
// The substitution map for a declref should be relatively unobtrusive.
// CHECK-AST-LABEL: (func_decl{{.*}}"generic(_:)" "<T : Hashable>" interface_type="<T where T : Hashable> (T) -> ()" access=internal captures=(<generic> {{.*}})
func generic<T: Hashable>(_: T) {}
// CHECK-AST: (pattern_binding_decl
// CHECK-AST: (processed_init=declref_expr type="(Int) -> ()" location={{.*}} range={{.*}} decl="main.(file).generic@{{.*}} [with (substitution_map generic_signature=<T where T : Hashable> T -> Int)]" function_ref=unapplied))
let _: (Int) -> () = generic
// Closures should be marked as escaping or not.
func escaping(_: @escaping (Int) -> Int) {}
escaping({ $0 })
// CHECK-AST: (declref_expr type="(@escaping (Int) -> Int) -> ()"
// CHECK-AST-NEXT: (argument_list
// CHECK-AST-NEXT: (argument
// CHECK-AST-NEXT: (closure_expr type="(Int) -> Int" {{.*}} discriminator=0 nonisolated escaping single_expression
func nonescaping(_: (Int) -> Int) {}
nonescaping({ $0 })
// CHECK-AST: (declref_expr type="((Int) -> Int) -> ()"
// CHECK-AST-NEXT: (argument_list
// CHECK-AST-NEXT: (argument
// CHECK-AST-NEXT: (closure_expr type="(Int) -> Int" {{.*}} discriminator=1 nonisolated single_expression
// CHECK-LABEL: (struct_decl decl_context=0x{{[0-9a-z]+}} range=[{{.+}}] "MyStruct")
struct MyStruct {}
// CHECK-LABEL: (enum_decl decl_context=0x{{[0-9a-z]+}} range=[{{.+}}] "MyEnum"
enum MyEnum {
// CHECK-LABEL: (enum_case_decl decl_context=0x{{[0-9a-z]+}} range=[{{.+}}]
// CHECK-NEXT: (enum_element_decl decl_context=0x{{[0-9a-z]+}} range=[{{.+}}] "foo(x:)"
// CHECK-NEXT: (parameter_list range=[{{.+}}]
// CHECK-NEXT: (parameter "x" decl_context=0x{{[0-9a-z]+}} apiName="x")))
// CHECK-NEXT: (enum_element_decl decl_context=0x{{[0-9a-z]+}} range=[{{.+}}] "bar"))
// CHECK-NEXT: (enum_element_decl decl_context=0x{{[0-9a-z]+}} range=[{{.+}}] "foo(x:)"
// CHECK-NEXT: (parameter_list range=[{{.+}}]
// CHECK-NEXT: (parameter "x" decl_context=0x{{[0-9a-z]+}} apiName="x")))
// CHECK-NEXT: (enum_element_decl decl_context=0x{{[0-9a-z]+}} range=[{{.+}}] "bar"))
case foo(x: MyStruct), bar
}
// CHECK-LABEL: (top_level_code_decl decl_context=0x{{[0-9a-z]+}} range=[{{.+}}]
// CHECK-NEXT: (brace_stmt implicit range=[{{.+}}]
// CHECK-NEXT: (sequence_expr type="<null>"
// CHECK-NEXT: (discard_assignment_expr type="<null>")
// CHECK-NEXT: (assign_expr type="<null>"
// CHECK-NEXT: (<null expr>)
// CHECK-NEXT: (<null expr>))
// CHECK-NEXT: (closure_expr type="<null>" discriminator={{[0-9]+}}
// CHECK-NEXT: (parameter_list range=[{{.+}}]
// CHECK-NEXT: (parameter "v" decl_context=0x{{[0-9a-z]+}}))
// CHECK-NEXT: (brace_stmt range=[{{.+}}])))))
_ = { (v: MyEnum) in }
// CHECK-LABEL: (struct_decl decl_context=0x{{[0-9a-z]+}} range=[{{.+}}] "SelfParam"
struct SelfParam {
// CHECK-LABEL: (func_decl decl_context=0x{{[0-9a-z]+}} range=[{{.+}}] "createOptional()" static
// CHECK-NEXT: (parameter "self" decl_context=0x{{[0-9a-z]+}})
// CHECK-NEXT: (result=type_optional
// CHECK-NEXT: (type_unqualified_ident id="SelfParam" unbound))
// CHECK-NEXT: (parameter_list range=[{{.+}}])
static func createOptional() -> SelfParam? {
// CHECK-LABEL: (call_expr type="<null>"
// CHECK-NEXT: (unresolved_decl_ref_expr type="<null>" name="SelfParam" function_ref=unapplied)
// CHECK-NEXT: (argument_list)
SelfParam()
}
}
// CHECK-LABEL: (func_decl decl_context=0x{{[0-9a-z]+}} range=[{{.+}}] "dumpMemberTypeRepr()"
// CHECK-NEXT: (result=type_qualified_ident id="Element" unbound
// CHECK-NEXT: (type_unqualified_ident id="Array" unbound
// CHECK-NEXT: (type_unqualified_ident id="Bool" unbound))
// CHECK-NEXT: (parameter_list range=[{{.+}}])
func dumpMemberTypeRepr() -> Array<Bool>.Element { true }
|
