go.starlark.net: go.starlark.net/syntax Index | Examples | Files

package syntax

import "go.starlark.net/syntax"

Package syntax provides a Starlark parser and abstract syntax tree.

Index

Examples

Package Files

parse.go quote.go scan.go syntax.go walk.go

func Walk Uses

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

ExampleWalk demonstrates the use of Walk to enumerate the identifiers in a Starlark source file containing a nonsense program with varied grammar.

Code:

const src = `
load("library", "a")

def b(c, *, d=e):
f += {g: h}
i = -(j)
return k.l[m + n]

for o in [p for q, r in s if t]:
u(lambda: v, w[x:y:z])
`
f, err := syntax.Parse("hello.star", src, 0)
if err != nil {
    log.Fatal(err)
}

var idents []string
syntax.Walk(f, func(n syntax.Node) bool {
    if id, ok := n.(*syntax.Ident); ok {
        idents = append(idents, id.Name)
    }
    return true
})
fmt.Println(strings.Join(idents, " "))

// The identifer 'a' appears in both LoadStmt.From[0] and LoadStmt.To[0].

Output:

a a b c d e f g h i j k l m n o p q r s t u v w x y z

type AssignStmt Uses

type AssignStmt struct {
    OpPos Position
    Op    Token // = EQ | {PLUS,MINUS,STAR,PERCENT}_EQ
    LHS   Expr
    RHS   Expr
    // contains filtered or unexported fields
}

An AssignStmt represents an assignment:

x = 0
x, y = y, x
x += 1

func (*AssignStmt) AllocComments Uses

func (cr *AssignStmt) AllocComments()

AllocComments enables comments to be associated with a syntax node.

func (AssignStmt) Comments Uses

func (cr AssignStmt) Comments() *Comments

Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.

func (*AssignStmt) Span Uses

func (x *AssignStmt) Span() (start, end Position)

type BinaryExpr Uses

type BinaryExpr struct {
    X     Expr
    OpPos Position
    Op    Token
    Y     Expr
    // contains filtered or unexported fields
}

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

func (*BinaryExpr) AllocComments Uses

func (cr *BinaryExpr) AllocComments()

AllocComments enables comments to be associated with a syntax node.

func (BinaryExpr) Comments Uses

func (cr BinaryExpr) Comments() *Comments

Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.

func (*BinaryExpr) Span Uses

func (x *BinaryExpr) Span() (start, end Position)

type BranchStmt Uses

type BranchStmt struct {
    Token    Token // = BREAK | CONTINUE | PASS
    TokenPos Position
    // contains filtered or unexported fields
}

A BranchStmt changes the flow of control: break, continue, pass.

func (*BranchStmt) AllocComments Uses

func (cr *BranchStmt) AllocComments()

AllocComments enables comments to be associated with a syntax node.

func (BranchStmt) Comments Uses

func (cr BranchStmt) Comments() *Comments

Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.

func (*BranchStmt) Span Uses

func (x *BranchStmt) Span() (start, end Position)

type CallExpr Uses

type CallExpr struct {
    Fn     Expr
    Lparen Position
    Args   []Expr // arg = expr | ident=expr | *expr | **expr
    Rparen Position
    // contains filtered or unexported fields
}

A CallExpr represents a function call expression: Fn(Args).

func (*CallExpr) AllocComments Uses

func (cr *CallExpr) AllocComments()

AllocComments enables comments to be associated with a syntax node.

func (CallExpr) Comments Uses

func (cr CallExpr) Comments() *Comments

Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.

func (*CallExpr) Span Uses

func (x *CallExpr) Span() (start, end Position)

type Comment Uses

type Comment struct {
    Start Position
    Text  string // without trailing newline
}

A Comment represents a single # comment.

type Comments Uses

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
}

Comments collects the comments associated with an expression.

type Comprehension Uses

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
}

A Comprehension represents a list or dict comprehension: [Body for ... if ...] or {Body for ... if ...}

func (*Comprehension) AllocComments Uses

func (cr *Comprehension) AllocComments()

AllocComments enables comments to be associated with a syntax node.

func (Comprehension) Comments Uses

func (cr Comprehension) Comments() *Comments

Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.

func (*Comprehension) Span Uses

func (x *Comprehension) Span() (start, end Position)

type CondExpr Uses

type CondExpr struct {
    If      Position
    Cond    Expr
    True    Expr
    ElsePos Position
    False   Expr
    // contains filtered or unexported fields
}

CondExpr represents the conditional: X if COND else ELSE.

func (*CondExpr) AllocComments Uses

func (cr *CondExpr) AllocComments()

AllocComments enables comments to be associated with a syntax node.

func (CondExpr) Comments Uses

func (cr CondExpr) Comments() *Comments

Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.

func (*CondExpr) Span Uses

func (x *CondExpr) Span() (start, end Position)

type DefStmt Uses

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
}

A DefStmt represents a function definition.

func (*DefStmt) AllocComments Uses

func (cr *DefStmt) AllocComments()

AllocComments enables comments to be associated with a syntax node.

func (DefStmt) Comments Uses

func (cr DefStmt) Comments() *Comments

Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.

func (*DefStmt) Span Uses

func (x *DefStmt) Span() (start, end Position)

type DictEntry Uses

type DictEntry struct {
    Key   Expr
    Colon Position
    Value Expr
    // contains filtered or unexported fields
}

A DictEntry represents a dictionary entry: Key: Value. Used only within a DictExpr.

func (*DictEntry) AllocComments Uses

func (cr *DictEntry) AllocComments()

AllocComments enables comments to be associated with a syntax node.

func (DictEntry) Comments Uses

func (cr DictEntry) Comments() *Comments

Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.

func (*DictEntry) Span Uses

func (x *DictEntry) Span() (start, end Position)

type DictExpr Uses

type DictExpr struct {
    Lbrace Position
    List   []Expr // all *DictEntrys
    Rbrace Position
    // contains filtered or unexported fields
}

A DictExpr represents a dictionary literal: { List }.

func (*DictExpr) AllocComments Uses

func (cr *DictExpr) AllocComments()

AllocComments enables comments to be associated with a syntax node.

func (DictExpr) Comments Uses

func (cr DictExpr) Comments() *Comments

Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.

func (*DictExpr) Span Uses

func (x *DictExpr) Span() (start, end Position)

type DotExpr Uses

type DotExpr struct {
    X       Expr
    Dot     Position
    NamePos Position
    Name    *Ident
    // contains filtered or unexported fields
}

A DotExpr represents a field or method selector: X.Name.

func (*DotExpr) AllocComments Uses

func (cr *DotExpr) AllocComments()

AllocComments enables comments to be associated with a syntax node.

func (DotExpr) Comments Uses

func (cr DotExpr) Comments() *Comments

Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.

func (*DotExpr) Span Uses

func (x *DotExpr) Span() (start, end Position)

type Error Uses

type Error struct {
    Pos Position
    Msg string
}

An Error describes the nature and position of a scanner or parser error.

func (Error) Error Uses

func (e Error) Error() string

type Expr Uses

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

An Expr is a Starlark expression.

func ParseExpr Uses

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.

type ExprStmt Uses

type ExprStmt struct {
    X Expr
    // contains filtered or unexported fields
}

An ExprStmt is an expression evaluated for side effects.

func (*ExprStmt) AllocComments Uses

func (cr *ExprStmt) AllocComments()

AllocComments enables comments to be associated with a syntax node.

func (ExprStmt) Comments Uses

func (cr ExprStmt) Comments() *Comments

Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.

func (*ExprStmt) Span Uses

func (x *ExprStmt) Span() (start, end Position)

type File Uses

type File struct {
    Path  string
    Stmts []Stmt

    Module interface{} // a *resolve.Module, set by resolver
    // contains filtered or unexported fields
}

A File represents a Starlark file.

func Parse Uses

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, or io.Reader. If src == nil, ParseFile parses the file specified by filename.

func ParseCompoundStmt Uses

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 (*File) AllocComments Uses

func (cr *File) AllocComments()

AllocComments enables comments to be associated with a syntax node.

func (File) Comments Uses

func (cr File) Comments() *Comments

Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.

func (*File) Span Uses

func (x *File) Span() (start, end Position)

type ForClause Uses

type ForClause struct {
    For  Position
    Vars Expr // name, or tuple of names
    In   Position
    X    Expr
    // contains filtered or unexported fields
}

A ForClause represents a for clause in a list comprehension: for Vars in X.

func (*ForClause) AllocComments Uses

func (cr *ForClause) AllocComments()

AllocComments enables comments to be associated with a syntax node.

func (ForClause) Comments Uses

func (cr ForClause) Comments() *Comments

Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.

func (*ForClause) Span Uses

func (x *ForClause) Span() (start, end Position)

type ForStmt Uses

type ForStmt struct {
    For  Position
    Vars Expr // name, or tuple of names
    X    Expr
    Body []Stmt
    // contains filtered or unexported fields
}

A ForStmt represents a loop: for Vars in X: Body.

func (*ForStmt) AllocComments Uses

func (cr *ForStmt) AllocComments()

AllocComments enables comments to be associated with a syntax node.

func (ForStmt) Comments Uses

func (cr ForStmt) Comments() *Comments

Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.

func (*ForStmt) Span Uses

func (x *ForStmt) Span() (start, end Position)

type Ident Uses

type Ident struct {
    NamePos Position
    Name    string

    Binding interface{} // a *resolver.Binding, set by resolver
    // contains filtered or unexported fields
}

An Ident represents an identifier.

func (*Ident) AllocComments Uses

func (cr *Ident) AllocComments()

AllocComments enables comments to be associated with a syntax node.

func (Ident) Comments Uses

func (cr Ident) Comments() *Comments

Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.

func (*Ident) Span Uses

func (x *Ident) Span() (start, end Position)

type IfClause Uses

type IfClause struct {
    If   Position
    Cond Expr
    // contains filtered or unexported fields
}

An IfClause represents an if clause in a list comprehension: if Cond.

func (*IfClause) AllocComments Uses

func (cr *IfClause) AllocComments()

AllocComments enables comments to be associated with a syntax node.

func (IfClause) Comments Uses

func (cr IfClause) Comments() *Comments

Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.

func (*IfClause) Span Uses

func (x *IfClause) Span() (start, end Position)

type IfStmt Uses

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
}

An IfStmt is a conditional: If Cond: True; else: False. 'elseif' is desugared into a chain of IfStmts.

func (*IfStmt) AllocComments Uses

func (cr *IfStmt) AllocComments()

AllocComments enables comments to be associated with a syntax node.

func (IfStmt) Comments Uses

func (cr IfStmt) Comments() *Comments

Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.

func (*IfStmt) Span Uses

func (x *IfStmt) Span() (start, end Position)

type IndexExpr Uses

type IndexExpr struct {
    X      Expr
    Lbrack Position
    Y      Expr
    Rbrack Position
    // contains filtered or unexported fields
}

An IndexExpr represents an index expression: X[Y].

func (*IndexExpr) AllocComments Uses

func (cr *IndexExpr) AllocComments()

AllocComments enables comments to be associated with a syntax node.

func (IndexExpr) Comments Uses

func (cr IndexExpr) Comments() *Comments

Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.

func (*IndexExpr) Span Uses

func (x *IndexExpr) Span() (start, end Position)

type LambdaExpr Uses

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
}

A LambdaExpr represents an inline function abstraction.

Although they may be added in future, lambda expressions are not currently part of the Starlark spec, so their use is controlled by the resolver.AllowLambda flag.

func (*LambdaExpr) AllocComments Uses

func (cr *LambdaExpr) AllocComments()

AllocComments enables comments to be associated with a syntax node.

func (LambdaExpr) Comments Uses

func (cr LambdaExpr) Comments() *Comments

Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.

func (*LambdaExpr) Span Uses

func (x *LambdaExpr) Span() (start, end Position)

type ListExpr Uses

type ListExpr struct {
    Lbrack Position
    List   []Expr
    Rbrack Position
    // contains filtered or unexported fields
}

A ListExpr represents a list literal: [ List ].

func (*ListExpr) AllocComments Uses

func (cr *ListExpr) AllocComments()

AllocComments enables comments to be associated with a syntax node.

func (ListExpr) Comments Uses

func (cr ListExpr) Comments() *Comments

Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.

func (*ListExpr) Span Uses

func (x *ListExpr) Span() (start, end Position)

type Literal Uses

type Literal struct {
    Token    Token // = STRING | INT
    TokenPos Position
    Raw      string      // uninterpreted text
    Value    interface{} // = string | int64 | *big.Int
    // contains filtered or unexported fields
}

A Literal represents a literal string or number.

func (*Literal) AllocComments Uses

func (cr *Literal) AllocComments()

AllocComments enables comments to be associated with a syntax node.

func (Literal) Comments Uses

func (cr Literal) Comments() *Comments

Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.

func (*Literal) Span Uses

func (x *Literal) Span() (start, end Position)

type LoadStmt Uses

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
}

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.

func (*LoadStmt) AllocComments Uses

func (cr *LoadStmt) AllocComments()

AllocComments enables comments to be associated with a syntax node.

func (LoadStmt) Comments Uses

func (cr LoadStmt) Comments() *Comments

Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.

func (*LoadStmt) ModuleName Uses

func (x *LoadStmt) ModuleName() string

ModuleName returns the name of the module loaded by this statement.

func (*LoadStmt) Span Uses

func (x *LoadStmt) Span() (start, end Position)

type Mode Uses

type Mode uint

A Mode value is a set of flags (or 0) that controls optional parser functionality.

const (
    RetainComments Mode = 1 << iota // retain comments in AST; see Node.Comments
)

type Node Uses

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 Node is a node in a Starlark syntax tree.

type ParenExpr Uses

type ParenExpr struct {
    Lparen Position
    X      Expr
    Rparen Position
    // contains filtered or unexported fields
}

A ParenExpr represents a parenthesized expression: (X).

func (*ParenExpr) AllocComments Uses

func (cr *ParenExpr) AllocComments()

AllocComments enables comments to be associated with a syntax node.

func (ParenExpr) Comments Uses

func (cr ParenExpr) Comments() *Comments

Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.

func (*ParenExpr) Span Uses

func (x *ParenExpr) Span() (start, end Position)

type Position Uses

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
}

A Position describes the location of a rune of input.

func End Uses

func End(n Node) Position

End returns the end position of the expression.

func MakePosition Uses

func MakePosition(file *string, line, col int32) Position

MakePosition returns position with the specified components.

func Start Uses

func Start(n Node) Position

Start returns the start position of the expression.

func (Position) Filename Uses

func (p Position) Filename() string

Filename returns the name of the file containing this position.

func (Position) IsValid Uses

func (p Position) IsValid() bool

IsValid reports whether the position is valid.

func (Position) String Uses

func (p Position) String() string

type ReturnStmt Uses

type ReturnStmt struct {
    Return Position
    Result Expr // may be nil
    // contains filtered or unexported fields
}

A ReturnStmt returns from a function.

func (*ReturnStmt) AllocComments Uses

func (cr *ReturnStmt) AllocComments()

AllocComments enables comments to be associated with a syntax node.

func (ReturnStmt) Comments Uses

func (cr ReturnStmt) Comments() *Comments

Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.

func (*ReturnStmt) Span Uses

func (x *ReturnStmt) Span() (start, end Position)

type SliceExpr Uses

type SliceExpr struct {
    X            Expr
    Lbrack       Position
    Lo, Hi, Step Expr // all optional
    Rbrack       Position
    // contains filtered or unexported fields
}

A SliceExpr represents a slice or substring expression: X[Lo:Hi:Step].

func (*SliceExpr) AllocComments Uses

func (cr *SliceExpr) AllocComments()

AllocComments enables comments to be associated with a syntax node.

func (SliceExpr) Comments Uses

func (cr SliceExpr) Comments() *Comments

Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.

func (*SliceExpr) Span Uses

func (x *SliceExpr) Span() (start, end Position)

type Stmt Uses

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

A Stmt is a Starlark statement.

type Token Uses

type Token int8

A Token represents a Starlark lexical token.

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"

    // 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 (Token) GoString Uses

func (tok Token) GoString() string

GoString is like String but quotes punctuation tokens. Use Sprintf("%#v", tok) when constructing error messages.

func (Token) String Uses

func (tok Token) String() string

type TupleExpr Uses

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
}

A TupleExpr represents a tuple literal: (List).

func (*TupleExpr) AllocComments Uses

func (cr *TupleExpr) AllocComments()

AllocComments enables comments to be associated with a syntax node.

func (TupleExpr) Comments Uses

func (cr TupleExpr) Comments() *Comments

Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.

func (*TupleExpr) Span Uses

func (x *TupleExpr) Span() (start, end Position)

type UnaryExpr Uses

type UnaryExpr struct {
    OpPos Position
    Op    Token
    X     Expr // may be nil if Op==STAR
    // contains filtered or unexported fields
}

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

func (*UnaryExpr) AllocComments Uses

func (cr *UnaryExpr) AllocComments()

AllocComments enables comments to be associated with a syntax node.

func (UnaryExpr) Comments Uses

func (cr UnaryExpr) Comments() *Comments

Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.

func (*UnaryExpr) Span Uses

func (x *UnaryExpr) Span() (start, end Position)

type WhileStmt Uses

type WhileStmt struct {
    While Position
    Cond  Expr
    Body  []Stmt
    // contains filtered or unexported fields
}

A WhileStmt represents a while loop: while X: Body.

func (*WhileStmt) AllocComments Uses

func (cr *WhileStmt) AllocComments()

AllocComments enables comments to be associated with a syntax node.

func (WhileStmt) Comments Uses

func (cr WhileStmt) Comments() *Comments

Comments returns the comments associated with a syntax node, or nil if AllocComments has not yet been called.

func (*WhileStmt) Span Uses

func (x *WhileStmt) Span() (start, end Position)

Package syntax imports 10 packages (graph) and is imported by 23 packages. Updated 2019-08-21. Refresh now. Tools for package owners.