+++ /dev/null
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package rename
-
-import (
- "bytes"
- "fmt"
- "go/build"
- "go/token"
- "io/ioutil"
- "os"
- "os/exec"
- "path/filepath"
- "regexp"
- "runtime"
- "strings"
- "testing"
-
- "golang.org/x/tools/go/buildutil"
- "golang.org/x/tools/internal/testenv"
-)
-
-// TODO(adonovan): test reported source positions, somehow.
-
-func TestConflicts(t *testing.T) {
- defer func(savedWriteFile func(string, []byte) error, savedReportError func(token.Position, string)) {
- writeFile = savedWriteFile
- reportError = savedReportError
- }(writeFile, reportError)
- writeFile = func(string, []byte) error { return nil }
-
- var ctxt *build.Context
- for _, test := range []struct {
- ctxt *build.Context // nil => use previous
- offset, from, to string // values of the -offset/-from and -to flags
- want string // regexp to match conflict errors, or "OK"
- }{
- // init() checks
- {
- ctxt: fakeContext(map[string][]string{
- "fmt": {`package fmt; type Stringer interface { String() }`},
- "main": {`
-package main
-
-import foo "fmt"
-
-var v foo.Stringer
-
-func f() { v.String(); f() }
-`,
- `package main; var w int`},
- }),
- from: "main.v", to: "init",
- want: `you cannot have a var at package level named "init"`,
- },
- {
- from: "main.f", to: "init",
- want: `renaming this func "f" to "init" would make it a package initializer.*` +
- `but references to it exist`,
- },
- {
- from: "/go/src/main/0.go::foo", to: "init",
- want: `"init" is not a valid imported package name`,
- },
-
- // Export checks
- {
- from: "fmt.Stringer", to: "stringer",
- want: `renaming this type "Stringer" to "stringer" would make it unexported.*` +
- `breaking references from packages such as "main"`,
- },
- {
- from: "(fmt.Stringer).String", to: "string",
- want: `renaming this method "String" to "string" would make it unexported.*` +
- `breaking references from packages such as "main"`,
- },
-
- // Lexical scope checks
- {
- // file/package conflict, same file
- from: "main.v", to: "foo",
- want: `renaming this var "v" to "foo" would conflict.*` +
- `with this imported package name`,
- },
- {
- // file/package conflict, same file
- from: "main::foo", to: "v",
- want: `renaming this imported package name "foo" to "v" would conflict.*` +
- `with this package member var`,
- },
- {
- // file/package conflict, different files
- from: "main.w", to: "foo",
- want: `renaming this var "w" to "foo" would conflict.*` +
- `with this imported package name`,
- },
- {
- // file/package conflict, different files
- from: "main::foo", to: "w",
- want: `renaming this imported package name "foo" to "w" would conflict.*` +
- `with this package member var`,
- },
- {
- ctxt: main(`
-package main
-
-var x, z int
-
-func f(y int) {
- print(x)
- print(y)
-}
-
-func g(w int) {
- print(x)
- x := 1
- print(x)
-}`),
- from: "main.x", to: "y",
- want: `renaming this var "x" to "y".*` +
- `would cause this reference to become shadowed.*` +
- `by this intervening var definition`,
- },
- {
- from: "main.g::x", to: "w",
- want: `renaming this var "x" to "w".*` +
- `conflicts with var in same block`,
- },
- {
- from: "main.f::y", to: "x",
- want: `renaming this var "y" to "x".*` +
- `would shadow this reference.*` +
- `to the var declared here`,
- },
- {
- from: "main.g::w", to: "x",
- want: `renaming this var "w" to "x".*` +
- `conflicts with var in same block`,
- },
- {
- from: "main.z", to: "y", want: "OK",
- },
-
- // Label checks
- {
- ctxt: main(`
-package main
-
-func f() {
-foo:
- goto foo
-bar:
- goto bar
- func(x int) {
- wiz:
- goto wiz
- }(0)
-}
-`),
- from: "main.f::foo", to: "bar",
- want: `renaming this label "foo" to "bar".*` +
- `would conflict with this one`,
- },
- {
- from: "main.f::foo", to: "wiz", want: "OK",
- },
- {
- from: "main.f::wiz", to: "x", want: "OK",
- },
- {
- from: "main.f::x", to: "wiz", want: "OK",
- },
- {
- from: "main.f::wiz", to: "foo", want: "OK",
- },
-
- // Struct fields
- {
- ctxt: main(`
-package main
-
-type U struct { u int }
-type V struct { v int }
-
-func (V) x() {}
-
-type W (struct {
- U
- V
- w int
-})
-
-func f() {
- var w W
- print(w.u) // NB: there is no selection of w.v
- var _ struct { yy, zz int }
-}
-`),
- // field/field conflict in named struct declaration
- from: "(main.W).U", to: "w",
- want: `renaming this field "U" to "w".*` +
- `would conflict with this field`,
- },
- {
- // rename type used as embedded field
- // => rename field
- // => field/field conflict
- // This is an entailed renaming;
- // it would be nice if we checked source positions.
- from: "main.U", to: "w",
- want: `renaming this field "U" to "w".*` +
- `would conflict with this field`,
- },
- {
- // field/field conflict in unnamed struct declaration
- from: "main.f::zz", to: "yy",
- want: `renaming this field "zz" to "yy".*` +
- `would conflict with this field`,
- },
-
- // Now we test both directions of (u,v) (u,w) (v,w) (u,x) (v,x).
- // Too bad we don't test position info...
- {
- // field/field ambiguity at same promotion level ('from' selection)
- from: "(main.U).u", to: "v",
- want: `renaming this field "u" to "v".*` +
- `would make this reference ambiguous.*` +
- `with this field`,
- },
- {
- // field/field ambiguity at same promotion level ('to' selection)
- from: "(main.V).v", to: "u",
- want: `renaming this field "v" to "u".*` +
- `would make this reference ambiguous.*` +
- `with this field`,
- },
- {
- // field/method conflict at different promotion level ('from' selection)
- from: "(main.U).u", to: "w",
- want: `renaming this field "u" to "w".*` +
- `would change the referent of this selection.*` +
- `of this field`,
- },
- {
- // field/field shadowing at different promotion levels ('to' selection)
- from: "(main.W).w", to: "u",
- want: `renaming this field "w" to "u".*` +
- `would shadow this selection.*` +
- `of the field declared here`,
- },
- {
- from: "(main.V).v", to: "w",
- want: "OK", // since no selections are made ambiguous
- },
- {
- from: "(main.W).w", to: "v",
- want: "OK", // since no selections are made ambiguous
- },
- {
- // field/method ambiguity at same promotion level ('from' selection)
- from: "(main.U).u", to: "x",
- want: `renaming this field "u" to "x".*` +
- `would make this reference ambiguous.*` +
- `with this method`,
- },
- {
- // field/field ambiguity at same promotion level ('to' selection)
- from: "(main.V).x", to: "u",
- want: `renaming this method "x" to "u".*` +
- `would make this reference ambiguous.*` +
- `with this field`,
- },
- {
- // field/method conflict at named struct declaration
- from: "(main.V).v", to: "x",
- want: `renaming this field "v" to "x".*` +
- `would conflict with this method`,
- },
- {
- // field/method conflict at named struct declaration
- from: "(main.V).x", to: "v",
- want: `renaming this method "x" to "v".*` +
- `would conflict with this field`,
- },
-
- // Methods
- {
- ctxt: main(`
-package main
-type C int
-func (C) f()
-func (C) g()
-type D int
-func (*D) f()
-func (*D) g()
-type I interface { f(); g() }
-type J interface { I; h() }
-var _ I = new(D)
-var _ interface {f()} = C(0)
-`),
- from: "(main.I).f", to: "g",
- want: `renaming this interface method "f" to "g".*` +
- `would conflict with this method`,
- },
- {
- from: `("main".I).f`, to: "h", // NB: exercises quoted import paths too
- want: `renaming this interface method "f" to "h".*` +
- `would conflict with this method.*` +
- `in named interface type "J"`,
- },
- {
- // type J interface { h; h() } is not a conflict, amusingly.
- from: "main.I", to: "h",
- want: `OK`,
- },
- {
- from: "(main.J).h", to: "f",
- want: `renaming this interface method "h" to "f".*` +
- `would conflict with this method`,
- },
- {
- from: "(main.C).f", to: "e",
- want: `renaming this method "f" to "e".*` +
- `would make main.C no longer assignable to interface{f..}.*` +
- `(rename interface{f..}.f if you intend to change both types)`,
- },
- {
- from: "(main.D).g", to: "e",
- want: `renaming this method "g" to "e".*` +
- `would make \*main.D no longer assignable to interface I.*` +
- `(rename main.I.g if you intend to change both types)`,
- },
- {
- from: "(main.I).f", to: "e",
- want: `OK`,
- },
- // Indirect C/I method coupling via another concrete type D.
- {
- ctxt: main(`
-package main
-type I interface { f() }
-type C int
-func (C) f()
-type D struct{C}
-var _ I = D{}
-`),
- from: "(main.C).f", to: "F",
- want: `renaming this method "f" to "F".*` +
- `would make main.D no longer assignable to interface I.*` +
- `(rename main.I.f if you intend to change both types)`,
- },
- // Renaming causes promoted method to become shadowed; C no longer satisfies I.
- {
- ctxt: main(`
-package main
-type I interface { f() }
-type C struct { I }
-func (C) g() int
-var _ I = C{}
-`),
- from: "main.I.f", to: "g",
- want: `renaming this method "f" to "g".*` +
- `would change the g method of main.C invoked via interface main.I.*` +
- `from \(main.I\).g.*` +
- `to \(main.C\).g`,
- },
- // Renaming causes promoted method to become ambiguous; C no longer satisfies I.
- {
- ctxt: main(`
-package main
-type I interface{f()}
-type C int
-func (C) f()
-type D int
-func (D) g()
-type E struct{C;D}
-var _ I = E{}
-`),
- from: "main.I.f", to: "g",
- want: `renaming this method "f" to "g".*` +
- `would make the g method of main.E invoked via interface main.I ambiguous.*` +
- `with \(main.D\).g`,
- },
- } {
- var conflicts []string
- reportError = func(posn token.Position, message string) {
- conflicts = append(conflicts, message)
- }
- if test.ctxt != nil {
- ctxt = test.ctxt
- }
- err := Main(ctxt, test.offset, test.from, test.to)
- var prefix string
- if test.offset == "" {
- prefix = fmt.Sprintf("-from %q -to %q", test.from, test.to)
- } else {
- prefix = fmt.Sprintf("-offset %q -to %q", test.offset, test.to)
- }
- if err == ConflictError {
- got := strings.Join(conflicts, "\n")
- if false {
- t.Logf("%s: %s", prefix, got)
- }
- pattern := "(?s:" + test.want + ")" // enable multi-line matching
- if !regexp.MustCompile(pattern).MatchString(got) {
- t.Errorf("%s: conflict does not match pattern:\n"+
- "Conflict:\t%s\n"+
- "Pattern: %s",
- prefix, got, test.want)
- }
- } else if err != nil {
- t.Errorf("%s: unexpected error: %s", prefix, err)
- } else if test.want != "OK" {
- t.Errorf("%s: unexpected success, want conflicts matching:\n%s",
- prefix, test.want)
- }
- }
-}
-
-func TestInvalidIdentifiers(t *testing.T) {
- ctxt := fakeContext(map[string][]string{
- "main": {`
-package main
-
-func f() { }
-`}})
-
- for _, test := range []struct {
- from, to string // values of the -offset/-from and -to flags
- want string // expected error message
- }{
- {
- from: "main.f", to: "_",
- want: `-to "_": not a valid identifier`,
- },
- {
- from: "main.f", to: "123",
- want: `-to "123": not a valid identifier`,
- },
- {
- from: "main.f", to: "for",
- want: `-to "for": not a valid identifier`,
- },
- {
- from: "switch", to: "v",
- want: `-from "switch": invalid expression`,
- },
- } {
- err := Main(ctxt, "", test.from, test.to)
- prefix := fmt.Sprintf("-from %q -to %q", test.from, test.to)
- if err == nil {
- t.Errorf("%s: expected error %q", prefix, test.want)
- } else if err.Error() != test.want {
- t.Errorf("%s: unexpected error\nwant: %s\n got: %s", prefix, test.want, err.Error())
- }
- }
-}
-
-func TestRewrites(t *testing.T) {
- defer func(savedWriteFile func(string, []byte) error) {
- writeFile = savedWriteFile
- }(writeFile)
-
- var ctxt *build.Context
- for _, test := range []struct {
- ctxt *build.Context // nil => use previous
- offset, from, to string // values of the -from/-offset and -to flags
- want map[string]string // contents of updated files
- }{
- // Elimination of renaming import.
- {
- ctxt: fakeContext(map[string][]string{
- "foo": {`package foo; type T int`},
- "main": {`package main
-
-import foo2 "foo"
-
-var _ foo2.T
-`},
- }),
- from: "main::foo2", to: "foo",
- want: map[string]string{
- "/go/src/main/0.go": `package main
-
-import "foo"
-
-var _ foo.T
-`,
- },
- },
- // Introduction of renaming import.
- {
- ctxt: fakeContext(map[string][]string{
- "foo": {`package foo; type T int`},
- "main": {`package main
-
-import "foo"
-
-var _ foo.T
-`},
- }),
- offset: "/go/src/main/0.go:#36", to: "foo2", // the "foo" in foo.T
- want: map[string]string{
- "/go/src/main/0.go": `package main
-
-import foo2 "foo"
-
-var _ foo2.T
-`,
- },
- },
- // Renaming of package-level member.
- {
- from: "foo.T", to: "U",
- want: map[string]string{
- "/go/src/main/0.go": `package main
-
-import "foo"
-
-var _ foo.U
-`,
- "/go/src/foo/0.go": `package foo
-
-type U int
-`,
- },
- },
- // Rename package-level func plus doc
- {
- ctxt: main(`package main
-
-// Foo is a no-op.
-// Calling Foo does nothing.
-func Foo() {
-}
-`),
- from: "main.Foo", to: "FooBar",
- want: map[string]string{
- "/go/src/main/0.go": `package main
-
-// FooBar is a no-op.
-// Calling FooBar does nothing.
-func FooBar() {
-}
-`,
- },
- },
- // Rename method plus doc
- {
- ctxt: main(`package main
-
-type Foo struct{}
-
-// Bar does nothing.
-func (Foo) Bar() {
-}
-`),
- from: "main.Foo.Bar", to: "Baz",
- want: map[string]string{
- "/go/src/main/0.go": `package main
-
-type Foo struct{}
-
-// Baz does nothing.
-func (Foo) Baz() {
-}
-`,
- },
- },
- // Rename type spec plus doc
- {
- ctxt: main(`package main
-
-type (
- // Test but not Testing.
- Test struct{}
-)
-`),
- from: "main.Test", to: "Type",
- want: map[string]string{
- "/go/src/main/0.go": `package main
-
-type (
- // Type but not Testing.
- Type struct{}
-)
-`,
- },
- },
- // Rename type in gen decl plus doc
- {
- ctxt: main(`package main
-
-// T is a test type.
-type T struct{}
-`),
- from: "main.T", to: "Type",
- want: map[string]string{
- "/go/src/main/0.go": `package main
-
-// Type is a test type.
-type Type struct{}
-`,
- },
- },
- // Rename value spec with doc
- {
- ctxt: main(`package main
-
-const (
- // C is the speed of light.
- C = 2.998e8
-)
-`),
- from: "main.C", to: "Lightspeed",
- want: map[string]string{
- "/go/src/main/0.go": `package main
-
-const (
- // Lightspeed is the speed of light.
- Lightspeed = 2.998e8
-)
-`,
- },
- },
- // Rename value inside gen decl with doc
- {
- ctxt: main(`package main
-
-var out *string
-`),
- from: "main.out", to: "discard",
- want: map[string]string{
- "/go/src/main/0.go": `package main
-
-var discard *string
-`,
- },
- },
- // Rename field plus doc
- {
- ctxt: main(`package main
-
-type Struct struct {
- // Field is a struct field.
- Field string
-}
-`),
- from: "main.Struct.Field", to: "Foo",
- want: map[string]string{
- "/go/src/main/0.go": `package main
-
-type Struct struct {
- // Foo is a struct field.
- Foo string
-}
-`,
- },
- },
- // Label renamings.
- {
- ctxt: main(`package main
-func f() {
-loop:
- loop := 0
- go func() {
- loop:
- goto loop
- }()
- loop++
- goto loop
-}
-`),
- offset: "/go/src/main/0.go:#25", to: "loop2", // def of outer label "loop"
- want: map[string]string{
- "/go/src/main/0.go": `package main
-
-func f() {
-loop2:
- loop := 0
- go func() {
- loop:
- goto loop
- }()
- loop++
- goto loop2
-}
-`,
- },
- },
- {
- offset: "/go/src/main/0.go:#70", to: "loop2", // ref to inner label "loop"
- want: map[string]string{
- "/go/src/main/0.go": `package main
-
-func f() {
-loop:
- loop := 0
- go func() {
- loop2:
- goto loop2
- }()
- loop++
- goto loop
-}
-`,
- },
- },
- // Renaming of type used as embedded field.
- {
- ctxt: main(`package main
-
-type T int
-type U struct { T }
-
-var _ = U{}.T
-`),
- from: "main.T", to: "T2",
- want: map[string]string{
- "/go/src/main/0.go": `package main
-
-type T2 int
-type U struct{ T2 }
-
-var _ = U{}.T2
-`,
- },
- },
- // Renaming of embedded field.
- {
- ctxt: main(`package main
-
-type T int
-type U struct { T }
-
-var _ = U{}.T
-`),
- offset: "/go/src/main/0.go:#58", to: "T2", // T in "U{}.T"
- want: map[string]string{
- "/go/src/main/0.go": `package main
-
-type T2 int
-type U struct{ T2 }
-
-var _ = U{}.T2
-`,
- },
- },
- // Renaming of pointer embedded field.
- {
- ctxt: main(`package main
-
-type T int
-type U struct { *T }
-
-var _ = U{}.T
-`),
- offset: "/go/src/main/0.go:#59", to: "T2", // T in "U{}.T"
- want: map[string]string{
- "/go/src/main/0.go": `package main
-
-type T2 int
-type U struct{ *T2 }
-
-var _ = U{}.T2
-`,
- },
- },
-
- // Lexical scope tests.
- {
- ctxt: main(`package main
-
-var y int
-
-func f() {
- print(y)
- y := ""
- print(y)
-}
-`),
- from: "main.y", to: "x",
- want: map[string]string{
- "/go/src/main/0.go": `package main
-
-var x int
-
-func f() {
- print(x)
- y := ""
- print(y)
-}
-`,
- },
- },
- {
- from: "main.f::y", to: "x",
- want: map[string]string{
- "/go/src/main/0.go": `package main
-
-var y int
-
-func f() {
- print(y)
- x := ""
- print(x)
-}
-`,
- },
- },
- // Renaming of typeswitch vars (a corner case).
- {
- ctxt: main(`package main
-
-func f(z interface{}) {
- switch y := z.(type) {
- case int:
- print(y)
- default:
- print(y)
- }
-}
-`),
- offset: "/go/src/main/0.go:#46", to: "x", // def of y
- want: map[string]string{
- "/go/src/main/0.go": `package main
-
-func f(z interface{}) {
- switch x := z.(type) {
- case int:
- print(x)
- default:
- print(x)
- }
-}
-`},
- },
- {
- offset: "/go/src/main/0.go:#81", to: "x", // ref of y in case int
- want: map[string]string{
- "/go/src/main/0.go": `package main
-
-func f(z interface{}) {
- switch x := z.(type) {
- case int:
- print(x)
- default:
- print(x)
- }
-}
-`},
- },
- {
- offset: "/go/src/main/0.go:#102", to: "x", // ref of y in default case
- want: map[string]string{
- "/go/src/main/0.go": `package main
-
-func f(z interface{}) {
- switch x := z.(type) {
- case int:
- print(x)
- default:
- print(x)
- }
-}
-`},
- },
-
- // Renaming of embedded field that is a qualified reference.
- // (Regression test for bug 8924.)
- {
- ctxt: fakeContext(map[string][]string{
- "foo": {`package foo; type T int`},
- "main": {`package main
-
-import "foo"
-
-type _ struct{ *foo.T }
-`},
- }),
- offset: "/go/src/main/0.go:#48", to: "U", // the "T" in *foo.T
- want: map[string]string{
- "/go/src/foo/0.go": `package foo
-
-type U int
-`,
- "/go/src/main/0.go": `package main
-
-import "foo"
-
-type _ struct{ *foo.U }
-`,
- },
- },
-
- // Renaming of embedded field that is a qualified reference with the '-from' flag.
- // (Regression test for bug 12038.)
- {
- ctxt: fakeContext(map[string][]string{
- "foo": {`package foo; type T int`},
- "main": {`package main
-
-import "foo"
-
-type V struct{ *foo.T }
-`},
- }),
- from: "(main.V).T", to: "U", // the "T" in *foo.T
- want: map[string]string{
- "/go/src/foo/0.go": `package foo
-
-type U int
-`,
- "/go/src/main/0.go": `package main
-
-import "foo"
-
-type V struct{ *foo.U }
-`,
- },
- },
- {
- ctxt: fakeContext(map[string][]string{
- "foo": {`package foo; type T int`},
- "main": {`package main
-
-import "foo"
-
-type V struct{ foo.T }
-`},
- }),
- from: "(main.V).T", to: "U", // the "T" in *foo.T
- want: map[string]string{
- "/go/src/foo/0.go": `package foo
-
-type U int
-`,
- "/go/src/main/0.go": `package main
-
-import "foo"
-
-type V struct{ foo.U }
-`,
- },
- },
-
- // Interface method renaming.
- {
- ctxt: fakeContext(map[string][]string{
- "main": {`
-package main
-type I interface {
- f()
-}
-type J interface { f(); g() }
-type A int
-func (A) f()
-type B int
-func (B) f()
-func (B) g()
-type C int
-func (C) f()
-func (C) g()
-var _, _ I = A(0), B(0)
-var _, _ J = B(0), C(0)
-`,
- },
- }),
- offset: "/go/src/main/0.go:#34", to: "F", // abstract method I.f
- want: map[string]string{
- "/go/src/main/0.go": `package main
-
-type I interface {
- F()
-}
-type J interface {
- F()
- g()
-}
-type A int
-
-func (A) F()
-
-type B int
-
-func (B) F()
-func (B) g()
-
-type C int
-
-func (C) F()
-func (C) g()
-
-var _, _ I = A(0), B(0)
-var _, _ J = B(0), C(0)
-`,
- },
- },
- {
- offset: "/go/src/main/0.go:#59", to: "F", // abstract method J.f
- want: map[string]string{
- "/go/src/main/0.go": `package main
-
-type I interface {
- F()
-}
-type J interface {
- F()
- g()
-}
-type A int
-
-func (A) F()
-
-type B int
-
-func (B) F()
-func (B) g()
-
-type C int
-
-func (C) F()
-func (C) g()
-
-var _, _ I = A(0), B(0)
-var _, _ J = B(0), C(0)
-`,
- },
- },
- {
- offset: "/go/src/main/0.go:#64", to: "G", // abstract method J.g
- want: map[string]string{
- "/go/src/main/0.go": `package main
-
-type I interface {
- f()
-}
-type J interface {
- f()
- G()
-}
-type A int
-
-func (A) f()
-
-type B int
-
-func (B) f()
-func (B) G()
-
-type C int
-
-func (C) f()
-func (C) G()
-
-var _, _ I = A(0), B(0)
-var _, _ J = B(0), C(0)
-`,
- },
- },
- // Indirect coupling of I.f to C.f from D->I assignment and anonymous field of D.
- {
- ctxt: fakeContext(map[string][]string{
- "main": {`
-package main
-type I interface {
- f()
-}
-type C int
-func (C) f()
-type D struct{C}
-var _ I = D{}
-`,
- },
- }),
- offset: "/go/src/main/0.go:#34", to: "F", // abstract method I.f
- want: map[string]string{
- "/go/src/main/0.go": `package main
-
-type I interface {
- F()
-}
-type C int
-
-func (C) F()
-
-type D struct{ C }
-
-var _ I = D{}
-`,
- },
- },
- // Interface embedded in struct. No conflict if C need not satisfy I.
- {
- ctxt: fakeContext(map[string][]string{
- "main": {`
-package main
-type I interface {
- f()
-}
-type C struct{I}
-func (C) g() int
-var _ int = C{}.g()
-`,
- },
- }),
- offset: "/go/src/main/0.go:#34", to: "g", // abstract method I.f
- want: map[string]string{
- "/go/src/main/0.go": `package main
-
-type I interface {
- g()
-}
-type C struct{ I }
-
-func (C) g() int
-
-var _ int = C{}.g()
-`,
- },
- },
- // A type assertion causes method coupling iff signatures match.
- {
- ctxt: fakeContext(map[string][]string{
- "main": {`package main
-type I interface{
- f()
-}
-type J interface{
- f()
-}
-var _ = I(nil).(J)
-`,
- },
- }),
- offset: "/go/src/main/0.go:#32", to: "g", // abstract method I.f
- want: map[string]string{
- "/go/src/main/0.go": `package main
-
-type I interface {
- g()
-}
-type J interface {
- g()
-}
-
-var _ = I(nil).(J)
-`,
- },
- },
- // Impossible type assertion: no method coupling.
- {
- ctxt: fakeContext(map[string][]string{
- "main": {`package main
-type I interface{
- f()
-}
-type J interface{
- f()int
-}
-var _ = I(nil).(J)
-`,
- },
- }),
- offset: "/go/src/main/0.go:#32", to: "g", // abstract method I.f
- want: map[string]string{
- "/go/src/main/0.go": `package main
-
-type I interface {
- g()
-}
-type J interface {
- f() int
-}
-
-var _ = I(nil).(J)
-`,
- },
- },
- // Impossible type assertion: no method coupling C.f<->J.f.
- {
- ctxt: fakeContext(map[string][]string{
- "main": {`package main
-type I interface{
- f()
-}
-type C int
-func (C) f()
-type J interface{
- f()int
-}
-var _ = I(C(0)).(J)
-`,
- },
- }),
- offset: "/go/src/main/0.go:#32", to: "g", // abstract method I.f
- want: map[string]string{
- "/go/src/main/0.go": `package main
-
-type I interface {
- g()
-}
-type C int
-
-func (C) g()
-
-type J interface {
- f() int
-}
-
-var _ = I(C(0)).(J)
-`,
- },
- },
- // Progress after "soft" type errors (Go issue 14596).
- {
- ctxt: fakeContext(map[string][]string{
- "main": {`package main
-
-func main() {
- var unused, x int
- print(x)
-}
-`,
- },
- }),
- offset: "/go/src/main/0.go:#54", to: "y", // var x
- want: map[string]string{
- "/go/src/main/0.go": `package main
-
-func main() {
- var unused, y int
- print(y)
-}
-`,
- },
- },
- } {
- if test.ctxt != nil {
- ctxt = test.ctxt
- }
-
- got := make(map[string]string)
- writeFile = func(filename string, content []byte) error {
- got[filepath.ToSlash(filename)] = string(content)
- return nil
- }
-
- err := Main(ctxt, test.offset, test.from, test.to)
- var prefix string
- if test.offset == "" {
- prefix = fmt.Sprintf("-from %q -to %q", test.from, test.to)
- } else {
- prefix = fmt.Sprintf("-offset %q -to %q", test.offset, test.to)
- }
- if err != nil {
- t.Errorf("%s: unexpected error: %s", prefix, err)
- continue
- }
-
- for file, wantContent := range test.want {
- gotContent, ok := got[file]
- delete(got, file)
- if !ok {
- t.Errorf("%s: file %s not rewritten", prefix, file)
- continue
- }
- if gotContent != wantContent {
- t.Errorf("%s: rewritten file %s does not match expectation; got <<<%s>>>\n"+
- "want <<<%s>>>", prefix, file, gotContent, wantContent)
- }
- }
- // got should now be empty
- for file := range got {
- t.Errorf("%s: unexpected rewrite of file %s", prefix, file)
- }
- }
-}
-
-func TestDiff(t *testing.T) {
- switch runtime.GOOS {
- case "windows":
- if os.Getenv("GO_BUILDER_NAME") != "" {
- if _, err := exec.LookPath(DiffCmd); err != nil {
- t.Skipf("diff tool non-existent for %s on builders", runtime.GOOS)
- }
- }
- case "plan9":
- t.Skipf("plan9 diff tool doesn't support -u flag")
- }
- testenv.NeedsTool(t, DiffCmd)
- testenv.NeedsTool(t, "go") // to locate the package to be renamed
-
- defer func() {
- Diff = false
- stdout = os.Stdout
- }()
- Diff = true
- stdout = new(bytes.Buffer)
-
- // Set up a fake GOPATH in a temporary directory,
- // and ensure we're in GOPATH mode.
- tmpdir, err := ioutil.TempDir("", "TestDiff")
- if err != nil {
- t.Fatal(err)
- }
- defer os.RemoveAll(tmpdir)
- buildCtx := build.Default
- buildCtx.GOPATH = tmpdir
-
- pkgDir := filepath.Join(tmpdir, "src", "example.com", "rename")
- if err := os.MkdirAll(pkgDir, 0777); err != nil {
- t.Fatal(err)
- }
-
- prevWD, err := os.Getwd()
- if err != nil {
- t.Fatal(err)
- }
- defer os.Chdir(prevWD)
-
- if err := os.Chdir(pkgDir); err != nil {
- t.Fatal(err)
- }
-
- const modFile = `module example.com/rename
-
-go 1.15
-`
- if err := ioutil.WriteFile(filepath.Join(pkgDir, "go.mod"), []byte(modFile), 0644); err != nil {
- t.Fatal(err)
- }
-
- const goFile = `package rename
-
-func justHereForTestingDiff() {
- justHereForTestingDiff()
-}
-`
- if err := ioutil.WriteFile(filepath.Join(pkgDir, "rename_test.go"), []byte(goFile), 0644); err != nil {
- t.Fatal(err)
- }
-
- if err := Main(&buildCtx, "", `"example.com/rename".justHereForTestingDiff`, "Foo"); err != nil {
- t.Fatal(err)
- }
-
- // NB: there are tabs in the string literal!
- if !strings.Contains(stdout.(fmt.Stringer).String(), `
--func justHereForTestingDiff() {
-- justHereForTestingDiff()
-+func Foo() {
-+ Foo()
- }
-`) {
- t.Errorf("unexpected diff:\n<<%s>>", stdout)
- }
-}
-
-// ---------------------------------------------------------------------
-
-// Simplifying wrapper around buildutil.FakeContext for packages whose
-// filenames are sequentially numbered (%d.go). pkgs maps a package
-// import path to its list of file contents.
-func fakeContext(pkgs map[string][]string) *build.Context {
- pkgs2 := make(map[string]map[string]string)
- for path, files := range pkgs {
- filemap := make(map[string]string)
- for i, contents := range files {
- filemap[fmt.Sprintf("%d.go", i)] = contents
- }
- pkgs2[path] = filemap
- }
- return buildutil.FakeContext(pkgs2)
-}
-
-// helper for single-file main packages with no imports.
-func main(content string) *build.Context {
- return fakeContext(map[string][]string{"main": {content}})
-}
projects / dotfiles / .git / blobdiff