package godoc

Import Path
	golang.org/x/pkgsite/internal/godoc (on go.dev)

Dependency Relation
	imports 20 packages, and imported by 3 packages

Involved Source Files

	      encode.go
	      encode_ast.gen.go
	   d➜ godoc.go
		Package godoc is for rendering Go documentation.

	      render.go
	      test_helper.go
Package-Level Type Names (total 4, in which 3 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type File (struct)
		A File contains everything needed about a source file to render documentation.

		Fields (total 2, both are exported)
			AST *ast.File
			Name string
				// full file pathname relative to zip content directory

		As Inputs Of (at least 4, none are exported)
			/* 4+ unexporteds ... *//* 4+ unexporteds: */
			func decode_File(d *codec.Decoder, p **File)
			func decode_slice_File(d *codec.Decoder, p *[]*File)
			func encode_File(e *codec.Encoder, x *File)
			func encode_slice_File(e *codec.Encoder, s []*File)

	 type ModuleInfo = dochtml.ModuleInfo (struct)
	 type Package (struct)
		A Package contains package-level information needed to render Go documentation.

		Fields (total 5, in which 3 are exported)
			encPackage.Files []*File
			encPackage.ModulePackagePaths map[string]bool
			Fset *token.FileSet
			/* 2 unexporteds ... *//* 2 unexporteds: */
			encPackage encPackage
			renderCalled bool
		Methods (total 7, in which 4 are exported)
			(*T) AddFile(f *ast.File, removeNodes bool)
				AddFile adds a file to the Package. After it returns, the contents of the ast.File
				are unsuitable for anything other than the methods of this package.

			(*T) DocInfo(ctx context.Context, innerPath string, sourceInfo *source.Info, modInfo *ModuleInfo) (synopsis string, imports []string, api []*internal.Symbol, err error)
				DocInfo returns information extracted from the package's documentation.
				This destroys p's AST; do not call any methods of p after it returns.

			(*T) Encode(ctx context.Context) (_ []byte, err error)
				Encode encodes a Package into a byte slice.
				During its operation, Encode modifies the AST,
				but it restores it to a state suitable for
				rendering before it returns.

			(*T) Render(ctx context.Context, innerPath string, sourceInfo *source.Info, modInfo *ModuleInfo, nameToVersion map[string]string) (_ *dochtml.Parts, err error)
				Render renders the documentation for the package.
				Rendering destroys p's AST; do not call any methods of p after it returns.

			/* 3 unexporteds ... *//* 3 unexporteds: */
			(*T) docPackage(innerPath string, modInfo *ModuleInfo) (_ *doc.Package, err error)
				docPackage computes and returns a doc.Package.

			(*T) fastEncode() (_ []byte, err error)
			(*T) renderOptions(innerPath string, sourceInfo *source.Info, modInfo *ModuleInfo, nameToVersion map[string]string) dochtml.RenderOptions
				renderOptions returns a RenderOptions for p.

		As Outputs Of (at least 3, in which 2 are exported)
			func DecodePackage(data []byte) (_ *Package, err error)
			func NewPackage(fset *token.FileSet, modPaths map[string]bool) *Package
			/* at least one unexported ... *//* at least one unexported: */
			func fastDecodePackage(data []byte) (_ *Package, err error)
		As Inputs Of (at least 3, none are exported)
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			func golang.org/x/pkgsite/internal/frontend.getHTML(ctx context.Context, u *internal.Unit, docPkg *Package, nameToVersion map[string]string) (_ *dochtml.Parts, err error)
			func golang.org/x/pkgsite/internal/frontend.renderDocParts(ctx context.Context, u *internal.Unit, docPkg *Package, nameToVersion map[string]string) (_ *dochtml.Parts, err error)
			func golang.org/x/pkgsite/internal/frontend.sourceFiles(u *internal.Unit, docPkg *Package) []*frontend.File

	/* one unexported ... *//* one unexported: */
	 type encPackage (struct)
		encPackage holds the fields of Package that can be directly encoded.

		If you add any fields, run go generate on this package.

		If you remove a field, you will have to hand-edit encode_ast.go
		just to make this package compile before running go generate.
		Do not remove the field name from the "Fields of" comment, however,
		or existing encoded data will decode incorrectly.

		If you rename a field, the field's values in existing encoded
		data will be lost. Renaming a field is like deleting the old field
		and adding a new one.

		Fields (total 2, both are exported)
			Files []*File
			ModulePackagePaths map[string]bool
		As Inputs Of (at least 2, neither is exported)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func decode_encPackage(d *codec.Decoder, p **encPackage)
			func encode_encPackage(e *codec.Encoder, x *encPackage)


Package-Level Functions (total 218, in which 3 are exported)

	 func DecodePackage(data []byte) (_ *Package, err error)
		DecodPackage decodes a byte slice encoded with Package.Encode into a Package.

	 func NewPackage(fset *token.FileSet, modPaths map[string]bool) *Package
		NewPackage returns a new Package with the given fset and set of module package paths.

	 func RenderFromUnit(ctx context.Context, u *internal.Unit) (_ *dochtml.Parts, err error)
		RenderFromUnit is a convenience function that first decodes the source
		in the unit, which must exist, and then calls Render.

	/* 215 unexporteds ... *//* 215 unexporteds: */
	 func decode_ast_ArrayType(d *codec.Decoder, p **ast.ArrayType)
	 func decode_ast_AssignStmt(d *codec.Decoder, p **ast.AssignStmt)
	 func decode_ast_BadDecl(d *codec.Decoder, p **ast.BadDecl)
	 func decode_ast_BadExpr(d *codec.Decoder, p **ast.BadExpr)
	 func decode_ast_BadStmt(d *codec.Decoder, p **ast.BadStmt)
	 func decode_ast_BasicLit(d *codec.Decoder, p **ast.BasicLit)
	 func decode_ast_BinaryExpr(d *codec.Decoder, p **ast.BinaryExpr)
	 func decode_ast_BlockStmt(d *codec.Decoder, p **ast.BlockStmt)
	 func decode_ast_BranchStmt(d *codec.Decoder, p **ast.BranchStmt)
	 func decode_ast_CallExpr(d *codec.Decoder, p **ast.CallExpr)
	 func decode_ast_CaseClause(d *codec.Decoder, p **ast.CaseClause)
	 func decode_ast_ChanType(d *codec.Decoder, p **ast.ChanType)
	 func decode_ast_CommClause(d *codec.Decoder, p **ast.CommClause)
	 func decode_ast_Comment(d *codec.Decoder, p **ast.Comment)
	 func decode_ast_CommentGroup(d *codec.Decoder, p **ast.CommentGroup)
	 func decode_ast_CompositeLit(d *codec.Decoder, p **ast.CompositeLit)
	 func decode_ast_DeclStmt(d *codec.Decoder, p **ast.DeclStmt)
	 func decode_ast_DeferStmt(d *codec.Decoder, p **ast.DeferStmt)
	 func decode_ast_Ellipsis(d *codec.Decoder, p **ast.Ellipsis)
	 func decode_ast_EmptyStmt(d *codec.Decoder, p **ast.EmptyStmt)
	 func decode_ast_ExprStmt(d *codec.Decoder, p **ast.ExprStmt)
	 func decode_ast_Field(d *codec.Decoder, p **ast.Field)
	 func decode_ast_FieldList(d *codec.Decoder, p **ast.FieldList)
	 func decode_ast_File(d *codec.Decoder, p **ast.File)
	 func decode_ast_ForStmt(d *codec.Decoder, p **ast.ForStmt)
	 func decode_ast_FuncDecl(d *codec.Decoder, p **ast.FuncDecl)
	 func decode_ast_FuncLit(d *codec.Decoder, p **ast.FuncLit)
	 func decode_ast_FuncType(d *codec.Decoder, p **ast.FuncType)
	 func decode_ast_GenDecl(d *codec.Decoder, p **ast.GenDecl)
	 func decode_ast_GoStmt(d *codec.Decoder, p **ast.GoStmt)
	 func decode_ast_Ident(d *codec.Decoder, p **ast.Ident)
	 func decode_ast_IfStmt(d *codec.Decoder, p **ast.IfStmt)
	 func decode_ast_ImportSpec(d *codec.Decoder, p **ast.ImportSpec)
	 func decode_ast_IncDecStmt(d *codec.Decoder, p **ast.IncDecStmt)
	 func decode_ast_IndexExpr(d *codec.Decoder, p **ast.IndexExpr)
	 func decode_ast_InterfaceType(d *codec.Decoder, p **ast.InterfaceType)
	 func decode_ast_KeyValueExpr(d *codec.Decoder, p **ast.KeyValueExpr)
	 func decode_ast_LabeledStmt(d *codec.Decoder, p **ast.LabeledStmt)
	 func decode_ast_MapType(d *codec.Decoder, p **ast.MapType)
	 func decode_ast_Object(d *codec.Decoder, p **ast.Object)
	 func decode_ast_ParenExpr(d *codec.Decoder, p **ast.ParenExpr)
	 func decode_ast_RangeStmt(d *codec.Decoder, p **ast.RangeStmt)
	 func decode_ast_ReturnStmt(d *codec.Decoder, p **ast.ReturnStmt)
	 func decode_ast_Scope(d *codec.Decoder, p **ast.Scope)
	 func decode_ast_SelectorExpr(d *codec.Decoder, p **ast.SelectorExpr)
	 func decode_ast_SelectStmt(d *codec.Decoder, p **ast.SelectStmt)
	 func decode_ast_SendStmt(d *codec.Decoder, p **ast.SendStmt)
	 func decode_ast_SliceExpr(d *codec.Decoder, p **ast.SliceExpr)
	 func decode_ast_StarExpr(d *codec.Decoder, p **ast.StarExpr)
	 func decode_ast_StructType(d *codec.Decoder, p **ast.StructType)
	 func decode_ast_SwitchStmt(d *codec.Decoder, p **ast.SwitchStmt)
	 func decode_ast_TypeAssertExpr(d *codec.Decoder, p **ast.TypeAssertExpr)
	 func decode_ast_TypeSpec(d *codec.Decoder, p **ast.TypeSpec)
	 func decode_ast_TypeSwitchStmt(d *codec.Decoder, p **ast.TypeSwitchStmt)
	 func decode_ast_UnaryExpr(d *codec.Decoder, p **ast.UnaryExpr)
	 func decode_ast_ValueSpec(d *codec.Decoder, p **ast.ValueSpec)
	 func decode_encPackage(d *codec.Decoder, p **encPackage)
	 func decode_File(d *codec.Decoder, p **File)
	 func decode_map_string_ast_Object(d *codec.Decoder, p *map[string]*ast.Object)
	 func decode_map_string_bool(d *codec.Decoder, p *map[string]bool)
	 func decode_slice_ast_Comment(d *codec.Decoder, p *[]*ast.Comment)
	 func decode_slice_ast_CommentGroup(d *codec.Decoder, p *[]*ast.CommentGroup)
	 func decode_slice_ast_Decl(d *codec.Decoder, p *[]ast.Decl)
	 func decode_slice_ast_Expr(d *codec.Decoder, p *[]ast.Expr)
	 func decode_slice_ast_Field(d *codec.Decoder, p *[]*ast.Field)
	 func decode_slice_ast_Ident(d *codec.Decoder, p *[]*ast.Ident)
	 func decode_slice_ast_ImportSpec(d *codec.Decoder, p *[]*ast.ImportSpec)
	 func decode_slice_ast_Spec(d *codec.Decoder, p *[]ast.Spec)
	 func decode_slice_ast_Stmt(d *codec.Decoder, p *[]ast.Stmt)
	 func decode_slice_File(d *codec.Decoder, p *[]*File)
	 func encode_ast_ArrayType(e *codec.Encoder, x *ast.ArrayType)
	 func encode_ast_AssignStmt(e *codec.Encoder, x *ast.AssignStmt)
	 func encode_ast_BadDecl(e *codec.Encoder, x *ast.BadDecl)
	 func encode_ast_BadExpr(e *codec.Encoder, x *ast.BadExpr)
	 func encode_ast_BadStmt(e *codec.Encoder, x *ast.BadStmt)
	 func encode_ast_BasicLit(e *codec.Encoder, x *ast.BasicLit)
	 func encode_ast_BinaryExpr(e *codec.Encoder, x *ast.BinaryExpr)
	 func encode_ast_BlockStmt(e *codec.Encoder, x *ast.BlockStmt)
	 func encode_ast_BranchStmt(e *codec.Encoder, x *ast.BranchStmt)
	 func encode_ast_CallExpr(e *codec.Encoder, x *ast.CallExpr)
	 func encode_ast_CaseClause(e *codec.Encoder, x *ast.CaseClause)
	 func encode_ast_ChanType(e *codec.Encoder, x *ast.ChanType)
	 func encode_ast_CommClause(e *codec.Encoder, x *ast.CommClause)
	 func encode_ast_Comment(e *codec.Encoder, x *ast.Comment)
	 func encode_ast_CommentGroup(e *codec.Encoder, x *ast.CommentGroup)
	 func encode_ast_CompositeLit(e *codec.Encoder, x *ast.CompositeLit)
	 func encode_ast_DeclStmt(e *codec.Encoder, x *ast.DeclStmt)
	 func encode_ast_DeferStmt(e *codec.Encoder, x *ast.DeferStmt)
	 func encode_ast_Ellipsis(e *codec.Encoder, x *ast.Ellipsis)
	 func encode_ast_EmptyStmt(e *codec.Encoder, x *ast.EmptyStmt)
	 func encode_ast_ExprStmt(e *codec.Encoder, x *ast.ExprStmt)
	 func encode_ast_Field(e *codec.Encoder, x *ast.Field)
	 func encode_ast_FieldList(e *codec.Encoder, x *ast.FieldList)
	 func encode_ast_File(e *codec.Encoder, x *ast.File)
	 func encode_ast_ForStmt(e *codec.Encoder, x *ast.ForStmt)
	 func encode_ast_FuncDecl(e *codec.Encoder, x *ast.FuncDecl)
	 func encode_ast_FuncLit(e *codec.Encoder, x *ast.FuncLit)
	 func encode_ast_FuncType(e *codec.Encoder, x *ast.FuncType)
	 func encode_ast_GenDecl(e *codec.Encoder, x *ast.GenDecl)
	 func encode_ast_GoStmt(e *codec.Encoder, x *ast.GoStmt)
	 func encode_ast_Ident(e *codec.Encoder, x *ast.Ident)
	 func encode_ast_IfStmt(e *codec.Encoder, x *ast.IfStmt)
	 func encode_ast_ImportSpec(e *codec.Encoder, x *ast.ImportSpec)
	 func encode_ast_IncDecStmt(e *codec.Encoder, x *ast.IncDecStmt)
	 func encode_ast_IndexExpr(e *codec.Encoder, x *ast.IndexExpr)
	 func encode_ast_InterfaceType(e *codec.Encoder, x *ast.InterfaceType)
	 func encode_ast_KeyValueExpr(e *codec.Encoder, x *ast.KeyValueExpr)
	 func encode_ast_LabeledStmt(e *codec.Encoder, x *ast.LabeledStmt)
	 func encode_ast_MapType(e *codec.Encoder, x *ast.MapType)
	 func encode_ast_Object(e *codec.Encoder, x *ast.Object)
	 func encode_ast_ParenExpr(e *codec.Encoder, x *ast.ParenExpr)
	 func encode_ast_RangeStmt(e *codec.Encoder, x *ast.RangeStmt)
	 func encode_ast_ReturnStmt(e *codec.Encoder, x *ast.ReturnStmt)
	 func encode_ast_Scope(e *codec.Encoder, x *ast.Scope)
	 func encode_ast_SelectorExpr(e *codec.Encoder, x *ast.SelectorExpr)
	 func encode_ast_SelectStmt(e *codec.Encoder, x *ast.SelectStmt)
	 func encode_ast_SendStmt(e *codec.Encoder, x *ast.SendStmt)
	 func encode_ast_SliceExpr(e *codec.Encoder, x *ast.SliceExpr)
	 func encode_ast_StarExpr(e *codec.Encoder, x *ast.StarExpr)
	 func encode_ast_StructType(e *codec.Encoder, x *ast.StructType)
	 func encode_ast_SwitchStmt(e *codec.Encoder, x *ast.SwitchStmt)
	 func encode_ast_TypeAssertExpr(e *codec.Encoder, x *ast.TypeAssertExpr)
	 func encode_ast_TypeSpec(e *codec.Encoder, x *ast.TypeSpec)
	 func encode_ast_TypeSwitchStmt(e *codec.Encoder, x *ast.TypeSwitchStmt)
	 func encode_ast_UnaryExpr(e *codec.Encoder, x *ast.UnaryExpr)
	 func encode_ast_ValueSpec(e *codec.Encoder, x *ast.ValueSpec)
	 func encode_encPackage(e *codec.Encoder, x *encPackage)
	 func encode_File(e *codec.Encoder, x *File)
	 func encode_map_string_ast_Object(e *codec.Encoder, m map[string]*ast.Object)
	 func encode_map_string_bool(e *codec.Encoder, m map[string]bool)
	 func encode_slice_ast_Comment(e *codec.Encoder, s []*ast.Comment)
	 func encode_slice_ast_CommentGroup(e *codec.Encoder, s []*ast.CommentGroup)
	 func encode_slice_ast_Decl(e *codec.Encoder, s []ast.Decl)
	 func encode_slice_ast_Expr(e *codec.Encoder, s []ast.Expr)
	 func encode_slice_ast_Field(e *codec.Encoder, s []*ast.Field)
	 func encode_slice_ast_Ident(e *codec.Encoder, s []*ast.Ident)
	 func encode_slice_ast_ImportSpec(e *codec.Encoder, s []*ast.ImportSpec)
	 func encode_slice_ast_Spec(e *codec.Encoder, s []ast.Spec)
	 func encode_slice_ast_Stmt(e *codec.Encoder, s []ast.Stmt)
	 func encode_slice_File(e *codec.Encoder, s []*File)
	 func fastDecodePackage(data []byte) (_ *Package, err error)
	 func fsetFromBytes(data []byte) (*token.FileSet, error)
	 func fsetToBytes(fset *token.FileSet) ([]byte, error)
		token.FileSet uses some unexported types in its encoding, so we can't use our
		own codec from it. Instead we use gob and encode the resulting bytes.

	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func init()
	 func removeUnusedASTNodes(pf *ast.File)
		removeUnusedASTNodes removes parts of the AST not needed for documentation.
		It doesn't remove unexported consts, vars or types, although it probably could.

	 func sinceVersionFunc(modulePath string, nameToVersion map[string]string) func(name string) string
		sinceVersionFunc returns a func that reports the version when the symbol
		with name was first introduced.  nameToVersion is a map of symbol name to
		the first version that symbol name was seen in the package.

		If the version when the symbol name was first introduced is the earliest
		version in nameToVersion, an empty string is returned. This is because we
		don't want to display that information on the main page to reduce clutter.


Package-Level Variables (total 4, all are exported)

	  var ErrInvalidEncodingType error
		ErrInvalidEncodingType is returned when the data to DecodePackage has an
		invalid encoding type.

	  var ErrTooLarge error
	  var MaxDocumentationHTML int
		MaxDocumentationHTML is a limit on the rendered documentation HTML size.

		The current limit of is based on the largest packages that
		pkg.go.dev has encountered. See https://golang.org/issue/40576.

		It is a variable for testing.

	  var TypesToGenerate []interface{}
		Used by the gen program to generate encodings for unexported types.


Package-Level Constants (total 5, in which 1 are exported)

	const DocTooLargeReplacement = "
Documentation is too large to display.
"
		Exported for tests.

	/* 4 unexporteds ... *//* 4 unexporteds: */
	const encodingTypeLen = 4 // all encoding types must be this many bytes
		The encoding type identifies the encoding being used, to distinguish them
		when reading from the DB.

	const fastEncodingType = "AST2"
		The encoding type identifies the encoding being used, to distinguish them
		when reading from the DB.

	const maxImportsPerPackage = 2000
	const megabyte = 1000000

The pages are generated with Golds v0.3.2-preview. (GOOS=darwin GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.