| // 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 + 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[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[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) |
| } |
| |
| |
| 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 _() { |
| _ = T{} |
| _ = struct{}{} |
| _ = [10]T{} |
| _ = [...]T{} |
| _ = []T{} |
| _ = map[int]T{} |
| |
| _ = (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}} // compositeLit context not propagated => multiLine result |
| } |
| |
| |
| 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` |
| } |
| |
| |
| func _() { |
| // one-line function literals |
| _ = func() {} |
| _ = func() int { return 0 } |
| _ = func(x, y int) bool { return x < y } |
| |
| f(func() {}) |
| f(func() int { return 0 }) |
| f(func(x, y int) bool { return x < y }) |
| } |
| |
| |
| 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" + // comment |
| "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, |
| ) |
| // TODO(gri) the cases below are not correct yet |
| f(1, |
| 2, |
| 3) // comment |
| f(1, |
| 2, |
| 3, // comment |
| ) |
| f(1, |
| 2, |
| 3) // comment |
| f(1, |
| 2, |
| 3 // comment |
| , |
| ) |
| } |
| |
| |
| 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 |
| } |
| } |
| } |
