Documentation
¶
Index ¶
- func IsExported(name string) bool
- type AssignStmt
- type BadDecl
- type BadExpr
- type BadStmt
- type BasicLit
- type BinaryExpr
- type Decl
- type DeclStmt
- type EmptyStmt
- type Expr
- type ExprStmt
- type File
- type GenDecl
- type Ident
- type IncDecStmt
- type Node
- type ObjKind
- type Object
- type ParenExpr
- type Scope
- type Spec
- type Stmt
- type UnaryExpr
- type ValueSpec
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func IsExported ¶
IsExported reports whether name starts with an upper-case letter.
Types ¶
type AssignStmt ¶
type AssignStmt struct {
Lhs []Expr
TokPos token.Pos // position of Tok
Tok token.Token // assignment token, DEFINE
Rhs []Expr
}
An AssignStmt node represents an assignment or a short variable declaration.
func (*AssignStmt) End ¶
func (s *AssignStmt) End() token.Pos
func (*AssignStmt) Pos ¶
func (s *AssignStmt) Pos() token.Pos
type BadDecl ¶
A BadDecl node is a placeholder for declarations containing syntax errors for which no correct declaration nodes can be created.
type BadExpr ¶
A BadExpr node is a placeholder for expressions containing syntax errors for which no correct expression nodes can be created.
type BadStmt ¶
A BadStmt node is a placeholder for statements containing syntax errors for which no correct statement nodes can be created.
type BasicLit ¶
type BasicLit struct {
ValuePos token.Pos // literal position
Kind token.Token // token.INT, token.FLOAT, token.CHAR, token.STRING, or token.RAW_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.
type BinaryExpr ¶
type BinaryExpr struct {
Lhs Expr // left operand
OpPos token.Pos // position of Op
Op token.Token // operator
Rhs Expr // right operand
}
A BinaryExpr node represents a binary expression.
func (*BinaryExpr) End ¶
func (x *BinaryExpr) End() token.Pos
func (*BinaryExpr) Pos ¶
func (x *BinaryExpr) Pos() token.Pos
type Decl ¶
type Decl interface {
Node
// contains filtered or unexported methods
}
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.
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.
type Expr ¶
type Expr interface {
Node
// contains filtered or unexported methods
}
All expression nodes implement the Expr interface.
type ExprStmt ¶
type ExprStmt struct {
Expr Expr // expression
}
An ExprStmt node represents a (stand-alone) expression in a statement list.
type File ¶
type File struct {
Package token.Pos // position of "package" keyword
Name *Ident // package name
Stmts []Stmt // top-level statements; or nil
Scope *Scope // package scope (this file only)
//Imports []*ImportSpec // imports in this file
Unresolved []*Ident // unresolved identifiers in this file
}
A File node represents a Go source file.
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
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 (*Ident) IsExported ¶
IsExported reports whether id starts with an upper-case letter.
type IncDecStmt ¶
type IncDecStmt struct {
Expr 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
func (*IncDecStmt) Pos ¶
func (s *IncDecStmt) Pos() token.Pos
type Node ¶
type Node interface {
Pos() token.Pos // position of first character belonging to the node
End() token.Pos // position of first character immediately after the node
}
All node types implement the Node interface.
type ObjKind ¶
type ObjKind int
ObjKind describes what an object represents.
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
TODO: (capnspacehook) remove interface{} fields?
type ParenExpr ¶
type ParenExpr struct {
Lparen token.Pos // position of "("
Expr Expr // parenthesized expression
Rparen token.Pos // position of ")"
}
A ParenExpr node represents a parenthesized expression.
type Scope ¶
A Scope maintains the set of named language entities declared in the scope and a link to the immediately surrounding (outer) scope.
func (*Scope) Insert ¶
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.
type Spec ¶
type Spec interface {
Node
// contains filtered or unexported methods
}
The Spec type stands for any of *ImportSpec, *ValueSpec, and *TypeSpec.
type Stmt ¶
type Stmt interface {
Node
// contains filtered or unexported methods
}
All statement nodes implement the Stmt interface.
type UnaryExpr ¶
type UnaryExpr struct {
OpPos token.Pos // position of Op
Op token.Token // operator
Expr Expr // operand
}
A UnaryExpr node represents a unary expression.
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
}
A ValueSpec node represents a constant or variable declaration (ConstSpec or VarSpec production).
Source Files