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 {
Value []Expression
LeftBracket file.Idx
RightBracket file.Idx
}
ArrayLiteral represents an array literal.
type AssignExpression ¶
type AssignExpression struct {
Left Expression
Right Expression
Operator token.Token
}
AssignExpression represents an assignment expression.
type BadExpression ¶
BadExpression represents a bad expression.
type BadStatement ¶
BadStatement represents a bad statement.
type BinaryExpression ¶
type BinaryExpression struct {
Left Expression
Right Expression
Operator token.Token
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 {
Label *Identifier
Idx file.Idx
Token token.Token
}
BranchStatement represents a branch statement.
type CallExpression ¶
type CallExpression struct {
Callee Expression
ArgumentList []Expression
LeftParenthesis file.Idx
RightParenthesis file.Idx
}
CallExpression represents a call expression.
type CaseStatement ¶
type CaseStatement struct {
Test Expression
Consequent []Statement
Case file.Idx
}
CaseStatement represents a case statement.
type CatchStatement ¶
type CatchStatement struct {
Body Statement
Parameter *Identifier
Catch file.Idx
}
CatchStatement represents a catch statement.
type Comment ¶
type Comment struct {
Text string
Begin file.Idx
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 {
Test Expression
Body Statement
Do file.Idx
RightParenthesis file.Idx
}
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 {
Into Expression
Source Expression
Body Statement
For file.Idx
}
ForInStatement represents a for in statement.
type ForStatement ¶
type ForStatement struct {
Initializer Expression
Update Expression
Test Expression
Body Statement
For file.Idx
}
ForStatement represents a for statement.
type FunctionDeclaration ¶
type FunctionDeclaration struct {
Function *FunctionLiteral
}
FunctionDeclaration represents a function declaration.
type FunctionLiteral ¶
type FunctionLiteral struct {
Body Statement
Name *Identifier
ParameterList *ParameterList
Source string
DeclarationList []Declaration
Function file.Idx
}
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 {
Test Expression
Consequent Statement
Alternate Statement
If file.Idx
}
IfStatement represents a if statement.
type LabelledStatement ¶
type LabelledStatement struct {
Statement Statement
Label *Identifier
Colon file.Idx
}
LabelledStatement represents a labelled statement.
type NewExpression ¶
type NewExpression struct {
Callee Expression
ArgumentList []Expression
New file.Idx
LeftParenthesis file.Idx
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 {
List []*Identifier
Opening file.Idx
Closing file.Idx
}
ParameterList represents a parameter list.
type Program ¶
type Program struct {
File *file.File
Comments CommentMap
Body []Statement
DeclarationList []Declaration
}
Program represents a full program.
type Property ¶
type Property struct {
Value Expression
Key string
Kind string
}
Property represents a property.
type RegExpLiteral ¶
RegExpLiteral represents a regular expression literal.
type ReturnStatement ¶
type ReturnStatement struct {
Argument Expression
Return file.Idx
}
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 {
Discriminant Expression
Body []*CaseStatement
Switch file.Idx
Default int
RightBrace file.Idx
}
SwitchStatement represents a switch statement.
type ThisExpression ¶
ThisExpression represents a this expression.
type ThrowStatement ¶
type ThrowStatement struct {
Argument Expression
Throw file.Idx
}
ThrowStatement represents a throw statement.
type TryStatement ¶
type TryStatement struct {
Body Statement
Finally Statement
Catch *CatchStatement
Try file.Idx
}
TryStatement represents a try statement.
type UnaryExpression ¶
UnaryExpression represents a unary expression.
type VariableDeclaration ¶
type VariableDeclaration struct {
List []*VariableExpression
Var file.Idx
}
VariableDeclaration represents a variable declaration.
type VariableExpression ¶
type VariableExpression struct {
Initializer Expression
Name string
Idx file.Idx
}
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 {
List []Expression
Var file.Idx
}
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 {
Test Expression
Body Statement
While file.Idx
}
WhileStatement represents a while statement.
type WithStatement ¶
type WithStatement struct {
Object Expression
Body Statement
With file.Idx
}
WithStatement represents a with statement.
Source Files