otto: github.com/robertkrimen/otto/ast Index | Examples | Files

package ast

import "github.com/robertkrimen/otto/ast"

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

Examples

Package Files

comments.go node.go walk.go

func Walk Uses

func Walk(v Visitor, n Node)

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

type ArrayLiteral Uses

type ArrayLiteral struct {
    LeftBracket  file.Idx
    RightBracket file.Idx
    Value        []Expression
}

func (*ArrayLiteral) Idx0 Uses

func (self *ArrayLiteral) Idx0() file.Idx

func (*ArrayLiteral) Idx1 Uses

func (self *ArrayLiteral) Idx1() file.Idx

type AssignExpression Uses

type AssignExpression struct {
    Operator token.Token
    Left     Expression
    Right    Expression
}

func (*AssignExpression) Idx0 Uses

func (self *AssignExpression) Idx0() file.Idx

func (*AssignExpression) Idx1 Uses

func (self *AssignExpression) Idx1() file.Idx

type BadExpression Uses

type BadExpression struct {
    From file.Idx
    To   file.Idx
}

func (*BadExpression) Idx0 Uses

func (self *BadExpression) Idx0() file.Idx

func (*BadExpression) Idx1 Uses

func (self *BadExpression) Idx1() file.Idx

type BadStatement Uses

type BadStatement struct {
    From file.Idx
    To   file.Idx
}

func (*BadStatement) Idx0 Uses

func (self *BadStatement) Idx0() file.Idx

func (*BadStatement) Idx1 Uses

func (self *BadStatement) Idx1() file.Idx

type BinaryExpression Uses

type BinaryExpression struct {
    Operator   token.Token
    Left       Expression
    Right      Expression
    Comparison bool
}

func (*BinaryExpression) Idx0 Uses

func (self *BinaryExpression) Idx0() file.Idx

func (*BinaryExpression) Idx1 Uses

func (self *BinaryExpression) Idx1() file.Idx

type BlockStatement Uses

type BlockStatement struct {
    LeftBrace  file.Idx
    List       []Statement
    RightBrace file.Idx
}

func (*BlockStatement) Idx0 Uses

func (self *BlockStatement) Idx0() file.Idx

func (*BlockStatement) Idx1 Uses

func (self *BlockStatement) Idx1() file.Idx

type BooleanLiteral Uses

type BooleanLiteral struct {
    Idx     file.Idx
    Literal string
    Value   bool
}

func (*BooleanLiteral) Idx0 Uses

func (self *BooleanLiteral) Idx0() file.Idx

func (*BooleanLiteral) Idx1 Uses

func (self *BooleanLiteral) Idx1() file.Idx

type BracketExpression Uses

type BracketExpression struct {
    Left         Expression
    Member       Expression
    LeftBracket  file.Idx
    RightBracket file.Idx
}

func (*BracketExpression) Idx0 Uses

func (self *BracketExpression) Idx0() file.Idx

func (*BracketExpression) Idx1 Uses

func (self *BracketExpression) Idx1() file.Idx

type BranchStatement Uses

type BranchStatement struct {
    Idx   file.Idx
    Token token.Token
    Label *Identifier
}

func (*BranchStatement) Idx0 Uses

func (self *BranchStatement) Idx0() file.Idx

func (*BranchStatement) Idx1 Uses

func (self *BranchStatement) Idx1() file.Idx

type CallExpression Uses

type CallExpression struct {
    Callee           Expression
    LeftParenthesis  file.Idx
    ArgumentList     []Expression
    RightParenthesis file.Idx
}

func (*CallExpression) Idx0 Uses

func (self *CallExpression) Idx0() file.Idx

func (*CallExpression) Idx1 Uses

func (self *CallExpression) Idx1() file.Idx

type CaseStatement Uses

type CaseStatement struct {
    Case       file.Idx
    Test       Expression
    Consequent []Statement
}

func (*CaseStatement) Idx0 Uses

func (self *CaseStatement) Idx0() file.Idx

func (*CaseStatement) Idx1 Uses

func (self *CaseStatement) Idx1() file.Idx

type CatchStatement Uses

type CatchStatement struct {
    Catch     file.Idx
    Parameter *Identifier
    Body      Statement
}

func (*CatchStatement) Idx0 Uses

func (self *CatchStatement) Idx0() file.Idx

func (*CatchStatement) Idx1 Uses

func (self *CatchStatement) Idx1() file.Idx

type Comment Uses

type Comment struct {
    Begin    file.Idx
    Text     string
    Position CommentPosition
}

Comment contains the data of the comment

func NewComment Uses

func NewComment(text string, idx file.Idx) *Comment

NewComment creates a new comment

func (Comment) String Uses

func (c Comment) String() string

String returns a stringified version of the comment

type CommentMap Uses

type CommentMap map[Node][]*Comment

CommentMap is the data structure where all found comments are stored

func (CommentMap) AddComment Uses

func (cm CommentMap) AddComment(node Node, comment *Comment)

AddComment adds a single comment to the map

func (CommentMap) AddComments Uses

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 Uses

func (cm CommentMap) MoveComments(from, to Node, position CommentPosition)

MoveComments moves comments with a given position from a node to another

func (CommentMap) Size Uses

func (cm CommentMap) Size() int

Size returns the size of the map

type CommentPosition Uses

type CommentPosition int

CommentPosition determines where the comment is in a given context

const (
    LEADING  CommentPosition // Before the pertinent expression
    TRAILING                 // After the pertinent expression
    KEY                      // Before a key in an object
    COLON                    // After a colon in a field declaration
    FINAL                    // Final comments in a block, not belonging to a specific expression or the comment after a trailing , in an array or object literal
    IF                       // After an if keyword
    WHILE                    // After a while keyword
    DO                       // After do keyword
    FOR                      // After a for keyword
    WITH                     // After a with keyword
    TBD
)

func (CommentPosition) String Uses

func (cp CommentPosition) String() string

String returns a stringified version of the position

type Comments Uses

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 NewComments Uses

func NewComments() *Comments

func (*Comments) AddComment Uses

func (c *Comments) AddComment(comment *Comment)

AddComment adds a comment to the view. Depending on the context, comments are added normally or as post line break.

func (*Comments) AfterBlock Uses

func (c *Comments) AfterBlock()

AfterBlock will mark the context as being after a block.

func (*Comments) AtLineBreak Uses

func (c *Comments) AtLineBreak()

AtLineBreak will mark a line break

func (*Comments) Fetch Uses

func (c *Comments) Fetch() []*Comment

Fetch returns all the currently scanned comments

func (*Comments) FetchAll Uses

func (c *Comments) FetchAll() []*Comment

FetchAll returns all the currently scanned comments, including those from the next line

func (*Comments) MarkComments Uses

func (c *Comments) MarkComments(position CommentPosition)

MarkComments will mark the found comments as the given position.

func (*Comments) MarkPrimary Uses

func (c *Comments) MarkPrimary()

MarkPrimary will mark the context as processing a primary expression

func (*Comments) PostProcessNode Uses

func (c *Comments) PostProcessNode(node Node)

PostProcessNode applies all found comments to the given node

func (*Comments) ResetLineBreak Uses

func (c *Comments) ResetLineBreak()

ResetLineBreak marks the beginning of a new statement

func (*Comments) SetExpression Uses

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.

func (*Comments) String Uses

func (c *Comments) String() string

func (*Comments) Unset Uses

func (c *Comments) Unset()

Unset the current node and apply the comments to the current expression. Resets context variables.

type ConditionalExpression Uses

type ConditionalExpression struct {
    Test       Expression
    Consequent Expression
    Alternate  Expression
}

func (*ConditionalExpression) Idx0 Uses

func (self *ConditionalExpression) Idx0() file.Idx

func (*ConditionalExpression) Idx1 Uses

func (self *ConditionalExpression) Idx1() file.Idx

type DebuggerStatement Uses

type DebuggerStatement struct {
    Debugger file.Idx
}

func (*DebuggerStatement) Idx0 Uses

func (self *DebuggerStatement) Idx0() file.Idx

func (*DebuggerStatement) Idx1 Uses

func (self *DebuggerStatement) Idx1() file.Idx

type Declaration Uses

type Declaration interface {
    // contains filtered or unexported methods
}

All declaration nodes implement the Declaration interface.

type DoWhileStatement Uses

type DoWhileStatement struct {
    Do   file.Idx
    Test Expression
    Body Statement
}

func (*DoWhileStatement) Idx0 Uses

func (self *DoWhileStatement) Idx0() file.Idx

func (*DoWhileStatement) Idx1 Uses

func (self *DoWhileStatement) Idx1() file.Idx

type DotExpression Uses

type DotExpression struct {
    Left       Expression
    Identifier *Identifier
}

func (*DotExpression) Idx0 Uses

func (self *DotExpression) Idx0() file.Idx

func (*DotExpression) Idx1 Uses

func (self *DotExpression) Idx1() file.Idx

type EmptyExpression Uses

type EmptyExpression struct {
    Begin file.Idx
    End   file.Idx
}

func (*EmptyExpression) Idx0 Uses

func (self *EmptyExpression) Idx0() file.Idx

func (*EmptyExpression) Idx1 Uses

func (self *EmptyExpression) Idx1() file.Idx

type EmptyStatement Uses

type EmptyStatement struct {
    Semicolon file.Idx
}

func (*EmptyStatement) Idx0 Uses

func (self *EmptyStatement) Idx0() file.Idx

func (*EmptyStatement) Idx1 Uses

func (self *EmptyStatement) Idx1() file.Idx

type Expression Uses

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

All expression nodes implement the Expression interface.

type ExpressionStatement Uses

type ExpressionStatement struct {
    Expression Expression
}

func (*ExpressionStatement) Idx0 Uses

func (self *ExpressionStatement) Idx0() file.Idx

func (*ExpressionStatement) Idx1 Uses

func (self *ExpressionStatement) Idx1() file.Idx

type ForInStatement Uses

type ForInStatement struct {
    For    file.Idx
    Into   Expression
    Source Expression
    Body   Statement
}

func (*ForInStatement) Idx0 Uses

func (self *ForInStatement) Idx0() file.Idx

func (*ForInStatement) Idx1 Uses

func (self *ForInStatement) Idx1() file.Idx

type ForStatement Uses

type ForStatement struct {
    For         file.Idx
    Initializer Expression
    Update      Expression
    Test        Expression
    Body        Statement
}

func (*ForStatement) Idx0 Uses

func (self *ForStatement) Idx0() file.Idx

func (*ForStatement) Idx1 Uses

func (self *ForStatement) Idx1() file.Idx

type FunctionDeclaration Uses

type FunctionDeclaration struct {
    Function *FunctionLiteral
}

type FunctionLiteral Uses

type FunctionLiteral struct {
    Function      file.Idx
    Name          *Identifier
    ParameterList *ParameterList
    Body          Statement
    Source        string

    DeclarationList []Declaration
}

func (*FunctionLiteral) Idx0 Uses

func (self *FunctionLiteral) Idx0() file.Idx

func (*FunctionLiteral) Idx1 Uses

func (self *FunctionLiteral) Idx1() file.Idx

type FunctionStatement Uses

type FunctionStatement struct {
    Function *FunctionLiteral
}

func (*FunctionStatement) Idx0 Uses

func (self *FunctionStatement) Idx0() file.Idx

func (*FunctionStatement) Idx1 Uses

func (self *FunctionStatement) Idx1() file.Idx

type Identifier Uses

type Identifier struct {
    Name string
    Idx  file.Idx
}

func (*Identifier) Idx0 Uses

func (self *Identifier) Idx0() file.Idx

func (*Identifier) Idx1 Uses

func (self *Identifier) Idx1() file.Idx

type IfStatement Uses

type IfStatement struct {
    If         file.Idx
    Test       Expression
    Consequent Statement
    Alternate  Statement
}

func (*IfStatement) Idx0 Uses

func (self *IfStatement) Idx0() file.Idx

func (*IfStatement) Idx1 Uses

func (self *IfStatement) Idx1() file.Idx

type LabelledStatement Uses

type LabelledStatement struct {
    Label     *Identifier
    Colon     file.Idx
    Statement Statement
}

func (*LabelledStatement) Idx0 Uses

func (self *LabelledStatement) Idx0() file.Idx

func (*LabelledStatement) Idx1 Uses

func (self *LabelledStatement) Idx1() file.Idx

type NewExpression Uses

type NewExpression struct {
    New              file.Idx
    Callee           Expression
    LeftParenthesis  file.Idx
    ArgumentList     []Expression
    RightParenthesis file.Idx
}

func (*NewExpression) Idx0 Uses

func (self *NewExpression) Idx0() file.Idx

func (*NewExpression) Idx1 Uses

func (self *NewExpression) Idx1() file.Idx

type Node Uses

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
}

All nodes implement the Node interface.

type NullLiteral Uses

type NullLiteral struct {
    Idx     file.Idx
    Literal string
}

func (*NullLiteral) Idx0 Uses

func (self *NullLiteral) Idx0() file.Idx

func (*NullLiteral) Idx1 Uses

func (self *NullLiteral) Idx1() file.Idx

type NumberLiteral Uses

type NumberLiteral struct {
    Idx     file.Idx
    Literal string
    Value   interface{}
}

func (*NumberLiteral) Idx0 Uses

func (self *NumberLiteral) Idx0() file.Idx

func (*NumberLiteral) Idx1 Uses

func (self *NumberLiteral) Idx1() file.Idx

type ObjectLiteral Uses

type ObjectLiteral struct {
    LeftBrace  file.Idx
    RightBrace file.Idx
    Value      []Property
}

func (*ObjectLiteral) Idx0 Uses

func (self *ObjectLiteral) Idx0() file.Idx

func (*ObjectLiteral) Idx1 Uses

func (self *ObjectLiteral) Idx1() file.Idx

type ParameterList Uses

type ParameterList struct {
    Opening file.Idx
    List    []*Identifier
    Closing file.Idx
}

type Program Uses

type Program struct {
    Body []Statement

    DeclarationList []Declaration

    File *file.File

    Comments CommentMap
}

func (*Program) Idx0 Uses

func (self *Program) Idx0() file.Idx

func (*Program) Idx1 Uses

func (self *Program) Idx1() file.Idx

type Property Uses

type Property struct {
    Key   string
    Kind  string
    Value Expression
}

type RegExpLiteral Uses

type RegExpLiteral struct {
    Idx     file.Idx
    Literal string
    Pattern string
    Flags   string
    Value   string
}

func (*RegExpLiteral) Idx0 Uses

func (self *RegExpLiteral) Idx0() file.Idx

func (*RegExpLiteral) Idx1 Uses

func (self *RegExpLiteral) Idx1() file.Idx

type ReturnStatement Uses

type ReturnStatement struct {
    Return   file.Idx
    Argument Expression
}

func (*ReturnStatement) Idx0 Uses

func (self *ReturnStatement) Idx0() file.Idx

func (*ReturnStatement) Idx1 Uses

func (self *ReturnStatement) Idx1() file.Idx

type SequenceExpression Uses

type SequenceExpression struct {
    Sequence []Expression
}

func (*SequenceExpression) Idx0 Uses

func (self *SequenceExpression) Idx0() file.Idx

func (*SequenceExpression) Idx1 Uses

func (self *SequenceExpression) Idx1() file.Idx

type Statement Uses

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

All statement nodes implement the Statement interface.

type StringLiteral Uses

type StringLiteral struct {
    Idx     file.Idx
    Literal string
    Value   string
}

func (*StringLiteral) Idx0 Uses

func (self *StringLiteral) Idx0() file.Idx

func (*StringLiteral) Idx1 Uses

func (self *StringLiteral) Idx1() file.Idx

type SwitchStatement Uses

type SwitchStatement struct {
    Switch       file.Idx
    Discriminant Expression
    Default      int
    Body         []*CaseStatement
}

func (*SwitchStatement) Idx0 Uses

func (self *SwitchStatement) Idx0() file.Idx

func (*SwitchStatement) Idx1 Uses

func (self *SwitchStatement) Idx1() file.Idx

type ThisExpression Uses

type ThisExpression struct {
    Idx file.Idx
}

func (*ThisExpression) Idx0 Uses

func (self *ThisExpression) Idx0() file.Idx

func (*ThisExpression) Idx1 Uses

func (self *ThisExpression) Idx1() file.Idx

type ThrowStatement Uses

type ThrowStatement struct {
    Throw    file.Idx
    Argument Expression
}

func (*ThrowStatement) Idx0 Uses

func (self *ThrowStatement) Idx0() file.Idx

func (*ThrowStatement) Idx1 Uses

func (self *ThrowStatement) Idx1() file.Idx

type TryStatement Uses

type TryStatement struct {
    Try     file.Idx
    Body    Statement
    Catch   *CatchStatement
    Finally Statement
}

func (*TryStatement) Idx0 Uses

func (self *TryStatement) Idx0() file.Idx

func (*TryStatement) Idx1 Uses

func (self *TryStatement) Idx1() file.Idx

type UnaryExpression Uses

type UnaryExpression struct {
    Operator token.Token
    Idx      file.Idx // If a prefix operation
    Operand  Expression
    Postfix  bool
}

func (*UnaryExpression) Idx0 Uses

func (self *UnaryExpression) Idx0() file.Idx

func (*UnaryExpression) Idx1 Uses

func (self *UnaryExpression) Idx1() file.Idx

type VariableDeclaration Uses

type VariableDeclaration struct {
    Var  file.Idx
    List []*VariableExpression
}

type VariableExpression Uses

type VariableExpression struct {
    Name        string
    Idx         file.Idx
    Initializer Expression
}

func (*VariableExpression) Idx0 Uses

func (self *VariableExpression) Idx0() file.Idx

func (*VariableExpression) Idx1 Uses

func (self *VariableExpression) Idx1() file.Idx

type VariableStatement Uses

type VariableStatement struct {
    Var  file.Idx
    List []Expression
}

func (*VariableStatement) Idx0 Uses

func (self *VariableStatement) Idx0() file.Idx

func (*VariableStatement) Idx1 Uses

func (self *VariableStatement) Idx1() file.Idx

type Visitor Uses

type Visitor interface {
    Enter(n Node) (v Visitor)
    Exit(n Node)
}

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.

Code:

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)
}

type WhileStatement Uses

type WhileStatement struct {
    While file.Idx
    Test  Expression
    Body  Statement
}

func (*WhileStatement) Idx0 Uses

func (self *WhileStatement) Idx0() file.Idx

func (*WhileStatement) Idx1 Uses

func (self *WhileStatement) Idx1() file.Idx

type WithStatement Uses

type WithStatement struct {
    With   file.Idx
    Object Expression
    Body   Statement
}

func (*WithStatement) Idx0 Uses

func (self *WithStatement) Idx0() file.Idx

func (*WithStatement) Idx1 Uses

func (self *WithStatement) Idx1() file.Idx

Package ast imports 3 packages (graph) and is imported by 93 packages. Updated 2017-07-21. Refresh now. Tools for package owners.