// 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 imports import "io" import ( _ "io" ) import _ "io" import ( "io" "io" "io" ) import ( "io" aLongRename "io" b "io" ) import ( "unrenamed" renamed "renameMe" . "io" _ "io" "io" . "os" ) // no newlines between consecutive single imports, but // respect extra line breaks in the source (at most one empty line) import _ "io" import _ "io" import _ "io" import _ "os" import _ "os" import _ "os" import _ "fmt" import _ "fmt" import _ "fmt" import "foo" // a comment import "bar" // a comment import ( _ "foo" // a comment "bar" "foo" // a comment "bar" // a comment ) // comments + renames import ( "unrenamed" // a comment renamed "renameMe" . "io" /* a comment */ _ "io/ioutil" // a comment "io" // testing alignment . "os" // 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" ) // more import examples import ( "xxx" "much_longer_name" // comment "short_name" // comment ) import ( _ "xxx" "much_longer_name" // comment ) import ( mymath "math" "/foo/bar/long_package_path" // a comment ) import ( "package_a" // comment "package_b" my_better_c "package_c" // comment "package_d" // comment my_e "package_e" // comment "package_a" // comment "package_bb" "package_ccc" // comment "package_dddd" // comment ) // print import paths as double-quoted strings // (we would like more test cases but the go/parser // already excludes most incorrect paths, and we don't // bother setting up test-ASTs manually) import ( `fmt` "math" ) // at least one empty line between declarations of different kind import _ "io" var _ int // at least one empty line between declarations of the same kind // if there is associated documentation (was issue 2570) type T1 struct{} // T2 comment type T2 struct { } // should be a two-line struct // T3 comment type T2 struct { } // should be a two-line struct // printing of constant literals const ( _ = "foobar" _ = "a۰۱۸" _ = "foo६४" _ = "bar9876" _ = 0 _ = 1 _ = 123456789012345678890 _ = 01234567 _ = 0xcafebabe _ = 0. _ = .0 _ = 3.14159265 _ = 1e0 _ = 1e+100 _ = 1e-100 _ = 2.71828e-1000 _ = 0i _ = 1i _ = 012345678901234567889i _ = 123456789012345678890i _ = 0.i _ = .0i _ = 3.14159265i _ = 1e0i _ = 1e+100i _ = 1e-100i _ = 2.71828e-1000i _ = 'a' _ = '\000' _ = '\xFF' _ = '\uff16' _ = '\U0000ff16' _ = `foobar` _ = `foo --- --- bar` ) func _() { 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 _ struct{} type _ *struct{} type _ []struct{} type _ map[string]struct{} type _ chan struct{} type _ func() struct{} type _ interface{} type _ *interface{} type _ []interface{} type _ map[string]interface{} type _ chan interface{} type _ func() interface{} var _ struct{} var _ *struct{} var _ []struct{} var _ map[string]struct{} var _ chan struct{} var _ func() struct{} var _ interface{} var _ *interface{} var _ []interface{} var _ map[string]interface{} var _ chan interface{} var _ func() interface{} } // don't lose blank lines in grouped declarations const ( _ int = 0 _ float = 1 _ string = "foo" _ = iota _ // a comment _ _ ) type ( _ int _ struct {} _ interface{} // a comment _ map[string]int ) var ( _ int = 0 _ float = 1 _ string = "foo" _ bool // a comment _ bool ) // don't lose blank lines in this struct type _ struct { String struct { Str, Len int } Slice struct { Array, Len, Cap int } Eface struct { Typ, Ptr int } UncommonType struct { Name, PkgPath int } CommonType struct { Size, Hash, Alg, Align, FieldAlign, String, UncommonType int } Type struct { Typ, Ptr int } StructField struct { Name, PkgPath, Typ, Tag, Offset int } StructType struct { Fields int } PtrType struct { Elem int } SliceType struct { Elem int } ArrayType struct { Elem, Len int } Stktop struct { Stackguard, Stackbase, Gobuf int } Gobuf struct { Sp, Pc, G int } G struct { Stackbase, Sched, Status, Alllink int } } // no blank lines in empty structs and interfaces, but leave 1- or 2-line layout alone type _ struct{ } type _ struct { } type _ interface{ } type _ interface { } // 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" ) } // tabs for multiple or grouped decls func _() { // no entry has a type const ( 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 ) } func _() { // no entry has a type var ( zzzzzz = 1 z = 2 zzz = 3 ) // no entry has a value var ( _ int _ float _ string _ 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" ) // 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 ) // respect original line breaks var _ = []T { T{0x20, "Telugu"}, } var _ = []T { // respect original line breaks T{0x20, "Telugu"}, } } // use the formatted output rather than the input to decide when to align // (was issue 4505) const ( short = 2 * ( 1 + 2) aMuchLongerName = 3 ) var ( short = X{ } aMuchLongerName = X{} x1 = X{} // foo x2 = X{ } // foo ) func _() { type ( xxxxxx int x float xxx string xxxxx []x xx struct{} xxxxxxx struct { _, _ int _ float } xxxx chan<- string ) } // alignment of "=" in consecutive lines (extended example from issue 1414) const ( umax uint = ^uint(0) // maximum value for a uint bpu = 1 << (5 + umax>>63) // bits per uint foo bar = -1 ) // typical enum const ( a MyType = iota abcd b c def ) // excerpt from godoc.go var ( goroot = flag.String("goroot", runtime.GOROOT(), "Go root directory") testDir = flag.String("testdir", "", "Go root subdirectory - for testing only (faster startups)") pkgPath = flag.String("path", "", "additional package directories (colon-separated)") filter = flag.String("filter", "", "filter file containing permitted package directory paths") filterMin = flag.Int("filter_minutes", 0, "filter file update interval in minutes; disabled if <= 0") filterDelay delayTime // actual filter update interval in minutes; usually filterDelay == filterMin, but filterDelay may back off exponentially ) // formatting of structs type _ struct{} type _ struct{ /* this comment should be visible */ } type _ struct{ // this comment should be visible and properly indented } type _ struct { // this comment must not change indentation f int f, ff, fff, ffff int } type _ struct { string } type _ struct { string // comment } type _ struct { string "tag" } type _ struct { string "tag" // comment } type _ struct { f int } type _ struct { f int // comment } type _ struct { f int "tag" } type _ struct { 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 } type _ struct { a, b, c, d int // this line should be indented u, v, w, x float // this line should be indented p, q, r, s float // this line should be indented } // difficult cases type _ struct { bool // comment text []byte // comment } // formatting of interfaces type EI interface{} type _ interface { EI } type _ interface { f() fffff() } type _ interface { 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 } // formatting of variable declarations func _() { type day struct { 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" } ) } // formatting of multi-line variable declarations var a1, b1, c1 int // all on one line var a2, b2, c2 int // this line should be indented var (a3, b3, c3, d3 int // this line should be indented a4, b4, c4 int // this line should be indented ) // Test case from issue 3304: multi-line declarations must end // a formatting section and not influence indentation of the // next line. var ( minRefreshTimeSec = flag.Int64("min_refresh_time_sec", 604800, "minimum time window between two refreshes for a given user.") x = flag.Int64("refresh_user_rollout_percent", 100, "temporary flag to ramp up the refresh user rpc") aVeryLongVariableName = stats.GetVarInt("refresh-user-count") ) func _() { var privateKey2 = &Block{Type: "RSA PRIVATE KEY", Headers: map[string]string{}, Bytes: []uint8{0x30, 0x82, 0x1, 0x3a, 0x2, 0x1, 0x0, 0x2, 0x41, 0x0, 0xb2, 0x99, 0xf, 0x49, 0xc4, 0x7d, 0xfa, 0x8c, 0xd4, 0x0, 0xae, 0x6a, 0x4d, 0x1b, 0x8a, 0x3b, 0x6a, 0x13, 0x64, 0x2b, 0x23, 0xf2, 0x8b, 0x0, 0x3b, 0xfb, 0x97, 0x79, }, } } func _() { var Universe = Scope { Names: map[string]*Ident { // basic types "bool": nil, "byte": nil, "int8": nil, "int16": nil, "int32": nil, "int64": nil, "uint8": nil, "uint16": nil, "uint32": nil, "uint64": nil, "float32": nil, "float64": nil, "string": nil, // convenience types "int": nil, "uint": nil, "uintptr": nil, "float": nil, // constants "false": nil, "true": nil, "iota": nil, "nil": nil, // functions "cap": nil, "len": nil, "new": nil, "make": nil, "panic": nil, "panicln": nil, "print": nil, "println": nil, }, } } // alignment of map composite entries var _ = map[int]int{ // small key sizes: always align even if size ratios are large a: a, abcdefghabcdefgh: a, ab: a, abc: a, abcdefgabcdefg: a, abcd: a, abcde: a, abcdef: a, // mixed key sizes: align when key sizes change within accepted ratio abcdefgh: a, abcdefghabcdefg: a, abcdefghij: a, abcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghij: a, // outlier - do not align with previous line abcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghij: a, // align with previous line ab: a, // do not align with previous line abcde: a, // align with previous line } // alignment of map composite entries: test cases from issue 3965 // aligned var _ = T1{ a: x, b: y, cccccccccccccccccccc: z, } // not aligned var _ = T2{ a: x, b: y, ccccccccccccccccccccc: z, } // aligned var _ = T3{ aaaaaaaaaaaaaaaaaaaa: x, b: y, c: z, } // not aligned var _ = T4{ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: x, b: y, c: z, } // no alignment of map composite entries if they are not the first entry on a line var _ = T{0: 0} // not aligned var _ = T{0: 0, // not aligned 1: 1, // aligned 22: 22, // aligned 333: 333, 1234: 12, 12345: 0, // first on line aligned } // test cases form issue 8685 // not aligned var _ = map[int]string{1: "spring", 2: "summer", 3: "autumn", 4: "winter"} // not aligned var _ = map[string]string{"a": "spring", "b": "summer", "c": "autumn", "d": "winter"} // aligned var _ = map[string]string{"a": "spring", "b": "summer", "c": "autumn", "d": "winter"} func _() { var _ = T{ a, // must introduce trailing comma } } // formatting of function results func _() func() {} func _() func(int) { return nil } func _() func(int) int { return nil } func _() func(int) func(int) func() { return nil } // formatting of consecutive single-line functions func _() {} func _() {} func _() {} func _() {} // an empty line before this function func _() {} func _() {} func _() { f(1, 2, 3) } func _(x int) int { y := x; return y+1 } func _() int { type T struct{}; var x T; return x } // these must remain multi-line since they are multi-line in the source func _() { f(1, 2, 3) } func _(x int) int { y := x; return y+1 } func _() int { type T struct{}; var x T; return x } // making function declarations safe for new semicolon rules func _() { /* single-line function because of "short-ish" comment */ } func _() { /* multi-line function because of "long-ish" comment - much more comment text is following here */ /* and more */ } func _() { /* multi-line func because block is on multiple lines */ } // test case for issue #19544 func _() {} func _longer_name_() { // this comment must not force the {} from above to alignment // multiple lines } // ellipsis parameters func _(...int) func _(...*int) func _(...[]int) func _(...struct{}) func _(bool, ...interface{}) func _(bool, ...func()) func _(bool, ...func(...int)) func _(bool, ...map[string]int) func _(bool, ...chan int) func _(b bool, x ...int) func _(b bool, x ...*int) func _(b bool, x ...[]int) func _(b bool, x ...struct{}) func _(x ...interface{}) func _(x ...func()) func _(x ...func(...int)) func _(x ...map[string]int) func _(x ...chan int) // these parameter lists must remain multi-line since they are multi-line in the source func _(bool, int) { } func _(x bool, y int) { } func _(x, y bool) { } func _(bool, // comment int) { } func _(x bool, // comment y int) { } func _(x, // comment y bool) { } func _(bool, // comment // comment int) { } func _(x bool, // comment // comment y int) { } func _(x, // comment // comment y bool) { } func _(bool, // comment int) { } func _(x bool, // comment y int) { } func _(x, // comment y bool) { } func _(x, // comment y,// comment z bool) { } func _(x, // comment y,// comment z bool) { } func _(x int, // comment y float, // comment z bool) { } // properly indent multi-line signatures func ManageStatus(in <-chan *Status, req <-chan Request, stat chan<- *TargetInfo, TargetHistorySize int) { } func MultiLineSignature0( a, b, c int, ) {} func MultiLineSignature1( a, b, c int, u, v, w float, ) {} func MultiLineSignature2( a, b, c int, ) {} func MultiLineSignature3( a, b, c int, u, v, w float, x ...int) {} func MultiLineSignature4( a, b, c int, u, v, w float, x ...int) {} func MultiLineSignature5( a, b, c int, u, v, w float, p, q, r string, x ...int) {} // make sure it also works for methods in interfaces type _ interface { MultiLineSignature0( a, b, c int, ) MultiLineSignature1( a, b, c int, u, v, w float, ) MultiLineSignature2( a, b, c int, ) MultiLineSignature3( a, b, c int, u, v, w float, x ...int) MultiLineSignature4( a, b, c int, u, v, w float, x ...int) MultiLineSignature5( a, b, c int, u, v, w float, p, q, r string, x ...int) } // omit superfluous parentheses in parameter lists func _((int)) func _((((((int)))))) func _(x (int)) func _(x (((((int)))))) func _(x, y (int)) func _(x, y (((((int)))))) func _() (int) func _() ((int)) func _() ((((((int)))))) func _() (x int) func _() (x (int)) func _() (x (((((int)))))) // special cases: some channel types require parentheses func _(x chan(<-chan int)) func _(x (chan(<-chan int))) func _(x ((((chan(<-chan int)))))) func _(x chan<-(chan int)) func _(x (chan<-(chan int))) func _(x ((((chan<-(chan int)))))) // don't introduce comma after last parameter if the closing ) is on the same line // even if the parameter type itself is multi-line (test cases from issue 4533) func _(...interface{}) func _(...interface { m() n() }) // no extra comma between } and ) func (t *T) _(...interface{}) func (t *T) _(...interface { m() n() }) // no extra comma between } and ) func _(interface{}) func _(interface { m() }) // no extra comma between } and ) func _(struct{}) func _(struct { x int y int }) // no extra comma between } and ) // alias declarations type c0 struct{} type c1 = C type c2 = struct{ x int} type c3 = p.C type ( s struct{} a = A b = A c = foo d = interface{} ddd = p.Foo )