289b30715d
This commit converts the dependency management from Godeps to the vendor folder, also switching the tool from godep to trash. Since the upstream tool lacks a few features proposed via a few PRs, until those PRs are merged in (if), use github.com/karalabe/trash. You can update dependencies via trash --update. All dependencies have been updated to their latest version. Parts of the build system are reworked to drop old notions of Godeps and invocation of the go vet command so that it doesn't run against the vendor folder, as that will just blow up during vetting. The conversion drops OpenCL (and hence GPU mining support) from ethash and our codebase. The short reasoning is that there's noone to maintain and having opencl libs in our deps messes up builds as go install ./... tries to build them, failing with unsatisfied link errors for the C OpenCL deps. golang.org/x/net/context is not vendored in. We expect it to be fetched by the user (i.e. using go get). To keep ci.go builds reproducible the package is "vendored" in build/_vendor.
516 lines
15 KiB
Go
516 lines
15 KiB
Go
/*
|
|
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.
|
|
|
|
*/
|
|
package ast
|
|
|
|
import (
|
|
"github.com/robertkrimen/otto/file"
|
|
"github.com/robertkrimen/otto/token"
|
|
)
|
|
|
|
// All nodes implement the Node interface.
|
|
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
|
|
}
|
|
|
|
// ========== //
|
|
// Expression //
|
|
// ========== //
|
|
|
|
type (
|
|
// All expression nodes implement the Expression interface.
|
|
Expression interface {
|
|
Node
|
|
_expressionNode()
|
|
}
|
|
|
|
ArrayLiteral struct {
|
|
LeftBracket file.Idx
|
|
RightBracket file.Idx
|
|
Value []Expression
|
|
}
|
|
|
|
AssignExpression struct {
|
|
Operator token.Token
|
|
Left Expression
|
|
Right Expression
|
|
}
|
|
|
|
BadExpression struct {
|
|
From file.Idx
|
|
To file.Idx
|
|
}
|
|
|
|
BinaryExpression struct {
|
|
Operator token.Token
|
|
Left Expression
|
|
Right Expression
|
|
Comparison bool
|
|
}
|
|
|
|
BooleanLiteral struct {
|
|
Idx file.Idx
|
|
Literal string
|
|
Value bool
|
|
}
|
|
|
|
BracketExpression struct {
|
|
Left Expression
|
|
Member Expression
|
|
LeftBracket file.Idx
|
|
RightBracket file.Idx
|
|
}
|
|
|
|
CallExpression struct {
|
|
Callee Expression
|
|
LeftParenthesis file.Idx
|
|
ArgumentList []Expression
|
|
RightParenthesis file.Idx
|
|
}
|
|
|
|
ConditionalExpression struct {
|
|
Test Expression
|
|
Consequent Expression
|
|
Alternate Expression
|
|
}
|
|
|
|
DotExpression struct {
|
|
Left Expression
|
|
Identifier *Identifier
|
|
}
|
|
|
|
EmptyExpression struct {
|
|
Begin file.Idx
|
|
End file.Idx
|
|
}
|
|
|
|
FunctionLiteral struct {
|
|
Function file.Idx
|
|
Name *Identifier
|
|
ParameterList *ParameterList
|
|
Body Statement
|
|
Source string
|
|
|
|
DeclarationList []Declaration
|
|
}
|
|
|
|
Identifier struct {
|
|
Name string
|
|
Idx file.Idx
|
|
}
|
|
|
|
NewExpression struct {
|
|
New file.Idx
|
|
Callee Expression
|
|
LeftParenthesis file.Idx
|
|
ArgumentList []Expression
|
|
RightParenthesis file.Idx
|
|
}
|
|
|
|
NullLiteral struct {
|
|
Idx file.Idx
|
|
Literal string
|
|
}
|
|
|
|
NumberLiteral struct {
|
|
Idx file.Idx
|
|
Literal string
|
|
Value interface{}
|
|
}
|
|
|
|
ObjectLiteral struct {
|
|
LeftBrace file.Idx
|
|
RightBrace file.Idx
|
|
Value []Property
|
|
}
|
|
|
|
ParameterList struct {
|
|
Opening file.Idx
|
|
List []*Identifier
|
|
Closing file.Idx
|
|
}
|
|
|
|
Property struct {
|
|
Key string
|
|
Kind string
|
|
Value Expression
|
|
}
|
|
|
|
RegExpLiteral struct {
|
|
Idx file.Idx
|
|
Literal string
|
|
Pattern string
|
|
Flags string
|
|
Value string
|
|
}
|
|
|
|
SequenceExpression struct {
|
|
Sequence []Expression
|
|
}
|
|
|
|
StringLiteral struct {
|
|
Idx file.Idx
|
|
Literal string
|
|
Value string
|
|
}
|
|
|
|
ThisExpression struct {
|
|
Idx file.Idx
|
|
}
|
|
|
|
UnaryExpression struct {
|
|
Operator token.Token
|
|
Idx file.Idx // If a prefix operation
|
|
Operand Expression
|
|
Postfix bool
|
|
}
|
|
|
|
VariableExpression struct {
|
|
Name string
|
|
Idx file.Idx
|
|
Initializer Expression
|
|
}
|
|
)
|
|
|
|
// _expressionNode
|
|
|
|
func (*ArrayLiteral) _expressionNode() {}
|
|
func (*AssignExpression) _expressionNode() {}
|
|
func (*BadExpression) _expressionNode() {}
|
|
func (*BinaryExpression) _expressionNode() {}
|
|
func (*BooleanLiteral) _expressionNode() {}
|
|
func (*BracketExpression) _expressionNode() {}
|
|
func (*CallExpression) _expressionNode() {}
|
|
func (*ConditionalExpression) _expressionNode() {}
|
|
func (*DotExpression) _expressionNode() {}
|
|
func (*EmptyExpression) _expressionNode() {}
|
|
func (*FunctionLiteral) _expressionNode() {}
|
|
func (*Identifier) _expressionNode() {}
|
|
func (*NewExpression) _expressionNode() {}
|
|
func (*NullLiteral) _expressionNode() {}
|
|
func (*NumberLiteral) _expressionNode() {}
|
|
func (*ObjectLiteral) _expressionNode() {}
|
|
func (*RegExpLiteral) _expressionNode() {}
|
|
func (*SequenceExpression) _expressionNode() {}
|
|
func (*StringLiteral) _expressionNode() {}
|
|
func (*ThisExpression) _expressionNode() {}
|
|
func (*UnaryExpression) _expressionNode() {}
|
|
func (*VariableExpression) _expressionNode() {}
|
|
|
|
// ========= //
|
|
// Statement //
|
|
// ========= //
|
|
|
|
type (
|
|
// All statement nodes implement the Statement interface.
|
|
Statement interface {
|
|
Node
|
|
_statementNode()
|
|
}
|
|
|
|
BadStatement struct {
|
|
From file.Idx
|
|
To file.Idx
|
|
}
|
|
|
|
BlockStatement struct {
|
|
LeftBrace file.Idx
|
|
List []Statement
|
|
RightBrace file.Idx
|
|
}
|
|
|
|
BranchStatement struct {
|
|
Idx file.Idx
|
|
Token token.Token
|
|
Label *Identifier
|
|
}
|
|
|
|
CaseStatement struct {
|
|
Case file.Idx
|
|
Test Expression
|
|
Consequent []Statement
|
|
}
|
|
|
|
CatchStatement struct {
|
|
Catch file.Idx
|
|
Parameter *Identifier
|
|
Body Statement
|
|
}
|
|
|
|
DebuggerStatement struct {
|
|
Debugger file.Idx
|
|
}
|
|
|
|
DoWhileStatement struct {
|
|
Do file.Idx
|
|
Test Expression
|
|
Body Statement
|
|
}
|
|
|
|
EmptyStatement struct {
|
|
Semicolon file.Idx
|
|
}
|
|
|
|
ExpressionStatement struct {
|
|
Expression Expression
|
|
}
|
|
|
|
ForInStatement struct {
|
|
For file.Idx
|
|
Into Expression
|
|
Source Expression
|
|
Body Statement
|
|
}
|
|
|
|
ForStatement struct {
|
|
For file.Idx
|
|
Initializer Expression
|
|
Update Expression
|
|
Test Expression
|
|
Body Statement
|
|
}
|
|
|
|
FunctionStatement struct {
|
|
Function *FunctionLiteral
|
|
}
|
|
|
|
IfStatement struct {
|
|
If file.Idx
|
|
Test Expression
|
|
Consequent Statement
|
|
Alternate Statement
|
|
}
|
|
|
|
LabelledStatement struct {
|
|
Label *Identifier
|
|
Colon file.Idx
|
|
Statement Statement
|
|
}
|
|
|
|
ReturnStatement struct {
|
|
Return file.Idx
|
|
Argument Expression
|
|
}
|
|
|
|
SwitchStatement struct {
|
|
Switch file.Idx
|
|
Discriminant Expression
|
|
Default int
|
|
Body []*CaseStatement
|
|
}
|
|
|
|
ThrowStatement struct {
|
|
Throw file.Idx
|
|
Argument Expression
|
|
}
|
|
|
|
TryStatement struct {
|
|
Try file.Idx
|
|
Body Statement
|
|
Catch *CatchStatement
|
|
Finally Statement
|
|
}
|
|
|
|
VariableStatement struct {
|
|
Var file.Idx
|
|
List []Expression
|
|
}
|
|
|
|
WhileStatement struct {
|
|
While file.Idx
|
|
Test Expression
|
|
Body Statement
|
|
}
|
|
|
|
WithStatement struct {
|
|
With file.Idx
|
|
Object Expression
|
|
Body Statement
|
|
}
|
|
)
|
|
|
|
// _statementNode
|
|
|
|
func (*BadStatement) _statementNode() {}
|
|
func (*BlockStatement) _statementNode() {}
|
|
func (*BranchStatement) _statementNode() {}
|
|
func (*CaseStatement) _statementNode() {}
|
|
func (*CatchStatement) _statementNode() {}
|
|
func (*DebuggerStatement) _statementNode() {}
|
|
func (*DoWhileStatement) _statementNode() {}
|
|
func (*EmptyStatement) _statementNode() {}
|
|
func (*ExpressionStatement) _statementNode() {}
|
|
func (*ForInStatement) _statementNode() {}
|
|
func (*ForStatement) _statementNode() {}
|
|
func (*FunctionStatement) _statementNode() {}
|
|
func (*IfStatement) _statementNode() {}
|
|
func (*LabelledStatement) _statementNode() {}
|
|
func (*ReturnStatement) _statementNode() {}
|
|
func (*SwitchStatement) _statementNode() {}
|
|
func (*ThrowStatement) _statementNode() {}
|
|
func (*TryStatement) _statementNode() {}
|
|
func (*VariableStatement) _statementNode() {}
|
|
func (*WhileStatement) _statementNode() {}
|
|
func (*WithStatement) _statementNode() {}
|
|
|
|
// =========== //
|
|
// Declaration //
|
|
// =========== //
|
|
|
|
type (
|
|
// All declaration nodes implement the Declaration interface.
|
|
Declaration interface {
|
|
_declarationNode()
|
|
}
|
|
|
|
FunctionDeclaration struct {
|
|
Function *FunctionLiteral
|
|
}
|
|
|
|
VariableDeclaration struct {
|
|
Var file.Idx
|
|
List []*VariableExpression
|
|
}
|
|
)
|
|
|
|
// _declarationNode
|
|
|
|
func (*FunctionDeclaration) _declarationNode() {}
|
|
func (*VariableDeclaration) _declarationNode() {}
|
|
|
|
// ==== //
|
|
// Node //
|
|
// ==== //
|
|
|
|
type Program struct {
|
|
Body []Statement
|
|
|
|
DeclarationList []Declaration
|
|
|
|
File *file.File
|
|
|
|
Comments CommentMap
|
|
}
|
|
|
|
// ==== //
|
|
// Idx0 //
|
|
// ==== //
|
|
|
|
func (self *ArrayLiteral) Idx0() file.Idx { return self.LeftBracket }
|
|
func (self *AssignExpression) Idx0() file.Idx { return self.Left.Idx0() }
|
|
func (self *BadExpression) Idx0() file.Idx { return self.From }
|
|
func (self *BinaryExpression) Idx0() file.Idx { return self.Left.Idx0() }
|
|
func (self *BooleanLiteral) Idx0() file.Idx { return self.Idx }
|
|
func (self *BracketExpression) Idx0() file.Idx { return self.Left.Idx0() }
|
|
func (self *CallExpression) Idx0() file.Idx { return self.Callee.Idx0() }
|
|
func (self *ConditionalExpression) Idx0() file.Idx { return self.Test.Idx0() }
|
|
func (self *DotExpression) Idx0() file.Idx { return self.Left.Idx0() }
|
|
func (self *EmptyExpression) Idx0() file.Idx { return self.Begin }
|
|
func (self *FunctionLiteral) Idx0() file.Idx { return self.Function }
|
|
func (self *Identifier) Idx0() file.Idx { return self.Idx }
|
|
func (self *NewExpression) Idx0() file.Idx { return self.New }
|
|
func (self *NullLiteral) Idx0() file.Idx { return self.Idx }
|
|
func (self *NumberLiteral) Idx0() file.Idx { return self.Idx }
|
|
func (self *ObjectLiteral) Idx0() file.Idx { return self.LeftBrace }
|
|
func (self *RegExpLiteral) Idx0() file.Idx { return self.Idx }
|
|
func (self *SequenceExpression) Idx0() file.Idx { return self.Sequence[0].Idx0() }
|
|
func (self *StringLiteral) Idx0() file.Idx { return self.Idx }
|
|
func (self *ThisExpression) Idx0() file.Idx { return self.Idx }
|
|
func (self *UnaryExpression) Idx0() file.Idx { return self.Idx }
|
|
func (self *VariableExpression) Idx0() file.Idx { return self.Idx }
|
|
|
|
func (self *BadStatement) Idx0() file.Idx { return self.From }
|
|
func (self *BlockStatement) Idx0() file.Idx { return self.LeftBrace }
|
|
func (self *BranchStatement) Idx0() file.Idx { return self.Idx }
|
|
func (self *CaseStatement) Idx0() file.Idx { return self.Case }
|
|
func (self *CatchStatement) Idx0() file.Idx { return self.Catch }
|
|
func (self *DebuggerStatement) Idx0() file.Idx { return self.Debugger }
|
|
func (self *DoWhileStatement) Idx0() file.Idx { return self.Do }
|
|
func (self *EmptyStatement) Idx0() file.Idx { return self.Semicolon }
|
|
func (self *ExpressionStatement) Idx0() file.Idx { return self.Expression.Idx0() }
|
|
func (self *ForInStatement) Idx0() file.Idx { return self.For }
|
|
func (self *ForStatement) Idx0() file.Idx { return self.For }
|
|
func (self *FunctionStatement) Idx0() file.Idx { return self.Function.Idx0() }
|
|
func (self *IfStatement) Idx0() file.Idx { return self.If }
|
|
func (self *LabelledStatement) Idx0() file.Idx { return self.Label.Idx0() }
|
|
func (self *Program) Idx0() file.Idx { return self.Body[0].Idx0() }
|
|
func (self *ReturnStatement) Idx0() file.Idx { return self.Return }
|
|
func (self *SwitchStatement) Idx0() file.Idx { return self.Switch }
|
|
func (self *ThrowStatement) Idx0() file.Idx { return self.Throw }
|
|
func (self *TryStatement) Idx0() file.Idx { return self.Try }
|
|
func (self *VariableStatement) Idx0() file.Idx { return self.Var }
|
|
func (self *WhileStatement) Idx0() file.Idx { return self.While }
|
|
func (self *WithStatement) Idx0() file.Idx { return self.With }
|
|
|
|
// ==== //
|
|
// Idx1 //
|
|
// ==== //
|
|
|
|
func (self *ArrayLiteral) Idx1() file.Idx { return self.RightBracket }
|
|
func (self *AssignExpression) Idx1() file.Idx { return self.Right.Idx1() }
|
|
func (self *BadExpression) Idx1() file.Idx { return self.To }
|
|
func (self *BinaryExpression) Idx1() file.Idx { return self.Right.Idx1() }
|
|
func (self *BooleanLiteral) Idx1() file.Idx { return file.Idx(int(self.Idx) + len(self.Literal)) }
|
|
func (self *BracketExpression) Idx1() file.Idx { return self.RightBracket + 1 }
|
|
func (self *CallExpression) Idx1() file.Idx { return self.RightParenthesis + 1 }
|
|
func (self *ConditionalExpression) Idx1() file.Idx { return self.Test.Idx1() }
|
|
func (self *DotExpression) Idx1() file.Idx { return self.Identifier.Idx1() }
|
|
func (self *EmptyExpression) Idx1() file.Idx { return self.End }
|
|
func (self *FunctionLiteral) Idx1() file.Idx { return self.Body.Idx1() }
|
|
func (self *Identifier) Idx1() file.Idx { return file.Idx(int(self.Idx) + len(self.Name)) }
|
|
func (self *NewExpression) Idx1() file.Idx { return self.RightParenthesis + 1 }
|
|
func (self *NullLiteral) Idx1() file.Idx { return file.Idx(int(self.Idx) + 4) } // "null"
|
|
func (self *NumberLiteral) Idx1() file.Idx { return file.Idx(int(self.Idx) + len(self.Literal)) }
|
|
func (self *ObjectLiteral) Idx1() file.Idx { return self.RightBrace }
|
|
func (self *RegExpLiteral) Idx1() file.Idx { return file.Idx(int(self.Idx) + len(self.Literal)) }
|
|
func (self *SequenceExpression) Idx1() file.Idx { return self.Sequence[0].Idx1() }
|
|
func (self *StringLiteral) Idx1() file.Idx { return file.Idx(int(self.Idx) + len(self.Literal)) }
|
|
func (self *ThisExpression) Idx1() file.Idx { return self.Idx }
|
|
func (self *UnaryExpression) Idx1() file.Idx {
|
|
if self.Postfix {
|
|
return self.Operand.Idx1() + 2 // ++ --
|
|
}
|
|
return self.Operand.Idx1()
|
|
}
|
|
func (self *VariableExpression) Idx1() file.Idx {
|
|
if self.Initializer == nil {
|
|
return file.Idx(int(self.Idx) + len(self.Name) + 1)
|
|
}
|
|
return self.Initializer.Idx1()
|
|
}
|
|
|
|
func (self *BadStatement) Idx1() file.Idx { return self.To }
|
|
func (self *BlockStatement) Idx1() file.Idx { return self.RightBrace + 1 }
|
|
func (self *BranchStatement) Idx1() file.Idx { return self.Idx }
|
|
func (self *CaseStatement) Idx1() file.Idx { return self.Consequent[len(self.Consequent)-1].Idx1() }
|
|
func (self *CatchStatement) Idx1() file.Idx { return self.Body.Idx1() }
|
|
func (self *DebuggerStatement) Idx1() file.Idx { return self.Debugger + 8 }
|
|
func (self *DoWhileStatement) Idx1() file.Idx { return self.Test.Idx1() }
|
|
func (self *EmptyStatement) Idx1() file.Idx { return self.Semicolon + 1 }
|
|
func (self *ExpressionStatement) Idx1() file.Idx { return self.Expression.Idx1() }
|
|
func (self *ForInStatement) Idx1() file.Idx { return self.Body.Idx1() }
|
|
func (self *ForStatement) Idx1() file.Idx { return self.Body.Idx1() }
|
|
func (self *FunctionStatement) Idx1() file.Idx { return self.Function.Idx1() }
|
|
func (self *IfStatement) Idx1() file.Idx {
|
|
if self.Alternate != nil {
|
|
return self.Alternate.Idx1()
|
|
}
|
|
return self.Consequent.Idx1()
|
|
}
|
|
func (self *LabelledStatement) Idx1() file.Idx { return self.Colon + 1 }
|
|
func (self *Program) Idx1() file.Idx { return self.Body[len(self.Body)-1].Idx1() }
|
|
func (self *ReturnStatement) Idx1() file.Idx { return self.Return }
|
|
func (self *SwitchStatement) Idx1() file.Idx { return self.Body[len(self.Body)-1].Idx1() }
|
|
func (self *ThrowStatement) Idx1() file.Idx { return self.Throw }
|
|
func (self *TryStatement) Idx1() file.Idx { return self.Try }
|
|
func (self *VariableStatement) Idx1() file.Idx { return self.List[len(self.List)-1].Idx1() }
|
|
func (self *WhileStatement) Idx1() file.Idx { return self.Body.Idx1() }
|
|
func (self *WithStatement) Idx1() file.Idx { return self.Body.Idx1() }
|