ast

package
v1.0.16 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 17, 2021 License: Apache-2.0 Imports: 11 Imported by: 9

Documentation

Overview

Package ast declares the types used to represent syntax trees for Go+ packages.

Index

Constants

View Source 
const (
	FileTypeGo  = -1 // .go (should be negative)
	FileTypeGop = 0  // .gop
	FileTypeSpx = 1  // .spx
	FileTypeGmx = 2  // .gmx
)

Variables

This section is empty.

Functions

func FileExports 

func FileExports(src *File) bool

FileExports trims the AST for a Go source file in place such that only exported nodes remain: all top-level identifiers which are not exported and their associated information (such as type, initial value, or function body) are removed. Non-exported fields and methods of exported types are stripped. The File.Comments list is not changed.

FileExports reports whether there are exported declarations.

func FilterDecl 

func FilterDecl(decl Decl, f Filter) bool

FilterDecl trims the AST for a Go declaration in place by removing all names (including struct field and interface method names, but not from parameter lists) that don't pass through the filter f.

FilterDecl reports whether there are any declared names left after filtering.

func FilterFile 

func FilterFile(src *File, f Filter) bool

FilterFile trims the AST for a Go file in place by removing all names from top-level declarations (including struct field and interface method names, but not from parameter lists) that don't pass through the filter f. If the declaration is empty afterwards, the declaration is removed from the AST. Import declarations are always removed. The File.Comments list is not changed.

FilterFile reports whether there are any top-level declarations left after filtering.

func FilterPackage 

func FilterPackage(pkg *Package, f Filter) bool

FilterPackage trims the AST for a Go package in place by removing all names from top-level declarations (including struct field and interface method names, but not from parameter lists) that don't pass through the filter f. If the declaration is empty afterwards, the declaration is removed from the AST. The pkg.Files list is not changed, so that file names and top-level package comments don't get lost.

FilterPackage reports whether there are any top-level declarations left after filtering.

func Fprint 

func Fprint(w io.Writer, fset *token.FileSet, x interface{}, f FieldFilter) error

Fprint prints the (sub-)tree starting at AST node x to w. If fset != nil, position information is interpreted relative to that file set. Otherwise positions are printed as integer values (file set specific offsets).

A non-nil FieldFilter f may be provided to control the output: struct fields for which f(fieldname, fieldvalue) is true are printed; all others are filtered from the output. Unexported struct fields are never printed.

func Inspect 

func Inspect(node Node, f func(Node) bool)

Inspect traverses an AST in depth-first order: It starts by calling f(node); node must not be nil. If f returns true, Inspect invokes f recursively for each of the non-nil children of node, followed by a call of f(nil).

func IsExported 

func IsExported(name string) bool

IsExported reports whether name starts with an upper-case letter.

func NotNilFilter 

func NotNilFilter(_ string, v reflect.Value) bool

NotNilFilter returns true for field values that are not nil; it returns false otherwise.

func PackageExports 

func PackageExports(pkg *Package) bool

PackageExports trims the AST for a Go package in place such that only exported nodes remain. The pkg.Files list is not changed, so that file names and top-level package comments don't get lost.

PackageExports reports whether there are exported declarations; it returns false otherwise.

func Print 

func Print(fset *token.FileSet, x interface{}) error

Print prints x to standard output, skipping nil fields. Print(fset, x) is the same as Fprint(os.Stdout, fset, x, NotNilFilter).

func SortImports 

func SortImports(fset *token.FileSet, f *File)

SortImports sorts runs of consecutive import lines in import blocks in f. It also removes duplicate imports when it is possible to do so without data loss.

func Walk 

func Walk(v Visitor, node Node)

Walk traverses an AST in depth-first order: It starts by calling v.Visit(node); node must not be nil. If the visitor w returned by v.Visit(node) is not nil, Walk is invoked recursively with visitor w for each of the non-nil children of node, followed by a call of w.Visit(nil).

Types

type ArrayType 

type ArrayType struct {
	Lbrack token.Pos // position of "["
	Len    Expr      // Ellipsis node for [...]T array types, nil for slice types
	Elt    Expr      // element type
}

An ArrayType node represents an array or slice type.

func (*ArrayType) End 

func (x *ArrayType) End() token.Pos

End returns position of first character immediately after the node.

func (*ArrayType) Pos 

func (x *ArrayType) Pos() token.Pos

Pos returns position of first character belonging to the node.

type AssignStmt 

type AssignStmt struct {
	Lhs    []Expr      // left hand side expressions
	TokPos token.Pos   // position of Tok
	Tok    token.Token // assignment token, DEFINE
	Rhs    []Expr      // right hand side expressions
}

An AssignStmt node represents an assignment or a short variable declaration.

func (*AssignStmt) End 

func (s *AssignStmt) End() token.Pos

End returns position of first character immediately after the node.

func (*AssignStmt) Pos 

func (s *AssignStmt) Pos() token.Pos

Pos returns position of first character belonging to the node.

type BadDecl 

type BadDecl struct {
	From, To token.Pos // position range of bad declaration
}

A BadDecl node is a placeholder for declarations containing syntax errors for which no correct declaration nodes can be created.

func (*BadDecl) End 

func (d *BadDecl) End() token.Pos

End returns position of first character immediately after the node.

func (*BadDecl) Pos 

func (d *BadDecl) Pos() token.Pos

Pos returns position of first character belonging to the node.

type BadExpr 

type BadExpr struct {
	From, To token.Pos // position range of bad expression
}

A BadExpr node is a placeholder for expressions containing syntax errors for which no correct expression nodes can be created.

func (*BadExpr) End 

func (x *BadExpr) End() token.Pos

End returns position of first character immediately after the node.

func (*BadExpr) Pos 

func (x *BadExpr) Pos() token.Pos

Pos returns position of first character belonging to the node.

type BadStmt 

type BadStmt struct {
	From, To token.Pos // position range of bad statement
}

A BadStmt node is a placeholder for statements containing syntax errors for which no correct statement nodes can be created.

func (*BadStmt) End 

func (s *BadStmt) End() token.Pos

End returns position of first character immediately after the node.

func (*BadStmt) Pos 

func (s *BadStmt) Pos() token.Pos

Pos returns position of first character belonging to the node.

type BasicLit 

type BasicLit struct {
	ValuePos token.Pos   // literal position
	Kind     token.Token // token.INT, token.FLOAT, token.IMAG, token.CHAR, or token.STRING
	Value    string      // literal string; e.g. 42, 0x7f, 3.14, 1e-9, 2.4i, 'a', '\x7f', "foo" or `\m\n\o`
}

A BasicLit node represents a literal of basic type.

func (*BasicLit) End 

func (x *BasicLit) End() token.Pos

End returns position of first character immediately after the node.

func (*BasicLit) Pos 

func (x *BasicLit) Pos() token.Pos

Pos returns position of first character belonging to the node.

type BinaryExpr 

type BinaryExpr struct {
	X     Expr        // left operand
	OpPos token.Pos   // position of Op
	Op    token.Token // operator
	Y     Expr        // right operand
}

A BinaryExpr node represents a binary expression.

func (*BinaryExpr) End 

func (x *BinaryExpr) End() token.Pos

End returns position of first character immediately after the node.

func (*BinaryExpr) Pos 

func (x *BinaryExpr) Pos() token.Pos

Pos returns position of first character belonging to the node.

type BlockStmt 

type BlockStmt struct {
	Lbrace token.Pos // position of "{"
	List   []Stmt
	Rbrace token.Pos // position of "}", if any (may be absent due to syntax error)
}

A BlockStmt node represents a braced statement list.

func (*BlockStmt) End 

func (s *BlockStmt) End() token.Pos

End returns position of first character immediately after the node.

func (*BlockStmt) Pos 

func (s *BlockStmt) Pos() token.Pos

Pos returns position of first character belonging to the node.

type BranchStmt 

type BranchStmt struct {
	TokPos token.Pos   // position of Tok
	Tok    token.Token // keyword token (BREAK, CONTINUE, GOTO, FALLTHROUGH)
	Label  *Ident      // label name; or nil
}

A BranchStmt node represents a break, continue, goto, or fallthrough statement.

func (*BranchStmt) End 

func (s *BranchStmt) End() token.Pos

End returns position of first character immediately after the node.

func (*BranchStmt) Pos 

func (s *BranchStmt) Pos() token.Pos

Pos returns position of first character belonging to the node.

type CallExpr 

type CallExpr struct {
	Fun        Expr      // function expression
	Lparen     token.Pos // position of "("
	Args       []Expr    // function arguments; or nil
	Ellipsis   token.Pos // position of "..." (token.NoPos if there is no "...")
	Rparen     token.Pos // position of ")"
	NoParenEnd token.Pos
}

A CallExpr node represents an expression followed by an argument list.

func (*CallExpr) End 

func (x *CallExpr) End() token.Pos

End returns position of first character immediately after the node.

func (*CallExpr) Pos 

func (x *CallExpr) Pos() token.Pos

Pos returns position of first character belonging to the node.

type CaseClause 

type CaseClause struct {
	Case  token.Pos // position of "case" or "default" keyword
	List  []Expr    // list of expressions or types; nil means default case
	Colon token.Pos // position of ":"
	Body  []Stmt    // statement list; or nil
}

A CaseClause represents a case of an expression or type switch statement.

func (*CaseClause) End 

func (s *CaseClause) End() token.Pos

End returns position of first character immediately after the node.

func (*CaseClause) Pos 

func (s *CaseClause) Pos() token.Pos

Pos returns position of first character belonging to the node.

type ChanDir 

type ChanDir int

ChanDir is the direction of a channel type is indicated by a bit mask including one or both of the following constants. 

const (
	// SEND - ChanDir
	SEND ChanDir = 1 << iota
	// RECV - ChanDir
	RECV
)

type ChanType 

type ChanType struct {
	Begin token.Pos // position of "chan" keyword or "<-" (whichever comes first)
	Arrow token.Pos // position of "<-" (token.NoPos if there is no "<-")
	Dir   ChanDir   // channel direction
	Value Expr      // value type
}

A ChanType node represents a channel type.

func (*ChanType) End 

func (x *ChanType) End() token.Pos

End returns position of first character immediately after the node.

func (*ChanType) Pos 

func (x *ChanType) Pos() token.Pos

Pos returns position of first character belonging to the node.

type CommClause 

type CommClause struct {
	Case  token.Pos // position of "case" or "default" keyword
	Comm  Stmt      // send or receive statement; nil means default case
	Colon token.Pos // position of ":"
	Body  []Stmt    // statement list; or nil
}

A CommClause node represents a case of a select statement.

func (*CommClause) End 

func (s *CommClause) End() token.Pos

End returns position of first character immediately after the node.

func (*CommClause) Pos 

func (s *CommClause) Pos() token.Pos

Pos returns position of first character belonging to the node.

type Comment 

type Comment struct {
	Slash token.Pos // position of "/" or # starting the comment
	Text  string    // comment text (excluding '\n' for //-style comments)
}

A Comment node represents a single //-style 、#-style or /*-style comment.

func (*Comment) End 

func (c *Comment) End() token.Pos

End returns position of first character immediately after the node.

func (*Comment) Pos 

func (c *Comment) Pos() token.Pos

Pos returns position of first character belonging to the node.

type CommentGroup 

type CommentGroup struct {
	List []*Comment // len(List) > 0
}

A CommentGroup represents a sequence of comments with no other tokens and no empty lines between.

func (*CommentGroup) End 

func (g *CommentGroup) End() token.Pos

End returns position of first character immediately after the node.

func (*CommentGroup) Pos 

func (g *CommentGroup) Pos() token.Pos

Pos returns position of first character belonging to the node.

func (*CommentGroup) Text 

func (g *CommentGroup) Text() string

Text returns the text of the comment. Comment markers (//, /*, and */), the first space of a line comment, and leading and trailing empty lines are removed. Multiple empty lines are reduced to one, and trailing space on lines is trimmed. Unless the result is empty, it is newline-terminated.

type CommentMap 

type CommentMap map[Node][]*CommentGroup

A CommentMap maps an AST node to a list of comment groups associated with it. See NewCommentMap for a description of the association.

func NewCommentMap 

func NewCommentMap(fset *token.FileSet, node Node, comments []*CommentGroup) CommentMap

NewCommentMap creates a new comment map by associating comment groups of the comments list with the nodes of the AST specified by node.

A comment group g is associated with a node n if:

  • g starts on the same line as n ends
  • g starts on the line immediately following n, and there is at least one empty line after g and before the next node
  • g starts before n and is not associated to the node before n via the previous rules

NewCommentMap tries to associate a comment group to the "largest" node possible: For instance, if the comment is a line comment trailing an assignment, the comment is associated with the entire assignment rather than just the last operand in the assignment.

func (CommentMap) Comments 

func (cmap CommentMap) Comments() []*CommentGroup

Comments returns the list of comment groups in the comment map. The result is sorted in source order.

func (CommentMap) Filter 

func (cmap CommentMap) Filter(node Node) CommentMap

Filter returns a new comment map consisting of only those entries of cmap for which a corresponding node exists in the AST specified by node.

func (CommentMap) String 

func (cmap CommentMap) String() string

func (CommentMap) Update 

func (cmap CommentMap) Update(old, new Node) Node

Update replaces an old node in the comment map with the new node and returns the new node. Comments that were associated with the old node are associated with the new node.

type CompositeLit 

type CompositeLit struct {
	Type       Expr      // literal type; or nil
	Lbrace     token.Pos // position of "{"
	Elts       []Expr    // list of composite elements; or nil
	Rbrace     token.Pos // position of "}"
	Incomplete bool      // true if (source) expressions are missing in the Elts list
}

A CompositeLit node represents a composite literal.

func (*CompositeLit) End 

func (x *CompositeLit) End() token.Pos

End returns position of first character immediately after the node.

func (*CompositeLit) Pos 

func (x *CompositeLit) Pos() token.Pos

Pos returns position of first character belonging to the node.

type ComprehensionExpr added in v0.9.0 

type ComprehensionExpr struct {
	Lpos token.Pos   // position of "[" or "{"
	Tok  token.Token // token.LBRACK '[' or token.LBRACE '{'
	Elt  Expr        // *KeyValueExpr or Expr or nil
	Fors []*ForPhrase
	Rpos token.Pos // position of "]" or "}"
}

ComprehensionExpr represents 

`[vexpr for k1, v1 <- container1, cond1 ...]` or
`{vexpr for k1, v1 <- container1, cond1 ...}` or
`{kexpr: vexpr for k1, v1 <- container1, cond1 ...}` or
`{for k1, v1 <- container1, cond1 ...}` or

func (*ComprehensionExpr) End added in v0.9.0 

func (p *ComprehensionExpr) End() token.Pos

End - position of first character immediately after the node

func (*ComprehensionExpr) Pos added in v0.9.0 

func (p *ComprehensionExpr) Pos() token.Pos

Pos - position of first character belonging to the node

type Decl 

type Decl interface {
	Node
	// contains filtered or unexported methods
}

Decl interface: all declaration nodes implement the Decl interface.

type DeclStmt 

type DeclStmt struct {
	Decl Decl // *GenDecl with CONST, TYPE, or VAR token
}

A DeclStmt node represents a declaration in a statement list.

func (*DeclStmt) End 

func (s *DeclStmt) End() token.Pos

End returns position of first character immediately after the node.

func (*DeclStmt) Pos 

func (s *DeclStmt) Pos() token.Pos

Pos returns position of first character belonging to the node.

type DeferStmt 

type DeferStmt struct {
	Defer token.Pos // position of "defer" keyword
	Call  *CallExpr
}

A DeferStmt node represents a defer statement.

func (*DeferStmt) End 

func (s *DeferStmt) End() token.Pos

End returns position of first character immediately after the node.

func (*DeferStmt) Pos 

func (s *DeferStmt) Pos() token.Pos

Pos returns position of first character belonging to the node.

type Ellipsis 

type Ellipsis struct {
	Ellipsis token.Pos // position of "..."
	Elt      Expr      // ellipsis element type (parameter lists only); or nil
}

An Ellipsis node stands for the "..." type in a parameter list or the "..." length in an array type.

func (*Ellipsis) End 

func (x *Ellipsis) End() token.Pos

End returns position of first character immediately after the node.

func (*Ellipsis) Pos 

func (x *Ellipsis) Pos() token.Pos

Pos returns position of first character belonging to the node.

type EmptyStmt 

type EmptyStmt struct {
	Semicolon token.Pos // position of following ";"
	Implicit  bool      // if set, ";" was omitted in the source
}

An EmptyStmt node represents an empty statement. The "position" of the empty statement is the position of the immediately following (explicit or implicit) semicolon.

func (*EmptyStmt) End 

func (s *EmptyStmt) End() token.Pos

End returns position of first character immediately after the node.

func (*EmptyStmt) Pos 

func (s *EmptyStmt) Pos() token.Pos

Pos returns position of first character belonging to the node.

type ErrWrapExpr 

type ErrWrapExpr struct {
	X       Expr
	Tok     token.Token // ! or ?
	TokPos  token.Pos
	Default Expr // can be nil
}

ErrWrapExpr represents `expr!`, `expr?` or `expr?: defaultValue`

func (*ErrWrapExpr) End 

func (p *ErrWrapExpr) End() token.Pos

End - position of first character immediately after the node

func (*ErrWrapExpr) Pos 

func (p *ErrWrapExpr) Pos() token.Pos

Pos - position of first character belonging to the node

type Expr 

type Expr interface {
	Node
	// contains filtered or unexported methods
}

Expr interface: all expression nodes implement the Expr interface.

type ExprStmt 

type ExprStmt struct {
	X Expr // expression
}

An ExprStmt node represents a (stand-alone) expression in a statement list.

func (*ExprStmt) End 

func (s *ExprStmt) End() token.Pos

End returns position of first character immediately after the node.

func (*ExprStmt) Pos 

func (s *ExprStmt) Pos() token.Pos

Pos returns position of first character belonging to the node.

type Field 

type Field struct {
	Doc     *CommentGroup // associated documentation; or nil
	Names   []*Ident      // field/method/parameter names; or nil
	Type    Expr          // field/method/parameter type
	Tag     *BasicLit     // field tag; or nil
	Comment *CommentGroup // line comments; or nil
}

A Field represents a Field declaration list in a struct type, a method list in an interface type, or a parameter/result declaration in a signature. Field.Names is nil for unnamed parameters (parameter lists which only contain types) and embedded struct fields. In the latter case, the field name is the type name.

func (*Field) End 

func (f *Field) End() token.Pos

End returns position of first character immediately after the node.

func (*Field) Pos 

func (f *Field) Pos() token.Pos

Pos returns position of first character belonging to the node.

type FieldFilter 

type FieldFilter func(name string, value reflect.Value) bool

A FieldFilter may be provided to Fprint to control the output.

type FieldList 

type FieldList struct {
	Opening token.Pos // position of opening parenthesis/brace, if any
	List    []*Field  // field list; or nil
	Closing token.Pos // position of closing parenthesis/brace, if any
}

A FieldList represents a list of Fields, enclosed by parentheses or braces.

func (*FieldList) End 

func (f *FieldList) End() token.Pos

End returns position of first character immediately after the node.

func (*FieldList) NumFields 

func (f *FieldList) NumFields() int

NumFields returns the number of parameters or struct fields represented by a FieldList.

func (*FieldList) Pos 

func (f *FieldList) Pos() token.Pos

Pos returns position of first character belonging to the node.

type File 

type File struct {
	Doc          *CommentGroup   // associated documentation; or nil
	Package      token.Pos       // position of "package" keyword
	Name         *Ident          // package name
	Decls        []Decl          // top-level declarations; or nil
	Scope        *Scope          // package scope (this file only)
	Imports      []*ImportSpec   // imports in this file
	Unresolved   []*Ident        // unresolved identifiers in this file
	Comments     []*CommentGroup // list of all comments in the source file
	Code         []byte
	NoEntrypoint bool // no `main` or `init` func to indicate the module entry point.
	NoPkgDecl    bool // no `package xxx` declaration
	FileType     FileType
}

A File node represents a Go source file.

The Comments list contains all comments in the source file in order of appearance, including the comments that are pointed to from other nodes via Doc and Comment fields.

For correct printing of source code containing comments (using packages go/format and go/printer), special care must be taken to update comments when a File's syntax tree is modified: For printing, comments are interspersed between tokens based on their position. If syntax tree nodes are removed or moved, relevant comments in their vicinity must also be removed (from the File.Comments list) or moved accordingly (by updating their positions). A CommentMap may be used to facilitate some of these operations.

Whether and how a comment is associated with a node depends on the interpretation of the syntax tree by the manipulating program: Except for Doc and Comment comments directly associated with nodes, the remaining comments are "free-floating" (see also issues #18593, #20744).

func MergePackageFiles 

func MergePackageFiles(pkg *Package, mode MergeMode) *File

MergePackageFiles creates a file AST by merging the ASTs of the files belonging to a package. The mode flags control merging behavior.

func (*File) End 

func (f *File) End() token.Pos

End returns position of first character immediately after the node.

func (*File) Pos 

func (f *File) Pos() token.Pos

Pos returns position of first character belonging to the node.

type FileType added in v1.0.9 

type FileType = int16

type Filter 

type Filter func(string) bool

Filter type

type ForPhrase 

type ForPhrase struct {
	For        token.Pos // position of "for" keyword
	Key, Value *Ident    // Key may be nil
	TokPos     token.Pos // position of "<-" operator
	X          Expr      // value to range over
	Init       Stmt      // initialization statement; or nil
	Cond       Expr      // value filter, can be nil
}

ForPhrase represents `for k, v <- container, cond`

func (*ForPhrase) End 

func (p *ForPhrase) End() token.Pos

End returns position of first character immediately after the node.

func (*ForPhrase) Pos 

func (p *ForPhrase) Pos() token.Pos

Pos returns position of first character belonging to the node.

type ForPhraseStmt 

type ForPhraseStmt struct {
	*ForPhrase
	Body *BlockStmt
}

A ForPhraseStmt represents a for statement with a for <- clause.

func (*ForPhraseStmt) End 

func (p *ForPhraseStmt) End() token.Pos

End - position of first character immediately after the node

func (*ForPhraseStmt) Pos 

func (p *ForPhraseStmt) Pos() token.Pos

Pos - position of first character belonging to the node

type ForStmt 

type ForStmt struct {
	For  token.Pos // position of "for" keyword
	Init Stmt      // initialization statement; or nil
	Cond Expr      // condition; or nil
	Post Stmt      // post iteration statement; or nil
	Body *BlockStmt
}

A ForStmt represents a for statement.

func (*ForStmt) End 

func (s *ForStmt) End() token.Pos

End returns position of first character immediately after the node.

func (*ForStmt) Pos 

func (s *ForStmt) Pos() token.Pos

Pos returns position of first character belonging to the node.

type FuncDecl 

type FuncDecl struct {
	Doc      *CommentGroup // associated documentation; or nil
	Recv     *FieldList    // receiver (methods); or nil (functions)
	Name     *Ident        // function/method name
	Type     *FuncType     // function signature: parameters, results, and position of "func" keyword
	Body     *BlockStmt    // function body; or nil for external (non-Go) function
	Operator bool          // is operator or not
}

A FuncDecl node represents a function declaration.

func (*FuncDecl) End 

func (d *FuncDecl) End() token.Pos

End returns position of first character immediately after the node.

func (*FuncDecl) Pos 

func (d *FuncDecl) Pos() token.Pos

Pos returns position of first character belonging to the node.

type FuncLit 

type FuncLit struct {
	Type *FuncType  // function type
	Body *BlockStmt // function body
}

A FuncLit node represents a function literal.

func (*FuncLit) End 

func (x *FuncLit) End() token.Pos

End returns position of first character immediately after the node.

func (*FuncLit) Pos 

func (x *FuncLit) Pos() token.Pos

Pos returns position of first character belonging to the node.

type FuncType 

type FuncType struct {
	Func    token.Pos  // position of "func" keyword (token.NoPos if there is no "func")
	Params  *FieldList // (incoming) parameters; non-nil
	Results *FieldList // (outgoing) results; or nil
}

A FuncType node represents a function type.

func (*FuncType) End 

func (x *FuncType) End() token.Pos

End returns position of first character immediately after the node.

func (*FuncType) Pos 

func (x *FuncType) Pos() token.Pos

Pos returns position of first character belonging to the node.

type GenDecl 

type GenDecl struct {
	Doc    *CommentGroup // associated documentation; or nil
	TokPos token.Pos     // position of Tok
	Tok    token.Token   // IMPORT, CONST, TYPE, VAR
	Lparen token.Pos     // position of '(', if any
	Specs  []Spec
	Rparen token.Pos // position of ')', if any
}

A GenDecl node (generic declaration node) represents an import, constant, type or variable declaration. A valid Lparen position (Lparen.IsValid()) indicates a parenthesized declaration.

Relationship between Tok value and Specs element type: 

token.IMPORT  *ImportSpec
token.CONST   *ValueSpec
token.TYPE    *TypeSpec
token.VAR     *ValueSpec

func (*GenDecl) End 

func (d *GenDecl) End() token.Pos

End returns position of first character immediately after the node.

func (*GenDecl) Pos 

func (d *GenDecl) Pos() token.Pos

Pos returns position of first character belonging to the node.

type GoStmt 

type GoStmt struct {
	Go   token.Pos // position of "go" keyword
	Call *CallExpr
}

A GoStmt node represents a go statement.

func (*GoStmt) End 

func (s *GoStmt) End() token.Pos

End returns position of first character immediately after the node.

func (*GoStmt) Pos 

func (s *GoStmt) Pos() token.Pos

Pos returns position of first character belonging to the node.

type Ident 

type Ident struct {
	NamePos token.Pos // identifier position
	Name    string    // identifier name
	Obj     *Object   // denoted object; or nil
}

An Ident node represents an identifier.

func NewIdent 

func NewIdent(name string) *Ident

NewIdent creates a new Ident without position. Useful for ASTs generated by code other than the Go parser.

func (*Ident) End 

func (x *Ident) End() token.Pos

End returns position of first character immediately after the node.

func (*Ident) IsExported 

func (x *Ident) IsExported() bool

IsExported reports whether id starts with an upper-case letter.

func (*Ident) Pos 

func (x *Ident) Pos() token.Pos

Pos returns position of first character belonging to the node.

func (*Ident) String 

func (x *Ident) String() string

type IfStmt 

type IfStmt struct {
	If   token.Pos // position of "if" keyword
	Init Stmt      // initialization statement; or nil
	Cond Expr      // condition
	Body *BlockStmt
	Else Stmt // else branch; or nil
}

An IfStmt node represents an if statement.

func (*IfStmt) End 

func (s *IfStmt) End() token.Pos

End returns position of first character immediately after the node.

func (*IfStmt) Pos 

func (s *IfStmt) Pos() token.Pos

Pos returns position of first character belonging to the node.

type ImportSpec 

type ImportSpec struct {
	Doc     *CommentGroup // associated documentation; or nil
	Name    *Ident        // local package name (including "."); or nil
	Path    *BasicLit     // import path
	Comment *CommentGroup // line comments; or nil
	EndPos  token.Pos     // end of spec (overrides Path.Pos if nonzero)
}

An ImportSpec node represents a single package import.

func (*ImportSpec) End 

func (s *ImportSpec) End() token.Pos

End returns position of first character immediately after the node.

func (*ImportSpec) Pos 

func (s *ImportSpec) Pos() token.Pos

Pos returns position of first character belonging to the node.

type Importer 

type Importer func(imports map[string]*Object, path string) (pkg *Object, err error)

An Importer resolves import paths to package Objects. The imports map records the packages already imported, indexed by package id (canonical import path). An Importer must determine the canonical import path and check the map to see if it is already present in the imports map. If so, the Importer can return the map entry. Otherwise, the Importer should load the package data for the given path into a new *Object (pkg), record pkg in the imports map, and then return pkg.

type IncDecStmt 

type IncDecStmt struct {
	X      Expr
	TokPos token.Pos   // position of Tok
	Tok    token.Token // INC or DEC
}

An IncDecStmt node represents an increment or decrement statement.

func (*IncDecStmt) End 

func (s *IncDecStmt) End() token.Pos

End returns position of first character immediately after the node.

func (*IncDecStmt) Pos 

func (s *IncDecStmt) Pos() token.Pos

Pos returns position of first character belonging to the node.

type IndexExpr 

type IndexExpr struct {
	X      Expr      // expression
	Lbrack token.Pos // position of "["
	Index  Expr      // index expression
	Rbrack token.Pos // position of "]"
}

An IndexExpr node represents an expression followed by an index.

func (*IndexExpr) End 

func (x *IndexExpr) End() token.Pos

End returns position of first character immediately after the node.

func (*IndexExpr) Pos 

func (x *IndexExpr) Pos() token.Pos

Pos returns position of first character belonging to the node.

type InterfaceType 

type InterfaceType struct {
	Interface  token.Pos  // position of "interface" keyword
	Methods    *FieldList // list of methods
	Incomplete bool       // true if (source) methods are missing in the Methods list
}

An InterfaceType node represents an interface type.

func (*InterfaceType) End 

func (x *InterfaceType) End() token.Pos

End returns position of first character immediately after the node.

func (*InterfaceType) Pos 

func (x *InterfaceType) Pos() token.Pos

Pos returns position of first character belonging to the node.

type KeyValueExpr 

type KeyValueExpr struct {
	Key   Expr
	Colon token.Pos // position of ":"
	Value Expr
}

A KeyValueExpr node represents (key : value) pairs in composite literals.

func (*KeyValueExpr) End 

func (x *KeyValueExpr) End() token.Pos

End returns position of first character immediately after the node.

func (*KeyValueExpr) Pos 

func (x *KeyValueExpr) Pos() token.Pos

Pos returns position of first character belonging to the node.

type LabeledStmt 

type LabeledStmt struct {
	Label *Ident
	Colon token.Pos // position of ":"
	Stmt  Stmt
}

A LabeledStmt node represents a labeled statement.

func (*LabeledStmt) End 

func (s *LabeledStmt) End() token.Pos

End returns position of first character immediately after the node.

func (*LabeledStmt) Pos 

func (s *LabeledStmt) Pos() token.Pos

Pos returns position of first character belonging to the node.

type LambdaExpr added in v1.0.0 

type LambdaExpr struct {
	First       token.Pos
	Lhs         []*Ident
	Rarrow      token.Pos
	Rhs         []Expr
	Last        token.Pos
	LhsHasParen bool
	RhsHasParen bool
}

LambdaExpr represents 

`(x, y, ...) => exprOrExprTuple`
`x => exprOrExprTuple`
`=> exprOrExprTuple`

here exprOrExprTuple represents 

`expr`
`(expr1, expr2, ...)`

func (*LambdaExpr) End added in v1.0.0 

func (p *LambdaExpr) End() token.Pos

func (*LambdaExpr) Pos added in v1.0.0 

func (p *LambdaExpr) Pos() token.Pos

type LambdaExpr2 added in v1.0.2 

type LambdaExpr2 struct {
	First       token.Pos
	Lhs         []*Ident
	Rarrow      token.Pos
	Body        *BlockStmt
	LhsHasParen bool
}

LambdaExpr2 represents 

`(x, y, ...) => { ... }`
`x => { ... }`
`=> { ... }`

func (*LambdaExpr2) End added in v1.0.2 

func (p *LambdaExpr2) End() token.Pos

func (*LambdaExpr2) Pos added in v1.0.2 

func (p *LambdaExpr2) Pos() token.Pos

type MapType 

type MapType struct {
	Map   token.Pos // position of "map" keyword
	Key   Expr
	Value Expr
}

A MapType node represents a map type.

func (*MapType) End 

func (x *MapType) End() token.Pos

End returns position of first character immediately after the node.

func (*MapType) Pos 

func (x *MapType) Pos() token.Pos

Pos returns position of first character belonging to the node.

type MergeMode 

type MergeMode uint

The MergeMode flags control the behavior of MergePackageFiles. 

const (
	// FilterFuncDuplicates - If set, duplicate function declarations are excluded.
	FilterFuncDuplicates MergeMode = 1 << iota
	// FilterUnassociatedComments - If set, comments that are not associated with a specific
	// AST node (as Doc or Comment) are excluded.
	FilterUnassociatedComments
	// FilterImportDuplicates - If set, duplicate import declarations are excluded.
	FilterImportDuplicates
)

type Node 

type Node = ast.Node

Node interface: all node types implement the Node interface.

type ObjKind 

type ObjKind int

ObjKind describes what an object represents. 

const (
	Bad ObjKind = iota // for error handling
	Pkg                // package
	Con                // constant
	Typ                // type
	Var                // variable
	Fun                // function or method
	Lbl                // label
)

The list of possible Object kinds.

func (ObjKind) String 

func (kind ObjKind) String() string

type Object 

type Object struct {
	Kind ObjKind
	Name string      // declared name
	Decl interface{} // corresponding Field, XxxSpec, FuncDecl, LabeledStmt, AssignStmt, Scope; or nil
	Data interface{} // object-specific data; or nil
	Type interface{} // placeholder for type information; may be nil
}

An Object describes a named language entity such as a package, constant, type, variable, function (incl. methods), or label.

The Data fields contains object-specific data: 

Kind    Data type         Data value
Pkg     *Scope            package scope
Con     int               iota for the respective declaration

func NewObj 

func NewObj(kind ObjKind, name string) *Object

NewObj creates a new object of a given kind and name.

func (*Object) Pos 

func (obj *Object) Pos() token.Pos

Pos computes the source position of the declaration of an object name. The result may be an invalid position if it cannot be computed (obj.Decl may be nil or not correct).

type Package 

type Package struct {
	Name    string             // package name
	Scope   *Scope             // package scope across all files
	Imports map[string]*Object // map of package id -> package object
	Files   map[string]*File   // Go source files by filename
}

A Package node represents a set of source files collectively building a Go package.

func NewPackage 

func NewPackage(fset *token.FileSet, files map[string]*File, importer Importer, universe *Scope) (*Package, error)

NewPackage creates a new Package node from a set of File nodes. It resolves unresolved identifiers across files and updates each file's Unresolved list accordingly. If a non-nil importer and universe scope are provided, they are used to resolve identifiers not declared in any of the package files. Any remaining unresolved identifiers are reported as undeclared. If the files belong to different packages, one package name is selected and files with different package names are reported and then ignored. The result is a package node and a scanner.ErrorList if there were errors.

func (*Package) End 

func (p *Package) End() token.Pos

End returns position of first character immediately after the node.

func (*Package) Pos 

func (p *Package) Pos() token.Pos

Pos returns position of first character belonging to the node.

type ParenExpr 

type ParenExpr struct {
	Lparen token.Pos // position of "("
	X      Expr      // parenthesized expression
	Rparen token.Pos // position of ")"
}

A ParenExpr node represents a parenthesized expression.

func (*ParenExpr) End 

func (x *ParenExpr) End() token.Pos

End returns position of first character immediately after the node.

func (*ParenExpr) Pos 

func (x *ParenExpr) Pos() token.Pos

Pos returns position of first character belonging to the node.

type RangeStmt 

type RangeStmt struct {
	For        token.Pos   // position of "for" keyword
	Key, Value Expr        // Key, Value may be nil
	TokPos     token.Pos   // position of Tok; invalid if Key == nil
	Tok        token.Token // ILLEGAL if Key == nil, ASSIGN, DEFINE
	X          Expr        // value to range over
	Body       *BlockStmt
}

A RangeStmt represents a for statement with a range clause.

func (*RangeStmt) End 

func (s *RangeStmt) End() token.Pos

End returns position of first character immediately after the node.

func (*RangeStmt) Pos 

func (s *RangeStmt) Pos() token.Pos

Pos returns position of first character belonging to the node.

type ReturnStmt 

type ReturnStmt struct {
	Return  token.Pos // position of "return" keyword
	Results []Expr    // result expressions; or nil
}

A ReturnStmt node represents a return statement.

func (*ReturnStmt) End 

func (s *ReturnStmt) End() token.Pos

End returns position of first character immediately after the node.

func (*ReturnStmt) Pos 

func (s *ReturnStmt) Pos() token.Pos

Pos returns position of first character belonging to the node.

type Scope 

type Scope struct {
	Outer   *Scope
	Objects map[string]*Object
}

A Scope maintains the set of named language entities declared in the scope and a link to the immediately surrounding (outer) scope.

func NewScope 

func NewScope(outer *Scope) *Scope

NewScope creates a new scope nested in the outer scope.

func (*Scope) Insert 

func (s *Scope) Insert(obj *Object) (alt *Object)

Insert attempts to insert a named object obj into the scope s. If the scope already contains an object alt with the same name, Insert leaves the scope unchanged and returns alt. Otherwise it inserts obj and returns nil.

func (*Scope) Lookup 

func (s *Scope) Lookup(name string) *Object

Lookup returns the object with the given name if it is found in scope s, otherwise it returns nil. Outer scopes are ignored.

func (*Scope) String 

func (s *Scope) String() string

Debugging support

type SelectStmt 

type SelectStmt struct {
	Select token.Pos  // position of "select" keyword
	Body   *BlockStmt // CommClauses only
}

A SelectStmt node represents a select statement.

func (*SelectStmt) End 

func (s *SelectStmt) End() token.Pos

End returns position of first character immediately after the node.

func (*SelectStmt) Pos 

func (s *SelectStmt) Pos() token.Pos

Pos returns position of first character belonging to the node.

type SelectorExpr 

type SelectorExpr struct {
	X   Expr   // expression
	Sel *Ident // field selector
}

A SelectorExpr node represents an expression followed by a selector.

func (*SelectorExpr) End 

func (x *SelectorExpr) End() token.Pos

End returns position of first character immediately after the node.

func (*SelectorExpr) Pos 

func (x *SelectorExpr) Pos() token.Pos

Pos returns position of first character belonging to the node.

type SendStmt 

type SendStmt struct {
	Chan  Expr
	Arrow token.Pos // position of "<-"
	Value Expr
}

A SendStmt node represents a send statement.

func (*SendStmt) End 

func (s *SendStmt) End() token.Pos

End returns position of first character immediately after the node.

func (*SendStmt) Pos 

func (s *SendStmt) Pos() token.Pos

Pos returns position of first character belonging to the node.

type SliceExpr 

type SliceExpr struct {
	X      Expr      // expression
	Lbrack token.Pos // position of "["
	Low    Expr      // begin of slice range; or nil
	High   Expr      // end of slice range; or nil
	Max    Expr      // maximum capacity of slice; or nil
	Slice3 bool      // true if 3-index slice (2 colons present)
	Rbrack token.Pos // position of "]"
}

A SliceExpr node represents an expression followed by slice indices.

func (*SliceExpr) End 

func (x *SliceExpr) End() token.Pos

End returns position of first character immediately after the node.

func (*SliceExpr) Pos 

func (x *SliceExpr) Pos() token.Pos

Pos returns position of first character belonging to the node.

type SliceLit 

type SliceLit struct {
	Lbrack     token.Pos // position of "["
	Elts       []Expr    // list of composite elements; or nil
	Rbrack     token.Pos // position of "]"
	Incomplete bool      // true if (source) expressions are missing in the Elts list
}

A SliceLit node represents a slice literal.

func (*SliceLit) End 

func (p *SliceLit) End() token.Pos

End - position of first character immediately after the node

func (*SliceLit) Pos 

func (p *SliceLit) Pos() token.Pos

Pos - position of first character belonging to the node

type Spec 

type Spec interface {
	Node
	// contains filtered or unexported methods
}

The Spec type stands for any of *ImportSpec, *ValueSpec, and *TypeSpec.

type StarExpr 

type StarExpr struct {
	Star token.Pos // position of "*"
	X    Expr      // operand
}

A StarExpr node represents an expression of the form "*" Expression. Semantically it could be a unary "*" expression, or a pointer type.

func (*StarExpr) End 

func (x *StarExpr) End() token.Pos

End returns position of first character immediately after the node.

func (*StarExpr) Pos 

func (x *StarExpr) Pos() token.Pos

Pos returns position of first character belonging to the node.

type Stmt 

type Stmt interface {
	Node
	// contains filtered or unexported methods
}

Stmt interface: all statement nodes implement the Stmt interface.

type StructType 

type StructType struct {
	Struct     token.Pos  // position of "struct" keyword
	Fields     *FieldList // list of field declarations
	Incomplete bool       // true if (source) fields are missing in the Fields list
}

A StructType node represents a struct type.

func (*StructType) End 

func (x *StructType) End() token.Pos

End returns position of first character immediately after the node.

func (*StructType) Pos 

func (x *StructType) Pos() token.Pos

Pos returns position of first character belonging to the node.

type SwitchStmt 

type SwitchStmt struct {
	Switch token.Pos  // position of "switch" keyword
	Init   Stmt       // initialization statement; or nil
	Tag    Expr       // tag expression; or nil
	Body   *BlockStmt // CaseClauses only
}

A SwitchStmt node represents an expression switch statement.

func (*SwitchStmt) End 

func (s *SwitchStmt) End() token.Pos

End returns position of first character immediately after the node.

func (*SwitchStmt) Pos 

func (s *SwitchStmt) Pos() token.Pos

Pos returns position of first character belonging to the node.

type TypeAssertExpr 

type TypeAssertExpr struct {
	X      Expr      // expression
	Lparen token.Pos // position of "("
	Type   Expr      // asserted type; nil means type switch X.(type)
	Rparen token.Pos // position of ")"
}

A TypeAssertExpr node represents an expression followed by a type assertion.

func (*TypeAssertExpr) End 

func (x *TypeAssertExpr) End() token.Pos

End returns position of first character immediately after the node.

func (*TypeAssertExpr) Pos 

func (x *TypeAssertExpr) Pos() token.Pos

Pos returns position of first character belonging to the node.

type TypeSpec 

type TypeSpec struct {
	Doc     *CommentGroup // associated documentation; or nil
	Name    *Ident        // type name
	Assign  token.Pos     // position of '=', if any
	Type    Expr          // *Ident, *ParenExpr, *SelectorExpr, *StarExpr, or any of the *XxxTypes
	Comment *CommentGroup // line comments; or nil
}

A TypeSpec node represents a type declaration (TypeSpec production).

func (*TypeSpec) End 

func (s *TypeSpec) End() token.Pos

End returns position of first character immediately after the node.

func (*TypeSpec) Pos 

func (s *TypeSpec) Pos() token.Pos

Pos returns position of first character belonging to the node.

type TypeSwitchStmt 

type TypeSwitchStmt struct {
	Switch token.Pos  // position of "switch" keyword
	Init   Stmt       // initialization statement; or nil
	Assign Stmt       // x := y.(type) or y.(type)
	Body   *BlockStmt // CaseClauses only
}

A TypeSwitchStmt node represents a type switch statement.

func (*TypeSwitchStmt) End 

func (s *TypeSwitchStmt) End() token.Pos

End returns position of first character immediately after the node.

func (*TypeSwitchStmt) Pos 

func (s *TypeSwitchStmt) Pos() token.Pos

Pos returns position of first character belonging to the node.

type UnaryExpr 

type UnaryExpr struct {
	OpPos token.Pos   // position of Op
	Op    token.Token // operator
	X     Expr        // operand
}

A UnaryExpr node represents a unary expression. Unary "*" expressions are represented via StarExpr nodes.

func (*UnaryExpr) End 

func (x *UnaryExpr) End() token.Pos

End returns position of first character immediately after the node.

func (*UnaryExpr) Pos 

func (x *UnaryExpr) Pos() token.Pos

Pos returns position of first character belonging to the node.

type ValueSpec 

type ValueSpec struct {
	Doc     *CommentGroup // associated documentation; or nil
	Names   []*Ident      // value names (len(Names) > 0)
	Type    Expr          // value type; or nil
	Values  []Expr        // initial values; or nil
	Comment *CommentGroup // line comments; or nil
}

A ValueSpec node represents a constant or variable declaration (ConstSpec or VarSpec production).

func (*ValueSpec) End 

func (s *ValueSpec) End() token.Pos

End returns position of first character immediately after the node.

func (*ValueSpec) Pos 

func (s *ValueSpec) Pos() token.Pos

Pos returns position of first character belonging to the node.

type Visitor 

type Visitor interface {
	Visit(node Node) (w Visitor)
}

Visitor - A Visitor's Visit method is invoked for each node encountered by Walk. If the result visitor w is not nil, Walk visits each of the children of node with the visitor w, followed by a call of w.Visit(nil).

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.