func Quote(s string, b bool) string
Quote returns a Starlark literal that denotes s. If b, it returns a bytes literal.
func Walk(n Node, f func(Node) bool)
Walk traverses a syntax tree in depth-first order. It starts by calling f(n); n must not be nil. If f returns true, Walk calls itself recursively for each non-nil child of n. Walk then calls f(nil).
▹ Example
An AssignStmt represents an assignment:
x = 0 x, y = y, x x += 1
type AssignStmt struct {
OpPos Position
Op Token // = EQ | {PLUS,MINUS,STAR,PERCENT}_EQ
LHS Expr
RHS Expr
// contains filtered or unexported fields
}
func (cr *AssignStmt) AllocComments()
AllocComments enables comments to be associated with a syntax node.
func (cr AssignStmt) Comments() *Comments
Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.
func (x *AssignStmt) Span() (start, end Position)
A BinaryExpr represents a binary expression: X Op Y.
As a special case, BinaryExpr{Op:EQ} may also represent a named argument in a call f(k=v) or a named parameter in a function declaration def f(param=default).
type BinaryExpr struct {
X Expr
OpPos Position
Op Token
Y Expr
// contains filtered or unexported fields
}
func (cr *BinaryExpr) AllocComments()
AllocComments enables comments to be associated with a syntax node.
func (cr BinaryExpr) Comments() *Comments
Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.
func (x *BinaryExpr) Span() (start, end Position)
A BranchStmt changes the flow of control: break, continue, pass.
type BranchStmt struct {
Token Token // = BREAK | CONTINUE | PASS
TokenPos Position
// contains filtered or unexported fields
}
func (cr *BranchStmt) AllocComments()
AllocComments enables comments to be associated with a syntax node.
func (cr BranchStmt) Comments() *Comments
Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.
func (x *BranchStmt) Span() (start, end Position)
A CallExpr represents a function call expression: Fn(Args).
type CallExpr struct {
Fn Expr
Lparen Position
Args []Expr // arg = expr | ident=expr | *expr | **expr
Rparen Position
// contains filtered or unexported fields
}
func (cr *CallExpr) AllocComments()
AllocComments enables comments to be associated with a syntax node.
func (cr CallExpr) Comments() *Comments
Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.
func (x *CallExpr) Span() (start, end Position)
A Comment represents a single # comment.
type Comment struct {
Start Position
Text string // without trailing newline
}
Comments collects the comments associated with an expression.
type Comments struct {
Before []Comment // whole-line comments before this expression
Suffix []Comment // end-of-line comments after this expression (up to 1)
// For top-level expressions only, After lists whole-line
// comments following the expression.
After []Comment
}
A Comprehension represents a list or dict comprehension: [Body for ... if ...] or {Body for ... if ...}
type Comprehension struct {
Curly bool // {x:y for ...} or {x for ...}, not [x for ...]
Lbrack Position
Body Expr
Clauses []Node // = *ForClause | *IfClause
Rbrack Position
// contains filtered or unexported fields
}
func (cr *Comprehension) AllocComments()
AllocComments enables comments to be associated with a syntax node.
func (cr Comprehension) Comments() *Comments
Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.
func (x *Comprehension) Span() (start, end Position)
CondExpr represents the conditional: X if COND else ELSE.
type CondExpr struct {
If Position
Cond Expr
True Expr
ElsePos Position
False Expr
// contains filtered or unexported fields
}
func (cr *CondExpr) AllocComments()
AllocComments enables comments to be associated with a syntax node.
func (cr CondExpr) Comments() *Comments
Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.
func (x *CondExpr) Span() (start, end Position)
A DefStmt represents a function definition.
type DefStmt struct {
Def Position
Name *Ident
Params []Expr // param = ident | ident=expr | * | *ident | **ident
Body []Stmt
Function interface{} // a *resolve.Function, set by resolver
// contains filtered or unexported fields
}
func (cr *DefStmt) AllocComments()
AllocComments enables comments to be associated with a syntax node.
func (cr DefStmt) Comments() *Comments
Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.
func (x *DefStmt) Span() (start, end Position)
A DictEntry represents a dictionary entry: Key: Value. Used only within a DictExpr.
type DictEntry struct {
Key Expr
Colon Position
Value Expr
// contains filtered or unexported fields
}
func (cr *DictEntry) AllocComments()
AllocComments enables comments to be associated with a syntax node.
func (cr DictEntry) Comments() *Comments
Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.
func (x *DictEntry) Span() (start, end Position)
A DictExpr represents a dictionary literal: { List }.
type DictExpr struct {
Lbrace Position
List []Expr // all *DictEntrys
Rbrace Position
// contains filtered or unexported fields
}
func (cr *DictExpr) AllocComments()
AllocComments enables comments to be associated with a syntax node.
func (cr DictExpr) Comments() *Comments
Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.
func (x *DictExpr) Span() (start, end Position)
A DotExpr represents a field or method selector: X.Name.
type DotExpr struct {
X Expr
Dot Position
NamePos Position
Name *Ident
// contains filtered or unexported fields
}
func (cr *DotExpr) AllocComments()
AllocComments enables comments to be associated with a syntax node.
func (cr DotExpr) Comments() *Comments
Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.
func (x *DotExpr) Span() (start, end Position)
An Error describes the nature and position of a scanner or parser error.
type Error struct {
Pos Position
Msg string
}
func (e Error) Error() string
An Expr is a Starlark expression.
type Expr interface {
Node
// contains filtered or unexported methods
}
func ParseExpr(filename string, src interface{}, mode Mode) (expr Expr, err error)
ParseExpr parses a Starlark expression. A comma-separated list of expressions is parsed as a tuple. See Parse for explanation of parameters.
An ExprStmt is an expression evaluated for side effects.
type ExprStmt struct {
X Expr
// contains filtered or unexported fields
}
func (cr *ExprStmt) AllocComments()
AllocComments enables comments to be associated with a syntax node.
func (cr ExprStmt) Comments() *Comments
Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.
func (x *ExprStmt) Span() (start, end Position)
A File represents a Starlark file.
type File struct {
Path string
Stmts []Stmt
Module interface{} // a *resolve.Module, set by resolver
// contains filtered or unexported fields
}
func Parse(filename string, src interface{}, mode Mode) (f *File, err error)
Parse parses the input data and returns the corresponding parse tree.
If src != nil, ParseFile parses the source from src and the filename is only used when recording position information. The type of the argument for the src parameter must be string, []byte, io.Reader, or FilePortion. If src == nil, ParseFile parses the file specified by filename.
func ParseCompoundStmt(filename string, readline func() ([]byte, error)) (f *File, err error)
ParseCompoundStmt parses a single compound statement: a blank line, a def, for, while, or if statement, or a semicolon-separated list of simple statements followed by a newline. These are the units on which the REPL operates. ParseCompoundStmt does not consume any following input. The parser calls the readline function each time it needs a new line of input.
func (cr *File) AllocComments()
AllocComments enables comments to be associated with a syntax node.
func (cr File) Comments() *Comments
Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.
func (x *File) Span() (start, end Position)
A FilePortion describes the content of a portion of a file. Callers may provide a FilePortion for the src argument of Parse when the desired initial line and column numbers are not (1, 1), such as when an expression is parsed from within larger file.
type FilePortion struct {
Content []byte
FirstLine, FirstCol int32
}
A ForClause represents a for clause in a list comprehension: for Vars in X.
type ForClause struct {
For Position
Vars Expr // name, or tuple of names
In Position
X Expr
// contains filtered or unexported fields
}
func (cr *ForClause) AllocComments()
AllocComments enables comments to be associated with a syntax node.
func (cr ForClause) Comments() *Comments
Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.
func (x *ForClause) Span() (start, end Position)
A ForStmt represents a loop: for Vars in X: Body.
type ForStmt struct {
For Position
Vars Expr // name, or tuple of names
X Expr
Body []Stmt
// contains filtered or unexported fields
}
func (cr *ForStmt) AllocComments()
AllocComments enables comments to be associated with a syntax node.
func (cr ForStmt) Comments() *Comments
Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.
func (x *ForStmt) Span() (start, end Position)
An Ident represents an identifier.
type Ident struct {
NamePos Position
Name string
Binding interface{} // a *resolver.Binding, set by resolver
// contains filtered or unexported fields
}
func (cr *Ident) AllocComments()
AllocComments enables comments to be associated with a syntax node.
func (cr Ident) Comments() *Comments
Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.
func (x *Ident) Span() (start, end Position)
An IfClause represents an if clause in a list comprehension: if Cond.
type IfClause struct {
If Position
Cond Expr
// contains filtered or unexported fields
}
func (cr *IfClause) AllocComments()
AllocComments enables comments to be associated with a syntax node.
func (cr IfClause) Comments() *Comments
Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.
func (x *IfClause) Span() (start, end Position)
An IfStmt is a conditional: If Cond: True; else: False. 'elseif' is desugared into a chain of IfStmts.
type IfStmt struct {
If Position // IF or ELIF
Cond Expr
True []Stmt
ElsePos Position // ELSE or ELIF
False []Stmt // optional
// contains filtered or unexported fields
}
func (cr *IfStmt) AllocComments()
AllocComments enables comments to be associated with a syntax node.
func (cr IfStmt) Comments() *Comments
Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.
func (x *IfStmt) Span() (start, end Position)
An IndexExpr represents an index expression: X[Y].
type IndexExpr struct {
X Expr
Lbrack Position
Y Expr
Rbrack Position
// contains filtered or unexported fields
}
func (cr *IndexExpr) AllocComments()
AllocComments enables comments to be associated with a syntax node.
func (cr IndexExpr) Comments() *Comments
Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.
func (x *IndexExpr) Span() (start, end Position)
A LambdaExpr represents an inline function abstraction.
type LambdaExpr struct {
Lambda Position
Params []Expr // param = ident | ident=expr | * | *ident | **ident
Body Expr
Function interface{} // a *resolve.Function, set by resolver
// contains filtered or unexported fields
}
func (cr *LambdaExpr) AllocComments()
AllocComments enables comments to be associated with a syntax node.
func (cr LambdaExpr) Comments() *Comments
Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.
func (x *LambdaExpr) Span() (start, end Position)
A ListExpr represents a list literal: [ List ].
type ListExpr struct {
Lbrack Position
List []Expr
Rbrack Position
// contains filtered or unexported fields
}
func (cr *ListExpr) AllocComments()
AllocComments enables comments to be associated with a syntax node.
func (cr ListExpr) Comments() *Comments
Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.
func (x *ListExpr) Span() (start, end Position)
A Literal represents a literal string or number.
type Literal struct {
Token Token // = STRING | BYTES | INT | FLOAT
TokenPos Position
Raw string // uninterpreted text
Value interface{} // = string | int64 | *big.Int | float64
// contains filtered or unexported fields
}
func (cr *Literal) AllocComments()
AllocComments enables comments to be associated with a syntax node.
func (cr Literal) Comments() *Comments
Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.
func (x *Literal) Span() (start, end Position)
A LoadStmt loads another module and binds names from it: load(Module, "x", y="foo").
The AST is slightly unfaithful to the concrete syntax here because Starlark's load statement, so that it can be implemented in Python, binds some names (like y above) with an identifier and some (like x) without. For consistency we create fake identifiers for all the strings.
type LoadStmt struct {
Load Position
Module *Literal // a string
From []*Ident // name defined in loading module
To []*Ident // name in loaded module
Rparen Position
// contains filtered or unexported fields
}
func (cr *LoadStmt) AllocComments()
AllocComments enables comments to be associated with a syntax node.
func (cr LoadStmt) Comments() *Comments
Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.
func (x *LoadStmt) ModuleName() string
ModuleName returns the name of the module loaded by this statement.
func (x *LoadStmt) Span() (start, end Position)
A Mode value is a set of flags (or 0) that controls optional parser functionality.
type Mode uint
const (
RetainComments Mode = 1 << iota // retain comments in AST; see Node.Comments
)
A Node is a node in a Starlark syntax tree.
type Node interface {
// Span returns the start and end position of the expression.
Span() (start, end Position)
// Comments returns the comments associated with this node.
// It returns nil if RetainComments was not specified during parsing,
// or if AllocComments was not called.
Comments() *Comments
// AllocComments allocates a new Comments node if there was none.
// This makes possible to add new comments using Comments() method.
AllocComments()
}
A ParenExpr represents a parenthesized expression: (X).
type ParenExpr struct {
Lparen Position
X Expr
Rparen Position
// contains filtered or unexported fields
}
func (cr *ParenExpr) AllocComments()
AllocComments enables comments to be associated with a syntax node.
func (cr ParenExpr) Comments() *Comments
Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.
func (x *ParenExpr) Span() (start, end Position)
A Position describes the location of a rune of input.
type Position struct {
Line int32 // 1-based line number; 0 if line unknown
Col int32 // 1-based column (rune) number; 0 if column unknown
// contains filtered or unexported fields
}
func End(n Node) Position
End returns the end position of the expression.
func MakePosition(file *string, line, col int32) Position
MakePosition returns position with the specified components.
func Start(n Node) Position
Start returns the start position of the expression.
func (p Position) Filename() string
Filename returns the name of the file containing this position.
func (p Position) IsValid() bool
IsValid reports whether the position is valid.
func (p Position) String() string
A ReturnStmt returns from a function.
type ReturnStmt struct {
Return Position
Result Expr // may be nil
// contains filtered or unexported fields
}
func (cr *ReturnStmt) AllocComments()
AllocComments enables comments to be associated with a syntax node.
func (cr ReturnStmt) Comments() *Comments
Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.
func (x *ReturnStmt) Span() (start, end Position)
A SliceExpr represents a slice or substring expression: X[Lo:Hi:Step].
type SliceExpr struct {
X Expr
Lbrack Position
Lo, Hi, Step Expr // all optional
Rbrack Position
// contains filtered or unexported fields
}
func (cr *SliceExpr) AllocComments()
AllocComments enables comments to be associated with a syntax node.
func (cr SliceExpr) Comments() *Comments
Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.
func (x *SliceExpr) Span() (start, end Position)
A Stmt is a Starlark statement.
type Stmt interface {
Node
// contains filtered or unexported methods
}
A Token represents a Starlark lexical token.
type Token int8
const (
ILLEGAL Token = iota
EOF
NEWLINE
INDENT
OUTDENT
// Tokens with values
IDENT // x
INT // 123
FLOAT // 1.23e45
STRING // "foo" or 'foo' or '''foo''' or r'foo' or r"foo"
BYTES // b"foo", etc
// Punctuation
PLUS // +
MINUS // -
STAR // *
SLASH // /
SLASHSLASH // //
PERCENT // %
AMP // &
PIPE // |
CIRCUMFLEX // ^
LTLT // <<
GTGT // >>
TILDE // ~
DOT // .
COMMA // ,
EQ // =
SEMI // ;
COLON // :
LPAREN // (
RPAREN // )
LBRACK // [
RBRACK // ]
LBRACE // {
RBRACE // }
LT // <
GT // >
GE // >=
LE // <=
EQL // ==
NEQ // !=
PLUS_EQ // += (keep order consistent with PLUS..GTGT)
MINUS_EQ // -=
STAR_EQ // *=
SLASH_EQ // /=
SLASHSLASH_EQ // //=
PERCENT_EQ // %=
AMP_EQ // &=
PIPE_EQ // |=
CIRCUMFLEX_EQ // ^=
LTLT_EQ // <<=
GTGT_EQ // >>=
STARSTAR // **
// Keywords
AND
BREAK
CONTINUE
DEF
ELIF
ELSE
FOR
IF
IN
LAMBDA
LOAD
NOT
NOT_IN // synthesized by parser from NOT IN
OR
PASS
RETURN
WHILE
)
func (tok Token) GoString() string
GoString is like String but quotes punctuation tokens. Use Sprintf("%#v", tok) when constructing error messages.
func (tok Token) String() string
A TupleExpr represents a tuple literal: (List).
type TupleExpr struct {
Lparen Position // optional (e.g. in x, y = 0, 1), but required if List is empty
List []Expr
Rparen Position
// contains filtered or unexported fields
}
func (cr *TupleExpr) AllocComments()
AllocComments enables comments to be associated with a syntax node.
func (cr TupleExpr) Comments() *Comments
Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.
func (x *TupleExpr) Span() (start, end Position)
A UnaryExpr represents a unary expression: Op X.
As a special case, UnaryOp{Op:Star} may also represent the star parameter in def f(*args) or def f(*, x).
type UnaryExpr struct {
OpPos Position
Op Token
X Expr // may be nil if Op==STAR
// contains filtered or unexported fields
}
func (cr *UnaryExpr) AllocComments()
AllocComments enables comments to be associated with a syntax node.
func (cr UnaryExpr) Comments() *Comments
Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.
func (x *UnaryExpr) Span() (start, end Position)
A WhileStmt represents a while loop: while X: Body.
type WhileStmt struct {
While Position
Cond Expr
Body []Stmt
// contains filtered or unexported fields
}
func (cr *WhileStmt) AllocComments()
AllocComments enables comments to be associated with a syntax node.
func (cr WhileStmt) Comments() *Comments
Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.
func (x *WhileStmt) Span() (start, end Position)