From b3064b66d0699618cae07e97068f653410b71abc Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Tue, 6 Apr 2021 22:46:57 -0700 Subject: [PATCH] cmd/compile/internal/types2: combine two loops (cleanup of TODO) Follow-up on https://golang.org/cl/306170. Change-Id: I71b451382b6780101a0c94174ebe579e8a0684c2 Reviewed-on: https://go-review.googlesource.com/c/go/+/307949 Trust: Robert Griesemer Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/infer.go | 32 ++++++++---------------- 1 file changed, 11 insertions(+), 21 deletions(-) diff --git a/src/cmd/compile/internal/types2/infer.go b/src/cmd/compile/internal/types2/infer.go index 995ebd7ea0c..13a9ccda0c0 100644 --- a/src/cmd/compile/internal/types2/infer.go +++ b/src/cmd/compile/internal/types2/infer.go @@ -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. // Some generic parameters with untyped arguments may have been given // a type by now, we can ignore them. - j := 0 for _, i := range indices { par := params.At(i) // Since untyped types are all basic (i.e., non-composite) types, an // untyped argument will never match a composite parameter type; the // only parameter type it can possibly match against is a *TypeParam. - // Thus, only keep the indices of generic parameters that are not of - // composite types and which don't have a type inferred yet. + // Thus, only consider untyped arguments for generic parameters that + // 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 { - indices[j] = i - j++ - } - } - indices = indices[:j] - - // Unify parameter and default argument types for remaining generic parameters. - // TODO(gri) Rather than iterating again, combine this code with the loop above. - 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 + 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 + } } }