//
// Specifically, it tests a scenerio wherein a C
// thread is calling into Go, creating a goroutine in
// a syscall (in the tracer's model). Because the actual
// m can be reused, it's possible for that m to have never
// had its P (in _Psyscall) stolen if the runtime doesn't
// model the scenario correctly. Make sure we reject such
// traces.

package main

import (
	"internal/trace"
	"internal/trace/event/go122"

Russ Cox <******@****.***> 1531944576 -0400

		(&p).Mv()
		(*&p).Mv()
		p.Mp()
		(&p).Mp()
		(*&p).Mp()
	}
	{
		var p P7
		p.Mv()     // ERROR "undefined"
		(&p).Mv()  // ERROR "undefined"
		(*&p).Mv() // ERROR "undefined"
		(**&p).Mv()
		(*p).Mv()
		(&*p).Mv()
		p.Mp()     // ERROR "undefined"
		(&p).Mp()  // ERROR "undefined"
		(*&p).Mp() // ERROR "undefined"
		(**&p).Mp()
		(*p).Mp()
		(&*p).Mp()
	}
	{
		var p P8

func _[P any]() {
        type (
                _[P any] interface{ *P | []P | chan P | map[string]P }
                _[P any] interface{ P /* ERROR "term cannot be a type parameter" */ }
                _[P any] interface{ ~P /* ERROR "type in term ~P cannot be a type parameter" */ }
                _[P any] interface{ int | P /* ERROR "term cannot be a type parameter" */ }

	`package p; type _ [A+B]struct{}`,
	`package p; func (R) _()`,
	`package p; type _ struct{ f [n]E }`,
	`package p; type _ struct{ f [a+b+c+d]E }`,
	`package p; type I1 interface{}; type I2 interface{ I1 }`,

	// generic code
	`package p; type _ []T[int]`,
	`package p; type T[P any] struct { P }`,
	`package p; type T[P comparable] struct { P }`,
	`package p; type T[P comparable[P]] struct { P }`,

func (x T[P]) m()
func ((T[P])) m(x T[P]) P

func _() {
	type _ []T[P]
	var _ []T[P]
	_ = []T[P]{}
}

// type constraint literals with elided interfaces
func _[P ~int, Q int | string]() {}
func _[P struct{f int}, Q *P]() {}

// various potentially ambiguous type parameter lists (issue #49482)
type _[P *T,] struct{}
type _[P T | T] struct{}
type _[P T | T | T | T] struct{}

        where:
        source                                             | transformed
        "  <p>text</p>   "                                 | "<p>text</p>"
        "<p>text</p>   <p>text</p>"                        | "<p>text</p><p>text</p>"
        "<p>text</p>   <h2>text</h2> <table/>"             | "<p>text</p><h2>text</h2><table></table>"
        "  <table>  <tr>  <td>text</td> </tr>\r\n</table>" | "<table><tr><td>text</td></tr></table>"

		p.print(_Func)
		p.printSignature(n)

	case *InterfaceType:
		p.print(_Interface)
		if p.linebreaks && len(n.MethodList) > 1 {
			p.print(blank)
			p.print(_Lbrace)
			p.print(newline, indent)
			p.printMethodList(n.MethodList)
			p.print(outdent, newline)
		} else {
			p.print(_Lbrace)
			p.printMethodList(n.MethodList)
		}
		p.print(_Rbrace)

	case *MapType:

		*p.next.ptr() = memHdr{}
	} else {
		bp.next = p.next
	}
	if uintptr(unsafe.Pointer(p))+p.size == bpn {
		p.size += bp.size
		p.next = bp.next
		*bp = memHdr{}
	} else {
		p.next.set(bp)
	}
}

func memCheck() {
	if !memDebug {
		return
	}
	for p := memFreelist.ptr(); p != nil && p.next != 0; p = p.next.ptr() {
		if uintptr(unsafe.Pointer(p)) == uintptr(unsafe.Pointer(p.next)) {

		p.As = mov
		p.From.Type = obj.TYPE_REG
		p.From.Reg = REGLINK
		p.To.Type = obj.TYPE_MEM
		p.To.Offset = int64(-frameSize)
		p.To.Reg = REGSP

		// MOV	REGCTXT, -4/-8(SP)
		p = obj.Appendp(p, c.newprog)
		p.As = mov
		p.From.Type = obj.TYPE_REG
		p.From.Reg = REGCTXT
		p.To.Type = obj.TYPE_MEM
		p.To.Offset = -int64(c.ctxt.Arch.PtrSize)
		p.To.Reg = REGSP

		// ADD	$-8/$-16, SP