mirror of https://go.googlesource.com/go
1039 lines
27 KiB
Go
1039 lines
27 KiB
Go
// Code generated by "go test -run=Generate -write=all"; DO NOT EDIT.
|
|
// Source: ../../cmd/compile/internal/types2/builtins.go
|
|
|
|
// Copyright 2012 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// This file implements typechecking of builtin function calls.
|
|
|
|
package types
|
|
|
|
import (
|
|
"go/ast"
|
|
"go/constant"
|
|
"go/token"
|
|
. "internal/types/errors"
|
|
)
|
|
|
|
// builtin type-checks a call to the built-in specified by id and
|
|
// reports whether the call is valid, with *x holding the result;
|
|
// but x.expr is not set. If the call is invalid, the result is
|
|
// false, and *x is undefined.
|
|
func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ bool) {
|
|
argList := call.Args
|
|
|
|
// append is the only built-in that permits the use of ... for the last argument
|
|
bin := predeclaredFuncs[id]
|
|
if hasDots(call) && id != _Append {
|
|
check.errorf(dddErrPos(call),
|
|
InvalidDotDotDot,
|
|
invalidOp+"invalid use of ... with built-in %s", bin.name)
|
|
check.use(argList...)
|
|
return
|
|
}
|
|
|
|
// For len(x) and cap(x) we need to know if x contains any function calls or
|
|
// receive operations. Save/restore current setting and set hasCallOrRecv to
|
|
// false for the evaluation of x so that we can check it afterwards.
|
|
// Note: We must do this _before_ calling exprList because exprList evaluates
|
|
// all arguments.
|
|
if id == _Len || id == _Cap {
|
|
defer func(b bool) {
|
|
check.hasCallOrRecv = b
|
|
}(check.hasCallOrRecv)
|
|
check.hasCallOrRecv = false
|
|
}
|
|
|
|
// Evaluate arguments for built-ins that use ordinary (value) arguments.
|
|
// For built-ins with special argument handling (make, new, etc.),
|
|
// evaluation is done by the respective built-in code.
|
|
var args []*operand // not valid for _Make, _New, _Offsetof, _Trace
|
|
var nargs int
|
|
switch id {
|
|
default:
|
|
// check all arguments
|
|
args = check.exprList(argList)
|
|
nargs = len(args)
|
|
for _, a := range args {
|
|
if a.mode == invalid {
|
|
return
|
|
}
|
|
}
|
|
// first argument is always in x
|
|
if nargs > 0 {
|
|
*x = *args[0]
|
|
}
|
|
case _Make, _New, _Offsetof, _Trace:
|
|
// arguments require special handling
|
|
nargs = len(argList)
|
|
}
|
|
|
|
// check argument count
|
|
{
|
|
msg := ""
|
|
if nargs < bin.nargs {
|
|
msg = "not enough"
|
|
} else if !bin.variadic && nargs > bin.nargs {
|
|
msg = "too many"
|
|
}
|
|
if msg != "" {
|
|
check.errorf(argErrPos(call), WrongArgCount, invalidOp+"%s arguments for %v (expected %d, found %d)", msg, call, bin.nargs, nargs)
|
|
return
|
|
}
|
|
}
|
|
|
|
switch id {
|
|
case _Append:
|
|
// append(s S, x ...T) S, where T is the element type of S
|
|
// spec: "The variadic function append appends zero or more values x to s of type
|
|
// S, which must be a slice type, and returns the resulting slice, also of type S.
|
|
// The values x are passed to a parameter of type ...T where T is the element type
|
|
// of S and the respective parameter passing rules apply."
|
|
S := x.typ
|
|
var T Type
|
|
if s, _ := coreType(S).(*Slice); s != nil {
|
|
T = s.elem
|
|
} else {
|
|
var cause string
|
|
switch {
|
|
case x.isNil():
|
|
cause = "have untyped nil"
|
|
case isTypeParam(S):
|
|
if u := coreType(S); u != nil {
|
|
cause = check.sprintf("%s has core type %s", x, u)
|
|
} else {
|
|
cause = check.sprintf("%s has no core type", x)
|
|
}
|
|
default:
|
|
cause = check.sprintf("have %s", x)
|
|
}
|
|
// don't use invalidArg prefix here as it would repeat "argument" in the error message
|
|
check.errorf(x, InvalidAppend, "first argument to append must be a slice; %s", cause)
|
|
return
|
|
}
|
|
|
|
// spec: "As a special case, append also accepts a first argument assignable
|
|
// to type []byte with a second argument of string type followed by ... .
|
|
// This form appends the bytes of the string.
|
|
if nargs == 2 && hasDots(call) {
|
|
if ok, _ := x.assignableTo(check, NewSlice(universeByte), nil); ok {
|
|
y := args[1]
|
|
if t := coreString(y.typ); t != nil && isString(t) {
|
|
if check.recordTypes() {
|
|
sig := makeSig(S, S, y.typ)
|
|
sig.variadic = true
|
|
check.recordBuiltinType(call.Fun, sig)
|
|
}
|
|
x.mode = value
|
|
x.typ = S
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// check general case by creating custom signature
|
|
sig := makeSig(S, S, NewSlice(T)) // []T required for variadic signature
|
|
sig.variadic = true
|
|
check.arguments(call, sig, nil, nil, args, nil, nil) // discard result (we know the result type)
|
|
// ok to continue even if check.arguments reported errors
|
|
|
|
x.mode = value
|
|
x.typ = S
|
|
if check.recordTypes() {
|
|
check.recordBuiltinType(call.Fun, sig)
|
|
}
|
|
|
|
case _Cap, _Len:
|
|
// cap(x)
|
|
// len(x)
|
|
mode := invalid
|
|
var val constant.Value
|
|
switch t := arrayPtrDeref(under(x.typ)).(type) {
|
|
case *Basic:
|
|
if isString(t) && id == _Len {
|
|
if x.mode == constant_ {
|
|
mode = constant_
|
|
val = constant.MakeInt64(int64(len(constant.StringVal(x.val))))
|
|
} else {
|
|
mode = value
|
|
}
|
|
}
|
|
|
|
case *Array:
|
|
mode = value
|
|
// spec: "The expressions len(s) and cap(s) are constants
|
|
// if the type of s is an array or pointer to an array and
|
|
// the expression s does not contain channel receives or
|
|
// function calls; in this case s is not evaluated."
|
|
if !check.hasCallOrRecv {
|
|
mode = constant_
|
|
if t.len >= 0 {
|
|
val = constant.MakeInt64(t.len)
|
|
} else {
|
|
val = constant.MakeUnknown()
|
|
}
|
|
}
|
|
|
|
case *Slice, *Chan:
|
|
mode = value
|
|
|
|
case *Map:
|
|
if id == _Len {
|
|
mode = value
|
|
}
|
|
|
|
case *Interface:
|
|
if !isTypeParam(x.typ) {
|
|
break
|
|
}
|
|
if t.typeSet().underIs(func(t Type) bool {
|
|
switch t := arrayPtrDeref(t).(type) {
|
|
case *Basic:
|
|
if isString(t) && id == _Len {
|
|
return true
|
|
}
|
|
case *Array, *Slice, *Chan:
|
|
return true
|
|
case *Map:
|
|
if id == _Len {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}) {
|
|
mode = value
|
|
}
|
|
}
|
|
|
|
if mode == invalid {
|
|
// avoid error if underlying type is invalid
|
|
if isValid(under(x.typ)) {
|
|
code := InvalidCap
|
|
if id == _Len {
|
|
code = InvalidLen
|
|
}
|
|
check.errorf(x, code, invalidArg+"%s for built-in %s", x, bin.name)
|
|
}
|
|
return
|
|
}
|
|
|
|
// record the signature before changing x.typ
|
|
if check.recordTypes() && mode != constant_ {
|
|
check.recordBuiltinType(call.Fun, makeSig(Typ[Int], x.typ))
|
|
}
|
|
|
|
x.mode = mode
|
|
x.typ = Typ[Int]
|
|
x.val = val
|
|
|
|
case _Clear:
|
|
// clear(m)
|
|
check.verifyVersionf(call.Fun, go1_21, "clear")
|
|
|
|
if !underIs(x.typ, func(u Type) bool {
|
|
switch u.(type) {
|
|
case *Map, *Slice:
|
|
return true
|
|
}
|
|
check.errorf(x, InvalidClear, invalidArg+"cannot clear %s: argument must be (or constrained by) map or slice", x)
|
|
return false
|
|
}) {
|
|
return
|
|
}
|
|
|
|
x.mode = novalue
|
|
if check.recordTypes() {
|
|
check.recordBuiltinType(call.Fun, makeSig(nil, x.typ))
|
|
}
|
|
|
|
case _Close:
|
|
// close(c)
|
|
if !underIs(x.typ, func(u Type) bool {
|
|
uch, _ := u.(*Chan)
|
|
if uch == nil {
|
|
check.errorf(x, InvalidClose, invalidOp+"cannot close non-channel %s", x)
|
|
return false
|
|
}
|
|
if uch.dir == RecvOnly {
|
|
check.errorf(x, InvalidClose, invalidOp+"cannot close receive-only channel %s", x)
|
|
return false
|
|
}
|
|
return true
|
|
}) {
|
|
return
|
|
}
|
|
x.mode = novalue
|
|
if check.recordTypes() {
|
|
check.recordBuiltinType(call.Fun, makeSig(nil, x.typ))
|
|
}
|
|
|
|
case _Complex:
|
|
// complex(x, y floatT) complexT
|
|
y := args[1]
|
|
|
|
// convert or check untyped arguments
|
|
d := 0
|
|
if isUntyped(x.typ) {
|
|
d |= 1
|
|
}
|
|
if isUntyped(y.typ) {
|
|
d |= 2
|
|
}
|
|
switch d {
|
|
case 0:
|
|
// x and y are typed => nothing to do
|
|
case 1:
|
|
// only x is untyped => convert to type of y
|
|
check.convertUntyped(x, y.typ)
|
|
case 2:
|
|
// only y is untyped => convert to type of x
|
|
check.convertUntyped(y, x.typ)
|
|
case 3:
|
|
// x and y are untyped =>
|
|
// 1) if both are constants, convert them to untyped
|
|
// floating-point numbers if possible,
|
|
// 2) if one of them is not constant (possible because
|
|
// it contains a shift that is yet untyped), convert
|
|
// both of them to float64 since they must have the
|
|
// same type to succeed (this will result in an error
|
|
// because shifts of floats are not permitted)
|
|
if x.mode == constant_ && y.mode == constant_ {
|
|
toFloat := func(x *operand) {
|
|
if isNumeric(x.typ) && constant.Sign(constant.Imag(x.val)) == 0 {
|
|
x.typ = Typ[UntypedFloat]
|
|
}
|
|
}
|
|
toFloat(x)
|
|
toFloat(y)
|
|
} else {
|
|
check.convertUntyped(x, Typ[Float64])
|
|
check.convertUntyped(y, Typ[Float64])
|
|
// x and y should be invalid now, but be conservative
|
|
// and check below
|
|
}
|
|
}
|
|
if x.mode == invalid || y.mode == invalid {
|
|
return
|
|
}
|
|
|
|
// both argument types must be identical
|
|
if !Identical(x.typ, y.typ) {
|
|
check.errorf(x, InvalidComplex, invalidOp+"%v (mismatched types %s and %s)", call, x.typ, y.typ)
|
|
return
|
|
}
|
|
|
|
// the argument types must be of floating-point type
|
|
// (applyTypeFunc never calls f with a type parameter)
|
|
f := func(typ Type) Type {
|
|
assert(!isTypeParam(typ))
|
|
if t, _ := under(typ).(*Basic); t != nil {
|
|
switch t.kind {
|
|
case Float32:
|
|
return Typ[Complex64]
|
|
case Float64:
|
|
return Typ[Complex128]
|
|
case UntypedFloat:
|
|
return Typ[UntypedComplex]
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
resTyp := check.applyTypeFunc(f, x, id)
|
|
if resTyp == nil {
|
|
check.errorf(x, InvalidComplex, invalidArg+"arguments have type %s, expected floating-point", x.typ)
|
|
return
|
|
}
|
|
|
|
// if both arguments are constants, the result is a constant
|
|
if x.mode == constant_ && y.mode == constant_ {
|
|
x.val = constant.BinaryOp(constant.ToFloat(x.val), token.ADD, constant.MakeImag(constant.ToFloat(y.val)))
|
|
} else {
|
|
x.mode = value
|
|
}
|
|
|
|
if check.recordTypes() && x.mode != constant_ {
|
|
check.recordBuiltinType(call.Fun, makeSig(resTyp, x.typ, x.typ))
|
|
}
|
|
|
|
x.typ = resTyp
|
|
|
|
case _Copy:
|
|
// copy(x, y []T) int
|
|
dst, _ := coreType(x.typ).(*Slice)
|
|
|
|
y := args[1]
|
|
src0 := coreString(y.typ)
|
|
if src0 != nil && isString(src0) {
|
|
src0 = NewSlice(universeByte)
|
|
}
|
|
src, _ := src0.(*Slice)
|
|
|
|
if dst == nil || src == nil {
|
|
check.errorf(x, InvalidCopy, invalidArg+"copy expects slice arguments; found %s and %s", x, y)
|
|
return
|
|
}
|
|
|
|
if !Identical(dst.elem, src.elem) {
|
|
check.errorf(x, InvalidCopy, invalidArg+"arguments to copy %s and %s have different element types %s and %s", x, y, dst.elem, src.elem)
|
|
return
|
|
}
|
|
|
|
if check.recordTypes() {
|
|
check.recordBuiltinType(call.Fun, makeSig(Typ[Int], x.typ, y.typ))
|
|
}
|
|
x.mode = value
|
|
x.typ = Typ[Int]
|
|
|
|
case _Delete:
|
|
// delete(map_, key)
|
|
// map_ must be a map type or a type parameter describing map types.
|
|
// The key cannot be a type parameter for now.
|
|
map_ := x.typ
|
|
var key Type
|
|
if !underIs(map_, func(u Type) bool {
|
|
map_, _ := u.(*Map)
|
|
if map_ == nil {
|
|
check.errorf(x, InvalidDelete, invalidArg+"%s is not a map", x)
|
|
return false
|
|
}
|
|
if key != nil && !Identical(map_.key, key) {
|
|
check.errorf(x, InvalidDelete, invalidArg+"maps of %s must have identical key types", x)
|
|
return false
|
|
}
|
|
key = map_.key
|
|
return true
|
|
}) {
|
|
return
|
|
}
|
|
|
|
*x = *args[1] // key
|
|
check.assignment(x, key, "argument to delete")
|
|
if x.mode == invalid {
|
|
return
|
|
}
|
|
|
|
x.mode = novalue
|
|
if check.recordTypes() {
|
|
check.recordBuiltinType(call.Fun, makeSig(nil, map_, key))
|
|
}
|
|
|
|
case _Imag, _Real:
|
|
// imag(complexT) floatT
|
|
// real(complexT) floatT
|
|
|
|
// convert or check untyped argument
|
|
if isUntyped(x.typ) {
|
|
if x.mode == constant_ {
|
|
// an untyped constant number can always be considered
|
|
// as a complex constant
|
|
if isNumeric(x.typ) {
|
|
x.typ = Typ[UntypedComplex]
|
|
}
|
|
} else {
|
|
// an untyped non-constant argument may appear if
|
|
// it contains a (yet untyped non-constant) shift
|
|
// expression: convert it to complex128 which will
|
|
// result in an error (shift of complex value)
|
|
check.convertUntyped(x, Typ[Complex128])
|
|
// x should be invalid now, but be conservative and check
|
|
if x.mode == invalid {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// the argument must be of complex type
|
|
// (applyTypeFunc never calls f with a type parameter)
|
|
f := func(typ Type) Type {
|
|
assert(!isTypeParam(typ))
|
|
if t, _ := under(typ).(*Basic); t != nil {
|
|
switch t.kind {
|
|
case Complex64:
|
|
return Typ[Float32]
|
|
case Complex128:
|
|
return Typ[Float64]
|
|
case UntypedComplex:
|
|
return Typ[UntypedFloat]
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
resTyp := check.applyTypeFunc(f, x, id)
|
|
if resTyp == nil {
|
|
code := InvalidImag
|
|
if id == _Real {
|
|
code = InvalidReal
|
|
}
|
|
check.errorf(x, code, invalidArg+"argument has type %s, expected complex type", x.typ)
|
|
return
|
|
}
|
|
|
|
// if the argument is a constant, the result is a constant
|
|
if x.mode == constant_ {
|
|
if id == _Real {
|
|
x.val = constant.Real(x.val)
|
|
} else {
|
|
x.val = constant.Imag(x.val)
|
|
}
|
|
} else {
|
|
x.mode = value
|
|
}
|
|
|
|
if check.recordTypes() && x.mode != constant_ {
|
|
check.recordBuiltinType(call.Fun, makeSig(resTyp, x.typ))
|
|
}
|
|
|
|
x.typ = resTyp
|
|
|
|
case _Make:
|
|
// make(T, n)
|
|
// make(T, n, m)
|
|
// (no argument evaluated yet)
|
|
arg0 := argList[0]
|
|
T := check.varType(arg0)
|
|
if !isValid(T) {
|
|
return
|
|
}
|
|
|
|
var min int // minimum number of arguments
|
|
switch coreType(T).(type) {
|
|
case *Slice:
|
|
min = 2
|
|
case *Map, *Chan:
|
|
min = 1
|
|
case nil:
|
|
check.errorf(arg0, InvalidMake, invalidArg+"cannot make %s: no core type", arg0)
|
|
return
|
|
default:
|
|
check.errorf(arg0, InvalidMake, invalidArg+"cannot make %s; type must be slice, map, or channel", arg0)
|
|
return
|
|
}
|
|
if nargs < min || min+1 < nargs {
|
|
check.errorf(call, WrongArgCount, invalidOp+"%v expects %d or %d arguments; found %d", call, min, min+1, nargs)
|
|
return
|
|
}
|
|
|
|
types := []Type{T}
|
|
var sizes []int64 // constant integer arguments, if any
|
|
for _, arg := range argList[1:] {
|
|
typ, size := check.index(arg, -1) // ok to continue with typ == Typ[Invalid]
|
|
types = append(types, typ)
|
|
if size >= 0 {
|
|
sizes = append(sizes, size)
|
|
}
|
|
}
|
|
if len(sizes) == 2 && sizes[0] > sizes[1] {
|
|
check.error(argList[1], SwappedMakeArgs, invalidArg+"length and capacity swapped")
|
|
// safe to continue
|
|
}
|
|
x.mode = value
|
|
x.typ = T
|
|
if check.recordTypes() {
|
|
check.recordBuiltinType(call.Fun, makeSig(x.typ, types...))
|
|
}
|
|
|
|
case _Max, _Min:
|
|
// max(x, ...)
|
|
// min(x, ...)
|
|
check.verifyVersionf(call.Fun, go1_21, "built-in %s", bin.name)
|
|
|
|
op := token.LSS
|
|
if id == _Max {
|
|
op = token.GTR
|
|
}
|
|
|
|
for i, a := range args {
|
|
if a.mode == invalid {
|
|
return
|
|
}
|
|
|
|
if !allOrdered(a.typ) {
|
|
check.errorf(a, InvalidMinMaxOperand, invalidArg+"%s cannot be ordered", a)
|
|
return
|
|
}
|
|
|
|
// The first argument is already in x and there's nothing left to do.
|
|
if i > 0 {
|
|
check.matchTypes(x, a)
|
|
if x.mode == invalid {
|
|
return
|
|
}
|
|
|
|
if !Identical(x.typ, a.typ) {
|
|
check.errorf(a, MismatchedTypes, invalidArg+"mismatched types %s (previous argument) and %s (type of %s)", x.typ, a.typ, a.expr)
|
|
return
|
|
}
|
|
|
|
if x.mode == constant_ && a.mode == constant_ {
|
|
if constant.Compare(a.val, op, x.val) {
|
|
*x = *a
|
|
}
|
|
} else {
|
|
x.mode = value
|
|
}
|
|
}
|
|
}
|
|
|
|
// If nargs == 1, make sure x.mode is either a value or a constant.
|
|
if x.mode != constant_ {
|
|
x.mode = value
|
|
// A value must not be untyped.
|
|
check.assignment(x, &emptyInterface, "argument to built-in "+bin.name)
|
|
if x.mode == invalid {
|
|
return
|
|
}
|
|
}
|
|
|
|
// Use the final type computed above for all arguments.
|
|
for _, a := range args {
|
|
check.updateExprType(a.expr, x.typ, true)
|
|
}
|
|
|
|
if check.recordTypes() && x.mode != constant_ {
|
|
types := make([]Type, nargs)
|
|
for i := range types {
|
|
types[i] = x.typ
|
|
}
|
|
check.recordBuiltinType(call.Fun, makeSig(x.typ, types...))
|
|
}
|
|
|
|
case _New:
|
|
// new(T)
|
|
// (no argument evaluated yet)
|
|
T := check.varType(argList[0])
|
|
if !isValid(T) {
|
|
return
|
|
}
|
|
|
|
x.mode = value
|
|
x.typ = &Pointer{base: T}
|
|
if check.recordTypes() {
|
|
check.recordBuiltinType(call.Fun, makeSig(x.typ, T))
|
|
}
|
|
|
|
case _Panic:
|
|
// panic(x)
|
|
// record panic call if inside a function with result parameters
|
|
// (for use in Checker.isTerminating)
|
|
if check.sig != nil && check.sig.results.Len() > 0 {
|
|
// function has result parameters
|
|
p := check.isPanic
|
|
if p == nil {
|
|
// allocate lazily
|
|
p = make(map[*ast.CallExpr]bool)
|
|
check.isPanic = p
|
|
}
|
|
p[call] = true
|
|
}
|
|
|
|
check.assignment(x, &emptyInterface, "argument to panic")
|
|
if x.mode == invalid {
|
|
return
|
|
}
|
|
|
|
x.mode = novalue
|
|
if check.recordTypes() {
|
|
check.recordBuiltinType(call.Fun, makeSig(nil, &emptyInterface))
|
|
}
|
|
|
|
case _Print, _Println:
|
|
// print(x, y, ...)
|
|
// println(x, y, ...)
|
|
var params []Type
|
|
if nargs > 0 {
|
|
params = make([]Type, nargs)
|
|
for i, a := range args {
|
|
check.assignment(a, nil, "argument to built-in"+predeclaredFuncs[id].name)
|
|
if a.mode == invalid {
|
|
return
|
|
}
|
|
params[i] = a.typ
|
|
}
|
|
}
|
|
|
|
x.mode = novalue
|
|
if check.recordTypes() {
|
|
check.recordBuiltinType(call.Fun, makeSig(nil, params...))
|
|
}
|
|
|
|
case _Recover:
|
|
// recover() interface{}
|
|
x.mode = value
|
|
x.typ = &emptyInterface
|
|
if check.recordTypes() {
|
|
check.recordBuiltinType(call.Fun, makeSig(x.typ))
|
|
}
|
|
|
|
case _Add:
|
|
// unsafe.Add(ptr unsafe.Pointer, len IntegerType) unsafe.Pointer
|
|
check.verifyVersionf(call.Fun, go1_17, "unsafe.Add")
|
|
|
|
check.assignment(x, Typ[UnsafePointer], "argument to unsafe.Add")
|
|
if x.mode == invalid {
|
|
return
|
|
}
|
|
|
|
y := args[1]
|
|
if !check.isValidIndex(y, InvalidUnsafeAdd, "length", true) {
|
|
return
|
|
}
|
|
|
|
x.mode = value
|
|
x.typ = Typ[UnsafePointer]
|
|
if check.recordTypes() {
|
|
check.recordBuiltinType(call.Fun, makeSig(x.typ, x.typ, y.typ))
|
|
}
|
|
|
|
case _Alignof:
|
|
// unsafe.Alignof(x T) uintptr
|
|
check.assignment(x, nil, "argument to unsafe.Alignof")
|
|
if x.mode == invalid {
|
|
return
|
|
}
|
|
|
|
if hasVarSize(x.typ, nil) {
|
|
x.mode = value
|
|
if check.recordTypes() {
|
|
check.recordBuiltinType(call.Fun, makeSig(Typ[Uintptr], x.typ))
|
|
}
|
|
} else {
|
|
x.mode = constant_
|
|
x.val = constant.MakeInt64(check.conf.alignof(x.typ))
|
|
// result is constant - no need to record signature
|
|
}
|
|
x.typ = Typ[Uintptr]
|
|
|
|
case _Offsetof:
|
|
// unsafe.Offsetof(x T) uintptr, where x must be a selector
|
|
// (no argument evaluated yet)
|
|
arg0 := argList[0]
|
|
selx, _ := ast.Unparen(arg0).(*ast.SelectorExpr)
|
|
if selx == nil {
|
|
check.errorf(arg0, BadOffsetofSyntax, invalidArg+"%s is not a selector expression", arg0)
|
|
check.use(arg0)
|
|
return
|
|
}
|
|
|
|
check.expr(nil, x, selx.X)
|
|
if x.mode == invalid {
|
|
return
|
|
}
|
|
|
|
base := derefStructPtr(x.typ)
|
|
sel := selx.Sel.Name
|
|
obj, index, indirect := lookupFieldOrMethod(base, false, check.pkg, sel, false)
|
|
switch obj.(type) {
|
|
case nil:
|
|
check.errorf(x, MissingFieldOrMethod, invalidArg+"%s has no single field %s", base, sel)
|
|
return
|
|
case *Func:
|
|
// TODO(gri) Using derefStructPtr may result in methods being found
|
|
// that don't actually exist. An error either way, but the error
|
|
// message is confusing. See: https://play.golang.org/p/al75v23kUy ,
|
|
// but go/types reports: "invalid argument: x.m is a method value".
|
|
check.errorf(arg0, InvalidOffsetof, invalidArg+"%s is a method value", arg0)
|
|
return
|
|
}
|
|
if indirect {
|
|
check.errorf(x, InvalidOffsetof, invalidArg+"field %s is embedded via a pointer in %s", sel, base)
|
|
return
|
|
}
|
|
|
|
// TODO(gri) Should we pass x.typ instead of base (and have indirect report if derefStructPtr indirected)?
|
|
check.recordSelection(selx, FieldVal, base, obj, index, false)
|
|
|
|
// record the selector expression (was bug - go.dev/issue/47895)
|
|
{
|
|
mode := value
|
|
if x.mode == variable || indirect {
|
|
mode = variable
|
|
}
|
|
check.record(&operand{mode, selx, obj.Type(), nil, 0})
|
|
}
|
|
|
|
// The field offset is considered a variable even if the field is declared before
|
|
// the part of the struct which is variable-sized. This makes both the rules
|
|
// simpler and also permits (or at least doesn't prevent) a compiler from re-
|
|
// arranging struct fields if it wanted to.
|
|
if hasVarSize(base, nil) {
|
|
x.mode = value
|
|
if check.recordTypes() {
|
|
check.recordBuiltinType(call.Fun, makeSig(Typ[Uintptr], obj.Type()))
|
|
}
|
|
} else {
|
|
offs := check.conf.offsetof(base, index)
|
|
if offs < 0 {
|
|
check.errorf(x, TypeTooLarge, "%s is too large", x)
|
|
return
|
|
}
|
|
x.mode = constant_
|
|
x.val = constant.MakeInt64(offs)
|
|
// result is constant - no need to record signature
|
|
}
|
|
x.typ = Typ[Uintptr]
|
|
|
|
case _Sizeof:
|
|
// unsafe.Sizeof(x T) uintptr
|
|
check.assignment(x, nil, "argument to unsafe.Sizeof")
|
|
if x.mode == invalid {
|
|
return
|
|
}
|
|
|
|
if hasVarSize(x.typ, nil) {
|
|
x.mode = value
|
|
if check.recordTypes() {
|
|
check.recordBuiltinType(call.Fun, makeSig(Typ[Uintptr], x.typ))
|
|
}
|
|
} else {
|
|
size := check.conf.sizeof(x.typ)
|
|
if size < 0 {
|
|
check.errorf(x, TypeTooLarge, "%s is too large", x)
|
|
return
|
|
}
|
|
x.mode = constant_
|
|
x.val = constant.MakeInt64(size)
|
|
// result is constant - no need to record signature
|
|
}
|
|
x.typ = Typ[Uintptr]
|
|
|
|
case _Slice:
|
|
// unsafe.Slice(ptr *T, len IntegerType) []T
|
|
check.verifyVersionf(call.Fun, go1_17, "unsafe.Slice")
|
|
|
|
ptr, _ := coreType(x.typ).(*Pointer)
|
|
if ptr == nil {
|
|
check.errorf(x, InvalidUnsafeSlice, invalidArg+"%s is not a pointer", x)
|
|
return
|
|
}
|
|
|
|
y := args[1]
|
|
if !check.isValidIndex(y, InvalidUnsafeSlice, "length", false) {
|
|
return
|
|
}
|
|
|
|
x.mode = value
|
|
x.typ = NewSlice(ptr.base)
|
|
if check.recordTypes() {
|
|
check.recordBuiltinType(call.Fun, makeSig(x.typ, ptr, y.typ))
|
|
}
|
|
|
|
case _SliceData:
|
|
// unsafe.SliceData(slice []T) *T
|
|
check.verifyVersionf(call.Fun, go1_20, "unsafe.SliceData")
|
|
|
|
slice, _ := coreType(x.typ).(*Slice)
|
|
if slice == nil {
|
|
check.errorf(x, InvalidUnsafeSliceData, invalidArg+"%s is not a slice", x)
|
|
return
|
|
}
|
|
|
|
x.mode = value
|
|
x.typ = NewPointer(slice.elem)
|
|
if check.recordTypes() {
|
|
check.recordBuiltinType(call.Fun, makeSig(x.typ, slice))
|
|
}
|
|
|
|
case _String:
|
|
// unsafe.String(ptr *byte, len IntegerType) string
|
|
check.verifyVersionf(call.Fun, go1_20, "unsafe.String")
|
|
|
|
check.assignment(x, NewPointer(universeByte), "argument to unsafe.String")
|
|
if x.mode == invalid {
|
|
return
|
|
}
|
|
|
|
y := args[1]
|
|
if !check.isValidIndex(y, InvalidUnsafeString, "length", false) {
|
|
return
|
|
}
|
|
|
|
x.mode = value
|
|
x.typ = Typ[String]
|
|
if check.recordTypes() {
|
|
check.recordBuiltinType(call.Fun, makeSig(x.typ, NewPointer(universeByte), y.typ))
|
|
}
|
|
|
|
case _StringData:
|
|
// unsafe.StringData(str string) *byte
|
|
check.verifyVersionf(call.Fun, go1_20, "unsafe.StringData")
|
|
|
|
check.assignment(x, Typ[String], "argument to unsafe.StringData")
|
|
if x.mode == invalid {
|
|
return
|
|
}
|
|
|
|
x.mode = value
|
|
x.typ = NewPointer(universeByte)
|
|
if check.recordTypes() {
|
|
check.recordBuiltinType(call.Fun, makeSig(x.typ, Typ[String]))
|
|
}
|
|
|
|
case _Assert:
|
|
// assert(pred) causes a typechecker error if pred is false.
|
|
// The result of assert is the value of pred if there is no error.
|
|
// Note: assert is only available in self-test mode.
|
|
if x.mode != constant_ || !isBoolean(x.typ) {
|
|
check.errorf(x, Test, invalidArg+"%s is not a boolean constant", x)
|
|
return
|
|
}
|
|
if x.val.Kind() != constant.Bool {
|
|
check.errorf(x, Test, "internal error: value of %s should be a boolean constant", x)
|
|
return
|
|
}
|
|
if !constant.BoolVal(x.val) {
|
|
check.errorf(call, Test, "%v failed", call)
|
|
// compile-time assertion failure - safe to continue
|
|
}
|
|
// result is constant - no need to record signature
|
|
|
|
case _Trace:
|
|
// trace(x, y, z, ...) dumps the positions, expressions, and
|
|
// values of its arguments. The result of trace is the value
|
|
// of the first argument.
|
|
// Note: trace is only available in self-test mode.
|
|
// (no argument evaluated yet)
|
|
if nargs == 0 {
|
|
check.dump("%v: trace() without arguments", call.Pos())
|
|
x.mode = novalue
|
|
break
|
|
}
|
|
var t operand
|
|
x1 := x
|
|
for _, arg := range argList {
|
|
check.rawExpr(nil, x1, arg, nil, false) // permit trace for types, e.g.: new(trace(T))
|
|
check.dump("%v: %s", x1.Pos(), x1)
|
|
x1 = &t // use incoming x only for first argument
|
|
}
|
|
if x.mode == invalid {
|
|
return
|
|
}
|
|
// trace is only available in test mode - no need to record signature
|
|
|
|
default:
|
|
panic("unreachable")
|
|
}
|
|
|
|
assert(x.mode != invalid)
|
|
return true
|
|
}
|
|
|
|
// hasVarSize reports if the size of type t is variable due to type parameters
|
|
// or if the type is infinitely-sized due to a cycle for which the type has not
|
|
// yet been checked.
|
|
func hasVarSize(t Type, seen map[*Named]bool) (varSized bool) {
|
|
// Cycles are only possible through *Named types.
|
|
// The seen map is used to detect cycles and track
|
|
// the results of previously seen types.
|
|
if named := asNamed(t); named != nil {
|
|
if v, ok := seen[named]; ok {
|
|
return v
|
|
}
|
|
if seen == nil {
|
|
seen = make(map[*Named]bool)
|
|
}
|
|
seen[named] = true // possibly cyclic until proven otherwise
|
|
defer func() {
|
|
seen[named] = varSized // record final determination for named
|
|
}()
|
|
}
|
|
|
|
switch u := under(t).(type) {
|
|
case *Array:
|
|
return hasVarSize(u.elem, seen)
|
|
case *Struct:
|
|
for _, f := range u.fields {
|
|
if hasVarSize(f.typ, seen) {
|
|
return true
|
|
}
|
|
}
|
|
case *Interface:
|
|
return isTypeParam(t)
|
|
case *Named, *Union:
|
|
panic("unreachable")
|
|
}
|
|
return false
|
|
}
|
|
|
|
// applyTypeFunc applies f to x. If x is a type parameter,
|
|
// the result is a type parameter constrained by a new
|
|
// interface bound. The type bounds for that interface
|
|
// are computed by applying f to each of the type bounds
|
|
// of x. If any of these applications of f return nil,
|
|
// applyTypeFunc returns nil.
|
|
// If x is not a type parameter, the result is f(x).
|
|
func (check *Checker) applyTypeFunc(f func(Type) Type, x *operand, id builtinId) Type {
|
|
if tp, _ := Unalias(x.typ).(*TypeParam); tp != nil {
|
|
// Test if t satisfies the requirements for the argument
|
|
// type and collect possible result types at the same time.
|
|
var terms []*Term
|
|
if !tp.is(func(t *term) bool {
|
|
if t == nil {
|
|
return false
|
|
}
|
|
if r := f(t.typ); r != nil {
|
|
terms = append(terms, NewTerm(t.tilde, r))
|
|
return true
|
|
}
|
|
return false
|
|
}) {
|
|
return nil
|
|
}
|
|
|
|
// We can type-check this fine but we're introducing a synthetic
|
|
// type parameter for the result. It's not clear what the API
|
|
// implications are here. Report an error for 1.18 (see go.dev/issue/50912),
|
|
// but continue type-checking.
|
|
var code Code
|
|
switch id {
|
|
case _Real:
|
|
code = InvalidReal
|
|
case _Imag:
|
|
code = InvalidImag
|
|
case _Complex:
|
|
code = InvalidComplex
|
|
default:
|
|
panic("unreachable")
|
|
}
|
|
check.softErrorf(x, code, "%s not supported as argument to built-in %s for go1.18 (see go.dev/issue/50937)", x, predeclaredFuncs[id].name)
|
|
|
|
// Construct a suitable new type parameter for the result type.
|
|
// The type parameter is placed in the current package so export/import
|
|
// works as expected.
|
|
tpar := NewTypeName(nopos, check.pkg, tp.obj.name, nil)
|
|
ptyp := check.newTypeParam(tpar, NewInterfaceType(nil, []Type{NewUnion(terms)})) // assigns type to tpar as a side-effect
|
|
ptyp.index = tp.index
|
|
|
|
return ptyp
|
|
}
|
|
|
|
return f(x.typ)
|
|
}
|
|
|
|
// makeSig makes a signature for the given argument and result types.
|
|
// Default types are used for untyped arguments, and res may be nil.
|
|
func makeSig(res Type, args ...Type) *Signature {
|
|
list := make([]*Var, len(args))
|
|
for i, param := range args {
|
|
list[i] = NewVar(nopos, nil, "", Default(param))
|
|
}
|
|
params := NewTuple(list...)
|
|
var result *Tuple
|
|
if res != nil {
|
|
assert(!isUntyped(res))
|
|
result = NewTuple(NewVar(nopos, nil, "", res))
|
|
}
|
|
return &Signature{params: params, results: result}
|
|
}
|
|
|
|
// arrayPtrDeref returns A if typ is of the form *A and A is an array;
|
|
// otherwise it returns typ.
|
|
func arrayPtrDeref(typ Type) Type {
|
|
if p, ok := Unalias(typ).(*Pointer); ok {
|
|
if a, _ := under(p.base).(*Array); a != nil {
|
|
return a
|
|
}
|
|
}
|
|
return typ
|
|
}
|