[!git] skip

env GOPROXY=direct

# Control case: fetching a nested module at a tag that exists should
# emit Origin metadata for that tag and commit, and the origin should
# be reusable for that tag.

go list -json -m --versions -e vcs-test.golang.org/git/issue61415.git/nested@has-nested
cp stdout has-nested.json
stdout '"Origin":'
stdout '"VCS": "git"'
stdout '"URL":'  # randomly-chosen vcweb localhost URL
stdout '"Subdir": "nested"'

import "unsafe"

const _ C.int = 0xff // no error due to invalid constant type

type T struct {
	Name    string
	Ordinal int
}

func _(args []T) {
	var s string
	for i, v := range args {
		cname := C.CString(v.Name)
		args[i].Ordinal = int(C.sqlite3_bind_parameter_index(s, cname)) // no error due to i not being "used"
		C.free(unsafe.Pointer(cname))
	}
}

type CType C.Type

The methods [Alias.Origin], [Alias.SetTypeParams], [Alias.TypeParams],

		return db + "/" + b
	}

	podToString := func(p pods.Pod) string {
		rv := trim(p.MetaFile) + " [\n"
		for k, df := range p.CounterDataFiles {
			rv += trim(df)
			if p.Origins != nil {
				rv += fmt.Sprintf(" o:%d", p.Origins[k])
			}
			rv += "\n"
		}
		return rv + "]"
	}

	// Create a couple of directories.
	o1 := mkdir("o1", 0777)
	o2 := mkdir("o2", 0777)

type Context struct {
	mu        sync.Mutex
	typeMap   map[string][]ctxtEntry // type hash -> instances entries
	nextID    int                    // next unique ID
	originIDs map[Type]int           // origin type -> unique ID
}

type ctxtEntry struct {
	orig     Type
	targs    []Type
	instance Type // = orig[targs]
}

// NewContext creates a new Context.
func NewContext() *Context {
	return &Context{

	// Read DL repo list and convert to "go" or "toolchain" version list.
	versions, err := r.repo.Versions(ctx, "")
	if err != nil {
		return nil, err
	}
	versions.Origin = nil
	var list []string
	have := make(map[string]bool)
	goPrefix := ""
	if r.path == "toolchain" {
		goPrefix = "go"
	}
	for _, v := range versions.List {
		v, ok := dlToGo(v)
		if !ok {
			continue

					if fnDecl, ok := decl.(*ast.FuncDecl); ok {
						if fn, ok := info.Defs[fnDecl.Name].(*types.Func); ok {
							fnDecls[fn] = fnDecl
						}
					}
				}
			}
		}
		// TODO: set f = f.Origin() here.
		return fnDecls[f]
	}
}

// isMethodNamed returns true if f is a method defined
// in package with the path pkgPath with a name in names.

	//
	// 'svn export' prints the filenames as they are written, but from reading the
	// svn source code (as of revision 1868933), those filenames are encoded using
	// the system locale rather than preserved byte-for-byte from the origin. For
	// our purposes, that won't do, but we don't want to go mucking around with
	// the user's locale settings either — that could impact error messages, and

// ExtractFiles extracts the files in ar to the state's current directory,
// expanding any environment variables within each name.
//
// The files must reside within the working directory with which the State was
// originally created.
func (s *State) ExtractFiles(ar *txtar.Archive) error {
	wd := s.workdir

	// Add trailing separator to terminate wd.
	// This prevents extracting to outside paths which prefix wd,

	if checksum != z.digest.Sum32() {
		z.err = ErrChecksum
		return n, z.err
	}
	return n, io.EOF
}

// Calling Close does not close the wrapped [io.Reader] originally passed to [NewReader].
// In order for the ZLIB checksum to be verified, the reader must be
// fully consumed until the [io.EOF].
func (z *reader) Close() error {
	if z.err != nil && z.err != io.EOF {
		return z.err