From d9dce0cd26a1e5df0aa2dbbecde4515807be929e Mon Sep 17 00:00:00 2001 From: Robert Griesemer <gri@golang.org> Date: Tue, 9 May 2023 14:02:07 -0700 Subject: [PATCH] go/types, types2: explicitly look for nil type arguments in infer Don't assume we have all type arguments if the number of type arguments matches the number of type parameters. Instead, look explicitly for nil type arguments in the provided targs. Preparation for type inference with type arguments provided for type parameters of generic function arguments passed to other functions. For #59338. Change-Id: I00918cd5ed06ae3277b4e41a3641063e0f53fef0 Reviewed-on: https://go-review.googlesource.com/c/go/+/494115 Reviewed-by: Robert Griesemer <gri@google.com> Run-TryBot: Robert Griesemer <gri@google.com> Reviewed-by: Robert Findley <rfindley@google.com> Auto-Submit: Robert Griesemer <gri@google.com> TryBot-Result: Gopher Robot <gobot@golang.org> --- src/cmd/compile/internal/types2/infer.go | 20 +++++++++++++------- src/go/types/infer.go | 20 +++++++++++++------- 2 files changed, 26 insertions(+), 14 deletions(-) diff --git a/src/cmd/compile/internal/types2/infer.go b/src/cmd/compile/internal/types2/infer.go index 94a59f94bbf77..d8c81820f8884 100644 --- a/src/cmd/compile/internal/types2/infer.go +++ b/src/cmd/compile/internal/types2/infer.go @@ -29,10 +29,7 @@ const enableReverseTypeInference = true // disable for debugging func (check *Checker) infer(pos syntax.Pos, tparams []*TypeParam, targs []Type, params *Tuple, args []*operand) (inferred []Type) { if debug { defer func() { - assert(inferred == nil || len(inferred) == len(tparams)) - for _, targ := range inferred { - assert(targ != nil) - } + assert(inferred == nil || len(inferred) == len(tparams) && !containsNil(inferred)) }() } @@ -47,14 +44,13 @@ func (check *Checker) infer(pos syntax.Pos, tparams []*TypeParam, targs []Type, n := len(tparams) assert(n > 0 && len(targs) <= n) - // Function parameters and arguments must match in number. + // Parameters and arguments must match in number. assert(params.Len() == len(args)) // If we already have all type arguments, we're done. - if len(targs) == n { + if len(targs) == n && !containsNil(targs) { return targs } - // len(targs) < n // Make sure we have a "full" list of type arguments, some of which may // be nil (unknown). Make a copy so as to not clobber the incoming slice. @@ -440,6 +436,16 @@ func (check *Checker) infer(pos syntax.Pos, tparams []*TypeParam, targs []Type, return } +// containsNil reports whether list contains a nil entry. +func containsNil(list []Type) bool { + for _, t := range list { + if t == nil { + return true + } + } + return false +} + // renameTParams renames the type parameters in the given type such that each type // parameter is given a new identity. renameTParams returns the new type parameters // and updated type. If the result type is unchanged from the argument type, none diff --git a/src/go/types/infer.go b/src/go/types/infer.go index 661ff771c838e..9c31d6adf62c8 100644 --- a/src/go/types/infer.go +++ b/src/go/types/infer.go @@ -31,10 +31,7 @@ const enableReverseTypeInference = true // disable for debugging func (check *Checker) infer(posn positioner, tparams []*TypeParam, targs []Type, params *Tuple, args []*operand) (inferred []Type) { if debug { defer func() { - assert(inferred == nil || len(inferred) == len(tparams)) - for _, targ := range inferred { - assert(targ != nil) - } + assert(inferred == nil || len(inferred) == len(tparams) && !containsNil(inferred)) }() } @@ -49,14 +46,13 @@ func (check *Checker) infer(posn positioner, tparams []*TypeParam, targs []Type, n := len(tparams) assert(n > 0 && len(targs) <= n) - // Function parameters and arguments must match in number. + // Parameters and arguments must match in number. assert(params.Len() == len(args)) // If we already have all type arguments, we're done. - if len(targs) == n { + if len(targs) == n && !containsNil(targs) { return targs } - // len(targs) < n // Make sure we have a "full" list of type arguments, some of which may // be nil (unknown). Make a copy so as to not clobber the incoming slice. @@ -442,6 +438,16 @@ func (check *Checker) infer(posn positioner, tparams []*TypeParam, targs []Type, return } +// containsNil reports whether list contains a nil entry. +func containsNil(list []Type) bool { + for _, t := range list { + if t == nil { + return true + } + } + return false +} + // renameTParams renames the type parameters in the given type such that each type // parameter is given a new identity. renameTParams returns the new type parameters // and updated type. If the result type is unchanged from the argument type, none