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