now printed using the semicolon-free style.
Removed NoSemis flag and mechanism dealing with
optional semicolons from go/printer.
Updated all go/printer output files using the
semi-colon free style.
Changes have no formatting impact on checked in
go code under src and misc.
R=rsc, r
CC=golang-dev
https://golang.org/cl/184068
// Write an AST-node to w; optionally html-escaped.
func writeNode(w io.Writer, node interface{}, html bool, styler printer.Styler) {
- mode := printer.TabIndent | printer.UseSpaces | printer.NoSemis
+ mode := printer.TabIndent | printer.UseSpaces
if html {
mode |= printer.GenHTML
}
useSpaces = flag.Bool("spaces", true, "align with spaces instead of tabs")
// semicolon transition
- useOldParser = flag.Bool("oldparser", false, "parse old syntax (required semicolons)")
- useOldPrinter = flag.Bool("oldprinter", false, "print old syntax (required semicolons)")
+ useOldParser = flag.Bool("oldparser", false, "parse old syntax (required semicolons)")
)
if *useSpaces {
printerMode |= printer.UseSpaces
}
- if !*useOldPrinter {
- printerMode |= printer.NoSemis
- }
}
}
-// Returns true if a separating semicolon is optional.
// Sets multiLine to true if the signature spans multiple lines.
-func (p *printer) signature(params, result []*ast.Field, multiLine *bool) (optSemi bool) {
+func (p *printer) signature(params, result []*ast.Field, multiLine *bool) {
p.parameters(params, multiLine)
if result != nil {
p.print(blank)
// single anonymous result; no ()'s unless it's a function type
f := result[0]
if _, isFtyp := f.Type.(*ast.FuncType); !isFtyp {
- optSemi = p.expr(f.Type, multiLine)
+ p.expr(f.Type, multiLine)
return
}
}
p.expr(&ast.StringList{f.Tag}, &ml)
extraTabs = 0
}
- if p.Mode&NoSemis == 0 {
- p.print(token.SEMICOLON)
- }
if f.Comment != nil {
for ; extraTabs > 0; extraTabs-- {
p.print(vtab)
// embedded interface
p.expr(f.Type, &ml)
}
- if p.Mode&NoSemis == 0 {
- p.print(token.SEMICOLON)
- }
p.lineComment(f.Comment)
}
if isIncomplete {
}
-// Returns true if a separating semicolon is optional.
// Sets multiLine to true if the expression spans multiple lines.
-func (p *printer) expr1(expr ast.Expr, prec1, depth int, ctxt exprContext, multiLine *bool) (optSemi bool) {
+func (p *printer) expr1(expr ast.Expr, prec1, depth int, ctxt exprContext, multiLine *bool) {
p.print(expr.Pos())
switch x := expr.(type) {
// parenthesis needed
p.print(token.LPAREN)
p.print(token.MUL)
- optSemi = p.expr(x.X, multiLine)
+ p.expr(x.X, multiLine)
p.print(token.RPAREN)
} else {
// no parenthesis needed
p.print(token.MUL)
- optSemi = p.expr(x.X, multiLine)
+ p.expr(x.X, multiLine)
}
case *ast.UnaryExpr:
}
p.expr1(x.Fun, token.HighestPrec, depth, 0, multiLine)
p.print(x.Lparen, token.LPAREN)
- mode := commaSep
- if p.Mode&NoSemis != 0 {
- mode |= commaTerm
- }
- p.exprList(x.Lparen, x.Args, depth, mode, multiLine, x.Rparen)
+ p.exprList(x.Lparen, x.Args, depth, commaSep|commaTerm, multiLine, x.Rparen)
p.print(x.Rparen, token.RPAREN)
case *ast.CompositeLit:
p.expr(x.Len, multiLine)
}
p.print(token.RBRACK)
- optSemi = p.expr(x.Elt, multiLine)
+ p.expr(x.Elt, multiLine)
case *ast.StructType:
p.print(token.STRUCT)
p.fieldList(x.Lbrace, x.Fields, x.Rbrace, x.Incomplete, ctxt|structType)
- optSemi = true
case *ast.FuncType:
p.print(token.FUNC)
- optSemi = p.signature(x.Params, x.Results, multiLine)
+ p.signature(x.Params, x.Results, multiLine)
case *ast.InterfaceType:
p.print(token.INTERFACE)
p.fieldList(x.Lbrace, x.Methods, x.Rbrace, x.Incomplete, ctxt)
- optSemi = true
case *ast.MapType:
p.print(token.MAP, token.LBRACK)
p.expr(x.Key, multiLine)
p.print(token.RBRACK)
- optSemi = p.expr(x.Value, multiLine)
+ p.expr(x.Value, multiLine)
case *ast.ChanType:
switch x.Dir {
p.print(token.CHAN, token.ARROW)
}
p.print(blank)
- optSemi = p.expr(x.Value, multiLine)
+ p.expr(x.Value, multiLine)
default:
panic("unreachable")
}
-func (p *printer) expr0(x ast.Expr, depth int, multiLine *bool) (optSemi bool) {
- return p.expr1(x, token.LowestPrec, depth, 0, multiLine)
+func (p *printer) expr0(x ast.Expr, depth int, multiLine *bool) {
+ p.expr1(x, token.LowestPrec, depth, 0, multiLine)
}
-// Returns true if a separating semicolon is optional.
// Sets multiLine to true if the expression spans multiple lines.
-func (p *printer) expr(x ast.Expr, multiLine *bool) (optSemi bool) {
+func (p *printer) expr(x ast.Expr, multiLine *bool) {
const depth = 1
- return p.expr1(x, token.LowestPrec, depth, 0, multiLine)
+ p.expr1(x, token.LowestPrec, depth, 0, multiLine)
}
// in those cases each clause is a new section
p.linebreak(s.Pos().Line, 1, maxStmtNewlines, ignore, i == 0 || _indent == 0 || multiLine)
multiLine = false
- if !p.stmt(s, &multiLine) && len(list) > 1 && p.Mode&NoSemis == 0 {
- p.print(token.SEMICOLON)
- }
+ p.stmt(s, &multiLine)
}
if _indent > 0 {
p.print(unindent)
}
-// Returns true if a separating semicolon is optional.
// Sets multiLine to true if the statements spans multiple lines.
-func (p *printer) stmt(stmt ast.Stmt, multiLine *bool) (optSemi bool) {
+func (p *printer) stmt(stmt ast.Stmt, multiLine *bool) {
p.print(stmt.Pos())
switch s := stmt.(type) {
case *ast.DeclStmt:
p.decl(s.Decl, inStmtList, multiLine)
- optSemi = true // decl prints terminating semicolon if necessary
case *ast.EmptyStmt:
// nothing to do
p.expr(s.Label, multiLine)
p.print(token.COLON, vtab, indent)
p.linebreak(s.Stmt.Pos().Line, 0, 1, ignore, true)
- optSemi = p.stmt(s.Stmt, multiLine)
+ p.stmt(s.Stmt, multiLine)
case *ast.ExprStmt:
const depth = 1
case *ast.BlockStmt:
p.block(s, 1, false)
*multiLine = true
- optSemi = true
case *ast.IfStmt:
p.print(token.IF)
p.controlClause(false, s.Init, s.Cond, nil)
p.block(s.Body, 1, true)
*multiLine = true
- optSemi = true
if s.Else != nil {
p.print(blank, token.ELSE, blank)
switch s.Else.(type) {
case *ast.BlockStmt, *ast.IfStmt:
- optSemi = p.stmt(s.Else, ignoreMultiLine)
+ p.stmt(s.Else, ignoreMultiLine)
default:
p.print(token.LBRACE, indent, formfeed)
p.stmt(s.Else, ignoreMultiLine)
}
p.print(s.Colon, token.COLON)
p.stmtList(s.Body, 1)
- optSemi = true // "block" without {}'s
case *ast.SwitchStmt:
p.print(token.SWITCH)
p.controlClause(false, s.Init, s.Tag, nil)
p.block(s.Body, 0, true)
*multiLine = true
- optSemi = true
case *ast.TypeCaseClause:
if s.Types != nil {
}
p.print(s.Colon, token.COLON)
p.stmtList(s.Body, 1)
- optSemi = true // "block" without {}'s
case *ast.TypeSwitchStmt:
p.print(token.SWITCH)
p.print(blank)
p.block(s.Body, 0, true)
*multiLine = true
- optSemi = true
case *ast.CommClause:
if s.Rhs != nil {
}
p.print(s.Colon, token.COLON)
p.stmtList(s.Body, 1)
- optSemi = true // "block" without {}'s
case *ast.SelectStmt:
p.print(token.SELECT, blank)
p.block(s.Body, 0, false)
*multiLine = true
- optSemi = true
case *ast.ForStmt:
p.print(token.FOR)
p.controlClause(true, s.Init, s.Cond, s.Post)
p.block(s.Body, 1, true)
*multiLine = true
- optSemi = true
case *ast.RangeStmt:
p.print(token.FOR, blank)
p.print(blank)
p.block(s.Body, 1, true)
*multiLine = true
- optSemi = true
default:
panic("unreachable")
//
func (p *printer) spec(spec ast.Spec, n int, context declContext, multiLine *bool) {
var (
- optSemi bool // true if a semicolon is optional
comment *ast.CommentGroup // a line comment, if any
extraTabs int // number of extra tabs before comment, if any
)
if n == 1 {
if s.Type != nil {
p.print(blank)
- optSemi = p.expr(s.Type, multiLine)
+ p.expr(s.Type, multiLine)
}
if s.Values != nil {
p.print(blank, token.ASSIGN)
p.exprList(noPos, s.Values, 1, blankStart|commaSep, multiLine, noPos)
- optSemi = false
}
} else {
extraTabs = 2
p.print(vtab)
}
if s.Type != nil {
- optSemi = p.expr(s.Type, multiLine)
+ p.expr(s.Type, multiLine)
extraTabs = 1
}
if s.Values != nil {
p.print(vtab)
p.print(token.ASSIGN)
p.exprList(noPos, s.Values, 1, blankStart|commaSep, multiLine, noPos)
- optSemi = false
extraTabs = 0
}
}
} else {
p.print(vtab)
}
- optSemi = p.expr(s.Type, multiLine)
+ p.expr(s.Type, multiLine)
comment = s.Comment
default:
panic("unreachable")
}
- if (context == inGroup || context == inStmtList && !optSemi) && p.Mode&NoSemis == 0 {
- p.print(token.SEMICOLON)
- }
-
if comment != nil {
for ; extraTabs > 0; extraTabs-- {
p.print(vtab)
RawFormat // do not use a tabwriter; if set, UseSpaces is ignored
TabIndent // use tabs for indentation independent of UseSpaces
UseSpaces // use spaces instead of tabs for alignment
- NoSemis // don't print semicolons at the end of a line
)
const c0 = 0 // zero
const (
- c1 = iota; // c1
- c2; // c2
+ c1 = iota // c1
+ c2 // c2
)
// The S0 struct; no field is exported.
type S0 struct {
- int;
- x, y, z int; // 3 unexported fields
+ int
+ x, y, z int // 3 unexported fields
}
// The S1 struct; some fields are not exported.
type S1 struct {
- S0;
- A, B, C float; // 3 exported fields
- D, b, c int; // 2 unexported fields
+ S0
+ A, B, C float // 3 exported fields
+ D, b, c int // 2 unexported fields
}
// The S2 struct; all fields are exported.
type S2 struct {
- S1;
- A, B, C float; // 3 exported fields
+ S1
+ A, B, C float // 3 exported fields
}
// The IZ interface; it is empty.
// The I0 interface; no method is exported.
type I0 interface {
- f(x int) int; // unexported method
+ f(x int) int // unexported method
}
// The I1 interface; some methods are not exported.
type I1 interface {
- I0;
- F(x float) float; // exported methods
- g(x int) int; // unexported method
+ I0
+ F(x float) float // exported methods
+ g(x int) int // unexported method
}
// The I2 interface; all methods are exported.
type I2 interface {
- I0;
- F(x float) float; // exported method
- G(x float) float; // exported method
+ I0
+ F(x float) float // exported method
+ G(x float) float // exported method
}
// This comment group should be separated
// This comment SHOULD be associated with the next declaration.
func f0() {
- const pi = 3.14; // pi
- var s1 struct{} /* an empty struct */ /* foo */
+ const pi = 3.14 // pi
+ var s1 struct{} /* an empty struct */ /* foo */
// a struct constructor
// --------------------
- var s2 struct{} = struct{}{};
- x := pi;
+ var s2 struct{} = struct{}{}
+ x := pi
}
//
// NO SPACE HERE
//
func f1() {
- f0();
+ f0()
/* 1 */
// 2
/* 3 */
/* 4 */
- f0();
+ f0()
}
if x < 0 { // the tab printed before this comment's // must not affect the remaining lines
return -x // this statement should be properly indented
}
- return x;
+ return x
}
// Line comments with tabs
func _() {
- var finput *bufio.Reader; // input file
- var stderr *bufio.Writer;
- var ftable *bufio.Writer; // y.go file
- var foutput *bufio.Writer; // y.output file
-
- var oflag string; // -o [y.go] - y.go file
- var vflag string; // -v [y.output] - y.output file
- var lflag bool; // -l - disable line directives
+ var finput *bufio.Reader // input file
+ var stderr *bufio.Writer
+ var ftable *bufio.Writer // y.go file
+ var foutput *bufio.Writer // y.output file
+
+ var oflag string // -o [y.go] - y.go file
+ var vflag string // -v [y.output] - y.output file
+ var lflag bool // -l - disable line directives
}
// The S1 struct; some fields are not exported.
type S1 struct {
- S0;
- A, B, C float; // 3 exported fields
- D int; // 2 unexported fields
+ S0
+ A, B, C float // 3 exported fields
+ D int // 2 unexported fields
// contains unexported fields
}
// The S2 struct; all fields are exported.
type S2 struct {
- S1;
- A, B, C float; // 3 exported fields
+ S1
+ A, B, C float // 3 exported fields
}
// The I1 interface; some methods are not exported.
type I1 interface {
- I0;
- F(x float) float; // exported methods
+ I0
+ F(x float) float // exported methods
// contains unexported methods
}
// The I2 interface; all methods are exported.
type I2 interface {
- I0;
- F(x float) float; // exported method
- G(x float) float; // exported method
+ I0
+ F(x float) float // exported method
+ G(x float) float // exported method
}
import "io"
import (
- _ "io";
+ _ "io"
)
import _ "io"
import (
- "io";
- "io";
- "io";
+ "io"
+ "io"
+ "io"
)
import (
- "io";
- aLongRename "io";
+ "io"
+ aLongRename "io"
- b "io";
+ b "io"
)
// no newlines between consecutive single imports, but
// a comment
"bar" +
"foo" + // a comment
- "bar"; // a comment
+ "bar" // a comment
)
// a case that caused problems in the past (comment placement)
import (
- . "fmt";
- "io";
- "malloc"; // for the malloc count test only
- "math";
- "strings";
- "testing";
+ . "fmt"
+ "io"
+ "malloc" // for the malloc count test only
+ "math"
+ "strings"
+ "testing"
)
func _() {
// the following decls need a semicolon at the end
- type _ int;
- type _ *int;
- type _ []int;
- type _ map[string]int;
- type _ chan int;
- type _ func() int;
-
- var _ int;
- var _ *int;
- var _ []int;
- var _ map[string]int;
- var _ chan int;
- var _ func() int;
+ type _ int
+ type _ *int
+ type _ []int
+ type _ map[string]int
+ type _ chan int
+ type _ func() int
+
+ var _ int
+ var _ *int
+ var _ []int
+ var _ map[string]int
+ var _ chan int
+ var _ func() int
// the following decls don't need a semicolon at the end
type _ struct{}
// don't lose blank lines in grouped declarations
const (
- _ int = 0;
- _ float = 1;
+ _ int = 0
+ _ float = 1
- _ string = "foo";
+ _ string = "foo"
- _ = iota;
- _;
+ _ = iota
+ _
// a comment
- _;
+ _
- _;
+ _
)
type (
- _ int;
- _ struct{};
+ _ int
+ _ struct{}
- _ interface{};
+ _ interface{}
// a comment
- _ map[string]int;
+ _ map[string]int
)
var (
- _ int = 0;
- _ float = 1;
+ _ int = 0
+ _ float = 1
- _ string = "foo";
+ _ string = "foo"
- _ bool;
+ _ bool
// a comment
- _ bool;
+ _ bool
)
// don't lose blank lines in this struct
type _ struct {
String struct {
- Str, Len int;
- };
+ Str, Len int
+ }
Slice struct {
- Array, Len, Cap int;
- };
+ Array, Len, Cap int
+ }
Eface struct {
- Typ, Ptr int;
- };
+ Typ, Ptr int
+ }
UncommonType struct {
- Name, PkgPath int;
- };
+ Name, PkgPath int
+ }
CommonType struct {
- Size, Hash, Alg, Align, FieldAlign, String, UncommonType int;
- };
+ Size, Hash, Alg, Align, FieldAlign, String, UncommonType int
+ }
Type struct {
- Typ, Ptr int;
- };
+ Typ, Ptr int
+ }
StructField struct {
- Name, PkgPath, Typ, Tag, Offset int;
- };
+ Name, PkgPath, Typ, Tag, Offset int
+ }
StructType struct {
- Fields int;
- };
+ Fields int
+ }
PtrType struct {
- Elem int;
- };
+ Elem int
+ }
SliceType struct {
- Elem int;
- };
+ Elem int
+ }
ArrayType struct {
- Elem, Len int;
- };
+ Elem, Len int
+ }
Stktop struct {
- Stackguard, Stackbase, Gobuf int;
- };
+ Stackguard, Stackbase, Gobuf int
+ }
Gobuf struct {
- Sp, Pc, G int;
- };
+ Sp, Pc, G int
+ }
G struct {
- Stackbase, Sched, Status, Alllink int;
- };
+ Stackbase, Sched, Status, Alllink int
+ }
}
// no tabs for single or ungrouped decls
func _() {
- const xxxxxx = 0;
- type x int;
- var xxx int;
- var yyyy float = 3.14;
- var zzzzz = "bar";
+ const xxxxxx = 0
+ type x int
+ var xxx int
+ var yyyy float = 3.14
+ var zzzzz = "bar"
const (
- xxxxxx = 0;
+ xxxxxx = 0
)
type (
- x int;
+ x int
)
var (
- xxx int;
+ xxx int
)
var (
- yyyy float = 3.14;
+ yyyy float = 3.14
)
var (
- zzzzz = "bar";
+ zzzzz = "bar"
)
}
func _() {
// no entry has a type
const (
- zzzzzz = 1;
- z = 2;
- zzz = 3;
+ zzzzzz = 1
+ z = 2
+ zzz = 3
)
// some entries have a type
const (
- xxxxxx = 1;
- x = 2;
- xxx = 3;
- yyyyyyyy float = iota;
- yyyy = "bar";
- yyy;
- yy = 2;
+ xxxxxx = 1
+ x = 2
+ xxx = 3
+ yyyyyyyy float = iota
+ yyyy = "bar"
+ yyy
+ yy = 2
)
}
func _() {
// no entry has a type
var (
- zzzzzz = 1;
- z = 2;
- zzz = 3;
+ zzzzzz = 1
+ z = 2
+ zzz = 3
)
// no entry has a value
var (
- _ int;
- _ float;
- _ string;
+ _ int
+ _ float
+ _ string
- _ int; // comment
- _ float; // comment
- _ string; // comment
+ _ int // comment
+ _ float // comment
+ _ string // comment
)
// some entries have a type
var (
- xxxxxx int;
- x float;
- xxx string;
- yyyyyyyy int = 1234;
- y float = 3.14;
- yyyy = "bar";
- yyy string = "foo";
+ xxxxxx int
+ x float
+ xxx string
+ yyyyyyyy int = 1234
+ y float = 3.14
+ yyyy = "bar"
+ yyy string = "foo"
)
// mixed entries - all comments should be aligned
var (
- a, b, c int;
- x = 10;
- d int; // comment
- y = 20; // comment
- f, ff, fff, ffff int = 0, 1, 2, 3; // comment
+ a, b, c int
+ x = 10
+ d int // comment
+ y = 20 // comment
+ f, ff, fff, ffff int = 0, 1, 2, 3 // comment
)
// respect original line breaks
var _ = []T{
T{0x20, "Telugu"},
- };
+ }
var _ = []T{
// respect original line breaks
T{0x20, "Telugu"},
- };
+ }
}
func _() {
type (
- xxxxxx int;
- x float;
- xxx string;
- xxxxx []x;
- xx struct{};
+ xxxxxx int
+ x float
+ xxx string
+ xxxxx []x
+ xx struct{}
xxxxxxx struct {
- _, _ int;
- _ float;
- };
- xxxx chan<- string;
+ _, _ int
+ _ float
+ }
+ xxxx chan<- string
)
}
}
type _ struct { // this comment must not change indentation
- f int;
- f, ff, fff, ffff int;
+ f int
+ f, ff, fff, ffff int
}
type _ struct {
- string;
+ string
}
type _ struct {
- string; // comment
+ string // comment
}
type _ struct {
- string "tag";
+ string "tag"
}
type _ struct {
- string "tag"; // comment
+ string "tag" // comment
}
type _ struct {
- f int;
+ f int
}
type _ struct {
- f int; // comment
+ f int // comment
}
type _ struct {
- f int "tag";
+ f int "tag"
}
type _ struct {
- f int "tag"; // comment
+ f int "tag" // comment
}
type _ struct {
- bool;
- a, b, c int;
- int "tag";
- ES; // comment
- float "tag"; // comment
- f int; // comment
- f, ff, fff, ffff int; // comment
- g float "tag";
- h float "tag"; // comment
+ bool
+ a, b, c int
+ int "tag"
+ ES // comment
+ float "tag" // comment
+ f int // comment
+ f, ff, fff, ffff int // comment
+ g float "tag"
+ h float "tag" // comment
}
// difficult cases
type _ struct {
- bool; // comment
- text []byte; // comment
+ bool // comment
+ text []byte // comment
}
type EI interface{}
type _ interface {
- EI;
+ EI
}
type _ interface {
- f();
- fffff();
+ f()
+ fffff()
}
type _ interface {
- EI;
- f();
- fffffg();
+ EI
+ f()
+ fffffg()
}
type _ interface { // this comment must not change indentation
- EI; // here's a comment
- f(); // no blank between identifier and ()
- fffff(); // no blank between identifier and ()
- gggggggggggg(x, y, z int); // hurray
+ EI // here's a comment
+ f() // no blank between identifier and ()
+ fffff() // no blank between identifier and ()
+ gggggggggggg(x, y, z int) // hurray
}
// formatting of variable declarations
func _() {
type day struct {
- n int;
- short, long string;
+ n int
+ short, long string
}
var (
- Sunday = day{0, "SUN", "Sunday"};
- Monday = day{1, "MON", "Monday"};
- Tuesday = day{2, "TUE", "Tuesday"};
- Wednesday = day{3, "WED", "Wednesday"};
- Thursday = day{4, "THU", "Thursday"};
- Friday = day{5, "FRI", "Friday"};
- Saturday = day{6, "SAT", "Saturday"};
+ Sunday = day{0, "SUN", "Sunday"}
+ Monday = day{1, "MON", "Monday"}
+ Tuesday = day{2, "TUE", "Tuesday"}
+ Wednesday = day{3, "WED", "Wednesday"}
+ Thursday = day{4, "THU", "Thursday"}
+ Friday = day{5, "FRI", "Friday"}
+ Saturday = day{6, "SAT", "Saturday"}
)
}
"print": nil,
"println": nil,
},
- };
+ }
}
func _() {
var _ = T{
a, // must introduce trailing comma
- };
+ }
}
// in the following declarations, a comment must not
// introduce a newline and thus cause a semicolon to
// be inserted
- const _ T = x // comment
- ;
- const _ = x // comment
- ;
+ const _ T = x // comment
+ const _ = x // comment
- type _ T // comment
- ;
+ type _ T // comment
type _ struct // comment
{
}
type _ * // comment
- T;
+ T
type _ [ // comment
- ]T;
+ ]T
type _ [ // comment
- 10]T;
+ 10]T
type _ chan // comment
- T;
+ T
type _ map // comment
- [T]T;
+ [T]T
- var _ T // comment
- ;
- var _ T = x // comment
- ;
+ var _ T // comment
+ var _ T = x // comment
var _ struct // comment
{
}
var _ * // comment
- T;
+ T
var _ [ // comment
- ]T;
+ ]T
var _ [ // comment
- 10]T;
+ 10]T
var _ chan // comment
- T;
+ T
var _ map // comment
- [T]T;
+ [T]T
- var _ = x // comment
- ;
+ var _ = x // comment
}
package expressions
type T struct {
- x, y, z int;
+ x, y, z int
}
var (
- a, b, c, d, e int;
- under_bar int;
- longIdentifier1, longIdentifier2, longIdentifier3 int;
- t0, t1, t2 T;
- s string;
- p *int;
+ a, b, c, d, e int
+ under_bar int
+ longIdentifier1, longIdentifier2, longIdentifier3 int
+ t0, t1, t2 T
+ s string
+ p *int
)
func _() {
// no spaces around simple or parenthesized expressions
- _ = a + b;
- _ = a + b + c;
- _ = a + b - c;
- _ = a - b - c;
- _ = a + (b * c);
- _ = a + (b / c);
- _ = a - (b % c);
- _ = 1 + a;
- _ = a + 1;
- _ = a + b + 1;
- _ = s[1:2];
- _ = s[a:b];
- _ = s[0:len(s)];
- _ = s[0] << 1;
- _ = (s[0] << 1) & 0xf;
- _ = s[0]<<2 | s[1]>>4;
- _ = "foo" + s;
- _ = s + "foo";
- _ = 'a' + 'b';
- _ = len(s) / 2;
- _ = len(t0.x) / a;
+ _ = a + b
+ _ = a + b + c
+ _ = a + b - c
+ _ = a - b - c
+ _ = a + (b * c)
+ _ = a + (b / c)
+ _ = a - (b % c)
+ _ = 1 + a
+ _ = a + 1
+ _ = a + b + 1
+ _ = s[1:2]
+ _ = s[a:b]
+ _ = s[0:len(s)]
+ _ = s[0] << 1
+ _ = (s[0] << 1) & 0xf
+ _ = s[0]<<2 | s[1]>>4
+ _ = "foo" + s
+ _ = s + "foo"
+ _ = 'a' + 'b'
+ _ = len(s) / 2
+ _ = len(t0.x) / a
// spaces around expressions of different precedence or expressions containing spaces
- _ = a + -b;
- _ = a - ^b;
- _ = a / *p;
- _ = a + b*c;
- _ = 1 + b*c;
- _ = a + 2*c;
- _ = a + c*2;
- _ = 1 + 2*3;
- _ = s[1 : 2*3];
- _ = s[a : b-c];
- _ = s[0:];
- _ = s[a+b];
- _ = s[a+b:];
- _ = a[a<<b+1];
- _ = a[a<<b+1:];
- _ = s[a+b : len(s)];
- _ = s[len(s):-a];
- _ = s[a : len(s)+1];
- _ = s[a:len(s)+1] + s;
+ _ = a + -b
+ _ = a - ^b
+ _ = a / *p
+ _ = a + b*c
+ _ = 1 + b*c
+ _ = a + 2*c
+ _ = a + c*2
+ _ = 1 + 2*3
+ _ = s[1 : 2*3]
+ _ = s[a : b-c]
+ _ = s[0:]
+ _ = s[a+b]
+ _ = s[a+b:]
+ _ = a[a<<b+1]
+ _ = a[a<<b+1:]
+ _ = s[a+b : len(s)]
+ _ = s[len(s):-a]
+ _ = s[a : len(s)+1]
+ _ = s[a:len(s)+1] + s
// spaces around operators with equal or lower precedence than comparisons
- _ = a == b;
- _ = a != b;
- _ = a > b;
- _ = a >= b;
- _ = a < b;
- _ = a <= b;
- _ = a < b && c > d;
- _ = a < b || c > d;
+ _ = a == b
+ _ = a != b
+ _ = a > b
+ _ = a >= b
+ _ = a < b
+ _ = a <= b
+ _ = a < b && c > d
+ _ = a < b || c > d
// spaces around "long" operands
- _ = a + longIdentifier1;
- _ = longIdentifier1 + a;
- _ = longIdentifier1 + longIdentifier2*longIdentifier3;
- _ = s + "a longer string";
+ _ = a + longIdentifier1
+ _ = longIdentifier1 + a
+ _ = longIdentifier1 + longIdentifier2*longIdentifier3
+ _ = s + "a longer string"
// some selected cases
- _ = a + t0.x;
- _ = a + t0.x + t1.x*t2.x;
- _ = a + b + c + d + e + 2*3;
- _ = a + b + c + 2*3 + d + e;
- _ = (a + b + c) * 2;
- _ = a - b + c - d + (a + b + c) + d&e;
- _ = under_bar - 1;
- _ = Open(dpath+"/file", O_WRONLY|O_CREAT, 0666);
- _ = int(c0&_Mask4)<<18 | int(c1&_Maskx)<<12 | int(c2&_Maskx)<<6 | int(c3&_Maskx);
+ _ = a + t0.x
+ _ = a + t0.x + t1.x*t2.x
+ _ = a + b + c + d + e + 2*3
+ _ = a + b + c + 2*3 + d + e
+ _ = (a + b + c) * 2
+ _ = a - b + c - d + (a + b + c) + d&e
+ _ = under_bar - 1
+ _ = Open(dpath+"/file", O_WRONLY|O_CREAT, 0666)
+ _ = int(c0&_Mask4)<<18 | int(c1&_Maskx)<<12 | int(c2&_Maskx)<<6 | int(c3&_Maskx)
}
func _() {
- a + b;
- a + b + c;
- a + b*c;
- a + (b * c);
- (a + b) * c;
- a + (b * c * d);
- a + (b*c + d);
-
- 1 << x;
- -1 << x;
- 1<<x - 1;
- -1<<x - 1;
-
- f(a + b);
- f(a + b + c);
- f(a + b*c);
- f(a + (b * c));
- f(1<<x-1, 1<<x-2);
-
- 1<<d.logWindowSize - 1;
-
- buf = make(x, 2*cap(b.buf)+n);
-
- dst[i*3+2] = dbuf[0] << 2;
- dst[i*3+2] = dbuf[0]<<2 | dbuf[1]>>4;
-
- b.buf = b.buf[0 : b.off+m+n];
- b.buf = b.buf[0 : b.off+m*n];
- f(b.buf[0 : b.off+m+n]);
-
- signed += ' ' * 8;
- tw.octal(header[148:155], chksum);
-
- x > 0 && i >= 0;
-
- x1, x0 := x>>w2, x&m2;
- z0 = t1<<w2 + t0;
- z1 = (t1 + t0>>w2) >> w2;
- q1, r1 := x1/d1, x1%d1;
- r1 = r1*b2 | x0>>w2;
- x1 = (x1 << z) | (x0 >> (uint(w) - z));
- x1 = x1<<z | x0>>(uint(w)-z);
-
- buf[0 : len(buf)+1];
- buf[0 : n+1];
-
- a, b = b, a;
- a = b + c;
- a = b*c + d;
- a*b + c;
- a - b - c;
- a - (b - c);
- a - b*c;
- a - (b * c);
- a * b / c;
- a / *b;
- x[a|^b];
- x[a / *b];
- a & ^b;
- a + +b;
- a - -b;
- x[a*-b];
- x[a + +b];
- x ^ y ^ z;
- b[a>>24] ^ b[(a>>16)&0xFF] ^ b[(a>>8)&0xFF] ^ b[a&0xFF];
- len(longVariableName) * 2;
-
- token(matchType + xlength<<lengthShift + xoffset);
+ a + b
+ a + b + c
+ a + b*c
+ a + (b * c)
+ (a + b) * c
+ a + (b * c * d)
+ a + (b*c + d)
+
+ 1 << x
+ -1 << x
+ 1<<x - 1
+ -1<<x - 1
+
+ f(a + b)
+ f(a + b + c)
+ f(a + b*c)
+ f(a + (b * c))
+ f(1<<x-1, 1<<x-2)
+
+ 1<<d.logWindowSize - 1
+
+ buf = make(x, 2*cap(b.buf)+n)
+
+ dst[i*3+2] = dbuf[0] << 2
+ dst[i*3+2] = dbuf[0]<<2 | dbuf[1]>>4
+
+ b.buf = b.buf[0 : b.off+m+n]
+ b.buf = b.buf[0 : b.off+m*n]
+ f(b.buf[0 : b.off+m+n])
+
+ signed += ' ' * 8
+ tw.octal(header[148:155], chksum)
+
+ x > 0 && i >= 0
+
+ x1, x0 := x>>w2, x&m2
+ z0 = t1<<w2 + t0
+ z1 = (t1 + t0>>w2) >> w2
+ q1, r1 := x1/d1, x1%d1
+ r1 = r1*b2 | x0>>w2
+ x1 = (x1 << z) | (x0 >> (uint(w) - z))
+ x1 = x1<<z | x0>>(uint(w)-z)
+
+ buf[0 : len(buf)+1]
+ buf[0 : n+1]
+
+ a, b = b, a
+ a = b + c
+ a = b*c + d
+ a*b + c
+ a - b - c
+ a - (b - c)
+ a - b*c
+ a - (b * c)
+ a * b / c
+ a / *b
+ x[a|^b]
+ x[a / *b]
+ a & ^b
+ a + +b
+ a - -b
+ x[a*-b]
+ x[a + +b]
+ x ^ y ^ z
+ b[a>>24] ^ b[(a>>16)&0xFF] ^ b[(a>>8)&0xFF] ^ b[a&0xFF]
+ len(longVariableName) * 2
+
+ token(matchType + xlength<<lengthShift + xoffset)
}
func _() {
- _ = T{};
- _ = struct{}{};
- _ = [10]T{};
- _ = [...]T{};
- _ = []T{};
- _ = map[int]T{};
-
- _ = (T){};
- _ = (struct{}){};
- _ = ([10]T){};
- _ = ([...]T){};
- _ = ([]T){};
- _ = (map[int]T){};
+ _ = T{}
+ _ = struct{}{}
+ _ = [10]T{}
+ _ = [...]T{}
+ _ = []T{}
+ _ = map[int]T{}
+
+ _ = (T){}
+ _ = (struct{}){}
+ _ = ([10]T){}
+ _ = ([...]T){}
+ _ = ([]T){}
+ _ = (map[int]T){}
}
// one-line structs/interfaces in composite literals (up to a threshold)
func _() {
- _ = struct{}{};
- _ = struct{ x int }{0};
- _ = struct{ x, y, z int }{0, 1, 2};
- _ = struct{ int }{0};
+ _ = struct{}{}
+ _ = struct{ x int }{0}
+ _ = struct{ x, y, z int }{0, 1, 2}
+ _ = struct{ int }{0}
_ = struct {
s struct {
- int;
- };
- }{struct{ int }{0}}; // compositeLit context not propagated => multiLine result
+ int
+ }
+ }{struct{ int }{0}} // compositeLit context not propagated => multiLine result
}
func _() {
// do not modify literals
- _ = "tab1 tab2 tab3 end"; // string contains 3 tabs
- _ = "tab1 tab2 tab3 end"; // same string with 3 blanks - may be unaligned because editors see tabs in strings
- _ = ""; // this comment should be aligned with the one on the previous line
- _ = ``;
+ _ = "tab1 tab2 tab3 end" // string contains 3 tabs
+ _ = "tab1 tab2 tab3 end" // same string with 3 blanks - may be unaligned because editors see tabs in strings
+ _ = "" // this comment should be aligned with the one on the previous line
+ _ = ``
_ = `
-`;
+`
_ = `foo
- bar`;
+ bar`
}
func _() {
// one-line function literals
- _ = func() {};
- _ = func() int { return 0 };
- _ = func(x, y int) bool { return x < y };
+ _ = func() {}
+ _ = func() int { return 0 }
+ _ = func(x, y int) bool { return x < y }
- f(func() {});
- f(func() int { return 0 });
- f(func(x, y int) bool { return x < y });
+ f(func() {})
+ f(func() int { return 0 })
+ f(func(x, y int) bool { return x < y })
}
func _() {
// do not add extra indentation to multi-line string lists
- _ = "foo" + "bar";
+ _ = "foo" + "bar"
_ = "foo" +
"bar" +
- "bah";
+ "bah"
_ = []string{
"abc" +
"def",
"foo" +
"bar",
- };
+ }
}
_ = F1 +
`string = "%s";` +
`ptr = *;` +
- `datafmt.T2 = s ["-" p "-"];`;
+ `datafmt.T2 = s ["-" p "-"];`
_ =
`datafmt "datafmt";` +
`default = "%v";` +
`array = *;` +
- `datafmt.T3 = s {" " a a / ","};`;
+ `datafmt.T3 = s {" " a a / ","};`
_ = `datafmt "datafmt";` +
`default = "%v";` +
`array = *;` +
- `datafmt.T3 = s {" " a a / ","};`;
+ `datafmt.T3 = s {" " a a / ","};`
}
// respect source lines in multi-line expressions
_ = a +
b +
- c;
+ c
_ = a < b ||
- b < a;
+ b < a
_ = "933262154439441526816992388562667004907159682643816214685929" +
"638952175999932299156089414639761565182862536979208272237582" +
- "51185210916864000000000000000000000000"; // 100!
- _ = "170141183460469231731687303715884105727"; // prime
+ "51185210916864000000000000000000000000" // 100!
+ _ = "170141183460469231731687303715884105727" // prime
}
// Alignment after overlong lines
const (
- _ = "991";
- _ = "2432902008176640000"; // 20!
+ _ = "991"
+ _ = "2432902008176640000" // 20!
_ = "933262154439441526816992388562667004907159682643816214685929" +
"638952175999932299156089414639761565182862536979208272237582" +
- "51185210916864000000000000000000000000"; // 100!
- _ = "170141183460469231731687303715884105727"; // prime
+ "51185210916864000000000000000000000000" // 100!
+ _ = "170141183460469231731687303715884105727" // prime
)
func _() {
_ = a + // comment
b + // comment
- c;
+ c
_ = "a" + // comment
"b" + // comment
- "c";
- _ = "ba0408" + "7265717569726564"; // field 71, encoding 2, string "required"
+ "c"
+ _ = "ba0408" + "7265717569726564" // field 71, encoding 2, string "required"
}
func _() {
f(1,
2,
- 3);
+ 3)
f(1,
2,
- 3);
+ 3,
+ )
// TODO(gri) the cases below are not correct yet
f(1,
2,
- 3); // comment
+ 3) // comment
f(1,
2,
- 3 // comment
- );
+ 3, // comment
+ )
f(1,
2,
- 3); // comment
+ 3) // comment
f(1,
2,
- 3 // comment
- );
+ 3 // comment
+ ,
+ )
}
// respect source lines in multi-line expressions
if cc.negate && len(cc.ranges) == 2 &&
cc.ranges[0] == '\n' && cc.ranges[1] == '\n' {
- nl := new(_NotNl);
- p.re.add(nl);
+ nl := new(_NotNl)
+ p.re.add(nl)
}
}
package expressions
type T struct {
- x, y, z int;
+ x, y, z int
}
var (
- a, b, c, d, e int;
- under_bar int;
- longIdentifier1, longIdentifier2, longIdentifier3 int;
- t0, t1, t2 T;
- s string;
- p *int;
+ a, b, c, d, e int
+ under_bar int
+ longIdentifier1, longIdentifier2, longIdentifier3 int
+ t0, t1, t2 T
+ s string
+ p *int
)
func _() {
// no spaces around simple or parenthesized expressions
- _ = a + b;
- _ = a + b + c;
- _ = a + b - c;
- _ = a - b - c;
- _ = a + (b * c);
- _ = a + (b / c);
- _ = a - (b % c);
- _ = 1 + a;
- _ = a + 1;
- _ = a + b + 1;
- _ = s[1:2];
- _ = s[a:b];
- _ = s[0:len(s)];
- _ = s[0] << 1;
- _ = (s[0] << 1) & 0xf;
- _ = s[0]<<2 | s[1]>>4;
- _ = "foo" + s;
- _ = s + "foo";
- _ = 'a' + 'b';
- _ = len(s) / 2;
- _ = len(t0.x) / a;
+ _ = a + b
+ _ = a + b + c
+ _ = a + b - c
+ _ = a - b - c
+ _ = a + (b * c)
+ _ = a + (b / c)
+ _ = a - (b % c)
+ _ = 1 + a
+ _ = a + 1
+ _ = a + b + 1
+ _ = s[1:2]
+ _ = s[a:b]
+ _ = s[0:len(s)]
+ _ = s[0] << 1
+ _ = (s[0] << 1) & 0xf
+ _ = s[0]<<2 | s[1]>>4
+ _ = "foo" + s
+ _ = s + "foo"
+ _ = 'a' + 'b'
+ _ = len(s) / 2
+ _ = len(t0.x) / a
// spaces around expressions of different precedence or expressions containing spaces
- _ = a + -b;
- _ = a - ^b;
- _ = a / *p;
- _ = a + b*c;
- _ = 1 + b*c;
- _ = a + 2*c;
- _ = a + c*2;
- _ = 1 + 2*3;
- _ = s[1 : 2*3];
- _ = s[a : b-c];
- _ = s[0:];
- _ = s[a+b];
- _ = s[a+b:];
- _ = a[a<<b+1];
- _ = a[a<<b+1:];
- _ = s[a+b : len(s)];
- _ = s[len(s):-a];
- _ = s[a : len(s)+1];
- _ = s[a:len(s)+1] + s;
+ _ = a + -b
+ _ = a - ^b
+ _ = a / *p
+ _ = a + b*c
+ _ = 1 + b*c
+ _ = a + 2*c
+ _ = a + c*2
+ _ = 1 + 2*3
+ _ = s[1 : 2*3]
+ _ = s[a : b-c]
+ _ = s[0:]
+ _ = s[a+b]
+ _ = s[a+b:]
+ _ = a[a<<b+1]
+ _ = a[a<<b+1:]
+ _ = s[a+b : len(s)]
+ _ = s[len(s):-a]
+ _ = s[a : len(s)+1]
+ _ = s[a:len(s)+1] + s
// spaces around operators with equal or lower precedence than comparisons
- _ = a == b;
- _ = a != b;
- _ = a > b;
- _ = a >= b;
- _ = a < b;
- _ = a <= b;
- _ = a < b && c > d;
- _ = a < b || c > d;
+ _ = a == b
+ _ = a != b
+ _ = a > b
+ _ = a >= b
+ _ = a < b
+ _ = a <= b
+ _ = a < b && c > d
+ _ = a < b || c > d
// spaces around "long" operands
- _ = a + longIdentifier1;
- _ = longIdentifier1 + a;
- _ = longIdentifier1 + longIdentifier2*longIdentifier3;
- _ = s + "a longer string";
+ _ = a + longIdentifier1
+ _ = longIdentifier1 + a
+ _ = longIdentifier1 + longIdentifier2*longIdentifier3
+ _ = s + "a longer string"
// some selected cases
- _ = a + t0.x;
- _ = a + t0.x + t1.x*t2.x;
- _ = a + b + c + d + e + 2*3;
- _ = a + b + c + 2*3 + d + e;
- _ = (a + b + c) * 2;
- _ = a - b + c - d + (a + b + c) + d&e;
- _ = under_bar - 1;
- _ = Open(dpath+"/file", O_WRONLY|O_CREAT, 0666);
- _ = int(c0&_Mask4)<<18 | int(c1&_Maskx)<<12 | int(c2&_Maskx)<<6 | int(c3&_Maskx);
+ _ = a + t0.x
+ _ = a + t0.x + t1.x*t2.x
+ _ = a + b + c + d + e + 2*3
+ _ = a + b + c + 2*3 + d + e
+ _ = (a + b + c) * 2
+ _ = a - b + c - d + (a + b + c) + d&e
+ _ = under_bar - 1
+ _ = Open(dpath+"/file", O_WRONLY|O_CREAT, 0666)
+ _ = int(c0&_Mask4)<<18 | int(c1&_Maskx)<<12 | int(c2&_Maskx)<<6 | int(c3&_Maskx)
}
func _() {
- a + b;
- a + b + c;
- a + b*c;
- a + (b * c);
- (a + b) * c;
- a + (b * c * d);
- a + (b*c + d);
-
- 1 << x;
- -1 << x;
- 1<<x - 1;
- -1<<x - 1;
-
- f(a + b);
- f(a + b + c);
- f(a + b*c);
- f(a + (b * c));
- f(1<<x-1, 1<<x-2);
-
- 1<<d.logWindowSize - 1;
-
- buf = make(x, 2*cap(b.buf)+n);
-
- dst[i*3+2] = dbuf[0] << 2;
- dst[i*3+2] = dbuf[0]<<2 | dbuf[1]>>4;
-
- b.buf = b.buf[0 : b.off+m+n];
- b.buf = b.buf[0 : b.off+m*n];
- f(b.buf[0 : b.off+m+n]);
-
- signed += ' ' * 8;
- tw.octal(header[148:155], chksum);
-
- x > 0 && i >= 0;
-
- x1, x0 := x>>w2, x&m2;
- z0 = t1<<w2 + t0;
- z1 = (t1 + t0>>w2) >> w2;
- q1, r1 := x1/d1, x1%d1;
- r1 = r1*b2 | x0>>w2;
- x1 = (x1 << z) | (x0 >> (uint(w) - z));
- x1 = x1<<z | x0>>(uint(w)-z);
-
- buf[0 : len(buf)+1];
- buf[0 : n+1];
-
- a, b = b, a;
- a = b + c;
- a = b*c + d;
- a*b + c;
- a - b - c;
- a - (b - c);
- a - b*c;
- a - (b * c);
- a * b / c;
- a / *b;
- x[a|^b];
- x[a / *b];
- a & ^b;
- a + +b;
- a - -b;
- x[a*-b];
- x[a + +b];
- x ^ y ^ z;
- b[a>>24] ^ b[(a>>16)&0xFF] ^ b[(a>>8)&0xFF] ^ b[a&0xFF];
- len(longVariableName) * 2;
-
- token(matchType + xlength<<lengthShift + xoffset);
+ a + b
+ a + b + c
+ a + b*c
+ a + (b * c)
+ (a + b) * c
+ a + (b * c * d)
+ a + (b*c + d)
+
+ 1 << x
+ -1 << x
+ 1<<x - 1
+ -1<<x - 1
+
+ f(a + b)
+ f(a + b + c)
+ f(a + b*c)
+ f(a + (b * c))
+ f(1<<x-1, 1<<x-2)
+
+ 1<<d.logWindowSize - 1
+
+ buf = make(x, 2*cap(b.buf)+n)
+
+ dst[i*3+2] = dbuf[0] << 2
+ dst[i*3+2] = dbuf[0]<<2 | dbuf[1]>>4
+
+ b.buf = b.buf[0 : b.off+m+n]
+ b.buf = b.buf[0 : b.off+m*n]
+ f(b.buf[0 : b.off+m+n])
+
+ signed += ' ' * 8
+ tw.octal(header[148:155], chksum)
+
+ x > 0 && i >= 0
+
+ x1, x0 := x>>w2, x&m2
+ z0 = t1<<w2 + t0
+ z1 = (t1 + t0>>w2) >> w2
+ q1, r1 := x1/d1, x1%d1
+ r1 = r1*b2 | x0>>w2
+ x1 = (x1 << z) | (x0 >> (uint(w) - z))
+ x1 = x1<<z | x0>>(uint(w)-z)
+
+ buf[0 : len(buf)+1]
+ buf[0 : n+1]
+
+ a, b = b, a
+ a = b + c
+ a = b*c + d
+ a*b + c
+ a - b - c
+ a - (b - c)
+ a - b*c
+ a - (b * c)
+ a * b / c
+ a / *b
+ x[a|^b]
+ x[a / *b]
+ a & ^b
+ a + +b
+ a - -b
+ x[a*-b]
+ x[a + +b]
+ x ^ y ^ z
+ b[a>>24] ^ b[(a>>16)&0xFF] ^ b[(a>>8)&0xFF] ^ b[a&0xFF]
+ len(longVariableName) * 2
+
+ token(matchType + xlength<<lengthShift + xoffset)
}
func _() {
- _ = T{};
- _ = struct{}{};
- _ = [10]T{};
- _ = [...]T{};
- _ = []T{};
- _ = map[int]T{};
-
- _ = (T){};
- _ = (struct{}){};
- _ = ([10]T){};
- _ = ([...]T){};
- _ = ([]T){};
- _ = (map[int]T){};
+ _ = T{}
+ _ = struct{}{}
+ _ = [10]T{}
+ _ = [...]T{}
+ _ = []T{}
+ _ = map[int]T{}
+
+ _ = (T){}
+ _ = (struct{}){}
+ _ = ([10]T){}
+ _ = ([...]T){}
+ _ = ([]T){}
+ _ = (map[int]T){}
}
// one-line structs/interfaces in composite literals (up to a threshold)
func _() {
- _ = struct{}{};
- _ = struct{ x int }{0};
- _ = struct{ x, y, z int }{0, 1, 2};
- _ = struct{ int }{0};
+ _ = struct{}{}
+ _ = struct{ x int }{0}
+ _ = struct{ x, y, z int }{0, 1, 2}
+ _ = struct{ int }{0}
_ = struct {
s struct {
- int;
- };
- }{struct{ int }{0}}; // compositeLit context not propagated => multiLine result
+ int
+ }
+ }{struct{ int }{0}} // compositeLit context not propagated => multiLine result
}
func _() {
// do not modify literals
- _ = "tab1 tab2 tab3 end"; // string contains 3 tabs
- _ = "tab1 tab2 tab3 end"; // same string with 3 blanks - may be unaligned because editors see tabs in strings
- _ = ""; // this comment should be aligned with the one on the previous line
- _ = ``;
+ _ = "tab1 tab2 tab3 end" // string contains 3 tabs
+ _ = "tab1 tab2 tab3 end" // same string with 3 blanks - may be unaligned because editors see tabs in strings
+ _ = "" // this comment should be aligned with the one on the previous line
+ _ = ``
_ = `
-`;
+`
_ = `foo
- bar`;
+ bar`
}
func _() {
// one-line function literals
- _ = func() {};
- _ = func() int { return 0 };
- _ = func(x, y int) bool { return x < y };
+ _ = func() {}
+ _ = func() int { return 0 }
+ _ = func(x, y int) bool { return x < y }
- f(func() {});
- f(func() int { return 0 });
- f(func(x, y int) bool { return x < y });
+ f(func() {})
+ f(func() int { return 0 })
+ f(func(x, y int) bool { return x < y })
}
func _() {
// do not add extra indentation to multi-line string lists
- _ = "foo" + "bar";
+ _ = "foo" + "bar"
_ = "foo" +
"bar" +
- "bah";
+ "bah"
_ = []string{
"abc" +
"def",
"foo" +
"bar",
- };
+ }
}
_ = F1 +
`string = "%s";` +
`ptr = *;` +
- `datafmt.T2 = s ["-" p "-"];`;
+ `datafmt.T2 = s ["-" p "-"];`
_ =
`datafmt "datafmt";` +
`default = "%v";` +
`array = *;` +
- `datafmt.T3 = s {" " a a / ","};`;
+ `datafmt.T3 = s {" " a a / ","};`
_ = `datafmt "datafmt";` +
`default = "%v";` +
`array = *;` +
- `datafmt.T3 = s {" " a a / ","};`;
+ `datafmt.T3 = s {" " a a / ","};`
}
// respect source lines in multi-line expressions
_ = a +
b +
- c;
+ c
_ = a < b ||
- b < a;
+ b < a
_ = "933262154439441526816992388562667004907159682643816214685929" +
"638952175999932299156089414639761565182862536979208272237582" +
- "51185210916864000000000000000000000000"; // 100!
- _ = "170141183460469231731687303715884105727"; // prime
+ "51185210916864000000000000000000000000" // 100!
+ _ = "170141183460469231731687303715884105727" // prime
}
// Alignment after overlong lines
const (
- _ = "991";
- _ = "2432902008176640000"; // 20!
+ _ = "991"
+ _ = "2432902008176640000" // 20!
_ = "933262154439441526816992388562667004907159682643816214685929" +
"638952175999932299156089414639761565182862536979208272237582" +
- "51185210916864000000000000000000000000"; // 100!
- _ = "170141183460469231731687303715884105727"; // prime
+ "51185210916864000000000000000000000000" // 100!
+ _ = "170141183460469231731687303715884105727" // prime
)
func _() {
_ = a + // comment
b + // comment
- c;
+ c
_ = "a" + // comment
"b" + // comment
- "c";
- _ = "ba0408" + "7265717569726564"; // field 71, encoding 2, string "required"
+ "c"
+ _ = "ba0408" + "7265717569726564" // field 71, encoding 2, string "required"
}
func _() {
f(1,
2,
- 3);
+ 3)
f(1,
2,
- 3);
+ 3,
+ )
// TODO(gri) the cases below are not correct yet
f(1,
2,
- 3); // comment
+ 3) // comment
f(1,
2,
- 3 // comment
- );
+ 3, // comment
+ )
f(1,
2,
- 3); // comment
+ 3) // comment
f(1,
2,
- 3 // comment
- );
+ 3 // comment
+ ,
+ )
}
// respect source lines in multi-line expressions
if cc.negate && len(cc.ranges) == 2 &&
cc.ranges[0] == '\n' && cc.ranges[1] == '\n' {
- nl := new(_NotNl);
- p.re.add(nl);
+ nl := new(_NotNl)
+ p.re.add(nl)
}
}
package linebreaks
import (
- "bytes";
- "fmt";
- "io";
- "os";
- "reflect";
- "strings";
- "testing";
+ "bytes"
+ "fmt"
+ "io"
+ "os"
+ "reflect"
+ "strings"
+ "testing"
)
type writerTestEntry struct {
- header *Header;
- contents string;
+ header *Header
+ contents string
}
type writerTest struct {
- file string; // filename of expected output
- entries []*writerTestEntry;
+ file string // filename of expected output
+ entries []*writerTestEntry
}
var writerTests = []*writerTest{
}
type untarTest struct {
- file string;
- headers []*Header;
+ file string
+ headers []*Header
}
var untarTests = []*untarTest{
fmt.Fprintf(os.Stderr,
// TODO(gri): the 2nd string of this string list should not be indented
"usage: godoc package [name ...]\n"+
- " godoc -http=:6060\n");
- flag.PrintDefaults();
- os.Exit(2);
+ " godoc -http=:6060\n")
+ flag.PrintDefaults()
+ os.Exit(2)
}
func TestReader(t *testing.T) {
testLoop:
for i, test := range untarTests {
- f, err := os.Open(test.file, os.O_RDONLY, 0444);
+ f, err := os.Open(test.file, os.O_RDONLY, 0444)
if err != nil {
- t.Errorf("test %d: Unexpected error: %v", i, err);
- continue;
+ t.Errorf("test %d: Unexpected error: %v", i, err)
+ continue
}
- tr := NewReader(f);
+ tr := NewReader(f)
for j, header := range test.headers {
- hdr, err := tr.Next();
+ hdr, err := tr.Next()
if err != nil || hdr == nil {
- t.Errorf("test %d, entry %d: Didn't get entry: %v", i, j, err);
- f.Close();
- continue testLoop;
+ t.Errorf("test %d, entry %d: Didn't get entry: %v", i, j, err)
+ f.Close()
+ continue testLoop
}
if !reflect.DeepEqual(hdr, header) {
t.Errorf("test %d, entry %d: Incorrect header:\nhave %+v\nwant %+v",
i, j, *hdr, *header)
}
}
- hdr, err := tr.Next();
+ hdr, err := tr.Next()
if hdr != nil || err != nil {
t.Errorf("test %d: Unexpected entry or error: hdr=%v err=%v", i, err)
}
- f.Close();
+ f.Close()
}
}
switch x := 0; x {
case 1:
- use(x);
- use(x); // followed by an empty line
+ 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);
+ use(x)
+ use(x)
}
switch x {
// line at a time.
func _() {
- const _ = 0;
+ const _ = 0
- const _ = 1;
- type _ int;
- type _ float;
+ const _ = 1
+ type _ int
+ type _ float
- var _ = 0;
- var x = 1;
+ var _ = 0
+ var x = 1
// Each use(x) call below should have at most one empty line before and after.
- use(x);
+ use(x)
if x < x {
func _() {
for {
- L1: _ = 0;
+ L1: _ = 0
L2:
- _ = 0;
+ _ = 0
}
}
func _() {
// this comment should be indented
for {
- L1: _ = 0;
+ L1: _ = 0
L2:
- _ = 0;
+ _ = 0
}
}
if {
_ = 0
}
- _ = 0; // the indentation here should not be affected by the long label name
+ _ = 0 // the indentation here should not be affected by the long label name
AnOverlongLabel:
- _ = 0;
+ _ = 0
if {
_ = 0
}
- _ = 0;
+ _ = 0
-L: _ = 0;
+L: _ = 0
}