This matches longstanding compiler behavior.
Also, for unused packages, report:
`"pkg" imported and not used`
`"pkg" imported as X and not used`
This matches the other `X declared and not used` errors.
For #55326.
Change-Id: Ie71cf662fb5f4648449c64fc51bede298a1bdcbf
Reviewed-on: https://go-review.googlesource.com/c/go/+/432557
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
Reviewed-by: Robert Griesemer <gri@google.com>
Auto-Submit: Robert Griesemer <gri@google.com>
Run-TryBot: Robert Griesemer <gri@google.com>
}
// Note: This was reverted in go/types (https://golang.org/cl/292751).
// TODO(gri): decide what to do (also affects test/run.go exclusion list)
- lhs.used = true // avoid follow-on "declared but not used" errors
+ lhs.used = true // avoid follow-on "declared and not used" errors
return nil
}
check.assignment(x, lhs.typ, context)
if x.mode == invalid {
- lhs.used = true // avoid follow-on "declared but not used" errors
+ lhs.used = true // avoid follow-on "declared and not used" errors
return nil
}
if len(lhs) != len(rhs) {
// invalidate lhs
for _, obj := range lhs {
- obj.used = true // avoid declared but not used errors
+ obj.used = true // avoid declared and not used errors
if obj.typ == nil {
obj.typ = Typ[Invalid]
}
}
}
- // avoid follow-on "declared but not used" errors if any initialization failed
+ // avoid follow-on "declared and not used" errors if any initialization failed
if !ok {
for _, lhs := range lhs {
lhs.used = true
}
}
- // avoid follow-on "declared but not used" errors if any assignment failed
+ // avoid follow-on "declared and not used" errors if any assignment failed
if !ok {
// don't call check.use to avoid re-evaluation of the lhs expressions
for _, lhs := range lhs {
// }
_MisplacedLabel
- // _UnusedLabel occurs when a label is declared but not used.
+ // _UnusedLabel occurs when a label is declared and not used.
//
// Example:
// func f() {
conf := Config{Error: func(err error) { got += err.Error() + "\n" }}
conf.Check(f.PkgName.Value, []*syntax.File{f}, nil) // do not crash
want := `
-:1:27: a declared but not used
-:1:30: b declared but not used
-:1:33: c declared but not used
-:1:36: d declared but not used
-:1:39: e declared but not used
+:1:27: a declared and not used
+:1:30: b declared and not used
+:1:33: c declared and not used
+:1:36: d declared and not used
+:1:39: e declared and not used
`
if got != want {
t.Errorf("got: %swant: %s", got, want)
for name, obj := range all.elems {
obj = resolve(name, obj)
if lbl := obj.(*Label); !lbl.used {
- check.softErrorf(lbl.pos, _UnusedLabel, "label %s declared but not used", lbl.name)
+ check.softErrorf(lbl.pos, _UnusedLabel, "label %s declared and not used", lbl.name)
}
}
}
elem = elem[i+1:]
}
if obj.name == "" || obj.name == "." || obj.name == elem {
- if check.conf.CompilerErrorMessages {
- check.softErrorf(obj, _UnusedImport, "imported and not used: %q", path)
- } else {
- check.softErrorf(obj, _UnusedImport, "%q imported but not used", path)
- }
+ check.softErrorf(obj, _UnusedImport, "%q imported and not used", path)
} else {
- if check.conf.CompilerErrorMessages {
- check.softErrorf(obj, _UnusedImport, "imported and not used: %q as %s", path, obj.name)
- } else {
- check.softErrorf(obj, _UnusedImport, "%q imported but not used as %s", path, obj.name)
- }
+ check.softErrorf(obj, _UnusedImport, "%q imported as %s and not used", path, obj.name)
}
}
return unused[i].pos.Cmp(unused[j].pos) < 0
})
for _, v := range unused {
- check.softErrorf(v.pos, _UnusedVar, "%s declared but not used", v.name)
+ check.softErrorf(v.pos, _UnusedVar, "%s declared and not used", v.name)
}
for _, scope := range scope.children {
if lhs.Value == "_" {
// _ := x.(type) is an invalid short variable declaration
check.softErrorf(lhs, _NoNewVar, "no new variable on left side of :=")
- lhs = nil // avoid declared but not used error below
+ lhs = nil // avoid declared and not used error below
} else {
check.recordDef(lhs, nil) // lhs variable is implicitly declared in each cause clause
}
}
check.declare(check.scope, nil, obj, scopePos)
check.recordImplicit(clause, obj)
- // For the "declared but not used" error, all lhs variables act as
+ // For the "declared and not used" error, all lhs variables act as
// one; i.e., if any one of them is 'used', all of them are 'used'.
// Collect them for later analysis.
lhsVars = append(lhsVars, obj)
v.used = true // avoid usage error when checking entire function
}
if !used {
- check.softErrorf(lhs, _UnusedVar, "%s declared but not used", lhs.Value)
+ check.softErrorf(lhs, _UnusedVar, "%s declared and not used", lhs.Value)
}
}
}
if len(lhs) != len(rhs) {
// invalidate lhs
for _, obj := range lhs {
- obj.used = true // avoid declared but not used errors
+ obj.used = true // avoid declared and not used errors
if obj.typ == nil {
obj.typ = Typ[Invalid]
}
// }
_MisplacedLabel
- // _UnusedLabel occurs when a label is declared but not used.
+ // _UnusedLabel occurs when a label is declared and not used.
//
// Example:
// func f() {
conf := Config{Error: func(err error) { got += err.Error() + "\n" }}
conf.Check(f.Name.Name, fset, []*ast.File{f}, nil) // do not crash
want := `
-1:27: a declared but not used
-1:30: b declared but not used
-1:33: c declared but not used
-1:36: d declared but not used
-1:39: e declared but not used
+1:27: a declared and not used
+1:30: b declared and not used
+1:33: c declared and not used
+1:36: d declared and not used
+1:39: e declared and not used
`
if got != want {
t.Errorf("got: %swant: %s", got, want)
for name, obj := range all.elems {
obj = resolve(name, obj)
if lbl := obj.(*Label); !lbl.used {
- check.softErrorf(lbl, _UnusedLabel, "label %s declared but not used", lbl.name)
+ check.softErrorf(lbl, _UnusedLabel, "label %s declared and not used", lbl.name)
}
}
}
// init exprs from s
n := s.Values[l]
check.errorf(n, code, "extra init expr %s", n)
- // TODO(gri) avoid declared but not used error here
+ // TODO(gri) avoid declared and not used error here
} else {
// init exprs "inherited"
check.errorf(s, code, "extra init expr at %s", check.fset.Position(init.Pos()))
- // TODO(gri) avoid declared but not used error here
+ // TODO(gri) avoid declared and not used error here
}
case l > r && (init != nil || r != 1):
n := s.Names[r]
elem = elem[i+1:]
}
if obj.name == "" || obj.name == "." || obj.name == elem {
- check.softErrorf(obj, _UnusedImport, "%q imported but not used", path)
+ check.softErrorf(obj, _UnusedImport, "%q imported and not used", path)
} else {
- check.softErrorf(obj, _UnusedImport, "%q imported but not used as %s", path, obj.name)
+ check.softErrorf(obj, _UnusedImport, "%q imported as %s and not used", path, obj.name)
}
}
return unused[i].pos < unused[j].pos
})
for _, v := range unused {
- check.softErrorf(v, _UnusedVar, "%s declared but not used", v.name)
+ check.softErrorf(v, _UnusedVar, "%s declared and not used", v.name)
}
for _, scope := range scope.children {
if lhs.Name == "_" {
// _ := x.(type) is an invalid short variable declaration
check.softErrorf(lhs, _NoNewVar, "no new variable on left side of :=")
- lhs = nil // avoid declared but not used error below
+ lhs = nil // avoid declared and not used error below
} else {
check.recordDef(lhs, nil) // lhs variable is implicitly declared in each cause clause
}
}
check.declare(check.scope, nil, obj, scopePos)
check.recordImplicit(clause, obj)
- // For the "declared but not used" error, all lhs variables act as
+ // For the "declared and not used" error, all lhs variables act as
// one; i.e., if any one of them is 'used', all of them are 'used'.
// Collect them for later analysis.
lhsVars = append(lhsVars, obj)
v.used = true // avoid usage error when checking entire function
}
if !used {
- check.softErrorf(lhs, _UnusedVar, "%s declared but not used", lhs.Name)
+ check.softErrorf(lhs, _UnusedVar, "%s declared and not used", lhs.Name)
}
}
check.softErrorf(s, _InvalidPostDecl, "cannot declare in post statement")
// Don't call useLHS here because we want to use the lhs in
// this erroneous statement so that we don't get errors about
- // these lhs variables being declared but not used.
+ // these lhs variables being declared and not used.
check.use(s.Lhs...) // avoid follow-up errors
}
check.stmt(inner, s.Body)
init /* ERROR "cannot import package as init" */ "fmt"
// reflect defines a type "flag" which shows up in the gc export data
"reflect"
- . /* ERROR "imported but not used" */ "reflect"
+ . /* ERROR "imported and not used" */ "reflect"
)
-import "math" /* ERROR "imported but not used" */
-import m /* ERROR "imported but not used as m" */ "math"
+import "math" /* ERROR "imported and not used" */
+import m /* ERROR "imported as m and not used" */ "math"
import _ "math"
import (
- "math/big" /* ERROR "imported but not used" */
- b /* ERROR "imported but not used" */ "math/big"
+ "math/big" /* ERROR "imported and not used" */
+ b /* ERROR "imported as b and not used" */ "math/big"
_ "math/big"
)
import m "math"
import . "testing" // declares T in file scope
-import . /* ERROR .unsafe. imported but not used */ "unsafe"
+import . /* ERROR .unsafe. imported and not used */ "unsafe"
import . "fmt" // declares Println in file scope
import (
package importdecl1
-import . /* ERROR .unsafe. imported but not used */ "unsafe"
+import . /* ERROR .unsafe. imported and not used */ "unsafe"
type B interface {
A
_ = v
}
-// Test that we don't get "declared but not used"
+// Test that we don't get "declared and not used"
// errors in the context of invalid/C objects.
func issue20358() {
var F C /* ERROR "undefined" */ .F
var x int
func f0() {
-L1 /* ERROR "label L1 declared but not used" */ :
+L1 /* ERROR "label L1 declared and not used" */ :
for {
}
-L2 /* ERROR "label L2 declared but not used" */ :
+L2 /* ERROR "label L2 declared and not used" */ :
select {
}
-L3 /* ERROR "label L3 declared but not used" */ :
+L3 /* ERROR "label L3 declared and not used" */ :
switch {
}
-L4 /* ERROR "label L4 declared but not used" */ :
+L4 /* ERROR "label L4 declared and not used" */ :
if true {
}
-L5 /* ERROR "label L5 declared but not used" */ :
+L5 /* ERROR "label L5 declared and not used" */ :
f0()
L6:
f0()
// A label must be directly associated with a switch, select, or
// for statement; it cannot be the label of a labeled statement.
-L7a /* ERROR "declared but not used" */ : L7b:
+L7a /* ERROR "declared and not used" */ : L7b:
for {
break L7a /* ERROR "invalid break label L7a" */
continue L7a /* ERROR "invalid continue label L7a" */
switch {
case true:
break L9
- defalt /* ERROR "label defalt declared but not used" */ :
+ defalt /* ERROR "label defalt declared and not used" */ :
}
L10:
// Additional tests not in the original files.
func f2() {
-L1 /* ERROR "label L1 declared but not used" */ :
+L1 /* ERROR "label L1 declared and not used" */ :
if x == 0 {
for {
continue L1 /* ERROR "invalid continue label L1" */
ch2 := make(chan int)
select {
case <-ch1:
- var ch2 /* ERROR ch2 declared but not used */ chan bool
+ var ch2 /* ERROR ch2 declared and not used */ chan bool
case i := <-ch2:
print(i + 1)
}
default /* ERROR "multiple defaults" */ :
}
- switch x /* ERROR "declared but not used" */ := x.(type) {}
+ switch x /* ERROR "declared and not used" */ := x.(type) {}
switch _ /* ERROR "no new variable on left side of :=" */ := x.(type) {}
switch x := x.(type) {
_ = y
}
- switch x /* ERROR "x declared but not used" */ := i /* ERROR "not an interface" */ .(type) {}
+ switch x /* ERROR "x declared and not used" */ := i /* ERROR "not an interface" */ .(type) {}
switch t := x.(type) {
case nil:
// the loop body is still type-checked (and thus
// errors reported).
func issue10148() {
- for y /* ERROR declared but not used */ := range "" {
+ for y /* ERROR declared and not used */ := range "" {
_ = "" /* ERROR mismatched types untyped string and untyped int */ + 1
}
for range 1 /* ERROR cannot range over 1 */ {
// Variables declared in function bodies must be 'used'.
type T struct{}
func (r T) _(a, b, c int) (u, v, w int) {
- var x1 /* ERROR "declared but not used" */ int
- var x2 /* ERROR "declared but not used" */ int
+ var x1 /* ERROR "declared and not used" */ int
+ var x2 /* ERROR "declared and not used" */ int
x1 = 1
(x2) = 2
- y1 /* ERROR "declared but not used" */ := 1
- y2 /* ERROR "declared but not used" */ := 2
+ y1 /* ERROR "declared and not used" */ := 1
+ y2 /* ERROR "declared and not used" */ := 2
y1 = 1
(y1) = 2
{
- var x1 /* ERROR "declared but not used" */ int
- var x2 /* ERROR "declared but not used" */ int
+ var x1 /* ERROR "declared and not used" */ int
+ var x2 /* ERROR "declared and not used" */ int
x1 = 1
(x2) = 2
- y1 /* ERROR "declared but not used" */ := 1
- y2 /* ERROR "declared but not used" */ := 2
+ y1 /* ERROR "declared and not used" */ := 1
+ y2 /* ERROR "declared and not used" */ := 2
y1 = 1
(y1) = 2
}
- if x /* ERROR "declared but not used" */ := 0; a < b {}
+ if x /* ERROR "declared and not used" */ := 0; a < b {}
- switch x /* ERROR "declared but not used" */, y := 0, 1; a {
+ switch x /* ERROR "declared and not used" */, y := 0, 1; a {
case 0:
_ = y
case 1:
- x /* ERROR "declared but not used" */ := 0
+ x /* ERROR "declared and not used" */ := 0
}
var t interface{}
- switch t /* ERROR "declared but not used" */ := t.(type) {}
+ switch t /* ERROR "declared and not used" */ := t.(type) {}
- switch t /* ERROR "declared but not used" */ := t.(type) {
+ switch t /* ERROR "declared and not used" */ := t.(type) {
case int:
}
- switch t /* ERROR "declared but not used" */ := t.(type) {
+ switch t /* ERROR "declared and not used" */ := t.(type) {
case int:
case float32, complex64:
t = nil
}
}
- switch t := t; t /* ERROR "declared but not used" */ := t.(type) {}
+ switch t := t; t /* ERROR "declared and not used" */ := t.(type) {}
- var z1 /* ERROR "declared but not used" */ int
+ var z1 /* ERROR "declared and not used" */ int
var z2 int
_ = func(a, b, c int) (u, v, w int) {
z1 = a
}
var s []int
- var i /* ERROR "declared but not used" */ , j int
+ var i /* ERROR "declared and not used" */ , j int
for i, j = range s {
_ = j
}
- for i, j /* ERROR "declared but not used" */ := range s {
+ for i, j /* ERROR "declared and not used" */ := range s {
_ = func() int {
return i
}
// Unused variables in function literals must lead to only one error (issue #22524).
func _() {
_ = func() {
- var x /* ERROR declared but not used */ int
+ var x /* ERROR declared and not used */ int
}
}
-// Invalid variable declarations must not lead to "declared but not used errors".
-// TODO(gri) enable these tests once go/types follows types2 logic for declared but not used variables
+// Invalid variable declarations must not lead to "declared and not used errors".
+// TODO(gri) enable these tests once go/types follows types2 logic for declared and not used variables
// func _() {
// var a x // DISABLED_ERROR undefined: x
// var b = x // DISABLED_ERROR undefined: x
// var d, e, f x /* DISABLED_ERROR x */ /* DISABLED_ERROR x */ /* DISABLED_ERROR x */
// var g, h, i = x, x, x /* DISABLED_ERROR x */ /* DISABLED_ERROR x */ /* DISABLED_ERROR x */
// var j, k, l float32 = x, x, x /* DISABLED_ERROR x */ /* DISABLED_ERROR x */ /* DISABLED_ERROR x */
-// // but no "declared but not used" errors
+// // but no "declared and not used" errors
// }
-// Invalid (unused) expressions must not lead to spurious "declared but not used errors".
+// Invalid (unused) expressions must not lead to spurious "declared and not used errors".
func _() {
var a, b, c int
var x, y int
var u /* ERROR cycle */ , i [func /* ERROR used as value */ /* ERROR used as value */ (u, c /* ERROR undefined */ /* ERROR undefined */ ) {}(0, len /* ERROR must be called */ /* ERROR must be called */ )]c /* ERROR undefined */ /* ERROR undefined */
// crash 15
-func y15() { var a /* ERROR declared but not used */ interface{ p() } = G15[string]{} }
+func y15() { var a /* ERROR declared and not used */ interface{ p() } = G15[string]{} }
type G15[X any] s /* ERROR undefined */
func (G15 /* ERROR generic type .* without instantiation */ ) p()
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// Ensure there is no "imported but not used" error
+// Ensure there is no "imported and not used" error
// if a package wasn't imported in the first place.
package p
package foo
func f(x interface{}) {
- switch t := x.(type) { // ERROR "declared but not used"
+ switch t := x.(type) { // ERROR "declared and not used"
case int:
}
}
// license that can be found in the LICENSE file.
// Issue 3899: 8g incorrectly thinks a variable is
-// "set but not used" and elides an assignment, causing
+// "set and not used" and elides an assignment, causing
// variables to end up with wrong data.
//
// The reason is a miscalculation of variable width.
func f() {
select {
- case x, x := <-func() chan int { // ERROR "x repeated on left side of :=|redefinition|declared but not used"
+ case x, x := <-func() chan int { // ERROR "x repeated on left side of :=|redefinition|declared and not used"
c := make(chan int)
return c
}():
package main
-import "math" // ERROR "imported and not used|imported but not used"
+import "math" // ERROR "imported and not used"
func main() {
math:
package p
func _() {
- if a := 10 { // ERROR "cannot use a := 10 as value|expected .*;|declared but not used"
+ if a := 10 { // ERROR "cannot use a := 10 as value|expected .*;|declared and not used"
}
- for b := 10 { // ERROR "cannot use b := 10 as value|parse error|declared but not used"
+ for b := 10 { // ERROR "cannot use b := 10 as value|parse error|declared and not used"
}
- switch c := 10 { // ERROR "cannot use c := 10 as value|expected .*;|declared but not used"
+ switch c := 10 { // ERROR "cannot use c := 10 as value|expected .*;|declared and not used"
}
}
const x = 1
func G() {
- switch t := x.(type) { // ERROR "cannot type switch on non-interface value|declared but not used|not an interface"
+ switch t := x.(type) { // ERROR "cannot type switch on non-interface value|declared and not used|not an interface"
default:
}
}
log.Fatalf("expected cmd/compile to fail")
}
wantErrs := []string{
- "7:9: n declared but not used",
- "7:12: err declared but not used",
+ "7:9: n declared and not used",
+ "7:12: err declared and not used",
}
outStr := string(out)
for _, want := range wantErrs {
i1 := it{Floats: true}
if i1.floats { // ERROR "(type it .* field or method floats, but does have Floats)|undefined field or method"
}
- i2 := &it{floats: false} // ERROR "(but does have Floats)|unknown field|declared but not used"
+ i2 := &it{floats: false} // ERROR "(but does have Floats)|unknown field|declared and not used"
_ = &it{InneR: "foo"} // ERROR "(but does have inner)|unknown field"
_ = i2
}
switch x.(type) {
}
- switch t := x.(type) { // ERROR "declared but not used"
+ switch t := x.(type) { // ERROR "declared and not used"
}
}
// Test that we type-check deferred/go functions even
// if they are not called (a common error). Specifically,
// we don't want to see errors such as import or variable
-// declared but not used.
+// declared and not used.
package p
package main
func _() {
- x := 7 // ERROR ".*x.* declared but not used"
+ x := 7 // ERROR ".*x.* declared and not used"
}
package p
import (
- "./a" // ERROR "imported and not used: \x22test/a\x22 as surprise|imported and not used: surprise"
- "./b" // ERROR "imported and not used: \x22test/b\x22 as surprise2|imported and not used: surprise2"
- b "./b" // ERROR "imported and not used: \x22test/b\x22$|imported and not used: surprise2"
- foo "math" // ERROR "imported and not used: \x22math\x22 as foo|imported and not used: math"
+ "./a" // ERROR "imported and not used: \x22test/a\x22 as surprise|imported and not used: surprise|\x22test/a\x22 imported as surprise and not used"
+ "./b" // ERROR "imported and not used: \x22test/b\x22 as surprise2|imported and not used: surprise2|\x22test/b\x22 imported as surprise2 and not used"
+ b "./b" // ERROR "imported and not used: \x22test/b\x22$|imported and not used: surprise2|\x22test/b\x22 imported and not used"
+ foo "math" // ERROR "imported and not used: \x22math\x22 as foo|imported and not used: math|\x22math\x22 imported as foo and not used"
"fmt" // actually used
- "strings" // ERROR "imported and not used: \x22strings\x22|imported and not used: strings"
+ "strings" // ERROR "imported and not used: \x22strings\x22|imported and not used: strings|\x22strings\x22 imported and not used"
)
var _ = fmt.Printf
package main
import "bufio" // ERROR "previous|not used"
-import bufio "os" // ERROR "redeclared|redefinition|incompatible" "imported and not used"
+import bufio "os" // ERROR "redeclared|redefinition|incompatible" "imported and not used|imported as bufio and not used"
import (
"fmt" // ERROR "previous|not used"
- fmt "math" // ERROR "redeclared|redefinition|incompatible" "imported and not used: \x22math\x22 as fmt"
- . "math" // GC_ERROR "imported and not used: \x22math\x22$"
+ fmt "math" // ERROR "redeclared|redefinition|incompatible" "imported and not used: \x22math\x22 as fmt|imported as fmt and not used"
+ . "math" // GC_ERROR "imported and not used: \x22math\x22$|imported and not used"
)
package main
// standard
-import "fmt" // ERROR "imported and not used.*fmt"
+import "fmt" // ERROR "imported and not used.*fmt|\x22fmt\x22 imported and not used"
// renamed
-import X "math" // ERROR "imported and not used.*math"
+import X "math" // ERROR "imported and not used.*math|\x22math\x22 imported as X and not used"
// import dot
-import . "bufio" // ERROR "imported and not used.*bufio"
+import . "bufio" // ERROR "imported and not used.*bufio|imported and not used"
// again, package without anything in it
-import "./empty" // ERROR "imported and not used.*empty"
-import Z "./empty" // ERROR "imported and not used.*empty"
-import . "./empty" // ERROR "imported and not used.*empty"
+import "./empty" // ERROR "imported and not used.*empty|imported and not used"
+import Z "./empty" // ERROR "imported and not used.*empty|imported as Z and not used"
+import . "./empty" // ERROR "imported and not used.*empty|imported and not used"
func notused(x interface{}) {
// The first t is in a different scope than the 2nd t; it cannot
- // be accessed (=> declared but not used error); but it is legal
+ // be accessed (=> declared and not used error); but it is legal
// to declare it.
- switch t := 0; t := x.(type) { // ERROR "declared but not used"
+ switch t := 0; t := x.(type) { // ERROR "declared and not used"
case int:
_ = t // this is using the t of "t := x.(type)"
}