1// Copyright 2009 The Go Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style
3// license that can be found in the LICENSE file.
4
5package imports
6
7import "io"
8
9import (
10 _ "io"
11)
12
13import _ "io"
14
15import (
16 "io"
17 "io"
18 "io"
19)
20
21import (
22 "io"
23 aLongRename "io"
24
25 b "io"
26)
27
28import (
29 "unrenamed"
30 renamed "renameMe"
31 . "io"
32 _ "io"
33 "io"
34 . "os"
35)
36
37// no newlines between consecutive single imports, but
38// respect extra line breaks in the source (at most one empty line)
39import _ "io"
40import _ "io"
41import _ "io"
42
43import _ "os"
44import _ "os"
45import _ "os"
46
47import _ "fmt"
48import _ "fmt"
49import _ "fmt"
50
51import "foo" // a comment
52import "bar" // a comment
53
54import (
55 _ "foo"
56 // a comment
57 "bar"
58 "foo" // a comment
59 "bar" // a comment
60)
61
62// comments + renames
63import (
64 "unrenamed" // a comment
65 renamed "renameMe"
66 . "io" /* a comment */
67 _ "io/ioutil" // a comment
68 "io" // testing alignment
69 . "os"
70 // a comment
71)
72
73// a case that caused problems in the past (comment placement)
74import (
75 . "fmt"
76 "io"
77 "malloc" // for the malloc count test only
78 "math"
79 "strings"
80 "testing"
81)
82
83// more import examples
84import (
85 "xxx"
86 "much_longer_name" // comment
87 "short_name" // comment
88)
89
90import (
91 _ "xxx"
92 "much_longer_name" // comment
93)
94
95import (
96 mymath "math"
97 "/foo/bar/long_package_path" // a comment
98)
99
100import (
101 "package_a" // comment
102 "package_b"
103 my_better_c "package_c" // comment
104 "package_d" // comment
105 my_e "package_e" // comment
106
107 "package_a" // comment
108 "package_bb"
109 "package_ccc" // comment
110 "package_dddd" // comment
111)
112
113// print import paths as double-quoted strings
114// (we would like more test cases but the go/parser
115// already excludes most incorrect paths, and we don't
116// bother setting up test-ASTs manually)
117import (
118 "fmt"
119 "math"
120)
121
122// at least one empty line between declarations of different kind
123import _ "io"
124
125var _ int
126
127// at least one empty line between declarations of the same kind
128// if there is associated documentation (was issue 2570)
129type T1 struct{}
130
131// T2 comment
132type T2 struct {
133} // should be a two-line struct
134
135// T3 comment
136type T2 struct {
137} // should be a two-line struct
138
139// printing of constant literals
140const (
141 _ = "foobar"
142 _ = "a۰۱۸"
143 _ = "foo६४"
144 _ = "bar９８７６"
145 _ = 0
146 _ = 1
147 _ = 123456789012345678890
148 _ = 01234567
149 _ = 0xcafebabe
150 _ = 0.
151 _ = .0
152 _ = 3.14159265
153 _ = 1e0
154 _ = 1e+100
155 _ = 1e-100
156 _ = 2.71828e-1000
157 _ = 0i
158 _ = 1i
159 _ = 012345678901234567889i
160 _ = 123456789012345678890i
161 _ = 0.i
162 _ = .0i
163 _ = 3.14159265i
164 _ = 1e0i
165 _ = 1e+100i
166 _ = 1e-100i
167 _ = 2.71828e-1000i
168 _ = 'a'
169 _ = '\000'
170 _ = '\xFF'
171 _ = '\uff16'
172 _ = '\U0000ff16'
173 _ = `foobar`
174 _ = `foo
175---
176---
177bar`
178)
179
180func _() {
181 type _ int
182 type _ *int
183 type _ []int
184 type _ map[string]int
185 type _ chan int
186 type _ func() int
187
188 var _ int
189 var _ *int
190 var _ []int
191 var _ map[string]int
192 var _ chan int
193 var _ func() int
194
195 type _ struct{}
196 type _ *struct{}
197 type _ []struct{}
198 type _ map[string]struct{}
199 type _ chan struct{}
200 type _ func() struct{}
201
202 type _ interface{}
203 type _ *interface{}
204 type _ []interface{}
205 type _ map[string]interface{}
206 type _ chan interface{}
207 type _ func() interface{}
208
209 var _ struct{}
210 var _ *struct{}
211 var _ []struct{}
212 var _ map[string]struct{}
213 var _ chan struct{}
214 var _ func() struct{}
215
216 var _ interface{}
217 var _ *interface{}
218 var _ []interface{}
219 var _ map[string]interface{}
220 var _ chan interface{}
221 var _ func() interface{}
222}
223
224// don't lose blank lines in grouped declarations
225const (
226 _ int = 0
227 _ float = 1
228
229 _ string = "foo"
230
231 _ = iota
232 _
233
234 // a comment
235 _
236
237 _
238)
239
240type (
241 _ int
242 _ struct{}
243
244 _ interface{}
245
246 // a comment
247 _ map[string]int
248)
249
250var (
251 _ int = 0
252 _ float = 1
253
254 _ string = "foo"
255
256 _ bool
257
258 // a comment
259 _ bool
260)
261
262// don't lose blank lines in this struct
263type _ struct {
264 String struct {
265 Str, Len int
266 }
267 Slice struct {
268 Array, Len, Cap int
269 }
270 Eface struct {
271 Typ, Ptr int
272 }
273
274 UncommonType struct {
275 Name, PkgPath int
276 }
277 CommonType struct {
278 Size, Hash, Alg, Align, FieldAlign, String, UncommonType int
279 }
280 Type struct {
281 Typ, Ptr int
282 }
283 StructField struct {
284 Name, PkgPath, Typ, Tag, Offset int
285 }
286 StructType struct {
287 Fields int
288 }
289 PtrType struct {
290 Elem int
291 }
292 SliceType struct {
293 Elem int
294 }
295 ArrayType struct {
296 Elem, Len int
297 }
298
299 Stktop struct {
300 Stackguard, Stackbase, Gobuf int
301 }
302 Gobuf struct {
303 Sp, Pc, G int
304 }
305 G struct {
306 Stackbase, Sched, Status, Alllink int
307 }
308}
309
310// no blank lines in empty structs and interfaces, but leave 1- or 2-line layout alone
311type _ struct{}
312type _ struct {
313}
314
315type _ interface{}
316type _ interface {
317}
318
319// no tabs for single or ungrouped decls
320func _() {
321 const xxxxxx = 0
322 type x int
323 var xxx int
324 var yyyy float = 3.14
325 var zzzzz = "bar"
326
327 const (
328 xxxxxx = 0
329 )
330 type (
331 x int
332 )
333 var (
334 xxx int
335 )
336 var (
337 yyyy float = 3.14
338 )
339 var (
340 zzzzz = "bar"
341 )
342}
343
344// tabs for multiple or grouped decls
345func _() {
346 // no entry has a type
347 const (
348 zzzzzz = 1
349 z = 2
350 zzz = 3
351 )
352 // some entries have a type
353 const (
354 xxxxxx = 1
355 x = 2
356 xxx = 3
357 yyyyyyyy float = iota
358 yyyy = "bar"
359 yyy
360 yy = 2
361 )
362}
363
364func _() {
365 // no entry has a type
366 var (
367 zzzzzz = 1
368 z = 2
369 zzz = 3
370 )
371 // no entry has a value
372 var (
373 _ int
374 _ float
375 _ string
376
377 _ int // comment
378 _ float // comment
379 _ string // comment
380 )
381 // some entries have a type
382 var (
383 xxxxxx int
384 x float
385 xxx string
386 yyyyyyyy int = 1234
387 y float = 3.14
388 yyyy = "bar"
389 yyy string = "foo"
390 )
391 // mixed entries - all comments should be aligned
392 var (
393 a, b, c int
394 x = 10
395 d int // comment
396 y = 20 // comment
397 f, ff, fff, ffff int = 0, 1, 2, 3 // comment
398 )
399 // respect original line breaks
400 var _ = []T{
401 T{0x20, "Telugu"},
402 }
403 var _ = []T{
404 // respect original line breaks
405 T{0x20, "Telugu"},
406 }
407}
408
409// use the formatted output rather than the input to decide when to align
410// (was issue 4505)
411const (
412 short = 2 * (1 + 2)
413 aMuchLongerName = 3
414)
415
416var (
417 short = X{}
418 aMuchLongerName = X{}
419
420 x1 = X{} // foo
421 x2 = X{} // foo
422)
423
424func _() {
425 type (
426 xxxxxx int
427 x float
428 xxx string
429 xxxxx []x
430 xx struct{}
431 xxxxxxx struct {
432 _, _ int
433 _ float
434 }
435 xxxx chan<- string
436 )
437}
438
439// alignment of "=" in consecutive lines (extended example from issue 1414)
440const (
441 umax uint = ^uint(0) // maximum value for a uint
442 bpu = 1 << (5 + umax>>63) // bits per uint
443 foo
444 bar = -1
445)
446
447// typical enum
448const (
449 a MyType = iota
450 abcd
451 b
452 c
453 def
454)
455
456// excerpt from godoc.go
457var (
458 goroot = flag.String("goroot", runtime.GOROOT(), "Go root directory")
459 testDir = flag.String("testdir", "", "Go root subdirectory - for testing only (faster startups)")
460 pkgPath = flag.String("path", "", "additional package directories (colon-separated)")
461 filter = flag.String("filter", "", "filter file containing permitted package directory paths")
462 filterMin = flag.Int("filter_minutes", 0, "filter file update interval in minutes; disabled if <= 0")
463 filterDelay delayTime // actual filter update interval in minutes; usually filterDelay == filterMin, but filterDelay may back off exponentially
464)
465
466// formatting of structs
467type _ struct{}
468
469type _ struct { /* this comment should be visible */
470}
471
472type _ struct {
473 // this comment should be visible and properly indented
474}
475
476type _ struct { // this comment must not change indentation
477 f int
478 f, ff, fff, ffff int
479}
480
481type _ struct {
482 string
483}
484
485type _ struct {
486 string // comment
487}
488
489type _ struct {
490 string "tag"
491}
492
493type _ struct {
494 string "tag" // comment
495}
496
497type _ struct {
498 f int
499}
500
501type _ struct {
502 f int // comment
503}
504
505type _ struct {
506 f int "tag"
507}
508
509type _ struct {
510 f int "tag" // comment
511}
512
513type _ struct {
514 bool
515 a, b, c int
516 int "tag"
517 ES // comment
518 float "tag" // comment
519 f int // comment
520 f, ff, fff, ffff int // comment
521 g float "tag"
522 h float "tag" // comment
523}
524
525type _ struct {
526 a, b,
527 c, d int // this line should be indented
528 u, v, w, x float // this line should be indented
529 p, q,
530 r, s float // this line should be indented
531}
532
533// difficult cases
534type _ struct {
535 bool // comment
536 text []byte // comment
537}
538
539// formatting of interfaces
540type EI interface{}
541
542type _ interface {
543 EI
544}
545
546type _ interface {
547 f()
548 fffff()
549}
550
551type _ interface {
552 EI
553 f()
554 fffffg()
555}
556
557type _ interface { // this comment must not change indentation
558 EI // here's a comment
559 f() // no blank between identifier and ()
560 fffff() // no blank between identifier and ()
561 gggggggggggg(x, y, z int) // hurray
562}
563
564// formatting of variable declarations
565func _() {
566 type day struct {
567 n int
568 short, long string
569 }
570 var (
571 Sunday = day{0, "SUN", "Sunday"}
572 Monday = day{1, "MON", "Monday"}
573 Tuesday = day{2, "TUE", "Tuesday"}
574 Wednesday = day{3, "WED", "Wednesday"}
575 Thursday = day{4, "THU", "Thursday"}
576 Friday = day{5, "FRI", "Friday"}
577 Saturday = day{6, "SAT", "Saturday"}
578 )
579}
580
581// formatting of multi-line variable declarations
582var a1, b1, c1 int // all on one line
583
584var a2, b2,
585 c2 int // this line should be indented
586
587var (
588 a3, b3,
589 c3, d3 int // this line should be indented
590 a4, b4, c4 int // this line should be indented
591)
592
593// Test case from issue 3304: multi-line declarations must end
594// a formatting section and not influence indentation of the
595// next line.
596var (
597 minRefreshTimeSec = flag.Int64("min_refresh_time_sec", 604800,
598 "minimum time window between two refreshes for a given user.")
599 x = flag.Int64("refresh_user_rollout_percent", 100,
600 "temporary flag to ramp up the refresh user rpc")
601 aVeryLongVariableName = stats.GetVarInt("refresh-user-count")
602)
603
604func _() {
605 var privateKey2 = &Block{Type: "RSA PRIVATE KEY",
606 Headers: map[string]string{},
607 Bytes: []uint8{0x30, 0x82, 0x1, 0x3a, 0x2, 0x1, 0x0, 0x2,
608 0x41, 0x0, 0xb2, 0x99, 0xf, 0x49, 0xc4, 0x7d, 0xfa, 0x8c,
609 0xd4, 0x0, 0xae, 0x6a, 0x4d, 0x1b, 0x8a, 0x3b, 0x6a, 0x13,
610 0x64, 0x2b, 0x23, 0xf2, 0x8b, 0x0, 0x3b, 0xfb, 0x97, 0x79,
611 },
612 }
613}
614
615func _() {
616 var Universe = Scope{
617 Names: map[string]*Ident{
618 // basic types
619 "bool": nil,
620 "byte": nil,
621 "int8": nil,
622 "int16": nil,
623 "int32": nil,
624 "int64": nil,
625 "uint8": nil,
626 "uint16": nil,
627 "uint32": nil,
628 "uint64": nil,
629 "float32": nil,
630 "float64": nil,
631 "string": nil,
632
633 // convenience types
634 "int": nil,
635 "uint": nil,
636 "uintptr": nil,
637 "float": nil,
638
639 // constants
640 "false": nil,
641 "true": nil,
642 "iota": nil,
643 "nil": nil,
644
645 // functions
646 "cap": nil,
647 "len": nil,
648 "new": nil,
649 "make": nil,
650 "panic": nil,
651 "panicln": nil,
652 "print": nil,
653 "println": nil,
654 },
655 }
656}
657
658// alignment of map composite entries
659var _ = map[int]int{
660 // small key sizes: always align even if size ratios are large
661 a: a,
662 abcdefghabcdefgh: a,
663 ab: a,
664 abc: a,
665 abcdefgabcdefg: a,
666 abcd: a,
667 abcde: a,
668 abcdef: a,
669
670 // mixed key sizes: align when key sizes change within accepted ratio
671 abcdefgh: a,
672 abcdefghabcdefg: a,
673 abcdefghij: a,
674 abcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghij: a, // outlier - do not align with previous line
675 abcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghij: a, // align with previous line
676
677 ab: a, // do not align with previous line
678 abcde: a, // align with previous line
679}
680
681// alignment of map composite entries: test cases from issue 3965
682// aligned
683var _ = T1{
684 a: x,
685 b: y,
686 cccccccccccccccccccc: z,
687}
688
689// not aligned
690var _ = T2{
691 a: x,
692 b: y,
693 ccccccccccccccccccccc: z,
694}
695
696// aligned
697var _ = T3{
698 aaaaaaaaaaaaaaaaaaaa: x,
699 b: y,
700 c: z,
701}
702
703// not aligned
704var _ = T4{
705 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: x,
706 b: y,
707 c: z,
708}
709
710// no alignment of map composite entries if they are not the first entry on a line
711var _ = T{0: 0} // not aligned
712var _ = T{0: 0, // not aligned
713 1: 1, // aligned
714 22: 22, // aligned
715 333: 333, 1234: 12, 12345: 0, // first on line aligned
716}
717
718// test cases form issue 8685
719// not aligned
720var _ = map[int]string{1: "spring", 2: "summer",
721 3: "autumn", 4: "winter"}
722
723// not aligned
724var _ = map[string]string{"a": "spring", "b": "summer",
725 "c": "autumn", "d": "winter"}
726
727// aligned
728var _ = map[string]string{"a": "spring",
729 "b": "summer",
730 "c": "autumn",
731 "d": "winter"}
732
733func _() {
734 var _ = T{
735 a, // must introduce trailing comma
736 }
737}
738
739// formatting of function results
740func _() func() {}
741func _() func(int) { return nil }
742func _() func(int) int { return nil }
743func _() func(int) func(int) func() { return nil }
744
745// formatting of consecutive single-line functions
746func _() {}
747func _() {}
748func _() {}
749
750func _() {} // an empty line before this function
751func _() {}
752func _() {}
753
754func _() { f(1, 2, 3) }
755func _(x int) int { y := x; return y + 1 }
756func _() int { type T struct{}; var x T; return x }
757
758// these must remain multi-line since they are multi-line in the source
759func _() {
760 f(1, 2, 3)
761}
762func _(x int) int {
763 y := x
764 return y + 1
765}
766func _() int {
767 type T struct{}
768 var x T
769 return x
770}
771
772// making function declarations safe for new semicolon rules
773func _() { /* single-line function because of "short-ish" comment */ }
774func _() { /* multi-line function because of "long-ish" comment - much more comment text is following here */ /* and more */
775}
776
777func _() {
778 /* multi-line func because block is on multiple lines */
779}
780
781// test case for issue #19544
782func _() {}
783func _longer_name_() { // this comment must not force the {} from above to alignment
784 // multiple lines
785}
786
787// ellipsis parameters
788func _(...int)
789func _(...*int)
790func _(...[]int)
791func _(...struct{})
792func _(bool, ...interface{})
793func _(bool, ...func())
794func _(bool, ...func(...int))
795func _(bool, ...map[string]int)
796func _(bool, ...chan int)
797
798func _(b bool, x ...int)
799func _(b bool, x ...*int)
800func _(b bool, x ...[]int)
801func _(b bool, x ...struct{})
802func _(x ...interface{})
803func _(x ...func())
804func _(x ...func(...int))
805func _(x ...map[string]int)
806func _(x ...chan int)
807
808// these parameter lists must remain multi-line since they are multi-line in the source
809func _(bool,
810 int) {
811}
812func _(x bool,
813 y int) {
814}
815func _(x,
816 y bool) {
817}
818func _(bool, // comment
819 int) {
820}
821func _(x bool, // comment
822 y int) {
823}
824func _(x, // comment
825 y bool) {
826}
827func _(bool, // comment
828 // comment
829 int) {
830}
831func _(x bool, // comment
832 // comment
833 y int) {
834}
835func _(x, // comment
836 // comment
837 y bool) {
838}
839func _(bool,
840 // comment
841 int) {
842}
843func _(x bool,
844 // comment
845 y int) {
846}
847func _(x,
848 // comment
849 y bool) {
850}
851func _(x, // comment
852 y, // comment
853 z bool) {
854}
855func _(x, // comment
856 y, // comment
857 z bool) {
858}
859func _(x int, // comment
860 y float, // comment
861 z bool) {
862}
863
864// properly indent multi-line signatures
865func ManageStatus(in <-chan *Status, req <-chan Request,
866 stat chan<- *TargetInfo,
867 TargetHistorySize int) {
868}
869
870func MultiLineSignature0(
871 a, b, c int,
872) {
873}
874
875func MultiLineSignature1(
876 a, b, c int,
877 u, v, w float,
878) {
879}
880
881func MultiLineSignature2(
882 a, b,
883 c int,
884) {
885}
886
887func MultiLineSignature3(
888 a, b,
889 c int, u, v,
890 w float,
891 x ...int) {
892}
893
894func MultiLineSignature4(
895 a, b, c int,
896 u, v,
897 w float,
898 x ...int) {
899}
900
901func MultiLineSignature5(
902 a, b, c int,
903 u, v, w float,
904 p, q,
905 r string,
906 x ...int) {
907}
908
909// make sure it also works for methods in interfaces
910type _ interface {
911 MultiLineSignature0(
912 a, b, c int,
913 )
914
915 MultiLineSignature1(
916 a, b, c int,
917 u, v, w float,
918 )
919
920 MultiLineSignature2(
921 a, b,
922 c int,
923 )
924
925 MultiLineSignature3(
926 a, b,
927 c int, u, v,
928 w float,
929 x ...int)
930
931 MultiLineSignature4(
932 a, b, c int,
933 u, v,
934 w float,
935 x ...int)
936
937 MultiLineSignature5(
938 a, b, c int,
939 u, v, w float,
940 p, q,
941 r string,
942 x ...int)
943}
944
945// omit superfluous parentheses in parameter lists
946func _(int)
947func _(int)
948func _(x int)
949func _(x int)
950func _(x, y int)
951func _(x, y int)
952
953func _() int
954func _() int
955func _() int
956
957func _() (x int)
958func _() (x int)
959func _() (x int)
960
961// special cases: some channel types require parentheses
962func _(x chan (<-chan int))
963func _(x chan (<-chan int))
964func _(x chan (<-chan int))
965
966func _(x chan<- (chan int))
967func _(x chan<- (chan int))
968func _(x chan<- (chan int))
969
970// don't introduce comma after last parameter if the closing ) is on the same line
971// even if the parameter type itself is multi-line (test cases from issue 4533)
972func _(...interface{})
973func _(...interface {
974 m()
975 n()
976}) // no extra comma between } and )
977
978func (t *T) _(...interface{})
979func (t *T) _(...interface {
980 m()
981 n()
982}) // no extra comma between } and )
983
984func _(interface{})
985func _(interface {
986 m()
987}) // no extra comma between } and )
988
989func _(struct{})
990func _(struct {
991 x int
992 y int
993}) // no extra comma between } and )
994
995// alias declarations
996
997type c0 struct{}
998type c1 = C
999type c2 = struct{ x int }
1000type c3 = p.C
1001type (
1002 s struct{}
1003 a = A
1004 b = A
1005 c = foo
1006 d = interface{}
1007 ddd = p.Foo
1008)
View as plain text