// If DisableUnusedImportCheck is set, packages are not checked
// for unused imports.
DisableUnusedImportCheck bool
+
+ // If EnableInterfaceInference is set, type inference uses
+ // shared methods for improved type inference involving
+ // interfaces.
+ EnableInterfaceInference bool
}
func srcimporter_setUsesCgo(conf *Config) {
flags := flag.NewFlagSet("", flag.PanicOnError)
flags.StringVar(&conf.GoVersion, "lang", "", "")
flags.BoolVar(&conf.FakeImportC, "fakeImportC", false, "")
+ flags.BoolVar(&conf.EnableInterfaceInference, "EnableInterfaceInference", false, "")
if err := parseFlags(srcs[0], flags); err != nil {
t.Fatal(err)
}
// Unify parameter and argument types for generic parameters with typed arguments
// and collect the indices of generic parameters with untyped arguments.
// Terminology: generic parameter = function parameter with a type-parameterized type
- u := newUnifier(tparams, targs)
+ u := check.newUnifier(tparams, targs)
errorf := func(kind string, tpar, targ Type, arg *operand) {
// provide a better error message if we can
// corresponding types inferred for each type parameter.
// A unifier is created by calling newUnifier.
type unifier struct {
+ check *Checker
// handles maps each type parameter to its inferred type through
// an indirection *Type called (inferred type) "handle".
// Initially, each type parameter has its own, separate handle,
// and corresponding type argument lists. The type argument list may be shorter
// than the type parameter list, and it may contain nil types. Matching type
// parameters and arguments must have the same index.
-func newUnifier(tparams []*TypeParam, targs []Type) *unifier {
+func (check *Checker) newUnifier(tparams []*TypeParam, targs []Type) *unifier {
assert(len(tparams) >= len(targs))
handles := make(map[*TypeParam]*Type, len(tparams))
// Allocate all handles up-front: in a correct program, all type parameters
}
handles[x] = &t
}
- return &unifier{handles, 0}
+ return &unifier{check, handles, 0}
}
// unify attempts to unify x and y and reports whether it succeeded.
// the same type structure are permitted as long as at least one of them
// is not a defined type. To accommodate for that possibility, we continue
// unification with the underlying type of a defined type if the other type
- // is a type literal.
+ // is a type literal. However, if the type literal is an interface and we
+ // set EnableInterfaceInference, we continue with the defined type because
+ // otherwise we may lose its methods.
// We also continue if the other type is a basic type because basic types
// are valid underlying types and may appear as core types of type constraints.
// If we exclude them, inferred defined types for type parameters may not
// we will fail at function instantiation or argument assignment time.
//
// If we have at least one defined type, there is one in y.
- if ny, _ := y.(*Named); ny != nil && isTypeLit(x) {
+ if ny, _ := y.(*Named); ny != nil && isTypeLit(x) && !(u.check.conf.EnableInterfaceInference && IsInterface(x)) {
if traceInference {
u.tracef("%s ≡ under %s", x, ny)
}
x, y = y, x
}
+ // If EnableInterfaceInference is set and both types are interfaces, one
+ // interface must have a subset of the methods of the other and corresponding
+ // method signatures must unify.
+ // If only one type is an interface, all its methods must be present in the
+ // other type and corresponding method signatures must unify.
+ if u.check.conf.EnableInterfaceInference {
+ xi, _ := x.(*Interface)
+ yi, _ := y.(*Interface)
+ // If we have two interfaces, check the type terms for equivalence,
+ // and unify common methods if possible.
+ if xi != nil && yi != nil {
+ xset := xi.typeSet()
+ yset := yi.typeSet()
+ if xset.comparable != yset.comparable {
+ return false
+ }
+ // For now we require terms to be equal.
+ // We should be able to relax this as well, eventually.
+ if !xset.terms.equal(yset.terms) {
+ return false
+ }
+ // Interface types are the only types where cycles can occur
+ // that are not "terminated" via named types; and such cycles
+ // can only be created via method parameter types that are
+ // anonymous interfaces (directly or indirectly) embedding
+ // the current interface. Example:
+ //
+ // type T interface {
+ // m() interface{T}
+ // }
+ //
+ // If two such (differently named) interfaces are compared,
+ // endless recursion occurs if the cycle is not detected.
+ //
+ // If x and y were compared before, they must be equal
+ // (if they were not, the recursion would have stopped);
+ // search the ifacePair stack for the same pair.
+ //
+ // This is a quadratic algorithm, but in practice these stacks
+ // are extremely short (bounded by the nesting depth of interface
+ // type declarations that recur via parameter types, an extremely
+ // rare occurrence). An alternative implementation might use a
+ // "visited" map, but that is probably less efficient overall.
+ q := &ifacePair{xi, yi, p}
+ for p != nil {
+ if p.identical(q) {
+ return true // same pair was compared before
+ }
+ p = p.prev
+ }
+ // The method set of x must be a subset of the method set
+ // of y or vice versa, and the common methods must unify.
+ xmethods := xset.methods
+ ymethods := yset.methods
+ // The smaller method set must be the subset, if it exists.
+ if len(xmethods) > len(ymethods) {
+ xmethods, ymethods = ymethods, xmethods
+ }
+ // len(xmethods) <= len(ymethods)
+ // Collect the ymethods in a map for quick lookup.
+ ymap := make(map[string]*Func, len(ymethods))
+ for _, ym := range ymethods {
+ ymap[ym.Id()] = ym
+ }
+ // All xmethods must exist in ymethods and corresponding signatures must unify.
+ for _, xm := range xmethods {
+ if ym := ymap[xm.Id()]; ym == nil || !u.nify(xm.typ, ym.typ, p) {
+ return false
+ }
+ }
+ return true
+ }
+
+ // We don't have two interfaces. If we have one, make sure it's in xi.
+ if yi != nil {
+ xi = yi
+ y = x
+ }
+
+ // If we have one interface, at a minimum each of the interface methods
+ // must be implemented and thus unify with a corresponding method from
+ // the non-interface type, otherwise unification fails.
+ if xi != nil {
+ // All xi methods must exist in y and corresponding signatures must unify.
+ xmethods := xi.typeSet().methods
+ for _, xm := range xmethods {
+ obj, _, _ := LookupFieldOrMethod(y, false, xm.pkg, xm.name)
+ if ym, _ := obj.(*Func); ym == nil || !u.nify(xm.typ, ym.typ, p) {
+ return false
+ }
+ }
+ return true
+ }
+
+ // Neither x nor y are interface types.
+ // They must be structurally equivalent to unify.
+ }
+
switch x := x.(type) {
case *Basic:
// Basic types are singletons except for the rune and byte
}
case *Interface:
+ assert(!u.check.conf.EnableInterfaceInference) // handled before this switch
+
// Two interface types unify if they have the same set of methods with
// the same names, and corresponding function types unify.
// Lower-case method names from different packages are always different.
}
case *Named:
- // Two named types unify if their type names originate
+ // Two defined types unify if their type names originate
// in the same type declaration. If they are instantiated,
// their type argument lists must unify.
if y, ok := y.(*Named); ok {
+ sameOrig := indenticalOrigin(x, y)
+ if u.check.conf.EnableInterfaceInference {
+ xu := x.under()
+ yu := y.under()
+ xi, _ := xu.(*Interface)
+ yi, _ := yu.(*Interface)
+ // If one or both defined types are interfaces, use interface unification,
+ // unless they originated in the same type declaration.
+ if xi != nil && yi != nil {
+ // If both interfaces originate in the same declaration,
+ // their methods unify if the type parameters unify.
+ // Unify the type parameters rather than the methods in
+ // case the type parameters are not used in the methods
+ // (and to preserve existing behavior in this case).
+ if sameOrig {
+ xargs := x.TypeArgs().list()
+ yargs := y.TypeArgs().list()
+ assert(len(xargs) == len(yargs))
+ for i, xarg := range xargs {
+ if !u.nify(xarg, yargs[i], p) {
+ return false
+ }
+ }
+ return true
+ }
+ return u.nify(xu, yu, p)
+ }
+ // We don't have two interfaces. If we have one, make sure it's in xi.
+ if yi != nil {
+ xi = yi
+ y = x
+ }
+ // If xi is an interface, use interface unification.
+ if xi != nil {
+ return u.nify(xi, y, p)
+ }
+ // In all other cases, the type arguments and origins must match.
+ }
+
// Check type arguments before origins so they unify
// even if the origins don't match; for better error
// messages (see go.dev/issue/53692).
return false
}
}
- return indenticalOrigin(x, y)
+ return sameOrig
}
case *TypeParam:
// If DisableUnusedImportCheck is set, packages are not checked
// for unused imports.
DisableUnusedImportCheck bool
+
+ // If _EnableInterfaceInference is set, type inference uses
+ // shared methods for improved type inference involving
+ // interfaces.
+ _EnableInterfaceInference bool
}
func srcimporter_setUsesCgo(conf *Config) {
flags := flag.NewFlagSet("", flag.PanicOnError)
flags.StringVar(&conf.GoVersion, "lang", "", "")
flags.BoolVar(&conf.FakeImportC, "fakeImportC", false, "")
+ flags.BoolVar(boolFieldAddr(&conf, "_EnableInterfaceInference"), "EnableInterfaceInference", false, "")
if err := parseFlags(srcs[0], flags); err != nil {
t.Fatal(err)
}
"typeterm_test.go": nil,
"typeterm.go": nil,
"under.go": nil,
- "unify.go": fixSprintf,
- "universe.go": fixGlobalTypVarDecl,
- "util_test.go": fixTokenPos,
- "validtype.go": nil,
+ "unify.go": func(f *ast.File) {
+ fixSprintf(f)
+ renameIdent(f, "EnableInterfaceInference", "_EnableInterfaceInference")
+ },
+ "universe.go": fixGlobalTypVarDecl,
+ "util_test.go": fixTokenPos,
+ "validtype.go": nil,
}
// TODO(gri) We should be able to make these rewriters more configurable/composable.
// Unify parameter and argument types for generic parameters with typed arguments
// and collect the indices of generic parameters with untyped arguments.
// Terminology: generic parameter = function parameter with a type-parameterized type
- u := newUnifier(tparams, targs)
+ u := check.newUnifier(tparams, targs)
errorf := func(kind string, tpar, targ Type, arg *operand) {
// provide a better error message if we can
// corresponding types inferred for each type parameter.
// A unifier is created by calling newUnifier.
type unifier struct {
+ check *Checker
// handles maps each type parameter to its inferred type through
// an indirection *Type called (inferred type) "handle".
// Initially, each type parameter has its own, separate handle,
// and corresponding type argument lists. The type argument list may be shorter
// than the type parameter list, and it may contain nil types. Matching type
// parameters and arguments must have the same index.
-func newUnifier(tparams []*TypeParam, targs []Type) *unifier {
+func (check *Checker) newUnifier(tparams []*TypeParam, targs []Type) *unifier {
assert(len(tparams) >= len(targs))
handles := make(map[*TypeParam]*Type, len(tparams))
// Allocate all handles up-front: in a correct program, all type parameters
}
handles[x] = &t
}
- return &unifier{handles, 0}
+ return &unifier{check, handles, 0}
}
// unify attempts to unify x and y and reports whether it succeeded.
// the same type structure are permitted as long as at least one of them
// is not a defined type. To accommodate for that possibility, we continue
// unification with the underlying type of a defined type if the other type
- // is a type literal.
+ // is a type literal. However, if the type literal is an interface and we
+ // set EnableInterfaceInference, we continue with the defined type because
+ // otherwise we may lose its methods.
// We also continue if the other type is a basic type because basic types
// are valid underlying types and may appear as core types of type constraints.
// If we exclude them, inferred defined types for type parameters may not
// we will fail at function instantiation or argument assignment time.
//
// If we have at least one defined type, there is one in y.
- if ny, _ := y.(*Named); ny != nil && isTypeLit(x) {
+ if ny, _ := y.(*Named); ny != nil && isTypeLit(x) && !(u.check.conf._EnableInterfaceInference && IsInterface(x)) {
if traceInference {
u.tracef("%s ≡ under %s", x, ny)
}
x, y = y, x
}
+ // If EnableInterfaceInference is set and both types are interfaces, one
+ // interface must have a subset of the methods of the other and corresponding
+ // method signatures must unify.
+ // If only one type is an interface, all its methods must be present in the
+ // other type and corresponding method signatures must unify.
+ if u.check.conf._EnableInterfaceInference {
+ xi, _ := x.(*Interface)
+ yi, _ := y.(*Interface)
+ // If we have two interfaces, check the type terms for equivalence,
+ // and unify common methods if possible.
+ if xi != nil && yi != nil {
+ xset := xi.typeSet()
+ yset := yi.typeSet()
+ if xset.comparable != yset.comparable {
+ return false
+ }
+ // For now we require terms to be equal.
+ // We should be able to relax this as well, eventually.
+ if !xset.terms.equal(yset.terms) {
+ return false
+ }
+ // Interface types are the only types where cycles can occur
+ // that are not "terminated" via named types; and such cycles
+ // can only be created via method parameter types that are
+ // anonymous interfaces (directly or indirectly) embedding
+ // the current interface. Example:
+ //
+ // type T interface {
+ // m() interface{T}
+ // }
+ //
+ // If two such (differently named) interfaces are compared,
+ // endless recursion occurs if the cycle is not detected.
+ //
+ // If x and y were compared before, they must be equal
+ // (if they were not, the recursion would have stopped);
+ // search the ifacePair stack for the same pair.
+ //
+ // This is a quadratic algorithm, but in practice these stacks
+ // are extremely short (bounded by the nesting depth of interface
+ // type declarations that recur via parameter types, an extremely
+ // rare occurrence). An alternative implementation might use a
+ // "visited" map, but that is probably less efficient overall.
+ q := &ifacePair{xi, yi, p}
+ for p != nil {
+ if p.identical(q) {
+ return true // same pair was compared before
+ }
+ p = p.prev
+ }
+ // The method set of x must be a subset of the method set
+ // of y or vice versa, and the common methods must unify.
+ xmethods := xset.methods
+ ymethods := yset.methods
+ // The smaller method set must be the subset, if it exists.
+ if len(xmethods) > len(ymethods) {
+ xmethods, ymethods = ymethods, xmethods
+ }
+ // len(xmethods) <= len(ymethods)
+ // Collect the ymethods in a map for quick lookup.
+ ymap := make(map[string]*Func, len(ymethods))
+ for _, ym := range ymethods {
+ ymap[ym.Id()] = ym
+ }
+ // All xmethods must exist in ymethods and corresponding signatures must unify.
+ for _, xm := range xmethods {
+ if ym := ymap[xm.Id()]; ym == nil || !u.nify(xm.typ, ym.typ, p) {
+ return false
+ }
+ }
+ return true
+ }
+
+ // We don't have two interfaces. If we have one, make sure it's in xi.
+ if yi != nil {
+ xi = yi
+ y = x
+ }
+
+ // If we have one interface, at a minimum each of the interface methods
+ // must be implemented and thus unify with a corresponding method from
+ // the non-interface type, otherwise unification fails.
+ if xi != nil {
+ // All xi methods must exist in y and corresponding signatures must unify.
+ xmethods := xi.typeSet().methods
+ for _, xm := range xmethods {
+ obj, _, _ := LookupFieldOrMethod(y, false, xm.pkg, xm.name)
+ if ym, _ := obj.(*Func); ym == nil || !u.nify(xm.typ, ym.typ, p) {
+ return false
+ }
+ }
+ return true
+ }
+
+ // Neither x nor y are interface types.
+ // They must be structurally equivalent to unify.
+ }
+
switch x := x.(type) {
case *Basic:
// Basic types are singletons except for the rune and byte
}
case *Interface:
+ assert(!u.check.conf._EnableInterfaceInference) // handled before this switch
+
// Two interface types unify if they have the same set of methods with
// the same names, and corresponding function types unify.
// Lower-case method names from different packages are always different.
}
case *Named:
- // Two named types unify if their type names originate
+ // Two defined types unify if their type names originate
// in the same type declaration. If they are instantiated,
// their type argument lists must unify.
if y, ok := y.(*Named); ok {
+ sameOrig := indenticalOrigin(x, y)
+ if u.check.conf._EnableInterfaceInference {
+ xu := x.under()
+ yu := y.under()
+ xi, _ := xu.(*Interface)
+ yi, _ := yu.(*Interface)
+ // If one or both defined types are interfaces, use interface unification,
+ // unless they originated in the same type declaration.
+ if xi != nil && yi != nil {
+ // If both interfaces originate in the same declaration,
+ // their methods unify if the type parameters unify.
+ // Unify the type parameters rather than the methods in
+ // case the type parameters are not used in the methods
+ // (and to preserve existing behavior in this case).
+ if sameOrig {
+ xargs := x.TypeArgs().list()
+ yargs := y.TypeArgs().list()
+ assert(len(xargs) == len(yargs))
+ for i, xarg := range xargs {
+ if !u.nify(xarg, yargs[i], p) {
+ return false
+ }
+ }
+ return true
+ }
+ return u.nify(xu, yu, p)
+ }
+ // We don't have two interfaces. If we have one, make sure it's in xi.
+ if yi != nil {
+ xi = yi
+ y = x
+ }
+ // If xi is an interface, use interface unification.
+ if xi != nil {
+ return u.nify(xi, y, p)
+ }
+ // In all other cases, the type arguments and origins must match.
+ }
+
// Check type arguments before origins so they unify
// even if the origins don't match; for better error
// messages (see go.dev/issue/53692).
return false
}
}
- return indenticalOrigin(x, y)
+ return sameOrig
}
case *TypeParam:
--- /dev/null
+// -EnableInterfaceInference
+
+// Copyright 2023 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 p
+
+type S struct{}
+
+func (S) M() byte {
+ return 0
+}
+
+type I[T any] interface {
+ M() T
+}
+
+func f[T any](x I[T]) {}
+
+func _() {
+ f(S{})
+}
--- /dev/null
+// -EnableInterfaceInference
+
+// Copyright 2023 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 p
+
+type I1[T any] interface {
+ m1(T)
+}
+type I2[T any] interface {
+ I1[T]
+ m2(T)
+}
+
+var V1 I1[int]
+var V2 I2[int]
+
+func g[T any](I1[T]) {}
+func _() {
+ g(V1)
+ g(V2)
+}