semantic

type ArrayExpression struct {
	Elements []Expression `json:"elements"`
	// contains filtered or unexported fields
}

type BinaryExpression struct {
	Operator ast.OperatorKind `json:"operator"`
	Left     Expression       `json:"left"`
	Right    Expression       `json:"right"`
}

type BlockStatement struct {
	Body []Statement `json:"body"`
}

type BooleanLiteral struct {
	Value bool `json:"value"`
}

type CallExpression struct {
	Callee    Expression        `json:"callee"`
	Arguments *ObjectExpression `json:"arguments"`
}

type ConditionalExpression struct {
	Test       Expression `json:"test"`
	Alternate  Expression `json:"alternate"`
	Consequent Expression `json:"consequent"`
}

type DateTimeLiteral struct {
	Value time.Time `json:"value"`
}

type DeclarationScope map[string]VariableDeclaration

type DurationLiteral struct {
	Value time.Duration `json:"value"`
}

type Expression interface {
	Node
	Type() Type
	// contains filtered or unexported methods
}

type ExpressionStatement struct {
	Expression Expression `json:"expression"`
}

type ExternalVariableDeclaration struct {
	Identifier *Identifier `json:"identifier"`
	Type       Type        `json:"type"`
}

type FloatLiteral struct {
	Value float64 `json:"value"`
}

type FunctionExpression struct {
	Params []*FunctionParam `json:"params"`
	Body   Node             `json:"body"`
	// contains filtered or unexported fields
}

type FunctionParam struct {
	Key     *Identifier `json:"key"`
	Default Expression  `json:"default"`
	Piped   bool        `json:"piped,omitempty"`
	// contains filtered or unexported fields
}

type FunctionSignature struct {
	Params       map[string]Type
	ReturnType   Type
	PipeArgument string
}

type Identifier struct {
	Name string `json:"name"`
}

type IdentifierExpression struct {
	Name string `json:"name"`
	// contains filtered or unexported fields
}

type IntegerLiteral struct {
	Value int64 `json:"value"`
}

type Kind int

type Literal interface {
	Expression
	// contains filtered or unexported methods
}

type LogicalExpression struct {
	Operator ast.LogicalOperatorKind `json:"operator"`
	Left     Expression              `json:"left"`
	Right    Expression              `json:"right"`
}

type MemberExpression struct {
	Object   Expression `json:"object"`
	Property string     `json:"property"`
}

type NativeVariableDeclaration struct {
	Identifier *Identifier `json:"identifier"`
	Init       Expression  `json:"init"`
}

type Node interface {
	NodeType() string
	Copy() Node

	json.Marshaler
	// contains filtered or unexported methods
}

type ObjectExpression struct {
	Properties []*Property `json:"properties"`
	// contains filtered or unexported fields
}

type Program struct {
	Body []Statement `json:"body"`
}

type Property struct {
	Key   *Identifier `json:"key"`
	Value Expression  `json:"value"`
}

type RegexpLiteral struct {
	Value *regexp.Regexp `json:"value"`
}

type ReturnStatement struct {
	Argument Expression `json:"argument"`
}

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

type StringLiteral struct {
	Value string `json:"value"`
}

type Type interface {
	// Kind returns the specific kind of this type.
	Kind() Kind

	// PropertyType returns the type of a given property.
	// It panics if the type's Kind is not Object
	PropertyType(name string) Type

	// Properties returns a map of all property types.
	// It panics if the type's Kind is not Object
	Properties() map[string]Type

	// ElementType return the type of elements in the array.
	// It panics if the type's Kind is not Array.
	ElementType() Type

	// PipeArgument reports the name of the argument that can be pipe into.
	// It panics if the type's Kind is not Function.
	PipeArgument() string

	// ReturnType reports the return type of the function
	// It panics if the type's Kind is not Function.
	ReturnType() Type
	// contains filtered or unexported methods
}

type UnaryExpression struct {
	Operator ast.OperatorKind `json:"operator"`
	Argument Expression       `json:"argument"`
}

type UnsignedIntegerLiteral struct {
	Value uint64 `json:"value"`
}

type VariableDeclaration interface {
	Node
	ID() *Identifier
	InitType() Type
}

type Visitor interface {
	Visit(node Node) Visitor
	Done()
}