example.net/m v0.2.0 => ./m2
	example.net/m/p v1.0.0 => ./p0
)
-- importer.go --
package importer
import _ "example.net/m/p"
-- m1/go.mod --
module example.net/m

go 1.16
-- m1/p/p.go --
package p
-- m2/go.mod --
module example.net/m

go 1.16
-- m2/README.txt --
Package p has been moved to module …/m/p.
Module …/m/p does not require any version of module …/m.

-- p0/go.mod --

</p>

<p>
Not allowing a single write to write multiple values also means not using
the memory where a local variable will be written as temporary storage before the write.
For example, a compiler must not use <code>*p</code> as temporary storage in this program:
</p>

<pre>
*p = i + *p/2
</pre>

<p>
That is, it must not rewrite the program into this one:
</p>

<pre>
*p /= 2
*p += i

	return hypot(p, q)
}

func hypot(p, q float64) float64 {
	p, q = Abs(p), Abs(q)
	// special cases
	switch {
	case IsInf(p, 1) || IsInf(q, 1):
		return Inf(1)
	case IsNaN(p) || IsNaN(q):
		return NaN()
	}
	if p < q {
		p, q = q, p
	}
	if p == 0 {
		return 0
	}
	q = q / p
	return p * Sqrt(1+q*q)

		expected string
	}{
		{
			func(p *Path) *Path { return p },
			"root",
		},
		{
			func(p *Path) *Path { return p.Child("first") },
			"root.first",
		},
		{
			func(p *Path) *Path { return p.Child("second") },
			"root.first.second",
		},
		{
			func(p *Path) *Path { return p.Index(0) },
			"root.first.second[0]",
		},
		{
			func(p *Path) *Path { return p.Child("third") },

		panic("FAIL")
	}
	if &y != p {
		print("&y=", &y, " p=", p, " &y==p = ", &y==p, "\n")
		panic("FAIL")
	}

    }

    @Nullable
    private <T, P extends ValueSourceParameters> Class<P> extractParametersTypeOf(Class<? extends ValueSource<T, P>> valueSourceType) {
        return isolationScheme.parameterTypeFor(valueSourceType, 1);
    }

    private <P extends ValueSourceParameters> void configureParameters(@Nullable P parameters, Action<? super ValueSourceSpec<P>> configureAction) {

	x := 0
	p := &x
	_ = func(p **int) *int { // ERROR "leaking param: p to result ~r0 level=1" "func literal does not escape"
		return *p
	}(&p)
}

func ClosureCallArgs15() {
	x := 0 // ERROR "moved to heap: x"
	p := &x
	sink = func(p **int) *int { // ERROR "leaking param content: p" "func literal does not escape"
		return *p
	}(&p)
}

func ClosureLeak1(s string) string { // ERROR "s does not escape"

// license that can be found in the LICENSE file.

package p

type T interface{ m() }
type P *T

func _(p *T) {
	p.m /* ERROR "type *T is pointer to interface, not interface" */ ()
}

func _(p P) {
	p.m /* ERROR "type P is pointer to interface, not interface" */ ()
}

func _[P T](p *P) {
	p.m /* ERROR "type *P is pointer to type parameter, not type parameter" */ ()

package b

import (
	"example.com/q"
)

func Foo() {
	q.Q()
}
-- p/go.mod --
go 1.18

module example.com/p
-- p/p.go --
package p

func P() {}
-- q/go.mod --
go 1.18

module example.com/q

require (
	example.com/p v1.0.0
)

replace (
	example.com/p => ../p
)
-- q/q.go --
package q

func Q() {
}
-- q/q_test.go --
package q

	}
	if p.tok == '<' && p.scanner.Peek() == 'e' {
		// EscInfo = "<esc:" int ">" . (optional and ignored)
		p.next()
		p.expectKeyword("esc")
		p.expect(':')
		p.expect(scanner.Int)
		p.expect('>')
	}
	if p.tok == '.' {
		p.next()
		p.expect('.')
		p.expect('.')
		isVariadic = true
	}
	typ := p.parseType(pkg)
	if isVariadic {
		typ = types.NewSlice(typ)
	}