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 } 556
