model

type Alias struct {
	Name     *Identifier
	AsName   *Identifier // can be nil
	StartPos Position
	EndPos   Position
}

type AnnAssign struct {
	Target     Expr
	Annotation Expr
	Value      Expr // can be nil
	Simple     bool
	StartPos   Position
}

type Arg struct {
	Arg        *Identifier
	Annotation Expr // can be nil
	StartPos   Position
	EndPos     Position
}

type Arguments struct {
	PosOnlyArgs []*Arg
	Args        []*Arg
	VarArg      *Arg // *args
	KwOnlyArgs  []*Arg
	KwDefaults  []Expr // defaults for kwonly args
	KwArg       *Arg   // **kwargs
	Defaults    []Expr // defaults for positional args
}

type Assert struct {
	Test     Expr
	Msg      Expr // can be nil
	StartPos Position
	EndPos   Position
}

type Assign struct {
	Targets []Expr
	Value   Expr
}

type Attribute struct {
	Value Expr
	Attr  *Identifier
}

type AugAssign struct {
	Target Expr
	Op     TokenKind
	Value  Expr
}

type Await struct {
	Value    Expr
	StartPos Position
}

type BinaryOp struct {
	Left  Expr
	Op    TokenKind
	Right Expr
}

type BoolLit struct {
	Value    bool
	StartPos Position
	EndPos   Position
}

type BoolOp struct {
	Op     TokenKind // TK_And or TK_Or
	Values []Expr
}

type Break struct {
	StartPos Position
	EndPos   Position
}

type BytesLit struct {
	Value    string
	StartPos Position
	EndPos   Position
}

type Call struct {
	Func     Expr
	Args     []Expr
	Keywords []*Keyword
	EndPos   Position
}

type ClassDef struct {
	Name       *Identifier
	Bases      []Expr
	Keywords   []*Keyword
	Body       []Stmt
	Decorators []Expr
	StartPos   Position
	EndPos     Position
}

type Compare struct {
	Left        Expr
	Ops         []TokenKind
	Comparators []Expr
}

type Comprehension struct {
	Target  Expr
	Iter    Expr
	Ifs     []Expr
	IsAsync bool
}

type Continue struct {
	StartPos Position
	EndPos   Position
}

type Delete struct {
	Targets  []Expr
	StartPos Position
}

type Dict struct {
	Keys     []Expr // nil key means **unpacking
	Values   []Expr
	StartPos Position
	EndPos   Position
}

type DictComp struct {
	Key        Expr
	Value      Expr
	Generators []*Comprehension
	StartPos   Position
	EndPos     Position
}

type Ellipsis struct {
	StartPos Position
	EndPos   Position
}

type ExceptHandler struct {
	Type     Expr        // can be nil for bare except
	Name     *Identifier // can be nil
	Body     []Stmt
	IsStar   bool // true for "except* Type:"
	StartPos Position
	EndPos   Position
}

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

type ExprStmt struct {
	Value Expr
}

type FStringLit struct {
	Parts    []FStringPart
	StartPos Position
	EndPos   Position
}

type FStringPart struct {
	IsExpr     bool   // true if this part is an expression, false if literal string
	Value      string // the literal string value (if IsExpr is false)
	Expr       Expr   // the expression (if IsExpr is true)
	FormatSpec string // optional format spec after ':'
	Conversion byte   // 0 for none, 'r' for !r, 's' for !s, 'a' for !a
}

type FloatLit struct {
	Value    string
	StartPos Position
	EndPos   Position
}

type For struct {
	Target   Expr
	Iter     Expr
	Body     []Stmt
	OrElse   []Stmt
	IsAsync  bool
	StartPos Position
	EndPos   Position
}

type FunctionDef struct {
	Name       *Identifier
	Args       *Arguments
	Body       []Stmt
	Decorators []Expr
	Returns    Expr // return type annotation, can be nil
	IsAsync    bool
	StartPos   Position
	EndPos     Position
}

type GeneratorExpr struct {
	Elt        Expr
	Generators []*Comprehension
	StartPos   Position
	EndPos     Position
}

type Global struct {
	Names    []*Identifier
	StartPos Position
	EndPos   Position
}

type Identifier struct {
	Name     string
	StartPos Position
	EndPos   Position
}

type If struct {
	Test     Expr
	Body     []Stmt
	OrElse   []Stmt // can include elif (nested If) or else body
	StartPos Position
	EndPos   Position
}

type IfExpr struct {
	Test   Expr
	Body   Expr
	OrElse Expr
}

type ImaginaryLit struct {
	Value    string
	StartPos Position
	EndPos   Position
}

type Import struct {
	Names    []*Alias
	StartPos Position
	EndPos   Position
}

type ImportFrom struct {
	Module   *Identifier // can be nil for relative imports
	Names    []*Alias
	Level    int // number of dots for relative import
	StartPos Position
	EndPos   Position
}

type IntLit struct {
	Value    string
	StartPos Position
	EndPos   Position
}

type Keyword struct {
	Arg      *Identifier // nil for **kwargs
	Value    Expr
	StartPos Position
}

type Lambda struct {
	Args     *Arguments
	Body     Expr
	StartPos Position
}

type List struct {
	Elts     []Expr
	StartPos Position
	EndPos   Position
}

type ListComp struct {
	Elt        Expr
	Generators []*Comprehension
	StartPos   Position
	EndPos     Position
}

type Match struct {
	Subject  Expr
	Cases    []*MatchCase
	StartPos Position
	EndPos   Position
}

type MatchAs struct {
	Pattern  Pattern     // nil for wildcard _
	Name     *Identifier // nil for wildcard _
	StartPos Position
	EndPos   Position
}

type MatchCase struct {
	Pattern  Pattern
	Guard    Expr // can be nil
	Body     []Stmt
	StartPos Position
	EndPos   Position
}

type MatchClass struct {
	Cls         Expr
	Patterns    []Pattern
	KwdAttrs    []*Identifier
	KwdPatterns []Pattern
	StartPos    Position
	EndPos      Position
}

type MatchMapping struct {
	Keys     []Expr
	Patterns []Pattern
	Rest     *Identifier // **rest, can be nil
	StartPos Position
	EndPos   Position
}

type MatchOr struct {
	Patterns []Pattern
	StartPos Position
	EndPos   Position
}

type MatchSequence struct {
	Patterns []Pattern
	StartPos Position
	EndPos   Position
}

type MatchSingleton struct {
	Value    Expr
	StartPos Position
	EndPos   Position
}

type MatchStar struct {
	Name     *Identifier // can be nil for _
	StartPos Position
	EndPos   Position
}

type MatchValue struct {
	Value    Expr
	StartPos Position
	EndPos   Position
}

type Module struct {
	Body     []Stmt
	StartPos Position
	EndPos   Position
}

type NamedExpr struct {
	Target *Identifier
	Value  Expr
}

type Node interface {
	Pos() Position
	End() Position
}

type NoneLit struct {
	StartPos Position
	EndPos   Position
}

type Nonlocal struct {
	Names    []*Identifier
	StartPos Position
	EndPos   Position
}

type Pass struct {
	StartPos Position
	EndPos   Position
}

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

type Position struct {
	Filename string
	Line     int
	Column   int
	Offset   int
}

type Raise struct {
	Exc      Expr // can be nil
	Cause    Expr // can be nil
	StartPos Position
	EndPos   Position
}

type Return struct {
	Value    Expr // can be nil
	StartPos Position
	EndPos   Position
}

type Set struct {
	Elts     []Expr
	StartPos Position
	EndPos   Position
}

type SetComp struct {
	Elt        Expr
	Generators []*Comprehension
	StartPos   Position
	EndPos     Position
}

type Slice struct {
	Lower    Expr // can be nil
	Upper    Expr // can be nil
	Step     Expr // can be nil
	StartPos Position
	EndPos   Position
}

type Starred struct {
	Value    Expr
	StartPos Position
}

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

type StringLit struct {
	Value    string
	StartPos Position
	EndPos   Position
}

type Subscript struct {
	Value  Expr
	Slice  Expr
	EndPos Position
}

type Token struct {
	Kind    TokenKind
	Literal string
	Pos     Position
	EndPos  Position
}

type TokenKind int

type Try struct {
	Body      []Stmt
	Handlers  []*ExceptHandler
	OrElse    []Stmt
	FinalBody []Stmt
	StartPos  Position
	EndPos    Position
}

type Tuple struct {
	Elts     []Expr
	StartPos Position
	EndPos   Position
}

type TypeAlias struct {
	Name       *Identifier
	TypeParams []*TypeParam
	Value      Expr
	StartPos   Position
	EndPos     Position
}

type TypeParam struct {
	Name     *Identifier
	Bound    Expr // can be nil
	StartPos Position
	EndPos   Position
}

type UnaryOp struct {
	Op       TokenKind
	Operand  Expr
	StartPos Position
}

type While struct {
	Test     Expr
	Body     []Stmt
	OrElse   []Stmt
	StartPos Position
	EndPos   Position
}

type With struct {
	Items    []*WithItem
	Body     []Stmt
	IsAsync  bool
	StartPos Position
	EndPos   Position
}

type WithItem struct {
	ContextExpr Expr
	OptionalVar Expr // can be nil
}

type Yield struct {
	Value    Expr // can be nil
	StartPos Position
	EndPos   Position
}

type YieldFrom struct {
	Value    Expr
	StartPos Position
}