...
Run Format

Text file src/go/printer/testdata/declarations.golden

Documentation: go/printer/testdata

     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	)

View as plain text