github.com/AndrienkoAleksandr/go@v0.0.19/src/go/printer/testdata/declarations.golden (about) 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 _ = "bar9876" 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 )