Source file src/go/types/typexpr.go

Documentation: go/types

		 1  // Copyright 2013 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-checking of identifiers and type expressions.
		 6  
		 7  package types
		 8  
		 9  import (
		10  	"fmt"
		11  	"go/ast"
		12  	"go/constant"
		13  	"go/internal/typeparams"
		14  	"go/token"
		15  	"sort"
		16  	"strconv"
		17  	"strings"
		18  )
		19  
		20  // ident type-checks identifier e and initializes x with the value or type of e.
		21  // If an error occurred, x.mode is set to invalid.
		22  // For the meaning of def, see Checker.definedType, below.
		23  // If wantType is set, the identifier e is expected to denote a type.
		24  //
		25  func (check *Checker) ident(x *operand, e *ast.Ident, def *Named, wantType bool) {
		26  	x.mode = invalid
		27  	x.expr = e
		28  
		29  	// Note that we cannot use check.lookup here because the returned scope
		30  	// may be different from obj.Parent(). See also Scope.LookupParent doc.
		31  	scope, obj := check.scope.LookupParent(e.Name, check.pos)
		32  	if obj == nil {
		33  		if e.Name == "_" {
		34  			check.errorf(e, _InvalidBlank, "cannot use _ as value or type")
		35  		} else {
		36  			check.errorf(e, _UndeclaredName, "undeclared name: %s", e.Name)
		37  		}
		38  		return
		39  	}
		40  	check.recordUse(e, obj)
		41  
		42  	// Type-check the object.
		43  	// Only call Checker.objDecl if the object doesn't have a type yet
		44  	// (in which case we must actually determine it) or the object is a
		45  	// TypeName and we also want a type (in which case we might detect
		46  	// a cycle which needs to be reported). Otherwise we can skip the
		47  	// call and avoid a possible cycle error in favor of the more
		48  	// informative "not a type/value" error that this function's caller
		49  	// will issue (see issue #25790).
		50  	typ := obj.Type()
		51  	if _, gotType := obj.(*TypeName); typ == nil || gotType && wantType {
		52  		check.objDecl(obj, def)
		53  		typ = obj.Type() // type must have been assigned by Checker.objDecl
		54  	}
		55  	assert(typ != nil)
		56  
		57  	// The object may have been dot-imported.
		58  	// If so, mark the respective package as used.
		59  	// (This code is only needed for dot-imports. Without them,
		60  	// we only have to mark variables, see *Var case below).
		61  	if pkgName := check.dotImportMap[dotImportKey{scope, obj}]; pkgName != nil {
		62  		pkgName.used = true
		63  	}
		64  
		65  	switch obj := obj.(type) {
		66  	case *PkgName:
		67  		check.errorf(e, _InvalidPkgUse, "use of package %s not in selector", obj.name)
		68  		return
		69  
		70  	case *Const:
		71  		check.addDeclDep(obj)
		72  		if typ == Typ[Invalid] {
		73  			return
		74  		}
		75  		if obj == universeIota {
		76  			if check.iota == nil {
		77  				check.errorf(e, _InvalidIota, "cannot use iota outside constant declaration")
		78  				return
		79  			}
		80  			x.val = check.iota
		81  		} else {
		82  			x.val = obj.val
		83  		}
		84  		assert(x.val != nil)
		85  		x.mode = constant_
		86  
		87  	case *TypeName:
		88  		x.mode = typexpr
		89  
		90  	case *Var:
		91  		// It's ok to mark non-local variables, but ignore variables
		92  		// from other packages to avoid potential race conditions with
		93  		// dot-imported variables.
		94  		if obj.pkg == check.pkg {
		95  			obj.used = true
		96  		}
		97  		check.addDeclDep(obj)
		98  		if typ == Typ[Invalid] {
		99  			return
	 100  		}
	 101  		x.mode = variable
	 102  
	 103  	case *Func:
	 104  		check.addDeclDep(obj)
	 105  		x.mode = value
	 106  
	 107  	case *Builtin:
	 108  		x.id = obj.id
	 109  		x.mode = builtin
	 110  
	 111  	case *Nil:
	 112  		x.mode = value
	 113  
	 114  	default:
	 115  		unreachable()
	 116  	}
	 117  
	 118  	x.typ = typ
	 119  }
	 120  
	 121  // typ type-checks the type expression e and returns its type, or Typ[Invalid].
	 122  // The type must not be an (uninstantiated) generic type.
	 123  func (check *Checker) typ(e ast.Expr) Type {
	 124  	return check.definedType(e, nil)
	 125  }
	 126  
	 127  // varType type-checks the type expression e and returns its type, or Typ[Invalid].
	 128  // The type must not be an (uninstantiated) generic type and it must be ordinary
	 129  // (see ordinaryType).
	 130  func (check *Checker) varType(e ast.Expr) Type {
	 131  	typ := check.definedType(e, nil)
	 132  	check.ordinaryType(e, typ)
	 133  	return typ
	 134  }
	 135  
	 136  // ordinaryType reports an error if typ is an interface type containing
	 137  // type lists or is (or embeds) the predeclared type comparable.
	 138  func (check *Checker) ordinaryType(pos positioner, typ Type) {
	 139  	// We don't want to call under() (via asInterface) or complete interfaces
	 140  	// while we are in the middle of type-checking parameter declarations that
	 141  	// might belong to interface methods. Delay this check to the end of
	 142  	// type-checking.
	 143  	check.later(func() {
	 144  		if t := asInterface(typ); t != nil {
	 145  			check.completeInterface(pos.Pos(), t) // TODO(gri) is this the correct position?
	 146  			if t.allTypes != nil {
	 147  				check.softErrorf(pos, _Todo, "interface contains type constraints (%s)", t.allTypes)
	 148  				return
	 149  			}
	 150  			if t._IsComparable() {
	 151  				check.softErrorf(pos, _Todo, "interface is (or embeds) comparable")
	 152  			}
	 153  		}
	 154  	})
	 155  }
	 156  
	 157  // anyType type-checks the type expression e and returns its type, or Typ[Invalid].
	 158  // The type may be generic or instantiated.
	 159  func (check *Checker) anyType(e ast.Expr) Type {
	 160  	typ := check.typInternal(e, nil)
	 161  	assert(isTyped(typ))
	 162  	check.recordTypeAndValue(e, typexpr, typ, nil)
	 163  	return typ
	 164  }
	 165  
	 166  // definedType is like typ but also accepts a type name def.
	 167  // If def != nil, e is the type specification for the defined type def, declared
	 168  // in a type declaration, and def.underlying will be set to the type of e before
	 169  // any components of e are type-checked.
	 170  //
	 171  func (check *Checker) definedType(e ast.Expr, def *Named) Type {
	 172  	typ := check.typInternal(e, def)
	 173  	assert(isTyped(typ))
	 174  	if isGeneric(typ) {
	 175  		check.errorf(e, _Todo, "cannot use generic type %s without instantiation", typ)
	 176  		typ = Typ[Invalid]
	 177  	}
	 178  	check.recordTypeAndValue(e, typexpr, typ, nil)
	 179  	return typ
	 180  }
	 181  
	 182  // genericType is like typ but the type must be an (uninstantiated) generic type.
	 183  func (check *Checker) genericType(e ast.Expr, reportErr bool) Type {
	 184  	typ := check.typInternal(e, nil)
	 185  	assert(isTyped(typ))
	 186  	if typ != Typ[Invalid] && !isGeneric(typ) {
	 187  		if reportErr {
	 188  			check.errorf(e, _Todo, "%s is not a generic type", typ)
	 189  		}
	 190  		typ = Typ[Invalid]
	 191  	}
	 192  	// TODO(gri) what is the correct call below?
	 193  	check.recordTypeAndValue(e, typexpr, typ, nil)
	 194  	return typ
	 195  }
	 196  
	 197  // isubst returns an x with identifiers substituted per the substitution map smap.
	 198  // isubst only handles the case of (valid) method receiver type expressions correctly.
	 199  func isubst(x ast.Expr, smap map[*ast.Ident]*ast.Ident) ast.Expr {
	 200  	switch n := x.(type) {
	 201  	case *ast.Ident:
	 202  		if alt := smap[n]; alt != nil {
	 203  			return alt
	 204  		}
	 205  	case *ast.StarExpr:
	 206  		X := isubst(n.X, smap)
	 207  		if X != n.X {
	 208  			new := *n
	 209  			new.X = X
	 210  			return &new
	 211  		}
	 212  	case *ast.IndexExpr:
	 213  		elems := typeparams.UnpackExpr(n.Index)
	 214  		var newElems []ast.Expr
	 215  		for i, elem := range elems {
	 216  			new := isubst(elem, smap)
	 217  			if new != elem {
	 218  				if newElems == nil {
	 219  					newElems = make([]ast.Expr, len(elems))
	 220  					copy(newElems, elems)
	 221  				}
	 222  				newElems[i] = new
	 223  			}
	 224  		}
	 225  		if newElems != nil {
	 226  			index := typeparams.PackExpr(newElems)
	 227  			new := *n
	 228  			new.Index = index
	 229  			return &new
	 230  		}
	 231  	case *ast.ParenExpr:
	 232  		return isubst(n.X, smap) // no need to keep parentheses
	 233  	default:
	 234  		// Other receiver type expressions are invalid.
	 235  		// It's fine to ignore those here as they will
	 236  		// be checked elsewhere.
	 237  	}
	 238  	return x
	 239  }
	 240  
	 241  // funcType type-checks a function or method type.
	 242  func (check *Checker) funcType(sig *Signature, recvPar *ast.FieldList, ftyp *ast.FuncType) {
	 243  	check.openScope(ftyp, "function")
	 244  	check.scope.isFunc = true
	 245  	check.recordScope(ftyp, check.scope)
	 246  	sig.scope = check.scope
	 247  	defer check.closeScope()
	 248  
	 249  	var recvTyp ast.Expr // rewritten receiver type; valid if != nil
	 250  	if recvPar != nil && len(recvPar.List) > 0 {
	 251  		// collect generic receiver type parameters, if any
	 252  		// - a receiver type parameter is like any other type parameter, except that it is declared implicitly
	 253  		// - the receiver specification acts as local declaration for its type parameters, which may be blank
	 254  		_, rname, rparams := check.unpackRecv(recvPar.List[0].Type, true)
	 255  		if len(rparams) > 0 {
	 256  			// Blank identifiers don't get declared and regular type-checking of the instantiated
	 257  			// parameterized receiver type expression fails in Checker.collectParams of receiver.
	 258  			// Identify blank type parameters and substitute each with a unique new identifier named
	 259  			// "n_" (where n is the parameter index) and which cannot conflict with any user-defined
	 260  			// name.
	 261  			var smap map[*ast.Ident]*ast.Ident // substitution map from "_" to "n_" identifiers
	 262  			for i, p := range rparams {
	 263  				if p.Name == "_" {
	 264  					new := *p
	 265  					new.Name = fmt.Sprintf("%d_", i)
	 266  					rparams[i] = &new // use n_ identifier instead of _ so it can be looked up
	 267  					if smap == nil {
	 268  						smap = make(map[*ast.Ident]*ast.Ident)
	 269  					}
	 270  					smap[p] = &new
	 271  				}
	 272  			}
	 273  			if smap != nil {
	 274  				// blank identifiers were found => use rewritten receiver type
	 275  				recvTyp = isubst(recvPar.List[0].Type, smap)
	 276  			}
	 277  			sig.rparams = check.declareTypeParams(nil, rparams)
	 278  			// determine receiver type to get its type parameters
	 279  			// and the respective type parameter bounds
	 280  			var recvTParams []*TypeName
	 281  			if rname != nil {
	 282  				// recv should be a Named type (otherwise an error is reported elsewhere)
	 283  				// Also: Don't report an error via genericType since it will be reported
	 284  				//			 again when we type-check the signature.
	 285  				// TODO(gri) maybe the receiver should be marked as invalid instead?
	 286  				if recv := asNamed(check.genericType(rname, false)); recv != nil {
	 287  					recvTParams = recv.tparams
	 288  				}
	 289  			}
	 290  			// provide type parameter bounds
	 291  			// - only do this if we have the right number (otherwise an error is reported elsewhere)
	 292  			if len(sig.rparams) == len(recvTParams) {
	 293  				// We have a list of *TypeNames but we need a list of Types.
	 294  				list := make([]Type, len(sig.rparams))
	 295  				for i, t := range sig.rparams {
	 296  					list[i] = t.typ
	 297  				}
	 298  				smap := makeSubstMap(recvTParams, list)
	 299  				for i, tname := range sig.rparams {
	 300  					bound := recvTParams[i].typ.(*_TypeParam).bound
	 301  					// bound is (possibly) parameterized in the context of the
	 302  					// receiver type declaration. Substitute parameters for the
	 303  					// current context.
	 304  					// TODO(gri) should we assume now that bounds always exist?
	 305  					//					 (no bound == empty interface)
	 306  					if bound != nil {
	 307  						bound = check.subst(tname.pos, bound, smap)
	 308  						tname.typ.(*_TypeParam).bound = bound
	 309  					}
	 310  				}
	 311  			}
	 312  		}
	 313  	}
	 314  
	 315  	if tparams := typeparams.Get(ftyp); tparams != nil {
	 316  		sig.tparams = check.collectTypeParams(tparams)
	 317  		// Always type-check method type parameters but complain that they are not allowed.
	 318  		// (A separate check is needed when type-checking interface method signatures because
	 319  		// they don't have a receiver specification.)
	 320  		if recvPar != nil {
	 321  			check.errorf(tparams, _Todo, "methods cannot have type parameters")
	 322  		}
	 323  	}
	 324  
	 325  	// Value (non-type) parameters' scope starts in the function body. Use a temporary scope for their
	 326  	// declarations and then squash that scope into the parent scope (and report any redeclarations at
	 327  	// that time).
	 328  	scope := NewScope(check.scope, token.NoPos, token.NoPos, "function body (temp. scope)")
	 329  	recvList, _ := check.collectParams(scope, recvPar, recvTyp, false) // use rewritten receiver type, if any
	 330  	params, variadic := check.collectParams(scope, ftyp.Params, nil, true)
	 331  	results, _ := check.collectParams(scope, ftyp.Results, nil, false)
	 332  	scope.squash(func(obj, alt Object) {
	 333  		check.errorf(obj, _DuplicateDecl, "%s redeclared in this block", obj.Name())
	 334  		check.reportAltDecl(alt)
	 335  	})
	 336  
	 337  	if recvPar != nil {
	 338  		// recv parameter list present (may be empty)
	 339  		// spec: "The receiver is specified via an extra parameter section preceding the
	 340  		// method name. That parameter section must declare a single parameter, the receiver."
	 341  		var recv *Var
	 342  		switch len(recvList) {
	 343  		case 0:
	 344  			// error reported by resolver
	 345  			recv = NewParam(0, nil, "", Typ[Invalid]) // ignore recv below
	 346  		default:
	 347  			// more than one receiver
	 348  			check.error(recvList[len(recvList)-1], _BadRecv, "method must have exactly one receiver")
	 349  			fallthrough // continue with first receiver
	 350  		case 1:
	 351  			recv = recvList[0]
	 352  		}
	 353  
	 354  		// TODO(gri) We should delay rtyp expansion to when we actually need the
	 355  		//					 receiver; thus all checks here should be delayed to later.
	 356  		rtyp, _ := deref(recv.typ)
	 357  		rtyp = expand(rtyp)
	 358  
	 359  		// spec: "The receiver type must be of the form T or *T where T is a type name."
	 360  		// (ignore invalid types - error was reported before)
	 361  		if t := rtyp; t != Typ[Invalid] {
	 362  			var err string
	 363  			if T := asNamed(t); T != nil {
	 364  				// spec: "The type denoted by T is called the receiver base type; it must not
	 365  				// be a pointer or interface type and it must be declared in the same package
	 366  				// as the method."
	 367  				if T.obj.pkg != check.pkg {
	 368  					err = "type not defined in this package"
	 369  				} else {
	 370  					switch u := optype(T).(type) {
	 371  					case *Basic:
	 372  						// unsafe.Pointer is treated like a regular pointer
	 373  						if u.kind == UnsafePointer {
	 374  							err = "unsafe.Pointer"
	 375  						}
	 376  					case *Pointer, *Interface:
	 377  						err = "pointer or interface type"
	 378  					}
	 379  				}
	 380  			} else {
	 381  				err = "basic or unnamed type"
	 382  			}
	 383  			if err != "" {
	 384  				check.errorf(recv, _InvalidRecv, "invalid receiver %s (%s)", recv.typ, err)
	 385  				// ok to continue
	 386  			}
	 387  		}
	 388  		sig.recv = recv
	 389  	}
	 390  
	 391  	sig.params = NewTuple(params...)
	 392  	sig.results = NewTuple(results...)
	 393  	sig.variadic = variadic
	 394  }
	 395  
	 396  // goTypeName returns the Go type name for typ and
	 397  // removes any occurrences of "types." from that name.
	 398  func goTypeName(typ Type) string {
	 399  	return strings.ReplaceAll(fmt.Sprintf("%T", typ), "types.", "")
	 400  }
	 401  
	 402  // typInternal drives type checking of types.
	 403  // Must only be called by definedType or genericType.
	 404  //
	 405  func (check *Checker) typInternal(e0 ast.Expr, def *Named) (T Type) {
	 406  	if trace {
	 407  		check.trace(e0.Pos(), "type %s", e0)
	 408  		check.indent++
	 409  		defer func() {
	 410  			check.indent--
	 411  			var under Type
	 412  			if T != nil {
	 413  				// Calling under() here may lead to endless instantiations.
	 414  				// Test case: type T[P any] *T[P]
	 415  				// TODO(gri) investigate if that's a bug or to be expected
	 416  				// (see also analogous comment in Checker.instantiate).
	 417  				under = T.Underlying()
	 418  			}
	 419  			if T == under {
	 420  				check.trace(e0.Pos(), "=> %s // %s", T, goTypeName(T))
	 421  			} else {
	 422  				check.trace(e0.Pos(), "=> %s (under = %s) // %s", T, under, goTypeName(T))
	 423  			}
	 424  		}()
	 425  	}
	 426  
	 427  	switch e := e0.(type) {
	 428  	case *ast.BadExpr:
	 429  		// ignore - error reported before
	 430  
	 431  	case *ast.Ident:
	 432  		var x operand
	 433  		check.ident(&x, e, def, true)
	 434  
	 435  		switch x.mode {
	 436  		case typexpr:
	 437  			typ := x.typ
	 438  			def.setUnderlying(typ)
	 439  			return typ
	 440  		case invalid:
	 441  			// ignore - error reported before
	 442  		case novalue:
	 443  			check.errorf(&x, _NotAType, "%s used as type", &x)
	 444  		default:
	 445  			check.errorf(&x, _NotAType, "%s is not a type", &x)
	 446  		}
	 447  
	 448  	case *ast.SelectorExpr:
	 449  		var x operand
	 450  		check.selector(&x, e)
	 451  
	 452  		switch x.mode {
	 453  		case typexpr:
	 454  			typ := x.typ
	 455  			def.setUnderlying(typ)
	 456  			return typ
	 457  		case invalid:
	 458  			// ignore - error reported before
	 459  		case novalue:
	 460  			check.errorf(&x, _NotAType, "%s used as type", &x)
	 461  		default:
	 462  			check.errorf(&x, _NotAType, "%s is not a type", &x)
	 463  		}
	 464  
	 465  	case *ast.IndexExpr:
	 466  		if typeparams.Enabled {
	 467  			exprs := typeparams.UnpackExpr(e.Index)
	 468  			return check.instantiatedType(e.X, exprs, def)
	 469  		}
	 470  		check.errorf(e0, _NotAType, "%s is not a type", e0)
	 471  		check.use(e.X)
	 472  
	 473  	case *ast.ParenExpr:
	 474  		// Generic types must be instantiated before they can be used in any form.
	 475  		// Consequently, generic types cannot be parenthesized.
	 476  		return check.definedType(e.X, def)
	 477  
	 478  	case *ast.ArrayType:
	 479  		if e.Len != nil {
	 480  			typ := new(Array)
	 481  			def.setUnderlying(typ)
	 482  			typ.len = check.arrayLength(e.Len)
	 483  			typ.elem = check.varType(e.Elt)
	 484  			return typ
	 485  		}
	 486  
	 487  		typ := new(Slice)
	 488  		def.setUnderlying(typ)
	 489  		typ.elem = check.varType(e.Elt)
	 490  		return typ
	 491  
	 492  	case *ast.Ellipsis:
	 493  		// dots are handled explicitly where they are legal
	 494  		// (array composite literals and parameter lists)
	 495  		check.error(e, _InvalidDotDotDot, "invalid use of '...'")
	 496  		check.use(e.Elt)
	 497  
	 498  	case *ast.StructType:
	 499  		typ := new(Struct)
	 500  		def.setUnderlying(typ)
	 501  		check.structType(typ, e)
	 502  		return typ
	 503  
	 504  	case *ast.StarExpr:
	 505  		typ := new(Pointer)
	 506  		def.setUnderlying(typ)
	 507  		typ.base = check.varType(e.X)
	 508  		return typ
	 509  
	 510  	case *ast.FuncType:
	 511  		typ := new(Signature)
	 512  		def.setUnderlying(typ)
	 513  		check.funcType(typ, nil, e)
	 514  		return typ
	 515  
	 516  	case *ast.InterfaceType:
	 517  		typ := new(Interface)
	 518  		def.setUnderlying(typ)
	 519  		if def != nil {
	 520  			typ.obj = def.obj
	 521  		}
	 522  		check.interfaceType(typ, e, def)
	 523  		return typ
	 524  
	 525  	case *ast.MapType:
	 526  		typ := new(Map)
	 527  		def.setUnderlying(typ)
	 528  
	 529  		typ.key = check.varType(e.Key)
	 530  		typ.elem = check.varType(e.Value)
	 531  
	 532  		// spec: "The comparison operators == and != must be fully defined
	 533  		// for operands of the key type; thus the key type must not be a
	 534  		// function, map, or slice."
	 535  		//
	 536  		// Delay this check because it requires fully setup types;
	 537  		// it is safe to continue in any case (was issue 6667).
	 538  		check.later(func() {
	 539  			if !Comparable(typ.key) {
	 540  				var why string
	 541  				if asTypeParam(typ.key) != nil {
	 542  					why = " (missing comparable constraint)"
	 543  				}
	 544  				check.errorf(e.Key, _IncomparableMapKey, "incomparable map key type %s%s", typ.key, why)
	 545  			}
	 546  		})
	 547  
	 548  		return typ
	 549  
	 550  	case *ast.ChanType:
	 551  		typ := new(Chan)
	 552  		def.setUnderlying(typ)
	 553  
	 554  		dir := SendRecv
	 555  		switch e.Dir {
	 556  		case ast.SEND | ast.RECV:
	 557  			// nothing to do
	 558  		case ast.SEND:
	 559  			dir = SendOnly
	 560  		case ast.RECV:
	 561  			dir = RecvOnly
	 562  		default:
	 563  			check.invalidAST(e, "unknown channel direction %d", e.Dir)
	 564  			// ok to continue
	 565  		}
	 566  
	 567  		typ.dir = dir
	 568  		typ.elem = check.varType(e.Value)
	 569  		return typ
	 570  
	 571  	default:
	 572  		check.errorf(e0, _NotAType, "%s is not a type", e0)
	 573  	}
	 574  
	 575  	typ := Typ[Invalid]
	 576  	def.setUnderlying(typ)
	 577  	return typ
	 578  }
	 579  
	 580  // typeOrNil type-checks the type expression (or nil value) e
	 581  // and returns the type of e, or nil. If e is a type, it must
	 582  // not be an (uninstantiated) generic type.
	 583  // If e is neither a type nor nil, typeOrNil returns Typ[Invalid].
	 584  // TODO(gri) should we also disallow non-var types?
	 585  func (check *Checker) typeOrNil(e ast.Expr) Type {
	 586  	var x operand
	 587  	check.rawExpr(&x, e, nil)
	 588  	switch x.mode {
	 589  	case invalid:
	 590  		// ignore - error reported before
	 591  	case novalue:
	 592  		check.errorf(&x, _NotAType, "%s used as type", &x)
	 593  	case typexpr:
	 594  		check.instantiatedOperand(&x)
	 595  		return x.typ
	 596  	case value:
	 597  		if x.isNil() {
	 598  			return nil
	 599  		}
	 600  		fallthrough
	 601  	default:
	 602  		check.errorf(&x, _NotAType, "%s is not a type", &x)
	 603  	}
	 604  	return Typ[Invalid]
	 605  }
	 606  
	 607  func (check *Checker) instantiatedType(x ast.Expr, targs []ast.Expr, def *Named) Type {
	 608  	b := check.genericType(x, true) // TODO(gri) what about cycles?
	 609  	if b == Typ[Invalid] {
	 610  		return b // error already reported
	 611  	}
	 612  	base := asNamed(b)
	 613  	if base == nil {
	 614  		unreachable() // should have been caught by genericType
	 615  	}
	 616  
	 617  	// create a new type instance rather than instantiate the type
	 618  	// TODO(gri) should do argument number check here rather than
	 619  	//					 when instantiating the type?
	 620  	typ := new(instance)
	 621  	def.setUnderlying(typ)
	 622  
	 623  	typ.check = check
	 624  	typ.pos = x.Pos()
	 625  	typ.base = base
	 626  
	 627  	// evaluate arguments (always)
	 628  	typ.targs = check.typeList(targs)
	 629  	if typ.targs == nil {
	 630  		def.setUnderlying(Typ[Invalid]) // avoid later errors due to lazy instantiation
	 631  		return Typ[Invalid]
	 632  	}
	 633  
	 634  	// determine argument positions (for error reporting)
	 635  	typ.poslist = make([]token.Pos, len(targs))
	 636  	for i, arg := range targs {
	 637  		typ.poslist[i] = arg.Pos()
	 638  	}
	 639  
	 640  	// make sure we check instantiation works at least once
	 641  	// and that the resulting type is valid
	 642  	check.later(func() {
	 643  		t := typ.expand()
	 644  		check.validType(t, nil)
	 645  	})
	 646  
	 647  	return typ
	 648  }
	 649  
	 650  // arrayLength type-checks the array length expression e
	 651  // and returns the constant length >= 0, or a value < 0
	 652  // to indicate an error (and thus an unknown length).
	 653  func (check *Checker) arrayLength(e ast.Expr) int64 {
	 654  	var x operand
	 655  	check.expr(&x, e)
	 656  	if x.mode != constant_ {
	 657  		if x.mode != invalid {
	 658  			check.errorf(&x, _InvalidArrayLen, "array length %s must be constant", &x)
	 659  		}
	 660  		return -1
	 661  	}
	 662  	if isUntyped(x.typ) || isInteger(x.typ) {
	 663  		if val := constant.ToInt(x.val); val.Kind() == constant.Int {
	 664  			if representableConst(val, check, Typ[Int], nil) {
	 665  				if n, ok := constant.Int64Val(val); ok && n >= 0 {
	 666  					return n
	 667  				}
	 668  				check.errorf(&x, _InvalidArrayLen, "invalid array length %s", &x)
	 669  				return -1
	 670  			}
	 671  		}
	 672  	}
	 673  	check.errorf(&x, _InvalidArrayLen, "array length %s must be integer", &x)
	 674  	return -1
	 675  }
	 676  
	 677  // typeList provides the list of types corresponding to the incoming expression list.
	 678  // If an error occurred, the result is nil, but all list elements were type-checked.
	 679  func (check *Checker) typeList(list []ast.Expr) []Type {
	 680  	res := make([]Type, len(list)) // res != nil even if len(list) == 0
	 681  	for i, x := range list {
	 682  		t := check.varType(x)
	 683  		if t == Typ[Invalid] {
	 684  			res = nil
	 685  		}
	 686  		if res != nil {
	 687  			res[i] = t
	 688  		}
	 689  	}
	 690  	return res
	 691  }
	 692  
	 693  // collectParams declares the parameters of list in scope and returns the corresponding
	 694  // variable list. If type0 != nil, it is used instead of the first type in list.
	 695  func (check *Checker) collectParams(scope *Scope, list *ast.FieldList, type0 ast.Expr, variadicOk bool) (params []*Var, variadic bool) {
	 696  	if list == nil {
	 697  		return
	 698  	}
	 699  
	 700  	var named, anonymous bool
	 701  	for i, field := range list.List {
	 702  		ftype := field.Type
	 703  		if i == 0 && type0 != nil {
	 704  			ftype = type0
	 705  		}
	 706  		if t, _ := ftype.(*ast.Ellipsis); t != nil {
	 707  			ftype = t.Elt
	 708  			if variadicOk && i == len(list.List)-1 && len(field.Names) <= 1 {
	 709  				variadic = true
	 710  			} else {
	 711  				check.softErrorf(t, _MisplacedDotDotDot, "can only use ... with final parameter in list")
	 712  				// ignore ... and continue
	 713  			}
	 714  		}
	 715  		typ := check.varType(ftype)
	 716  		// The parser ensures that f.Tag is nil and we don't
	 717  		// care if a constructed AST contains a non-nil tag.
	 718  		if len(field.Names) > 0 {
	 719  			// named parameter
	 720  			for _, name := range field.Names {
	 721  				if name.Name == "" {
	 722  					check.invalidAST(name, "anonymous parameter")
	 723  					// ok to continue
	 724  				}
	 725  				par := NewParam(name.Pos(), check.pkg, name.Name, typ)
	 726  				check.declare(scope, name, par, scope.pos)
	 727  				params = append(params, par)
	 728  			}
	 729  			named = true
	 730  		} else {
	 731  			// anonymous parameter
	 732  			par := NewParam(ftype.Pos(), check.pkg, "", typ)
	 733  			check.recordImplicit(field, par)
	 734  			params = append(params, par)
	 735  			anonymous = true
	 736  		}
	 737  	}
	 738  
	 739  	if named && anonymous {
	 740  		check.invalidAST(list, "list contains both named and anonymous parameters")
	 741  		// ok to continue
	 742  	}
	 743  
	 744  	// For a variadic function, change the last parameter's type from T to []T.
	 745  	// Since we type-checked T rather than ...T, we also need to retro-actively
	 746  	// record the type for ...T.
	 747  	if variadic {
	 748  		last := params[len(params)-1]
	 749  		last.typ = &Slice{elem: last.typ}
	 750  		check.recordTypeAndValue(list.List[len(list.List)-1].Type, typexpr, last.typ, nil)
	 751  	}
	 752  
	 753  	return
	 754  }
	 755  
	 756  func (check *Checker) declareInSet(oset *objset, pos token.Pos, obj Object) bool {
	 757  	if alt := oset.insert(obj); alt != nil {
	 758  		check.errorf(atPos(pos), _DuplicateDecl, "%s redeclared", obj.Name())
	 759  		check.reportAltDecl(alt)
	 760  		return false
	 761  	}
	 762  	return true
	 763  }
	 764  
	 765  func (check *Checker) interfaceType(ityp *Interface, iface *ast.InterfaceType, def *Named) {
	 766  	var tlist *ast.Ident // "type" name of first entry in a type list declaration
	 767  	var types []ast.Expr
	 768  	for _, f := range iface.Methods.List {
	 769  		if len(f.Names) > 0 {
	 770  			// We have a method with name f.Names[0], or a type
	 771  			// of a type list (name.Name == "type").
	 772  			// (The parser ensures that there's only one method
	 773  			// and we don't care if a constructed AST has more.)
	 774  			name := f.Names[0]
	 775  			if name.Name == "_" {
	 776  				check.errorf(name, _BlankIfaceMethod, "invalid method name _")
	 777  				continue // ignore
	 778  			}
	 779  
	 780  			if name.Name == "type" {
	 781  				// Always collect all type list entries, even from
	 782  				// different type lists, under the assumption that
	 783  				// the author intended to include all types.
	 784  				types = append(types, f.Type)
	 785  				if tlist != nil && tlist != name {
	 786  					check.errorf(name, _Todo, "cannot have multiple type lists in an interface")
	 787  				}
	 788  				tlist = name
	 789  				continue
	 790  			}
	 791  
	 792  			typ := check.typ(f.Type)
	 793  			sig, _ := typ.(*Signature)
	 794  			if sig == nil {
	 795  				if typ != Typ[Invalid] {
	 796  					check.invalidAST(f.Type, "%s is not a method signature", typ)
	 797  				}
	 798  				continue // ignore
	 799  			}
	 800  
	 801  			// Always type-check method type parameters but complain if they are not enabled.
	 802  			// (This extra check is needed here because interface method signatures don't have
	 803  			// a receiver specification.)
	 804  			if sig.tparams != nil {
	 805  				var at positioner = f.Type
	 806  				if tparams := typeparams.Get(f.Type); tparams != nil {
	 807  					at = tparams
	 808  				}
	 809  				check.errorf(at, _Todo, "methods cannot have type parameters")
	 810  			}
	 811  
	 812  			// use named receiver type if available (for better error messages)
	 813  			var recvTyp Type = ityp
	 814  			if def != nil {
	 815  				recvTyp = def
	 816  			}
	 817  			sig.recv = NewVar(name.Pos(), check.pkg, "", recvTyp)
	 818  
	 819  			m := NewFunc(name.Pos(), check.pkg, name.Name, sig)
	 820  			check.recordDef(name, m)
	 821  			ityp.methods = append(ityp.methods, m)
	 822  		} else {
	 823  			// We have an embedded type. completeInterface will
	 824  			// eventually verify that we have an interface.
	 825  			ityp.embeddeds = append(ityp.embeddeds, check.typ(f.Type))
	 826  			check.posMap[ityp] = append(check.posMap[ityp], f.Type.Pos())
	 827  		}
	 828  	}
	 829  
	 830  	// type constraints
	 831  	ityp.types = _NewSum(check.collectTypeConstraints(iface.Pos(), types))
	 832  
	 833  	if len(ityp.methods) == 0 && ityp.types == nil && len(ityp.embeddeds) == 0 {
	 834  		// empty interface
	 835  		ityp.allMethods = markComplete
	 836  		return
	 837  	}
	 838  
	 839  	// sort for API stability
	 840  	sortMethods(ityp.methods)
	 841  	sortTypes(ityp.embeddeds)
	 842  
	 843  	check.later(func() { check.completeInterface(iface.Pos(), ityp) })
	 844  }
	 845  
	 846  func (check *Checker) completeInterface(pos token.Pos, ityp *Interface) {
	 847  	if ityp.allMethods != nil {
	 848  		return
	 849  	}
	 850  
	 851  	// completeInterface may be called via the LookupFieldOrMethod,
	 852  	// MissingMethod, Identical, or IdenticalIgnoreTags external API
	 853  	// in which case check will be nil. In this case, type-checking
	 854  	// must be finished and all interfaces should have been completed.
	 855  	if check == nil {
	 856  		panic("internal error: incomplete interface")
	 857  	}
	 858  
	 859  	if trace {
	 860  		// Types don't generally have position information.
	 861  		// If we don't have a valid pos provided, try to use
	 862  		// one close enough.
	 863  		if !pos.IsValid() && len(ityp.methods) > 0 {
	 864  			pos = ityp.methods[0].pos
	 865  		}
	 866  
	 867  		check.trace(pos, "complete %s", ityp)
	 868  		check.indent++
	 869  		defer func() {
	 870  			check.indent--
	 871  			check.trace(pos, "=> %s (methods = %v, types = %v)", ityp, ityp.allMethods, ityp.allTypes)
	 872  		}()
	 873  	}
	 874  
	 875  	// An infinitely expanding interface (due to a cycle) is detected
	 876  	// elsewhere (Checker.validType), so here we simply assume we only
	 877  	// have valid interfaces. Mark the interface as complete to avoid
	 878  	// infinite recursion if the validType check occurs later for some
	 879  	// reason.
	 880  	ityp.allMethods = markComplete
	 881  
	 882  	// Methods of embedded interfaces are collected unchanged; i.e., the identity
	 883  	// of a method I.m's Func Object of an interface I is the same as that of
	 884  	// the method m in an interface that embeds interface I. On the other hand,
	 885  	// if a method is embedded via multiple overlapping embedded interfaces, we
	 886  	// don't provide a guarantee which "original m" got chosen for the embedding
	 887  	// interface. See also issue #34421.
	 888  	//
	 889  	// If we don't care to provide this identity guarantee anymore, instead of
	 890  	// reusing the original method in embeddings, we can clone the method's Func
	 891  	// Object and give it the position of a corresponding embedded interface. Then
	 892  	// we can get rid of the mpos map below and simply use the cloned method's
	 893  	// position.
	 894  
	 895  	var seen objset
	 896  	var methods []*Func
	 897  	mpos := make(map[*Func]token.Pos) // method specification or method embedding position, for good error messages
	 898  	addMethod := func(pos token.Pos, m *Func, explicit bool) {
	 899  		switch other := seen.insert(m); {
	 900  		case other == nil:
	 901  			methods = append(methods, m)
	 902  			mpos[m] = pos
	 903  		case explicit:
	 904  			check.errorf(atPos(pos), _DuplicateDecl, "duplicate method %s", m.name)
	 905  			check.errorf(atPos(mpos[other.(*Func)]), _DuplicateDecl, "\tother declaration of %s", m.name) // secondary error, \t indented
	 906  		default:
	 907  			// We have a duplicate method name in an embedded (not explicitly declared) method.
	 908  			// Check method signatures after all types are computed (issue #33656).
	 909  			// If we're pre-go1.14 (overlapping embeddings are not permitted), report that
	 910  			// error here as well (even though we could do it eagerly) because it's the same
	 911  			// error message.
	 912  			check.later(func() {
	 913  				if !check.allowVersion(m.pkg, 1, 14) || !check.identical(m.typ, other.Type()) {
	 914  					check.errorf(atPos(pos), _DuplicateDecl, "duplicate method %s", m.name)
	 915  					check.errorf(atPos(mpos[other.(*Func)]), _DuplicateDecl, "\tother declaration of %s", m.name) // secondary error, \t indented
	 916  				}
	 917  			})
	 918  		}
	 919  	}
	 920  
	 921  	for _, m := range ityp.methods {
	 922  		addMethod(m.pos, m, true)
	 923  	}
	 924  
	 925  	// collect types
	 926  	allTypes := ityp.types
	 927  
	 928  	posList := check.posMap[ityp]
	 929  	for i, typ := range ityp.embeddeds {
	 930  		pos := posList[i] // embedding position
	 931  		utyp := under(typ)
	 932  		etyp := asInterface(utyp)
	 933  		if etyp == nil {
	 934  			if utyp != Typ[Invalid] {
	 935  				var format string
	 936  				if _, ok := utyp.(*_TypeParam); ok {
	 937  					format = "%s is a type parameter, not an interface"
	 938  				} else {
	 939  					format = "%s is not an interface"
	 940  				}
	 941  				// TODO: correct error code.
	 942  				check.errorf(atPos(pos), _InvalidIfaceEmbed, format, typ)
	 943  			}
	 944  			continue
	 945  		}
	 946  		check.completeInterface(pos, etyp)
	 947  		for _, m := range etyp.allMethods {
	 948  			addMethod(pos, m, false) // use embedding position pos rather than m.pos
	 949  		}
	 950  		allTypes = intersect(allTypes, etyp.allTypes)
	 951  	}
	 952  
	 953  	if methods != nil {
	 954  		sort.Sort(byUniqueMethodName(methods))
	 955  		ityp.allMethods = methods
	 956  	}
	 957  	ityp.allTypes = allTypes
	 958  }
	 959  
	 960  // intersect computes the intersection of the types x and y.
	 961  // Note: A incomming nil type stands for the top type. A top
	 962  // type result is returned as nil.
	 963  func intersect(x, y Type) (r Type) {
	 964  	defer func() {
	 965  		if r == theTop {
	 966  			r = nil
	 967  		}
	 968  	}()
	 969  
	 970  	switch {
	 971  	case x == theBottom || y == theBottom:
	 972  		return theBottom
	 973  	case x == nil || x == theTop:
	 974  		return y
	 975  	case y == nil || x == theTop:
	 976  		return x
	 977  	}
	 978  
	 979  	xtypes := unpackType(x)
	 980  	ytypes := unpackType(y)
	 981  	// Compute the list rtypes which includes only
	 982  	// types that are in both xtypes and ytypes.
	 983  	// Quadratic algorithm, but good enough for now.
	 984  	// TODO(gri) fix this
	 985  	var rtypes []Type
	 986  	for _, x := range xtypes {
	 987  		if includes(ytypes, x) {
	 988  			rtypes = append(rtypes, x)
	 989  		}
	 990  	}
	 991  
	 992  	if rtypes == nil {
	 993  		return theBottom
	 994  	}
	 995  	return _NewSum(rtypes)
	 996  }
	 997  
	 998  func sortTypes(list []Type) {
	 999  	sort.Stable(byUniqueTypeName(list))
	1000  }
	1001  
	1002  // byUniqueTypeName named type lists can be sorted by their unique type names.
	1003  type byUniqueTypeName []Type
	1004  
	1005  func (a byUniqueTypeName) Len() int					 { return len(a) }
	1006  func (a byUniqueTypeName) Less(i, j int) bool { return sortName(a[i]) < sortName(a[j]) }
	1007  func (a byUniqueTypeName) Swap(i, j int)			{ a[i], a[j] = a[j], a[i] }
	1008  
	1009  func sortName(t Type) string {
	1010  	if named := asNamed(t); named != nil {
	1011  		return named.obj.Id()
	1012  	}
	1013  	return ""
	1014  }
	1015  
	1016  func sortMethods(list []*Func) {
	1017  	sort.Sort(byUniqueMethodName(list))
	1018  }
	1019  
	1020  func assertSortedMethods(list []*Func) {
	1021  	if !debug {
	1022  		panic("internal error: assertSortedMethods called outside debug mode")
	1023  	}
	1024  	if !sort.IsSorted(byUniqueMethodName(list)) {
	1025  		panic("internal error: methods not sorted")
	1026  	}
	1027  }
	1028  
	1029  // byUniqueMethodName method lists can be sorted by their unique method names.
	1030  type byUniqueMethodName []*Func
	1031  
	1032  func (a byUniqueMethodName) Len() int					 { return len(a) }
	1033  func (a byUniqueMethodName) Less(i, j int) bool { return a[i].Id() < a[j].Id() }
	1034  func (a byUniqueMethodName) Swap(i, j int)			{ a[i], a[j] = a[j], a[i] }
	1035  
	1036  func (check *Checker) tag(t *ast.BasicLit) string {
	1037  	if t != nil {
	1038  		if t.Kind == token.STRING {
	1039  			if val, err := strconv.Unquote(t.Value); err == nil {
	1040  				return val
	1041  			}
	1042  		}
	1043  		check.invalidAST(t, "incorrect tag syntax: %q", t.Value)
	1044  	}
	1045  	return ""
	1046  }
	1047  
	1048  func (check *Checker) structType(styp *Struct, e *ast.StructType) {
	1049  	list := e.Fields
	1050  	if list == nil {
	1051  		return
	1052  	}
	1053  
	1054  	// struct fields and tags
	1055  	var fields []*Var
	1056  	var tags []string
	1057  
	1058  	// for double-declaration checks
	1059  	var fset objset
	1060  
	1061  	// current field typ and tag
	1062  	var typ Type
	1063  	var tag string
	1064  	add := func(ident *ast.Ident, embedded bool, pos token.Pos) {
	1065  		if tag != "" && tags == nil {
	1066  			tags = make([]string, len(fields))
	1067  		}
	1068  		if tags != nil {
	1069  			tags = append(tags, tag)
	1070  		}
	1071  
	1072  		name := ident.Name
	1073  		fld := NewField(pos, check.pkg, name, typ, embedded)
	1074  		// spec: "Within a struct, non-blank field names must be unique."
	1075  		if name == "_" || check.declareInSet(&fset, pos, fld) {
	1076  			fields = append(fields, fld)
	1077  			check.recordDef(ident, fld)
	1078  		}
	1079  	}
	1080  
	1081  	// addInvalid adds an embedded field of invalid type to the struct for
	1082  	// fields with errors; this keeps the number of struct fields in sync
	1083  	// with the source as long as the fields are _ or have different names
	1084  	// (issue #25627).
	1085  	addInvalid := func(ident *ast.Ident, pos token.Pos) {
	1086  		typ = Typ[Invalid]
	1087  		tag = ""
	1088  		add(ident, true, pos)
	1089  	}
	1090  
	1091  	for _, f := range list.List {
	1092  		typ = check.varType(f.Type)
	1093  		tag = check.tag(f.Tag)
	1094  		if len(f.Names) > 0 {
	1095  			// named fields
	1096  			for _, name := range f.Names {
	1097  				add(name, false, name.Pos())
	1098  			}
	1099  		} else {
	1100  			// embedded field
	1101  			// spec: "An embedded type must be specified as a type name T or as a
	1102  			// pointer to a non-interface type name *T, and T itself may not be a
	1103  			// pointer type."
	1104  			pos := f.Type.Pos()
	1105  			name := embeddedFieldIdent(f.Type)
	1106  			if name == nil {
	1107  				// TODO(rFindley): using invalidAST here causes test failures (all
	1108  				//								 errors should have codes). Clean this up.
	1109  				check.errorf(f.Type, _Todo, "invalid AST: embedded field type %s has no name", f.Type)
	1110  				name = ast.NewIdent("_")
	1111  				name.NamePos = pos
	1112  				addInvalid(name, pos)
	1113  				continue
	1114  			}
	1115  			add(name, true, pos)
	1116  
	1117  			// Because we have a name, typ must be of the form T or *T, where T is the name
	1118  			// of a (named or alias) type, and t (= deref(typ)) must be the type of T.
	1119  			// We must delay this check to the end because we don't want to instantiate
	1120  			// (via under(t)) a possibly incomplete type.
	1121  
	1122  			// for use in the closure below
	1123  			embeddedTyp := typ
	1124  			embeddedPos := f.Type
	1125  
	1126  			check.later(func() {
	1127  				t, isPtr := deref(embeddedTyp)
	1128  				switch t := optype(t).(type) {
	1129  				case *Basic:
	1130  					if t == Typ[Invalid] {
	1131  						// error was reported before
	1132  						return
	1133  					}
	1134  					// unsafe.Pointer is treated like a regular pointer
	1135  					if t.kind == UnsafePointer {
	1136  						check.errorf(embeddedPos, _InvalidPtrEmbed, "embedded field type cannot be unsafe.Pointer")
	1137  					}
	1138  				case *Pointer:
	1139  					check.errorf(embeddedPos, _InvalidPtrEmbed, "embedded field type cannot be a pointer")
	1140  				case *Interface:
	1141  					if isPtr {
	1142  						check.errorf(embeddedPos, _InvalidPtrEmbed, "embedded field type cannot be a pointer to an interface")
	1143  					}
	1144  				}
	1145  			})
	1146  		}
	1147  	}
	1148  
	1149  	styp.fields = fields
	1150  	styp.tags = tags
	1151  }
	1152  
	1153  func embeddedFieldIdent(e ast.Expr) *ast.Ident {
	1154  	switch e := e.(type) {
	1155  	case *ast.Ident:
	1156  		return e
	1157  	case *ast.StarExpr:
	1158  		// *T is valid, but **T is not
	1159  		if _, ok := e.X.(*ast.StarExpr); !ok {
	1160  			return embeddedFieldIdent(e.X)
	1161  		}
	1162  	case *ast.SelectorExpr:
	1163  		return e.Sel
	1164  	case *ast.IndexExpr:
	1165  		return embeddedFieldIdent(e.X)
	1166  	}
	1167  	return nil // invalid embedded field
	1168  }
	1169  
	1170  func (check *Checker) collectTypeConstraints(pos token.Pos, types []ast.Expr) []Type {
	1171  	list := make([]Type, 0, len(types)) // assume all types are correct
	1172  	for _, texpr := range types {
	1173  		if texpr == nil {
	1174  			check.invalidAST(atPos(pos), "missing type constraint")
	1175  			continue
	1176  		}
	1177  		list = append(list, check.varType(texpr))
	1178  	}
	1179  
	1180  	// Ensure that each type is only present once in the type list.	Types may be
	1181  	// interfaces, which may not be complete yet. It's ok to do this check at the
	1182  	// end because it's not a requirement for correctness of the code.
	1183  	// Note: This is a quadratic algorithm, but type lists tend to be short.
	1184  	check.later(func() {
	1185  		for i, t := range list {
	1186  			if t := asInterface(t); t != nil {
	1187  				check.completeInterface(types[i].Pos(), t)
	1188  			}
	1189  			if includes(list[:i], t) {
	1190  				check.softErrorf(types[i], _Todo, "duplicate type %s in type list", t)
	1191  			}
	1192  		}
	1193  	})
	1194  
	1195  	return list
	1196  }
	1197  
	1198  // includes reports whether typ is in list.
	1199  func includes(list []Type, typ Type) bool {
	1200  	for _, e := range list {
	1201  		if Identical(typ, e) {
	1202  			return true
	1203  		}
	1204  	}
	1205  	return false
	1206  }
	1207  

View as plain text