From 3c751cd15c4c991829b13a128387223a5b0efa84 Mon Sep 17 00:00:00 2001 From: Tim King Date: Thu, 20 Jan 2022 15:04:44 -0800 Subject: [PATCH] passes/ifaceassert: supress typeparams reports Supresses reporting when either interface is type parameterized. In principle, we should be able to report when we know two interfaces cannot be unified. This is more complicated with type parameters. Waiting on go/types to provide this complex functionality. Updates #50658 Change-Id: Ib767585c785aea12dbb9e337cc339881a63be57e Reviewed-on: https://go-review.googlesource.com/c/tools/+/380014 Run-TryBot: Tim King Reviewed-by: Robert Findley gopls-CI: kokoro TryBot-Result: Gopher Robot Trust: Tim King --- go/analysis/passes/ifaceassert/ifaceassert.go | 6 + .../passes/ifaceassert/parameterized.go | 112 ++++++++++++++++++ .../testdata/src/typeparams/typeparams.go | 66 +++++++++++ 3 files changed, 184 insertions(+) create mode 100644 go/analysis/passes/ifaceassert/parameterized.go diff --git a/go/analysis/passes/ifaceassert/ifaceassert.go b/go/analysis/passes/ifaceassert/ifaceassert.go index fd2285332cc..30130f63ea6 100644 --- a/go/analysis/passes/ifaceassert/ifaceassert.go +++ b/go/analysis/passes/ifaceassert/ifaceassert.go @@ -51,6 +51,12 @@ func assertableTo(v, t types.Type) *types.Func { if V == nil || T == nil { return nil } + + // Mitigations for interface comparisons and generics. + // TODO(https://github.com/golang/go/issues/50658): Support more precise conclusion. + if isParameterized(V) || isParameterized(T) { + return nil + } if f, wrongType := types.MissingMethod(V, T, false); wrongType { return f } diff --git a/go/analysis/passes/ifaceassert/parameterized.go b/go/analysis/passes/ifaceassert/parameterized.go new file mode 100644 index 00000000000..1285ecf1367 --- /dev/null +++ b/go/analysis/passes/ifaceassert/parameterized.go @@ -0,0 +1,112 @@ +// Copyright 2022 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 ifaceassert + +import ( + "go/types" + + "golang.org/x/tools/internal/typeparams" +) + +// isParameterized reports whether typ contains any of the type parameters of tparams. +// +// NOTE: Adapted from go/types/infer.go. If that is exported in a future release remove this copy. +func isParameterized(typ types.Type) bool { + w := tpWalker{ + seen: make(map[types.Type]bool), + } + return w.isParameterized(typ) +} + +type tpWalker struct { + seen map[types.Type]bool +} + +func (w *tpWalker) isParameterized(typ types.Type) (res bool) { + // detect cycles + if x, ok := w.seen[typ]; ok { + return x + } + w.seen[typ] = false + defer func() { + w.seen[typ] = res + }() + + switch t := typ.(type) { + case nil, *types.Basic: // TODO(gri) should nil be handled here? + break + + case *types.Array: + return w.isParameterized(t.Elem()) + + case *types.Slice: + return w.isParameterized(t.Elem()) + + case *types.Struct: + for i, n := 0, t.NumFields(); i < n; i++ { + if w.isParameterized(t.Field(i).Type()) { + return true + } + } + + case *types.Pointer: + return w.isParameterized(t.Elem()) + + case *types.Tuple: + n := t.Len() + for i := 0; i < n; i++ { + if w.isParameterized(t.At(i).Type()) { + return true + } + } + + case *types.Signature: + // t.tparams may not be nil if we are looking at a signature + // of a generic function type (or an interface method) that is + // part of the type we're testing. We don't care about these type + // parameters. + // Similarly, the receiver of a method may declare (rather then + // use) type parameters, we don't care about those either. + // Thus, we only need to look at the input and result parameters. + return w.isParameterized(t.Params()) || w.isParameterized(t.Results()) + + case *types.Interface: + for i, n := 0, t.NumMethods(); i < n; i++ { + if w.isParameterized(t.Method(i).Type()) { + return true + } + } + terms, err := typeparams.InterfaceTermSet(t) + if err != nil { + panic(err) + } + for _, term := range terms { + if w.isParameterized(term.Type()) { + return true + } + } + + case *types.Map: + return w.isParameterized(t.Key()) || w.isParameterized(t.Elem()) + + case *types.Chan: + return w.isParameterized(t.Elem()) + + case *types.Named: + list := typeparams.NamedTypeArgs(t) + for i, n := 0, list.Len(); i < n; i++ { + if w.isParameterized(list.At(i)) { + return true + } + } + + case *typeparams.TypeParam: + return true + + default: + panic(t) // unreachable + } + + return false +} diff --git a/go/analysis/passes/ifaceassert/testdata/src/typeparams/typeparams.go b/go/analysis/passes/ifaceassert/testdata/src/typeparams/typeparams.go index dd0c9b2b59a..65709c067a8 100644 --- a/go/analysis/passes/ifaceassert/testdata/src/typeparams/typeparams.go +++ b/go/analysis/passes/ifaceassert/testdata/src/typeparams/typeparams.go @@ -34,3 +34,69 @@ func GenericInterfaceAssertionTest[T io.Reader]() { default: } } + +// Issue 50658: Check for type parameters in type switches. +type Float interface { + float32 | float64 +} + +type Doer[F Float] interface { + Do() F +} + +func Underlying[F Float](v Doer[F]) string { + switch v.(type) { + case Doer[float32]: + return "float32!" + case Doer[float64]: + return "float64!" + default: + return "" + } +} + +func DoIf[F Float]() { + // This is a synthetic function to create a non-generic to generic assignment. + // This function does not make much sense. + var v Doer[float32] + if t, ok := v.(Doer[F]); ok { + t.Do() + } +} + +func IsASwitch[F Float, U Float](v Doer[F]) bool { + switch v.(type) { + case Doer[U]: + return true + } + return false +} + +func IsA[F Float, U Float](v Doer[F]) bool { + _, is := v.(Doer[U]) + return is +} + +func LayeredTypes[F Float]() { + // This is a synthetic function cover more isParameterized cases. + type T interface { + foo() struct{ _ map[T][2]chan *F } + } + type V interface { + foo() struct{ _ map[T][2]chan *float32 } + } + var t T + var v V + t, _ = v.(T) + _ = t +} + +type X[T any] struct{} + +func (x X[T]) m(T) {} + +func InstancesOfGenericMethods() { + var x interface{ m(string) } + // _ = x.(X[int]) // BAD. Not enabled as it does not type check. + _ = x.(X[string]) // OK +}