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