ast

type AliasDecl struct {
	DeclHead
	Params []*TypeParam
	Target *TypeRef
}

type AssocTypeBind struct {
	P      Position
	N      string
	Target *TypeRef
}

type AssocTypeReq struct {
	DeclHead
	Kind *Kind
}

type ClassDecl struct {
	DeclHead
	Params   []*TypeParam
	FunDeps  []*FunDep
	Conforms []*ClassRef // superclasses
	Requires []*ClassRef
	Members  []Member
	End      Position // the body's `}`
}

type ClassRef struct {
	P         Position
	Qualifier string
	N         string
	Args      []*TypeArg
}

type Comment struct {
	P    Position
	Text string // the text after the slashes, with one leading space removed
}

type Constraint struct {
	P    Position
	N    string
	Args []*Literal
}

type Decl interface {
	Pos() Position
	Name() string
	Head() *DeclHead
}

type DeclHead struct {
	Doc []string

	// DocP is where the doc comment was written, zero without one.
	DocP Position

	P   Position
	N   string
	Dep *Deprecation
}

type Deprecation struct {
	P      Position
	Reason string // "" when written without a reason
}

type Directive struct {
	P    Position
	N    string
	Args []*Literal
}

type EnumDecl struct {
	DeclHead
	Params   []*TypeParam
	Conforms []*ClassRef
	Requires []*ClassRef
	Variants []*Variant
	End      Position // the body's `}`
}

type Field struct {
	DeclHead
	Owned       bool // composition rather than reference
	Type        *TypeRef
	Constraints []*Constraint
	Default     *Literal
	End         Position // the constraint block's `}`; zero without one
}

type File struct {
	Filename string
	Package  *PackageDecl // nil if omitted
	Imports  []*ImportDecl
	Decls    []Decl

	// Comments holds every ordinary `//` comment in source order. Doc
	// comments live in the Doc of the declaration they precede.
	Comments []*Comment

	End Position
}

type FunDep struct {
	P    Position
	From []string
	To   []string
}

type ImportDecl struct {
	Doc  []string
	DocP Position // where the doc comment was written; zero without one

	P     Position
	Path  string
	Alias string // "_" merges the imported names into the current scope
}

type Include struct {
	P    Position
	Type *ClassRef
}

type InstanceDecl struct {
	DeclHead // N is the class name
	Params   []*TypeParam
	Class    *ClassRef
	For      *TypeRef // set for `instance C for T`, nil for `instance C<T>`
	Requires []*ClassRef
	Binds    []*AssocTypeBind
	End      Position // the bind block's `}`; zero without one
}

type Kind struct {
	P     Position
	N     string // "type" or "unit"; empty when Paren is set
	Paren *Kind
	Arrow *Kind // `left -> Arrow`; nil for a bare atom
}

type Literal struct {
	P     Position
	Kind  LiteralKind
	Text  string     // decoded for LitString, pattern body for LitRegex, source text otherwise
	Items []*Literal // set for LitList
	Lo    *Literal   // set for LitRange; nil when the range is open below
	Hi    *Literal   // set for LitRange; nil when the range is open above
}

type LiteralKind int

type Member interface {
	Pos() Position
}

type NewtypeDecl struct {
	DeclHead
	Params      []*TypeParam
	Base        *TypeRef
	Requires    []*ClassRef
	Constraints []*Constraint
	End         Position // the constraint block's `}`; zero without one
}

type PackageDecl struct {
	P    Position
	Path string // dotted, e.g. "shop.orders"
}

type Position = lex.Position

type PrimitiveDecl struct {
	DeclHead
	Kind *Kind // nil when the kind is left to inference
}

type StructDecl struct {
	DeclHead
	Keyword  string // "type" or "mixin"
	Params   []*TypeParam
	Conforms []*ClassRef
	Requires []*ClassRef
	Members  []Member
	End      Position // the body's `}`
}

type TargetDecl struct {
	DeclHead
	For     string // the dotted package name the target applies to
	Entries []*TargetEntry
	End     Position // the block's `}`
}

type TargetEntry struct {
	P         Position
	Path      string         // "" for a bare directive
	Directive *Directive     // nil when Entries is set
	Entries   []*TargetEntry // nil when Directive is set
	End       Position       // the nested block's `}`; zero without one
}

type TypeArg struct {
	P    Position
	Type *TypeRef  // set unless Unit is
	Unit *UnitExpr // set only when operators made the argument unambiguous
}

type TypeParam struct {
	P    Position
	N    string
	Kind *Kind // nil when inferred from use
}

type TypeRef struct {
	P Position

	Qualifier string // "" if unqualified; set for "alias.Type"
	N         string // "" for the collection forms below
	Args      []*TypeArg

	List *TypeRef // [T]
	Set  *TypeRef // {T}

	MapKey   *TypeRef // {K -> V}
	MapValue *TypeRef

	Optional bool // trailing ?
	Nullable bool // trailing | null
}

type UnitDecl struct {
	DeclHead
	Expr *UnitExpr // nil for a base unit
}

type UnitExpr struct {
	P     Position
	Terms []*UnitTerm
}

type UnitTerm struct {
	P     Position
	Op    string    // "" for the first term, otherwise "*" or "/"
	N     string    // unit name; "" when Paren is set
	Exp   int       // exponent; 1 when written without one
	Paren *UnitExpr // set for a parenthesized sub-expression
}

type Variant struct {
	DeclHead
	Fields []*Field // nil for a variant without a payload
	End    Position // the payload's `}`; zero without one
}