type Doc … type LinkDef … type Block … type Heading … func (*Heading) block() { … } type List … func (*List) block() { … } // BlankBefore reports whether a reformatting of the comment // should include a blank line before the list. // The default rule is the same as for [BlankBetween]: // if the list item content contains any blank lines // (meaning at least one item has multiple paragraphs) // then the list itself must be preceded by a blank line. // A preceding blank line can be forced by setting [List].ForceBlankBefore. func (l *List) BlankBefore() bool { … } // BlankBetween reports whether a reformatting of the comment // should include a blank line between each pair of list items. // The default rule is that if the list item content contains any blank lines // (meaning at least one item has multiple paragraphs) // then list items must themselves be separated by blank lines. // Blank line separators can be forced by setting [List].ForceBlankBetween. func (l *List) BlankBetween() bool { … } type ListItem … type Paragraph … func (*Paragraph) block() { … } type Code … func (*Code) block() { … } type Text … type Plain … func (Plain) text() { … } type Italic … func (Italic) text() { … } type Link … func (*Link) text() { … } type DocLink … func (*DocLink) text() { … } type Parser … type parseDoc … // lookupPkg is called to look up the pkg in [pkg], [pkg.Name], and [pkg.Name.Recv]. // If pkg has a slash, it is assumed to be the full import path and is returned with ok = true. // // Otherwise, pkg is probably a simple package name like "rand" (not "crypto/rand" or "math/rand"). // d.LookupPackage provides a way for the caller to allow resolving such names with reference // to the imports in the surrounding package. // // There is one collision between these two cases: single-element standard library names // like "math" are full import paths but don't contain slashes. We let d.LookupPackage have // the first chance to resolve it, in case there's a different package imported as math, // and otherwise we refer to a built-in list of single-element standard library package names. func (d *parseDoc) lookupPkg(pkg string) (importPath string, ok bool) { … } func isStdPkg(path string) bool { … } // DefaultLookupPackage is the default package lookup // function, used when [Parser.LookupPackage] is nil. // It recognizes names of the packages from the standard // library with single-element import paths, such as math, // which would otherwise be impossible to name. // // Note that the go/doc package provides a more sophisticated // lookup based on the imports used in the current package. func DefaultLookupPackage(name string) (importPath string, ok bool) { … } // Parse parses the doc comment text and returns the *[Doc] form. // Comment markers (/* // and */) in the text must have already been removed. func (p *Parser) Parse(text string) *Doc { … } type span … type spanKind … const _ … const spanCode … const spanHeading … const spanList … const spanOldHeading … const spanPara … func parseSpans(lines []string) []span { … } // indented reports whether line is indented // (starts with a leading space or tab). func indented(line string) bool { … } // unindent removes any common space/tab prefix // from each line in lines, returning a copy of lines in which // those prefixes have been trimmed from each line. // It also replaces any lines containing only spaces with blank lines (empty strings). func unindent(lines []string) []string { … } // isBlank reports whether s is a blank line. func isBlank(s string) bool { … } // commonPrefix returns the longest common prefix of a and b. func commonPrefix(a, b string) string { … } // leadingSpace returns the longest prefix of s consisting of spaces and tabs. func leadingSpace(s string) string { … } // isOldHeading reports whether line is an old-style section heading. // line is all[off]. func isOldHeading(line string, all []string, off int) bool { … } // oldHeading returns the *Heading for the given old-style section heading line. func (d *parseDoc) oldHeading(line string) Block { … } // isHeading reports whether line is a new-style section heading. func isHeading(line string) bool { … } // heading returns the *Heading for the given new-style section heading line. func (d *parseDoc) heading(line string) Block { … } // code returns a code block built from the lines. func (d *parseDoc) code(lines []string) *Code { … } // paragraph returns a paragraph block built from the lines. // If the lines are link definitions, paragraph adds them to d and returns nil. func (d *parseDoc) paragraph(lines []string) Block { … } // parseLink parses a single link definition line: // // [text]: url // // It returns the link definition and whether the line was well formed. func parseLink(line string) (*LinkDef, bool) { … } // list returns a list built from the indented lines, // using forceBlankBefore as the value of the List's ForceBlankBefore field. func (d *parseDoc) list(lines []string, forceBlankBefore bool) *List { … } // listMarker parses the line as beginning with a list marker. // If it can do that, it returns the numeric marker ("" for a bullet list), // the rest of the line, and ok == true. // Otherwise, it returns "", "", false. func listMarker(line string) (num, rest string, ok bool) { … } // isList reports whether the line is the first line of a list, // meaning starts with a list marker after any indentation. // (The caller is responsible for checking the line is indented, as appropriate.) func isList(line string) bool { … } // parseLinkedText parses text that is allowed to contain explicit links, // such as [math.Sin] or [Go home page], into a slice of Text items. // // A “pkg” is only assumed to be a full import path if it starts with // a domain name (a path element with a dot) or is one of the packages // from the standard library (“[os]”, “[encoding/json]”, and so on). // To avoid problems with maps, generics, and array types, doc links // must be both preceded and followed by punctuation, spaces, tabs, // or the start or end of a line. An example problem would be treating // map[ast.Expr]TypeAndValue as containing a link. func (d *parseDoc) parseLinkedText(text string) []Text { … } // docLink parses text, which was found inside [ ] brackets, // as a doc link if possible, returning the DocLink and ok == true // or else nil, false. // The before and after strings are the text before the [ and after the ] // on the same line. Doc links must be preceded and followed by // punctuation, spaces, tabs, or the start or end of a line. func (d *parseDoc) docLink(text, before, after string) (link *DocLink, ok bool) { … } // If text is of the form before.Name, where Name is a capitalized Go identifier, // then splitDocName returns before, name, true. // Otherwise it returns text, "", false. func splitDocName(text string) (before, name string, foundDot bool) { … } // parseText parses s as text and returns the result of appending // those parsed Text elements to out. // parseText does not handle explicit links like [math.Sin] or [Go home page]: // those are handled by parseLinkedText. // If autoLink is true, then parseText recognizes URLs and words from d.Words // and converts those to links as appropriate. func (d *parseDoc) parseText(out []Text, s string, autoLink bool) []Text { … } // autoURL checks whether s begins with a URL that should be hyperlinked. // If so, it returns the URL, which is a prefix of s, and ok == true. // Otherwise it returns "", false. // The caller should skip over the first len(url) bytes of s // before further processing. func autoURL(s string) (url string, ok bool) { … } // isScheme reports whether s is a recognized URL scheme. // Note that if strings of new length (beyond 3-7) // are added here, the fast path at the top of autoURL will need updating. func isScheme(s string) bool { … } // isHost reports whether c is a byte that can appear in a URL host, // like www.example.com or user@[::1]:8080 func isHost(c byte) bool { … } // isPunct reports whether c is a punctuation byte that can appear // inside a path but not at the end. func isPunct(c byte) bool { … } // isPath reports whether c is a (non-punctuation) path byte. func isPath(c byte) bool { … } // isName reports whether s is a capitalized Go identifier (like Name). func isName(s string) bool { … } // ident checks whether s begins with a Go identifier. // If so, it returns the identifier, which is a prefix of s, and ok == true. // Otherwise it returns "", false. // The caller should skip over the first len(id) bytes of s // before further processing. func ident(s string) (id string, ok bool) { … } // isIdentASCII reports whether c is an ASCII identifier byte. func isIdentASCII(c byte) bool { … } // validImportPath reports whether path is a valid import path. // It is a lightly edited copy of golang.org/x/mod/module.CheckImportPath. func validImportPath(path string) bool { … } func validImportPathElem(elem string) bool { … } func importPathOK(c byte) bool { … }
Codebase Browser
go