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
5 package imports
6
7 import "io"
8
9 import (
10 _ "io"
11 )
12
13 import _ "io"
14
15 import (
16 "io"
17 "io"
18 "io"
19 )
20
21 import (
22 "io"
23 aLongRename "io"
24
25 b "io"
26 )
27
28 import (
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)
39 import _ "io"
40 import _ "io"
41 import _ "io"
42
43 import _ "os"
44 import _ "os"
45 import _ "os"
46
47 import _ "fmt"
48 import _ "fmt"
49 import _ "fmt"
50
51 import "foo" // a comment
52 import "bar" // a comment
53
54 import (
55 _ "foo"
56 // a comment
57 "bar"
58 "foo" // a comment
59 "bar" // a comment
60 )
61
62 // comments + renames
63 import (
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)
74 import (
75 . "fmt"
76 "io"
77 "malloc" // for the malloc count test only
78 "math"
79 "strings"
80 "testing"
81 )
82
83 // more import examples
84 import (
85 "xxx"
86 "much_longer_name" // comment
87 "short_name" // comment
88 )
89
90 import (
91 _ "xxx"
92 "much_longer_name" // comment
93 )
94
95 import (
96 mymath "math"
97 "/foo/bar/long_package_path" // a comment
98 )
99
100 import (
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)
117 import (
118 "fmt"
119 "math"
120 )
121
122 // at least one empty line between declarations of different kind
123 import _ "io"
124
125 var _ int
126
127 // at least one empty line between declarations of the same kind
128 // if there is associated documentation (was issue 2570)
129 type T1 struct{}
130
131 // T2 comment
132 type T2 struct {
133 } // should be a two-line struct
134
135 // T3 comment
136 type T2 struct {
137 } // should be a two-line struct
138
139 // printing of constant literals
140 const (
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 ---
177 bar`
178 )
179
180 func _() {
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
225 const (
226 _ int = 0
227 _ float = 1
228
229 _ string = "foo"
230
231 _ = iota
232 _
233
234 // a comment
235 _
236
237 _
238 )
239
240 type (
241 _ int
242 _ struct{}
243
244 _ interface{}
245
246 // a comment
247 _ map[string]int
248 )
249
250 var (
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
263 type _ 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
311 type _ struct{}
312 type _ struct {
313 }
314
315 type _ interface{}
316 type _ interface {
317 }
318
319 // no tabs for single or ungrouped decls
320 func _() {
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
345 func _() {
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
364 func _() {
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)
411 const (
412 short = 2 * (1 + 2)
413 aMuchLongerName = 3
414 )
415
416 var (
417 short = X{}
418 aMuchLongerName = X{}
419
420 x1 = X{} // foo
421 x2 = X{} // foo
422 )
423
424 func _() {
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)
440 const (
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
448 const (
449 a MyType = iota
450 abcd
451 b
452 c
453 def
454 )
455
456 // excerpt from godoc.go
457 var (
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
467 type _ struct{}
468
469 type _ struct { /* this comment should be visible */
470 }
471
472 type _ struct {
473 // this comment should be visible and properly indented
474 }
475
476 type _ struct { // this comment must not change indentation
477 f int
478 f, ff, fff, ffff int
479 }
480
481 type _ struct {
482 string
483 }
484
485 type _ struct {
486 string // comment
487 }
488
489 type _ struct {
490 string "tag"
491 }
492
493 type _ struct {
494 string "tag" // comment
495 }
496
497 type _ struct {
498 f int
499 }
500
501 type _ struct {
502 f int // comment
503 }
504
505 type _ struct {
506 f int "tag"
507 }
508
509 type _ struct {
510 f int "tag" // comment
511 }
512
513 type _ 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
525 type _ 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
534 type _ struct {
535 bool // comment
536 text []byte // comment
537 }
538
539 // formatting of interfaces
540 type EI interface{}
541
542 type _ interface {
543 EI
544 }
545
546 type _ interface {
547 f()
548 fffff()
549 }
550
551 type _ interface {
552 EI
553 f()
554 fffffg()
555 }
556
557 type _ 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
565 func _() {
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
582 var a1, b1, c1 int // all on one line
583
584 var a2, b2,
585 c2 int // this line should be indented
586
587 var (
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.
596 var (
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
604 func _() {
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
615 func _() {
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
659 var _ = 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
683 var _ = T1{
684 a: x,
685 b: y,
686 cccccccccccccccccccc: z,
687 }
688
689 // not aligned
690 var _ = T2{
691 a: x,
692 b: y,
693 ccccccccccccccccccccc: z,
694 }
695
696 // aligned
697 var _ = T3{
698 aaaaaaaaaaaaaaaaaaaa: x,
699 b: y,
700 c: z,
701 }
702
703 // not aligned
704 var _ = 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
711 var _ = T{0: 0} // not aligned
712 var _ = 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
720 var _ = map[int]string{1: "spring", 2: "summer",
721 3: "autumn", 4: "winter"}
722
723 // not aligned
724 var _ = map[string]string{"a": "spring", "b": "summer",
725 "c": "autumn", "d": "winter"}
726
727 // aligned
728 var _ = map[string]string{"a": "spring",
729 "b": "summer",
730 "c": "autumn",
731 "d": "winter"}
732
733 func _() {
734 var _ = T{
735 a, // must introduce trailing comma
736 }
737 }
738
739 // formatting of function results
740 func _() func() {}
741 func _() func(int) { return nil }
742 func _() func(int) int { return nil }
743 func _() func(int) func(int) func() { return nil }
744
745 // formatting of consecutive single-line functions
746 func _() {}
747 func _() {}
748 func _() {}
749
750 func _() {} // an empty line before this function
751 func _() {}
752 func _() {}
753
754 func _() { f(1, 2, 3) }
755 func _(x int) int { y := x; return y + 1 }
756 func _() int { type T struct{}; var x T; return x }
757
758 // these must remain multi-line since they are multi-line in the source
759 func _() {
760 f(1, 2, 3)
761 }
762 func _(x int) int {
763 y := x
764 return y + 1
765 }
766 func _() int {
767 type T struct{}
768 var x T
769 return x
770 }
771
772 // making function declarations safe for new semicolon rules
773 func _() { /* single-line function because of "short-ish" comment */ }
774 func _() { /* multi-line function because of "long-ish" comment - much more comment text is following here */ /* and more */
775 }
776
777 func _() {
778 /* multi-line func because block is on multiple lines */
779 }
780
781 // test case for issue #19544
782 func _() {}
783 func _longer_name_() { // this comment must not force the {} from above to alignment
784 // multiple lines
785 }
786
787 // ellipsis parameters
788 func _(...int)
789 func _(...*int)
790 func _(...[]int)
791 func _(...struct{})
792 func _(bool, ...interface{})
793 func _(bool, ...func())
794 func _(bool, ...func(...int))
795 func _(bool, ...map[string]int)
796 func _(bool, ...chan int)
797
798 func _(b bool, x ...int)
799 func _(b bool, x ...*int)
800 func _(b bool, x ...[]int)
801 func _(b bool, x ...struct{})
802 func _(x ...interface{})
803 func _(x ...func())
804 func _(x ...func(...int))
805 func _(x ...map[string]int)
806 func _(x ...chan int)
807
808 // these parameter lists must remain multi-line since they are multi-line in the source
809 func _(bool,
810 int) {
811 }
812 func _(x bool,
813 y int) {
814 }
815 func _(x,
816 y bool) {
817 }
818 func _(bool, // comment
819 int) {
820 }
821 func _(x bool, // comment
822 y int) {
823 }
824 func _(x, // comment
825 y bool) {
826 }
827 func _(bool, // comment
828 // comment
829 int) {
830 }
831 func _(x bool, // comment
832 // comment
833 y int) {
834 }
835 func _(x, // comment
836 // comment
837 y bool) {
838 }
839 func _(bool,
840 // comment
841 int) {
842 }
843 func _(x bool,
844 // comment
845 y int) {
846 }
847 func _(x,
848 // comment
849 y bool) {
850 }
851 func _(x, // comment
852 y, // comment
853 z bool) {
854 }
855 func _(x, // comment
856 y, // comment
857 z bool) {
858 }
859 func _(x int, // comment
860 y float, // comment
861 z bool) {
862 }
863
864 // properly indent multi-line signatures
865 func ManageStatus(in <-chan *Status, req <-chan Request,
866 stat chan<- *TargetInfo,
867 TargetHistorySize int) {
868 }
869
870 func MultiLineSignature0(
871 a, b, c int,
872 ) {
873 }
874
875 func MultiLineSignature1(
876 a, b, c int,
877 u, v, w float,
878 ) {
879 }
880
881 func MultiLineSignature2(
882 a, b,
883 c int,
884 ) {
885 }
886
887 func MultiLineSignature3(
888 a, b,
889 c int, u, v,
890 w float,
891 x ...int) {
892 }
893
894 func MultiLineSignature4(
895 a, b, c int,
896 u, v,
897 w float,
898 x ...int) {
899 }
900
901 func 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
910 type _ 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
946 func _(int)
947 func _(int)
948 func _(x int)
949 func _(x int)
950 func _(x, y int)
951 func _(x, y int)
952
953 func _() int
954 func _() int
955 func _() int
956
957 func _() (x int)
958 func _() (x int)
959 func _() (x int)
960
961 // special cases: some channel types require parentheses
962 func _(x chan (<-chan int))
963 func _(x chan (<-chan int))
964 func _(x chan (<-chan int))
965
966 func _(x chan<- (chan int))
967 func _(x chan<- (chan int))
968 func _(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)
972 func _(...interface{})
973 func _(...interface {
974 m()
975 n()
976 }) // no extra comma between } and )
977
978 func (t *T) _(...interface{})
979 func (t *T) _(...interface {
980 m()
981 n()
982 }) // no extra comma between } and )
983
984 func _(interface{})
985 func _(interface {
986 m()
987 }) // no extra comma between } and )
988
989 func _(struct{})
990 func _(struct {
991 x int
992 y int
993 }) // no extra comma between } and )
994
995 // alias declarations
996
997 type c0 struct{}
998 type c1 = C
999 type c2 = struct{ x int }
1000 type c3 = p.C
1001 type (
1002 s struct{}
1003 a = A
1004 b = A
1005 c = foo
1006 d = interface{}
1007 ddd = p.Foo
1008 )
1009
View as plain text