// 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६४"

_ = "bar９８７６"

_ = 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 )