// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

func main() {
	Foo: {
		return;
	}
	goto Foo;
}
/*
bug5.go:4: Foo undefined
bug5.go:4: fatal error: walktype: switch 1 unknown op GOTO l(4)

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package bug1

import "./bug0"

// This is expected to fail--t0 is in package bug0 and should not be
// visible here in package bug1.  The test for failure is in
// ../bug083.go.

package main

import P "./bug0"

func main() {
	a0 := P.V0();  // works
	a1 := P.V1();  // works
	a2, b2 := P.V2();  // doesn't work
	_, _, _, _ = a0, a1, a2, b2;
}

/*
uetli:~/Source/go1/test/bugs/bug088.dir gri$ 6g bug0.go && 6g bug1.go
bug1.go:8: shape error across :=
bug1.go:8: a2: undefined
bug1.go:8: b2: undefined
bug1.go:8: illegal types for operand: AS
	(<(bug0)P.int32>INT32)

	{"bug2", "{{$.NonEmptyInterface.Method0}}", "M0", tVal, true},
	// Struct values were not legal in with - mere oversight.
	{"bug3", "{{with $}}{{.Method0}}{{end}}", "M0", tVal, true},
	// Nil interface values in if.
	{"bug4", "{{if .Empty0}}non-nil{{else}}nil{{end}}", "nil", tVal, true},
	// Stringer.
	{"bug5", "{{.Str}}", "foozle", tVal, true},
	{"bug5a", "{{.Err}}", "erroozle", tVal, true},

	{"bug2", "{{$.NonEmptyInterface.Method0}}", "M0", tVal, true},
	// Struct values were not legal in with - mere oversight.
	{"bug3", "{{with $}}{{.Method0}}{{end}}", "M0", tVal, true},
	// Nil interface values in if.
	{"bug4", "{{if .Empty0}}non-nil{{else}}nil{{end}}", "nil", tVal, true},
	// Stringer.
	{"bug5", "{{.Str}}", "foozle", tVal, true},
	{"bug5a", "{{.Err}}", "erroozle", tVal, true},

// Copyright 2010 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 s

import (
	p0 "./bug0"
	p1 "./bug1"
)

// both p0.T and p1.T are struct { X, Y int }.

var v0 p0.T
var v1 p1.T

// interfaces involving the two

type I0 interface {
	M(p0.T)
}

type I1 interface {
	M(p1.T)
}

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package bug2

import _ "./bug1"
import "./bug0"

type T2 struct { t bug0.T }

func fn(p *T2) int {
	// This reference should be invalid, because bug0.T.i is local
	// to package bug0 and should not be visible in package bug1.
	return p.t.i;	// ERROR "field|undef"

	// path is full (rooted) path name.  check suffix for gc, prefix for gccgo
	if s := reflect.TypeOf(v0).PkgPath(); !strings.HasSuffix(s, "/bug0") && !strings.HasPrefix(s, "bug0") {
		println("bad v0 path", len(s), s)
		panic("fail")
	}
	if s := reflect.TypeOf(v1).PkgPath(); !strings.HasSuffix(s, "/bug1") && !strings.HasPrefix(s, "bug1") {
		println("bad v1 path", s)
		panic("fail")
	}

	// check that dynamic interface check doesn't get confused

// Copyright 2009 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 bug1

import "./bug0"

// Copyright 2009 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 ignored

// Compile: bug0.go, bug1.go
// Compile and errorCheck: bug2.go