Documentation ¶
Overview ¶
Package ast declares types representing a JavaScript AST.
# Warning The parser and AST interfaces are still works-in-progress (particularly where node types are concerned) and may change in the future.
Index ¶
- func Walk(v Visitor, n Node)
- type ArrayLiteral
- type AssignExpression
- type BadExpression
- type BadStatement
- type BinaryExpression
- type BlockStatement
- type BooleanLiteral
- type BracketExpression
- type BranchStatement
- type CallExpression
- type CaseStatement
- type CatchStatement
- type Comment
- type CommentMap
- type CommentPosition
- type Comments
- func (c *Comments) AddComment(comment *Comment)
- func (c *Comments) AfterBlock()
- func (c *Comments) AtLineBreak()
- func (c *Comments) Fetch() []*Comment
- func (c *Comments) FetchAll() []*Comment
- func (c *Comments) MarkComments(position CommentPosition)
- func (c *Comments) MarkPrimary()
- func (c *Comments) PostProcessNode(node Node)
- func (c *Comments) ResetLineBreak()
- func (c *Comments) SetExpression(node Expression)
- func (c *Comments) String() string
- func (c *Comments) Unset()
- type ConditionalExpression
- type DebuggerStatement
- type Declaration
- type DoWhileStatement
- type DotExpression
- type EmptyExpression
- type EmptyStatement
- type Expression
- type ExpressionStatement
- type ForInStatement
- type ForStatement
- type FunctionDeclaration
- type FunctionLiteral
- type FunctionStatement
- type Identifier
- type IfStatement
- type LabelledStatement
- type NewExpression
- type Node
- type NullLiteral
- type NumberLiteral
- type ObjectLiteral
- type ParameterList
- type Program
- type Property
- type RegExpLiteral
- type ReturnStatement
- type SequenceExpression
- type Statement
- type StringLiteral
- type SwitchStatement
- type ThisExpression
- type ThrowStatement
- type TryStatement
- type UnaryExpression
- type VariableDeclaration
- type VariableExpression
- type VariableStatement
- type Visitor
- type WhileStatement
- type WithStatement
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
Types ¶
type ArrayLiteral ¶
type ArrayLiteral struct { LeftBracket file.Idx RightBracket file.Idx Value []Expression }
ArrayLiteral represents an array literal.
type AssignExpression ¶
type AssignExpression struct { Operator token.Token Left Expression Right Expression }
AssignExpression represents an assignment expression.
type BadExpression ¶
BadExpression represents a bad expression.
type BadStatement ¶
BadStatement represents a bad statement.
type BinaryExpression ¶
type BinaryExpression struct { Operator token.Token Left Expression Right Expression Comparison bool }
BinaryExpression represents a binary expression.
type BlockStatement ¶
BlockStatement represents a block statement.
type BooleanLiteral ¶
BooleanLiteral represents a boolean expression.
type BracketExpression ¶
type BracketExpression struct { Left Expression Member Expression LeftBracket file.Idx RightBracket file.Idx }
BracketExpression represents a bracketed expression.
type BranchStatement ¶
type BranchStatement struct { Idx file.Idx Token token.Token Label *Identifier }
BranchStatement represents a branch statement.
type CallExpression ¶
type CallExpression struct { Callee Expression LeftParenthesis file.Idx ArgumentList []Expression RightParenthesis file.Idx }
CallExpression represents a call expression.
type CaseStatement ¶
type CaseStatement struct { Case file.Idx Test Expression Consequent []Statement }
CaseStatement represents a case statement.
type CatchStatement ¶
type CatchStatement struct { Catch file.Idx Parameter *Identifier Body Statement }
CatchStatement represents a catch statement.
type Comment ¶
type Comment struct { Begin file.Idx Text string Position CommentPosition }
Comment contains the data of the comment.
func NewComment ¶
NewComment creates a new comment.
type CommentMap ¶
CommentMap is the data structure where all found comments are stored.
func (CommentMap) AddComment ¶
func (cm CommentMap) AddComment(node Node, comment *Comment)
AddComment adds a single comment to the map.
func (CommentMap) AddComments ¶
func (cm CommentMap) AddComments(node Node, comments []*Comment, position CommentPosition)
AddComments adds a slice of comments, given a node and an updated position.
func (CommentMap) MoveComments ¶
func (cm CommentMap) MoveComments(from, to Node, position CommentPosition)
MoveComments moves comments with a given position from a node to another.
type CommentPosition ¶
type CommentPosition int
CommentPosition determines where the comment is in a given context.
const ( // LEADING is before the pertinent expression. LEADING CommentPosition // TRAILING is after the pertinent expression. TRAILING // KEY is before a key in an object. KEY // COLON is after a colon in a field declaration. COLON // FINAL is the final comments in a block, not belonging to a specific expression or the comment after a trailing , in an array or object literal. FINAL // IF is after an if keyword. IF // WHILE is after a while keyword. WHILE // DO is after do keyword. DO // FOR is after a for keyword. FOR // WITH is after a with keyword. WITH // TBD is unknown. TBD )
Available comment positions.
func (CommentPosition) String ¶
func (cp CommentPosition) String() string
String returns a stringified version of the position.
type Comments ¶
type Comments struct { // CommentMap is a reference to the parser comment map CommentMap CommentMap // Comments lists the comments scanned, not linked to a node yet Comments []*Comment // Current is node for which comments are linked to Current Expression // contains filtered or unexported fields }
Comments defines the current view of comments from the parser.
func (*Comments) AddComment ¶
AddComment adds a comment to the view. Depending on the context, comments are added normally or as post line break.
func (*Comments) AfterBlock ¶
func (c *Comments) AfterBlock()
AfterBlock will mark the context as being after a block.
func (*Comments) FetchAll ¶
FetchAll returns all the currently scanned comments, including those from the next line.
func (*Comments) MarkComments ¶
func (c *Comments) MarkComments(position CommentPosition)
MarkComments will mark the found comments as the given position.
func (*Comments) MarkPrimary ¶
func (c *Comments) MarkPrimary()
MarkPrimary will mark the context as processing a primary expression.
func (*Comments) PostProcessNode ¶
PostProcessNode applies all found comments to the given node.
func (*Comments) ResetLineBreak ¶
func (c *Comments) ResetLineBreak()
ResetLineBreak marks the beginning of a new statement.
func (*Comments) SetExpression ¶
func (c *Comments) SetExpression(node Expression)
SetExpression sets the current expression. It is applied the found comments, unless the previous expression has not been unset. It is skipped if the node is already set or if it is a part of the previous node.
type ConditionalExpression ¶
type ConditionalExpression struct { Test Expression Consequent Expression Alternate Expression }
ConditionalExpression represents a conditional expression.
func (*ConditionalExpression) Idx0 ¶
func (ce *ConditionalExpression) Idx0() file.Idx
Idx0 implements Node.
func (*ConditionalExpression) Idx1 ¶
func (ce *ConditionalExpression) Idx1() file.Idx
Idx1 implements Node.
type DebuggerStatement ¶
DebuggerStatement represents a debugger statement.
type Declaration ¶
type Declaration interface {
// contains filtered or unexported methods
}
Declaration is implemented by type which represent declarations.
type DoWhileStatement ¶
type DoWhileStatement struct { Do file.Idx Test Expression Body Statement }
DoWhileStatement represents a do while statement.
type DotExpression ¶
type DotExpression struct { Left Expression Identifier *Identifier }
DotExpression represents a dot expression.
type EmptyExpression ¶
EmptyExpression represents an empty expression.
type EmptyStatement ¶
EmptyStatement represents a empty statement.
type Expression ¶
type Expression interface { Node // contains filtered or unexported methods }
Expression is implemented by types that represent an Expression.
type ExpressionStatement ¶
type ExpressionStatement struct {
Expression Expression
}
ExpressionStatement represents a expression statement.
func (*ExpressionStatement) Idx0 ¶
func (es *ExpressionStatement) Idx0() file.Idx
Idx0 implements Node.
func (*ExpressionStatement) Idx1 ¶
func (es *ExpressionStatement) Idx1() file.Idx
Idx1 implements Node.
type ForInStatement ¶
type ForInStatement struct { For file.Idx Into Expression Source Expression Body Statement }
ForInStatement represents a for in statement.
type ForStatement ¶
type ForStatement struct { For file.Idx Initializer Expression Update Expression Test Expression Body Statement }
ForStatement represents a for statement.
type FunctionDeclaration ¶
type FunctionDeclaration struct {
Function *FunctionLiteral
}
FunctionDeclaration represents a function declaration.
type FunctionLiteral ¶
type FunctionLiteral struct { Function file.Idx Name *Identifier ParameterList *ParameterList Body Statement Source string DeclarationList []Declaration }
FunctionLiteral represents a function literal.
type FunctionStatement ¶
type FunctionStatement struct {
Function *FunctionLiteral
}
FunctionStatement represents a function statement.
type Identifier ¶
Identifier represents an identifier.
type IfStatement ¶
type IfStatement struct { If file.Idx Test Expression Consequent Statement Alternate Statement }
IfStatement represents a if statement.
type LabelledStatement ¶
type LabelledStatement struct { Label *Identifier Colon file.Idx Statement Statement }
LabelledStatement represents a labelled statement.
type NewExpression ¶
type NewExpression struct { New file.Idx Callee Expression LeftParenthesis file.Idx ArgumentList []Expression RightParenthesis file.Idx }
NewExpression represents a new expression.
type Node ¶
type Node interface { Idx0() file.Idx // The index of the first character belonging to the node Idx1() file.Idx // The index of the first character immediately after the node }
Node is implemented by types that represent a node.
type NullLiteral ¶
NullLiteral represents a null literal.
type NumberLiteral ¶
NumberLiteral represents a number literal.
type ObjectLiteral ¶
ObjectLiteral represents an object literal.
type ParameterList ¶
type ParameterList struct { Opening file.Idx List []*Identifier Closing file.Idx }
ParameterList represents a parameter list.
type Program ¶
type Program struct { Body []Statement DeclarationList []Declaration File *file.File Comments CommentMap }
Program represents a full program.
type Property ¶
type Property struct { Key string Kind string Value Expression }
Property represents a property.
type RegExpLiteral ¶
RegExpLiteral represents a regular expression literal.
type ReturnStatement ¶
type ReturnStatement struct { Return file.Idx Argument Expression }
ReturnStatement represents a return statement.
type SequenceExpression ¶
type SequenceExpression struct {
Sequence []Expression
}
SequenceExpression represents a sequence literal.
func (*SequenceExpression) Idx0 ¶
func (se *SequenceExpression) Idx0() file.Idx
Idx0 implements Node.
func (*SequenceExpression) Idx1 ¶
func (se *SequenceExpression) Idx1() file.Idx
Idx1 implements Node.
type Statement ¶
type Statement interface { Node // contains filtered or unexported methods }
Statement is implemented by types which represent a statement.
type StringLiteral ¶
StringLiteral represents a string literal.
type SwitchStatement ¶
type SwitchStatement struct { Switch file.Idx Discriminant Expression Default int Body []*CaseStatement }
SwitchStatement represents a switch statement.
type ThisExpression ¶
ThisExpression represents a this expression.
type ThrowStatement ¶
type ThrowStatement struct { Throw file.Idx Argument Expression }
ThrowStatement represents a throw statement.
type TryStatement ¶
type TryStatement struct { Try file.Idx Body Statement Catch *CatchStatement Finally Statement }
TryStatement represents a try statement.
type UnaryExpression ¶
type UnaryExpression struct { Operator token.Token Idx file.Idx // If a prefix operation Operand Expression Postfix bool }
UnaryExpression represents a unary expression.
type VariableDeclaration ¶
type VariableDeclaration struct { Var file.Idx List []*VariableExpression }
VariableDeclaration represents a variable declaration.
type VariableExpression ¶
type VariableExpression struct { Name string Idx file.Idx Initializer Expression }
VariableExpression represents a variable expression.
func (*VariableExpression) Idx0 ¶
func (ve *VariableExpression) Idx0() file.Idx
Idx0 implements Node.
func (*VariableExpression) Idx1 ¶
func (ve *VariableExpression) Idx1() file.Idx
Idx1 implements Node.
type VariableStatement ¶
type VariableStatement struct { Var file.Idx List []Expression }
VariableStatement represents a variable statement.
type Visitor ¶
Visitor Enter 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 v, followed by a call of the Exit method.
Example (CodeRewrite) ¶
package main import ( "fmt" "log" "github.com/robertkrimen/otto/ast" "github.com/robertkrimen/otto/file" "github.com/robertkrimen/otto/parser" ) type walkExample struct { source string shift file.Idx } func (w *walkExample) Enter(n ast.Node) ast.Visitor { if id, ok := n.(*ast.Identifier); ok && id != nil { idx := n.Idx0() + w.shift - 1 s := w.source[:idx] + "new_" + w.source[idx:] w.source = s w.shift += 4 } if v, ok := n.(*ast.VariableExpression); ok && v != nil { idx := n.Idx0() + w.shift - 1 s := w.source[:idx] + "varnew_" + w.source[idx:] w.source = s w.shift += 7 } return w } func (w *walkExample) Exit(n ast.Node) { // AST node n has had all its children walked. Pop it out of your // stack, or do whatever processing you need to do, if any. } func main() { source := `var b = function() {test(); try {} catch(e) {} var test = "test(); var test = 1"} // test` program, err := parser.ParseFile(nil, "", source, 0) if err != nil { log.Fatal(err) } w := &walkExample{source: source} ast.Walk(w, program) fmt.Println(w.source) }
Output: var varnew_b = function() {new_test(); try {} catch(new_e) {} var varnew_test = "test(); var test = 1"} // test
type WhileStatement ¶
type WhileStatement struct { While file.Idx Test Expression Body Statement }
WhileStatement represents a while statement.
type WithStatement ¶
type WithStatement struct { With file.Idx Object Expression Body Statement }
WithStatement represents a with statement.