| This test exercises various renaming features on generic code. |
| |
| Fixed bugs: |
| |
| - golang/go#61614: renaming a method of a type in a package that uses type |
| parameter composite lits used to panic, because previous iterations of the |
| satisfy analysis did not account for this language feature. |
| |
| - golang/go#61635: renaming type parameters did not work when they were |
| capitalized and the package was imported by another package. |
| |
| -- flags -- |
| -min_go=go1.18 |
| |
| -- go.mod -- |
| module example.com |
| go 1.20 |
| |
| -- a.go -- |
| package a |
| |
| type I int |
| |
| func (I) m() {} //@rename("m", "M", mToM) |
| |
| func _[P ~[]int]() { |
| _ = P{} |
| } |
| |
| -- @mToM/a.go -- |
| package a |
| |
| type I int |
| |
| func (I) M() {} //@rename("m", "M", mToM) |
| |
| func _[P ~[]int]() { |
| _ = P{} |
| } |
| |
| -- g.go -- |
| package a |
| |
| type S[P any] struct { //@rename("P", "Q", PToQ) |
| P P |
| F func(P) P |
| } |
| |
| func F[R any](r R) { |
| var _ R //@rename("R", "S", RToS) |
| } |
| |
| -- @PToQ/g.go -- |
| package a |
| |
| type S[Q any] struct { //@rename("P", "Q", PToQ) |
| P Q |
| F func(Q) Q |
| } |
| |
| func F[R any](r R) { |
| var _ R //@rename("R", "S", RToS) |
| } |
| |
| -- @RToS/g.go -- |
| package a |
| |
| type S[P any] struct { //@rename("P", "Q", PToQ) |
| P P |
| F func(P) P |
| } |
| |
| func F[S any](r S) { |
| var _ S //@rename("R", "S", RToS) |
| } |
| |
| -- issue61635/p.go -- |
| package issue61635 |
| |
| type builder[S ~[]F, F ~string] struct { //@rename("S", "T", SToT) |
| name string |
| elements S |
| elemData map[F][]ElemData[F] |
| // other fields... |
| } |
| |
| type ElemData[F ~string] struct { |
| Name F |
| // other fields... |
| } |
| |
| type BuilderImpl[S ~[]F, F ~string] struct{ builder[S, F] } |
| |
| -- importer/i.go -- |
| package importer |
| |
| import "example.com/issue61635" // importing is necessary to repro golang/go#61635 |
| |
| var _ issue61635.ElemData[string] |
| |
| -- @SToT/issue61635/p.go -- |
| package issue61635 |
| |
| type builder[T ~[]F, F ~string] struct { //@rename("S", "T", SToT) |
| name string |
| elements T |
| elemData map[F][]ElemData[F] |
| // other fields... |
| } |
| |
| type ElemData[F ~string] struct { |
| Name F |
| // other fields... |
| } |
| |
| type BuilderImpl[S ~[]F, F ~string] struct{ builder[S, F] } |
| |
| -- instances/type.go -- |
| package instances |
| |
| type R[P any] struct { //@rename("R", "u", Rtou) |
| Next *R[P] //@rename("R", "s", RTos) |
| } |
| |
| func (rv R[P]) Do(R[P]) R[P] { //@rename("Do", "Do1", DoToDo1) |
| var x R[P] |
| return rv.Do(x) //@rename("Do", "Do2", DoToDo2) |
| } |
| |
| func _() { |
| var x R[int] //@rename("R", "r", RTor) |
| x = x.Do(x) |
| } |
| |
| -- @RTos/instances/type.go -- |
| package instances |
| |
| type s[P any] struct { //@rename("R", "u", Rtou) |
| Next *s[P] //@rename("R", "s", RTos) |
| } |
| |
| func (rv s[P]) Do(s[P]) s[P] { //@rename("Do", "Do1", DoToDo1) |
| var x s[P] |
| return rv.Do(x) //@rename("Do", "Do2", DoToDo2) |
| } |
| |
| func _() { |
| var x s[int] //@rename("R", "r", RTor) |
| x = x.Do(x) |
| } |
| |
| -- @Rtou/instances/type.go -- |
| package instances |
| |
| type u[P any] struct { //@rename("R", "u", Rtou) |
| Next *u[P] //@rename("R", "s", RTos) |
| } |
| |
| func (rv u[P]) Do(u[P]) u[P] { //@rename("Do", "Do1", DoToDo1) |
| var x u[P] |
| return rv.Do(x) //@rename("Do", "Do2", DoToDo2) |
| } |
| |
| func _() { |
| var x u[int] //@rename("R", "r", RTor) |
| x = x.Do(x) |
| } |
| |
| -- @DoToDo1/instances/type.go -- |
| package instances |
| |
| type R[P any] struct { //@rename("R", "u", Rtou) |
| Next *R[P] //@rename("R", "s", RTos) |
| } |
| |
| func (rv R[P]) Do1(R[P]) R[P] { //@rename("Do", "Do1", DoToDo1) |
| var x R[P] |
| return rv.Do1(x) //@rename("Do", "Do2", DoToDo2) |
| } |
| |
| func _() { |
| var x R[int] //@rename("R", "r", RTor) |
| x = x.Do1(x) |
| } |
| |
| -- @DoToDo2/instances/type.go -- |
| package instances |
| |
| type R[P any] struct { //@rename("R", "u", Rtou) |
| Next *R[P] //@rename("R", "s", RTos) |
| } |
| |
| func (rv R[P]) Do2(R[P]) R[P] { //@rename("Do", "Do1", DoToDo1) |
| var x R[P] |
| return rv.Do2(x) //@rename("Do", "Do2", DoToDo2) |
| } |
| |
| func _() { |
| var x R[int] //@rename("R", "r", RTor) |
| x = x.Do2(x) |
| } |
| |
| -- instances/func.go -- |
| package instances |
| |
| func Foo[P any](p P) { //@rename("Foo", "Bar", FooToBar) |
| Foo(p) //@rename("Foo", "Baz", FooToBaz) |
| } |
| |
| -- @FooToBar/instances/func.go -- |
| package instances |
| |
| func Bar[P any](p P) { //@rename("Foo", "Bar", FooToBar) |
| Bar(p) //@rename("Foo", "Baz", FooToBaz) |
| } |
| |
| -- @FooToBaz/instances/func.go -- |
| package instances |
| |
| func Baz[P any](p P) { //@rename("Foo", "Bar", FooToBar) |
| Baz(p) //@rename("Foo", "Baz", FooToBaz) |
| } |
| |
| -- @RTor/instances/type.go -- |
| package instances |
| |
| type r[P any] struct { //@rename("R", "u", Rtou) |
| Next *r[P] //@rename("R", "s", RTos) |
| } |
| |
| func (rv r[P]) Do(r[P]) r[P] { //@rename("Do", "Do1", DoToDo1) |
| var x r[P] |
| return rv.Do(x) //@rename("Do", "Do2", DoToDo2) |
| } |
| |
| func _() { |
| var x r[int] //@rename("R", "r", RTor) |
| x = x.Do(x) |
| } |
| |