// 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 statements
var expr bool
func use(x interface{}) {}
// Formatting of multi-line return statements.
func _f() {
return
return x, y, z
return T{}
return T{1, 2, 3},
x, y, z
return T{1, 2, 3},
x, y,
z
return T{1,
2,
3}
return T{1,
2,
3,
}
return T{
1,
2,
3}
return T{
1,
2,
3,
}
return T{
1,
T{1, 2, 3},
3,
}
return T{
1,
T{1,
2, 3},
3,
}
return T{
1,
T{1,
2,
3},
3,
}
return T{
1,
2,
}, nil
return T{
1,
2,
},
T{
x: 3,
y: 4,
}, nil
return T{
1,
2,
},
nil
return T{
1,
2,
},
T{
x: 3,
y: 4,
},
nil
return x + y +
z
return func() {}
return func() {
_ = 0
}, T{
1, 2,
}
return func() {
_ = 0
}
return func() T {
return T {
1, 2,
}
}
}
// Formatting of multi-line returns: test cases from issue 1207.
func F() (*T, os.Error) {
return &T{
X: 1,
Y: 2,
},
nil
}
func G() (*T, *T, os.Error) {
return &T{
X: 1,
Y: 2,
},
&T{
X: 3,
Y: 4,
},
nil
}
func _() interface{} {
return &fileStat{
name: basename(file.name),
size: mkSize(d.FileSizeHigh, d.FileSizeLow),
modTime: mkModTime(d.LastWriteTime),
mode: mkMode(d.FileAttributes),
sys: mkSysFromFI(&d),
}, nil
}
// Formatting of if-statement headers.
func _() {
if true {}
if; true {} // no semicolon printed
if expr{}
if;expr{} // no semicolon printed
if (expr){} // no parens printed
if;((expr)){} // no semicolon and parens printed
if x:=expr;true{
use(x)}
if x:=expr; expr {use(x)}
}
// Formatting of switch-statement headers.
func _() {
switch {}
switch;{} // no semicolon printed
switch expr {}
switch;expr{} // no semicolon printed
switch (expr) {} // no parens printed
switch;((expr)){} // no semicolon and parens printed
switch x := expr; { default:use(
x)
}
switch x := expr; expr {default:use(x)}
}
// Formatting of switch statement bodies.
func _() {
switch {
}
switch x := 0; x {
case 1:
use(x)
use(x) // followed by an empty line
case 2: // followed by an empty line
use(x) // followed by an empty line
case 3: // no empty lines
use(x)
use(x)
}
switch x {
case 0:
use(x)
case 1: // this comment should have no effect on the previous or next line
use(x)
}
switch x := 0; x {
case 1:
x = 0
// this comment should be indented
case 2:
x = 0
// this comment should not be indented, it is aligned with the next case
case 3:
x = 0
/* indented comment
aligned
aligned
*/
// bla
/* and more */
case 4:
x = 0
/* not indented comment
aligned
aligned
*/
// bla
/* and more */
case 5:
}
}
// Formatting of selected select statements.
func _() {
select {
}
select { /* this comment should not be tab-aligned because the closing } is on the same line */ }
select { /* this comment should be tab-aligned */
}
select { // this comment should be tab-aligned
}
select { case <-c: }
}
// Formatting of for-statement headers for single-line for-loops.
func _() {
for{}
for expr {}
for (expr) {} // no parens printed
for;;{} // no semicolons printed
for x :=expr;; {use( x)}
for; expr;{} // no semicolons printed
for; ((expr));{} // no semicolons and parens printed
for; ; expr = false {}
for x :=expr; expr; {use(x)}
for x := expr;; expr=false {use(x)}
for;expr;expr =false {}
for x := expr;expr;expr = false { use(x) }
for x := range []int{} { use(x) }
for x := range (([]int{})) { use(x) } // no parens printed
}
// Formatting of for-statement headers for multi-line for-loops.
func _() {
for{
}
for expr {
}
for (expr) {
} // no parens printed
for;;{
} // no semicolons printed
for x :=expr;; {use( x)
}
for; expr;{
} // no semicolons printed
for; ((expr));{
} // no semicolons and parens printed
for; ; expr = false {
}
for x :=expr; expr; {use(x)
}
for x := expr;; expr=false {use(x)
}
for;expr;expr =false {
}
for x := expr;expr;expr = false {
use(x)
}
for range []int{} {
println("foo")}
for x := range []int{} {
use(x) }
for x := range (([]int{})) {
use(x) } // no parens printed
}
// Formatting of selected short single- and multi-line statements.
func _() {
if cond {}
if cond {
} // multiple lines
if cond {} else {} // else clause always requires multiple lines
for {}
for i := 0; i < len(a); 1++ {}
for i := 0; i < len(a); 1++ { a[i] = i }
for i := 0; i < len(a); 1++ { a[i] = i
} // multiple lines
for range a{}
for _ = range a{}
for _, _ = range a{}
for i := range a {}
for i := range a { a[i] = i }
for i := range a { a[i] = i
} // multiple lines
go func() { for { a <- <-b } }()
defer func() { if x := recover(); x != nil { err = fmt.Sprintf("error: %s", x.msg) } }()
}
// Don't remove mandatory parentheses around composite literals in control clauses.
func _() {
// strip parentheses - no composite literals or composite literals don't start with a type name
if (x) {}
if (((x))) {}
if ([]T{}) {}
if (([]T{})) {}
if ; (((([]T{})))) {}
for (x) {}
for (((x))) {}
for ([]T{}) {}
for (([]T{})) {}
for ; (((([]T{})))) ; {}
switch (x) {}
switch (((x))) {}
switch ([]T{}) {}
switch ; (((([]T{})))) {}
for _ = range ((([]T{T{42}}))) {}
// leave parentheses - composite literals start with a type name
if (T{}) {}
if ((T{})) {}
if ; ((((T{})))) {}
for (T{}) {}
for ((T{})) {}
for ; ((((T{})))) ; {}
switch (T{}) {}
switch ; ((((T{})))) {}
for _ = range (((T1{T{42}}))) {}
if x == (T{42}[0]) {}
if (x == T{42}[0]) {}
if (x == (T{42}[0])) {}
if (x == (((T{42}[0])))) {}
if (((x == (T{42}[0])))) {}
if x == a + b*(T{42}[0]) {}
if (x == a + b*T{42}[0]) {}
if (x == a + b*(T{42}[0])) {}
if (x == a + ((b * (T{42}[0])))) {}
if (((x == a + b * (T{42}[0])))) {}
if (((a + b * (T{42}[0])) == x)) {}
if (((a + b * (T{42}[0])))) == x {}
if (struct{x bool}{false}.x) {}
if (struct{x bool}{false}.x) == false {}
if (struct{x bool}{false}.x == false) {}
}
// Extra empty lines inside functions. Do respect source code line
// breaks between statement boundaries but print at most one empty
// line at a time.
func _() {
const _ = 0
const _ = 1
type _ int
type _ float
var _ = 0
var x = 1
// Each use(x) call below should have at most one empty line before and after.
// Known bug: The first use call may have more than one empty line before
// (see go/printer/nodes.go, func linebreak).
use(x)
if x < x {
use(x)
} else {
use(x)
}
}
// Formatting around labels.
func _() {
L:
}
func _() {
// this comment should be indented
L: ; // no semicolon needed
}
func _() {
switch 0 {
case 0:
L0: ; // semicolon required
case 1:
L1: ; // semicolon required
default:
L2: ; // no semicolon needed
}
}
func _() {
f()
L1:
f()
L2:
;
L3:
}
func _() {
// this comment should be indented
L:
}
func _() {
L: _ = 0
}
func _() {
// this comment should be indented
L: _ = 0
}
func _() {
for {
L1: _ = 0
L2:
_ = 0
}
}
func _() {
// this comment should be indented
for {
L1: _ = 0
L2:
_ = 0
}
}
func _() {
if true {
_ = 0
}
_ = 0 // the indentation here should not be affected by the long label name
AnOverlongLabel:
_ = 0
if true {
_ = 0
}
_ = 0
L: _ = 0
}
func _() {
for {
goto L
}
L:
MoreCode()
}
func _() {
for {
goto L
}
L: // A comment on the same line as the label, followed by a single empty line.
// Known bug: There may be more than one empty line before MoreCode()
// (see go/printer/nodes.go, func linebreak).
MoreCode()
}
func _() {
for {
goto L
}
L:
// There should be a single empty line before this comment.
MoreCode()
}
func _() {
for {
goto AVeryLongLabelThatShouldNotAffectFormatting
}
AVeryLongLabelThatShouldNotAffectFormatting:
// There should be a single empty line after this comment.
// There should be a single empty line before this comment.
MoreCode()
}
// Formatting of empty statements.
func _() {
;;;;;;;;;;;;;;;;;;;;;;;;;
}
func _() {;;;;;;;;;;;;;;;;;;;;;;;;;
}
func _() {;;;;;;;;;;;;;;;;;;;;;;;;;}
func _() {
f();;;;;;;;;;;;;;;;;;;;;;;;;
}
func _() {
L:;;;;;;;;;;;;
}
func _() {
L:;;;;;;;;;;;;
f()
}