pkg go/types, type Info struct
pkg go/types, type Info struct, Defs map[*ast.Ident]Object
pkg go/types, type Info struct, Implicits map[ast.Node]Object
pkg go/types, type Info struct, InitOrder []*Initializer
pkg go/types, type Info struct, Scopes map[ast.Node]*Scope
pkg go/types, type Info struct, Selections map[*ast.SelectorExpr]*Selection
pkg go/types, type Info struct, Types map[ast.Expr]TypeAndValue

	zip64ExtraID       = 0x0001 // Zip64 extended information
	ntfsExtraID        = 0x000a // NTFS
	unixExtraID        = 0x000d // UNIX
	extTimeExtraID     = 0x5455 // Extended timestamp
	infoZipUnixExtraID = 0x5855 // Info-ZIP Unix extension
)

// FileHeader describes a file within a ZIP file.
// See the [ZIP specification] for details.
//
// [ZIP specification]: https://support.pkware.com/pkzip/appnote
type FileHeader struct {

		if err != nil {
			return err
		}
		if d.IsDir() {
			return nil
		}
		info, err := d.Info()
		if err != nil {
			return err
		}
		// TODO(#49580): Handle symlinks when fs.ReadLinkFS is available.
		if !info.Mode().IsRegular() {
			return errors.New("tar: cannot add non-regular file")
		}
		h, err := FileInfoHeader(info, "")
		if err != nil {
			return err
		}
		h.Name = name

pkg go/types, type ArgumentError struct, Index int
pkg go/types, type Config struct, Context *Context
pkg go/types, type Config struct, GoVersion string
pkg go/types, type Context struct
pkg go/types, type Info struct, Instances map[*ast.Ident]Instance
pkg go/types, type Instance struct
pkg go/types, type Instance struct, Type Type
pkg go/types, type Instance struct, TypeArgs *TypeList
pkg go/types, type Term struct

func (f *fileListEntry) ModTime() time.Time {
	if f.file == nil {
		return time.Time{}
	}
	return f.file.FileHeader.Modified.UTC()
}

func (f *fileListEntry) Info() (fs.FileInfo, error) { return f, nil }

func (f *fileListEntry) String() string {
	return fs.FormatDirEntry(f)
}

// toValidName coerces name to be a valid name for fs.FS.Open.

		if err != nil {
			return err
		}
		if d.IsDir() {
			return nil
		}
		info, err := d.Info()
		if err != nil {
			return err
		}
		if !info.Mode().IsRegular() {
			return errors.New("zip: cannot add non-regular file")
		}
		h, err := FileInfoHeader(info)
		if err != nil {
			return err
		}
		h.Name = name
		h.Method = Deflate
		fw, err := w.CreateHeader(h)

		os.Stderr.Write(out)
		return fmt.Errorf("ideviceimagemounter: %v", err)
	}
	var info struct {
		Dict struct {
			Data []byte `xml:",innerxml"`
		} `xml:"dict"`
	}
	if err := xml.Unmarshal(out, &info); err != nil {
		return fmt.Errorf("mountDevImage: failed to decode mount information: %v", err)
	}
	dict, err := parsePlistDict(info.Dict.Data)
	if err != nil {

				return pkg, nil
			}
		}
	}

	info, err := context.ImportDir(dir, 0)
	if err != nil {
		if _, nogo := err.(*build.NoGoError); nogo {
			return nil, err
		}
		log.Fatalf("pkg %q, dir %q: ScanDir: %v", name, dir, err)
	}

	// Save tags list first time we see a directory.
	if usePkgCache {
		if _, ok := pkgTags[dir]; !ok {
			pkgTags[dir] = info.AllTags
			key = tagKey(dir, context, info.AllTags)

	return "Uname", nil
}

func (f *fileInfoNames) Gname() (string, error) {
	return "Gname", nil
}

func TestFileInfoHeaderUseFileInfoNames(t *testing.T) {
	info := &fileInfoNames{}
	header, err := FileInfoHeader(info, "")
	if err != nil {
		t.Fatal(err)
	}
	if header.Uname != "Uname" {
		t.Fatalf("header.Uname: got %s, want %s", header.Uname, "Uname")
	}
	if header.Gname != "Gname" {

pkg syscall (linux-arm-cgo), type SysProcIDMap struct, Size int

# CL 122200043 net: fix CNAME resolving on Windows, Egon Elbre <******@****.***>
pkg syscall (windows-386), const DNS_INFO_NO_RECORDS = 9501
pkg syscall (windows-386), const DNS_INFO_NO_RECORDS ideal-int
pkg syscall (windows-386), const DnsSectionAdditional = 3
pkg syscall (windows-386), const DnsSectionAdditional ideal-int
pkg syscall (windows-386), const DnsSectionAnswer = 1