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
|
// RUN: %target-typecheck-verify-swift -parse-stdlib
// This disables importing the stdlib intentionally.
infix operator == : Equal
precedencegroup Equal {
associativity: left
higherThan: FatArrow
}
infix operator & : BitAnd
precedencegroup BitAnd {
associativity: left
higherThan: Equal
}
infix operator => : FatArrow
precedencegroup FatArrow {
associativity: right
higherThan: AssignmentPrecedence
}
precedencegroup AssignmentPrecedence {
assignment: true
}
precedencegroup DefaultPrecedence {}
struct Man {}
struct TheDevil {}
struct God {}
struct Five {}
struct Six {}
struct Seven {}
struct ManIsFive {}
struct TheDevilIsSix {}
struct GodIsSeven {}
struct TheDevilIsSixThenGodIsSeven {}
func == (x: Man, y: Five) -> ManIsFive {}
func == (x: TheDevil, y: Six) -> TheDevilIsSix {}
func == (x: God, y: Seven) -> GodIsSeven {}
func => (x: TheDevilIsSix, y: GodIsSeven) -> TheDevilIsSixThenGodIsSeven {}
func => (x: ManIsFive, y: TheDevilIsSixThenGodIsSeven) {}
func test1() {
Man() == Five() => TheDevil() == Six() => God() == Seven()
}
postfix operator *!*
prefix operator *!*
struct LOOK {}
struct LOOKBang {
func exclaim() {}
}
postfix func *!* (x: LOOK) -> LOOKBang {}
prefix func *!* (x: LOOKBang) {}
func test2() {
*!*LOOK()*!*
}
// This should be parsed as (x*!*).exclaim()
LOOK()*!*.exclaim()
prefix operator ^
infix operator ^
postfix operator ^
postfix func ^ (x: God) -> TheDevil {}
prefix func ^ (x: TheDevil) -> God {}
func ^ (x: TheDevil, y: God) -> Man {}
var _ : TheDevil = God()^
var _ : God = ^TheDevil()
var _ : Man = TheDevil() ^ God()
var _ : Man = God()^ ^ ^TheDevil()
let _ = God()^TheDevil() // expected-error{{operator argument #2 must precede operator argument #1}} {{9-9=TheDevil() ^ }} {{14-25=}}
let _ = God() ^ TheDevil() // expected-error{{operator argument #2 must precede operator argument #1}} {{9-9=TheDevil() ^ }} {{14-27=}}
postfix func ^ (x: Man) -> () -> God {
return { return God() }
}
var _ : God = Man()^() // expected-error{{cannot convert value of type 'Man' to expected argument type 'TheDevil'}}
// expected-error@-1 {{cannot convert value of type '()' to expected argument type 'God'}}
// expected-error@-2 {{cannot convert value of type 'Man' to specified type 'God'}}
func &(x : Man, y : Man) -> Man { return x } // forgive amp_prefix token
prefix operator ⚽️
prefix func ⚽️(x: Man) { }
infix operator ?? : OptTest
precedencegroup OptTest {
associativity: right
}
func ??(x: Man, y: TheDevil) -> TheDevil {
return y
}
func test3(a: Man, b: Man, c: TheDevil) -> TheDevil {
return a ?? b ?? c
}
// <rdar://problem/17821399> We don't parse infix operators bound on both
// sides that begin with ! or ? correctly yet.
infix operator !!
func !!(x: Man, y: Man) {}
let foo = Man()
let bar = TheDevil()
foo!!foo
// expected-error@-1 {{cannot force unwrap value of non-optional type 'Man'}} {{4-5=}}
// expected-error@-2 {{cannot force unwrap value of non-optional type 'Man'}} {{5-6=}}
// expected-error@-3 {{consecutive statements}} {{6-6=;}}
// expected-warning@-4 {{expression of type 'Man' is unused}}
foo??bar // expected-error{{broken standard library}} expected-error{{consecutive statements}} {{6-6=;}}
// expected-warning @-1 {{expression of type 'TheDevil' is unused}}
|
