qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-26 11:58:07 -07:00
Code Releases Activity

cmd/compile/internal/types2: combine two loops (cleanup of TODO)

Browse Source 
Follow-up on https://golang.org/cl/306170.

Change-Id: I71b451382b6780101a0c94174ebe579e8a0684c2
Reviewed-on: https://go-review.googlesource.com/c/go/+/307949
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
This commit is contained in:
Robert Griesemer 2021-04-06 22:46:57 -07:00
parent 4520da486b
commit b3064b66d0
1 changed files with 11 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
src/cmd/compile/internal/types2/infer.go
View File

@ -184,33 +184,23 @@ func (check *Checker) infer(pos syntax.Pos, tparams []*TypeName, targs []Type, p
// Use any untyped arguments to infer additional type arguments. // Use any untyped arguments to infer additional type arguments.
// Some generic parameters with untyped arguments may have been given // Some generic parameters with untyped arguments may have been given
// a type by now, we can ignore them. // a type by now, we can ignore them.
j := 0
for _, i := range indices { for _, i := range indices {
par := params.At(i) par := params.At(i)
// Since untyped types are all basic (i.e., non-composite) types, an // Since untyped types are all basic (i.e., non-composite) types, an
// untyped argument will never match a composite parameter type; the // untyped argument will never match a composite parameter type; the
// only parameter type it can possibly match against is a *TypeParam. // only parameter type it can possibly match against is a *TypeParam.
// Thus, only keep the indices of generic parameters that are not of // Thus, only consider untyped arguments for generic parameters that
// composite types and which don't have a type inferred yet. // are not of composite types and which don't have a type inferred yet.
if tpar, _ := par.typ.(*TypeParam); tpar != nil && targs[tpar.index] == nil { if tpar, _ := par.typ.(*TypeParam); tpar != nil && targs[tpar.index] == nil {
indices[j] = i arg := args[i]
j++ targ := Default(arg.typ)
} // The default type for an untyped nil is untyped nil. We must not
} // infer an untyped nil type as type parameter type. Ignore untyped
indices = indices[:j] // nil by making sure all default argument types are typed.
if isTyped(targ) && !u.unify(par.typ, targ) {
// Unify parameter and default argument types for remaining generic parameters. errorf("default type", par.typ, targ, arg)
// TODO(gri) Rather than iterating again, combine this code with the loop above. return nil
for _, i := range indices { }
par := params.At(i)
arg := args[i]
targ := Default(arg.typ)
// The default type for an untyped nil is untyped nil. We must not
// infer an untyped nil type as type parameter type. Ignore untyped
// nil by making sure all default argument types are typed.
if isTyped(targ) && !u.unify(par.typ, targ) {
errorf("default type", par.typ, targ, arg)
return nil
} }
} }