Your IP : 172.28.240.42
// -lang=go1.17
// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package p // don't permit non-interface elements in interfaces
import (
"fmt"
syn "regexp/syntax"
t1 "text/template"
t2 "html/template"
)
func issue7035() {
type T struct{ X int }
_ = func() {
fmt.Println() // must refer to imported fmt rather than the fmt below
}
fmt := new(T)
_ = fmt.X
}
func issue8066() {
const (
_ = float32(340282356779733661637539395458142568447)
_ = float32(340282356779733661637539395458142568448 /* ERROR "cannot convert" */ )
)
}
// Check that a missing identifier doesn't lead to a spurious error cascade.
func issue8799a() {
x, ok := missing /* ERROR "undefined" */ ()
_ = !ok
_ = x
}
func issue8799b(x int, ok bool) {
x, ok = missing /* ERROR "undefined" */ ()
_ = !ok
_ = x
}
func issue9182() {
type Point C /* ERROR "undefined" */ .Point
// no error for composite literal based on unknown type
_ = Point{x: 1, y: 2}
}
func f0() (a []int) { return }
func f1() (a []int, b int) { return }
func f2() (a, b []int) { return }
func append_([]int, ...int) {}
func issue9473(a []int, b ...int) {
// variadic builtin function
_ = append(f0())
_ = append(f0(), f0()...)
_ = append(f1())
_ = append(f2 /* ERRORx `cannot use .* in argument` */ ())
_ = append(f2()... /* ERROR "cannot use ..." */ )
_ = append(f0(), f1 /* ERROR "multiple-value f1" */ ())
_ = append(f0(), f2 /* ERROR "multiple-value f2" */ ())
_ = append(f0(), f1 /* ERROR "multiple-value f1" */ ()...)
_ = append(f0(), f2 /* ERROR "multiple-value f2" */ ()...)
// variadic user-defined function
append_(f0())
append_(f0(), f0()...)
append_(f1())
append_(f2 /* ERRORx `cannot use .* in argument` */ ())
append_(f2()... /* ERROR "cannot use ..." */ )
append_(f0(), f1 /* ERROR "multiple-value f1" */ ())
append_(f0(), f2 /* ERROR "multiple-value f2" */ ())
append_(f0(), f1 /* ERROR "multiple-value f1" */ ()...)
append_(f0(), f2 /* ERROR "multiple-value f2" */ ()...)
}
// Check that embedding a non-interface type in an interface results in a good error message.
func issue10979() {
type _ interface {
int /* ERROR "non-interface type int" */
}
type T struct{}
type _ interface {
T /* ERROR "non-interface type T" */
}
type _ interface {
nosuchtype /* ERROR "undefined: nosuchtype" */
}
type _ interface {
fmt.Nosuchtype /* ERROR "undefined: fmt.Nosuchtype" */
}
type _ interface {
nosuchpkg /* ERROR "undefined: nosuchpkg" */ .Nosuchtype
}
type I interface {
I.m /* ERROR "I.m is not a type" */
m()
}
}
// issue11347
// These should not crash.
var a1, b1 /* ERROR "cycle" */ , c1 /* ERROR "cycle" */ b1 = 0 > 0<<""[""[c1]]>c1
var a2, b2 /* ERROR "cycle" */ = 0 /* ERROR "assignment mismatch" */ /* ERROR "assignment mismatch" */ > 0<<""[b2]
var a3, b3 /* ERROR "cycle" */ = int /* ERROR "assignment mismatch" */ /* ERROR "assignment mismatch" */ (1<<""[b3])
// issue10260
// Check that error messages explain reason for interface assignment failures.
type (
I0 interface{}
I1 interface{ foo() }
I2 interface{ foo(x int) }
T0 struct{}
T1 struct{}
T2 struct{}
)
func (*T1) foo() {}
func (*T2) foo(x int) {}
func issue10260() {
var (
i0 I0
i1 I1
i2 I2
t0 *T0
t1 *T1
t2 *T2
)
var x I1
x = T1 /* ERRORx `cannot use T1{} .* as I1 value in assignment: T1 does not implement I1 \(method foo has pointer receiver\)` */ {}
_ = x /* ERROR "impossible type assertion: x.(T1)\n\tT1 does not implement I1 (method foo has pointer receiver)" */ .(T1)
T1{}.foo /* ERROR "cannot call pointer method foo on T1" */ ()
x.Foo /* ERROR "x.Foo undefined (type I1 has no field or method Foo, but does have foo)" */ ()
_ = i2 /* ERROR "impossible type assertion: i2.(*T1)\n\t*T1 does not implement I2 (wrong type for method foo)\n\t\thave foo()\n\t\twant foo(int)" */ .(*T1)
i1 = i0 /* ERRORx `cannot use i0 .* as I1 value in assignment: I0 does not implement I1 \(missing method foo\)` */
i1 = t0 /* ERRORx `.* t0 .* as I1 .*: \*T0 does not implement I1 \(missing method foo\)` */
i1 = i2 /* ERRORx `.* i2 .* as I1 .*: I2 does not implement I1 \(wrong type for method foo\)\n\t\thave foo\(int\)\n\t\twant foo\(\)` */
i1 = t2 /* ERRORx `.* t2 .* as I1 .*: \*T2 does not implement I1 \(wrong type for method foo\)\n\t\thave foo\(int\)\n\t\twant foo\(\)` */
i2 = i1 /* ERRORx `.* i1 .* as I2 .*: I1 does not implement I2 \(wrong type for method foo\)\n\t\thave foo\(\)\n\t\twant foo\(int\)` */
i2 = t1 /* ERRORx `.* t1 .* as I2 .*: \*T1 does not implement I2 \(wrong type for method foo\)\n\t\thave foo\(\)\n\t\twant foo\(int\)` */
_ = func() I1 { return i0 /* ERRORx `cannot use i0 .* as I1 value in return statement: I0 does not implement I1 \(missing method foo\)` */ }
_ = func() I1 { return t0 /* ERRORx `.* t0 .* as I1 .*: \*T0 does not implement I1 \(missing method foo\)` */ }
_ = func() I1 { return i2 /* ERRORx `.* i2 .* as I1 .*: I2 does not implement I1 \(wrong type for method foo\)\n\t\thave foo\(int\)\n\t\twant foo\(\)` */ }
_ = func() I1 { return t2 /* ERRORx `.* t2 .* as I1 .*: \*T2 does not implement I1 \(wrong type for method foo\)\n\t\thave foo\(int\)\n\t\twant foo\(\)` */ }
_ = func() I2 { return i1 /* ERRORx `.* i1 .* as I2 .*: I1 does not implement I2 \(wrong type for method foo\)\n\t\thave foo\(\)\n\t\twant foo\(int\)` */ }
_ = func() I2 { return t1 /* ERRORx `.* t1 .* as I2 .*: \*T1 does not implement I2 \(wrong type for method foo\)\n\t\thave foo\(\)\n\t\twant foo\(int\)` */ }
// a few more - less exhaustive now
f := func(I1, I2){}
f(i0 /* ERROR "missing method foo" */ , i1 /* ERROR "wrong type for method foo" */ )
_ = [...]I1{i0 /* ERRORx `cannot use i0 .* as I1 value in array or slice literal: I0 does not implement I1 \(missing method foo\)` */ }
_ = [...]I1{i2 /* ERRORx `cannot use i2 .* as I1 value in array or slice literal: I2 does not implement I1 \(wrong type for method foo\)\n\t\thave foo\(int\)\n\t\twant foo\(\)` */ }
_ = []I1{i0 /* ERROR "missing method foo" */ }
_ = []I1{i2 /* ERROR "wrong type for method foo" */ }
_ = map[int]I1{0: i0 /* ERROR "missing method foo" */ }
_ = map[int]I1{0: i2 /* ERROR "wrong type for method foo" */ }
make(chan I1) <- i0 /* ERROR "missing method foo" */
make(chan I1) <- i2 /* ERROR "wrong type for method foo" */
}
// Check that constants representable as integers are in integer form
// before being used in operations that are only defined on integers.
func issue14229() {
// from the issue
const _ = int64(-1<<63) % 1e6
// related
const (
a int = 3
b = 4.0
_ = a / b
_ = a % b
_ = b / a
_ = b % a
)
}
// Check that in a n:1 variable declaration with type and initialization
// expression the type is distributed to all variables of the lhs before
// the initialization expression assignment is checked.
func issue15755() {
// from issue
var i interface{}
type b bool
var x, y b = i.(b)
_ = x == y
// related: we should see an error since the result of f1 is ([]int, int)
var u, v []int = f1 /* ERROR "cannot use f1" */ ()
_ = u
_ = v
}
// 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 A C /* ERROR "undefined" */ .A
var S C /* ERROR "undefined" */ .S
type T C /* ERROR "undefined" */ .T
type P C /* ERROR "undefined" */ .P
// these variables must be "used" even though
// the LHS expressions/types below in which
// context they are used are unknown/invalid
var f, a, s1, s2, s3, t, p int
_ = F(f)
_ = A[a]
_ = S[s1:s2:s3]
_ = T{t}
_ = P{f: p}
}
// Test that we don't declare lhs variables in short variable
// declarations before we type-check function literals on the
// rhs.
func issue24026() {
f := func() int { f(0) /* must refer to outer f */; return 0 }
_ = f
_ = func() {
f := func() { _ = f() /* must refer to outer f */ }
_ = f
}
// b and c must not be visible inside function literal
a := 0
a, b, c := func() (int, int, int) {
return a, b /* ERROR "undefined" */ , c /* ERROR "undefined" */
}()
_, _ = b, c
}
func f(int) {} // for issue24026
// Test that we don't report a "missing return statement" error
// (due to incorrect context when type-checking interfaces).
func issue24140(x interface{}) int {
switch x.(type) {
case interface{}:
return 0
default:
panic(0)
}
}
// Test that we don't crash when the 'if' condition is missing.
func issue25438() {
if { /* ERROR "missing condition" */ }
if x := 0; /* ERROR "missing condition" */ { _ = x }
if
{ /* ERROR "missing condition" */ }
}
// Test that we can embed alias type names in interfaces.
type issue25301 interface {
E
}
type E = interface {
m()
}
// Test case from issue.
// cmd/compile reports a cycle as well.
type issue25301b /* ERROR "invalid recursive type" */ = interface {
m() interface{ issue25301b }
}
type issue25301c interface {
notE // ERROR "non-interface type struct{}"
}
type notE = struct{}
// Test that method declarations don't introduce artificial cycles
// (issue #26124).
const CC TT = 1
type TT int
func (TT) MM() [CC]TT
// Reduced test case from issue #26124.
const preloadLimit LNumber = 128
type LNumber float64
func (LNumber) assertFunction() *LFunction
type LFunction struct {
GFunction LGFunction
}
type LGFunction func(*LState)
type LState struct {
reg *registry
}
type registry struct {
alloc *allocator
}
type allocator struct {
_ [int(preloadLimit)]int
}
// Test that we don't crash when type-checking composite literals
// containing errors in the type.
var issue27346 = [][n /* ERROR "undefined" */ ]int{
0: {},
}
var issue22467 = map[int][... /* ERROR "invalid use of [...] array" */ ]int{0: {}}
// Test that invalid use of ... in parameter lists is recognized
// (issue #28281).
func issue28281a(int, int, ...int)
func issue28281b(a, b int, c ...int)
func issue28281c(a, b, c ... /* ERROR "can only use ... with final parameter" */ int)
func issue28281d(... /* ERROR "can only use ... with final parameter" */ int, int)
func issue28281e(a, b, c ... /* ERROR "can only use ... with final parameter" */ int, d int)
func issue28281f(... /* ERROR "can only use ... with final parameter" */ int, ... /* ERROR "can only use ... with final parameter" */ int, int)
func (... /* ERROR "can only use ... with final parameter" */ TT) f()
func issue28281g() (... /* ERROR "can only use ... with final parameter" */ TT)
// Issue #26234: Make various field/method lookup errors easier to read by matching cmd/compile's output
func issue26234a(f *syn.Prog) {
// The error message below should refer to the actual package name (syntax)
// not the local package name (syn).
f.foo /* ERROR "f.foo undefined (type *syntax.Prog has no field or method foo)" */
}
type T struct {
x int
E1
E2
}
type E1 struct{ f int }
type E2 struct{ f int }
func issue26234b(x T) {
_ = x.f /* ERROR "ambiguous selector x.f" */
}
func issue26234c() {
T.x /* ERROR "T.x undefined (type T has no method x)" */ ()
}
func issue35895() {
// T is defined in this package, don't qualify its name with the package name.
var _ T = 0 // ERROR "cannot use 0 (untyped int constant) as T"
// There is only one package with name syntax imported, only use the (global) package name in error messages.
var _ *syn.Prog = 0 // ERROR "cannot use 0 (untyped int constant) as *syntax.Prog"
// Because both t1 and t2 have the same global package name (template),
// qualify packages with full path name in this case.
var _ t1.Template = t2 /* ERRORx `cannot use .* \(value of type .html/template.\.Template\) as .text/template.\.Template` */ .Template{}
}
func issue42989(s uint) {
var m map[int]string
delete(m, 1<<s)
delete(m, 1.<<s)
}