builtins.go

Documentation: go/types

		 1  // Copyright 2012 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 typechecking of builtin function calls.
		 6  
		 7  package types
		 8  
		 9  import (
		10  	"go/ast"
		11  	"go/constant"
		12  	"go/token"
		13  )
		14  
		15  // builtin type-checks a call to the built-in specified by id and
		16  // reports whether the call is valid, with *x holding the result;
		17  // but x.expr is not set. If the call is invalid, the result is
		18  // false, and *x is undefined.
		19  //
		20  func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ bool) {
		21  	// append is the only built-in that permits the use of ... for the last argument
		22  	bin := predeclaredFuncs[id]
		23  	if call.Ellipsis.IsValid() && id != _Append {
		24  		check.invalidOp(atPos(call.Ellipsis),
		25  			_InvalidDotDotDot,
		26  			"invalid use of ... with built-in %s", bin.name)
		27  		check.use(call.Args...)
		28  		return
		29  	}
		30  
		31  	// For len(x) and cap(x) we need to know if x contains any function calls or
		32  	// receive operations. Save/restore current setting and set hasCallOrRecv to
		33  	// false for the evaluation of x so that we can check it afterwards.
		34  	// Note: We must do this _before_ calling exprList because exprList evaluates
		35  	//			 all arguments.
		36  	if id == _Len || id == _Cap {
		37  		defer func(b bool) {
		38  			check.hasCallOrRecv = b
		39  		}(check.hasCallOrRecv)
		40  		check.hasCallOrRecv = false
		41  	}
		42  
		43  	// determine actual arguments
		44  	var arg func(*operand, int) // TODO(gri) remove use of arg getter in favor of using xlist directly
		45  	nargs := len(call.Args)
		46  	switch id {
		47  	default:
		48  		// make argument getter
		49  		xlist, _ := check.exprList(call.Args, false)
		50  		arg = func(x *operand, i int) { *x = *xlist[i]; x.typ = expand(x.typ) }
		51  		nargs = len(xlist)
		52  		// evaluate first argument, if present
		53  		if nargs > 0 {
		54  			arg(x, 0)
		55  			if x.mode == invalid {
		56  				return
		57  			}
		58  		}
		59  	case _Make, _New, _Offsetof, _Trace:
		60  		// arguments require special handling
		61  	}
		62  
		63  	// check argument count
		64  	{
		65  		msg := ""
		66  		if nargs < bin.nargs {
		67  			msg = "not enough"
		68  		} else if !bin.variadic && nargs > bin.nargs {
		69  			msg = "too many"
		70  		}
		71  		if msg != "" {
		72  			check.invalidOp(inNode(call, call.Rparen), _WrongArgCount, "%s arguments for %s (expected %d, found %d)", msg, call, bin.nargs, nargs)
		73  			return
		74  		}
		75  	}
		76  
		77  	switch id {
		78  	case _Append:
		79  		// append(s S, x ...T) S, where T is the element type of S
		80  		// spec: "The variadic function append appends zero or more values x to s of type
		81  		// S, which must be a slice type, and returns the resulting slice, also of type S.
		82  		// The values x are passed to a parameter of type ...T where T is the element type
		83  		// of S and the respective parameter passing rules apply."
		84  		S := x.typ
		85  		var T Type
		86  		if s := asSlice(S); s != nil {
		87  			T = s.elem
		88  		} else {
		89  			check.invalidArg(x, _InvalidAppend, "%s is not a slice", x)
		90  			return
		91  		}
		92  
		93  		// remember arguments that have been evaluated already
		94  		alist := []operand{*x}
		95  
		96  		// spec: "As a special case, append also accepts a first argument assignable
		97  		// to type []byte with a second argument of string type followed by ... .
		98  		// This form appends the bytes of the string.
		99  		if nargs == 2 && call.Ellipsis.IsValid() {
	 100  			if ok, _ := x.assignableTo(check, NewSlice(universeByte), nil); ok {
	 101  				arg(x, 1)
	 102  				if x.mode == invalid {
	 103  					return
	 104  				}
	 105  				if isString(x.typ) {
	 106  					if check.Types != nil {
	 107  						sig := makeSig(S, S, x.typ)
	 108  						sig.variadic = true
	 109  						check.recordBuiltinType(call.Fun, sig)
	 110  					}
	 111  					x.mode = value
	 112  					x.typ = S
	 113  					break
	 114  				}
	 115  				alist = append(alist, *x)
	 116  				// fallthrough
	 117  			}
	 118  		}
	 119  
	 120  		// check general case by creating custom signature
	 121  		sig := makeSig(S, S, NewSlice(T)) // []T required for variadic signature
	 122  		sig.variadic = true
	 123  		var xlist []*operand
	 124  		// convert []operand to []*operand
	 125  		for i := range alist {
	 126  			xlist = append(xlist, &alist[i])
	 127  		}
	 128  		for i := len(alist); i < nargs; i++ {
	 129  			var x operand
	 130  			arg(&x, i)
	 131  			xlist = append(xlist, &x)
	 132  		}
	 133  		check.arguments(call, sig, nil, xlist) // discard result (we know the result type)
	 134  		// ok to continue even if check.arguments reported errors
	 135  
	 136  		x.mode = value
	 137  		x.typ = S
	 138  		if check.Types != nil {
	 139  			check.recordBuiltinType(call.Fun, sig)
	 140  		}
	 141  
	 142  	case _Cap, _Len:
	 143  		// cap(x)
	 144  		// len(x)
	 145  		mode := invalid
	 146  		var typ Type
	 147  		var val constant.Value
	 148  		switch typ = implicitArrayDeref(optype(x.typ)); t := typ.(type) {
	 149  		case *Basic:
	 150  			if isString(t) && id == _Len {
	 151  				if x.mode == constant_ {
	 152  					mode = constant_
	 153  					val = constant.MakeInt64(int64(len(constant.StringVal(x.val))))
	 154  				} else {
	 155  					mode = value
	 156  				}
	 157  			}
	 158  
	 159  		case *Array:
	 160  			mode = value
	 161  			// spec: "The expressions len(s) and cap(s) are constants
	 162  			// if the type of s is an array or pointer to an array and
	 163  			// the expression s does not contain channel receives or
	 164  			// function calls; in this case s is not evaluated."
	 165  			if !check.hasCallOrRecv {
	 166  				mode = constant_
	 167  				if t.len >= 0 {
	 168  					val = constant.MakeInt64(t.len)
	 169  				} else {
	 170  					val = constant.MakeUnknown()
	 171  				}
	 172  			}
	 173  
	 174  		case *Slice, *Chan:
	 175  			mode = value
	 176  
	 177  		case *Map:
	 178  			if id == _Len {
	 179  				mode = value
	 180  			}
	 181  
	 182  		case *_Sum:
	 183  			if t.is(func(t Type) bool {
	 184  				switch t := under(t).(type) {
	 185  				case *Basic:
	 186  					if isString(t) && id == _Len {
	 187  						return true
	 188  					}
	 189  				case *Array, *Slice, *Chan:
	 190  					return true
	 191  				case *Map:
	 192  					if id == _Len {
	 193  						return true
	 194  					}
	 195  				}
	 196  				return false
	 197  			}) {
	 198  				mode = value
	 199  			}
	 200  		}
	 201  
	 202  		if mode == invalid && typ != Typ[Invalid] {
	 203  			code := _InvalidCap
	 204  			if id == _Len {
	 205  				code = _InvalidLen
	 206  			}
	 207  			check.invalidArg(x, code, "%s for %s", x, bin.name)
	 208  			return
	 209  		}
	 210  
	 211  		x.mode = mode
	 212  		x.typ = Typ[Int]
	 213  		x.val = val
	 214  		if check.Types != nil && mode != constant_ {
	 215  			check.recordBuiltinType(call.Fun, makeSig(x.typ, typ))
	 216  		}
	 217  
	 218  	case _Close:
	 219  		// close(c)
	 220  		c := asChan(x.typ)
	 221  		if c == nil {
	 222  			check.invalidArg(x, _InvalidClose, "%s is not a channel", x)
	 223  			return
	 224  		}
	 225  		if c.dir == RecvOnly {
	 226  			check.invalidArg(x, _InvalidClose, "%s must not be a receive-only channel", x)
	 227  			return
	 228  		}
	 229  
	 230  		x.mode = novalue
	 231  		if check.Types != nil {
	 232  			check.recordBuiltinType(call.Fun, makeSig(nil, c))
	 233  		}
	 234  
	 235  	case _Complex:
	 236  		// complex(x, y floatT) complexT
	 237  		var y operand
	 238  		arg(&y, 1)
	 239  		if y.mode == invalid {
	 240  			return
	 241  		}
	 242  
	 243  		// convert or check untyped arguments
	 244  		d := 0
	 245  		if isUntyped(x.typ) {
	 246  			d |= 1
	 247  		}
	 248  		if isUntyped(y.typ) {
	 249  			d |= 2
	 250  		}
	 251  		switch d {
	 252  		case 0:
	 253  			// x and y are typed => nothing to do
	 254  		case 1:
	 255  			// only x is untyped => convert to type of y
	 256  			check.convertUntyped(x, y.typ)
	 257  		case 2:
	 258  			// only y is untyped => convert to type of x
	 259  			check.convertUntyped(&y, x.typ)
	 260  		case 3:
	 261  			// x and y are untyped =>
	 262  			// 1) if both are constants, convert them to untyped
	 263  			//		floating-point numbers if possible,
	 264  			// 2) if one of them is not constant (possible because
	 265  			//		it contains a shift that is yet untyped), convert
	 266  			//		both of them to float64 since they must have the
	 267  			//		same type to succeed (this will result in an error
	 268  			//		because shifts of floats are not permitted)
	 269  			if x.mode == constant_ && y.mode == constant_ {
	 270  				toFloat := func(x *operand) {
	 271  					if isNumeric(x.typ) && constant.Sign(constant.Imag(x.val)) == 0 {
	 272  						x.typ = Typ[UntypedFloat]
	 273  					}
	 274  				}
	 275  				toFloat(x)
	 276  				toFloat(&y)
	 277  			} else {
	 278  				check.convertUntyped(x, Typ[Float64])
	 279  				check.convertUntyped(&y, Typ[Float64])
	 280  				// x and y should be invalid now, but be conservative
	 281  				// and check below
	 282  			}
	 283  		}
	 284  		if x.mode == invalid || y.mode == invalid {
	 285  			return
	 286  		}
	 287  
	 288  		// both argument types must be identical
	 289  		if !check.identical(x.typ, y.typ) {
	 290  			check.invalidArg(x, _InvalidComplex, "mismatched types %s and %s", x.typ, y.typ)
	 291  			return
	 292  		}
	 293  
	 294  		// the argument types must be of floating-point type
	 295  		f := func(x Type) Type {
	 296  			if t := asBasic(x); t != nil {
	 297  				switch t.kind {
	 298  				case Float32:
	 299  					return Typ[Complex64]
	 300  				case Float64:
	 301  					return Typ[Complex128]
	 302  				case UntypedFloat:
	 303  					return Typ[UntypedComplex]
	 304  				}
	 305  			}
	 306  			return nil
	 307  		}
	 308  		resTyp := check.applyTypeFunc(f, x.typ)
	 309  		if resTyp == nil {
	 310  			check.invalidArg(x, _InvalidComplex, "arguments have type %s, expected floating-point", x.typ)
	 311  			return
	 312  		}
	 313  
	 314  		// if both arguments are constants, the result is a constant
	 315  		if x.mode == constant_ && y.mode == constant_ {
	 316  			x.val = constant.BinaryOp(constant.ToFloat(x.val), token.ADD, constant.MakeImag(constant.ToFloat(y.val)))
	 317  		} else {
	 318  			x.mode = value
	 319  		}
	 320  
	 321  		if check.Types != nil && x.mode != constant_ {
	 322  			check.recordBuiltinType(call.Fun, makeSig(resTyp, x.typ, x.typ))
	 323  		}
	 324  
	 325  		x.typ = resTyp
	 326  
	 327  	case _Copy:
	 328  		// copy(x, y []T) int
	 329  		var dst Type
	 330  		if t := asSlice(x.typ); t != nil {
	 331  			dst = t.elem
	 332  		}
	 333  
	 334  		var y operand
	 335  		arg(&y, 1)
	 336  		if y.mode == invalid {
	 337  			return
	 338  		}
	 339  		var src Type
	 340  		switch t := optype(y.typ).(type) {
	 341  		case *Basic:
	 342  			if isString(y.typ) {
	 343  				src = universeByte
	 344  			}
	 345  		case *Slice:
	 346  			src = t.elem
	 347  		}
	 348  
	 349  		if dst == nil || src == nil {
	 350  			check.invalidArg(x, _InvalidCopy, "copy expects slice arguments; found %s and %s", x, &y)
	 351  			return
	 352  		}
	 353  
	 354  		if !check.identical(dst, src) {
	 355  			check.invalidArg(x, _InvalidCopy, "arguments to copy %s and %s have different element types %s and %s", x, &y, dst, src)
	 356  			return
	 357  		}
	 358  
	 359  		if check.Types != nil {
	 360  			check.recordBuiltinType(call.Fun, makeSig(Typ[Int], x.typ, y.typ))
	 361  		}
	 362  		x.mode = value
	 363  		x.typ = Typ[Int]
	 364  
	 365  	case _Delete:
	 366  		// delete(m, k)
	 367  		m := asMap(x.typ)
	 368  		if m == nil {
	 369  			check.invalidArg(x, _InvalidDelete, "%s is not a map", x)
	 370  			return
	 371  		}
	 372  		arg(x, 1) // k
	 373  		if x.mode == invalid {
	 374  			return
	 375  		}
	 376  
	 377  		check.assignment(x, m.key, "argument to delete")
	 378  		if x.mode == invalid {
	 379  			return
	 380  		}
	 381  
	 382  		x.mode = novalue
	 383  		if check.Types != nil {
	 384  			check.recordBuiltinType(call.Fun, makeSig(nil, m, m.key))
	 385  		}
	 386  
	 387  	case _Imag, _Real:
	 388  		// imag(complexT) floatT
	 389  		// real(complexT) floatT
	 390  
	 391  		// convert or check untyped argument
	 392  		if isUntyped(x.typ) {
	 393  			if x.mode == constant_ {
	 394  				// an untyped constant number can always be considered
	 395  				// as a complex constant
	 396  				if isNumeric(x.typ) {
	 397  					x.typ = Typ[UntypedComplex]
	 398  				}
	 399  			} else {
	 400  				// an untyped non-constant argument may appear if
	 401  				// it contains a (yet untyped non-constant) shift
	 402  				// expression: convert it to complex128 which will
	 403  				// result in an error (shift of complex value)
	 404  				check.convertUntyped(x, Typ[Complex128])
	 405  				// x should be invalid now, but be conservative and check
	 406  				if x.mode == invalid {
	 407  					return
	 408  				}
	 409  			}
	 410  		}
	 411  
	 412  		// the argument must be of complex type
	 413  		f := func(x Type) Type {
	 414  			if t := asBasic(x); t != nil {
	 415  				switch t.kind {
	 416  				case Complex64:
	 417  					return Typ[Float32]
	 418  				case Complex128:
	 419  					return Typ[Float64]
	 420  				case UntypedComplex:
	 421  					return Typ[UntypedFloat]
	 422  				}
	 423  			}
	 424  			return nil
	 425  		}
	 426  		resTyp := check.applyTypeFunc(f, x.typ)
	 427  		if resTyp == nil {
	 428  			code := _InvalidImag
	 429  			if id == _Real {
	 430  				code = _InvalidReal
	 431  			}
	 432  			check.invalidArg(x, code, "argument has type %s, expected complex type", x.typ)
	 433  			return
	 434  		}
	 435  
	 436  		// if the argument is a constant, the result is a constant
	 437  		if x.mode == constant_ {
	 438  			if id == _Real {
	 439  				x.val = constant.Real(x.val)
	 440  			} else {
	 441  				x.val = constant.Imag(x.val)
	 442  			}
	 443  		} else {
	 444  			x.mode = value
	 445  		}
	 446  
	 447  		if check.Types != nil && x.mode != constant_ {
	 448  			check.recordBuiltinType(call.Fun, makeSig(resTyp, x.typ))
	 449  		}
	 450  
	 451  		x.typ = resTyp
	 452  
	 453  	case _Make:
	 454  		// make(T, n)
	 455  		// make(T, n, m)
	 456  		// (no argument evaluated yet)
	 457  		arg0 := call.Args[0]
	 458  		T := check.varType(arg0)
	 459  		if T == Typ[Invalid] {
	 460  			return
	 461  		}
	 462  
	 463  		min, max := -1, 10
	 464  		var valid func(t Type) bool
	 465  		valid = func(t Type) bool {
	 466  			var m int
	 467  			switch t := optype(t).(type) {
	 468  			case *Slice:
	 469  				m = 2
	 470  			case *Map, *Chan:
	 471  				m = 1
	 472  			case *_Sum:
	 473  				return t.is(valid)
	 474  			default:
	 475  				return false
	 476  			}
	 477  			if m > min {
	 478  				min = m
	 479  			}
	 480  			if m+1 < max {
	 481  				max = m + 1
	 482  			}
	 483  			return true
	 484  		}
	 485  
	 486  		if !valid(T) {
	 487  			check.invalidArg(arg0, _InvalidMake, "cannot make %s; type must be slice, map, or channel", arg0)
	 488  			return
	 489  		}
	 490  		if nargs < min || max < nargs {
	 491  			if min == max {
	 492  				check.errorf(call, _WrongArgCount, "%v expects %d arguments; found %d", call, min, nargs)
	 493  			} else {
	 494  				check.errorf(call, _WrongArgCount, "%v expects %d or %d arguments; found %d", call, min, max, nargs)
	 495  			}
	 496  			return
	 497  		}
	 498  
	 499  		types := []Type{T}
	 500  		var sizes []int64 // constant integer arguments, if any
	 501  		for _, arg := range call.Args[1:] {
	 502  			typ, size := check.index(arg, -1) // ok to continue with typ == Typ[Invalid]
	 503  			types = append(types, typ)
	 504  			if size >= 0 {
	 505  				sizes = append(sizes, size)
	 506  			}
	 507  		}
	 508  		if len(sizes) == 2 && sizes[0] > sizes[1] {
	 509  			check.invalidArg(call.Args[1], _SwappedMakeArgs, "length and capacity swapped")
	 510  			// safe to continue
	 511  		}
	 512  		x.mode = value
	 513  		x.typ = T
	 514  		if check.Types != nil {
	 515  			check.recordBuiltinType(call.Fun, makeSig(x.typ, types...))
	 516  		}
	 517  
	 518  	case _New:
	 519  		// new(T)
	 520  		// (no argument evaluated yet)
	 521  		T := check.varType(call.Args[0])
	 522  		if T == Typ[Invalid] {
	 523  			return
	 524  		}
	 525  
	 526  		x.mode = value
	 527  		x.typ = &Pointer{base: T}
	 528  		if check.Types != nil {
	 529  			check.recordBuiltinType(call.Fun, makeSig(x.typ, T))
	 530  		}
	 531  
	 532  	case _Panic:
	 533  		// panic(x)
	 534  		// record panic call if inside a function with result parameters
	 535  		// (for use in Checker.isTerminating)
	 536  		if check.sig != nil && check.sig.results.Len() > 0 {
	 537  			// function has result parameters
	 538  			p := check.isPanic
	 539  			if p == nil {
	 540  				// allocate lazily
	 541  				p = make(map[*ast.CallExpr]bool)
	 542  				check.isPanic = p
	 543  			}
	 544  			p[call] = true
	 545  		}
	 546  
	 547  		check.assignment(x, &emptyInterface, "argument to panic")
	 548  		if x.mode == invalid {
	 549  			return
	 550  		}
	 551  
	 552  		x.mode = novalue
	 553  		if check.Types != nil {
	 554  			check.recordBuiltinType(call.Fun, makeSig(nil, &emptyInterface))
	 555  		}
	 556  
	 557  	case _Print, _Println:
	 558  		// print(x, y, ...)
	 559  		// println(x, y, ...)
	 560  		var params []Type
	 561  		if nargs > 0 {
	 562  			params = make([]Type, nargs)
	 563  			for i := 0; i < nargs; i++ {
	 564  				if i > 0 {
	 565  					arg(x, i) // first argument already evaluated
	 566  				}
	 567  				check.assignment(x, nil, "argument to "+predeclaredFuncs[id].name)
	 568  				if x.mode == invalid {
	 569  					// TODO(gri) "use" all arguments?
	 570  					return
	 571  				}
	 572  				params[i] = x.typ
	 573  			}
	 574  		}
	 575  
	 576  		x.mode = novalue
	 577  		if check.Types != nil {
	 578  			check.recordBuiltinType(call.Fun, makeSig(nil, params...))
	 579  		}
	 580  
	 581  	case _Recover:
	 582  		// recover() interface{}
	 583  		x.mode = value
	 584  		x.typ = &emptyInterface
	 585  		if check.Types != nil {
	 586  			check.recordBuiltinType(call.Fun, makeSig(x.typ))
	 587  		}
	 588  
	 589  	case _Add:
	 590  		// unsafe.Add(ptr unsafe.Pointer, len IntegerType) unsafe.Pointer
	 591  		if !check.allowVersion(check.pkg, 1, 17) {
	 592  			check.errorf(call.Fun, _InvalidUnsafeAdd, "unsafe.Add requires go1.17 or later")
	 593  			return
	 594  		}
	 595  
	 596  		check.assignment(x, Typ[UnsafePointer], "argument to unsafe.Add")
	 597  		if x.mode == invalid {
	 598  			return
	 599  		}
	 600  
	 601  		var y operand
	 602  		arg(&y, 1)
	 603  		if !check.isValidIndex(&y, _InvalidUnsafeAdd, "length", true) {
	 604  			return
	 605  		}
	 606  
	 607  		x.mode = value
	 608  		x.typ = Typ[UnsafePointer]
	 609  		if check.Types != nil {
	 610  			check.recordBuiltinType(call.Fun, makeSig(x.typ, x.typ, y.typ))
	 611  		}
	 612  
	 613  	case _Alignof:
	 614  		// unsafe.Alignof(x T) uintptr
	 615  		if asTypeParam(x.typ) != nil {
	 616  			check.invalidOp(call, _Todo, "unsafe.Alignof undefined for %s", x)
	 617  			return
	 618  		}
	 619  		check.assignment(x, nil, "argument to unsafe.Alignof")
	 620  		if x.mode == invalid {
	 621  			return
	 622  		}
	 623  
	 624  		x.mode = constant_
	 625  		x.val = constant.MakeInt64(check.conf.alignof(x.typ))
	 626  		x.typ = Typ[Uintptr]
	 627  		// result is constant - no need to record signature
	 628  
	 629  	case _Offsetof:
	 630  		// unsafe.Offsetof(x T) uintptr, where x must be a selector
	 631  		// (no argument evaluated yet)
	 632  		arg0 := call.Args[0]
	 633  		selx, _ := unparen(arg0).(*ast.SelectorExpr)
	 634  		if selx == nil {
	 635  			check.invalidArg(arg0, _BadOffsetofSyntax, "%s is not a selector expression", arg0)
	 636  			check.use(arg0)
	 637  			return
	 638  		}
	 639  
	 640  		check.expr(x, selx.X)
	 641  		if x.mode == invalid {
	 642  			return
	 643  		}
	 644  
	 645  		base := derefStructPtr(x.typ)
	 646  		sel := selx.Sel.Name
	 647  		obj, index, indirect := check.lookupFieldOrMethod(base, false, check.pkg, sel)
	 648  		switch obj.(type) {
	 649  		case nil:
	 650  			check.invalidArg(x, _MissingFieldOrMethod, "%s has no single field %s", base, sel)
	 651  			return
	 652  		case *Func:
	 653  			// TODO(gri) Using derefStructPtr may result in methods being found
	 654  			// that don't actually exist. An error either way, but the error
	 655  			// message is confusing. See: https://play.golang.org/p/al75v23kUy ,
	 656  			// but go/types reports: "invalid argument: x.m is a method value".
	 657  			check.invalidArg(arg0, _InvalidOffsetof, "%s is a method value", arg0)
	 658  			return
	 659  		}
	 660  		if indirect {
	 661  			check.invalidArg(x, _InvalidOffsetof, "field %s is embedded via a pointer in %s", sel, base)
	 662  			return
	 663  		}
	 664  
	 665  		// TODO(gri) Should we pass x.typ instead of base (and indirect report if derefStructPtr indirected)?
	 666  		check.recordSelection(selx, FieldVal, base, obj, index, false)
	 667  
	 668  		offs := check.conf.offsetof(base, index)
	 669  		x.mode = constant_
	 670  		x.val = constant.MakeInt64(offs)
	 671  		x.typ = Typ[Uintptr]
	 672  		// result is constant - no need to record signature
	 673  
	 674  	case _Sizeof:
	 675  		// unsafe.Sizeof(x T) uintptr
	 676  		if asTypeParam(x.typ) != nil {
	 677  			check.invalidOp(call, _Todo, "unsafe.Sizeof undefined for %s", x)
	 678  			return
	 679  		}
	 680  		check.assignment(x, nil, "argument to unsafe.Sizeof")
	 681  		if x.mode == invalid {
	 682  			return
	 683  		}
	 684  
	 685  		x.mode = constant_
	 686  		x.val = constant.MakeInt64(check.conf.sizeof(x.typ))
	 687  		x.typ = Typ[Uintptr]
	 688  		// result is constant - no need to record signature
	 689  
	 690  	case _Slice:
	 691  		// unsafe.Slice(ptr *T, len IntegerType) []T
	 692  		if !check.allowVersion(check.pkg, 1, 17) {
	 693  			check.errorf(call.Fun, _InvalidUnsafeSlice, "unsafe.Slice requires go1.17 or later")
	 694  			return
	 695  		}
	 696  
	 697  		typ := asPointer(x.typ)
	 698  		if typ == nil {
	 699  			check.invalidArg(x, _InvalidUnsafeSlice, "%s is not a pointer", x)
	 700  			return
	 701  		}
	 702  
	 703  		var y operand
	 704  		arg(&y, 1)
	 705  		if !check.isValidIndex(&y, _InvalidUnsafeSlice, "length", false) {
	 706  			return
	 707  		}
	 708  
	 709  		x.mode = value
	 710  		x.typ = NewSlice(typ.base)
	 711  		if check.Types != nil {
	 712  			check.recordBuiltinType(call.Fun, makeSig(x.typ, typ, y.typ))
	 713  		}
	 714  
	 715  	case _Assert:
	 716  		// assert(pred) causes a typechecker error if pred is false.
	 717  		// The result of assert is the value of pred if there is no error.
	 718  		// Note: assert is only available in self-test mode.
	 719  		if x.mode != constant_ || !isBoolean(x.typ) {
	 720  			check.invalidArg(x, _Test, "%s is not a boolean constant", x)
	 721  			return
	 722  		}
	 723  		if x.val.Kind() != constant.Bool {
	 724  			check.errorf(x, _Test, "internal error: value of %s should be a boolean constant", x)
	 725  			return
	 726  		}
	 727  		if !constant.BoolVal(x.val) {
	 728  			check.errorf(call, _Test, "%v failed", call)
	 729  			// compile-time assertion failure - safe to continue
	 730  		}
	 731  		// result is constant - no need to record signature
	 732  
	 733  	case _Trace:
	 734  		// trace(x, y, z, ...) dumps the positions, expressions, and
	 735  		// values of its arguments. The result of trace is the value
	 736  		// of the first argument.
	 737  		// Note: trace is only available in self-test mode.
	 738  		// (no argument evaluated yet)
	 739  		if nargs == 0 {
	 740  			check.dump("%v: trace() without arguments", call.Pos())
	 741  			x.mode = novalue
	 742  			break
	 743  		}
	 744  		var t operand
	 745  		x1 := x
	 746  		for _, arg := range call.Args {
	 747  			check.rawExpr(x1, arg, nil) // permit trace for types, e.g.: new(trace(T))
	 748  			check.dump("%v: %s", x1.Pos(), x1)
	 749  			x1 = &t // use incoming x only for first argument
	 750  		}
	 751  		// trace is only available in test mode - no need to record signature
	 752  
	 753  	default:
	 754  		unreachable()
	 755  	}
	 756  
	 757  	return true
	 758  }
	 759  
	 760  // applyTypeFunc applies f to x. If x is a type parameter,
	 761  // the result is a type parameter constrained by an new
	 762  // interface bound. The type bounds for that interface
	 763  // are computed by applying f to each of the type bounds
	 764  // of x. If any of these applications of f return nil,
	 765  // applyTypeFunc returns nil.
	 766  // If x is not a type parameter, the result is f(x).
	 767  func (check *Checker) applyTypeFunc(f func(Type) Type, x Type) Type {
	 768  	if tp := asTypeParam(x); tp != nil {
	 769  		// Test if t satisfies the requirements for the argument
	 770  		// type and collect possible result types at the same time.
	 771  		var rtypes []Type
	 772  		if !tp.Bound().is(func(x Type) bool {
	 773  			if r := f(x); r != nil {
	 774  				rtypes = append(rtypes, r)
	 775  				return true
	 776  			}
	 777  			return false
	 778  		}) {
	 779  			return nil
	 780  		}
	 781  
	 782  		// construct a suitable new type parameter
	 783  		tpar := NewTypeName(token.NoPos, nil /* = Universe pkg */, "<type parameter>", nil)
	 784  		ptyp := check.newTypeParam(tpar, 0, &emptyInterface) // assigns type to tpar as a side-effect
	 785  		tsum := _NewSum(rtypes)
	 786  		ptyp.bound = &Interface{types: tsum, allMethods: markComplete, allTypes: tsum}
	 787  
	 788  		return ptyp
	 789  	}
	 790  
	 791  	return f(x)
	 792  }
	 793  
	 794  // makeSig makes a signature for the given argument and result types.
	 795  // Default types are used for untyped arguments, and res may be nil.
	 796  func makeSig(res Type, args ...Type) *Signature {
	 797  	list := make([]*Var, len(args))
	 798  	for i, param := range args {
	 799  		list[i] = NewVar(token.NoPos, nil, "", Default(param))
	 800  	}
	 801  	params := NewTuple(list...)
	 802  	var result *Tuple
	 803  	if res != nil {
	 804  		assert(!isUntyped(res))
	 805  		result = NewTuple(NewVar(token.NoPos, nil, "", res))
	 806  	}
	 807  	return &Signature{params: params, results: result}
	 808  }
	 809  
	 810  // implicitArrayDeref returns A if typ is of the form *A and A is an array;
	 811  // otherwise it returns typ.
	 812  //
	 813  func implicitArrayDeref(typ Type) Type {
	 814  	if p, ok := typ.(*Pointer); ok {
	 815  		if a := asArray(p.base); a != nil {
	 816  			return a
	 817  		}
	 818  	}
	 819  	return typ
	 820  }
	 821  
	 822  // unparen returns e with any enclosing parentheses stripped.
	 823  func unparen(e ast.Expr) ast.Expr {
	 824  	for {
	 825  		p, ok := e.(*ast.ParenExpr)
	 826  		if !ok {
	 827  			return e
	 828  		}
	 829  		e = p.X
	 830  	}
	 831  }
	 832
View as plain text