// 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 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.
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
}


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