github.com/AndrienkoAleksandr/go@v0.0.19/src/go/printer/testdata/statements.golden

// 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()
}