Current File : //usr/local/go/src/go/printer/testdata/declarations.input
// 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 )
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
)
Mini Shell