infer.go

Documentation: go/types

		 1  // Copyright 2018 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  // This file implements type parameter inference given
		 6  // a list of concrete arguments and a parameter list.
		 7  
		 8  package types
		 9  
		10  import (
		11  	"go/token"
		12  	"strings"
		13  )
		14  
		15  // infer attempts to infer the complete set of type arguments for generic function instantiation/call
		16  // based on the given type parameters tparams, type arguments targs, function parameters params, and
		17  // function arguments args, if any. There must be at least one type parameter, no more type arguments
		18  // than type parameters, and params and args must match in number (incl. zero).
		19  // If successful, infer returns the complete list of type arguments, one for each type parameter.
		20  // Otherwise the result is nil and appropriate errors will be reported unless report is set to false.
		21  //
		22  // Inference proceeds in 3 steps:
		23  //
		24  //	 1) Start with given type arguments.
		25  //	 2) Infer type arguments from typed function arguments.
		26  //	 3) Infer type arguments from untyped function arguments.
		27  //
		28  // Constraint type inference is used after each step to expand the set of type arguments.
		29  //
		30  func (check *Checker) infer(posn positioner, tparams []*TypeName, targs []Type, params *Tuple, args []*operand, report bool) (result []Type) {
		31  	if debug {
		32  		defer func() {
		33  			assert(result == nil || len(result) == len(tparams))
		34  			for _, targ := range result {
		35  				assert(targ != nil)
		36  			}
		37  			//check.dump("### inferred targs = %s", result)
		38  		}()
		39  	}
		40  
		41  	// There must be at least one type parameter, and no more type arguments than type parameters.
		42  	n := len(tparams)
		43  	assert(n > 0 && len(targs) <= n)
		44  
		45  	// Function parameters and arguments must match in number.
		46  	assert(params.Len() == len(args))
		47  
		48  	// --- 0 ---
		49  	// If we already have all type arguments, we're done.
		50  	if len(targs) == n {
		51  		return targs
		52  	}
		53  	// len(targs) < n
		54  
		55  	// --- 1 ---
		56  	// Explicitly provided type arguments take precedence over any inferred types;
		57  	// and types inferred via constraint type inference take precedence over types
		58  	// inferred from function arguments.
		59  	// If we have type arguments, see how far we get with constraint type inference.
		60  	if len(targs) > 0 {
		61  		var index int
		62  		targs, index = check.inferB(tparams, targs, report)
		63  		if targs == nil || index < 0 {
		64  			return targs
		65  		}
		66  	}
		67  
		68  	// Continue with the type arguments we have now. Avoid matching generic
		69  	// parameters that already have type arguments against function arguments:
		70  	// It may fail because matching uses type identity while parameter passing
		71  	// uses assignment rules. Instantiate the parameter list with the type
		72  	// arguments we have, and continue with that parameter list.
		73  
		74  	// First, make sure we have a "full" list of type arguments, so of which
		75  	// may be nil (unknown).
		76  	if len(targs) < n {
		77  		targs2 := make([]Type, n)
		78  		copy(targs2, targs)
		79  		targs = targs2
		80  	}
		81  	// len(targs) == n
		82  
		83  	// Substitute type arguments for their respective type parameters in params,
		84  	// if any. Note that nil targs entries are ignored by check.subst.
		85  	// TODO(gri) Can we avoid this (we're setting known type argumemts below,
		86  	//					 but that doesn't impact the isParameterized check for now).
		87  	if params.Len() > 0 {
		88  		smap := makeSubstMap(tparams, targs)
		89  		params = check.subst(token.NoPos, params, smap).(*Tuple)
		90  	}
		91  
		92  	// --- 2 ---
		93  	// Unify parameter and argument types for generic parameters with typed arguments
		94  	// and collect the indices of generic parameters with untyped arguments.
		95  	// Terminology: generic parameter = function parameter with a type-parameterized type
		96  	u := newUnifier(check, false)
		97  	u.x.init(tparams)
		98  
		99  	// Set the type arguments which we know already.
	 100  	for i, targ := range targs {
	 101  		if targ != nil {
	 102  			u.x.set(i, targ)
	 103  		}
	 104  	}
	 105  
	 106  	errorf := func(kind string, tpar, targ Type, arg *operand) {
	 107  		if !report {
	 108  			return
	 109  		}
	 110  		// provide a better error message if we can
	 111  		targs, index := u.x.types()
	 112  		if index == 0 {
	 113  			// The first type parameter couldn't be inferred.
	 114  			// If none of them could be inferred, don't try
	 115  			// to provide the inferred type in the error msg.
	 116  			allFailed := true
	 117  			for _, targ := range targs {
	 118  				if targ != nil {
	 119  					allFailed = false
	 120  					break
	 121  				}
	 122  			}
	 123  			if allFailed {
	 124  				check.errorf(arg, _Todo, "%s %s of %s does not match %s (cannot infer %s)", kind, targ, arg.expr, tpar, typeNamesString(tparams))
	 125  				return
	 126  			}
	 127  		}
	 128  		smap := makeSubstMap(tparams, targs)
	 129  		// TODO(rFindley): pass a positioner here, rather than arg.Pos().
	 130  		inferred := check.subst(arg.Pos(), tpar, smap)
	 131  		if inferred != tpar {
	 132  			check.errorf(arg, _Todo, "%s %s of %s does not match inferred type %s for %s", kind, targ, arg.expr, inferred, tpar)
	 133  		} else {
	 134  			check.errorf(arg, 0, "%s %s of %s does not match %s", kind, targ, arg.expr, tpar)
	 135  		}
	 136  	}
	 137  
	 138  	// indices of the generic parameters with untyped arguments - save for later
	 139  	var indices []int
	 140  	for i, arg := range args {
	 141  		par := params.At(i)
	 142  		// If we permit bidirectional unification, this conditional code needs to be
	 143  		// executed even if par.typ is not parameterized since the argument may be a
	 144  		// generic function (for which we want to infer its type arguments).
	 145  		if isParameterized(tparams, par.typ) {
	 146  			if arg.mode == invalid {
	 147  				// An error was reported earlier. Ignore this targ
	 148  				// and continue, we may still be able to infer all
	 149  				// targs resulting in fewer follon-on errors.
	 150  				continue
	 151  			}
	 152  			if targ := arg.typ; isTyped(targ) {
	 153  				// If we permit bidirectional unification, and targ is
	 154  				// a generic function, we need to initialize u.y with
	 155  				// the respective type parameters of targ.
	 156  				if !u.unify(par.typ, targ) {
	 157  					errorf("type", par.typ, targ, arg)
	 158  					return nil
	 159  				}
	 160  			} else {
	 161  				indices = append(indices, i)
	 162  			}
	 163  		}
	 164  	}
	 165  
	 166  	// If we've got all type arguments, we're done.
	 167  	var index int
	 168  	targs, index = u.x.types()
	 169  	if index < 0 {
	 170  		return targs
	 171  	}
	 172  
	 173  	// See how far we get with constraint type inference.
	 174  	// Note that even if we don't have any type arguments, constraint type inference
	 175  	// may produce results for constraints that explicitly specify a type.
	 176  	targs, index = check.inferB(tparams, targs, report)
	 177  	if targs == nil || index < 0 {
	 178  		return targs
	 179  	}
	 180  
	 181  	// --- 3 ---
	 182  	// Use any untyped arguments to infer additional type arguments.
	 183  	// Some generic parameters with untyped arguments may have been given
	 184  	// a type by now, we can ignore them.
	 185  	for _, i := range indices {
	 186  		par := params.At(i)
	 187  		// Since untyped types are all basic (i.e., non-composite) types, an
	 188  		// untyped argument will never match a composite parameter type; the
	 189  		// only parameter type it can possibly match against is a *TypeParam.
	 190  		// Thus, only consider untyped arguments for generic parameters that
	 191  		// are not of composite types and which don't have a type inferred yet.
	 192  		if tpar, _ := par.typ.(*_TypeParam); tpar != nil && targs[tpar.index] == nil {
	 193  			arg := args[i]
	 194  			targ := Default(arg.typ)
	 195  			// The default type for an untyped nil is untyped nil. We must not
	 196  			// infer an untyped nil type as type parameter type. Ignore untyped
	 197  			// nil by making sure all default argument types are typed.
	 198  			if isTyped(targ) && !u.unify(par.typ, targ) {
	 199  				errorf("default type", par.typ, targ, arg)
	 200  				return nil
	 201  			}
	 202  		}
	 203  	}
	 204  
	 205  	// If we've got all type arguments, we're done.
	 206  	targs, index = u.x.types()
	 207  	if index < 0 {
	 208  		return targs
	 209  	}
	 210  
	 211  	// Again, follow up with constraint type inference.
	 212  	targs, index = check.inferB(tparams, targs, report)
	 213  	if targs == nil || index < 0 {
	 214  		return targs
	 215  	}
	 216  
	 217  	// At least one type argument couldn't be inferred.
	 218  	assert(index >= 0 && targs[index] == nil)
	 219  	tpar := tparams[index]
	 220  	if report {
	 221  		check.errorf(posn, _Todo, "cannot infer %s (%v) (%v)", tpar.name, tpar.pos, targs)
	 222  	}
	 223  	return nil
	 224  }
	 225  
	 226  // typeNamesString produces a string containing all the
	 227  // type names in list suitable for human consumption.
	 228  func typeNamesString(list []*TypeName) string {
	 229  	// common cases
	 230  	n := len(list)
	 231  	switch n {
	 232  	case 0:
	 233  		return ""
	 234  	case 1:
	 235  		return list[0].name
	 236  	case 2:
	 237  		return list[0].name + " and " + list[1].name
	 238  	}
	 239  
	 240  	// general case (n > 2)
	 241  	var b strings.Builder
	 242  	for i, tname := range list[:n-1] {
	 243  		if i > 0 {
	 244  			b.WriteString(", ")
	 245  		}
	 246  		b.WriteString(tname.name)
	 247  	}
	 248  	b.WriteString(", and ")
	 249  	b.WriteString(list[n-1].name)
	 250  	return b.String()
	 251  }
	 252  
	 253  // IsParameterized reports whether typ contains any of the type parameters of tparams.
	 254  func isParameterized(tparams []*TypeName, typ Type) bool {
	 255  	w := tpWalker{
	 256  		seen:		make(map[Type]bool),
	 257  		tparams: tparams,
	 258  	}
	 259  	return w.isParameterized(typ)
	 260  }
	 261  
	 262  type tpWalker struct {
	 263  	seen		map[Type]bool
	 264  	tparams []*TypeName
	 265  }
	 266  
	 267  func (w *tpWalker) isParameterized(typ Type) (res bool) {
	 268  	// detect cycles
	 269  	if x, ok := w.seen[typ]; ok {
	 270  		return x
	 271  	}
	 272  	w.seen[typ] = false
	 273  	defer func() {
	 274  		w.seen[typ] = res
	 275  	}()
	 276  
	 277  	switch t := typ.(type) {
	 278  	case nil, *Basic: // TODO(gri) should nil be handled here?
	 279  		break
	 280  
	 281  	case *Array:
	 282  		return w.isParameterized(t.elem)
	 283  
	 284  	case *Slice:
	 285  		return w.isParameterized(t.elem)
	 286  
	 287  	case *Struct:
	 288  		for _, fld := range t.fields {
	 289  			if w.isParameterized(fld.typ) {
	 290  				return true
	 291  			}
	 292  		}
	 293  
	 294  	case *Pointer:
	 295  		return w.isParameterized(t.base)
	 296  
	 297  	case *Tuple:
	 298  		n := t.Len()
	 299  		for i := 0; i < n; i++ {
	 300  			if w.isParameterized(t.At(i).typ) {
	 301  				return true
	 302  			}
	 303  		}
	 304  
	 305  	case *_Sum:
	 306  		return w.isParameterizedList(t.types)
	 307  
	 308  	case *Signature:
	 309  		// t.tparams may not be nil if we are looking at a signature
	 310  		// of a generic function type (or an interface method) that is
	 311  		// part of the type we're testing. We don't care about these type
	 312  		// parameters.
	 313  		// Similarly, the receiver of a method may declare (rather then
	 314  		// use) type parameters, we don't care about those either.
	 315  		// Thus, we only need to look at the input and result parameters.
	 316  		return w.isParameterized(t.params) || w.isParameterized(t.results)
	 317  
	 318  	case *Interface:
	 319  		if t.allMethods != nil {
	 320  			// TODO(rFindley) at some point we should enforce completeness here
	 321  			for _, m := range t.allMethods {
	 322  				if w.isParameterized(m.typ) {
	 323  					return true
	 324  				}
	 325  			}
	 326  			return w.isParameterizedList(unpackType(t.allTypes))
	 327  		}
	 328  
	 329  		return t.iterate(func(t *Interface) bool {
	 330  			for _, m := range t.methods {
	 331  				if w.isParameterized(m.typ) {
	 332  					return true
	 333  				}
	 334  			}
	 335  			return w.isParameterizedList(unpackType(t.types))
	 336  		}, nil)
	 337  
	 338  	case *Map:
	 339  		return w.isParameterized(t.key) || w.isParameterized(t.elem)
	 340  
	 341  	case *Chan:
	 342  		return w.isParameterized(t.elem)
	 343  
	 344  	case *Named:
	 345  		return w.isParameterizedList(t.targs)
	 346  
	 347  	case *_TypeParam:
	 348  		// t must be one of w.tparams
	 349  		return t.index < len(w.tparams) && w.tparams[t.index].typ == t
	 350  
	 351  	case *instance:
	 352  		return w.isParameterizedList(t.targs)
	 353  
	 354  	default:
	 355  		unreachable()
	 356  	}
	 357  
	 358  	return false
	 359  }
	 360  
	 361  func (w *tpWalker) isParameterizedList(list []Type) bool {
	 362  	for _, t := range list {
	 363  		if w.isParameterized(t) {
	 364  			return true
	 365  		}
	 366  	}
	 367  	return false
	 368  }
	 369  
	 370  // inferB returns the list of actual type arguments inferred from the type parameters'
	 371  // bounds and an initial set of type arguments. If type inference is impossible because
	 372  // unification fails, an error is reported if report is set to true, the resulting types
	 373  // list is nil, and index is 0.
	 374  // Otherwise, types is the list of inferred type arguments, and index is the index of the
	 375  // first type argument in that list that couldn't be inferred (and thus is nil). If all
	 376  // type arguments were inferred successfully, index is < 0. The number of type arguments
	 377  // provided may be less than the number of type parameters, but there must be at least one.
	 378  func (check *Checker) inferB(tparams []*TypeName, targs []Type, report bool) (types []Type, index int) {
	 379  	assert(len(tparams) >= len(targs) && len(targs) > 0)
	 380  
	 381  	// Setup bidirectional unification between those structural bounds
	 382  	// and the corresponding type arguments (which may be nil!).
	 383  	u := newUnifier(check, false)
	 384  	u.x.init(tparams)
	 385  	u.y = u.x // type parameters between LHS and RHS of unification are identical
	 386  
	 387  	// Set the type arguments which we know already.
	 388  	for i, targ := range targs {
	 389  		if targ != nil {
	 390  			u.x.set(i, targ)
	 391  		}
	 392  	}
	 393  
	 394  	// Unify type parameters with their structural constraints, if any.
	 395  	for _, tpar := range tparams {
	 396  		typ := tpar.typ.(*_TypeParam)
	 397  		sbound := check.structuralType(typ.bound)
	 398  		if sbound != nil {
	 399  			if !u.unify(typ, sbound) {
	 400  				if report {
	 401  					check.errorf(tpar, _Todo, "%s does not match %s", tpar, sbound)
	 402  				}
	 403  				return nil, 0
	 404  			}
	 405  		}
	 406  	}
	 407  
	 408  	// u.x.types() now contains the incoming type arguments plus any additional type
	 409  	// arguments for which there were structural constraints. The newly inferred non-
	 410  	// nil entries may still contain references to other type parameters. For instance,
	 411  	// for [A any, B interface{type []C}, C interface{type *A}], if A == int
	 412  	// was given, unification produced the type list [int, []C, *A]. We eliminate the
	 413  	// remaining type parameters by substituting the type parameters in this type list
	 414  	// until nothing changes anymore.
	 415  	types, _ = u.x.types()
	 416  	if debug {
	 417  		for i, targ := range targs {
	 418  			assert(targ == nil || types[i] == targ)
	 419  		}
	 420  	}
	 421  
	 422  	// dirty tracks the indices of all types that may still contain type parameters.
	 423  	// We know that nil type entries and entries corresponding to provided (non-nil)
	 424  	// type arguments are clean, so exclude them from the start.
	 425  	var dirty []int
	 426  	for i, typ := range types {
	 427  		if typ != nil && (i >= len(targs) || targs[i] == nil) {
	 428  			dirty = append(dirty, i)
	 429  		}
	 430  	}
	 431  
	 432  	for len(dirty) > 0 {
	 433  		// TODO(gri) Instead of creating a new substMap for each iteration,
	 434  		// provide an update operation for substMaps and only change when
	 435  		// needed. Optimization.
	 436  		smap := makeSubstMap(tparams, types)
	 437  		n := 0
	 438  		for _, index := range dirty {
	 439  			t0 := types[index]
	 440  			if t1 := check.subst(token.NoPos, t0, smap); t1 != t0 {
	 441  				types[index] = t1
	 442  				dirty[n] = index
	 443  				n++
	 444  			}
	 445  		}
	 446  		dirty = dirty[:n]
	 447  	}
	 448  
	 449  	// Once nothing changes anymore, we may still have type parameters left;
	 450  	// e.g., a structural constraint *P may match a type parameter Q but we
	 451  	// don't have any type arguments to fill in for *P or Q (issue #45548).
	 452  	// Don't let such inferences escape, instead nil them out.
	 453  	for i, typ := range types {
	 454  		if typ != nil && isParameterized(tparams, typ) {
	 455  			types[i] = nil
	 456  		}
	 457  	}
	 458  
	 459  	// update index
	 460  	index = -1
	 461  	for i, typ := range types {
	 462  		if typ == nil {
	 463  			index = i
	 464  			break
	 465  		}
	 466  	}
	 467  
	 468  	return
	 469  }
	 470  
	 471  // structuralType returns the structural type of a constraint, if any.
	 472  func (check *Checker) structuralType(constraint Type) Type {
	 473  	if iface, _ := under(constraint).(*Interface); iface != nil {
	 474  		check.completeInterface(token.NoPos, iface)
	 475  		types := unpackType(iface.allTypes)
	 476  		if len(types) == 1 {
	 477  			return types[0]
	 478  		}
	 479  		return nil
	 480  	}
	 481  	return constraint
	 482  }
	 483
View as plain text