go/src/cmd/compile/internal/importer/iimport.go

type intReader

func (r *intReader) int64() int64 {}

func (r *intReader) uint64() uint64 {}

const iexportVersionGo1_11

const iexportVersionPosCol

const iexportVersionGenerics

const iexportVersionGo1_18

const iexportVersionCurrent

type ident

const predeclReserved

type itag

const definedType

const pointerType

const sliceType

const arrayType

const chanType

const mapType

const signatureType

const structType

const interfaceType

const typeParamType

const instanceType

const unionType

// ImportData 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 ImportData(imports map[string]*types2.Package, data, path string) (pkg *types2.Package, err error) {}

type setConstraintArgs

type iimporter

func (p *iimporter) doDecl(pkg *types2.Package, name string) {}

func (p *iimporter) stringAt(off uint64) string {}

func (p *iimporter) pkgAt(off uint64) *types2.Package {}

func (p *iimporter) posBaseAt(off uint64) *syntax.PosBase {}

func (p *iimporter) typAt(off uint64, base *types2.Named) types2.Type {}

// canReuse reports whether the type rhs on the RHS of the declaration for def
// may be re-used.
//
// Specifically, if def is non-nil and rhs is an interface type with methods, it
// may not be re-used because we have a convention of setting the receiver type
// for interface methods to def.
func canReuse(def *types2.Named, rhs types2.Type) bool {}

type importReader

func (r *importReader) obj(name string) {}

func (r *importReader) declare(obj types2.Object) {}

func (r *importReader) value() (typ types2.Type, val constant.Value) {}

func intSize(b *types2.Basic) (signed bool, maxBytes uint) {}

func (r *importReader) mpint(x *big.Int, typ *types2.Basic) {}

func (r *importReader) mpfloat(typ *types2.Basic) constant.Value {}

func (r *importReader) ident() string {}

func (r *importReader) qualifiedIdent() (*types2.Package, string) {}

func (r *importReader) pos() syntax.Pos {}

func (r *importReader) posv0() {}

func (r *importReader) posv1() {}

func (r *importReader) typ() types2.Type {}

func isInterface(t types2.Type) bool {}

func (r *importReader) pkg() *types2.Package     {}

func (r *importReader) string() string           {}

func (r *importReader) posBase() *syntax.PosBase {}

func (r *importReader) doType(base *types2.Named) types2.Type {}

func (r *importReader) kind() itag {}

func (r *importReader) signature(recv *types2.Var, rparams, tparams []*types2.TypeParam) *types2.Signature {}

func (r *importReader) tparamList() []*types2.TypeParam {}

func (r *importReader) paramList() *types2.Tuple {}

func (r *importReader) param() *types2.Var {}

func (r *importReader) bool() bool {}

func (r *importReader) int64() int64 {}

func (r *importReader) uint64() uint64 {}

func (r *importReader) byte() byte {}

func baseType(typ types2.Type) *types2.Named {}