// 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 (

func test31891(t *testing.T) {
	C.callIssue31891()
}

// issue 37033, check if cgo.Handle works properly

var issue37033 = 42

//export GoFunc37033
func GoFunc37033(handle C.uintptr_t) {
	h := cgo.Handle(handle)
	ch := h.Value().(chan int)
	ch <- issue37033
}

// issue 38408
// A typedef pointer can be used as the element type.
// No runtime test; just make sure it compiles.

	// This package only handles gc export data.
	if runtime.Compiler != "gc" {
		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
	}

	compileAndImportPkg(t, "issue57015")
}

func importPkg(t *testing.T, path, srcDir string) *types.Package {
	fset := token.NewFileSet()
	pkg, err := Import(fset, make(map[string]*types.Package), path, srcDir, nil)
	if err != nil {
		t.Helper()

// that mirror to the 9 glibc syscalls with POSIX semantics. The test
// here is considered authoritative and should compile and run
// CGO_ENABLED=0 or 1. Note, there is an extended copy of this same
// test in ../../misc/cgo/test/issue1435.go which requires
// CGO_ENABLED=1 and launches pthreads from C that run concurrently
// with the Go code of the test - and the test validates that these
// pthreads are also kept in sync with the security state changed with

	ch := make(chan int)

	for i := 0; i < 42; i++ {
		h := cgo.NewHandle(ch)
		go func() {
			C.cFunc37033(C.uintptr_t(h))
		}()
		if v := <-ch; issue37033 != v {
			t.Fatalf("unexpected receiving value: got %d, want %d", v, issue37033)
		}
		h.Delete()
	}
}

// issue 38649

var issue38649 C.netbsd_gid = 42

// issue 39877

var issue39877 *C.void = nil

	return m["foo"] // ERROR ".foo. does not escape$"
}

func nonescapingIface(m map[M]bool) bool { // ERROR "m does not escape$"
	return m[MV(0)] // ERROR "MV\(0\) does not escape$"
}

func issue10353() {
	x := new(int) // ERROR "new\(int\) escapes to heap$"
	issue10353a(x)()
}

func issue10353a(x *int) func() { // ERROR "leaking param: x$"
	return func() { // ERROR "func literal escapes to heap$"

	return m["foo"] // ERROR ".foo. does not escape$"
}

func nonescapingIface(m map[M]bool) bool { // ERROR "m does not escape$"
	return m[MV(0)] // ERROR "MV\(0\) does not escape$"
}

func issue10353() {
	x := new(int) // ERROR "new\(int\) escapes to heap$"
	issue10353a(x)()
}

func issue10353a(x *int) func() { // ERROR "leaking param: x$"
	return func() { // ERROR "func literal escapes to heap$"