go/pkg/mod/golang.org/x/[email protected]/go/internal/gcimporter/bimport.go

type importer

// BImportData imports a package from the serialized package data
// and returns the number of bytes consumed and a reference to the package.
// If the export data version is not recognized or the format is otherwise
// compromised, an error is returned.
func BImportData(fset *token.FileSet, imports map[string]*types.Package, data []byte, path string) (_ int, pkg *types.Package, err error) {}

func errorf(format string, args ...interface{}

func (p *importer) pkg() *types.Package {}

// objTag returns the tag value for each object kind.
func objTag(obj types.Object) int {}

func sameObj(a, b types.Object) bool {}

func (p *importer) declare(obj types.Object) {}

func (p *importer) obj(tag int) {}

const deltaNewFile

func (p *importer) pos() token.Pos {}

type fakeFileSet

func (s *fakeFileSet) pos(file string, line, column int) token.Pos {}

var fakeLines

var fakeLinesOnce

func (p *importer) qualifiedName() (pkg *types.Package, name string) {}

func (p *importer) record(t types.Type) {}

type dddSlice

func (t *dddSlice) Underlying() types.Type {}

func (t *dddSlice) String() string         {}

// parent is the package which declared the type; parent == nil means
// the package currently imported. The parent package is needed for
// exported struct fields and interface methods which don't contain
// explicit package information in the export data.
//
// A non-nil tname is used as the "owner" of the result type; i.e.,
// the result type is the underlying type of tname. tname is used
// to give interface methods a named receiver type where possible.
func (p *importer) typ(parent *types.Package, tname *types.Named) types.Type {}

func chanDir(d int) types.ChanDir {}

func (p *importer) fieldList(parent *types.Package) (fields []*types.Var, tags []string) {}

func (p *importer) field(parent *types.Package) (*types.Var, string) {}

func (p *importer) methodList(parent *types.Package, baseType *types.Named) (methods []*types.Func) {}

func (p *importer) method(parent *types.Package, baseType *types.Named) *types.Func {}

func (p *importer) fieldName(parent *types.Package) (pkg *types.Package, name string, alias bool) {}

func (p *importer) paramList() (*types.Tuple, bool) {}

func (p *importer) param(named bool) (*types.Var, bool) {}

func exported(name string) bool {}

func (p *importer) value() constant.Value {}

func (p *importer) float() constant.Value {}

func (p *importer) tagOrIndex() int {}

func (p *importer) int() int {}

func (p *importer) int64() int64 {}

func (p *importer) path() string {}

func (p *importer) string() string {}

func (p *importer) marker(want byte) {}

// rawInt64 should only be used by low-level decoders.
func (p *importer) rawInt64() int64 {}

// rawStringln should only be used to read the initial version string.
func (p *importer) rawStringln(b byte) string {}

// needed for binary.ReadVarint in rawInt64
func (p *importer) ReadByte() (byte, error) {}

// byte is the bottleneck interface for reading p.data.
// It unescapes '|' 'S' to '$' and '|' '|' to '|'.
// rawByte should only be used by low-level decoders.
func (p *importer) rawByte() byte {}

const packageTag

const constTag

const typeTag

const varTag

const funcTag

const endTag

const namedTag

const arrayTag

const sliceTag

const dddTag

const structTag

const pointerTag

const signatureTag

const interfaceTag

const mapTag

const chanTag

const falseTag

const trueTag

const int64Tag

const floatTag

const fractionTag

const complexTag

const stringTag

const nilTag

const unknownTag

const aliasTag

var predeclOnce

var predecl

func predeclared() []types.Type {}

type anyType

func (t anyType) Underlying() types.Type {}

func (t anyType) String() string         {}