import "golang.org/x/mod/modfile"
Package modfile implements a parser and formatter for go.mod files.
The go.mod syntax is described in https://golang.org/cmd/go/#hdr-The_go_mod_file.
The Parse and ParseLax functions both parse a go.mod file and return an abstract syntax tree. ParseLax ignores unknown statements and may be used to parse go.mod files that may have been developed with newer versions of Go.
The File struct returned by Parse and ParseLax represent an abstract go.mod file. File has several methods like AddNewRequire and DropReplace that can be used to programmatically edit a file.
The Format function formats a File back to a byte slice which can be written to a file.
var GoVersionRE = lazyregexp.New(`^([1-9][0-9]*)\.(0|[1-9][0-9]*)$`)
AutoQuote returns s or, if quoting is required for s to appear in a go.mod, the quotation of s.
func Format(f *FileSyntax) []byte
Format returns a go.mod file as a byte slice, formatted in standard style.
IsDirectoryPath reports whether the given path should be interpreted as a directory path. Just like on the go command line, relative paths and rooted paths are directory paths; the rest are module paths.
ModulePath returns the module path from the gomod file text. If it cannot find a module path, it returns an empty string. It is tolerant of unrelated problems in the go.mod file.
MustQuote reports whether s must be quoted in order to appear as a single token in a go.mod line.
type Comment struct {
Start Position
Token string // without trailing newline
Suffix bool // an end of line (not whole line) comment
}A Comment represents a single // comment.
A CommentBlock represents a top-level block of comments separate from any rule.
func (x *CommentBlock) Span() (start, end Position)
type Comments struct {
Before []Comment // whole-line comments before this expression
Suffix []Comment // end-of-line comments after this expression
// For top-level expressions only, After lists whole-line
// comments following the expression.
After []Comment
}Comments collects the comments associated with an expression.
Comment returns the receiver. This isn't useful by itself, but a Comments struct is embedded into all the expression implementation types, and this gives each of those a Comment method to satisfy the Expr interface.
An Exclude is a single exclude statement.
type Expr interface {
// Span returns the start and end position of the expression,
// excluding leading or trailing comments.
Span() (start, end Position)
// Comment returns the comments attached to the expression.
// This method would normally be named 'Comments' but that
// would interfere with embedding a type of the same name.
Comment() *Comments
}An Expr represents an input element.
type File struct {
Module *Module
Go *Go
Require []*Require
Exclude []*Exclude
Replace []*Replace
Retract []*Retract
Syntax *FileSyntax
}A File is the parsed, interpreted form of a go.mod file.
Parse parses the data, reported in errors as being from file, into a File struct. It applies fix, if non-nil, to canonicalize all module versions found.
ParseLax is like Parse but ignores unknown statements. It is used when parsing go.mod files other than the main module, under the theory that most statement types we add in the future will only apply in the main module, like exclude and replace, and so we get better gradual deployments if old go commands simply ignore those statements when found in go.mod files in dependencies.
AddExclude adds a exclude statement to the mod file. Errors if the provided version is not a canonical version string
func (f *File) AddRetract(vi VersionInterval, rationale string) error
AddRetract adds a retract statement to the mod file. Errors if the provided version interval does not consist of canonical version strings
Cleanup cleans up the file f after any edit operations. To avoid quadratic behavior, modifications like DropRequire clear the entry but do not remove it from the slice. Cleanup cleans out all the cleared entries.
func (f *File) DropRetract(vi VersionInterval) error
A FileSyntax represents an entire go.mod file.
func (x *FileSyntax) Cleanup()
Cleanup cleans up the file syntax x after any edit operations. To avoid quadratic behavior, removeLine marks the line as dead by setting line.Token = nil but does not remove it from the slice in which it appears. After edits have all been indicated, calling Cleanup cleans out the dead lines.
func (x *FileSyntax) Span() (start, end Position)
A Go is the go statement.
An LParen represents the beginning of a parenthesized line block. It is a place to store suffix comments.
A Line is a single line of tokens.
type LineBlock struct {
Comments
Start Position
LParen LParen
Token []string
Line []*Line
RParen RParen
}A LineBlock is a factored block of lines, like
require ( "x" "y" )
A Module is the module statement.
type Position struct {
Line int // line in input (starting at 1)
LineRune int // rune in line (starting at 1)
Byte int // byte in input (starting at 0)
}A Position describes an arbitrary source position in a file, including the file, line, column, and byte offset.
An RParen represents the end of a parenthesized line block. It is a place to store whole-line (before) comments.
A Replace is a single replace statement.
A Require is a single require statement.
type Retract struct {
VersionInterval
Rationale string
Syntax *Line
}A Retract is a single retract statement.
A VersionInterval represents a range of versions with upper and lower bounds. Intervals are closed: both bounds are included. When Low is equal to High, the interval may refer to a single version ('v1.2.3') or an interval ('[v1.2.3, v1.2.3]'); both have the same representation.
Package modfile imports 13 packages (graph) and is imported by 92 packages. Updated 2021-01-14. Refresh now. Tools for package owners.