syntax

type Arg struct {
	// Name is the argument name; HasName tells `f(a = 1)` from `f(1)` (and
	// `f("" = 1)` from both).
	Name    string
	HasName bool
	// Value is nil for an empty argument: f(,), x[1, ].
	Value Node
	Pos   Span
}

type Call struct {
	Pos  Span
	Fun  Node
	Args []Arg
	// contains filtered or unexported fields
}

type Const struct {
	Pos  Span
	Kind ConstKind
	// Logical: 0 or 1, NA when NA is set. Integer: Int, NA when NA is set.
	// Double: Double (NA_real_ has the bits of rds.NAReal; use NA to tell).
	// Complex: Re and Im. String: Str, NA when NA is set.
	Int      int32
	Double   float64
	Im       float64
	Str      string
	NA       bool
	LogicalV bool
	// contains filtered or unexported fields
}

type ConstKind int

type DeparseOptions struct {
	// Cutoff is the line width, in bytes, after which a line is broken at the
	// next break point (default 60).
	Cutoff int
	// NoBackquote turns off the backquoting of non-syntactic names, as
	// deparse(backtick = FALSE) does (R turns it off for a bare symbol).
	NoBackquote bool
	// NoKeepInteger drops the L suffix and NA_integer_/NA_real_ spellings.
	NoKeepInteger bool
}

type Error struct {
	// Line and Col locate the error as R reports it (Col counts characters,
	// tab-expanded; 0 at the end of input).
	Line, Col int
	// Message is R's own description: "unexpected symbol", "unexpected end
	// of input", "'\q' is an unrecognized escape in character string", ...
	Message string
	// Lexical is set for errors R raises from its lexer or from the pipe
	// rewriting (their text carries "(<input>:line:col)" and no context).
	Lexical bool
	// contains filtered or unexported fields
}

type File struct {
	// Source is the text that was parsed: the input and the newline R adds.
	Source []byte
	// Exprs are the top-level expressions, in order.
	Exprs []Node
	// Tokens are the terminals getParseData() lists, in source order,
	// comments included.
	Tokens []Token
}

type Function struct {
	Pos    Span
	Params []Param
	Body   Node
	// Lambda is set for the backslash form; both are the same call to
	// `function` in R.
	Lambda bool
	// contains filtered or unexported fields
}

type Kind int

type LimitError struct {
	What  string // "bytes", "depth" or "nodes"
	Limit int
}

type Limits struct {
	// MaxBytes bounds the source size (default 64 MiB).
	MaxBytes int
	// MaxDepth bounds the nesting of the syntax tree (default 5000).
	MaxDepth int
	// MaxNodes bounds the number of tree nodes (default 8 million).
	MaxNodes int
}

type Names struct {
	// Assigned are the names the cell binds in the environment it runs in
	// (the top level), in order of first assignment: x <- v, x = v, v -> x,
	// "x" <- v, f(x) <- v and x$a <- v (which assign x), assign("x", v) with
	// a literal name, and the variable of a top-level for loop. Function
	// definitions are assignments of a function value like any other.
	Assigned []string
	// Read are the names the cell uses without having bound them first:
	// free variables of top-level code, and free variables of function bodies
	// that the cell does not itself assign anywhere at top level. Called
	// functions are included (f in f(x)), as are get("x") literals. Names
	// bound inside a function (its parameters and its local assignments) or
	// inside local() are not.
	Read []string
	// Dynamic is set when the set of names cannot be resolved statically: see
	// Reasons for which construct made it so.
	Dynamic bool
	// Reasons lists the constructs that set Dynamic, each once, in order of
	// appearance: "<<-", "eval", "assign with a computed name", ...
	Reasons []string
}

type Node interface {
	// Span is the source range of the node.
	Span() Span
	// contains filtered or unexported methods
}

type Options struct {
	Limits
	// Filename is the name R shows in syntax errors (default "<text>", what
	// parse(text = ) uses).
	Filename string
	// KeepSource makes lexical errors use Filename too; without it they say
	// "<input>", as parse(keep.source = FALSE) does.
	KeepSource bool
}

type Param struct {
	Name string
	// Default is nil when there is none.
	Default Node
	Pos     Span
}

type Pos struct{ Line, Col int }

type Span struct {
	Start, End         Pos
	StartByte, EndByte int
}

type Sym struct {
	Pos  Span
	Name string
}

type Token struct {
	// Kind is getParseData's token name: SYMBOL, SYMBOL_FUNCTION_CALL,
	// NUM_CONST, '+', LEFT_ASSIGN, COMMENT, ...
	Kind string
	Text string
	Span
}