...
Run Format

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

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 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		if; true {}  // no semicolon printed
   134		if expr{}
   135		if;expr{}  // no semicolon printed
   136		if (expr){}  // no parens printed
   137		if;((expr)){}  // no semicolon and parens printed
   138		if x:=expr;true{
   139		use(x)}
   140		if x:=expr; expr {use(x)}
   141	}
   142	
   143	
   144	// Formatting of switch-statement headers.
   145	func _() {
   146		switch {}
   147		switch;{}  // no semicolon printed
   148		switch expr {}
   149		switch;expr{}  // no semicolon printed
   150		switch (expr) {}  // no parens printed
   151		switch;((expr)){}  // no semicolon and parens printed
   152		switch x := expr; { default:use(
   153	x)
   154		}
   155		switch x := expr; expr {default:use(x)}
   156	}
   157	
   158	
   159	// Formatting of switch statement bodies.
   160	func _() {
   161		switch {
   162		}
   163	
   164		switch x := 0; x {
   165		case 1:
   166			use(x)
   167			use(x)  // followed by an empty line
   168	
   169		case 2:  // followed by an empty line
   170	
   171			use(x)  // followed by an empty line
   172	
   173		case 3:  // no empty lines
   174			use(x)
   175			use(x)
   176		}
   177	
   178		switch x {
   179		case 0:
   180			use(x)
   181		case 1:  // this comment should have no effect on the previous or next line
   182			use(x)
   183		}
   184	
   185		switch x := 0; x {
   186		case 1:
   187			x = 0
   188			// this comment should be indented
   189		case 2:
   190			x = 0
   191		// this comment should not be indented, it is aligned with the next case
   192		case 3:
   193			x = 0
   194			/* indented comment
   195			   aligned
   196			   aligned
   197			*/
   198			// bla
   199			/* and more */
   200		case 4:
   201			x = 0
   202		/* not indented comment
   203		   aligned
   204		   aligned
   205		*/
   206		// bla
   207		/* and more */
   208		case 5:
   209		}
   210	}
   211	
   212	
   213	// Formatting of selected select statements.
   214	func _() {
   215		select {
   216		}
   217		select { /* this comment should not be tab-aligned because the closing } is on the same line */ }
   218		select { /* this comment should be tab-aligned */
   219		}
   220		select { // this comment should be tab-aligned
   221		}
   222		select { case <-c: }
   223	}
   224	
   225	
   226	// Formatting of for-statement headers for single-line for-loops.
   227	func _() {
   228		for{}
   229		for expr {}
   230		for (expr) {}  // no parens printed
   231		for;;{}  // no semicolons printed
   232		for x :=expr;; {use( x)}
   233		for; expr;{}  // no semicolons printed
   234		for; ((expr));{}  // no semicolons and parens printed
   235		for; ; expr = false {}
   236		for x :=expr; expr; {use(x)}
   237		for x := expr;; expr=false {use(x)}
   238		for;expr;expr =false {}
   239		for x := expr;expr;expr = false { use(x) }
   240		for x := range []int{} { use(x) }
   241		for x := range (([]int{})) { use(x) }  // no parens printed
   242	}
   243	
   244	
   245	// Formatting of for-statement headers for multi-line for-loops.
   246	func _() {
   247		for{
   248		}
   249		for expr {
   250		}
   251		for (expr) {
   252		}  // no parens printed
   253		for;;{
   254		}  // no semicolons printed
   255		for x :=expr;; {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; {use(x)
   264		}
   265		for x := expr;; expr=false {use(x)
   266		}
   267		for;expr;expr =false {
   268		}
   269		for x := expr;expr;expr = false {
   270		use(x)
   271		}
   272		for range []int{} {
   273		println("foo")}
   274		for x := range []int{} {
   275		use(x) }
   276		for x := range (([]int{})) {
   277		use(x) }  // no parens printed
   278	}
   279	
   280	
   281	// Formatting of selected short single- and multi-line statements.
   282	func _() {
   283		if cond {}
   284		if cond {
   285		} // multiple lines
   286		if cond {} else {} // else clause always requires multiple lines
   287	
   288		for {}
   289		for i := 0; i < len(a); 1++ {}
   290		for i := 0; i < len(a); 1++ { a[i] = i }
   291		for i := 0; i < len(a); 1++ { a[i] = i
   292		} // multiple lines
   293	
   294		for range a{}
   295		for _ = range a{}
   296		for _, _ = range a{}
   297		for i := range a {}
   298		for i := range a { a[i] = i }
   299		for i := range a { a[i] = i
   300		} // multiple lines
   301	
   302		go func() { for { a <- <-b } }()
   303		defer func() { if x := recover(); x != nil { err = fmt.Sprintf("error: %s", x.msg) } }()
   304	}
   305	
   306	
   307	// Don't remove mandatory parentheses around composite literals in control clauses.
   308	func _() {
   309		// strip parentheses - no composite literals or composite literals don't start with a type name
   310		if (x) {}
   311		if (((x))) {}
   312		if ([]T{}) {}
   313		if (([]T{})) {}
   314		if ; (((([]T{})))) {}
   315	
   316		for (x) {}
   317		for (((x))) {}
   318		for ([]T{}) {}
   319		for (([]T{})) {}
   320		for ; (((([]T{})))) ; {}
   321	
   322		switch (x) {}
   323		switch (((x))) {}
   324		switch ([]T{}) {}
   325		switch ; (((([]T{})))) {}
   326	
   327		for _ = range ((([]T{T{42}}))) {}
   328	
   329		// leave parentheses - composite literals start with a type name
   330		if (T{}) {}
   331		if ((T{})) {}
   332		if ; ((((T{})))) {}
   333	
   334		for (T{}) {}
   335		for ((T{})) {}
   336		for ; ((((T{})))) ; {}
   337	
   338		switch (T{}) {}
   339		switch ; ((((T{})))) {}
   340	
   341		for _ = range (((T1{T{42}}))) {}
   342	
   343		if x == (T{42}[0]) {}
   344		if (x == T{42}[0]) {}
   345		if (x == (T{42}[0])) {}
   346		if (x == (((T{42}[0])))) {}
   347		if (((x == (T{42}[0])))) {}
   348		if x == a + b*(T{42}[0]) {}
   349		if (x == a + b*T{42}[0]) {}
   350		if (x == a + b*(T{42}[0])) {}
   351		if (x == a + ((b * (T{42}[0])))) {}
   352		if (((x == a + b * (T{42}[0])))) {}
   353		if (((a + b * (T{42}[0])) == x)) {}
   354		if (((a + b * (T{42}[0])))) == x {}
   355	
   356		if (struct{x bool}{false}.x) {}
   357		if (struct{x bool}{false}.x) == false {}
   358		if (struct{x bool}{false}.x == false) {}
   359	}
   360	
   361	
   362	// Extra empty lines inside functions. Do respect source code line
   363	// breaks between statement boundaries but print at most one empty
   364	// line at a time.
   365	func _() {
   366	
   367		const _ = 0
   368	
   369		const _ = 1
   370		type _ int
   371		type _ float
   372	
   373		var _ = 0
   374		var x = 1
   375	
   376		// Each use(x) call below should have at most one empty line before and after.
   377		// Known bug: The first use call may have more than one empty line before
   378		//            (see go/printer/nodes.go, func linebreak).
   379	
   380	
   381	
   382		use(x)
   383	
   384		if x < x {
   385	
   386			use(x)
   387	
   388		} else {
   389	
   390			use(x)
   391	
   392		}
   393	}
   394	
   395	
   396	// Formatting around labels.
   397	func _() {
   398		L:
   399	}
   400	
   401	
   402	func _() {
   403		// this comment should be indented
   404		L: ;  // no semicolon needed
   405	}
   406	
   407	
   408	func _() {
   409		switch 0 {
   410		case 0:
   411			L0: ;  // semicolon required
   412		case 1:
   413			L1: ;  // semicolon required
   414		default:
   415			L2: ;  // no semicolon needed
   416		}
   417	}
   418	
   419	
   420	func _() {
   421		f()
   422	L1:
   423		f()
   424	L2:
   425		;
   426	L3:
   427	}
   428	
   429	
   430	func _() {
   431		// this comment should be indented
   432		L:
   433	}
   434	
   435	
   436	func _() {
   437		L: _ = 0
   438	}
   439	
   440	
   441	func _() {
   442		// this comment should be indented
   443		L: _ = 0
   444	}
   445	
   446	
   447	func _() {
   448		for {
   449		L1: _ = 0
   450		L2:
   451			_ = 0
   452		}
   453	}
   454	
   455	
   456	func _() {
   457			// this comment should be indented
   458		for {
   459		L1: _ = 0
   460		L2:
   461			_ = 0
   462		}
   463	}
   464	
   465	
   466	func _() {
   467		if true {
   468			_ = 0
   469		}
   470		_ = 0  // the indentation here should not be affected by the long label name
   471	AnOverlongLabel:
   472		_ = 0
   473		
   474		if true {
   475			_ = 0
   476		}
   477		_ = 0
   478	
   479	L:	_ = 0
   480	}
   481	
   482	
   483	func _() {
   484		for {
   485			goto L
   486		}
   487	L:
   488	
   489		MoreCode()
   490	}
   491	
   492	
   493	func _() {
   494		for {
   495			goto L
   496		}
   497	L:	// A comment on the same line as the label, followed by a single empty line.
   498		// Known bug: There may be more than one empty line before MoreCode()
   499		//            (see go/printer/nodes.go, func linebreak).
   500	
   501	
   502	
   503	
   504		MoreCode()
   505	}
   506	
   507	
   508	func _() {
   509		for {
   510			goto L
   511		}
   512	L:
   513	
   514	
   515	
   516	
   517		// There should be a single empty line before this comment.
   518		MoreCode()
   519	}
   520	
   521	
   522	func _() {
   523		for {
   524			goto AVeryLongLabelThatShouldNotAffectFormatting
   525		}
   526	AVeryLongLabelThatShouldNotAffectFormatting:
   527		// There should be a single empty line after this comment.
   528	
   529		// There should be a single empty line before this comment.
   530		MoreCode()
   531	}
   532	
   533	
   534	// Formatting of empty statements.
   535	func _() {
   536		;;;;;;;;;;;;;;;;;;;;;;;;;
   537	}
   538	
   539	func _() {;;;;;;;;;;;;;;;;;;;;;;;;;
   540	}
   541	
   542	func _() {;;;;;;;;;;;;;;;;;;;;;;;;;}
   543	
   544	func _() {
   545	f();;;;;;;;;;;;;;;;;;;;;;;;;
   546	}
   547	
   548	func _() {
   549	L:;;;;;;;;;;;;
   550	}
   551	
   552	func _() {
   553	L:;;;;;;;;;;;;
   554		f()
   555	}

View as plain text