blob: d9060621ced5f55cb78c650924aca71344e301b6 [file] [log] [blame]
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package expressions
type T struct {
x, y, z int
}
var (
a, b, c, d, e int
under_bar int
longIdentifier1, longIdentifier2, longIdentifier3 int
t0, t1, t2 T
s string
p *int
)
func _() {
// no spaces around simple or parenthesized expressions
_ = (a + 0)
_ = a + b
_ = a + b + c
_ = a + b - c
_ = a - b - c
_ = a + (b * c)
_ = a + (b / c)
_ = a - (b % c)
_ = 1 + a
_ = a + 1
_ = a + b + 1
_ = s[a]
_ = s[a:]
_ = s[:b]
_ = s[1:2]
_ = s[a:b]
_ = s[0:len(s)]
_ = s[0] << 1
_ = (s[0] << 1) & 0xf
_ = s[0]<<2 | s[1]>>4
_ = "foo" + s
_ = s + "foo"
_ = 'a' + 'b'
_ = len(s) / 2
_ = len(t0.x) / a
// spaces around expressions of different precedence or expressions containing spaces
_ = a + -b
_ = a - ^b
_ = a / *p
_ = a + b*c
_ = 1 + b*c
_ = a + 2*c
_ = a + c*2
_ = 1 + 2*3
_ = s[1 : 2*3]
_ = s[a : b-c]
_ = s[0:]
_ = s[a+b]
_ = s[:b-c]
_ = s[a+b:]
_ = a[a<<b+1]
_ = a[a<<b+1:]
_ = s[a+b : len(s)]
_ = s[len(s):-a]
_ = s[a : len(s)+1]
_ = s[a:len(s)+1] + s
// spaces around operators with equal or lower precedence than comparisons
_ = a == b
_ = a != b
_ = a > b
_ = a >= b
_ = a < b
_ = a <= b
_ = a < b && c > d
_ = a < b || c > d
// spaces around "long" operands
_ = a + longIdentifier1
_ = longIdentifier1 + a
_ = longIdentifier1 + longIdentifier2*longIdentifier3
_ = s + "a longer string"
// some selected cases
_ = a + t0.x
_ = a + t0.x + t1.x*t2.x
_ = a + b + c + d + e + 2*3
_ = a + b + c + 2*3 + d + e
_ = (a + b + c) * 2
_ = a - b + c - d + (a + b + c) + d&e
_ = under_bar - 1
_ = Open(dpath+"/file", O_WRONLY|O_CREAT, 0666)
_ = int(c0&_Mask4)<<18 | int(c1&_Maskx)<<12 | int(c2&_Maskx)<<6 | int(c3&_Maskx)
// test case for issue 8021
// want:
// ([]bool{})[([]int{})[((1)+(((1)+((((1)*(((1)+(1))+(1)))+(1))*(1)))+(1)))]]
_ = ([]bool{})[([]int{})[((1)+(((1)+((((1)*(((1)+(1))+(1)))+(1))*(1)))+(1)))]]
// the parser does not restrict expressions that may appear as statements
true
42
"foo"
x
(x)
a + b
a + b + c
a + (b * c)
a + (b / c)
1 + a
a + 1
s[a]
x << 1
(s[0] << 1) & 0xf
"foo" + s
x == y
x < y || z > 42
}
// slice expressions with cap
func _() {
_ = x[a:b:c]
_ = x[a:b : c+d]
_ = x[a : b+d : c]
_ = x[a : b+d : c+d]
_ = x[a+d : b:c]
_ = x[a+d : b : c+d]
_ = x[a+d : b+d : c]
_ = x[a+d : b+d : c+d]
_ = x[:b:c]
_ = x[:b : c+d]
_ = x[:b+d : c]
_ = x[:b+d : c+d]
}
func _() {
_ = a + b
_ = a + b + c
_ = a + b*c
_ = a + (b * c)
_ = (a + b) * c
_ = a + (b * c * d)
_ = a + (b*c + d)
_ = 1 << x
_ = -1 << x
_ = 1<<x - 1
_ = -1<<x - 1
_ = f(a + b)
_ = f(a + b + c)
_ = f(a + b*c)
_ = f(a + (b * c))
_ = f(1<<x-1, 1<<x-2)
_ = 1<<d.logWindowSize - 1
buf = make(x, 2*cap(b.buf)+n)
dst[i*3+2] = dbuf[0] << 2
dst[i*3+2] = dbuf[0]<<2 | dbuf[1]>>4
b.buf = b.buf[0 : b.off+m+n]
b.buf = b.buf[0 : b.off+m*n]
f(b.buf[0 : b.off+m+n])
signed += ' ' * 8
tw.octal(header[148:155], chksum)
_ = x > 0 && i >= 0
x1, x0 := x>>w2, x&m2
z0 = t1<<w2 + t0
z1 = (t1 + t0>>w2) >> w2
q1, r1 := x1/d1, x1%d1
r1 = r1*b2 | x0>>w2
x1 = (x1 << z) | (x0 >> (uint(w) - z))
x1 = x1<<z | x0>>(uint(w)-z)
_ = buf[0 : len(buf)+1]
_ = buf[0 : n+1]
a, b = b, a
a = b + c
a = b*c + d
_ = a*b + c
_ = a - b - c
_ = a - (b - c)
_ = a - b*c
_ = a - (b * c)
_ = a * b / c
_ = a / *b
_ = x[a|^b]
_ = x[a / *b]
_ = a & ^b
_ = a + +b
_ = a - -b
_ = x[a*-b]
_ = x[a + +b]
_ = x ^ y ^ z
_ = b[a>>24] ^ b[(a>>16)&0xFF] ^ b[(a>>8)&0xFF] ^ b[a&0xFF]
_ = len(longVariableName) * 2
_ = token(matchType + xlength<<lengthShift + xoffset)
}
func f(x int, args ...int) {
f(0, args...)
f(1, args)
f(2, args[0])
// make sure syntactically legal code remains syntactically legal
f(3, 42 ...) // a blank must remain between 42 and ...
f(4, 42....)
f(5, 42....)
f(6, 42.0...)
f(7, 42.0...)
f(8, .42...)
f(9, .42...)
f(10, 42e0...)
f(11, 42e0...)
_ = 42 .x // a blank must remain between 42 and .x
_ = 42..x
_ = 42..x
_ = 42.0.x
_ = 42.0.x
_ = .42.x
_ = .42.x
_ = 42e0.x
_ = 42e0.x
// a blank must remain between the binary operator and the 2nd operand
_ = x / *y
_ = x < -1
_ = x < <-1
_ = x + +1
_ = x - -1
_ = x & &x
_ = x & ^x
_ = f(x / *y, x < -1, x < <-1, x + +1, x - -1, x & &x, x & ^x)
}
func _() {
_ = T{}
_ = struct{}{}
_ = [10]T{}
_ = [...]T{}
_ = []T{}
_ = map[int]T{}
}
// one-line structs/interfaces in composite literals (up to a threshold)
func _() {
_ = struct{}{}
_ = struct{ x int }{0}
_ = struct{ x, y, z int }{0, 1, 2}
_ = struct{ int }{0}
_ = struct{ s struct{ int } }{struct{ int }{0}}
}
func _() {
// do not modify literals
_ = "tab1 tab2 tab3 end" // string contains 3 tabs
_ = "tab1 tab2 tab3 end" // same string with 3 blanks - may be unaligned because editors see tabs in strings
_ = "" // this comment should be aligned with the one on the previous line
_ = ``
_ = `
`
_ = `foo
bar`
_ = `three spaces before the end of the line starting here:
they must not be removed`
}
func _() {
// smart handling of indentation for multi-line raw strings
var _ = ``
var _ = `foo`
var _ = `foo
bar`
var _ = ``
var _ = `foo`
var _ =
// the next line should remain indented
`foo
bar`
var _ = // comment
``
var _ = // comment
`foo`
var _ = // comment
// the next line should remain indented
`foo
bar`
var _ = /* comment */ ``
var _ = /* comment */ `foo`
var _ = /* comment */ `foo
bar`
var _ = /* comment */
``
var _ = /* comment */
`foo`
var _ = /* comment */
// the next line should remain indented
`foo
bar`
var board = []int(
`...........
...........
....●●●....
....●●●....
..●●●●●●●..
..●●●○●●●..
..●●●●●●●..
....●●●....
....●●●....
...........
...........
`)
var state = S{
"foo",
// the next line should remain indented
`...........
...........
....●●●....
....●●●....
..●●●●●●●..
..●●●○●●●..
..●●●●●●●..
....●●●....
....●●●....
...........
...........
`,
"bar",
}
}
func _() {
// one-line function literals (body is on a single line)
_ = func() {}
_ = func() int { return 0 }
_ = func(x, y int) bool { m := (x + y) / 2; return m < 0 }
// multi-line function literals (body is not on one line)
_ = func() {
}
_ = func() int {
return 0
}
_ = func(x, y int) bool {
m := (x + y) / 2
return x < y
}
f(func() {
})
f(func() int {
return 0
})
f(func(x, y int) bool {
m := (x + y) / 2
return x < y
})
}
func _() {
_ = [][]int{
[]int{1},
[]int{1, 2},
[]int{1, 2, 3},
}
_ = [][]int{
{1},
[]int{1, 2},
[]int{1, 2, 3},
}
_ = [][]int{
{1},
{1, 2},
{1, 2, 3},
}
_ = [][]int{{1}, {1, 2}, {1, 2, 3}}
}
// various multi-line expressions
func _() {
// do not add extra indentation to multi-line string lists
_ = "foo" + "bar"
_ = "foo" +
"bar" +
"bah"
_ = []string{
"abc" +
"def",
"foo" +
"bar",
}
}
const _ = F1 +
`string = "%s";` +
`ptr = *;` +
`datafmt.T2 = s ["-" p "-"];`
const _ = `datafmt "datafmt";` +
`default = "%v";` +
`array = *;` +
`datafmt.T3 = s {" " a a / ","};`
const _ = `datafmt "datafmt";` +
`default = "%v";` +
`array = *;` +
`datafmt.T3 = s {" " a a / ","};`
func _() {
_ = F1 +
`string = "%s";` +
`ptr = *;` +
`datafmt.T2 = s ["-" p "-"];`
_ =
`datafmt "datafmt";` +
`default = "%v";` +
`array = *;` +
`datafmt.T3 = s {" " a a / ","};`
_ = `datafmt "datafmt";` +
`default = "%v";` +
`array = *;` +
`datafmt.T3 = s {" " a a / ","};`
}
func _() {
// respect source lines in multi-line expressions
_ = a +
b +
c
_ = a < b ||
b < a
_ = "933262154439441526816992388562667004907159682643816214685929" +
"638952175999932299156089414639761565182862536979208272237582" +
"51185210916864000000000000000000000000" // 100!
_ = "170141183460469231731687303715884105727" // prime
}
// Alignment after overlong lines
const (
_ = "991"
_ = "2432902008176640000" // 20!
_ = "933262154439441526816992388562667004907159682643816214685929" +
"638952175999932299156089414639761565182862536979208272237582" +
"51185210916864000000000000000000000000" // 100!
_ = "170141183460469231731687303715884105727" // prime
)
// Correct placement of operators and comments in multi-line expressions
func _() {
_ = a + // comment
b + // comment
c
_ = "a" +
"b" + // comment
"c"
_ = "ba0408" + "7265717569726564" // field 71, encoding 2, string "required"
}
// Correct placement of terminating comma/closing parentheses in multi-line calls.
func _() {
f(1,
2,
3)
f(1,
2,
3,
)
f(1,
2,
3) // comment
f(1,
2,
3, // comment
)
f(1,
2,
3) // comment
f(1,
2,
3, // comment
)
}
// Align comments in multi-line lists of single-line expressions.
var txpix = [NCOL]draw.Color{
draw.Yellow, // yellow
draw.Cyan, // cyan
draw.Green, // lime green
draw.GreyBlue, // slate
draw.Red, /* red */
draw.GreyGreen, /* olive green */
draw.Blue, /* blue */
draw.Color(0xFF55AAFF), /* pink */
draw.Color(0xFFAAFFFF), /* lavender */
draw.Color(0xBB005DFF), /* maroon */
}
func same(t, u *Time) bool {
// respect source lines in multi-line expressions
return t.Year == u.Year &&
t.Month == u.Month &&
t.Day == u.Day &&
t.Hour == u.Hour &&
t.Minute == u.Minute &&
t.Second == u.Second &&
t.Weekday == u.Weekday &&
t.ZoneOffset == u.ZoneOffset &&
t.Zone == u.Zone
}
func (p *parser) charClass() {
// respect source lines in multi-line expressions
if cc.negate && len(cc.ranges) == 2 &&
cc.ranges[0] == '\n' && cc.ranges[1] == '\n' {
nl := new(_NotNl)
p.re.add(nl)
}
}
func addState(s []state, inst instr, match []int) {
// handle comments correctly in multi-line expressions
for i := 0; i < l; i++ {
if s[i].inst.index() == index && // same instruction
s[i].match[0] < pos { // earlier match already going; leftmost wins
return s
}
}
}
func (self *T) foo(x int) *T { return self }
func _() { module.Func1().Func2() }
func _() {
_ = new(T).
foo(1).
foo(2).
foo(3)
_ = new(T).
foo(1).
foo(2). // inline comments
foo(3)
_ = new(T).foo(1).foo(2).foo(3)
// handle multiline argument list correctly
_ = new(T).
foo(
1).
foo(2)
_ = new(T).foo(
1).foo(2)
_ = Array[3+
4]
_ = Method(1, 2,
3)
_ = new(T).
foo().
bar().(*Type)
_ = new(T).
foo().
bar().(*Type).
baz()
_ = new(T).
foo().
bar()["idx"]
_ = new(T).
foo().
bar()["idx"].
baz()
_ = new(T).
foo().
bar()[1:2]
_ = new(T).
foo().
bar()[1:2].
baz()
_ = new(T).
Field.
Array[3+
4].
Table["foo"].
Blob.(*Type).
Slices[1:4].
Method(1, 2,
3).
Thingy
_ = a.b.c
_ = a.
b.
c
_ = a.b().c
_ = a.
b().
c
_ = a.b[0].c
_ = a.
b[0].
c
_ = a.b[0:].c
_ = a.
b[0:].
c
_ = a.b.(T).c
_ = a.
b.(T).
c
}
// Don't introduce extra newlines in strangely formatted expression lists.
func f() {
// os.Open parameters should remain on two lines
if writer, err = os.Open(outfile, s.O_WRONLY|os.O_CREATE|
os.O_TRUNC, 0666); err != nil {
log.Fatal(err)
}
}
// Handle multi-line argument lists ending in ... correctly.
// Was issue 3130.
func _() {
_ = append(s, a...)
_ = append(
s, a...)
_ = append(s,
a...)
_ = append(
s,
a...)
_ = append(s, a...,
)
_ = append(s,
a...,
)
_ = append(
s,
a...,
)
}
// Literal function types in conversions must be parenthesized;
// for now go/parser accepts the unparenthesized form where it
// is non-ambiguous.
func _() {
// these conversions should be rewritten to look
// the same as the parenthesized conversions below
_ = (func())(nil)
_ = (func(x int) float)(nil)
_ = (func() func() func())(nil)
_ = (func())(nil)
_ = (func(x int) float)(nil)
_ = (func() func() func())(nil)
}
func _() {
_ = f().
f(func() {
f()
}).
f(map[int]int{
1: 2,
3: 4,
})
_ = f().
f(
func() {
f()
},
)
}