.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.0.0-20201105173854-bc9fc8d8c4bc/refactor/rename/rename_test.go

   1 // Copyright 2014 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 rename
   6
   7 import (
   8         "bytes"
   9         "fmt"
  10         "go/build"
  11         "go/token"
  12         "io/ioutil"
  13         "os"
  14         "os/exec"
  15         "path/filepath"
  16         "regexp"
  17         "runtime"
  18         "strings"
  19         "testing"
  20
  21         "golang.org/x/tools/go/buildutil"
  22         "golang.org/x/tools/internal/testenv"
  23 )
  24
  25 // TODO(adonovan): test reported source positions, somehow.
  26
  27 func TestConflicts(t *testing.T) {
  28         defer func(savedWriteFile func(string, []byte) error, savedReportError func(token.Position, string)) {
  29                 writeFile = savedWriteFile
  30                 reportError = savedReportError
  31         }(writeFile, reportError)
  32         writeFile = func(string, []byte) error { return nil }
  33
  34         var ctxt *build.Context
  35         for _, test := range []struct {
  36                 ctxt             *build.Context // nil => use previous
  37                 offset, from, to string         // values of the -offset/-from and -to flags
  38                 want             string         // regexp to match conflict errors, or "OK"
  39         }{
  40                 // init() checks
  41                 {
  42                         ctxt: fakeContext(map[string][]string{
  43                                 "fmt": {`package fmt; type Stringer interface { String() }`},
  44                                 "main": {`
  45 package main
  46
  47 import foo "fmt"
  48
  49 var v foo.Stringer
  50
  51 func f() { v.String(); f() }
  52 `,
  53                                         `package main; var w int`},
  54                         }),
  55                         from: "main.v", to: "init",
  56                         want: `you cannot have a var at package level named "init"`,
  57                 },
  58                 {
  59                         from: "main.f", to: "init",
  60                         want: `renaming this func "f" to "init" would make it a package initializer.*` +
  61                                 `but references to it exist`,
  62                 },
  63                 {
  64                         from: "/go/src/main/0.go::foo", to: "init",
  65                         want: `"init" is not a valid imported package name`,
  66                 },
  67
  68                 // Export checks
  69                 {
  70                         from: "fmt.Stringer", to: "stringer",
  71                         want: `renaming this type "Stringer" to "stringer" would make it unexported.*` +
  72                                 `breaking references from packages such as "main"`,
  73                 },
  74                 {
  75                         from: "(fmt.Stringer).String", to: "string",
  76                         want: `renaming this method "String" to "string" would make it unexported.*` +
  77                                 `breaking references from packages such as "main"`,
  78                 },
  79
  80                 // Lexical scope checks
  81                 {
  82                         // file/package conflict, same file
  83                         from: "main.v", to: "foo",
  84                         want: `renaming this var "v" to "foo" would conflict.*` +
  85                                 `with this imported package name`,
  86                 },
  87                 {
  88                         // file/package conflict, same file
  89                         from: "main::foo", to: "v",
  90                         want: `renaming this imported package name "foo" to "v" would conflict.*` +
  91                                 `with this package member var`,
  92                 },
  93                 {
  94                         // file/package conflict, different files
  95                         from: "main.w", to: "foo",
  96                         want: `renaming this var "w" to "foo" would conflict.*` +
  97                                 `with this imported package name`,
  98                 },
  99                 {
 100                         // file/package conflict, different files
 101                         from: "main::foo", to: "w",
 102                         want: `renaming this imported package name "foo" to "w" would conflict.*` +
 103                                 `with this package member var`,
 104                 },
 105                 {
 106                         ctxt: main(`
 107 package main
 108
 109 var x, z int
 110
 111 func f(y int) {
 112         print(x)
 113         print(y)
 114 }
 115
 116 func g(w int) {
 117         print(x)
 118         x := 1
 119         print(x)
 120 }`),
 121                         from: "main.x", to: "y",
 122                         want: `renaming this var "x" to "y".*` +
 123                                 `would cause this reference to become shadowed.*` +
 124                                 `by this intervening var definition`,
 125                 },
 126                 {
 127                         from: "main.g::x", to: "w",
 128                         want: `renaming this var "x" to "w".*` +
 129                                 `conflicts with var in same block`,
 130                 },
 131                 {
 132                         from: "main.f::y", to: "x",
 133                         want: `renaming this var "y" to "x".*` +
 134                                 `would shadow this reference.*` +
 135                                 `to the var declared here`,
 136                 },
 137                 {
 138                         from: "main.g::w", to: "x",
 139                         want: `renaming this var "w" to "x".*` +
 140                                 `conflicts with var in same block`,
 141                 },
 142                 {
 143                         from: "main.z", to: "y", want: "OK",
 144                 },
 145
 146                 // Label checks
 147                 {
 148                         ctxt: main(`
 149 package main
 150
 151 func f() {
 152 foo:
 153         goto foo
 154 bar:
 155         goto bar
 156         func(x int) {
 157         wiz:
 158                 goto wiz
 159         }(0)
 160 }
 161 `),
 162                         from: "main.f::foo", to: "bar",
 163                         want: `renaming this label "foo" to "bar".*` +
 164                                 `would conflict with this one`,
 165                 },
 166                 {
 167                         from: "main.f::foo", to: "wiz", want: "OK",
 168                 },
 169                 {
 170                         from: "main.f::wiz", to: "x", want: "OK",
 171                 },
 172                 {
 173                         from: "main.f::x", to: "wiz", want: "OK",
 174                 },
 175                 {
 176                         from: "main.f::wiz", to: "foo", want: "OK",
 177                 },
 178
 179                 // Struct fields
 180                 {
 181                         ctxt: main(`
 182 package main
 183
 184 type U struct { u int }
 185 type V struct { v int }
 186
 187 func (V) x() {}
 188
 189 type W (struct {
 190         U
 191         V
 192         w int
 193 })
 194
 195 func f() {
 196         var w W
 197         print(w.u) // NB: there is no selection of w.v
 198         var _ struct { yy, zz int }
 199 }
 200 `),
 201                         // field/field conflict in named struct declaration
 202                         from: "(main.W).U", to: "w",
 203                         want: `renaming this field "U" to "w".*` +
 204                                 `would conflict with this field`,
 205                 },
 206                 {
 207                         // rename type used as embedded field
 208                         // => rename field
 209                         // => field/field conflict
 210                         // This is an entailed renaming;
 211                         // it would be nice if we checked source positions.
 212                         from: "main.U", to: "w",
 213                         want: `renaming this field "U" to "w".*` +
 214                                 `would conflict with this field`,
 215                 },
 216                 {
 217                         // field/field conflict in unnamed struct declaration
 218                         from: "main.f::zz", to: "yy",
 219                         want: `renaming this field "zz" to "yy".*` +
 220                                 `would conflict with this field`,
 221                 },
 222
 223                 // Now we test both directions of (u,v) (u,w) (v,w) (u,x) (v,x).
 224                 // Too bad we don't test position info...
 225                 {
 226                         // field/field ambiguity at same promotion level ('from' selection)
 227                         from: "(main.U).u", to: "v",
 228                         want: `renaming this field "u" to "v".*` +
 229                                 `would make this reference ambiguous.*` +
 230                                 `with this field`,
 231                 },
 232                 {
 233                         // field/field ambiguity at same promotion level ('to' selection)
 234                         from: "(main.V).v", to: "u",
 235                         want: `renaming this field "v" to "u".*` +
 236                                 `would make this reference ambiguous.*` +
 237                                 `with this field`,
 238                 },
 239                 {
 240                         // field/method conflict at different promotion level ('from' selection)
 241                         from: "(main.U).u", to: "w",
 242                         want: `renaming this field "u" to "w".*` +
 243                                 `would change the referent of this selection.*` +
 244                                 `of this field`,
 245                 },
 246                 {
 247                         // field/field shadowing at different promotion levels ('to' selection)
 248                         from: "(main.W).w", to: "u",
 249                         want: `renaming this field "w" to "u".*` +
 250                                 `would shadow this selection.*` +
 251                                 `of the field declared here`,
 252                 },
 253                 {
 254                         from: "(main.V).v", to: "w",
 255                         want: "OK", // since no selections are made ambiguous
 256                 },
 257                 {
 258                         from: "(main.W).w", to: "v",
 259                         want: "OK", // since no selections are made ambiguous
 260                 },
 261                 {
 262                         // field/method ambiguity at same promotion level ('from' selection)
 263                         from: "(main.U).u", to: "x",
 264                         want: `renaming this field "u" to "x".*` +
 265                                 `would make this reference ambiguous.*` +
 266                                 `with this method`,
 267                 },
 268                 {
 269                         // field/field ambiguity at same promotion level ('to' selection)
 270                         from: "(main.V).x", to: "u",
 271                         want: `renaming this method "x" to "u".*` +
 272                                 `would make this reference ambiguous.*` +
 273                                 `with this field`,
 274                 },
 275                 {
 276                         // field/method conflict at named struct declaration
 277                         from: "(main.V).v", to: "x",
 278                         want: `renaming this field "v" to "x".*` +
 279                                 `would conflict with this method`,
 280                 },
 281                 {
 282                         // field/method conflict at named struct declaration
 283                         from: "(main.V).x", to: "v",
 284                         want: `renaming this method "x" to "v".*` +
 285                                 `would conflict with this field`,
 286                 },
 287
 288                 // Methods
 289                 {
 290                         ctxt: main(`
 291 package main
 292 type C int
 293 func (C) f()
 294 func (C) g()
 295 type D int
 296 func (*D) f()
 297 func (*D) g()
 298 type I interface { f(); g() }
 299 type J interface { I; h() }
 300 var _ I = new(D)
 301 var _ interface {f()} = C(0)
 302 `),
 303                         from: "(main.I).f", to: "g",
 304                         want: `renaming this interface method "f" to "g".*` +
 305                                 `would conflict with this method`,
 306                 },
 307                 {
 308                         from: `("main".I).f`, to: "h", // NB: exercises quoted import paths too
 309                         want: `renaming this interface method "f" to "h".*` +
 310                                 `would conflict with this method.*` +
 311                                 `in named interface type "J"`,
 312                 },
 313                 {
 314                         // type J interface { h; h() } is not a conflict, amusingly.
 315                         from: "main.I", to: "h",
 316                         want: `OK`,
 317                 },
 318                 {
 319                         from: "(main.J).h", to: "f",
 320                         want: `renaming this interface method "h" to "f".*` +
 321                                 `would conflict with this method`,
 322                 },
 323                 {
 324                         from: "(main.C).f", to: "e",
 325                         want: `renaming this method "f" to "e".*` +
 326                                 `would make main.C no longer assignable to interface{f..}.*` +
 327                                 `(rename interface{f..}.f if you intend to change both types)`,
 328                 },
 329                 {
 330                         from: "(main.D).g", to: "e",
 331                         want: `renaming this method "g" to "e".*` +
 332                                 `would make \*main.D no longer assignable to interface I.*` +
 333                                 `(rename main.I.g if you intend to change both types)`,
 334                 },
 335                 {
 336                         from: "(main.I).f", to: "e",
 337                         want: `OK`,
 338                 },
 339                 // Indirect C/I method coupling via another concrete type D.
 340                 {
 341                         ctxt: main(`
 342 package main
 343 type I interface { f() }
 344 type C int
 345 func (C) f()
 346 type D struct{C}
 347 var _ I = D{}
 348 `),
 349                         from: "(main.C).f", to: "F",
 350                         want: `renaming this method "f" to "F".*` +
 351                                 `would make main.D no longer assignable to interface I.*` +
 352                                 `(rename main.I.f if you intend to change both types)`,
 353                 },
 354                 // Renaming causes promoted method to become shadowed; C no longer satisfies I.
 355                 {
 356                         ctxt: main(`
 357 package main
 358 type I interface { f() }
 359 type C struct { I }
 360 func (C) g() int
 361 var _ I = C{}
 362 `),
 363                         from: "main.I.f", to: "g",
 364                         want: `renaming this method "f" to "g".*` +
 365                                 `would change the g method of main.C invoked via interface main.I.*` +
 366                                 `from \(main.I\).g.*` +
 367                                 `to \(main.C\).g`,
 368                 },
 369                 // Renaming causes promoted method to become ambiguous; C no longer satisfies I.
 370                 {
 371                         ctxt: main(`
 372 package main
 373 type I interface{f()}
 374 type C int
 375 func (C) f()
 376 type D int
 377 func (D) g()
 378 type E struct{C;D}
 379 var _ I = E{}
 380 `),
 381                         from: "main.I.f", to: "g",
 382                         want: `renaming this method "f" to "g".*` +
 383                                 `would make the g method of main.E invoked via interface main.I ambiguous.*` +
 384                                 `with \(main.D\).g`,
 385                 },
 386         } {
 387                 var conflicts []string
 388                 reportError = func(posn token.Position, message string) {
 389                         conflicts = append(conflicts, message)
 390                 }
 391                 if test.ctxt != nil {
 392                         ctxt = test.ctxt
 393                 }
 394                 err := Main(ctxt, test.offset, test.from, test.to)
 395                 var prefix string
 396                 if test.offset == "" {
 397                         prefix = fmt.Sprintf("-from %q -to %q", test.from, test.to)
 398                 } else {
 399                         prefix = fmt.Sprintf("-offset %q -to %q", test.offset, test.to)
 400                 }
 401                 if err == ConflictError {
 402                         got := strings.Join(conflicts, "\n")
 403                         if false {
 404                                 t.Logf("%s: %s", prefix, got)
 405                         }
 406                         pattern := "(?s:" + test.want + ")" // enable multi-line matching
 407                         if !regexp.MustCompile(pattern).MatchString(got) {
 408                                 t.Errorf("%s: conflict does not match pattern:\n"+
 409                                         "Conflict:\t%s\n"+
 410                                         "Pattern: %s",
 411                                         prefix, got, test.want)
 412                         }
 413                 } else if err != nil {
 414                         t.Errorf("%s: unexpected error: %s", prefix, err)
 415                 } else if test.want != "OK" {
 416                         t.Errorf("%s: unexpected success, want conflicts matching:\n%s",
 417                                 prefix, test.want)
 418                 }
 419         }
 420 }
 421
 422 func TestInvalidIdentifiers(t *testing.T) {
 423         ctxt := fakeContext(map[string][]string{
 424                 "main": {`
 425 package main
 426
 427 func f() { }
 428 `}})
 429
 430         for _, test := range []struct {
 431                 from, to string // values of the -offset/-from and -to flags
 432                 want     string // expected error message
 433         }{
 434                 {
 435                         from: "main.f", to: "_",
 436                         want: `-to "_": not a valid identifier`,
 437                 },
 438                 {
 439                         from: "main.f", to: "123",
 440                         want: `-to "123": not a valid identifier`,
 441                 },
 442                 {
 443                         from: "main.f", to: "for",
 444                         want: `-to "for": not a valid identifier`,
 445                 },
 446                 {
 447                         from: "switch", to: "v",
 448                         want: `-from "switch": invalid expression`,
 449                 },
 450         } {
 451                 err := Main(ctxt, "", test.from, test.to)
 452                 prefix := fmt.Sprintf("-from %q -to %q", test.from, test.to)
 453                 if err == nil {
 454                         t.Errorf("%s: expected error %q", prefix, test.want)
 455                 } else if err.Error() != test.want {
 456                         t.Errorf("%s: unexpected error\nwant: %s\n got: %s", prefix, test.want, err.Error())
 457                 }
 458         }
 459 }
 460
 461 func TestRewrites(t *testing.T) {
 462         defer func(savedWriteFile func(string, []byte) error) {
 463                 writeFile = savedWriteFile
 464         }(writeFile)
 465
 466         var ctxt *build.Context
 467         for _, test := range []struct {
 468                 ctxt             *build.Context    // nil => use previous
 469                 offset, from, to string            // values of the -from/-offset and -to flags
 470                 want             map[string]string // contents of updated files
 471         }{
 472                 // Elimination of renaming import.
 473                 {
 474                         ctxt: fakeContext(map[string][]string{
 475                                 "foo": {`package foo; type T int`},
 476                                 "main": {`package main
 477
 478 import foo2 "foo"
 479
 480 var _ foo2.T
 481 `},
 482                         }),
 483                         from: "main::foo2", to: "foo",
 484                         want: map[string]string{
 485                                 "/go/src/main/0.go": `package main
 486
 487 import "foo"
 488
 489 var _ foo.T
 490 `,
 491                         },
 492                 },
 493                 // Introduction of renaming import.
 494                 {
 495                         ctxt: fakeContext(map[string][]string{
 496                                 "foo": {`package foo; type T int`},
 497                                 "main": {`package main
 498
 499 import "foo"
 500
 501 var _ foo.T
 502 `},
 503                         }),
 504                         offset: "/go/src/main/0.go:#36", to: "foo2", // the "foo" in foo.T
 505                         want: map[string]string{
 506                                 "/go/src/main/0.go": `package main
 507
 508 import foo2 "foo"
 509
 510 var _ foo2.T
 511 `,
 512                         },
 513                 },
 514                 // Renaming of package-level member.
 515                 {
 516                         from: "foo.T", to: "U",
 517                         want: map[string]string{
 518                                 "/go/src/main/0.go": `package main
 519
 520 import "foo"
 521
 522 var _ foo.U
 523 `,
 524                                 "/go/src/foo/0.go": `package foo
 525
 526 type U int
 527 `,
 528                         },
 529                 },
 530                 // Rename package-level func plus doc
 531                 {
 532                         ctxt: main(`package main
 533
 534 // Foo is a no-op.
 535 // Calling Foo does nothing.
 536 func Foo() {
 537 }
 538 `),
 539                         from: "main.Foo", to: "FooBar",
 540                         want: map[string]string{
 541                                 "/go/src/main/0.go": `package main
 542
 543 // FooBar is a no-op.
 544 // Calling FooBar does nothing.
 545 func FooBar() {
 546 }
 547 `,
 548                         },
 549                 },
 550                 // Rename method plus doc
 551                 {
 552                         ctxt: main(`package main
 553
 554 type Foo struct{}
 555
 556 // Bar does nothing.
 557 func (Foo) Bar() {
 558 }
 559 `),
 560                         from: "main.Foo.Bar", to: "Baz",
 561                         want: map[string]string{
 562                                 "/go/src/main/0.go": `package main
 563
 564 type Foo struct{}
 565
 566 // Baz does nothing.
 567 func (Foo) Baz() {
 568 }
 569 `,
 570                         },
 571                 },
 572                 // Rename type spec plus doc
 573                 {
 574                         ctxt: main(`package main
 575
 576 type (
 577         // Test but not Testing.
 578         Test struct{}
 579 )
 580 `),
 581                         from: "main.Test", to: "Type",
 582                         want: map[string]string{
 583                                 "/go/src/main/0.go": `package main
 584
 585 type (
 586         // Type but not Testing.
 587         Type struct{}
 588 )
 589 `,
 590                         },
 591                 },
 592                 // Rename type in gen decl plus doc
 593                 {
 594                         ctxt: main(`package main
 595
 596 // T is a test type.
 597 type T struct{}
 598 `),
 599                         from: "main.T", to: "Type",
 600                         want: map[string]string{
 601                                 "/go/src/main/0.go": `package main
 602
 603 // Type is a test type.
 604 type Type struct{}
 605 `,
 606                         },
 607                 },
 608                 // Rename value spec with doc
 609                 {
 610                         ctxt: main(`package main
 611
 612 const (
 613         // C is the speed of light.
 614         C = 2.998e8
 615 )
 616 `),
 617                         from: "main.C", to: "Lightspeed",
 618                         want: map[string]string{
 619                                 "/go/src/main/0.go": `package main
 620
 621 const (
 622         // Lightspeed is the speed of light.
 623         Lightspeed = 2.998e8
 624 )
 625 `,
 626                         },
 627                 },
 628                 // Rename value inside gen decl with doc
 629                 {
 630                         ctxt: main(`package main
 631
 632 var out *string
 633 `),
 634                         from: "main.out", to: "discard",
 635                         want: map[string]string{
 636                                 "/go/src/main/0.go": `package main
 637
 638 var discard *string
 639 `,
 640                         },
 641                 },
 642                 // Rename field plus doc
 643                 {
 644                         ctxt: main(`package main
 645
 646 type Struct struct {
 647         // Field is a struct field.
 648         Field string
 649 }
 650 `),
 651                         from: "main.Struct.Field", to: "Foo",
 652                         want: map[string]string{
 653                                 "/go/src/main/0.go": `package main
 654
 655 type Struct struct {
 656         // Foo is a struct field.
 657         Foo string
 658 }
 659 `,
 660                         },
 661                 },
 662                 // Label renamings.
 663                 {
 664                         ctxt: main(`package main
 665 func f() {
 666 loop:
 667         loop := 0
 668         go func() {
 669         loop:
 670                 goto loop
 671         }()
 672         loop++
 673         goto loop
 674 }
 675 `),
 676                         offset: "/go/src/main/0.go:#25", to: "loop2", // def of outer label "loop"
 677                         want: map[string]string{
 678                                 "/go/src/main/0.go": `package main
 679
 680 func f() {
 681 loop2:
 682         loop := 0
 683         go func() {
 684         loop:
 685                 goto loop
 686         }()
 687         loop++
 688         goto loop2
 689 }
 690 `,
 691                         },
 692                 },
 693                 {
 694                         offset: "/go/src/main/0.go:#70", to: "loop2", // ref to inner label "loop"
 695                         want: map[string]string{
 696                                 "/go/src/main/0.go": `package main
 697
 698 func f() {
 699 loop:
 700         loop := 0
 701         go func() {
 702         loop2:
 703                 goto loop2
 704         }()
 705         loop++
 706         goto loop
 707 }
 708 `,
 709                         },
 710                 },
 711                 // Renaming of type used as embedded field.
 712                 {
 713                         ctxt: main(`package main
 714
 715 type T int
 716 type U struct { T }
 717
 718 var _ = U{}.T
 719 `),
 720                         from: "main.T", to: "T2",
 721                         want: map[string]string{
 722                                 "/go/src/main/0.go": `package main
 723
 724 type T2 int
 725 type U struct{ T2 }
 726
 727 var _ = U{}.T2
 728 `,
 729                         },
 730                 },
 731                 // Renaming of embedded field.
 732                 {
 733                         ctxt: main(`package main
 734
 735 type T int
 736 type U struct { T }
 737
 738 var _ = U{}.T
 739 `),
 740                         offset: "/go/src/main/0.go:#58", to: "T2", // T in "U{}.T"
 741                         want: map[string]string{
 742                                 "/go/src/main/0.go": `package main
 743
 744 type T2 int
 745 type U struct{ T2 }
 746
 747 var _ = U{}.T2
 748 `,
 749                         },
 750                 },
 751                 // Renaming of pointer embedded field.
 752                 {
 753                         ctxt: main(`package main
 754
 755 type T int
 756 type U struct { *T }
 757
 758 var _ = U{}.T
 759 `),
 760                         offset: "/go/src/main/0.go:#59", to: "T2", // T in "U{}.T"
 761                         want: map[string]string{
 762                                 "/go/src/main/0.go": `package main
 763
 764 type T2 int
 765 type U struct{ *T2 }
 766
 767 var _ = U{}.T2
 768 `,
 769                         },
 770                 },
 771
 772                 // Lexical scope tests.
 773                 {
 774                         ctxt: main(`package main
 775
 776 var y int
 777
 778 func f() {
 779         print(y)
 780         y := ""
 781         print(y)
 782 }
 783 `),
 784                         from: "main.y", to: "x",
 785                         want: map[string]string{
 786                                 "/go/src/main/0.go": `package main
 787
 788 var x int
 789
 790 func f() {
 791         print(x)
 792         y := ""
 793         print(y)
 794 }
 795 `,
 796                         },
 797                 },
 798                 {
 799                         from: "main.f::y", to: "x",
 800                         want: map[string]string{
 801                                 "/go/src/main/0.go": `package main
 802
 803 var y int
 804
 805 func f() {
 806         print(y)
 807         x := ""
 808         print(x)
 809 }
 810 `,
 811                         },
 812                 },
 813                 // Renaming of typeswitch vars (a corner case).
 814                 {
 815                         ctxt: main(`package main
 816
 817 func f(z interface{}) {
 818         switch y := z.(type) {
 819         case int:
 820                 print(y)
 821         default:
 822                 print(y)
 823         }
 824 }
 825 `),
 826                         offset: "/go/src/main/0.go:#46", to: "x", // def of y
 827                         want: map[string]string{
 828                                 "/go/src/main/0.go": `package main
 829
 830 func f(z interface{}) {
 831         switch x := z.(type) {
 832         case int:
 833                 print(x)
 834         default:
 835                 print(x)
 836         }
 837 }
 838 `},
 839                 },
 840                 {
 841                         offset: "/go/src/main/0.go:#81", to: "x", // ref of y in case int
 842                         want: map[string]string{
 843                                 "/go/src/main/0.go": `package main
 844
 845 func f(z interface{}) {
 846         switch x := z.(type) {
 847         case int:
 848                 print(x)
 849         default:
 850                 print(x)
 851         }
 852 }
 853 `},
 854                 },
 855                 {
 856                         offset: "/go/src/main/0.go:#102", to: "x", // ref of y in default case
 857                         want: map[string]string{
 858                                 "/go/src/main/0.go": `package main
 859
 860 func f(z interface{}) {
 861         switch x := z.(type) {
 862         case int:
 863                 print(x)
 864         default:
 865                 print(x)
 866         }
 867 }
 868 `},
 869                 },
 870
 871                 // Renaming of embedded field that is a qualified reference.
 872                 // (Regression test for bug 8924.)
 873                 {
 874                         ctxt: fakeContext(map[string][]string{
 875                                 "foo": {`package foo; type T int`},
 876                                 "main": {`package main
 877
 878 import "foo"
 879
 880 type _ struct{ *foo.T }
 881 `},
 882                         }),
 883                         offset: "/go/src/main/0.go:#48", to: "U", // the "T" in *foo.T
 884                         want: map[string]string{
 885                                 "/go/src/foo/0.go": `package foo
 886
 887 type U int
 888 `,
 889                                 "/go/src/main/0.go": `package main
 890
 891 import "foo"
 892
 893 type _ struct{ *foo.U }
 894 `,
 895                         },
 896                 },
 897
 898                 // Renaming of embedded field that is a qualified reference with the '-from' flag.
 899                 // (Regression test for bug 12038.)
 900                 {
 901                         ctxt: fakeContext(map[string][]string{
 902                                 "foo": {`package foo; type T int`},
 903                                 "main": {`package main
 904
 905 import "foo"
 906
 907 type V struct{ *foo.T }
 908 `},
 909                         }),
 910                         from: "(main.V).T", to: "U", // the "T" in *foo.T
 911                         want: map[string]string{
 912                                 "/go/src/foo/0.go": `package foo
 913
 914 type U int
 915 `,
 916                                 "/go/src/main/0.go": `package main
 917
 918 import "foo"
 919
 920 type V struct{ *foo.U }
 921 `,
 922                         },
 923                 },
 924                 {
 925                         ctxt: fakeContext(map[string][]string{
 926                                 "foo": {`package foo; type T int`},
 927                                 "main": {`package main
 928
 929 import "foo"
 930
 931 type V struct{ foo.T }
 932 `},
 933                         }),
 934                         from: "(main.V).T", to: "U", // the "T" in *foo.T
 935                         want: map[string]string{
 936                                 "/go/src/foo/0.go": `package foo
 937
 938 type U int
 939 `,
 940                                 "/go/src/main/0.go": `package main
 941
 942 import "foo"
 943
 944 type V struct{ foo.U }
 945 `,
 946                         },
 947                 },
 948
 949                 // Interface method renaming.
 950                 {
 951                         ctxt: fakeContext(map[string][]string{
 952                                 "main": {`
 953 package main
 954 type I interface {
 955         f()
 956 }
 957 type J interface { f(); g() }
 958 type A int
 959 func (A) f()
 960 type B int
 961 func (B) f()
 962 func (B) g()
 963 type C int
 964 func (C) f()
 965 func (C) g()
 966 var _, _ I = A(0), B(0)
 967 var _, _ J = B(0), C(0)
 968 `,
 969                                 },
 970                         }),
 971                         offset: "/go/src/main/0.go:#34", to: "F", // abstract method I.f
 972                         want: map[string]string{
 973                                 "/go/src/main/0.go": `package main
 974
 975 type I interface {
 976         F()
 977 }
 978 type J interface {
 979         F()
 980         g()
 981 }
 982 type A int
 983
 984 func (A) F()
 985
 986 type B int
 987
 988 func (B) F()
 989 func (B) g()
 990
 991 type C int
 992
 993 func (C) F()
 994 func (C) g()
 995
 996 var _, _ I = A(0), B(0)
 997 var _, _ J = B(0), C(0)
 998 `,
 999                         },
1000                 },
1001                 {
1002                         offset: "/go/src/main/0.go:#59", to: "F", // abstract method J.f
1003                         want: map[string]string{
1004                                 "/go/src/main/0.go": `package main
1005
1006 type I interface {
1007         F()
1008 }
1009 type J interface {
1010         F()
1011         g()
1012 }
1013 type A int
1014
1015 func (A) F()
1016
1017 type B int
1018
1019 func (B) F()
1020 func (B) g()
1021
1022 type C int
1023
1024 func (C) F()
1025 func (C) g()
1026
1027 var _, _ I = A(0), B(0)
1028 var _, _ J = B(0), C(0)
1029 `,
1030                         },
1031                 },
1032                 {
1033                         offset: "/go/src/main/0.go:#64", to: "G", // abstract method J.g
1034                         want: map[string]string{
1035                                 "/go/src/main/0.go": `package main
1036
1037 type I interface {
1038         f()
1039 }
1040 type J interface {
1041         f()
1042         G()
1043 }
1044 type A int
1045
1046 func (A) f()
1047
1048 type B int
1049
1050 func (B) f()
1051 func (B) G()
1052
1053 type C int
1054
1055 func (C) f()
1056 func (C) G()
1057
1058 var _, _ I = A(0), B(0)
1059 var _, _ J = B(0), C(0)
1060 `,
1061                         },
1062                 },
1063                 // Indirect coupling of I.f to C.f from D->I assignment and anonymous field of D.
1064                 {
1065                         ctxt: fakeContext(map[string][]string{
1066                                 "main": {`
1067 package main
1068 type I interface {
1069         f()
1070 }
1071 type C int
1072 func (C) f()
1073 type D struct{C}
1074 var _ I = D{}
1075 `,
1076                                 },
1077                         }),
1078                         offset: "/go/src/main/0.go:#34", to: "F", // abstract method I.f
1079                         want: map[string]string{
1080                                 "/go/src/main/0.go": `package main
1081
1082 type I interface {
1083         F()
1084 }
1085 type C int
1086
1087 func (C) F()
1088
1089 type D struct{ C }
1090
1091 var _ I = D{}
1092 `,
1093                         },
1094                 },
1095                 // Interface embedded in struct.  No conflict if C need not satisfy I.
1096                 {
1097                         ctxt: fakeContext(map[string][]string{
1098                                 "main": {`
1099 package main
1100 type I interface {
1101         f()
1102 }
1103 type C struct{I}
1104 func (C) g() int
1105 var _ int = C{}.g()
1106 `,
1107                                 },
1108                         }),
1109                         offset: "/go/src/main/0.go:#34", to: "g", // abstract method I.f
1110                         want: map[string]string{
1111                                 "/go/src/main/0.go": `package main
1112
1113 type I interface {
1114         g()
1115 }
1116 type C struct{ I }
1117
1118 func (C) g() int
1119
1120 var _ int = C{}.g()
1121 `,
1122                         },
1123                 },
1124                 // A type assertion causes method coupling iff signatures match.
1125                 {
1126                         ctxt: fakeContext(map[string][]string{
1127                                 "main": {`package main
1128 type I interface{
1129         f()
1130 }
1131 type J interface{
1132         f()
1133 }
1134 var _ = I(nil).(J)
1135 `,
1136                                 },
1137                         }),
1138                         offset: "/go/src/main/0.go:#32", to: "g", // abstract method I.f
1139                         want: map[string]string{
1140                                 "/go/src/main/0.go": `package main
1141
1142 type I interface {
1143         g()
1144 }
1145 type J interface {
1146         g()
1147 }
1148
1149 var _ = I(nil).(J)
1150 `,
1151                         },
1152                 },
1153                 // Impossible type assertion: no method coupling.
1154                 {
1155                         ctxt: fakeContext(map[string][]string{
1156                                 "main": {`package main
1157 type I interface{
1158         f()
1159 }
1160 type J interface{
1161         f()int
1162 }
1163 var _ = I(nil).(J)
1164 `,
1165                                 },
1166                         }),
1167                         offset: "/go/src/main/0.go:#32", to: "g", // abstract method I.f
1168                         want: map[string]string{
1169                                 "/go/src/main/0.go": `package main
1170
1171 type I interface {
1172         g()
1173 }
1174 type J interface {
1175         f() int
1176 }
1177
1178 var _ = I(nil).(J)
1179 `,
1180                         },
1181                 },
1182                 // Impossible type assertion: no method coupling C.f<->J.f.
1183                 {
1184                         ctxt: fakeContext(map[string][]string{
1185                                 "main": {`package main
1186 type I interface{
1187         f()
1188 }
1189 type C int
1190 func (C) f()
1191 type J interface{
1192         f()int
1193 }
1194 var _ = I(C(0)).(J)
1195 `,
1196                                 },
1197                         }),
1198                         offset: "/go/src/main/0.go:#32", to: "g", // abstract method I.f
1199                         want: map[string]string{
1200                                 "/go/src/main/0.go": `package main
1201
1202 type I interface {
1203         g()
1204 }
1205 type C int
1206
1207 func (C) g()
1208
1209 type J interface {
1210         f() int
1211 }
1212
1213 var _ = I(C(0)).(J)
1214 `,
1215                         },
1216                 },
1217                 // Progress after "soft" type errors (Go issue 14596).
1218                 {
1219                         ctxt: fakeContext(map[string][]string{
1220                                 "main": {`package main
1221
1222 func main() {
1223         var unused, x int
1224         print(x)
1225 }
1226 `,
1227                                 },
1228                         }),
1229                         offset: "/go/src/main/0.go:#54", to: "y", // var x
1230                         want: map[string]string{
1231                                 "/go/src/main/0.go": `package main
1232
1233 func main() {
1234         var unused, y int
1235         print(y)
1236 }
1237 `,
1238                         },
1239                 },
1240         } {
1241                 if test.ctxt != nil {
1242                         ctxt = test.ctxt
1243                 }
1244
1245                 got := make(map[string]string)
1246                 writeFile = func(filename string, content []byte) error {
1247                         got[filepath.ToSlash(filename)] = string(content)
1248                         return nil
1249                 }
1250
1251                 err := Main(ctxt, test.offset, test.from, test.to)
1252                 var prefix string
1253                 if test.offset == "" {
1254                         prefix = fmt.Sprintf("-from %q -to %q", test.from, test.to)
1255                 } else {
1256                         prefix = fmt.Sprintf("-offset %q -to %q", test.offset, test.to)
1257                 }
1258                 if err != nil {
1259                         t.Errorf("%s: unexpected error: %s", prefix, err)
1260                         continue
1261                 }
1262
1263                 for file, wantContent := range test.want {
1264                         gotContent, ok := got[file]
1265                         delete(got, file)
1266                         if !ok {
1267                                 t.Errorf("%s: file %s not rewritten", prefix, file)
1268                                 continue
1269                         }
1270                         if gotContent != wantContent {
1271                                 t.Errorf("%s: rewritten file %s does not match expectation; got <<<%s>>>\n"+
1272                                         "want <<<%s>>>", prefix, file, gotContent, wantContent)
1273                         }
1274                 }
1275                 // got should now be empty
1276                 for file := range got {
1277                         t.Errorf("%s: unexpected rewrite of file %s", prefix, file)
1278                 }
1279         }
1280 }
1281
1282 func TestDiff(t *testing.T) {
1283         switch runtime.GOOS {
1284         case "windows":
1285                 if os.Getenv("GO_BUILDER_NAME") != "" {
1286                         if _, err := exec.LookPath(DiffCmd); err != nil {
1287                                 t.Skipf("diff tool non-existent for %s on builders", runtime.GOOS)
1288                         }
1289                 }
1290         case "plan9":
1291                 t.Skipf("plan9 diff tool doesn't support -u flag")
1292         }
1293         testenv.NeedsTool(t, DiffCmd)
1294         testenv.NeedsTool(t, "go") // to locate the package to be renamed
1295
1296         defer func() {
1297                 Diff = false
1298                 stdout = os.Stdout
1299         }()
1300         Diff = true
1301         stdout = new(bytes.Buffer)
1302
1303         // Set up a fake GOPATH in a temporary directory,
1304         // and ensure we're in GOPATH mode.
1305         tmpdir, err := ioutil.TempDir("", "TestDiff")
1306         if err != nil {
1307                 t.Fatal(err)
1308         }
1309         defer os.RemoveAll(tmpdir)
1310         buildCtx := build.Default
1311         buildCtx.GOPATH = tmpdir
1312
1313         pkgDir := filepath.Join(tmpdir, "src", "example.com", "rename")
1314         if err := os.MkdirAll(pkgDir, 0777); err != nil {
1315                 t.Fatal(err)
1316         }
1317
1318         prevWD, err := os.Getwd()
1319         if err != nil {
1320                 t.Fatal(err)
1321         }
1322         defer os.Chdir(prevWD)
1323
1324         if err := os.Chdir(pkgDir); err != nil {
1325                 t.Fatal(err)
1326         }
1327
1328         const modFile = `module example.com/rename
1329
1330 go 1.15
1331 `
1332         if err := ioutil.WriteFile(filepath.Join(pkgDir, "go.mod"), []byte(modFile), 0644); err != nil {
1333                 t.Fatal(err)
1334         }
1335
1336         const goFile = `package rename
1337
1338 func justHereForTestingDiff() {
1339         justHereForTestingDiff()
1340 }
1341 `
1342         if err := ioutil.WriteFile(filepath.Join(pkgDir, "rename_test.go"), []byte(goFile), 0644); err != nil {
1343                 t.Fatal(err)
1344         }
1345
1346         if err := Main(&buildCtx, "", `"example.com/rename".justHereForTestingDiff`, "Foo"); err != nil {
1347                 t.Fatal(err)
1348         }
1349
1350         // NB: there are tabs in the string literal!
1351         if !strings.Contains(stdout.(fmt.Stringer).String(), `
1352 -func justHereForTestingDiff() {
1353 -       justHereForTestingDiff()
1354 +func Foo() {
1355 +       Foo()
1356  }
1357 `) {
1358                 t.Errorf("unexpected diff:\n<<%s>>", stdout)
1359         }
1360 }
1361
1362 // ---------------------------------------------------------------------
1363
1364 // Simplifying wrapper around buildutil.FakeContext for packages whose
1365 // filenames are sequentially numbered (%d.go).  pkgs maps a package
1366 // import path to its list of file contents.
1367 func fakeContext(pkgs map[string][]string) *build.Context {
1368         pkgs2 := make(map[string]map[string]string)
1369         for path, files := range pkgs {
1370                 filemap := make(map[string]string)
1371                 for i, contents := range files {
1372                         filemap[fmt.Sprintf("%d.go", i)] = contents
1373                 }
1374                 pkgs2[path] = filemap
1375         }
1376         return buildutil.FakeContext(pkgs2)
1377 }
1378
1379 // helper for single-file main packages with no imports.
1380 func main(content string) *build.Context {
1381         return fakeContext(map[string][]string{"main": {content}})
1382 }