}

var nilStruct *Ship

type EmbedA struct {
	EmbedC
	EmbedB EmbedB
	FieldA string
	embedD
}

type EmbedB struct {
	FieldB string
	*EmbedC
}

type EmbedC struct {
	FieldA1 string `xml:"FieldA>A1"`
	FieldA2 string `xml:"FieldA>A2"`
	FieldB  string
	FieldC  string
}

type embedD struct {
	fieldD string

import "embed"

//go:embed z*t*t
var Z string

-- x.go2 --
package p

import "embed"

//go:embed *t
var X embed.FS

-- x.go3 --
package p

import "embed"

//go:embed all:t
var X embed.FS

-- x.txt --
hello

-- y.txt --
-- z.txt --
-- x.txt2 --
not hello

-- use/use.go --
package use

import _ "m"
-- go.mod --
module m

//	//go:embed image template html/index.html
//	var content embed.FS
//
// The difference is that ‘image/*’ embeds ‘image/.tempfile’ while ‘image’ does not.
// Neither embeds ‘image/dir/.tempfile’.
//
// If a pattern begins with the prefix ‘all:’, then the rule for walking directories is changed
// to include those files beginning with ‘.’ or ‘_’. For example, ‘all:image’ embeds
// both ‘image/.tempfile’ and ‘image/dir/.tempfile’.
//

		S6 struct {
			embed1 `json:"embed1"`
		}
		S7 struct {
			embed1 `json:"embed1"`
			embed2
		}
		S8 struct {
			embed1 `json:"embed1"`
			embed2 `json:"embed2"`
			Q      int
		}
		S9 struct {
			unexportedWithMethods `json:"embed"`
		}
	)

	tests := []struct {
		CaseName
		in  string
		ptr any
		out any
		err error
	}{{

// Heap allocation is not okay.

var y *nih
var y2 *struct{ x nih }
var y3 *[1]nih
var z []nih
var w []nih
var n int
var sink interface{}

type embed1 struct { // implicitly notinheap
	x nih
}

type embed2 [1]nih // implicitly notinheap

type embed3 struct { // implicitly notinheap
	x [1]nih
}

// Type aliases inherit the go:notinheap-ness of the type they alias.
type nihAlias = nih

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

// Test that embedded interface types can have local methods.

package main

import "./embed0"

type T int
func (t T) m() {}

type I interface { m() }
type J interface { I }

type PI interface { p.I }
type PJ interface { p.J }

func main() {
	var i I
	var j J
	var t T
	i = t

	have := make(map[string]bool)
	var list []string
	for _, e := range *v.Embed {
		for _, pattern := range e.Patterns {
			files, ok := base.Flag.Cfg.Embed.Patterns[pattern]
			if !ok {
				base.ErrorfAt(e.Pos, 0, "invalid go:embed: build system did not map pattern: %s", pattern)
			}
			for _, file := range files {
				if base.Flag.Cfg.Embed.Files[file] == "" {

// Copyright 2019 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 main

import "./embed0"

type X1 struct{}

func (X1) Foo() {}

type X2 struct{}

func (X2) foo() {}

type X3 struct{}

func (X3) foo(int) {}

type X4 struct{ p.M1 }

type X5 struct{ p.M1 }

func (X5) foo(int) {}

// Copyright 2020 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.

// This file is used with build tag timetzdata to embed tzdata into
// the binary.

//go:build timetzdata

package time

cmp vendor/example.com/a/subdir/embed.txt a/subdir/embed.txt
cmp vendor/example.com/a/subdir/test/embed.txt a/subdir/test/embed.txt
cmp vendor/example.com/a/subdir/test/xtest/embed.txt a/subdir/test/xtest/embed.txt

cd broken_no_matching_files
! go mod vendor
stderr '^go: resolving embeds in example.com/brokendep: pattern foo.txt: no matching files found$'
go mod vendor -e