qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-19 00:44:40 -07:00
Code Releases Activity

go.tools/go/types: built-in calls of the form builtin(f())

Browse Source 
- factor out argument extraction logic
- cleaned up error handling in builtin.go (no need for goto's anymore)
- lots of additional test cases
- various cleanups, better documentation

Fixes golang/go#5795.

R=adonovan
CC=golang-dev
https://golang.org/cl/14312044
This commit is contained in:
Robert Griesemer 2013-10-04 13:32:21 -07:00
parent 6af036a659
commit 5d0990f591
4 changed files with 588 additions and 313 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

292
go/types/builtins.go
View File

@ -13,48 +13,48 @@ import (
"code.google.com/p/go.tools/go/exact" "code.google.com/p/go.tools/go/exact"
) )
// builtin typechecks a call to a built-in and returns the result via x. // builtin type-checks a call to the built-in specified by id and
// If the call has type errors, the returned x is marked as invalid. // returns true if 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) { func (check *checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ bool) {
args := call.Args // determine actual arguments
var arg getter
// declare before goto's nargs := len(call.Args)
var arg0 ast.Expr // first argument, if present switch id {
default:
// make argument getter
arg, nargs = unpack(func(x *operand, i int) { check.expr(x, call.Args[i]) }, nargs, false)
// evaluate first argument, if present
if nargs > 0 {
arg(x, 0)
if x.mode == invalid {
return
}
}
case _Make, _New, _Offsetof, _Trace:
// arguments requires special handling
}
// check argument count // check argument count
n := len(args)
msg := ""
bin := predeclaredFuncs[id] bin := predeclaredFuncs[id]
if n < bin.nargs { {
msg = "not enough" msg := ""
} else if !bin.variadic && n > bin.nargs { if nargs < bin.nargs {
msg = "too many" msg = "not enough"
} } else if !bin.variadic && nargs > bin.nargs {
if msg != "" { msg = "too many"
check.invalidOp(call.Pos(), "%s arguments for %s (expected %d, found %d)", msg, call, bin.nargs, n) }
goto Error if msg != "" {
} check.invalidOp(call.Rparen, "%s arguments for %s (expected %d, found %d)", msg, call, bin.nargs, nargs)
return
// common case: evaluate first argument if present;
// if it is an expression, x has the expression value
if n > 0 {
arg0 = args[0]
switch id {
case _Make, _New, _Print, _Println, _Offsetof, _Trace:
// respective cases below do the work
default:
// argument must be an expression
check.expr(x, arg0)
if x.mode == invalid {
goto Error
}
} }
} }
switch id { switch id {
case _Append: case _Append:
// append(s S, x ...T) S where T is the element type of S // 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 // 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. // 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 // The values x are passed to a parameter of type ...T where T is the element type
@ -65,7 +65,7 @@ func (check *checker) builtin(x *operand, call *ast.CallExpr, id builtinId) {
T = s.elt T = s.elt
} else { } else {
check.invalidArg(x.pos(), "%s is not a slice", x) check.invalidArg(x.pos(), "%s is not a slice", x)
goto Error return
} }
// remember arguments that have been evaluated already // remember arguments that have been evaluated already
@ -74,16 +74,15 @@ func (check *checker) builtin(x *operand, call *ast.CallExpr, id builtinId) {
// spec: "As a special case, append also accepts a first argument assignable // spec: "As a special case, append also accepts a first argument assignable
// to type []byte with a second argument of string type followed by ... . // to type []byte with a second argument of string type followed by ... .
// This form appends the bytes of the string. // This form appends the bytes of the string.
if n == 2 && call.Ellipsis.IsValid() && x.isAssignableTo(check.conf, NewSlice(Typ[Byte])) { if nargs == 2 && call.Ellipsis.IsValid() && x.isAssignableTo(check.conf, NewSlice(Typ[Byte])) {
check.expr(x, args[1]) arg(x, 1)
if x.mode == invalid { if x.mode == invalid {
goto Error return
} }
if isString(x.typ) { if isString(x.typ) {
x.mode = value x.mode = value
x.typ = S x.typ = S
x.expr = call break
return
} }
alist = append(alist, *x) alist = append(alist, *x)
// fallthrough // fallthrough
@ -98,13 +97,15 @@ func (check *checker) builtin(x *operand, call *ast.CallExpr, id builtinId) {
*x = alist[i] *x = alist[i]
return return
} }
check.expr(x, args[i]) arg(x, i)
}) }, nargs)
x.mode = value x.mode = value
x.typ = S x.typ = S
case _Cap, _Len: case _Cap, _Len:
// cap(x)
// len(x)
mode := invalid mode := invalid
var val exact.Value var val exact.Value
switch typ := implicitArrayDeref(x.typ.Underlying()).(type) { switch typ := implicitArrayDeref(x.typ.Underlying()).(type) {
@ -124,7 +125,7 @@ func (check *checker) builtin(x *operand, call *ast.CallExpr, id builtinId) {
// if the type of s is an array or pointer to an array and // if the type of s is an array or pointer to an array and
// the expression s does not contain channel receives or // the expression s does not contain channel receives or
// function calls; in this case s is not evaluated." // function calls; in this case s is not evaluated."
if !check.containsCallsOrReceives(arg0) { if !check.containsCallsOrReceives(x.expr) {
mode = constant mode = constant
val = exact.MakeInt64(typ.len) val = exact.MakeInt64(typ.len)
} }
@ -140,78 +141,82 @@ func (check *checker) builtin(x *operand, call *ast.CallExpr, id builtinId) {
if mode == invalid { if mode == invalid {
check.invalidArg(x.pos(), "%s for %s", x, bin.name) check.invalidArg(x.pos(), "%s for %s", x, bin.name)
goto Error return
} }
x.mode = mode x.mode = mode
x.typ = Typ[Int] x.typ = Typ[Int]
x.val = val x.val = val
case _Close: case _Close:
ch, ok := x.typ.Underlying().(*Chan) // close(c)
if !ok { c, _ := x.typ.Underlying().(*Chan)
if c == nil {
check.invalidArg(x.pos(), "%s is not a channel", x) check.invalidArg(x.pos(), "%s is not a channel", x)
goto Error return
} }
if ch.dir&ast.SEND == 0 { if c.dir&ast.SEND == 0 {
check.invalidArg(x.pos(), "%s must not be a receive-only channel", x) check.invalidArg(x.pos(), "%s must not be a receive-only channel", x)
goto Error return
} }
x.mode = novalue x.mode = novalue
case _Complex: case _Complex:
// complex(x, y realT) complexT
if !check.complexArg(x) { if !check.complexArg(x) {
goto Error return
} }
var y operand var y operand
check.expr(&y, args[1]) arg(&y, 1)
if y.mode == invalid { if y.mode == invalid {
goto Error return
} }
if !check.complexArg(&y) { if !check.complexArg(&y) {
goto Error return
} }
check.convertUntyped(x, y.typ) check.convertUntyped(x, y.typ)
if x.mode == invalid { if x.mode == invalid {
goto Error return
} }
check.convertUntyped(&y, x.typ) check.convertUntyped(&y, x.typ)
if y.mode == invalid { if y.mode == invalid {
goto Error return
} }
if !IsIdentical(x.typ, y.typ) { if !IsIdentical(x.typ, y.typ) {
check.invalidArg(x.pos(), "mismatched types %s and %s", x.typ, y.typ) check.invalidArg(x.pos(), "mismatched types %s and %s", x.typ, y.typ)
goto Error return
} }
typ := x.typ.Underlying().(*Basic)
if x.mode == constant && y.mode == constant { if x.mode == constant && y.mode == constant {
x.val = exact.BinaryOp(x.val, token.ADD, exact.MakeImag(y.val)) x.val = exact.BinaryOp(x.val, token.ADD, exact.MakeImag(y.val))
} else { } else {
x.mode = value x.mode = value
} }
switch typ.kind { realT := x.typ.Underlying().(*Basic)
complexT := Typ[Invalid]
switch realT.kind {
case Float32: case Float32:
x.typ = Typ[Complex64] complexT = Typ[Complex64]
case Float64: case Float64:
x.typ = Typ[Complex128] complexT = Typ[Complex128]
case UntypedInt, UntypedRune, UntypedFloat: case UntypedInt, UntypedRune, UntypedFloat:
if x.mode == constant { if x.mode == constant {
typ = defaultType(typ).(*Basic) realT = defaultType(realT).(*Basic)
x.typ = Typ[UntypedComplex] complexT = Typ[UntypedComplex]
} else { } else {
// untyped but not constant; probably because one // untyped but not constant; probably because one
// operand is a non-constant shift of untyped lhs // operand is a non-constant shift of untyped lhs
typ = Typ[Float64] realT = Typ[Float64]
x.typ = Typ[Complex128] complexT = Typ[Complex128]
} }
default: default:
check.invalidArg(x.pos(), "float32 or float64 arguments expected") check.invalidArg(x.pos(), "float32 or float64 arguments expected")
goto Error return
} }
x.typ = complexT
if x.mode != constant { if x.mode != constant {
// The arguments have now their final types, which at run- // The arguments have now their final types, which at run-
@ -220,21 +225,23 @@ func (check *checker) builtin(x *operand, call *ast.CallExpr, id builtinId) {
// is the respective default type. // is the respective default type.
// (If the result is constant, the arguments are never // (If the result is constant, the arguments are never
// materialized and there is nothing to do.) // materialized and there is nothing to do.)
check.updateExprType(args[0], typ, true) check.updateExprType(x.expr, realT, true)
check.updateExprType(args[1], typ, true) check.updateExprType(y.expr, realT, true)
} }
case _Copy: case _Copy:
var y operand // copy(x, y []T) int
check.expr(&y, args[1]) var dst Type
if y.mode == invalid { if t, _ := x.typ.Underlying().(*Slice); t != nil {
goto Error
}
var dst, src Type
if t, ok := x.typ.Underlying().(*Slice); ok {
dst = t.elt dst = t.elt
} }
var y operand
arg(&y, 1)
if y.mode == invalid {
return
}
var src Type
switch t := y.typ.Underlying().(type) { switch t := y.typ.Underlying().(type) {
case *Basic: case *Basic:
if isString(y.typ) { if isString(y.typ) {
@ -246,37 +253,40 @@ func (check *checker) builtin(x *operand, call *ast.CallExpr, id builtinId) {
if dst == nil || src == nil { if dst == nil || src == nil {
check.invalidArg(x.pos(), "copy expects slice arguments; found %s and %s", x, &y) check.invalidArg(x.pos(), "copy expects slice arguments; found %s and %s", x, &y)
goto Error return
} }
if !IsIdentical(dst, src) { if !IsIdentical(dst, src) {
check.invalidArg(x.pos(), "arguments to copy %s and %s have different element types %s and %s", x, &y, dst, src) check.invalidArg(x.pos(), "arguments to copy %s and %s have different element types %s and %s", x, &y, dst, src)
goto Error return
} }
x.mode = value x.mode = value
x.typ = Typ[Int] x.typ = Typ[Int]
case _Delete: case _Delete:
m, ok := x.typ.Underlying().(*Map) // delete(m, k)
if !ok { m, _ := x.typ.Underlying().(*Map)
if m == nil {
check.invalidArg(x.pos(), "%s is not a map", x) check.invalidArg(x.pos(), "%s is not a map", x)
goto Error return
} }
check.expr(x, args[1]) arg(x, 1) // k
if x.mode == invalid { if x.mode == invalid {
goto Error return
} }
if !x.isAssignableTo(check.conf, m.key) { if !x.isAssignableTo(check.conf, m.key) {
check.invalidArg(x.pos(), "%s is not assignable to %s", x, m.key) check.invalidArg(x.pos(), "%s is not assignable to %s", x, m.key)
goto Error return
} }
x.mode = novalue x.mode = novalue
case _Imag, _Real: case _Imag, _Real:
// imag(complexT) realT
// real(complexT) realT
if !isComplex(x.typ) { if !isComplex(x.typ) {
check.invalidArg(x.pos(), "%s must be a complex number", x) check.invalidArg(x.pos(), "%s must be a complex number", x)
goto Error return
} }
if x.mode == constant { if x.mode == constant {
if id == _Real { if id == _Real {
@ -301,94 +311,107 @@ func (check *checker) builtin(x *operand, call *ast.CallExpr, id builtinId) {
x.typ = Typ[k] x.typ = Typ[k]
case _Make: case _Make:
resultTyp := check.typ(arg0, nil, false) // make(T, n)
if resultTyp == Typ[Invalid] { // make(T, n, m)
goto Error // (no argument evaluated yet)
arg0 := call.Args[0]
T := check.typ(arg0, nil, false)
if T == Typ[Invalid] {
return
} }
var min int // minimum number of arguments var min int // minimum number of arguments
switch resultTyp.Underlying().(type) { switch T.Underlying().(type) {
case *Slice: case *Slice:
min = 2 min = 2
case *Map, *Chan: case *Map, *Chan:
min = 1 min = 1
default: default:
check.invalidArg(arg0.Pos(), "cannot make %s; type must be slice, map, or channel", arg0) check.invalidArg(arg0.Pos(), "cannot make %s; type must be slice, map, or channel", arg0)
goto Error return
} }
if n := len(args); n < min || min+1 < n { if nargs < min || min+1 < nargs {
check.errorf(call.Pos(), "%s expects %d or %d arguments; found %d", call, min, min+1, n) check.errorf(call.Pos(), "%s expects %d or %d arguments; found %d", call, min, min+1, nargs)
goto Error return
} }
var sizes []int64 // constant integer arguments, if any var sizes []int64 // constant integer arguments, if any
for _, arg := range args[1:] { for _, arg := range call.Args[1:] {
if s, ok := check.index(arg, -1); ok && s >= 0 { if s, ok := check.index(arg, -1); ok && s >= 0 {
sizes = append(sizes, s) sizes = append(sizes, s)
} }
} }
if len(sizes) == 2 && sizes[0] > sizes[1] { if len(sizes) == 2 && sizes[0] > sizes[1] {
check.invalidArg(args[1].Pos(), "length and capacity swapped") check.invalidArg(call.Args[1].Pos(), "length and capacity swapped")
// safe to continue // safe to continue
} }
x.mode = variable x.mode = variable
x.typ = resultTyp x.typ = T
case _New: case _New:
resultTyp := check.typ(arg0, nil, false) // new(T)
if resultTyp == Typ[Invalid] { // (no argument evaluated yet)
goto Error T := check.typ(call.Args[0], nil, false)
if T == Typ[Invalid] {
return
} }
x.mode = variable x.mode = variable
x.typ = &Pointer{base: resultTyp} x.typ = &Pointer{base: T}
case _Panic: case _Panic, _Print, _Println:
x.mode = novalue // panic(x interface{})
// print(x, y, ...)
case _Print, _Println: // println(x, y, ...)
for _, arg := range args { for i := 1; i < nargs; i++ {
check.expr(x, arg) arg(x, i)
if x.mode == invalid { if x.mode == invalid {
goto Error return
} }
// TODO(gri) arguments must be assignable to _
} }
x.mode = novalue x.mode = novalue
case _Recover: case _Recover:
// recover() interface{}
x.mode = value x.mode = value
x.typ = new(Interface) x.typ = new(Interface)
case _Alignof: case _Alignof:
// unsafe.Alignof(x T) uintptr, where x must be a variable
x.mode = constant x.mode = constant
x.val = exact.MakeInt64(check.conf.alignof(x.typ)) x.val = exact.MakeInt64(check.conf.alignof(x.typ))
x.typ = Typ[Uintptr] x.typ = Typ[Uintptr]
case _Offsetof: case _Offsetof:
arg, ok := unparen(arg0).(*ast.SelectorExpr) // unsafe.Offsetof(x T) uintptr, where x must be a selector
if !ok { // (no argument evaluated yet)
arg0 := call.Args[0]
selx, _ := unparen(arg0).(*ast.SelectorExpr)
if selx == nil {
check.invalidArg(arg0.Pos(), "%s is not a selector expression", arg0) check.invalidArg(arg0.Pos(), "%s is not a selector expression", arg0)
goto Error check.rawExpr(x, arg0, nil) // evaluate to avoid spurious "declared but not used" errors
return
} }
check.expr(x, arg.X) check.expr(x, selx.X)
if x.mode == invalid { if x.mode == invalid {
goto Error return
} }
base := derefStructPtr(x.typ) base := derefStructPtr(x.typ)
sel := arg.Sel.Name sel := selx.Sel.Name
obj, index, indirect := LookupFieldOrMethod(base, check.pkg, arg.Sel.Name) obj, index, indirect := LookupFieldOrMethod(base, check.pkg, sel)
switch obj.(type) { switch obj.(type) {
case nil: case nil:
check.invalidArg(x.pos(), "%s has no single field %s", base, sel) check.invalidArg(x.pos(), "%s has no single field %s", base, sel)
goto Error return
case *Func: case *Func:
check.invalidArg(arg0.Pos(), "%s is a method value", arg0) check.invalidArg(arg0.Pos(), "%s is a method value", arg0)
goto Error return
} }
if indirect { if indirect {
check.invalidArg(x.pos(), "field %s is embedded via a pointer in %s", sel, base) check.invalidArg(x.pos(), "field %s is embedded via a pointer in %s", sel, base)
goto Error return
} }
// TODO(gri) Should we pass x.typ instead of base (and indirect report if derefStructPtr indirected)? // TODO(gri) Should we pass x.typ instead of base (and indirect report if derefStructPtr indirected)?
check.recordSelection(arg, FieldVal, base, obj, index, false) check.recordSelection(selx, FieldVal, base, obj, index, false)
offs := check.conf.offsetof(base, index) offs := check.conf.offsetof(base, index)
x.mode = constant x.mode = constant
@ -396,6 +419,7 @@ func (check *checker) builtin(x *operand, call *ast.CallExpr, id builtinId) {
x.typ = Typ[Uintptr] x.typ = Typ[Uintptr]
case _Sizeof: case _Sizeof:
// unsafe.Sizeof(x T) uintptr
x.mode = constant x.mode = constant
x.val = exact.MakeInt64(check.conf.sizeof(x.typ)) x.val = exact.MakeInt64(check.conf.sizeof(x.typ))
x.typ = Typ[Uintptr] x.typ = Typ[Uintptr]
@ -406,11 +430,11 @@ func (check *checker) builtin(x *operand, call *ast.CallExpr, id builtinId) {
// Note: assert is only available in self-test mode. // Note: assert is only available in self-test mode.
if x.mode != constant || !isBoolean(x.typ) { if x.mode != constant || !isBoolean(x.typ) {
check.invalidArg(x.pos(), "%s is not a boolean constant", x) check.invalidArg(x.pos(), "%s is not a boolean constant", x)
goto Error return
} }
if x.val.Kind() != exact.Bool { if x.val.Kind() != exact.Bool {
check.errorf(x.pos(), "internal error: value of %s should be a boolean constant", x) check.errorf(x.pos(), "internal error: value of %s should be a boolean constant", x)
goto Error return
} }
if !exact.BoolVal(x.val) { if !exact.BoolVal(x.val) {
check.errorf(call.Pos(), "%s failed", call) check.errorf(call.Pos(), "%s failed", call)
@ -422,15 +446,15 @@ func (check *checker) builtin(x *operand, call *ast.CallExpr, id builtinId) {
// values of its arguments. The result of trace is the value // values of its arguments. The result of trace is the value
// of the first argument. // of the first argument.
// Note: trace is only available in self-test mode. // Note: trace is only available in self-test mode.
if len(args) == 0 { // (no argument evaluated yet)
if nargs == 0 {
check.dump("%s: trace() without arguments", call.Pos()) check.dump("%s: trace() without arguments", call.Pos())
x.mode = novalue x.mode = novalue
x.expr = call break
return
} }
var t operand var t operand
x1 := x x1 := x
for _, arg := range args { for _, arg := range call.Args {
check.rawExpr(x1, arg, nil) // permit trace for types, e.g.: new(trace(T)) check.rawExpr(x1, arg, nil) // permit trace for types, e.g.: new(trace(T))
check.dump("%s: %s", x1.pos(), x1) check.dump("%s: %s", x1.pos(), x1)
x1 = &t // use incoming x only for first argument x1 = &t // use incoming x only for first argument
@ -440,24 +464,22 @@ func (check *checker) builtin(x *operand, call *ast.CallExpr, id builtinId) {
unreachable() unreachable()
} }
x.expr = call return true
return
Error:
x.mode = invalid
x.expr = call
} }
// makeSig returns the signature for the given parameter and result types. // makeSig makes a signature for the given argument and result types.
func makeSig(result Type, params ...Type) *Signature { // res may be nil.
list := make([]*Var, len(params)) func makeSig(res Type, args ...Type) *Signature {
for i, param := range params { list := make([]*Var, len(args))
for i, param := range args {
list[i] = NewVar(token.NoPos, nil, "", param) list[i] = NewVar(token.NoPos, nil, "", param)
} }
return &Signature{ params := NewTuple(list...)
params: NewTuple(list...), var result *Tuple
results: NewTuple(NewVar(token.NoPos, nil, "", result)), if res != nil {
result = NewTuple(NewVar(token.NoPos, nil, "", res))
} }
return &Signature{params: params, results: result}
} }
// implicitArrayDeref returns A if typ is of the form *A and A is an array; // implicitArrayDeref returns A if typ is of the form *A and A is an array;

120
go/types/call.go
View File

@ -49,7 +49,10 @@ func (check *checker) call(x *operand, e *ast.CallExpr) exprKind {
case builtin: case builtin:
id := x.id id := x.id
check.builtin(x, e, id) if !check.builtin(x, e, id) {
x.mode = invalid
}
x.expr = e
return predeclaredFuncs[id].kind return predeclaredFuncs[id].kind
default: default:
@ -62,7 +65,8 @@ func (check *checker) call(x *operand, e *ast.CallExpr) exprKind {
return statement return statement
} }
check.arguments(x, e, sig, func(x *operand, i int) { check.expr(x, e.Args[i]) }) arg, n := unpack(func(x *operand, i int) { check.expr(x, e.Args[i]) }, len(e.Args), false)
check.arguments(x, e, sig, arg, n)
// determine result // determine result
switch sig.results.Len() { switch sig.results.Len() {
@ -81,9 +85,88 @@ func (check *checker) call(x *operand, e *ast.CallExpr) exprKind {
} }
} }
// TODO(gri) use unpack for assignment checking as well.
// A getter sets x as the i'th operand, where 0 <= i < n and n is the total
// number of operands (context-specific, and maintained elsewhere). A getter
// type-checks the i'th operand; the details of the actual check are getter-
// specific.
type getter func(x *operand, i int)
// unpack takes a getter get and a number of operands n. If n == 1 and the
// first operand is a function call, or a comma,ok expression and allowCommaOk
// is set, the result is a new getter and operand count providing access to the
// function results, or comma,ok values, respectively. In all other cases, the
// incoming getter and operand count are returned unchanged. In other words,
// if there's exactly one operand that - after type-checking by calling get -
// stands for multiple operands, the resulting getter provides access to those
// operands instead.
//
// Note that unpack may call get(..., 0); but if the result getter is called
// at most once for a given operand index i (including i == 0), that operand
// is guaranteed to cause only one call of the incoming getter with that i.
//
func unpack(get getter, n int, allowCommaOk bool) (getter, int) {
if n == 1 {
// possibly result of an n-valued function call or comma,ok value
var x0 operand
get(&x0, 0)
if x0.mode == invalid {
return func(x *operand, i int) {
if i != 0 {
unreachable()
}
// i == 0
x.mode = invalid
}, 1
}
if t, ok := x0.typ.(*Tuple); ok {
// result of an n-valued function call
return func(x *operand, i int) {
x.mode = value
x.expr = x0.expr
x.typ = t.At(i).typ
}, t.Len()
}
if x0.mode == valueok {
// comma-ok value
if allowCommaOk {
return func(x *operand, i int) {
switch i {
case 0:
x.mode = value
x.expr = x0.expr
x.typ = x0.typ
case 1:
x.mode = value
x.expr = x0.expr
x.typ = Typ[UntypedBool]
default:
unreachable()
}
}, 2
}
x0.mode = value
}
// single value
return func(x *operand, i int) {
if i != 0 {
unreachable()
}
*x = x0
}, 1
}
// zero or multiple values
return get, n
}
// arguments checks argument passing for the call with the given signature. // arguments checks argument passing for the call with the given signature.
// The arg function provides the operand for the i'th argument. // The arg function provides the operand for the i'th argument.
func (check *checker) arguments(x *operand, call *ast.CallExpr, sig *Signature, arg func(*operand, int)) { func (check *checker) arguments(x *operand, call *ast.CallExpr, sig *Signature, arg func(*operand, int), n int) {
passSlice := false passSlice := false
if call.Ellipsis.IsValid() { if call.Ellipsis.IsValid() {
// last argument is of the form x... // last argument is of the form x...
@ -96,35 +179,10 @@ func (check *checker) arguments(x *operand, call *ast.CallExpr, sig *Signature,
} }
// evaluate arguments // evaluate arguments
n := len(call.Args) // argument count for i := 0; i < n; i++ {
if n == 1 { arg(x, i)
// single argument but possibly a multi-valued function call
arg(x, 0)
if x.mode != invalid { if x.mode != invalid {
if t, ok := x.typ.(*Tuple); ok { check.argument(sig, i, x, passSlice && i == n-1)
// argument is multi-valued function call
n = t.Len()
expr := call.Args[0]
for i := 0; i < n; i++ {
x.mode = value
x.expr = expr
x.typ = t.At(i).typ
check.argument(sig, i, x, passSlice && i == n-1)
}
} else {
// single value
check.argument(sig, 0, x, passSlice)
}
} else {
n = sig.params.Len() // avoid additional argument length errors below
}
} else {
// zero or multiple arguments
for i := range call.Args {
arg(x, i)
if x.mode != invalid {
check.argument(sig, i, x, passSlice && i == n-1)
}
} }
} }

487
go/types/testdata/builtins.src vendored
View File

@ -8,16 +8,18 @@ package builtins
import "unsafe" import "unsafe"
func _append1() { func f0() {}
func append1() {
var b byte var b byte
var x int var x int
var s []byte var s []byte
_ = append /* ERROR "argument" */ () _ = append() // ERROR not enough arguments
_ = append("foo" /* ERROR "not a slice" */ ) _ = append("foo" /* ERROR not a slice */ )
_ = append(nil /* ERROR "not a slice" */ , s) _ = append(nil /* ERROR not a slice */ , s)
_ = append(x /* ERROR "not a slice" */ , s) _ = append(x /* ERROR not a slice */ , s)
_ = append(s) _ = append(s)
append /* ERROR "not used" */ (s) append /* ERROR not used */ (s)
_ = append(s, b) _ = append(s, b)
_ = append(s, x /* ERROR cannot pass argument x */ ) _ = append(s, x /* ERROR cannot pass argument x */ )
@ -47,7 +49,7 @@ func _append1() {
} }
// from the spec // from the spec
func _append2() { func append2() {
s0 := []int{0, 0} s0 := []int{0, 0}
s1 := append(s0, 2) // append a single element s1 == []int{0, 0, 2} s1 := append(s0, 2) // append a single element s1 == []int{0, 0, 2}
s2 := append(s1, 3, 5, 7) // append multiple elements s2 == []int{0, 0, 2, 3, 5, 7} s2 := append(s1, 3, 5, 7) // append multiple elements s2 == []int{0, 0, 2, 3, 5, 7}
@ -63,50 +65,83 @@ func _append2() {
_ = s4 _ = s4
} }
func _cap() { func append3() {
f1 := func() (s []int) { return }
f2 := func() (s []int, x int) { return }
f3 := func() (s []int, x, y int) { return }
f5 := func() (s []interface{}, x int, y float32, z string, b bool) { return }
ff := func() (int, float32) { return 0, 0 }
_ = append(f0 /* ERROR used as value */ ())
_ = append(f1())
_ = append(f2())
_ = append(f3())
_ = append(f5())
_ = append(ff /* ERROR not a slice */ ()) // TODO(gri) better error message
}
func cap1() {
var a [10]bool var a [10]bool
var p *[20]int var p *[20]int
var c chan string var c chan string
_ = cap /* ERROR "argument" */ () _ = cap() // ERROR not enough arguments
_ = cap /* ERROR "argument" */ (1, 2) _ = cap(1, 2) // ERROR too many arguments
_ = cap(42 /* ERROR "invalid" */) _ = cap(42 /* ERROR invalid */)
const _3 = cap(a) const _3 = cap(a)
assert(_3 == 10) assert(_3 == 10)
const _4 = cap(p) const _4 = cap(p)
assert(_4 == 20) assert(_4 == 20)
_ = cap(c) _ = cap(c)
cap /* ERROR "not used" */ (c) cap /* ERROR not used */ (c)
// issue 4744 // issue 4744
type T struct{ a [10]int } type T struct{ a [10]int }
const _ = cap(((*T)(nil)).a) const _ = cap(((*T)(nil)).a)
} }
func _close() { func cap2() {
var c chan int f1a := func() (a [10]int) { return }
var r <-chan int f1s := func() (s []int) { return }
close /* ERROR "argument" */ () f2 := func() (s []int, x int) { return }
close /* ERROR "argument" */ (1, 2) _ = cap(f0 /* ERROR used as value */ ())
close(42 /* ERROR "not a channel" */) _ = cap(f1a())
close(r /* ERROR "receive-only channel" */) _ = cap(f1s())
close(c) _ = cap(f2()) // ERROR too many arguments
} }
func _complex() { func close1() {
var c chan int
var r <-chan int
close() // ERROR not enough arguments
close(1, 2) // ERROR too many arguments
close(42 /* ERROR not a channel */)
close(r /* ERROR receive-only channel */)
close(c)
_ = close /* ERROR used as value */ (c)
}
func close2() {
f1 := func() (ch chan int) { return }
f2 := func() (ch chan int, x int) { return }
close(f0 /* ERROR used as value */ ())
close(f1())
close(f2()) // ERROR too many arguments
}
func complex1() {
var i32 int32 var i32 int32
var f32 float32 var f32 float32
var f64 float64 var f64 float64
var c64 complex64 var c64 complex64
_ = complex /* ERROR "argument" */ () _ = complex() // ERROR not enough arguments
_ = complex /* ERROR "argument" */ (1) _ = complex(1) // ERROR not enough arguments
_ = complex(true /* ERROR "invalid argument" */ , 0) _ = complex(true /* ERROR invalid argument */ , 0)
_ = complex(i32 /* ERROR "invalid argument" */ , 0) _ = complex(i32 /* ERROR invalid argument */ , 0)
_ = complex("foo" /* ERROR "invalid argument" */ , 0) _ = complex("foo" /* ERROR invalid argument */ , 0)
_ = complex(c64 /* ERROR "invalid argument" */ , 0) _ = complex(c64 /* ERROR invalid argument */ , 0)
_ = complex(0, true /* ERROR "invalid argument" */ ) _ = complex(0, true /* ERROR invalid argument */ )
_ = complex(0, i32 /* ERROR "invalid argument" */ ) _ = complex(0, i32 /* ERROR invalid argument */ )
_ = complex(0, "foo" /* ERROR "invalid argument" */ ) _ = complex(0, "foo" /* ERROR invalid argument */ )
_ = complex(0, c64 /* ERROR "invalid argument" */ ) _ = complex(0, c64 /* ERROR invalid argument */ )
_ = complex(f32, f32) _ = complex(f32, f32)
_ = complex(f32, 1) _ = complex(f32, 1)
_ = complex(f32, 1.0) _ = complex(f32, 1.0)
@ -115,17 +150,17 @@ func _complex() {
_ = complex(f64, 1) _ = complex(f64, 1)
_ = complex(f64, 1.0) _ = complex(f64, 1.0)
_ = complex(f64, 'a') _ = complex(f64, 'a')
_ = complex(f32 /* ERROR "mismatched types" */, f64) _ = complex(f32 /* ERROR mismatched types */, f64)
_ = complex(f64 /* ERROR "mismatched types" */, f32) _ = complex(f64 /* ERROR mismatched types */, f32)
_ = complex(1, 1) _ = complex(1, 1)
_ = complex(1, 1.1) _ = complex(1, 1.1)
_ = complex(1, 'a') _ = complex(1, 'a')
complex /* ERROR "not used" */ (1, 2) complex /* ERROR not used */ (1, 2)
var _ complex64 = complex(f32, f32) var _ complex64 = complex(f32, f32)
var _ complex64 = complex /* ERROR "cannot initialize" */ (f64, f64) var _ complex64 = complex /* ERROR cannot initialize */ (f64, f64)
var _ complex128 = complex /* ERROR "cannot initialize" */ (f32, f32) var _ complex128 = complex /* ERROR cannot initialize */ (f32, f32)
var _ complex128 = complex(f64, f64) var _ complex128 = complex(f64, f64)
// untyped constants // untyped constants
@ -134,22 +169,32 @@ func _complex() {
const _ complex64 = complex(1, 0) const _ complex64 = complex(1, 0)
const _ complex128 = complex(1, 0) const _ complex128 = complex(1, 0)
const _ int = complex /* ERROR "int" */ (1.1, 0) const _ int = complex /* ERROR int */ (1.1, 0)
const _ float32 = complex /* ERROR "float32" */ (1, 2) const _ float32 = complex /* ERROR float32 */ (1, 2)
// untyped values // untyped values
var s uint var s uint
_ = complex(1 /* ERROR "integer" */ <<s, 0) _ = complex(1 /* ERROR integer */ <<s, 0)
const _ = complex /* ERROR "not constant" */ (1 /* ERROR "integer" */ <<s, 0) const _ = complex /* ERROR not constant */ (1 /* ERROR integer */ <<s, 0)
var _ int = complex /* ERROR "cannot initialize" */ (1 /* ERROR "integer" */ <<s, 0) var _ int = complex /* ERROR cannot initialize */ (1 /* ERROR integer */ <<s, 0)
} }
func _copy() { func complex2() {
copy /* ERROR "not enough arguments" */ () f1 := func() (x float32) { return }
copy /* ERROR "not enough arguments" */ ("foo") f2 := func() (x, y float32) { return }
copy([ /* ERROR "copy expects slice arguments" */ ...]int{}, []int{}) f3 := func() (x, y, z float32) { return }
copy([ /* ERROR "copy expects slice arguments" */ ]int{}, [...]int{}) _ = complex(f0 /* ERROR used as value */ ())
copy([ /* ERROR "different element types" */ ]int8{}, "foo") _ = complex(f1()) // ERROR not enough arguments
_ = complex(f2())
_ = complex(f3()) // ERROR too many arguments
}
func copy1() {
copy() // ERROR not enough arguments
copy("foo") // ERROR not enough arguments
copy([ /* ERROR copy expects slice arguments */ ...]int{}, []int{})
copy([ /* ERROR copy expects slice arguments */ ]int{}, [...]int{})
copy([ /* ERROR different element types */ ]int8{}, "foo")
// spec examples // spec examples
var a = [...]int{0, 1, 2, 3, 4, 5, 6, 7} var a = [...]int{0, 1, 2, 3, 4, 5, 6, 7}
@ -161,26 +206,47 @@ func _copy() {
_, _, _ = n1, n2, n3 _, _, _ = n1, n2, n3
} }
func _delete() { func copy2() {
var m map[string]int f1 := func() (a []int) { return }
var s string f2 := func() (a, b []int) { return }
delete /* ERROR "argument" */ () f3 := func() (a, b, c []int) { return }
delete /* ERROR "argument" */ (1) copy(f0 /* ERROR used as value */ ())
delete /* ERROR "argument" */ (1, 2, 3) copy(f1()) // ERROR not enough arguments
delete(m, 0 /* ERROR "not assignable" */) copy(f2())
delete(m, s) copy(f3()) // ERROR too many arguments
} }
func _imag() { func delete1() {
var m map[string]int
var s string
delete() // ERROR not enough arguments
delete(1) // ERROR not enough arguments
delete(1, 2, 3) // ERROR too many arguments
delete(m, 0 /* ERROR not assignable */)
delete(m, s)
_ = delete /* ERROR used as value */ (m, s)
}
func delete2() {
f1 := func() (m map[string]int) { return }
f2 := func() (m map[string]int, k string) { return }
f3 := func() (m map[string]int, k string, x float32) { return }
delete(f0 /* ERROR used as value */ ())
delete(f1()) // ERROR not enough arguments
delete(f2())
delete(f3()) // ERROR too many arguments
}
func imag1() {
var f32 float32 var f32 float32
var f64 float64 var f64 float64
var c64 complex64 var c64 complex64
var c128 complex128 var c128 complex128
_ = imag /* ERROR "argument" */ () _ = imag() // ERROR not enough arguments
_ = imag /* ERROR "argument" */ (1, 2) _ = imag(1, 2) // ERROR too many arguments
_ = imag(10 /* ERROR "must be a complex number" */) _ = imag(10 /* ERROR must be a complex number */)
_ = imag(2.7182818 /* ERROR "must be a complex number" */) _ = imag(2.7182818 /* ERROR must be a complex number */)
_ = imag("foo" /* ERROR "must be a complex number" */) _ = imag("foo" /* ERROR must be a complex number */)
const _5 = imag(1 + 2i) const _5 = imag(1 + 2i)
assert(_5 == 2) assert(_5 == 2)
f32 = _5 f32 = _5
@ -189,20 +255,28 @@ func _imag() {
assert(_6 == 0) assert(_6 == 0)
f32 = imag(c64) f32 = imag(c64)
f64 = imag(c128) f64 = imag(c128)
f32 = imag /* ERROR "cannot assign" */ (c128) f32 = imag /* ERROR cannot assign */ (c128)
f64 = imag /* ERROR "cannot assign" */ (c64) f64 = imag /* ERROR cannot assign */ (c64)
imag /* ERROR "not used" */ (c64) imag /* ERROR not used */ (c64)
_, _ = f32, f64 _, _ = f32, f64
} }
func _len() { func imag2() {
f1 := func() (x complex128) { return }
f2 := func() (x, y complex128) { return }
_ = imag(f0 /* ERROR used as value */ ())
_ = imag(f1())
_ = imag(f2()) // ERROR too many arguments
}
func len1() {
const c = "foobar" const c = "foobar"
var a [10]bool var a [10]bool
var p *[20]int var p *[20]int
var m map[string]complex128 var m map[string]complex128
_ = len /* ERROR "argument" */ () _ = len() // ERROR not enough arguments
_ = len /* ERROR "argument" */ (1, 2) _ = len(1, 2) // ERROR too many arguments
_ = len(42 /* ERROR "invalid" */) _ = len(42 /* ERROR invalid */)
const _3 = len(c) const _3 = len(c)
assert(_3 == 6) assert(_3 == 6)
const _4 = len(a) const _4 = len(a)
@ -210,54 +284,62 @@ func _len() {
const _5 = len(p) const _5 = len(p)
assert(_5 == 20) assert(_5 == 20)
_ = len(m) _ = len(m)
len /* ERROR "not used" */ (c) len /* ERROR not used */ (c)
// esoteric case // esoteric case
var t string var t string
var hash map[interface{}][]*[10]int var hash map[interface{}][]*[10]int
const n = len /* ERROR "not constant" */ (hash[recover()][len(t)]) const n = len /* ERROR not constant */ (hash[recover()][len(t)])
assert(n == 10) // ok because n has unknown value and no error is reported assert(n == 10) // ok because n has unknown value and no error is reported
var ch <-chan int var ch <-chan int
const nn = len /* ERROR "not constant" */ (hash[<-ch][len(t)]) const nn = len /* ERROR not constant */ (hash[<-ch][len(t)])
// issue 4744 // issue 4744
type T struct{ a [10]int } type T struct{ a [10]int }
const _ = len(((*T)(nil)).a) const _ = len(((*T)(nil)).a)
} }
func _make() { func len2() {
f1 := func() (x []int) { return }
f2 := func() (x, y []int) { return }
_ = len(f0 /* ERROR used as value */ ())
_ = len(f1())
_ = len(f2()) // ERROR too many arguments
}
func make1() {
var n int var n int
var m float32 var m float32
var s uint var s uint
_ = make /* ERROR "argument" */ () _ = make() // ERROR not enough arguments
_ = make(1 /* ERROR "not a type" */) _ = make(1 /* ERROR not a type */)
_ = make(int /* ERROR "cannot make" */) _ = make(int /* ERROR cannot make */)
// slices // slices
_ = make/* ERROR "arguments" */ ([]int) _ = make/* ERROR arguments */ ([]int)
_ = make/* ERROR "arguments" */ ([]int, 2, 3, 4) _ = make/* ERROR arguments */ ([]int, 2, 3, 4)
_ = make([]int, int /* ERROR "not an expression" */) _ = make([]int, int /* ERROR not an expression */)
_ = make([]int, 10, float32 /* ERROR "not an expression" */) _ = make([]int, 10, float32 /* ERROR not an expression */)
_ = make([]int, "foo" /* ERROR "cannot convert" */) _ = make([]int, "foo" /* ERROR cannot convert */)
_ = make([]int, 10, 2.3 /* ERROR "overflows" */) _ = make([]int, 10, 2.3 /* ERROR overflows */)
_ = make([]int, 5, 10.0) _ = make([]int, 5, 10.0)
_ = make([]int, 0i) _ = make([]int, 0i)
_ = make([]int, 1.0) _ = make([]int, 1.0)
_ = make([]int, 1.0<<s) _ = make([]int, 1.0<<s)
_ = make([]int, 1.1 /* ERROR "int" */ <<s) _ = make([]int, 1.1 /* ERROR int */ <<s)
_ = make([]int, - /* ERROR "must not be negative" */ 1, 10) _ = make([]int, - /* ERROR must not be negative */ 1, 10)
_ = make([]int, 0, - /* ERROR "must not be negative" */ 1) _ = make([]int, 0, - /* ERROR must not be negative */ 1)
_ = make([]int, - /* ERROR "must not be negative" */ 1, - /* ERROR "must not be negative" */ 1) _ = make([]int, - /* ERROR must not be negative */ 1, - /* ERROR must not be negative */ 1)
_ = make([]int, 1 /* ERROR "overflows" */ <<100, 1 /* ERROR "overflows" */ <<100) _ = make([]int, 1 /* ERROR overflows */ <<100, 1 /* ERROR overflows */ <<100)
_ = make([]int, 10 /* ERROR "length and capacity swapped" */ , 9) _ = make([]int, 10 /* ERROR length and capacity swapped */ , 9)
_ = make([]int, 1 /* ERROR "overflows" */ <<100, 12345) _ = make([]int, 1 /* ERROR overflows */ <<100, 12345)
_ = make([]int, m /* ERROR "must be integer" */ ) _ = make([]int, m /* ERROR must be integer */ )
// maps // maps
_ = make /* ERROR "arguments" */ (map[int]string, 10, 20) _ = make /* ERROR arguments */ (map[int]string, 10, 20)
_ = make(map[int]float32, int /* ERROR "not an expression" */) _ = make(map[int]float32, int /* ERROR not an expression */)
_ = make(map[int]float32, "foo" /* ERROR "cannot convert" */) _ = make(map[int]float32, "foo" /* ERROR cannot convert */)
_ = make(map[int]float32, 10) _ = make(map[int]float32, 10)
_ = make(map[int]float32, n) _ = make(map[int]float32, n)
_ = make(map[int]float32, int64(n)) _ = make(map[int]float32, int64(n))
@ -265,65 +347,111 @@ func _make() {
_ = make(map[string]bool, 10.0<<s) _ = make(map[string]bool, 10.0<<s)
// channels // channels
_ = make /* ERROR "arguments" */ (chan int, 10, 20) _ = make /* ERROR arguments */ (chan int, 10, 20)
_ = make(chan int, int /* ERROR "not an expression" */) _ = make(chan int, int /* ERROR not an expression */)
_ = make(chan<- int, "foo" /* ERROR "cannot convert" */) _ = make(chan<- int, "foo" /* ERROR cannot convert */)
_ = make(<-chan float64, 10) _ = make(<-chan float64, 10)
_ = make(chan chan int, n) _ = make(chan chan int, n)
_ = make(chan string, int64(n)) _ = make(chan string, int64(n))
_ = make(chan bool, 10.0) _ = make(chan bool, 10.0)
_ = make(chan bool, 10.0<<s) _ = make(chan bool, 10.0<<s)
make /* ERROR "not used" */ ([]int, 10) make /* ERROR not used */ ([]int, 10)
} }
func _new() { func make2() {
_ = new /* ERROR "argument" */ () f1 /* ERROR not used */ := func() (x []int) { return }
_ = new /* ERROR "argument" */ (1, 2) _ = make(f0 /* ERROR not a type */ ())
_ = new("foo" /* ERROR "not a type" */) _ = make(f1 /* ERROR not a type */ ())
}
func new1() {
_ = new() // ERROR not enough arguments
_ = new(1, 2) // ERROR too many arguments
_ = new("foo" /* ERROR not a type */)
p := new(float64) p := new(float64)
_ = new(struct{ x, y int }) _ = new(struct{ x, y int })
q := new(*float64) q := new(*float64)
_ = *p == **q _ = *p == **q
new /* ERROR "not used" */ (int) new /* ERROR not used */ (int)
} }
func _panic() { func new2() {
panic /* ERROR "arguments" */ () f1 /* ERROR not used */ := func() (x []int) { return }
panic /* ERROR "arguments" */ (1, 2) _ = new(f0 /* ERROR not a type */ ())
_ = new(f1 /* ERROR not a type */ ())
}
func panic1() {
panic() // ERROR not enough arguments
panic(1, 2) // ERROR too many arguments
panic(0) panic(0)
panic("foo") panic("foo")
panic(false) panic(false)
panic(1<<1000) // TODO(gri) argument should be assignable to _
_ = panic /* ERROR used as value */ (0)
} }
func _print() { func panic2() {
f1 := func() (x int) { return }
f2 := func() (x, y int) { return }
panic(f0 /* ERROR used as value */ ())
panic(f1())
panic(f2()) // ERROR too many arguments
}
func print1() {
print() print()
print(1) print(1)
print(1, 2) print(1, 2)
print("foo") print("foo")
print(2.718281828) print(2.718281828)
print(false) print(false)
print(1<<1000, 1<<1000) // TODO(gri) arguments should be assignable to _
_ = print /* ERROR used as value */ ()
} }
func _println() { func print2() {
f1 := func() (x int) { return }
f2 := func() (x, y int) { return }
f3 := func() (x int, y float32, z string) { return }
print(f0 /* ERROR used as value */ ())
print(f1())
print(f2())
print(f3())
}
func println1() {
println() println()
println(1) println(1)
println(1, 2) println(1, 2)
println("foo") println("foo")
println(2.718281828) println(2.718281828)
println(false) println(false)
println(1<<1000, 1<<1000) // TODO(gri) arguments should be assignable to _
_ = println /* ERROR used as value */ ()
} }
func _real() { func println2() {
f1 := func() (x int) { return }
f2 := func() (x, y int) { return }
f3 := func() (x int, y float32, z string) { return }
println(f0 /* ERROR used as value */ ())
println(f1())
println(f2())
println(f3())
}
func real1() {
var f32 float32 var f32 float32
var f64 float64 var f64 float64
var c64 complex64 var c64 complex64
var c128 complex128 var c128 complex128
_ = real /* ERROR "argument" */ () _ = real() // ERROR not enough arguments
_ = real /* ERROR "argument" */ (1, 2) _ = real(1, 2) // ERROR too many arguments
_ = real(10 /* ERROR "must be a complex number" */) _ = real(10 /* ERROR must be a complex number */)
_ = real(2.7182818 /* ERROR "must be a complex number" */) _ = real(2.7182818 /* ERROR must be a complex number */)
_ = real("foo" /* ERROR "must be a complex number" */) _ = real("foo" /* ERROR must be a complex number */)
const _5 = real(1 + 2i) const _5 = real(1 + 2i)
assert(_5 == 1) assert(_5 == 1)
f32 = _5 f32 = _5
@ -332,18 +460,34 @@ func _real() {
assert(_6 == 0) assert(_6 == 0)
f32 = real(c64) f32 = real(c64)
f64 = real(c128) f64 = real(c128)
f32 = real /* ERROR "cannot assign" */ (c128) f32 = real /* ERROR cannot assign */ (c128)
f64 = real /* ERROR "cannot assign" */ (c64) f64 = real /* ERROR cannot assign */ (c64)
real /* ERROR "not used" */ (c64) real /* ERROR not used */ (c64)
_, _ = f32, f64 _, _ = f32, f64
} }
func _recover() { func real2() {
f1 := func() (x complex128) { return }
f2 := func() (x, y complex128) { return }
_ = real(f0 /* ERROR used as value */ ())
_ = real(f1())
_ = real(f2()) // ERROR too many arguments
}
func recover1() {
_ = recover() _ = recover()
_ = recover /* ERROR "argument" */ (10) _ = recover(10) // ERROR too many arguments
recover() recover()
} }
func recover2() {
f1 := func() (x int) { return }
f2 := func() (x, y int) { return }
_ = recover(f0 /* ERROR used as value */ ())
_ = recover(f1()) // ERROR too many arguments
_ = recover(f2()) // ERROR too many arguments
}
// assuming types.DefaultPtrSize == 8 // assuming types.DefaultPtrSize == 8
type S0 struct{ // offset type S0 struct{ // offset
a bool // 0 a bool // 0
@ -366,14 +510,14 @@ type S2 struct{ // offset
func (S2) m() {} func (S2) m() {}
func _Alignof() { func Alignof1() {
var x int var x int
_ = unsafe /* ERROR "argument" */ .Alignof() _ = unsafe.Alignof() // ERROR not enough arguments
_ = unsafe /* ERROR "argument" */ .Alignof(1, 2) _ = unsafe.Alignof(1, 2) // ERROR too many arguments
_ = unsafe.Alignof(int /* ERROR "not an expression" */) _ = unsafe.Alignof(int /* ERROR not an expression */)
_ = unsafe.Alignof(42) _ = unsafe.Alignof(42)
_ = unsafe.Alignof(new(struct{})) _ = unsafe.Alignof(new(struct{}))
unsafe /* ERROR "not used" */ .Alignof(x) unsafe /* ERROR not used */ .Alignof(x)
var y S0 var y S0
assert(unsafe.Alignof(y.a) == 1) assert(unsafe.Alignof(y.a) == 1)
@ -383,16 +527,24 @@ func _Alignof() {
assert(unsafe.Alignof(y.e) == 8) assert(unsafe.Alignof(y.e) == 8)
} }
func _Offsetof() { func Alignof2() {
f1 := func() (x int32) { return }
f2 := func() (x, y int32) { return }
_ = unsafe.Alignof(f0 /* ERROR used as value */ ())
assert(unsafe.Alignof(f1()) == 4)
_ = unsafe.Alignof(f2()) // ERROR too many arguments
}
func Offsetof1() {
var x struct{ f int } var x struct{ f int }
_ = unsafe /* ERROR "argument" */ .Offsetof() _ = unsafe.Offsetof() // ERROR not enough arguments
_ = unsafe /* ERROR "argument" */ .Offsetof(1, 2) _ = unsafe.Offsetof(1, 2) // ERROR too many arguments
_ = unsafe.Offsetof(int /* ERROR "not a selector expression" */) _ = unsafe.Offsetof(int /* ERROR not a selector expression */)
_ = unsafe.Offsetof(x /* ERROR "not a selector expression" */) _ = unsafe.Offsetof(x /* ERROR not a selector expression */)
_ = unsafe.Offsetof(x.f) _ = unsafe.Offsetof(x.f)
_ = unsafe.Offsetof((x.f)) _ = unsafe.Offsetof((x.f))
_ = unsafe.Offsetof((((((((x))).f))))) _ = unsafe.Offsetof((((((((x))).f)))))
unsafe /* ERROR "not used" */ .Offsetof(x.f) unsafe /* ERROR not used */ .Offsetof(x.f)
var y0 S0 var y0 S0
assert(unsafe.Offsetof(y0.a) == 0) assert(unsafe.Offsetof(y0.a) == 0)
@ -423,18 +575,26 @@ func _Offsetof() {
var y2 S2 var y2 S2
assert(unsafe.Offsetof(y2.S1) == 0) assert(unsafe.Offsetof(y2.S1) == 0)
_ = unsafe.Offsetof(y2 /* ERROR "embedded via a pointer" */ .x) _ = unsafe.Offsetof(y2 /* ERROR embedded via a pointer */ .x)
_ = unsafe.Offsetof(y2 /* ERROR "method value" */ .m) _ = unsafe.Offsetof(y2 /* ERROR method value */ .m)
} }
func _Sizeof() { func Offsetof2() {
f1 := func() (x int32) { return }
f2 := func() (x, y int32) { return }
_ = unsafe.Offsetof(f0 /* ERROR not a selector expression */ ())
_ = unsafe.Offsetof(f1 /* ERROR not a selector expression */ ())
_ = unsafe.Offsetof(f2 /* ERROR not a selector expression */ ())
}
func Sizeof1() {
var x int var x int
_ = unsafe /* ERROR "argument" */ .Sizeof() _ = unsafe.Sizeof() // ERROR not enough arguments
_ = unsafe /* ERROR "argument" */ .Sizeof(1, 2) _ = unsafe.Sizeof(1, 2) // ERROR too many arguments
_ = unsafe.Sizeof(int /* ERROR "not an expression" */) _ = unsafe.Sizeof(int /* ERROR not an expression */)
_ = unsafe.Sizeof(42) _ = unsafe.Sizeof(42)
_ = unsafe.Sizeof(new(complex128)) _ = unsafe.Sizeof(new(complex128))
unsafe /* ERROR "not used" */ .Sizeof(x) unsafe /* ERROR not used */ .Sizeof(x)
// basic types have size guarantees // basic types have size guarantees
assert(unsafe.Sizeof(byte(0)) == 1) assert(unsafe.Sizeof(byte(0)) == 1)
@ -474,21 +634,56 @@ func _Sizeof() {
assert(unsafe.Sizeof(T{}) == 12) assert(unsafe.Sizeof(T{}) == 12)
} }
// self-testing only func Sizeof2() {
func _assert() { f1 := func() (x int64) { return }
var x int f2 := func() (x, y int64) { return }
assert /* ERROR "argument" */ () _ = unsafe.Sizeof(f0 /* ERROR used as value */ ())
assert /* ERROR "argument" */ (1, 2) assert(unsafe.Sizeof(f1()) == 8)
assert("foo" /* ERROR "boolean constant" */ ) _ = unsafe.Sizeof(f2()) // ERROR too many arguments
assert(x /* ERROR "boolean constant" */)
assert(true)
assert /* ERROR "failed" */ (false)
} }
// self-testing only // self-testing only
func _trace() { func assert1() {
var x int
assert() /* ERROR not enough arguments */
assert(1, 2) /* ERROR too many arguments */
assert("foo" /* ERROR boolean constant */ )
assert(x /* ERROR boolean constant */)
assert(true)
assert /* ERROR failed */ (false)
_ = assert(true)
}
func assert2() {
f1 := func() (x bool) { return }
f2 := func() (x bool) { return }
assert(f0 /* ERROR used as value */ ())
assert(f1 /* ERROR boolean constant */ ())
assert(f2 /* ERROR boolean constant */ ())
}
// self-testing only
func trace1() {
// Uncomment the code below to test trace - will produce console output // Uncomment the code below to test trace - will produce console output
// _ = trace /* ERROR "no value" */ () // _ = trace /* ERROR no value */ ()
// _ = trace(1) // _ = trace(1)
// _ = trace(true, 1.2, '\'', "foo", 42i, "foo" <= "bar") // _ = trace(true, 1.2, '\'', "foo", 42i, "foo" <= "bar")
} }
func trace2() {
f1 := func() (x int) { return }
f2 := func() (x int, y string) { return }
f3 := func() (x int, y string, z []int) { return }
_ = f1
_ = f2
_ = f3
// Uncomment the code below to test trace - will produce console output
// trace(f0())
// trace(f1())
// trace(f2())
// trace(f3())
// trace(f0(), 1)
// trace(f1(), 1, 2)
// trace(f2(), 1, 2, 3)
// trace(f3(), 1, 2, 3, 4)
}

2
go/types/testdata/expr3.src vendored
View File

@ -383,7 +383,7 @@ func _calls() {
f2(3.14) /* ERROR "too few arguments" */ f2(3.14) /* ERROR "too few arguments" */
f2(3.14, "foo") f2(3.14, "foo")
f2(x /* ERROR "cannot pass" */ , "foo") f2(x /* ERROR "cannot pass" */ , "foo")
f2(g0 /* ERROR "used as value" */ ()) f2(g0 /* ERROR "used as value" */ ()) /* ERROR "too few arguments" */
f2(g1 /* ERROR "cannot pass" */ ()) /* ERROR "too few arguments" */ f2(g1 /* ERROR "cannot pass" */ ()) /* ERROR "too few arguments" */
f2(g2()) f2(g2())