From d81ae7cfc746f9f1fe1d67a5d9f4e15dcddb306a Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 23 Feb 2023 18:04:54 -0800 Subject: [PATCH] go/types, types2: remove code for infer1 Fixes #58283. Change-Id: I4a82083cddfed1b1be7776464f926a4c69a35e10 Reviewed-on: https://go-review.googlesource.com/c/go/+/470995 Reviewed-by: Robert Griesemer TryBot-Result: Gopher Robot Auto-Submit: Robert Griesemer Reviewed-by: Robert Findley Run-TryBot: Robert Griesemer --- src/cmd/compile/internal/types2/infer.go | 398 ---------------------- src/cmd/compile/internal/types2/infer2.go | 30 +- src/go/types/infer.go | 398 ---------------------- src/go/types/infer2.go | 30 +- 4 files changed, 4 insertions(+), 852 deletions(-) diff --git a/src/cmd/compile/internal/types2/infer.go b/src/cmd/compile/internal/types2/infer.go index 3305d7b733..8d4ecf6856 100644 --- a/src/cmd/compile/internal/types2/infer.go +++ b/src/cmd/compile/internal/types2/infer.go @@ -9,210 +9,9 @@ package types2 import ( "cmd/compile/internal/syntax" "fmt" - . "internal/types/errors" "strings" ) -// infer1 is an implementation of infer. -// Inference proceeds as follows. Starting with given type arguments: -// -// 1. apply FTI (function type inference) with typed arguments, -// 2. apply CTI (constraint type inference), -// 3. apply FTI with untyped function arguments, -// 4. apply CTI. -// -// The process stops as soon as all type arguments are known or an error occurs. -func (check *Checker) infer1(pos syntax.Pos, tparams []*TypeParam, targs []Type, params *Tuple, args []*operand, silent bool) (result []Type) { - if debug { - defer func() { - assert(result == nil || len(result) == len(tparams)) - for _, targ := range result { - assert(targ != nil) - } - //check.dump("### inferred targs = %s", result) - }() - } - - if traceInference { - check.dump("-- inferA %s%s ➞ %s", tparams, params, targs) - defer func() { - check.dump("=> inferA %s ➞ %s", tparams, result) - }() - } - - // There must be at least one type parameter, and no more type arguments than type parameters. - n := len(tparams) - assert(n > 0 && len(targs) <= n) - - // Function 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 { - return targs - } - // len(targs) < n - - // Rename type parameters to avoid conflicts in recursive instantiation scenarios. - tparams, params = check.renameTParams(pos, tparams, params) - - // --- 1 --- - // Continue with the type arguments we have. Avoid matching generic - // parameters that already have type arguments against function arguments: - // It may fail because matching uses type identity while parameter passing - // uses assignment rules. Instantiate the parameter list with the type - // arguments we have, and continue with that parameter list. - - // First, 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. - if len(targs) < n { - targs2 := make([]Type, n) - copy(targs2, targs) - targs = targs2 - } - // len(targs) == n - - // Substitute type arguments for their respective type parameters in params, - // if any. Note that nil targs entries are ignored by check.subst. - // TODO(gri) Can we avoid this (we're setting known type arguments below, - // but that doesn't impact the isParameterized check for now). - if params.Len() > 0 { - smap := makeSubstMap(tparams, targs) - params = check.subst(nopos, params, smap, nil, check.context()).(*Tuple) - } - - // 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) - - errorf := func(kind string, tpar, targ Type, arg *operand) { - if silent { - return - } - // provide a better error message if we can - targs := u.inferred(tparams) - if targs[0] == nil { - // The first type parameter couldn't be inferred. - // If none of them could be inferred, don't try - // to provide the inferred type in the error msg. - allFailed := true - for _, targ := range targs { - if targ != nil { - allFailed = false - break - } - } - if allFailed { - check.errorf(arg, CannotInferTypeArgs, "%s %s of %s does not match %s (cannot infer %s)", kind, targ, arg.expr, tpar, typeParamsString(tparams)) - return - } - } - smap := makeSubstMap(tparams, targs) - // TODO(gri): pass a poser here, rather than arg.Pos(). - inferred := check.subst(arg.Pos(), tpar, smap, nil, check.context()) - // CannotInferTypeArgs indicates a failure of inference, though the actual - // error may be better attributed to a user-provided type argument (hence - // InvalidTypeArg). We can't differentiate these cases, so fall back on - // the more general CannotInferTypeArgs. - if inferred != tpar { - check.errorf(arg, CannotInferTypeArgs, "%s %s of %s does not match inferred type %s for %s", kind, targ, arg.expr, inferred, tpar) - } else { - check.errorf(arg, CannotInferTypeArgs, "%s %s of %s does not match %s", kind, targ, arg.expr, tpar) - } - } - - // indices of the generic parameters with untyped arguments - save for later - var indices []int - for i, arg := range args { - par := params.At(i) - // If we permit bidirectional unification, this conditional code needs to be - // executed even if par.typ is not parameterized since the argument may be a - // generic function (for which we want to infer its type arguments). - if isParameterized(tparams, par.typ) { - if arg.mode == invalid { - // An error was reported earlier. Ignore this targ - // and continue, we may still be able to infer all - // targs resulting in fewer follow-on errors. - continue - } - if targ := arg.typ; isTyped(targ) { - // If we permit bidirectional unification, and targ is - // a generic function, we need to initialize u.y with - // the respective type parameters of targ. - if !u.unify(par.typ, targ) { - errorf("type", par.typ, targ, arg) - return nil - } - } else if _, ok := par.typ.(*TypeParam); ok { - // Since default 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, for untyped arguments we only need to look at parameter types - // that are single type parameters. - indices = append(indices, i) - } - } - } - - // If we've got all type arguments, we're done. - targs = u.inferred(tparams) - if u.unknowns() == 0 { - return targs - } - - // --- 2 --- - // See how far we get with constraint type inference. - // Note that even if we don't have any type arguments, constraint type inference - // may produce results for constraints that explicitly specify a type. - targs, index := check.inferB(tparams, targs) - if targs == nil || index < 0 { - return targs - } - - // --- 3 --- - // 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. - for _, i := range indices { - tpar := params.At(i).typ.(*TypeParam) // is type parameter by construction of indices - // Only consider untyped arguments for which the corresponding type - // parameter doesn't have an inferred type yet. - if targs[tpar.index] == 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(tpar, targ) { - errorf("default type", tpar, targ, arg) - return nil - } - } - } - - // If we've got all type arguments, we're done. - targs = u.inferred(tparams) - if u.unknowns() == 0 { - return targs - } - - // --- 4 --- - // Again, follow up with constraint type inference. - targs, index = check.inferB(tparams, targs) - if targs == nil || index < 0 { - return targs - } - - // At least one type argument couldn't be inferred. - assert(targs != nil && index >= 0 && targs[index] == nil) - tpar := tparams[index] - if !silent { - check.errorf(pos, CannotInferTypeArgs, "cannot infer %s (%s)", tpar.obj.name, tpar.obj.pos) - } - return nil -} - // renameTParams renames the type parameters in a function signature described by its // type and ordinary parameters (tparams and params) such that each type parameter is // given a new identity. renameTParams returns the new type and ordinary parameters. @@ -388,203 +187,6 @@ func (w *tpWalker) isParameterizedTypeList(list []Type) bool { return false } -// inferB returns the list of actual type arguments inferred from the type parameters' -// bounds and an initial set of type arguments. If type inference is impossible because -// unification fails, an error is reported if report is set to true, the resulting types -// list is nil, and index is 0. -// Otherwise, types is the list of inferred type arguments, and index is the index of the -// first type argument in that list that couldn't be inferred (and thus is nil). If all -// type arguments were inferred successfully, index is < 0. The number of type arguments -// provided may be less than the number of type parameters, but there must be at least one. -func (check *Checker) inferB(tparams []*TypeParam, targs []Type) (types []Type, index int) { - assert(len(tparams) >= len(targs) && len(targs) > 0) - - if traceInference { - check.dump("-- inferB %s ➞ %s", tparams, targs) - defer func() { - check.dump("=> inferB %s ➞ %s", tparams, types) - }() - } - - // Unify type parameters with their constraints. - u := newUnifier(tparams, targs) - - // Repeatedly apply constraint type inference as long as - // there are still unknown type arguments and progress is - // being made. - // - // This is an O(n^2) algorithm where n is the number of - // type parameters: if there is progress (and iteration - // continues), at least one type argument is inferred - // per iteration and we have a doubly nested loop. - // In practice this is not a problem because the number - // of type parameters tends to be very small (< 5 or so). - // (It should be possible for unification to efficiently - // signal newly inferred type arguments; then the loops - // here could handle the respective type parameters only, - // but that will come at a cost of extra complexity which - // may not be worth it.) - for n := u.unknowns(); n > 0; { - nn := n - - for _, tpar := range tparams { - // If there is a core term (i.e., a core type with tilde information) - // unify the type parameter with the core type. - if core, single := coreTerm(tpar); core != nil { - if traceInference { - u.tracef("core(%s) = %s (single = %v)", tpar, core, single) - } - // A type parameter can be unified with its core type in two cases. - tx := u.at(tpar) - switch { - case tx != nil: - // The corresponding type argument tx is known. - // In this case, if the core type has a tilde, the type argument's underlying - // type must match the core type, otherwise the type argument and the core type - // must match. - // If tx is an external type parameter, don't consider its underlying type - // (which is an interface). Core type unification will attempt to unify against - // core.typ. - // Note also that even with inexact unification we cannot leave away the under - // call here because it's possible that both tx and core.typ are named types, - // with under(tx) being a (named) basic type matching core.typ. Such cases do - // not match with inexact unification. - if core.tilde && !isTypeParam(tx) { - tx = under(tx) - } - // Unification may fail because it operates with limited information (core type), - // even if a given type argument satisfies the corresponding type constraint. - // For instance, given [P T1|T2, ...] where the type argument for P is (named - // type) T1, and T1 and T2 have the same built-in (named) type T0 as underlying - // type, the core type will be the named type T0, which doesn't match T1. - // Yet the instantiation of P with T1 is clearly valid (see go.dev/issue/53650). - // Reporting an error if unification fails would be incorrect in this case. - // On the other hand, it is safe to ignore failing unification during constraint - // type inference because if the failure is true, an error will be reported when - // checking instantiation. - u.unify(tx, core.typ) - - case single && !core.tilde: - // The corresponding type argument tx is unknown and there's a single - // specific type and no tilde. - // In this case the type argument must be that single type; set it. - u.set(tpar, core.typ) - - default: - // Unification is not possible and no progress was made. - continue - } - - // The number of known type arguments may have changed. - nn = u.unknowns() - if nn == 0 { - break // all type arguments are known - } - } else { - if traceInference { - u.tracef("core(%s) = nil", tpar) - } - } - } - - assert(nn <= n) - if nn == n { - break // no progress - } - n = nn - } - - // u.inferred(tparams) now contains the incoming type arguments plus any additional type - // arguments which were inferred from core terms. The newly inferred non-nil - // entries may still contain references to other type parameters. - // For instance, for [A any, B interface{ []C }, C interface{ *A }], if A == int - // was given, unification produced the type list [int, []C, *A]. We eliminate the - // remaining type parameters by substituting the type parameters in this type list - // until nothing changes anymore. - types = u.inferred(tparams) - if debug { - for i, targ := range targs { - assert(targ == nil || types[i] == targ) - } - } - - // The data structure of each (provided or inferred) type represents a graph, where - // each node corresponds to a type and each (directed) vertex points to a component - // type. The substitution process described above repeatedly replaces type parameter - // nodes in these graphs with the graphs of the types the type parameters stand for, - // which creates a new (possibly bigger) graph for each type. - // The substitution process will not stop if the replacement graph for a type parameter - // also contains that type parameter. - // For instance, for [A interface{ *A }], without any type argument provided for A, - // unification produces the type list [*A]. Substituting A in *A with the value for - // A will lead to infinite expansion by producing [**A], [****A], [********A], etc., - // because the graph A -> *A has a cycle through A. - // Generally, cycles may occur across multiple type parameters and inferred types - // (for instance, consider [P interface{ *Q }, Q interface{ func(P) }]). - // We eliminate cycles by walking the graphs for all type parameters. If a cycle - // through a type parameter is detected, cycleFinder nils out the respective type - // which kills the cycle; this also means that the respective type could not be - // inferred. - // - // TODO(gri) If useful, we could report the respective cycle as an error. We don't - // do this now because type inference will fail anyway, and furthermore, - // constraints with cycles of this kind cannot currently be satisfied by - // any user-supplied type. But should that change, reporting an error - // would be wrong. - w := cycleFinder{tparams, types, make(map[Type]bool)} - for _, t := range tparams { - w.typ(t) // t != nil - } - - // dirty tracks the indices of all types that may still contain type parameters. - // We know that nil type entries and entries corresponding to provided (non-nil) - // type arguments are clean, so exclude them from the start. - var dirty []int - for i, typ := range types { - if typ != nil && (i >= len(targs) || targs[i] == nil) { - dirty = append(dirty, i) - } - } - - for len(dirty) > 0 { - // TODO(gri) Instead of creating a new substMap for each iteration, - // provide an update operation for substMaps and only change when - // needed. Optimization. - smap := makeSubstMap(tparams, types) - n := 0 - for _, index := range dirty { - t0 := types[index] - if t1 := check.subst(nopos, t0, smap, nil, check.context()); t1 != t0 { - types[index] = t1 - dirty[n] = index - n++ - } - } - dirty = dirty[:n] - } - - // Once nothing changes anymore, we may still have type parameters left; - // e.g., a constraint with core type *P may match a type parameter Q but - // we don't have any type arguments to fill in for *P or Q (go.dev/issue/45548). - // Don't let such inferences escape, instead nil them out. - for i, typ := range types { - if typ != nil && isParameterized(tparams, typ) { - types[i] = nil - } - } - - // update index - index = -1 - for i, typ := range types { - if typ == nil { - index = i - break - } - } - - return -} - // If the type parameter has a single specific type S, coreTerm returns (S, true). // Otherwise, if tpar has a core type T, it returns a term corresponding to that // core type and false. In that case, if any term of tpar has a tilde, the core diff --git a/src/cmd/compile/internal/types2/infer2.go b/src/cmd/compile/internal/types2/infer2.go index 8cc96278bf..e915017cab 100644 --- a/src/cmd/compile/internal/types2/infer2.go +++ b/src/cmd/compile/internal/types2/infer2.go @@ -11,39 +11,13 @@ import ( . "internal/types/errors" ) -// If compareWithInfer1, infer2 results must match infer1 results. -// Disable before releasing Go 1.21. -const compareWithInfer1 = false - // infer attempts to infer the complete set of type arguments for generic function instantiation/call // based on the given type parameters tparams, type arguments targs, function parameters params, and // function arguments args, if any. There must be at least one type parameter, no more type arguments // than type parameters, and params and args must match in number (incl. zero). // If successful, infer returns the complete list of given and inferred type arguments, one for each // type parameter. Otherwise the result is nil and appropriate errors will be reported. -func (check *Checker) infer(pos syntax.Pos, tparams []*TypeParam, targs []Type, params *Tuple, args []*operand) []Type { - r2 := check.infer2(pos, tparams, targs, params, args) - - if compareWithInfer1 { - r1 := check.infer1(pos, tparams, targs, params, args, r2 == nil) // be silent on errors if infer2 failed - assert(len(r2) == len(r1)) - for i, targ2 := range r2 { - targ1 := r1[i] - var c comparer - c.ignoreInvalids = true - if !c.identical(targ2, targ1, nil) { - tpar := tparams[i] - check.dump("%v: type argument for %s: infer1: %s, infer2: %s", tpar.Obj().Pos(), tpar, targ1, targ2) - panic("inconsistent type inference") - } - } - } - - return r2 -} - -// infer2 is an implementation of infer. -func (check *Checker) infer2(pos syntax.Pos, tparams []*TypeParam, targs []Type, params *Tuple, args []*operand) (inferred []Type) { +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)) @@ -54,7 +28,7 @@ func (check *Checker) infer2(pos syntax.Pos, tparams []*TypeParam, targs []Type, } if traceInference { - check.dump("-- infer2 %s%s ➞ %s", tparams, params, targs) + check.dump("-- infer %s%s ➞ %s", tparams, params, targs) defer func() { check.dump("=> %s ➞ %s\n", tparams, inferred) }() diff --git a/src/go/types/infer.go b/src/go/types/infer.go index f278638c0b..cf67d356a8 100644 --- a/src/go/types/infer.go +++ b/src/go/types/infer.go @@ -11,210 +11,9 @@ package types import ( "fmt" "go/token" - . "internal/types/errors" "strings" ) -// infer1 is an implementation of infer. -// Inference proceeds as follows. Starting with given type arguments: -// -// 1. apply FTI (function type inference) with typed arguments, -// 2. apply CTI (constraint type inference), -// 3. apply FTI with untyped function arguments, -// 4. apply CTI. -// -// The process stops as soon as all type arguments are known or an error occurs. -func (check *Checker) infer1(posn positioner, tparams []*TypeParam, targs []Type, params *Tuple, args []*operand, silent bool) (result []Type) { - if debug { - defer func() { - assert(result == nil || len(result) == len(tparams)) - for _, targ := range result { - assert(targ != nil) - } - //check.dump("### inferred targs = %s", result) - }() - } - - if traceInference { - check.dump("-- inferA %s%s ➞ %s", tparams, params, targs) - defer func() { - check.dump("=> inferA %s ➞ %s", tparams, result) - }() - } - - // There must be at least one type parameter, and no more type arguments than type parameters. - n := len(tparams) - assert(n > 0 && len(targs) <= n) - - // Function 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 { - return targs - } - // len(targs) < n - - // Rename type parameters to avoid conflicts in recursive instantiation scenarios. - tparams, params = check.renameTParams(posn.Pos(), tparams, params) - - // --- 1 --- - // Continue with the type arguments we have. Avoid matching generic - // parameters that already have type arguments against function arguments: - // It may fail because matching uses type identity while parameter passing - // uses assignment rules. Instantiate the parameter list with the type - // arguments we have, and continue with that parameter list. - - // First, 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. - if len(targs) < n { - targs2 := make([]Type, n) - copy(targs2, targs) - targs = targs2 - } - // len(targs) == n - - // Substitute type arguments for their respective type parameters in params, - // if any. Note that nil targs entries are ignored by check.subst. - // TODO(gri) Can we avoid this (we're setting known type arguments below, - // but that doesn't impact the isParameterized check for now). - if params.Len() > 0 { - smap := makeSubstMap(tparams, targs) - params = check.subst(nopos, params, smap, nil, check.context()).(*Tuple) - } - - // 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) - - errorf := func(kind string, tpar, targ Type, arg *operand) { - if silent { - return - } - // provide a better error message if we can - targs := u.inferred(tparams) - if targs[0] == nil { - // The first type parameter couldn't be inferred. - // If none of them could be inferred, don't try - // to provide the inferred type in the error msg. - allFailed := true - for _, targ := range targs { - if targ != nil { - allFailed = false - break - } - } - if allFailed { - check.errorf(arg, CannotInferTypeArgs, "%s %s of %s does not match %s (cannot infer %s)", kind, targ, arg.expr, tpar, typeParamsString(tparams)) - return - } - } - smap := makeSubstMap(tparams, targs) - // TODO(gri): pass a poser here, rather than arg.Pos(). - inferred := check.subst(arg.Pos(), tpar, smap, nil, check.context()) - // CannotInferTypeArgs indicates a failure of inference, though the actual - // error may be better attributed to a user-provided type argument (hence - // InvalidTypeArg). We can't differentiate these cases, so fall back on - // the more general CannotInferTypeArgs. - if inferred != tpar { - check.errorf(arg, CannotInferTypeArgs, "%s %s of %s does not match inferred type %s for %s", kind, targ, arg.expr, inferred, tpar) - } else { - check.errorf(arg, CannotInferTypeArgs, "%s %s of %s does not match %s", kind, targ, arg.expr, tpar) - } - } - - // indices of the generic parameters with untyped arguments - save for later - var indices []int - for i, arg := range args { - par := params.At(i) - // If we permit bidirectional unification, this conditional code needs to be - // executed even if par.typ is not parameterized since the argument may be a - // generic function (for which we want to infer its type arguments). - if isParameterized(tparams, par.typ) { - if arg.mode == invalid { - // An error was reported earlier. Ignore this targ - // and continue, we may still be able to infer all - // targs resulting in fewer follow-on errors. - continue - } - if targ := arg.typ; isTyped(targ) { - // If we permit bidirectional unification, and targ is - // a generic function, we need to initialize u.y with - // the respective type parameters of targ. - if !u.unify(par.typ, targ) { - errorf("type", par.typ, targ, arg) - return nil - } - } else if _, ok := par.typ.(*TypeParam); ok { - // Since default 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, for untyped arguments we only need to look at parameter types - // that are single type parameters. - indices = append(indices, i) - } - } - } - - // If we've got all type arguments, we're done. - targs = u.inferred(tparams) - if u.unknowns() == 0 { - return targs - } - - // --- 2 --- - // See how far we get with constraint type inference. - // Note that even if we don't have any type arguments, constraint type inference - // may produce results for constraints that explicitly specify a type. - targs, index := check.inferB(tparams, targs) - if targs == nil || index < 0 { - return targs - } - - // --- 3 --- - // 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. - for _, i := range indices { - tpar := params.At(i).typ.(*TypeParam) // is type parameter by construction of indices - // Only consider untyped arguments for which the corresponding type - // parameter doesn't have an inferred type yet. - if targs[tpar.index] == 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(tpar, targ) { - errorf("default type", tpar, targ, arg) - return nil - } - } - } - - // If we've got all type arguments, we're done. - targs = u.inferred(tparams) - if u.unknowns() == 0 { - return targs - } - - // --- 4 --- - // Again, follow up with constraint type inference. - targs, index = check.inferB(tparams, targs) - if targs == nil || index < 0 { - return targs - } - - // At least one type argument couldn't be inferred. - assert(targs != nil && index >= 0 && targs[index] == nil) - tpar := tparams[index] - if !silent { - check.errorf(posn, CannotInferTypeArgs, "cannot infer %s (%s)", tpar.obj.name, tpar.obj.pos) - } - return nil -} - // renameTParams renames the type parameters in a function signature described by its // type and ordinary parameters (tparams and params) such that each type parameter is // given a new identity. renameTParams returns the new type and ordinary parameters. @@ -390,203 +189,6 @@ func (w *tpWalker) isParameterizedTypeList(list []Type) bool { return false } -// inferB returns the list of actual type arguments inferred from the type parameters' -// bounds and an initial set of type arguments. If type inference is impossible because -// unification fails, an error is reported if report is set to true, the resulting types -// list is nil, and index is 0. -// Otherwise, types is the list of inferred type arguments, and index is the index of the -// first type argument in that list that couldn't be inferred (and thus is nil). If all -// type arguments were inferred successfully, index is < 0. The number of type arguments -// provided may be less than the number of type parameters, but there must be at least one. -func (check *Checker) inferB(tparams []*TypeParam, targs []Type) (types []Type, index int) { - assert(len(tparams) >= len(targs) && len(targs) > 0) - - if traceInference { - check.dump("-- inferB %s ➞ %s", tparams, targs) - defer func() { - check.dump("=> inferB %s ➞ %s", tparams, types) - }() - } - - // Unify type parameters with their constraints. - u := newUnifier(tparams, targs) - - // Repeatedly apply constraint type inference as long as - // there are still unknown type arguments and progress is - // being made. - // - // This is an O(n^2) algorithm where n is the number of - // type parameters: if there is progress (and iteration - // continues), at least one type argument is inferred - // per iteration and we have a doubly nested loop. - // In practice this is not a problem because the number - // of type parameters tends to be very small (< 5 or so). - // (It should be possible for unification to efficiently - // signal newly inferred type arguments; then the loops - // here could handle the respective type parameters only, - // but that will come at a cost of extra complexity which - // may not be worth it.) - for n := u.unknowns(); n > 0; { - nn := n - - for _, tpar := range tparams { - // If there is a core term (i.e., a core type with tilde information) - // unify the type parameter with the core type. - if core, single := coreTerm(tpar); core != nil { - if traceInference { - u.tracef("core(%s) = %s (single = %v)", tpar, core, single) - } - // A type parameter can be unified with its core type in two cases. - tx := u.at(tpar) - switch { - case tx != nil: - // The corresponding type argument tx is known. - // In this case, if the core type has a tilde, the type argument's underlying - // type must match the core type, otherwise the type argument and the core type - // must match. - // If tx is an external type parameter, don't consider its underlying type - // (which is an interface). Core type unification will attempt to unify against - // core.typ. - // Note also that even with inexact unification we cannot leave away the under - // call here because it's possible that both tx and core.typ are named types, - // with under(tx) being a (named) basic type matching core.typ. Such cases do - // not match with inexact unification. - if core.tilde && !isTypeParam(tx) { - tx = under(tx) - } - // Unification may fail because it operates with limited information (core type), - // even if a given type argument satisfies the corresponding type constraint. - // For instance, given [P T1|T2, ...] where the type argument for P is (named - // type) T1, and T1 and T2 have the same built-in (named) type T0 as underlying - // type, the core type will be the named type T0, which doesn't match T1. - // Yet the instantiation of P with T1 is clearly valid (see go.dev/issue/53650). - // Reporting an error if unification fails would be incorrect in this case. - // On the other hand, it is safe to ignore failing unification during constraint - // type inference because if the failure is true, an error will be reported when - // checking instantiation. - u.unify(tx, core.typ) - - case single && !core.tilde: - // The corresponding type argument tx is unknown and there's a single - // specific type and no tilde. - // In this case the type argument must be that single type; set it. - u.set(tpar, core.typ) - - default: - // Unification is not possible and no progress was made. - continue - } - - // The number of known type arguments may have changed. - nn = u.unknowns() - if nn == 0 { - break // all type arguments are known - } - } else { - if traceInference { - u.tracef("core(%s) = nil", tpar) - } - } - } - - assert(nn <= n) - if nn == n { - break // no progress - } - n = nn - } - - // u.inferred(tparams) now contains the incoming type arguments plus any additional type - // arguments which were inferred from core terms. The newly inferred non-nil - // entries may still contain references to other type parameters. - // For instance, for [A any, B interface{ []C }, C interface{ *A }], if A == int - // was given, unification produced the type list [int, []C, *A]. We eliminate the - // remaining type parameters by substituting the type parameters in this type list - // until nothing changes anymore. - types = u.inferred(tparams) - if debug { - for i, targ := range targs { - assert(targ == nil || types[i] == targ) - } - } - - // The data structure of each (provided or inferred) type represents a graph, where - // each node corresponds to a type and each (directed) vertex points to a component - // type. The substitution process described above repeatedly replaces type parameter - // nodes in these graphs with the graphs of the types the type parameters stand for, - // which creates a new (possibly bigger) graph for each type. - // The substitution process will not stop if the replacement graph for a type parameter - // also contains that type parameter. - // For instance, for [A interface{ *A }], without any type argument provided for A, - // unification produces the type list [*A]. Substituting A in *A with the value for - // A will lead to infinite expansion by producing [**A], [****A], [********A], etc., - // because the graph A -> *A has a cycle through A. - // Generally, cycles may occur across multiple type parameters and inferred types - // (for instance, consider [P interface{ *Q }, Q interface{ func(P) }]). - // We eliminate cycles by walking the graphs for all type parameters. If a cycle - // through a type parameter is detected, cycleFinder nils out the respective type - // which kills the cycle; this also means that the respective type could not be - // inferred. - // - // TODO(gri) If useful, we could report the respective cycle as an error. We don't - // do this now because type inference will fail anyway, and furthermore, - // constraints with cycles of this kind cannot currently be satisfied by - // any user-supplied type. But should that change, reporting an error - // would be wrong. - w := cycleFinder{tparams, types, make(map[Type]bool)} - for _, t := range tparams { - w.typ(t) // t != nil - } - - // dirty tracks the indices of all types that may still contain type parameters. - // We know that nil type entries and entries corresponding to provided (non-nil) - // type arguments are clean, so exclude them from the start. - var dirty []int - for i, typ := range types { - if typ != nil && (i >= len(targs) || targs[i] == nil) { - dirty = append(dirty, i) - } - } - - for len(dirty) > 0 { - // TODO(gri) Instead of creating a new substMap for each iteration, - // provide an update operation for substMaps and only change when - // needed. Optimization. - smap := makeSubstMap(tparams, types) - n := 0 - for _, index := range dirty { - t0 := types[index] - if t1 := check.subst(nopos, t0, smap, nil, check.context()); t1 != t0 { - types[index] = t1 - dirty[n] = index - n++ - } - } - dirty = dirty[:n] - } - - // Once nothing changes anymore, we may still have type parameters left; - // e.g., a constraint with core type *P may match a type parameter Q but - // we don't have any type arguments to fill in for *P or Q (go.dev/issue/45548). - // Don't let such inferences escape, instead nil them out. - for i, typ := range types { - if typ != nil && isParameterized(tparams, typ) { - types[i] = nil - } - } - - // update index - index = -1 - for i, typ := range types { - if typ == nil { - index = i - break - } - } - - return -} - // If the type parameter has a single specific type S, coreTerm returns (S, true). // Otherwise, if tpar has a core type T, it returns a term corresponding to that // core type and false. In that case, if any term of tpar has a tilde, the core diff --git a/src/go/types/infer2.go b/src/go/types/infer2.go index b41cd5ae08..dfba8cf999 100644 --- a/src/go/types/infer2.go +++ b/src/go/types/infer2.go @@ -13,39 +13,13 @@ import ( . "internal/types/errors" ) -// If compareWithInfer1, infer2 results must match infer1 results. -// Disable before releasing Go 1.21. -const compareWithInfer1 = false - // infer attempts to infer the complete set of type arguments for generic function instantiation/call // based on the given type parameters tparams, type arguments targs, function parameters params, and // function arguments args, if any. There must be at least one type parameter, no more type arguments // than type parameters, and params and args must match in number (incl. zero). // If successful, infer returns the complete list of given and inferred type arguments, one for each // type parameter. Otherwise the result is nil and appropriate errors will be reported. -func (check *Checker) infer(posn positioner, tparams []*TypeParam, targs []Type, params *Tuple, args []*operand) []Type { - r2 := check.infer2(posn, tparams, targs, params, args) - - if compareWithInfer1 { - r1 := check.infer1(posn, tparams, targs, params, args, r2 == nil) // be silent on errors if infer2 failed - assert(len(r2) == len(r1)) - for i, targ2 := range r2 { - targ1 := r1[i] - var c comparer - c.ignoreInvalids = true - if !c.identical(targ2, targ1, nil) { - tpar := tparams[i] - check.dump("%v: type argument for %s: infer1: %s, infer2: %s", tpar.Obj().Pos(), tpar, targ1, targ2) - panic("inconsistent type inference") - } - } - } - - return r2 -} - -// infer2 is an implementation of infer. -func (check *Checker) infer2(posn positioner, tparams []*TypeParam, targs []Type, params *Tuple, args []*operand) (inferred []Type) { +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)) @@ -56,7 +30,7 @@ func (check *Checker) infer2(posn positioner, tparams []*TypeParam, targs []Type } if traceInference { - check.dump("-- infer2 %s%s ➞ %s", tparams, params, targs) + check.dump("-- infer %s%s ➞ %s", tparams, params, targs) defer func() { check.dump("=> %s ➞ %s\n", tparams, inferred) }() -- 2.51.0