languages/go
languages/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-07-19 19:44:12 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[dev.typeparams] go/types: interface identity must consider full type set

Browse source 
This is a port of CL 333889 to go/types.

Change-Id: I66cefb81a33f4677efc18c1ca923ded374a87f12
Reviewed-on: https://go-review.googlesource.com/c/go/+/335080
Trust: Robert Findley <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
This commit is contained in:
Rob Findley 2021-07-16 20:46:39 -04:00 committed by Robert Findley
parent baeabf3b36
commit 62f6f130fe
2 changed files with 21 additions and 8 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

17
src/go/types/predicates.go
View file

@ -270,12 +270,21 @@ func identical(x, y Type, cmpTags bool, p *ifacePair) bool {
}
case *Interface:
// Two interface types are identical if they describe the same type sets.
// With the existing implementation restriction, this simplifies to:
//
// Two interface types are identical if they have the same set of methods with
// the same names and identical function types. Lower-case method names from
// different packages are always different. The order of the methods is irrelevant.
// the same names and identical function types, and if any type restrictions
// are the same. Lower-case method names from different packages are always
// different. The order of the methods is irrelevant.
if y, ok := y.(*Interface); ok {
a := x.typeSet().methods
b := y.typeSet().methods
xset := x.typeSet()
yset := y.typeSet()
if !Identical(xset.types, yset.types) {
return false
}
a := xset.methods
b := yset.methods
if len(a) == len(b) {
// Interface types are the only types where cycles can occur
// that are not "terminated" via named types; and such cycles

12
src/go/types/unify.go
View file

@ -359,16 +359,20 @@ func (u *unifier) nify(x, y Type, p *ifacePair) bool {
}
case *Union:
// This should not happen with the current internal use of union types.
panic("type inference across union types not implemented")
panic("unimplemented: unification with type sets described by types")
case *Interface:
// Two interface types are identical if they have the same set of methods with
// the same names and identical function types. Lower-case method names from
// different packages are always different. The order of the methods is irrelevant.
if y, ok := y.(*Interface); ok {
a := x.typeSet().methods
b := y.typeSet().methods
xset := x.typeSet()
yset := y.typeSet()
if !Identical(xset.types, yset.types) {
return false
}
a := xset.methods
b := yset.methods
if len(a) == len(b) {
// Interface types are the only types where cycles can occur
// that are not "terminated" via named types; and such cycles