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