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

     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 statements
     6  
     7  var expr bool
     8  
     9  func use(x interface{})	{}
    10  
    11  // Formatting of multi-line return statements.
    12  func _f() {
    13  	return
    14  	return x, y, z
    15  	return T{}
    16  	return T{1, 2, 3},
    17  		x, y, z
    18  	return T{1, 2, 3},
    19  		x, y,
    20  		z
    21  	return T{1,
    22  		2,
    23  		3}
    24  	return T{1,
    25  		2,
    26  		3,
    27  	}
    28  	return T{
    29  		1,
    30  		2,
    31  		3}
    32  	return T{
    33  		1,
    34  		2,
    35  		3,
    36  	}
    37  	return T{
    38  		1,
    39  		T{1, 2, 3},
    40  		3,
    41  	}
    42  	return T{
    43  		1,
    44  		T{1,
    45  			2, 3},
    46  		3,
    47  	}
    48  	return T{
    49  		1,
    50  		T{1,
    51  			2,
    52  			3},
    53  		3,
    54  	}
    55  	return T{
    56  		1,
    57  		2,
    58  	}, nil
    59  	return T{
    60  			1,
    61  			2,
    62  		},
    63  		T{
    64  			x:	3,
    65  			y:	4,
    66  		}, nil
    67  	return T{
    68  			1,
    69  			2,
    70  		},
    71  		nil
    72  	return T{
    73  			1,
    74  			2,
    75  		},
    76  		T{
    77  			x:	3,
    78  			y:	4,
    79  		},
    80  		nil
    81  	return x + y +
    82  		z
    83  	return func() {}
    84  	return func() {
    85  			_ = 0
    86  		}, T{
    87  			1, 2,
    88  		}
    89  	return func() {
    90  		_ = 0
    91  	}
    92  	return func() T {
    93  		return T{
    94  			1, 2,
    95  		}
    96  	}
    97  }
    98  
    99  // Formatting of multi-line returns: test cases from issue 1207.
   100  func F() (*T, os.Error) {
   101  	return &T{
   102  			X:	1,
   103  			Y:	2,
   104  		},
   105  		nil
   106  }
   107  
   108  func G() (*T, *T, os.Error) {
   109  	return &T{
   110  			X:	1,
   111  			Y:	2,
   112  		},
   113  		&T{
   114  			X:	3,
   115  			Y:	4,
   116  		},
   117  		nil
   118  }
   119  
   120  func _() interface{} {
   121  	return &fileStat{
   122  		name:		basename(file.name),
   123  		size:		mkSize(d.FileSizeHigh, d.FileSizeLow),
   124  		modTime:	mkModTime(d.LastWriteTime),
   125  		mode:		mkMode(d.FileAttributes),
   126  		sys:		mkSysFromFI(&d),
   127  	}, nil
   128  }
   129  
   130  // Formatting of if-statement headers.
   131  func _() {
   132  	if true {
   133  	}
   134  	if true {
   135  	}	// no semicolon printed
   136  	if expr {
   137  	}
   138  	if expr {
   139  	}	// no semicolon printed
   140  	if expr {
   141  	}	// no parens printed
   142  	if expr {
   143  	}	// no semicolon and parens printed
   144  	if x := expr; true {
   145  		use(x)
   146  	}
   147  	if x := expr; expr {
   148  		use(x)
   149  	}
   150  }
   151  
   152  // Formatting of switch-statement headers.
   153  func _() {
   154  	switch {
   155  	}
   156  	switch {
   157  	}	// no semicolon printed
   158  	switch expr {
   159  	}
   160  	switch expr {
   161  	}	// no semicolon printed
   162  	switch expr {
   163  	}	// no parens printed
   164  	switch expr {
   165  	}	// no semicolon and parens printed
   166  	switch x := expr; {
   167  	default:
   168  		use(
   169  			x)
   170  	}
   171  	switch x := expr; expr {
   172  	default:
   173  		use(x)
   174  	}
   175  }
   176  
   177  // Formatting of switch statement bodies.
   178  func _() {
   179  	switch {
   180  	}
   181  
   182  	switch x := 0; x {
   183  	case 1:
   184  		use(x)
   185  		use(x)	// followed by an empty line
   186  
   187  	case 2:	// followed by an empty line
   188  
   189  		use(x)	// followed by an empty line
   190  
   191  	case 3:	// no empty lines
   192  		use(x)
   193  		use(x)
   194  	}
   195  
   196  	switch x {
   197  	case 0:
   198  		use(x)
   199  	case 1:	// this comment should have no effect on the previous or next line
   200  		use(x)
   201  	}
   202  
   203  	switch x := 0; x {
   204  	case 1:
   205  		x = 0
   206  		// this comment should be indented
   207  	case 2:
   208  		x = 0
   209  	// this comment should not be indented, it is aligned with the next case
   210  	case 3:
   211  		x = 0
   212  		/* indented comment
   213  		   aligned
   214  		   aligned
   215  		*/
   216  		// bla
   217  		/* and more */
   218  	case 4:
   219  		x = 0
   220  	/* not indented comment
   221  	   aligned
   222  	   aligned
   223  	*/
   224  	// bla
   225  	/* and more */
   226  	case 5:
   227  	}
   228  }
   229  
   230  // Formatting of selected select statements.
   231  func _() {
   232  	select {}
   233  	select { /* this comment should not be tab-aligned because the closing } is on the same line */
   234  	}
   235  	select {	/* this comment should be tab-aligned */
   236  	}
   237  	select {	// this comment should be tab-aligned
   238  	}
   239  	select {
   240  	case <-c:
   241  	}
   242  }
   243  
   244  // Formatting of for-statement headers for single-line for-loops.
   245  func _() {
   246  	for {
   247  	}
   248  	for expr {
   249  	}
   250  	for expr {
   251  	}	// no parens printed
   252  	for {
   253  	}	// no semicolons printed
   254  	for x := expr; ; {
   255  		use(x)
   256  	}
   257  	for expr {
   258  	}	// no semicolons printed
   259  	for expr {
   260  	}	// no semicolons and parens printed
   261  	for ; ; expr = false {
   262  	}
   263  	for x := expr; expr; {
   264  		use(x)
   265  	}
   266  	for x := expr; ; expr = false {
   267  		use(x)
   268  	}
   269  	for ; expr; expr = false {
   270  	}
   271  	for x := expr; expr; expr = false {
   272  		use(x)
   273  	}
   274  	for x := range []int{} {
   275  		use(x)
   276  	}
   277  	for x := range []int{} {
   278  		use(x)
   279  	}	// no parens printed
   280  }
   281  
   282  // Formatting of for-statement headers for multi-line for-loops.
   283  func _() {
   284  	for {
   285  	}
   286  	for expr {
   287  	}
   288  	for expr {
   289  	}	// no parens printed
   290  	for {
   291  	}	// no semicolons printed
   292  	for x := expr; ; {
   293  		use(x)
   294  	}
   295  	for expr {
   296  	}	// no semicolons printed
   297  	for expr {
   298  	}	// no semicolons and parens printed
   299  	for ; ; expr = false {
   300  	}
   301  	for x := expr; expr; {
   302  		use(x)
   303  	}
   304  	for x := expr; ; expr = false {
   305  		use(x)
   306  	}
   307  	for ; expr; expr = false {
   308  	}
   309  	for x := expr; expr; expr = false {
   310  		use(x)
   311  	}
   312  	for range []int{} {
   313  		println("foo")
   314  	}
   315  	for x := range []int{} {
   316  		use(x)
   317  	}
   318  	for x := range []int{} {
   319  		use(x)
   320  	}	// no parens printed
   321  }
   322  
   323  // Formatting of selected short single- and multi-line statements.
   324  func _() {
   325  	if cond {
   326  	}
   327  	if cond {
   328  	}	// multiple lines
   329  	if cond {
   330  	} else {
   331  	}	// else clause always requires multiple lines
   332  
   333  	for {
   334  	}
   335  	for i := 0; i < len(a); 1++ {
   336  	}
   337  	for i := 0; i < len(a); 1++ {
   338  		a[i] = i
   339  	}
   340  	for i := 0; i < len(a); 1++ {
   341  		a[i] = i
   342  	}	// multiple lines
   343  
   344  	for range a {
   345  	}
   346  	for _ = range a {
   347  	}
   348  	for _, _ = range a {
   349  	}
   350  	for i := range a {
   351  	}
   352  	for i := range a {
   353  		a[i] = i
   354  	}
   355  	for i := range a {
   356  		a[i] = i
   357  	}	// multiple lines
   358  
   359  	go func() {
   360  		for {
   361  			a <- <-b
   362  		}
   363  	}()
   364  	defer func() {
   365  		if x := recover(); x != nil {
   366  			err = fmt.Sprintf("error: %s", x.msg)
   367  		}
   368  	}()
   369  }
   370  
   371  // Don't remove mandatory parentheses around composite literals in control clauses.
   372  func _() {
   373  	// strip parentheses - no composite literals or composite literals don't start with a type name
   374  	if x {
   375  	}
   376  	if x {
   377  	}
   378  	if []T{} {
   379  	}
   380  	if []T{} {
   381  	}
   382  	if []T{} {
   383  	}
   384  
   385  	for x {
   386  	}
   387  	for x {
   388  	}
   389  	for []T{} {
   390  	}
   391  	for []T{} {
   392  	}
   393  	for []T{} {
   394  	}
   395  
   396  	switch x {
   397  	}
   398  	switch x {
   399  	}
   400  	switch []T{} {
   401  	}
   402  	switch []T{} {
   403  	}
   404  
   405  	for _ = range []T{T{42}} {
   406  	}
   407  
   408  	// leave parentheses - composite literals start with a type name
   409  	if (T{}) {
   410  	}
   411  	if (T{}) {
   412  	}
   413  	if (T{}) {
   414  	}
   415  
   416  	for (T{}) {
   417  	}
   418  	for (T{}) {
   419  	}
   420  	for (T{}) {
   421  	}
   422  
   423  	switch (T{}) {
   424  	}
   425  	switch (T{}) {
   426  	}
   427  
   428  	for _ = range (T1{T{42}}) {
   429  	}
   430  
   431  	if x == (T{42}[0]) {
   432  	}
   433  	if (x == T{42}[0]) {
   434  	}
   435  	if x == (T{42}[0]) {
   436  	}
   437  	if x == (T{42}[0]) {
   438  	}
   439  	if x == (T{42}[0]) {
   440  	}
   441  	if x == a+b*(T{42}[0]) {
   442  	}
   443  	if (x == a+b*T{42}[0]) {
   444  	}
   445  	if x == a+b*(T{42}[0]) {
   446  	}
   447  	if x == a+(b*(T{42}[0])) {
   448  	}
   449  	if x == a+b*(T{42}[0]) {
   450  	}
   451  	if (a + b*(T{42}[0])) == x {
   452  	}
   453  	if (a + b*(T{42}[0])) == x {
   454  	}
   455  
   456  	if struct{ x bool }{false}.x {
   457  	}
   458  	if (struct{ x bool }{false}.x) == false {
   459  	}
   460  	if struct{ x bool }{false}.x == false {
   461  	}
   462  }
   463  
   464  // Extra empty lines inside functions. Do respect source code line
   465  // breaks between statement boundaries but print at most one empty
   466  // line at a time.
   467  func _() {
   468  
   469  	const _ = 0
   470  
   471  	const _ = 1
   472  	type _ int
   473  	type _ float
   474  
   475  	var _ = 0
   476  	var x = 1
   477  
   478  	// Each use(x) call below should have at most one empty line before and after.
   479  	// Known bug: The first use call may have more than one empty line before
   480  	//            (see go/printer/nodes.go, func linebreak).
   481  
   482  	use(x)
   483  
   484  	if x < x {
   485  
   486  		use(x)
   487  
   488  	} else {
   489  
   490  		use(x)
   491  
   492  	}
   493  }
   494  
   495  // Formatting around labels.
   496  func _() {
   497  L:
   498  }
   499  
   500  func _() {
   501  	// this comment should be indented
   502  L:	// no semicolon needed
   503  }
   504  
   505  func _() {
   506  	switch 0 {
   507  	case 0:
   508  	L0:
   509  		;	// semicolon required
   510  	case 1:
   511  	L1:
   512  		;	// semicolon required
   513  	default:
   514  	L2:	// no semicolon needed
   515  	}
   516  }
   517  
   518  func _() {
   519  	f()
   520  L1:
   521  	f()
   522  L2:
   523  	;
   524  L3:
   525  }
   526  
   527  func _() {
   528  	// this comment should be indented
   529  L:
   530  }
   531  
   532  func _() {
   533  L:
   534  	_ = 0
   535  }
   536  
   537  func _() {
   538  	// this comment should be indented
   539  L:
   540  	_ = 0
   541  }
   542  
   543  func _() {
   544  	for {
   545  	L1:
   546  		_ = 0
   547  	L2:
   548  		_ = 0
   549  	}
   550  }
   551  
   552  func _() {
   553  	// this comment should be indented
   554  	for {
   555  	L1:
   556  		_ = 0
   557  	L2:
   558  		_ = 0
   559  	}
   560  }
   561  
   562  func _() {
   563  	if true {
   564  		_ = 0
   565  	}
   566  	_ = 0	// the indentation here should not be affected by the long label name
   567  AnOverlongLabel:
   568  	_ = 0
   569  
   570  	if true {
   571  		_ = 0
   572  	}
   573  	_ = 0
   574  
   575  L:
   576  	_ = 0
   577  }
   578  
   579  func _() {
   580  	for {
   581  		goto L
   582  	}
   583  L:
   584  
   585  	MoreCode()
   586  }
   587  
   588  func _() {
   589  	for {
   590  		goto L
   591  	}
   592  L:	// A comment on the same line as the label, followed by a single empty line.
   593  	// Known bug: There may be more than one empty line before MoreCode()
   594  	//            (see go/printer/nodes.go, func linebreak).
   595  
   596  	MoreCode()
   597  }
   598  
   599  func _() {
   600  	for {
   601  		goto L
   602  	}
   603  L:
   604  
   605  	// There should be a single empty line before this comment.
   606  	MoreCode()
   607  }
   608  
   609  func _() {
   610  	for {
   611  		goto AVeryLongLabelThatShouldNotAffectFormatting
   612  	}
   613  AVeryLongLabelThatShouldNotAffectFormatting:
   614  	// There should be a single empty line after this comment.
   615  
   616  	// There should be a single empty line before this comment.
   617  	MoreCode()
   618  }
   619  
   620  // Formatting of empty statements.
   621  func _() {
   622  
   623  }
   624  
   625  func _() {
   626  }
   627  
   628  func _() {
   629  }
   630  
   631  func _() {
   632  	f()
   633  }
   634  
   635  func _() {
   636  L:
   637  	;
   638  }
   639  
   640  func _() {
   641  L:
   642  	;
   643  	f()
   644  }
   645  

View as plain text