go: cuelang.org/go/cue/ast Index | Files | Directories

package ast

import "cuelang.org/go/cue/ast"

Package ast declares the types used to represent syntax trees for CUE packages.

Index

Package Files

ast.go comments.go ident.go walk.go

Variables

var ErrIsExpression = errors.New("not a concrete label")

ErrIsExpression reports whether a label is an expression. This error is never returned directly. Use errors.Is or xerrors.Is.

func AddComment Uses

func AddComment(n Node, cg *CommentGroup)

AddComment adds the given comment to the node if it supports it. If a node does not support comments, such as for CommentGroup or Comment, this call has no effect.

func IsValidIdent Uses

func IsValidIdent(ident string) bool

IsValidIdent reports whether str is a valid identifier.

func LabelName Uses

func LabelName(l Label) (name string, isIdent bool, err error)

LabelName reports the name of a label, whether it is an identifier (it binds a value to a scope), and whether it is valid. Keywords that are allowed in label positions are interpreted accordingly.

Examples:

Label   Result
foo     "foo"  true   nil
true    "true" true   nil
"foo"   "foo"  false  nil
"x-y"   "x-y"  false  nil
"foo    ""     false  invalid string
"\(x)"  ""     false  errors.Is(err, ErrIsExpression)
X=foo   "foo"  true   nil

func ParseIdent Uses

func ParseIdent(n *Ident) (string, error)

ParseIdent unquotes a possibly quoted identifier and validates if the result is valid.

Deprecated: quoted identifiers are deprecated. Use aliases.

func QuoteIdent Uses

func QuoteIdent(ident string) (string, error)

QuoteIdent quotes an identifier, if needed, and reports an error if the identifier is invalid.

Deprecated: quoted identifiers are deprecated. Use aliases.

func SetComments Uses

func SetComments(n Node, cgs []*CommentGroup)

SetComments replaces all comments of n with the given set of comments. If a node does not support comments, such as for CommentGroup or Comment, this call has no effect.

func SetPos Uses

func SetPos(n Node, p token.Pos)

SetPos sets a node to the given position, if possible.

func SetRelPos Uses

func SetRelPos(n Node, p token.RelPos)

SetRelPos sets the relative position of a node without modifying its file position. Setting it to token.NoRelPos allows a node to adopt default formatting.

func Walk Uses

func Walk(node Node, before func(Node) bool, after func(Node))

Walk traverses an AST in depth-first order: It starts by calling f(node); node must not be nil. If before returns true, Walk invokes f recursively for each of the non-nil children of node, followed by a call of after. Both functions may be nil. If before is nil, it is assumed to always return true.

type Alias Uses

type Alias struct {
    Ident *Ident    // field name, always an Ident
    Equal token.Pos // position of "="
    Expr  Expr      // An Ident or SelectorExpr
    // contains filtered or unexported fields
}

An Alias binds another field to the alias name in the current struct.

func (*Alias) AddComment Uses

func (c *Alias) AddComment(cg *CommentGroup)

func (*Alias) Comments Uses

func (c *Alias) Comments() []*CommentGroup

func (*Alias) End Uses

func (a *Alias) End() token.Pos

func (*Alias) Pos Uses

func (a *Alias) Pos() token.Pos

func (*Alias) SetComments Uses

func (c *Alias) SetComments(cgs []*CommentGroup)

type Attribute Uses

type Attribute struct {
    At   token.Pos
    Text string // must be a valid attribute format.
    // contains filtered or unexported fields
}

An Attribute provides meta data about a field.

func (*Attribute) AddComment Uses

func (c *Attribute) AddComment(cg *CommentGroup)

func (*Attribute) Comments Uses

func (c *Attribute) Comments() []*CommentGroup

func (*Attribute) End Uses

func (a *Attribute) End() token.Pos

func (*Attribute) Pos Uses

func (a *Attribute) Pos() token.Pos

func (*Attribute) SetComments Uses

func (c *Attribute) SetComments(cgs []*CommentGroup)

type BadDecl Uses

type BadDecl struct {
    From, To token.Pos // position range of bad declaration
    // contains filtered or unexported fields
}

A BadDecl node is a placeholder for declarations containing syntax errors for which no correct declaration nodes can be created.

func (*BadDecl) AddComment Uses

func (c *BadDecl) AddComment(cg *CommentGroup)

func (*BadDecl) Comments Uses

func (c *BadDecl) Comments() []*CommentGroup

func (*BadDecl) End Uses

func (d *BadDecl) End() token.Pos

func (*BadDecl) Pos Uses

func (d *BadDecl) Pos() token.Pos

func (*BadDecl) SetComments Uses

func (c *BadDecl) SetComments(cgs []*CommentGroup)

type BadExpr Uses

type BadExpr struct {
    From, To token.Pos // position range of bad expression
    // contains filtered or unexported fields
}

A BadExpr node is a placeholder for expressions containing syntax errors for which no correct expression nodes can be created. This is different from an ErrorExpr which represents an explicitly marked error in the source.

func (*BadExpr) AddComment Uses

func (c *BadExpr) AddComment(cg *CommentGroup)

func (*BadExpr) Comments Uses

func (c *BadExpr) Comments() []*CommentGroup

func (*BadExpr) End Uses

func (x *BadExpr) End() token.Pos

func (*BadExpr) Pos Uses

func (x *BadExpr) Pos() token.Pos

func (*BadExpr) SetComments Uses

func (c *BadExpr) SetComments(cgs []*CommentGroup)

type BasicLit Uses

type BasicLit struct {
    ValuePos token.Pos   // literal position
    Kind     token.Token // INT, FLOAT, DURATION, or STRING
    Value    string      // literal string; e.g. 42, 0x7f, 3.14, 1_234_567, 1e-9, 2.4i, 'a', '\x7f', "foo", or '\m\n\o'
    // contains filtered or unexported fields
}

A BasicLit node represents a literal of basic type.

func NewString Uses

func NewString(str string) *BasicLit

NewString creates a new BasicLit with a string value without position. It quotes the given string. Useful for ASTs generated by code other than the CUE parser.

func (*BasicLit) AddComment Uses

func (c *BasicLit) AddComment(cg *CommentGroup)

func (*BasicLit) Comments Uses

func (c *BasicLit) Comments() []*CommentGroup

func (*BasicLit) End Uses

func (x *BasicLit) End() token.Pos

func (*BasicLit) Pos Uses

func (x *BasicLit) Pos() token.Pos

func (*BasicLit) SetComments Uses

func (c *BasicLit) SetComments(cgs []*CommentGroup)

type BinaryExpr Uses

type BinaryExpr struct {
    X     Expr        // left operand
    OpPos token.Pos   // position of Op
    Op    token.Token // operator
    Y     Expr        // right operand
    // contains filtered or unexported fields
}

A BinaryExpr node represents a binary expression.

func (*BinaryExpr) AddComment Uses

func (c *BinaryExpr) AddComment(cg *CommentGroup)

func (*BinaryExpr) Comments Uses

func (c *BinaryExpr) Comments() []*CommentGroup

func (*BinaryExpr) End Uses

func (x *BinaryExpr) End() token.Pos

func (*BinaryExpr) Pos Uses

func (x *BinaryExpr) Pos() token.Pos

func (*BinaryExpr) SetComments Uses

func (c *BinaryExpr) SetComments(cgs []*CommentGroup)

type BottomLit Uses

type BottomLit struct {
    Bottom token.Pos
    // contains filtered or unexported fields
}

A BottomLit indicates an error.

func (*BottomLit) AddComment Uses

func (c *BottomLit) AddComment(cg *CommentGroup)

func (*BottomLit) Comments Uses

func (c *BottomLit) Comments() []*CommentGroup

func (*BottomLit) End Uses

func (x *BottomLit) End() token.Pos

func (*BottomLit) Pos Uses

func (x *BottomLit) Pos() token.Pos

func (*BottomLit) SetComments Uses

func (c *BottomLit) SetComments(cgs []*CommentGroup)

type CallExpr Uses

type CallExpr struct {
    Fun    Expr      // function expression
    Lparen token.Pos // position of "("
    Args   []Expr    // function arguments; or nil
    Rparen token.Pos // position of ")"
    // contains filtered or unexported fields
}

A CallExpr node represents an expression followed by an argument list.

func NewCall Uses

func NewCall(fun Expr, args ...Expr) *CallExpr

NewCall creates a new CallExpr. Useful for ASTs generated by code other than the CUE parser.

func (*CallExpr) AddComment Uses

func (c *CallExpr) AddComment(cg *CommentGroup)

func (*CallExpr) Comments Uses

func (c *CallExpr) Comments() []*CommentGroup

func (*CallExpr) End Uses

func (x *CallExpr) End() token.Pos

func (*CallExpr) Pos Uses

func (x *CallExpr) Pos() token.Pos

func (*CallExpr) SetComments Uses

func (c *CallExpr) SetComments(cgs []*CommentGroup)

type Clause Uses

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

Clause nodes are part of comprehensions.

type Comment Uses

type Comment struct {
    Slash token.Pos // position of "/" starting the comment
    Text  string    // comment text (excluding '\n' for //-style comments)
}

A Comment node represents a single //-style or /*-style comment.

func (*Comment) AddComment Uses

func (c *Comment) AddComment(*CommentGroup)

func (*Comment) Comments Uses

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

func (*Comment) End Uses

func (c *Comment) End() token.Pos

func (*Comment) Pos Uses

func (c *Comment) Pos() token.Pos

type CommentGroup Uses

type CommentGroup struct {
    // TODO: remove and use the token position of the first comment.
    Doc  bool
    Line bool // true if it is on the same line as the node's end pos.

    // Position indicates where a comment should be attached if a node has
    // multiple tokens. 0 means before the first token, 1 means before the
    // second, etc. For instance, for a field, the positions are:
    //    <0> Label <1> ":" <2> Expr <3> "," <4>
    Position int8
    List     []*Comment // len(List) > 0
    // contains filtered or unexported fields
}

A CommentGroup represents a sequence of comments with no other tokens and no empty lines between.

func Comments Uses

func Comments(n Node) []*CommentGroup

Comments returns all comments associated with a given node.

func (*CommentGroup) AddComment Uses

func (g *CommentGroup) AddComment(*CommentGroup)

func (*CommentGroup) Comments Uses

func (g *CommentGroup) Comments() []*CommentGroup

func (*CommentGroup) End Uses

func (g *CommentGroup) End() token.Pos

func (*CommentGroup) Pos Uses

func (g *CommentGroup) Pos() token.Pos

func (*CommentGroup) Text Uses

func (g *CommentGroup) Text() string

Text returns the text of the comment. Comment markers (//, /*, and */), the first space of a line comment, and leading and trailing empty lines are removed. Multiple empty lines are reduced to one, and trailing space on lines is trimmed. Unless the result is empty, it is newline-terminated.

type Comprehension Uses

type Comprehension struct {
    Clauses []Clause // There must be at least one clause.
    Value   Expr     // Must be a struct
    // contains filtered or unexported fields
}

A Comprehension node represents a comprehension declaration.

func (*Comprehension) AddComment Uses

func (c *Comprehension) AddComment(cg *CommentGroup)

func (*Comprehension) Comments Uses

func (c *Comprehension) Comments() []*CommentGroup

func (*Comprehension) End Uses

func (x *Comprehension) End() token.Pos

func (*Comprehension) Pos Uses

func (x *Comprehension) Pos() token.Pos

func (*Comprehension) SetComments Uses

func (c *Comprehension) SetComments(cgs []*CommentGroup)

type Decl Uses

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

A Decl node is implemented by all declarations.

type Ellipsis Uses

type Ellipsis struct {
    Ellipsis token.Pos // open list if set
    Type     Expr      // type for the remaining elements
    // contains filtered or unexported fields
}

func (*Ellipsis) AddComment Uses

func (c *Ellipsis) AddComment(cg *CommentGroup)

func (*Ellipsis) Comments Uses

func (c *Ellipsis) Comments() []*CommentGroup

func (*Ellipsis) End Uses

func (x *Ellipsis) End() token.Pos

func (*Ellipsis) Pos Uses

func (x *Ellipsis) Pos() token.Pos

func (*Ellipsis) SetComments Uses

func (c *Ellipsis) SetComments(cgs []*CommentGroup)

type EmbedDecl Uses

type EmbedDecl struct {
    Expr Expr
    // contains filtered or unexported fields
}

An EmbedDecl node represents a single expression used as a declaration. The expressions in this declaration is what will be emitted as configuration output.

An EmbedDecl may only appear at the top level.

func (*EmbedDecl) AddComment Uses

func (c *EmbedDecl) AddComment(cg *CommentGroup)

func (*EmbedDecl) Comments Uses

func (c *EmbedDecl) Comments() []*CommentGroup

func (*EmbedDecl) End Uses

func (d *EmbedDecl) End() token.Pos

func (*EmbedDecl) Pos Uses

func (d *EmbedDecl) Pos() token.Pos

func (*EmbedDecl) SetComments Uses

func (c *EmbedDecl) SetComments(cgs []*CommentGroup)

type Expr Uses

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

An Expr is implemented by all expression nodes.

func NewSel Uses

func NewSel(x Expr, sel ...string) Expr

NewSel creates a sequence of selectors. Useful for ASTs generated by code other than the CUE parser.

type Field Uses

type Field struct {
    Label    Label // must have at least one element.
    Optional token.Pos

    // No TokenPos: Value must be an StructLit with one field.
    TokenPos token.Pos
    Token    token.Token // ':' or '::', ILLEGAL implies ':'

    Value Expr // the value associated with this field.

    Attrs []*Attribute
    // contains filtered or unexported fields
}

A Field represents a field declaration in a struct.

func (*Field) AddComment Uses

func (c *Field) AddComment(cg *CommentGroup)

func (*Field) Comments Uses

func (c *Field) Comments() []*CommentGroup

func (*Field) End Uses

func (d *Field) End() token.Pos

func (*Field) Pos Uses

func (d *Field) Pos() token.Pos

func (*Field) SetComments Uses

func (c *Field) SetComments(cgs []*CommentGroup)

type File Uses

type File struct {
    Filename string
    Decls    []Decl // top-level declarations; or nil

    Imports    []*ImportSpec // imports in this file
    Unresolved []*Ident      // unresolved identifiers in this file
    // contains filtered or unexported fields
}

A File node represents a Go source file.

The Comments list contains all comments in the source file in order of appearance, including the comments that are pointed to from other nodes via Doc and Comment fields.

func (*File) AddComment Uses

func (c *File) AddComment(cg *CommentGroup)

func (*File) Comments Uses

func (c *File) Comments() []*CommentGroup

func (*File) End Uses

func (f *File) End() token.Pos

func (*File) Pos Uses

func (f *File) Pos() token.Pos

func (*File) SetComments Uses

func (c *File) SetComments(cgs []*CommentGroup)

type ForClause Uses

type ForClause struct {
    For token.Pos
    Key *Ident // allow pattern matching?
    // TODO: change to Comma
    Colon  token.Pos
    Value  *Ident // allow pattern matching?
    In     token.Pos
    Source Expr
    // contains filtered or unexported fields
}

A ForClause node represents a for clause in a comprehension.

func (*ForClause) AddComment Uses

func (c *ForClause) AddComment(cg *CommentGroup)

func (*ForClause) Comments Uses

func (c *ForClause) Comments() []*CommentGroup

func (*ForClause) End Uses

func (x *ForClause) End() token.Pos

func (*ForClause) Pos Uses

func (x *ForClause) Pos() token.Pos

func (*ForClause) SetComments Uses

func (c *ForClause) SetComments(cgs []*CommentGroup)

type Ident Uses

type Ident struct {
    NamePos token.Pos // identifier position

    // This LHS path element may be an identifier. Possible forms:
    //  foo:    a normal identifier
    //  "foo":  JSON compatible
    //  <foo>:  a template shorthand
    Name string

    Scope Node // scope in which node was found or nil if referring directly
    Node  Node
    // contains filtered or unexported fields
}

An Ident node represents an left-hand side identifier.

func NewIdent Uses

func NewIdent(name string) *Ident

NewIdent creates a new Ident without position. Useful for ASTs generated by code other than the CUE parser.

func (*Ident) AddComment Uses

func (c *Ident) AddComment(cg *CommentGroup)

func (*Ident) Comments Uses

func (c *Ident) Comments() []*CommentGroup

func (*Ident) End Uses

func (x *Ident) End() token.Pos

func (*Ident) Pos Uses

func (x *Ident) Pos() token.Pos

func (*Ident) SetComments Uses

func (c *Ident) SetComments(cgs []*CommentGroup)

func (*Ident) String Uses

func (id *Ident) String() string

type IfClause Uses

type IfClause struct {
    If        token.Pos
    Condition Expr
    // contains filtered or unexported fields
}

A IfClause node represents an if guard clause in a comprehension.

func (*IfClause) AddComment Uses

func (c *IfClause) AddComment(cg *CommentGroup)

func (*IfClause) Comments Uses

func (c *IfClause) Comments() []*CommentGroup

func (*IfClause) End Uses

func (x *IfClause) End() token.Pos

func (*IfClause) Pos Uses

func (x *IfClause) Pos() token.Pos

func (*IfClause) SetComments Uses

func (c *IfClause) SetComments(cgs []*CommentGroup)

type ImportDecl Uses

type ImportDecl struct {
    Import token.Pos
    Lparen token.Pos // position of '(', if any
    Specs  []*ImportSpec
    Rparen token.Pos // position of ')', if any
    // contains filtered or unexported fields
}

A ImportDecl node represents a series of import declarations. A valid Lparen position (Lparen.Line > 0) indicates a parenthesized declaration.

func (*ImportDecl) AddComment Uses

func (c *ImportDecl) AddComment(cg *CommentGroup)

func (*ImportDecl) Comments Uses

func (c *ImportDecl) Comments() []*CommentGroup

func (*ImportDecl) End Uses

func (d *ImportDecl) End() token.Pos

func (*ImportDecl) Pos Uses

func (d *ImportDecl) Pos() token.Pos

func (*ImportDecl) SetComments Uses

func (c *ImportDecl) SetComments(cgs []*CommentGroup)

type ImportSpec Uses

type ImportSpec struct {
    Name   *Ident    // local package name (including "."); or nil
    Path   *BasicLit // import path
    EndPos token.Pos // end of spec (overrides Path.Pos if nonzero)
    // contains filtered or unexported fields
}

An ImportSpec node represents a single package import.

func NewImport Uses

func NewImport(name *Ident, importPath string) *ImportSpec

func (*ImportSpec) AddComment Uses

func (c *ImportSpec) AddComment(cg *CommentGroup)

func (*ImportSpec) Comments Uses

func (c *ImportSpec) Comments() []*CommentGroup

func (*ImportSpec) End Uses

func (s *ImportSpec) End() token.Pos

func (*ImportSpec) Pos Uses

func (s *ImportSpec) Pos() token.Pos

func (*ImportSpec) SetComments Uses

func (c *ImportSpec) SetComments(cgs []*CommentGroup)

type IndexExpr Uses

type IndexExpr struct {
    X      Expr      // expression
    Lbrack token.Pos // position of "["
    Index  Expr      // index expression
    Rbrack token.Pos // position of "]"
    // contains filtered or unexported fields
}

An IndexExpr node represents an expression followed by an index.

func (*IndexExpr) AddComment Uses

func (c *IndexExpr) AddComment(cg *CommentGroup)

func (*IndexExpr) Comments Uses

func (c *IndexExpr) Comments() []*CommentGroup

func (*IndexExpr) End Uses

func (x *IndexExpr) End() token.Pos

func (*IndexExpr) Pos Uses

func (x *IndexExpr) Pos() token.Pos

func (*IndexExpr) SetComments Uses

func (c *IndexExpr) SetComments(cgs []*CommentGroup)

type Interpolation Uses

type Interpolation struct {
    Elts []Expr // interleaving of strings and expressions.
    // contains filtered or unexported fields
}

A Interpolation node represents a string or bytes interpolation.

func (*Interpolation) AddComment Uses

func (c *Interpolation) AddComment(cg *CommentGroup)

func (*Interpolation) Comments Uses

func (c *Interpolation) Comments() []*CommentGroup

func (*Interpolation) End Uses

func (x *Interpolation) End() token.Pos

func (*Interpolation) Pos Uses

func (x *Interpolation) Pos() token.Pos

func (*Interpolation) SetComments Uses

func (c *Interpolation) SetComments(cgs []*CommentGroup)

type Label Uses

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

A Label is any production that can be used as a LHS label.

type ListComprehension Uses

type ListComprehension struct {
    Lbrack  token.Pos // position of "["
    Expr    Expr
    Clauses []Clause  // Feed or Guard (TODO let)
    Rbrack  token.Pos // position of "]"
    // contains filtered or unexported fields
}

A ListComprehension node represents as list comprehension.

func (*ListComprehension) AddComment Uses

func (c *ListComprehension) AddComment(cg *CommentGroup)

func (*ListComprehension) Comments Uses

func (c *ListComprehension) Comments() []*CommentGroup

func (*ListComprehension) End Uses

func (x *ListComprehension) End() token.Pos

func (*ListComprehension) Pos Uses

func (x *ListComprehension) Pos() token.Pos

func (*ListComprehension) SetComments Uses

func (c *ListComprehension) SetComments(cgs []*CommentGroup)

type ListLit Uses

type ListLit struct {
    Lbrack token.Pos // position of "["
    Elts   []Expr    // list of composite elements; or nil
    Rbrack token.Pos // position of "]"
    // contains filtered or unexported fields
}

A ListLit node represents a literal list.

func NewList Uses

func NewList(exprs ...Expr) *ListLit

NewList creates a list of Expressions. Useful for ASTs generated by code other than the CUE parser.

func (*ListLit) AddComment Uses

func (c *ListLit) AddComment(cg *CommentGroup)

func (*ListLit) Comments Uses

func (c *ListLit) Comments() []*CommentGroup

func (*ListLit) End Uses

func (x *ListLit) End() token.Pos

func (*ListLit) Pos Uses

func (x *ListLit) Pos() token.Pos

func (*ListLit) SetComments Uses

func (c *ListLit) SetComments(cgs []*CommentGroup)

type Node Uses

type Node interface {
    Pos() token.Pos // position of first character belonging to the node
    End() token.Pos // position of first character immediately after the node

    // Deprecated: use ast.Comments
    Comments() []*CommentGroup

    // Deprecated: use ast.AddComment
    AddComment(*CommentGroup)
    // contains filtered or unexported methods
}

A Node represents any node in the abstract syntax tree.

type Package Uses

type Package struct {
    PackagePos token.Pos // position of "package" pseudo-keyword
    Name       *Ident    // package name
    // contains filtered or unexported fields
}

A Package represents a package clause.

func (*Package) AddComment Uses

func (c *Package) AddComment(cg *CommentGroup)

func (*Package) Comments Uses

func (c *Package) Comments() []*CommentGroup

func (*Package) End Uses

func (p *Package) End() token.Pos

func (*Package) Pos Uses

func (p *Package) Pos() token.Pos

func (*Package) SetComments Uses

func (c *Package) SetComments(cgs []*CommentGroup)

type ParenExpr Uses

type ParenExpr struct {
    Lparen token.Pos // position of "("
    X      Expr      // parenthesized expression
    Rparen token.Pos // position of ")"
    // contains filtered or unexported fields
}

A ParenExpr node represents a parenthesized expression.

func (*ParenExpr) AddComment Uses

func (c *ParenExpr) AddComment(cg *CommentGroup)

func (*ParenExpr) Comments Uses

func (c *ParenExpr) Comments() []*CommentGroup

func (*ParenExpr) End Uses

func (x *ParenExpr) End() token.Pos

func (*ParenExpr) Pos Uses

func (x *ParenExpr) Pos() token.Pos

func (*ParenExpr) SetComments Uses

func (c *ParenExpr) SetComments(cgs []*CommentGroup)

type SelectorExpr Uses

type SelectorExpr struct {
    X   Expr   // expression
    Sel *Ident // field selector
    // contains filtered or unexported fields
}

A SelectorExpr node represents an expression followed by a selector.

func (*SelectorExpr) AddComment Uses

func (c *SelectorExpr) AddComment(cg *CommentGroup)

func (*SelectorExpr) Comments Uses

func (c *SelectorExpr) Comments() []*CommentGroup

func (*SelectorExpr) End Uses

func (x *SelectorExpr) End() token.Pos

func (*SelectorExpr) Pos Uses

func (x *SelectorExpr) Pos() token.Pos

func (*SelectorExpr) SetComments Uses

func (c *SelectorExpr) SetComments(cgs []*CommentGroup)

type SliceExpr Uses

type SliceExpr struct {
    X      Expr      // expression
    Lbrack token.Pos // position of "["
    Low    Expr      // begin of slice range; or nil
    High   Expr      // end of slice range; or nil
    Rbrack token.Pos // position of "]"
    // contains filtered or unexported fields
}

An SliceExpr node represents an expression followed by slice indices.

func (*SliceExpr) AddComment Uses

func (c *SliceExpr) AddComment(cg *CommentGroup)

func (*SliceExpr) Comments Uses

func (c *SliceExpr) Comments() []*CommentGroup

func (*SliceExpr) End Uses

func (x *SliceExpr) End() token.Pos

func (*SliceExpr) Pos Uses

func (x *SliceExpr) Pos() token.Pos

func (*SliceExpr) SetComments Uses

func (c *SliceExpr) SetComments(cgs []*CommentGroup)

type Spec Uses

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

type StructLit Uses

type StructLit struct {
    Lbrace token.Pos // position of "{"
    Elts   []Decl    // list of elements; or nil
    Rbrace token.Pos // position of "}"
    // contains filtered or unexported fields
}

A StructLit node represents a literal struct.

func (*StructLit) AddComment Uses

func (c *StructLit) AddComment(cg *CommentGroup)

func (*StructLit) Comments Uses

func (c *StructLit) Comments() []*CommentGroup

func (*StructLit) End Uses

func (x *StructLit) End() token.Pos

func (*StructLit) Pos Uses

func (x *StructLit) Pos() token.Pos

func (*StructLit) SetComments Uses

func (c *StructLit) SetComments(cgs []*CommentGroup)

type TemplateLabel Uses

type TemplateLabel struct {
    Langle token.Pos
    Ident  *Ident
    Rangle token.Pos
    // contains filtered or unexported fields
}

A TemplateLabel represents a field template declaration in a struct.

Deprecated: use square bracket notation through ListLit.

func (*TemplateLabel) AddComment Uses

func (c *TemplateLabel) AddComment(cg *CommentGroup)

func (*TemplateLabel) Comments Uses

func (c *TemplateLabel) Comments() []*CommentGroup

func (*TemplateLabel) End Uses

func (x *TemplateLabel) End() token.Pos

func (*TemplateLabel) Pos Uses

func (x *TemplateLabel) Pos() token.Pos

func (*TemplateLabel) SetComments Uses

func (c *TemplateLabel) SetComments(cgs []*CommentGroup)

type UnaryExpr Uses

type UnaryExpr struct {
    OpPos token.Pos   // position of Op
    Op    token.Token // operator
    X     Expr        // operand
    // contains filtered or unexported fields
}

A UnaryExpr node represents a unary expression.

func (*UnaryExpr) AddComment Uses

func (c *UnaryExpr) AddComment(cg *CommentGroup)

func (*UnaryExpr) Comments Uses

func (c *UnaryExpr) Comments() []*CommentGroup

func (*UnaryExpr) End Uses

func (x *UnaryExpr) End() token.Pos

func (*UnaryExpr) Pos Uses

func (x *UnaryExpr) Pos() token.Pos

func (*UnaryExpr) SetComments Uses

func (c *UnaryExpr) SetComments(cgs []*CommentGroup)

Directories

PathSynopsis
astutil

Package ast imports 7 packages (graph) and is imported by 19 packages. Updated 2019-11-17. Refresh now. Tools for package owners.