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] cmd/compile/internal/types2: interface identity must consider full type set

Browse source 
There is no (obvious) way to test this at the moment because we
don't permit such constraint interfaces as ordinary types.

Change-Id: Ieeec023ed82a2c71ed50d111f26916aba4a59099
Reviewed-on: https://go-review.googlesource.com/c/go/+/333889
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
This commit is contained in:
Robert Griesemer 2021-07-11 15:27:49 -07:00
parent 2a8087817c
commit dd8bdf4a1f
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/cmd/compile/internal/types2/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/cmd/compile/internal/types2/unify.go
View file

@ -362,16 +362,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