// 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 go1_17 // 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 undeclared */ ()
	_ = !ok
	_ = x
}

func issue8799b(x int, ok bool) {
	x, ok = missing /* ERROR undeclared */ ()
	_ = !ok
	_ = x
}

func issue9182() {
	type Point C /* ERROR undeclared */ .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 /* ERROR cannot use .* in argument */ ())
	_ = append(f2()... /* ERROR cannot use ... */ )
	_ = append(f0(), f1 /* ERROR 2-valued f1 */ ())
	_ = append(f0(), f2 /* ERROR 2-valued f2 */ ())
	_ = append(f0(), f1 /* ERROR 2-valued f1 */ ()...)
	_ = append(f0(), f2 /* ERROR 2-valued f2 */ ()...)

	// variadic user-defined function
	append_(f0())
	append_(f0(), f0()...)
	append_(f1())
	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 */ ())
	append_(f0(), f1 /* ERROR 2-valued f1 */ ()...)
	append_(f0(), f2 /* ERROR 2-valued 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 undeclared name: nosuchtype */
	}
	type _ interface {
		fmt.Nosuchtype /* ERROR Nosuchtype not declared by package fmt */
	}
	type _ interface {
		nosuchpkg /* ERROR undeclared name: nosuchpkg */ .Nosuchtype
	}
	type I interface {
		I.m /* ERROR no field or method m */
		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 cannot initialize */ /* ERROR cannot initialize */ > 0<<""[b2]
var a3, b3 /* ERROR cycle */ = int /* ERROR cannot initialize */ /* ERROR cannot initialize */ (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 /* ERROR cannot use .*: missing method foo \(foo has pointer receiver\) */ {}
	_ = x /* ERROR .* cannot have dynamic type T1 \(missing method foo \(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 i2 .* cannot have dynamic type \*T1 \(wrong type for method foo \(have func\(\), want func\(x int\)\)\) */ .(*T1)

	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 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 use .* missing method foo */ , i1 /* ERROR cannot use .* wrong type for method foo \(have func\(\), want func\(x int\)\) */ )

	_ = [...]I1{i0 /* ERROR cannot use .* missing method foo */ }
	_ = [...]I1{i2 /* 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 */ }
	_ = 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 use .* in send: missing method foo */
	make(chan I1) <- i2 /* ERROR cannot use .* in send: 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 but not used"
// errors in the context of invalid/C objects.
func issue20358() {
	var F C /* ERROR "undeclared" */ .F
	var A C /* ERROR "undeclared" */ .A
	var S C /* ERROR "undeclared" */ .S
	type T C /* ERROR "undeclared" */ .T
	type P C /* ERROR "undeclared" */ .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 undeclared */ , c /* ERROR undeclared */
	}()
	_, _ = 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 cycle */ = 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 undeclared */ ]int{
	0: {},
}

var issue22467 = map[int][... /* ERROR invalid use of ... */ ]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 /* ERROR 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)
}