go/types: unified handling of assignment errors
- simpler code
- closer to gc error messages
- more context information in some cases
Change-Id: Iad155a887b838a4fc1edf719eed18269670b5ede
Reviewed-on: https://go-review.googlesource.com/14720
Reviewed-by: Alan Donovan <adonovan@google.com>
diff --git a/src/go/types/api_test.go b/src/go/types/api_test.go
index eeda0d8..76c34b4 100644
--- a/src/go/types/api_test.go
+++ b/src/go/types/api_test.go
@@ -797,7 +797,7 @@
makePkg("main", mainSrc)
for e, sel := range selections {
- sel.String() // assertion: must not panic
+ _ = sel.String() // assertion: must not panic
start := fset.Position(e.Pos()).Offset
end := fset.Position(e.End()).Offset
diff --git a/src/go/types/assignments.go b/src/go/types/assignments.go
index a906252..10ab17b 100644
--- a/src/go/types/assignments.go
+++ b/src/go/types/assignments.go
@@ -13,17 +13,15 @@
// assignment reports whether x can be assigned to a variable of type T,
// if necessary by attempting to convert untyped values to the appropriate
-// type. If x.mode == invalid upon return, then assignment has already
-// issued an error message and the caller doesn't have to report another.
+// type. context describes the context in which the assignment takes place.
// Use T == nil to indicate assignment to an untyped blank identifier.
-// If the result is false and a non-nil reason is provided, it may be set
-// to a more detailed explanation of the failure (result != "").
-func (check *Checker) assignment(x *operand, T Type, reason *string) bool {
+// x.mode is set to invalid if the assignment failed.
+func (check *Checker) assignment(x *operand, T Type, context string) {
check.singleValue(x)
switch x.mode {
case invalid:
- return true // error reported before
+ return // error reported before
case constant_, variable, mapindex, value, commaok:
// ok
default:
@@ -39,15 +37,15 @@
// or string constant."
if T == nil || IsInterface(T) {
if T == nil && x.typ == Typ[UntypedNil] {
- check.errorf(x.pos(), "use of untyped nil")
+ check.errorf(x.pos(), "use of untyped nil in %s", context)
x.mode = invalid
- return false
+ return
}
target = defaultType(x.typ)
}
check.convertUntyped(x, target)
if x.mode == invalid {
- return false
+ return
}
}
// x.typ is typed
@@ -55,7 +53,18 @@
// spec: "If a left-hand side is the blank identifier, any typed or
// non-constant value except for the predeclared identifier nil may
// be assigned to it."
- return T == nil || x.assignableTo(check.conf, T, reason)
+ if T == nil {
+ return
+ }
+
+ if reason := ""; !x.assignableTo(check.conf, T, &reason) {
+ if reason != "" {
+ check.errorf(x.pos(), "cannot use %s as %s value in %s: %s", x, T, context, reason)
+ } else {
+ check.errorf(x.pos(), "cannot use %s as %s value in %s", x, T, context)
+ }
+ x.mode = invalid
+ }
}
func (check *Checker) initConst(lhs *Const, x *operand) {
@@ -81,18 +90,15 @@
lhs.typ = x.typ
}
- if reason := ""; !check.assignment(x, lhs.typ, &reason) {
- if x.mode != invalid {
- check.xerrorf(x.pos(), reason, "cannot define constant %s (type %s) as %s", lhs.Name(), lhs.typ, x)
- }
+ check.assignment(x, lhs.typ, "constant declaration")
+ if x.mode == invalid {
return
}
lhs.val = x.val
}
-// If result is set, lhs is a function result parameter and x is a return result.
-func (check *Checker) initVar(lhs *Var, x *operand, result bool) Type {
+func (check *Checker) initVar(lhs *Var, x *operand, context string) Type {
if x.mode == invalid || x.typ == Typ[Invalid] || lhs.typ == Typ[Invalid] {
if lhs.typ == nil {
lhs.typ = Typ[Invalid]
@@ -106,7 +112,7 @@
if isUntyped(typ) {
// convert untyped types to default types
if typ == Typ[UntypedNil] {
- check.errorf(x.pos(), "use of untyped nil")
+ check.errorf(x.pos(), "use of untyped nil in %s", context)
lhs.typ = Typ[Invalid]
return nil
}
@@ -115,15 +121,8 @@
lhs.typ = typ
}
- if reason := ""; !check.assignment(x, lhs.typ, &reason) {
- if x.mode != invalid {
- if result {
- // don't refer to lhs.name because it may be an anonymous result parameter
- check.xerrorf(x.pos(), reason, "cannot return %s as value of type %s", x, lhs.typ)
- } else {
- check.xerrorf(x.pos(), reason, "cannot initialize %s with %s", lhs, x)
- }
- }
+ check.assignment(x, lhs.typ, context)
+ if x.mode == invalid {
return nil
}
@@ -141,9 +140,9 @@
// Don't evaluate lhs if it is the blank identifier.
if ident != nil && ident.Name == "_" {
check.recordDef(ident, nil)
- if !check.assignment(x, nil, nil) {
- assert(x.mode == invalid)
- x.typ = nil
+ check.assignment(x, nil, "assignment to _ identifier")
+ if x.mode == invalid {
+ return nil
}
return x.typ
}
@@ -184,10 +183,8 @@
return nil
}
- if reason := ""; !check.assignment(x, z.typ, &reason) {
- if x.mode != invalid {
- check.xerrorf(x.pos(), reason, "cannot assign %s to %s", x, &z)
- }
+ check.assignment(x, z.typ, "assignment")
+ if x.mode == invalid {
return nil
}
@@ -218,12 +215,17 @@
return
}
+ context := "assignment"
+ if returnPos.IsValid() {
+ context = "return statement"
+ }
+
var x operand
if commaOk {
var a [2]Type
for i := range a {
get(&x, i)
- a[i] = check.initVar(lhs[i], &x, returnPos.IsValid())
+ a[i] = check.initVar(lhs[i], &x, context)
}
check.recordCommaOkTypes(rhs[0], a)
return
@@ -231,7 +233,7 @@
for i, lhs := range lhs {
get(&x, i)
- check.initVar(lhs, &x, returnPos.IsValid())
+ check.initVar(lhs, &x, context)
}
}
diff --git a/src/go/types/builtins.go b/src/go/types/builtins.go
index be6c929..c288024 100644
--- a/src/go/types/builtins.go
+++ b/src/go/types/builtins.go
@@ -471,8 +471,8 @@
case _Panic:
// panic(x)
T := new(Interface)
- if !check.assignment(x, T, nil) {
- assert(x.mode == invalid)
+ check.assignment(x, T, "argument to panic")
+ if x.mode == invalid {
return
}
@@ -491,8 +491,9 @@
if i > 0 {
arg(x, i) // first argument already evaluated
}
- if !check.assignment(x, nil, nil) {
- assert(x.mode == invalid)
+ check.assignment(x, nil, "argument to "+predeclaredFuncs[id].name)
+ if x.mode == invalid {
+ // TODO(gri) "use" all arguments?
return
}
params[i] = x.typ
@@ -514,8 +515,8 @@
case _Alignof:
// unsafe.Alignof(x T) uintptr
- if !check.assignment(x, nil, nil) {
- assert(x.mode == invalid)
+ check.assignment(x, nil, "argument to unsafe.Alignof")
+ if x.mode == invalid {
return
}
@@ -571,8 +572,8 @@
case _Sizeof:
// unsafe.Sizeof(x T) uintptr
- if !check.assignment(x, nil, nil) {
- assert(x.mode == invalid)
+ check.assignment(x, nil, "argument to unsafe.Sizeof")
+ if x.mode == invalid {
return
}
diff --git a/src/go/types/call.go b/src/go/types/call.go
index 4ce0a6b..8aeb862 100644
--- a/src/go/types/call.go
+++ b/src/go/types/call.go
@@ -202,7 +202,7 @@
if i == n-1 && call.Ellipsis.IsValid() {
ellipsis = call.Ellipsis
}
- check.argument(sig, i, x, ellipsis)
+ check.argument(call.Fun, sig, i, x, ellipsis)
}
}
@@ -220,7 +220,7 @@
// argument checks passing of argument x to the i'th parameter of the given signature.
// If ellipsis is valid, the argument is followed by ... at that position in the call.
-func (check *Checker) argument(sig *Signature, i int, x *operand, ellipsis token.Pos) {
+func (check *Checker) argument(fun ast.Expr, sig *Signature, i int, x *operand, ellipsis token.Pos) {
check.singleValue(x)
if x.mode == invalid {
return
@@ -260,9 +260,7 @@
typ = typ.(*Slice).elem
}
- if reason := ""; !check.assignment(x, typ, &reason) && x.mode != invalid {
- check.xerrorf(x.pos(), reason, "cannot pass argument %s to parameter of type %s", x, typ)
- }
+ check.assignment(x, typ, check.sprintf("argument to %s", fun))
}
func (check *Checker) selector(x *operand, e *ast.SelectorExpr) {
diff --git a/src/go/types/decl.go b/src/go/types/decl.go
index 8e9e5f3..f064f68 100644
--- a/src/go/types/decl.go
+++ b/src/go/types/decl.go
@@ -156,7 +156,7 @@
assert(lhs == nil || lhs[0] == obj)
var x operand
check.expr(&x, init)
- check.initVar(obj, &x, false)
+ check.initVar(obj, &x, "variable declaration")
return
}
diff --git a/src/go/types/errors.go b/src/go/types/errors.go
index 7c81b12..0c0049b 100644
--- a/src/go/types/errors.go
+++ b/src/go/types/errors.go
@@ -86,14 +86,6 @@
check.err(pos, check.sprintf(format, args...), false)
}
-func (check *Checker) xerrorf(pos token.Pos, reason, format string, args ...interface{}) {
- if reason != "" {
- format += ": %s"
- args = append(args, reason)
- }
- check.err(pos, check.sprintf(format, args...), true)
-}
-
func (check *Checker) softErrorf(pos token.Pos, format string, args ...interface{}) {
check.err(pos, check.sprintf(format, args...), true)
}
diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index 0f5712b..ce9ea83 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -898,9 +898,7 @@
// check element against composite literal element type
var x operand
check.exprWithHint(&x, eval, typ)
- if reason := ""; !check.assignment(&x, typ, &reason) && x.mode != invalid {
- check.xerrorf(x.pos(), reason, "cannot use %s as %s value in array or slice literal", &x, typ)
- }
+ check.assignment(&x, typ, "array or slice literal")
}
return max
}
@@ -1062,12 +1060,7 @@
visited[i] = true
check.expr(x, kv.Value)
etyp := fld.typ
- if reason := ""; !check.assignment(x, etyp, &reason) {
- if x.mode != invalid {
- check.xerrorf(x.pos(), reason, "cannot use %s as %s value in struct literal", x, etyp)
- }
- continue
- }
+ check.assignment(x, etyp, "struct literal")
}
} else {
// no element must have a key
@@ -1088,12 +1081,7 @@
continue
}
etyp := fld.typ
- if reason := ""; !check.assignment(x, etyp, &reason) {
- if x.mode != invalid {
- check.xerrorf(x.pos(), reason, "cannot use %s as %s value in struct literal", x, etyp)
- }
- continue
- }
+ check.assignment(x, etyp, "struct literal")
}
if len(e.Elts) < len(fields) {
check.error(e.Rbrace, "too few values in struct literal")
@@ -1120,10 +1108,8 @@
continue
}
check.exprWithHint(x, kv.Key, utyp.key)
- if reason := ""; !check.assignment(x, utyp.key, &reason) {
- if x.mode != invalid {
- check.xerrorf(x.pos(), reason, "cannot use %s as %s key in map literal", x, utyp.key)
- }
+ check.assignment(x, utyp.key, "map literal")
+ if x.mode == invalid {
continue
}
if x.mode == constant_ {
@@ -1147,12 +1133,7 @@
}
}
check.exprWithHint(x, kv.Value, utyp.elem)
- if reason := ""; !check.assignment(x, utyp.elem, &reason) {
- if x.mode != invalid {
- check.xerrorf(x.pos(), reason, "cannot use %s as %s value in map literal", x, utyp.elem)
- }
- continue
- }
+ check.assignment(x, utyp.elem, "map literal")
}
default:
@@ -1220,10 +1201,8 @@
case *Map:
var key operand
check.expr(&key, e.Index)
- if reason := ""; !check.assignment(&key, typ.key, &reason) {
- if key.mode != invalid {
- check.xerrorf(key.pos(), reason, "cannot use %s as map index of type %s", &key, typ.key)
- }
+ check.assignment(&key, typ.key, "map index")
+ if x.mode == invalid {
goto Error
}
x.mode = mapindex
diff --git a/src/go/types/stmt.go b/src/go/types/stmt.go
index 50efc1f..973af42 100644
--- a/src/go/types/stmt.go
+++ b/src/go/types/stmt.go
@@ -321,13 +321,20 @@
if ch.mode == invalid || x.mode == invalid {
return
}
- reason := ""
- if tch, ok := ch.typ.Underlying().(*Chan); !ok || tch.dir == RecvOnly || !check.assignment(&x, tch.elem, &reason) {
- if x.mode != invalid {
- check.xerrorf(x.pos(), reason, "cannot send %s to channel %s", &x, &ch)
- }
+
+ tch, ok := ch.typ.Underlying().(*Chan)
+ if !ok {
+ check.invalidOp(s.Arrow, "cannot send to non-chan type %s", ch.typ)
+ return
}
+ if tch.dir == RecvOnly {
+ check.invalidOp(s.Arrow, "cannot send to receive-only type %s", tch)
+ return
+ }
+
+ check.assignment(&x, tch.elem, "send")
+
case *ast.IncDecStmt:
var op token.Token
switch s.Tok {
@@ -465,7 +472,7 @@
check.expr(&x, s.Tag)
// By checking assignment of x to an invisible temporary
// (as a compiler would), we get all the relevant checks.
- check.assignment(&x, nil, nil)
+ check.assignment(&x, nil, "switch expression")
} else {
// spec: "A missing switch expression is
// equivalent to the boolean value true."
@@ -767,7 +774,7 @@
x.mode = value
x.expr = lhs // we don't have a better rhs expression to use here
x.typ = typ
- check.initVar(obj, &x, false)
+ check.initVar(obj, &x, "range clause")
} else {
obj.typ = Typ[Invalid]
obj.used = true // don't complain about unused variable
diff --git a/src/go/types/testdata/builtins.src b/src/go/types/testdata/builtins.src
index 1931d56..7fb7b58 100644
--- a/src/go/types/testdata/builtins.src
+++ b/src/go/types/testdata/builtins.src
@@ -22,12 +22,12 @@
append /* ERROR not used */ (s)
_ = append(s, b)
- _ = append(s, x /* ERROR cannot pass argument x */ )
- _ = append(s, s /* ERROR cannot pass argument s */ )
+ _ = append(s, x /* ERROR cannot use x */ )
+ _ = append(s, s /* ERROR cannot use s */ )
_ = append(s... /* ERROR can only use ... with matching parameter */ )
_ = append(s, b, s... /* ERROR can only use ... with matching parameter */ )
_ = append(s, 1, 2, 3)
- _ = append(s, 1, 2, 3, x /* ERROR cannot pass argument x */ , 5, 6, 6)
+ _ = append(s, 1, 2, 3, x /* ERROR cannot use x */ , 5, 6, 6)
_ = append(s, 1, 2, s... /* ERROR can only use ... with matching parameter */ )
_ = append([]interface{}(nil), 1, 2, "foo", x, 3.1425, false)
@@ -38,13 +38,13 @@
_ = append(s, "foo"...)
_ = append(S(s), "foo" /* ERROR cannot convert */ )
_ = append(S(s), "foo"...)
- _ = append(s, t /* ERROR cannot pass argument t */ )
+ _ = append(s, t /* ERROR cannot use t */ )
_ = append(s, t...)
_ = append(s, T("foo")...)
- _ = append(S(s), t /* ERROR cannot pass argument t */ )
+ _ = append(S(s), t /* ERROR cannot use t */ )
_ = append(S(s), t...)
_ = append(S(s), T("foo")...)
- _ = append([]string{}, t /* ERROR cannot pass argument t */ , "foo")
+ _ = append([]string{}, t /* ERROR cannot use t */ , "foo")
_ = append([]T{}, t, "foo")
}
@@ -192,9 +192,9 @@
complex /* ERROR not used */ (1, 2)
var _ complex64 = complex(f32, f32)
- var _ complex64 = complex /* ERROR cannot initialize */ (f64, f64)
+ var _ complex64 = complex /* ERROR cannot use .* in variable declaration */ (f64, f64)
- var _ complex128 = complex /* ERROR cannot initialize */ (f32, f32)
+ var _ complex128 = complex /* ERROR cannot use .* in variable declaration */ (f32, f32)
var _ complex128 = complex(f64, f64)
// untyped constants
@@ -213,7 +213,7 @@
var s uint
_ = complex(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 use .* in variable declaration */ (1 /* ERROR integer */ <<s, 0)
// floating-point argument types must be identical
type F32 float32
@@ -319,8 +319,8 @@
assert(_6 == 0)
f32 = imag(c64)
f64 = imag(c128)
- f32 = imag /* ERROR cannot assign */ (c128)
- f64 = imag /* ERROR cannot assign */ (c64)
+ f32 = imag /* ERROR cannot use .* in assignment */ (c128)
+ f64 = imag /* ERROR cannot use .* in assignment */ (c64)
imag /* ERROR not used */ (c64)
_, _ = f32, f64
@@ -599,8 +599,8 @@
assert(_6 == 0)
f32 = real(c64)
f64 = real(c128)
- f32 = real /* ERROR cannot assign */ (c128)
- f64 = real /* ERROR cannot assign */ (c64)
+ f32 = real /* ERROR cannot use .* in assignment */ (c128)
+ f64 = real /* ERROR cannot use .* in assignment */ (c64)
real /* ERROR not used */ (c64)
// complex type may not be predeclared
diff --git a/src/go/types/testdata/decls1.src b/src/go/types/testdata/decls1.src
index 7855e46..cb162f7 100644
--- a/src/go/types/testdata/decls1.src
+++ b/src/go/types/testdata/decls1.src
@@ -25,7 +25,7 @@
s, t string
array []byte
iface interface{}
-
+
blank _ /* ERROR "cannot use _" */
)
@@ -43,33 +43,33 @@
s11 = &v
s12 = -(u + *t11) / *&v
s13 = a /* ERROR "shifted operand" */ << d
- s14 = i << j /* ERROR "must be unsigned" */
+ s14 = i << j /* ERROR "must be unsigned" */
s18 = math.Pi * 10.0
s19 = s1 /* ERROR "cannot call" */ ()
s20 = f0 /* ERROR "no value" */ ()
s21 = f6(1, s1, i)
- s22 = f6(1, s1, uu /* ERROR "cannot pass argument" */ )
-
+ s22 = f6(1, s1, uu /* ERROR "cannot use .* in argument" */ )
+
t1 int = i + j
t2 int = i /* ERROR "mismatched types" */ + x
- t3 int = c /* ERROR "cannot initialize" */ + d
+ t3 int = c /* ERROR "cannot use .* variable declaration" */ + d
t4 string = s + t
t5 string = s /* ERROR "invalid operation" */ / t
t6 byte = array[t1]
t7 byte = array[x /* ERROR "must be integer" */]
- t8 *int = & /* ERROR "cannot initialize" */ a
+ t8 *int = & /* ERROR "cannot use .* variable declaration" */ a
t10 *int = &42 /* ERROR "cannot take address" */
t11 *complex64 = &v
t12 complex64 = -(u + *t11) / *&v
t13 int = a /* ERROR "shifted operand" */ << d
- t14 int = i << j /* ERROR "must be unsigned" */
+ t14 int = i << j /* ERROR "must be unsigned" */
t15 math /* ERROR "not in selector" */
t16 math /* ERROR "not declared" */ .xxx
t17 math /* ERROR "not a type" */ .Pi
t18 float64 = math.Pi * 10.0
t19 int = t1 /* ERROR "cannot call" */ ()
t20 int = f0 /* ERROR "no value" */ ()
- t21 int = a /* ERROR "cannot initialize" */
+ t21 int = a /* ERROR "cannot use .* variable declaration" */
)
// Various more complex expressions
diff --git a/src/go/types/testdata/expr0.src b/src/go/types/testdata/expr0.src
index 2a917c0..1aac726 100644
--- a/src/go/types/testdata/expr0.src
+++ b/src/go/types/testdata/expr0.src
@@ -144,7 +144,7 @@
ch10, ok = <-ch
// ok is of type bool
ch11, myok = <-ch
- _ mybool = myok /* ERROR "cannot initialize" */
+ _ mybool = myok /* ERROR "cannot use .* in variable declaration" */
)
// address of composite literals
diff --git a/src/go/types/testdata/expr3.src b/src/go/types/testdata/expr3.src
index 1b02c9a..53c03e7 100644
--- a/src/go/types/testdata/expr3.src
+++ b/src/go/types/testdata/expr3.src
@@ -28,7 +28,7 @@
a0 = a[0]
_ = a0
var a1 int32
- a1 = a /* ERROR "cannot assign" */ [1]
+ a1 = a /* ERROR "cannot use .* in assignment" */ [1]
_ = a1
_ = a[9]
@@ -113,7 +113,7 @@
t0 = t[0]
_ = t0
var t1 rune
- t1 = t /* ERROR "cannot assign" */ [2]
+ t1 = t /* ERROR "cannot use .* in assignment" */ [2]
_ = t1
_ = ("foo" + "bar")[5]
_ = ("foo" + "bar")[6 /* ERROR "index .* out of bounds" */ ]
@@ -126,7 +126,7 @@
c0 = c[0]
_ = c0
var c2 float32
- c2 = c /* ERROR "cannot assign" */ [2]
+ c2 = c /* ERROR "cannot use .* in assignment" */ [2]
_ = c[3 /* ERROR "index .* out of bounds" */ ]
_ = ""[0 /* ERROR "index .* out of bounds" */ ]
_ = c2
@@ -140,8 +140,8 @@
var i, j int
ss = "foo"[1:2]
ss = "foo"[i:j]
- ms = "foo" /* ERROR "cannot assign" */ [1:2]
- ms = "foo" /* ERROR "cannot assign" */ [i:j]
+ ms = "foo" /* ERROR "cannot use .* in assignment" */ [1:2]
+ ms = "foo" /* ERROR "cannot use .* in assignment" */ [i:j]
_, _ = ss, ms
}
@@ -253,7 +253,7 @@
var a13 [3]int
var a14 [4]int
a13 = a1
- a14 = a1 /* ERROR "cannot assign" */
+ a14 = a1 /* ERROR "cannot use .* in assignment" */
_, _ = a13, a14
a2 := [...]int{- /* ERROR "negative" */ 1: 0}
@@ -465,7 +465,7 @@
f1(10.0)
f1() /* ERROR "too few arguments" */
f1(x, y /* ERROR "too many arguments" */ )
- f1(s /* ERROR "cannot pass" */ )
+ f1(s /* ERROR "cannot use .* in argument" */ )
f1(x ... /* ERROR "cannot use ..." */ )
f1(g0 /* ERROR "used as value" */ ())
f1(g1())
@@ -474,51 +474,51 @@
f2() /* ERROR "too few arguments" */
f2(3.14) /* ERROR "too few arguments" */
f2(3.14, "foo")
- f2(x /* ERROR "cannot pass" */ , "foo")
+ f2(x /* ERROR "cannot use .* in argument" */ , "foo")
f2(g0 /* ERROR "used as value" */ ())
- f2(g1 /* ERROR "cannot pass" */ ()) /* ERROR "too few arguments" */
+ f2(g1 /* ERROR "cannot use .* in argument" */ ()) /* ERROR "too few arguments" */
f2(g2())
fs() /* ERROR "too few arguments" */
fs(g0 /* ERROR "used as value" */ ())
- fs(g1 /* ERROR "cannot pass" */ ())
- fs(g2 /* ERROR "cannot pass" */ /* ERROR "too many arguments" */ ())
+ fs(g1 /* ERROR "cannot use .* in argument" */ ())
+ fs(g2 /* ERROR "cannot use .* in argument" */ /* ERROR "too many arguments" */ ())
fs(gs())
fv()
fv(1, 2.0, x)
- fv(s /* ERROR "cannot pass" */ )
+ fv(s /* ERROR "cannot use .* in argument" */ )
fv(s...)
fv(x /* ERROR "cannot use" */ ...)
fv(1, s... /* ERROR "can only use ... with matching parameter" */ )
- fv(gs /* ERROR "cannot pass" */ ())
- fv(gs /* ERROR "cannot pass" */ ()...)
+ fv(gs /* ERROR "cannot use .* in argument" */ ())
+ fv(gs /* ERROR "cannot use .* in argument" */ ()...)
var t T
t.fm()
t.fm(1, 2.0, x)
- t.fm(s /* ERROR "cannot pass" */ )
+ t.fm(s /* ERROR "cannot use .* in argument" */ )
t.fm(g1())
t.fm(1, s... /* ERROR "can only use ... with matching parameter" */ )
- t.fm(gs /* ERROR "cannot pass" */ ())
- t.fm(gs /* ERROR "cannot pass" */ ()...)
+ t.fm(gs /* ERROR "cannot use .* in argument" */ ())
+ t.fm(gs /* ERROR "cannot use .* in argument" */ ()...)
T.fm(t, )
T.fm(t, 1, 2.0, x)
- T.fm(t, s /* ERROR "cannot pass" */ )
+ T.fm(t, s /* ERROR "cannot use .* in argument" */ )
T.fm(t, g1())
T.fm(t, 1, s... /* ERROR "can only use ... with matching parameter" */ )
- T.fm(t, gs /* ERROR "cannot pass" */ ())
- T.fm(t, gs /* ERROR "cannot pass" */ ()...)
+ T.fm(t, gs /* ERROR "cannot use .* in argument" */ ())
+ T.fm(t, gs /* ERROR "cannot use .* in argument" */ ()...)
var i interface{ fm(x ...int) } = t
i.fm()
i.fm(1, 2.0, x)
- i.fm(s /* ERROR "cannot pass" */ )
+ i.fm(s /* ERROR "cannot use .* in argument" */ )
i.fm(g1())
i.fm(1, s... /* ERROR "can only use ... with matching parameter" */ )
- i.fm(gs /* ERROR "cannot pass" */ ())
- i.fm(gs /* ERROR "cannot pass" */ ()...)
+ i.fm(gs /* ERROR "cannot use .* in argument" */ ())
+ i.fm(gs /* ERROR "cannot use .* in argument" */ ()...)
fi()
fi(1, 2.0, x, 3.14, "foo")
diff --git a/src/go/types/testdata/issues.src b/src/go/types/testdata/issues.src
index a2db9d7..564d064 100644
--- a/src/go/types/testdata/issues.src
+++ b/src/go/types/testdata/issues.src
@@ -52,7 +52,7 @@
_ = append(f0())
_ = append(f0(), f0()...)
_ = append(f1())
- _ = append(f2 /* ERROR cannot pass argument */ ())
+ _ = append(f2 /* ERROR cannot use .* in argument */ ())
_ = append(f2()... /* ERROR cannot use ... */ )
_ = append(f0(), f1 /* ERROR 2-valued f1 */ ())
_ = append(f0(), f2 /* ERROR 2-valued f2 */ ())
@@ -63,7 +63,7 @@
append_(f0())
append_(f0(), f0()...)
append_(f1())
- append_(f2 /* ERROR cannot pass argument */ ())
+ append_(f2 /* ERROR cannot use .* in argument */ ())
append_(f2()... /* ERROR cannot use ... */ )
append_(f0(), f1 /* ERROR 2-valued f1 */ ())
append_(f0(), f2 /* ERROR 2-valued f2 */ ())
@@ -124,24 +124,24 @@
t1 *T1
t2 *T2
)
- i1 = i0 /* ERROR cannot assign .* missing method foo */
- i1 = t0 /* ERROR cannot assign .* missing method foo */
- i1 = i2 /* ERROR cannot assign .* wrong type for method foo */
- i1 = t2 /* ERROR cannot assign .* wrong type for method foo */
- i2 = i1 /* ERROR cannot assign .* wrong type for method foo */
- i2 = t1 /* ERROR cannot assign .* wrong type for method foo */
+ i1 = i0 /* ERROR cannot use .* missing method foo */
+ i1 = t0 /* ERROR cannot use .* missing method foo */
+ i1 = i2 /* ERROR cannot use .* wrong type for method foo */
+ i1 = t2 /* ERROR cannot use .* wrong type for method foo */
+ i2 = i1 /* ERROR cannot use .* wrong type for method foo */
+ i2 = t1 /* ERROR cannot use .* wrong type for method foo */
- _ = func() I1 { return i0 /* ERROR cannot return .* missing method foo */ }
- _ = func() I1 { return t0 /* ERROR cannot return .* missing method foo */ }
- _ = func() I1 { return i2 /* ERROR cannot return .* wrong type for method foo */ }
- _ = func() I1 { return t2 /* ERROR cannot return .* wrong type for method foo */ }
- _ = func() I2 { return i1 /* ERROR cannot return .* wrong type for method foo */ }
- _ = func() I2 { return t1 /* ERROR cannot return .* wrong type for method foo */ }
+ _ = func() I1 { return i0 /* ERROR cannot use .* missing method foo */ }
+ _ = func() I1 { return t0 /* ERROR cannot use .* missing method foo */ }
+ _ = func() I1 { return i2 /* ERROR cannot use .* wrong type for method foo */ }
+ _ = func() I1 { return t2 /* ERROR cannot use .* wrong type for method foo */ }
+ _ = func() I2 { return i1 /* ERROR cannot use .* wrong type for method foo */ }
+ _ = func() I2 { return t1 /* ERROR cannot use .* wrong type for method foo */ }
// a few more - less exhaustive now
f := func(I1, I2){}
- f(i0 /* ERROR cannot pass .* missing method foo */ , i1 /* ERROR cannot pass .* wrong type for method foo */)
+ f(i0 /* ERROR cannot use .* missing method foo */ , i1 /* ERROR cannot use .* wrong type for method foo */)
_ = [...]I1{i0 /* ERROR cannot use .* missing method foo */ }
_ = [...]I1{i2 /* ERROR cannot use .* wrong type for method foo */ }
@@ -150,6 +150,6 @@
_ = map[int]I1{0: i0 /* ERROR cannot use .* missing method foo */ }
_ = map[int]I1{0: i2 /* ERROR cannot use .* wrong type for method foo */ }
- make(chan I1) <- i0 /* ERROR cannot send .* missing method foo */
- make(chan I1) <- i2 /* ERROR cannot send .* wrong type for method foo */
+ make(chan I1) <- i0 /* ERROR cannot use .* in send: missing method foo */
+ make(chan I1) <- i2 /* ERROR cannot use .* in send: wrong type for method foo */
}
diff --git a/src/go/types/testdata/stmt0.src b/src/go/types/testdata/stmt0.src
index 52ed65c..b7966ed 100644
--- a/src/go/types/testdata/stmt0.src
+++ b/src/go/types/testdata/stmt0.src
@@ -37,11 +37,11 @@
func assignments1() {
b, i, f, c, s := false, 1, 1.0, 1i, "foo"
- b = i /* ERROR "cannot assign" */
- i = f /* ERROR "cannot assign" */
- f = c /* ERROR "cannot assign" */
- c = s /* ERROR "cannot assign" */
- s = b /* ERROR "cannot assign" */
+ b = i /* ERROR "cannot use .* in assignment" */
+ i = f /* ERROR "cannot use .* in assignment" */
+ f = c /* ERROR "cannot use .* in assignment" */
+ c = s /* ERROR "cannot use .* in assignment" */
+ s = b /* ERROR "cannot use .* in assignment" */
v0, v1, v2 := 1 /* ERROR "mismatch" */ , 2, 3, 4
_, _, _ = v0, v1, v2
@@ -180,8 +180,8 @@
var ch chan int
var rch <-chan int
var x int
- x <- x /* ERROR "cannot send" */
- rch <- x /* ERROR "cannot send" */
+ x <- /* ERROR "cannot send" */ x
+ rch <- /* ERROR "cannot send" */ x
ch <- "foo" /* ERROR "cannot convert" */
ch <- x
}
@@ -381,7 +381,7 @@
func returns1(x float64) (int, *float64) {
return 0, &x
return /* ERROR wrong number of return values */
- return "foo" /* ERROR "cannot convert" */, x /* ERROR "cannot return" */
+ return "foo" /* ERROR "cannot convert" */, x /* ERROR "cannot use .* in return statement" */
return /* ERROR wrong number of return values */ 0, &x, 1
}
@@ -421,7 +421,7 @@
true := "false"
_ = true
- // A tagless switch is equivalent to the bool
+ // A tagless switch is equivalent to the bool
// constant true, not the identifier 'true'.
switch {
case "false" /* ERROR "cannot convert" */:
@@ -682,16 +682,16 @@
switch t := x.(type) {
case nil:
- var v bool = t /* ERROR "cannot initialize" */
+ var v bool = t /* ERROR "cannot use .* in variable declaration" */
_ = v
case int:
var v int = t
_ = v
case float32, complex64:
- var v float32 = t /* ERROR "cannot initialize" */
+ var v float32 = t /* ERROR "cannot use .* in variable declaration" */
_ = v
default:
- var v float32 = t /* ERROR "cannot initialize" */
+ var v float32 = t /* ERROR "cannot use .* in variable declaration" */
_ = v
}
@@ -801,7 +801,7 @@
ii = i
_ = ii
var xx float64
- xx = x /* ERROR "cannot assign" */
+ xx = x /* ERROR "cannot use .* in assignment" */
_ = xx
}
var ii int
@@ -852,7 +852,7 @@
for range m {}
for k := range m {
var kk int32
- kk = k /* ERROR "cannot assign" */
+ kk = k /* ERROR "cannot use .* in assignment" */
_ = kk
}
for k, v := range m {
@@ -894,17 +894,17 @@
var a [10]int
var i I
_ = i
- for i /* ERROR cannot assign */ = range a {}
- for i /* ERROR cannot assign */ = range &a {}
- for i /* ERROR cannot assign */ = range a[:] {}
+ for i /* ERROR cannot use .* in assignment */ = range a {}
+ for i /* ERROR cannot use .* in assignment */ = range &a {}
+ for i /* ERROR cannot use .* in assignment */ = range a[:] {}
var s string
var r R
_ = r
- for i /* ERROR cannot assign */ = range s {}
- for i /* ERROR cannot assign */ = range "foo" {}
- for _, r /* ERROR cannot assign */ = range s {}
- for _, r /* ERROR cannot assign */ = range "foo" {}
+ for i /* ERROR cannot use .* in assignment */ = range s {}
+ for i /* ERROR cannot use .* in assignment */ = range "foo" {}
+ for _, r /* ERROR cannot use .* in assignment */ = range s {}
+ for _, r /* ERROR cannot use .* in assignment */ = range "foo" {}
}
func issue6766b() {
@@ -937,7 +937,7 @@
L1:
L1 /* ERROR "already declared" */ :
if true {
- goto L2
+ goto L2
L2:
L0 /* ERROR "already declared" */ :
}
